Sprintf-ähnliche Funktionalität in Python

Ich möchte einen Zeichenfolgenpuffer erstellen, um viel zu verarbeiten, zu formatieren und schließlich den Puffer in eine Textdatei zu schreiben, wobei eine C-ähnliche sprintfFunktionalität in Python verwendet wird. Aufgrund von bedingten Anweisungen kann ich sie nicht direkt in die Datei schreiben.

zB Pseudocode:

sprintf(buf,"A = %d\n , B= %s\n",A,B)
/* some processing */
sprint(buf,"C=%d\n",c)
....
...
fprintf(file,buf)

In der Ausgabedatei haben wir also diese Art von O / P:

A= foo B= bar
C= ded
etc...

Bearbeiten, um meine Frage zu klären:
buf Ist ein großer Puffer enthält alle diese Zeichenfolgen, die mit sprintf formatiert wurden. Wenn Sie sich Ihre Beispiele ansehen, bufwerden nur aktuelle Werte enthalten, keine älteren. zB wurde zuerst in, das bufich A= something ,B= somethingspäter schrieb, C= somethingdasselbe angehängt buf, aber in Ihren Python-Antworten bufist nur der letzte Wert enthalten, den ich nicht möchte - ich möchte bufalle printfs haben, die ich von Anfang an getan habe, wie in C.

Python hat dafür einen %Operator.

>>> a = 5
>>> b = "hello"
>>> buf = "A = %d\n , B = %s\n" % (a, b)
>>> print buf
A = 5
 , B = hello

>>> c = 10
>>> buf = "C = %d\n" % c
>>> print buf
C = 10

In dieser Referenz finden Sie alle unterstützten Formatspezifizierer.

Sie könnten auch verwenden format:

>>> print "This is the {}th tome of {}".format(5, "knowledge")
This is the 5th tome of knowledge

Wenn ich Ihre Frage richtig verstehe, ist format () genau das, wonach Sie suchen, zusammen mit seiner Minisprache .

Dummes Beispiel für Python 2.7 und höher:

>>> print "{} ...\r\n {}!".format("Hello", "world")
Hello ...
 world!

Für frühere Python-Versionen: (getestet mit 2.6.2)

>>> print "{0} ...\r\n {1}!".format("Hello", "world")
Hello ...
 world!

Ich bin nicht ganz sicher, ob ich Ihr Ziel verstehe, aber Sie können eine StringIOInstanz als Puffer verwenden:

>>> import StringIO 
>>> buf = StringIO.StringIO()
>>> buf.write("A = %d, B = %s\n" % (3, "bar"))
>>> buf.write("C=%d\n" % 5)
>>> print(buf.getvalue())
A = 3, B = bar
C=5

Im Gegensatz dazu übergeben sprintfSie einfach eine Zeichenfolge an buf.writeund formatieren sie mit dem %Operator oder der formatMethode der Zeichenfolgen.

Sie können natürlich eine Funktion definieren, um die sprintfgewünschte Schnittstelle zu erhalten :

def sprintf(buf, fmt, *args):
    buf.write(fmt % args)

welches so verwendet werden würde:

>>> buf = StringIO.StringIO()
>>> sprintf(buf, "A = %d, B = %s\n", 3, "foo")
>>> sprintf(buf, "C = %d\n", 5)
>>> print(buf.getvalue())
A = 3, B = foo
C = 5

Verwenden Sie den Formatierungsoperator% :

buf = "A = %d\n , B= %s\n" % (a, b)
print >>f, buf

Sie können die Zeichenfolgenformatierung verwenden:

>>> a=42
>>> b="bar"
>>> "The number is %d and the word is %s" % (a,b)
'The number is 42 and the word is bar'

Dies wird jedoch in Python 3 entfernt. Sie sollten "str.format ()" verwenden:

>>> a=42
>>> b="bar"
>>> "The number is {0} and the word is {1}".format(a,b)
'The number is 42 and the word is bar'

Zum Einfügen in eine sehr lange Zeichenfolge ist es hilfreich, Namen für die verschiedenen Argumente zu verwenden, anstatt zu hoffen, dass sie sich an den richtigen Positionen befinden. Dies erleichtert auch das Ersetzen mehrerer Wiederholungen.

>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'

Entnommen aus Formatbeispielen , in denen auch alle anderen FormatAntworten angezeigt werden.

Dies ist wahrscheinlich die nächste Übersetzung von Ihrem C-Code in Python-Code.

A = 1
B = "hello"
buf = "A = %d\n , B= %s\n" % (A, B)

c = 2
buf += "C=%d\n" % c

f = open('output.txt', 'w')
print >> f, c
f.close()

Der %Operator in Python macht fast genau das Gleiche wie Cs sprintf. Sie können die Zeichenfolge auch direkt in eine Datei drucken. Wenn viele dieser String-formatierten Stringlets beteiligt sind, ist es möglicherweise ratsam, a zu verwendenStringIO Objekt zu verwenden, um die Verarbeitungszeit zu verkürzen.

Anstatt dies zu tun +=, tun Sie Folgendes:

import cStringIO
buf = cStringIO.StringIO()

...

print >> buf, "A = %d\n , B= %s\n" % (A, B)

...

print >> buf, "C=%d\n" % c

...

print >> f, buf.getvalue()

Wenn Sie etwas wie die Python3-Druckfunktion wollen, aber eine Zeichenfolge:

def sprint(*args, **kwargs):
    sio = io.StringIO()
    print(*args, **kwargs, file=sio)
    return sio.getvalue()

>>> x = sprint('abc', 10, ['one', 'two'], {'a': 1, 'b': 2}, {1, 2, 3})
>>> x
"abc 10 ['one', 'two'] {'a': 1, 'b': 2} {1, 2, 3}\n"

oder ohne das '\n'am Ende:

def sprint(*args, end='', **kwargs):
    sio = io.StringIO()
    print(*args, **kwargs, end=end, file=sio)
    return sio.getvalue()

>>> x = sprint('abc', 10, ['one', 'two'], {'a': 1, 'b': 2}, {1, 2, 3})
>>> x
"abc 10 ['one', 'two'] {'a': 1, 'b': 2} {1, 2, 3}"

Etwas wie...

greetings = 'Hello {name}'.format(name = 'John')

Hello John

Schauen Sie sich "Literal String Interpolation" an https://www.python.org/dev/peps/pep-0498/

Ich fand es über die http://www.malemburg.com/

Zwei Ansätze bestehen darin, in einen Zeichenfolgenpuffer zu schreiben oder Zeilen in eine Liste zu schreiben und sie später zu verbinden. Ich denke, der StringIOAnsatz ist eher pythonisch, hat aber vor Python 2.6 nicht funktioniert.

from io import StringIO

with StringIO() as s:
   print("Hello", file=s)
   print("Goodbye", file=s)
   # And later...
   with open('myfile', 'w') as f:
       f.write(s.getvalue())

Sie können diese auch ohne ContextMananger( s = StringIO()) verwenden. Derzeit verwende ich eine Kontextmanagerklasse mit einer printFunktion. Dieses Fragment kann nützlich sein, um Debugging- oder ungerade Paging-Anforderungen einfügen zu können:

class Report:
    ... usual init/enter/exit
    def print(self, *args, **kwargs):
        with StringIO() as s:
            print(*args, **kwargs, file=s)
            out = s.getvalue()
        ... stuff with out

with Report() as r:
   r.print(f"This is {datetime.date.today()}!", 'Yikes!', end=':')