F-Strings von Python 3: Eine verbesserte Syntax zur Formatierung von Strings (Handbuch)

F-Strings von Python 3: Eine verbesserte Syntax zur Formatierung von Strings (Handbuch)

Ab Python 3.6 sind F-Strings eine großartige neue Möglichkeit, Strings zu formatieren. Sie sind nicht nur lesbarer, prägnanter und weniger fehleranfällig als andere Formatierungsmethoden, sondern auch schneller!

Am Ende dieses Artikels erfahren Sie, wie und warum Sie heute mit der Verwendung von F-Strings beginnen.

Aber zuerst ist hier, wie das Leben vor den F-Saiten war, als man im Schnee bergauf in beide Richtungen zur Schule laufen musste.

*Kostenloser PDF-Download:* https://realpython.com/bonus/python-cheat-sheet-short/[Python 3 Cheat Sheet]

String-Formatierung der alten Schule in Python

Vor Python 3.6 hatten Sie zwei Möglichkeiten, Python-Ausdrücke zur Formatierung in Zeichenfolgenliterale einzubetten:% -Formatierung und + str.format () +. Sie werden gleich sehen, wie Sie sie verwenden und welche Einschränkungen sie haben.

Option 1:% -Formatierung

Dies ist das OG der Python-Formatierung und wurde von Anfang an in der Sprache verwendet. Weitere Informationen finden Sie in den Python docs. Beachten Sie, dass die% -Formatierung in den Dokumenten, die den folgenden Hinweis enthalten, nicht empfohlen wird:

_ _ „Die hier beschriebenen Formatierungsvorgänge weisen eine Vielzahl von Macken auf, die zu einer Reihe häufiger Fehler führen (z. B. wenn Tupel und Wörterbücher nicht korrekt angezeigt werden).

Die Verwendung der neueren formatierten Zeichenfolgenliterale oder der Schnittstelle + str.format () + hilft, diese Fehler zu vermeiden. Diese Alternativen bieten auch leistungsfähigere, flexiblere und erweiterbarere Ansätze zum Formatieren von Text. “ (Source) _ _

Verwendung der% -Formatierung

String-Objekte verfügen über eine integrierte Operation mit dem Operator "+% +", mit dem Sie Strings formatieren können. So sieht das in der Praxis aus:

>>>

>>> name = "Eric"
>>> "Hello, %s." % name
'Hello, Eric.'

Um mehr als eine Variable einzufügen, müssen Sie ein Tupel dieser Variablen verwenden. So würden Sie das machen:

>>>

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % (name, age)
'Hello Eric. You are 74.'
Warum% -Formatierung nicht großartig ist

Die Codebeispiele, die Sie oben gesehen haben, sind ausreichend lesbar. Sobald Sie jedoch mehrere Parameter und längere Zeichenfolgen verwenden, wird Ihr Code schnell weniger lesbar. Die Dinge sehen schon etwas chaotisch aus:

>>>

>>> first_name = "Eric"
>>> last_name = "Idle"
>>> age = 74
>>> profession = "comedian"
>>> affiliation = "Monty Python"
>>> "Hello, %s %s. You are %s. You are a %s. You were a member of %s." % (first_name, last_name, age, profession, affiliation)
'Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.'

Leider ist diese Art der Formatierung nicht besonders gut, da sie ausführlich ist und zu Fehlern führt, z. B. wenn Tupel oder Wörterbücher nicht korrekt angezeigt werden. Zum Glück stehen noch hellere Tage bevor.

Option 2: str.format ()

Diese neuere Methode zur Erledigung der Aufgabe wurde in Python 2.6 eingeführt. Weitere Informationen finden Sie unter Python docs.

Verwendung von str.format ()

+ str.format () + ist eine Verbesserung der% -Formatierung. Es verwendet die normale Funktionsaufrufsyntax und ist extensible durch das `+ Format () + `method für das Objekt, das in eine Zeichenfolge konvertiert wird.

Mit + str.format () + werden die Ersatzfelder durch geschweifte Klammern markiert:

>>>

>>> "Hello, {}. You are {}.".format(name, age)
'Hello, Eric. You are 74.'

Sie können Variablen in beliebiger Reihenfolge referenzieren, indem Sie auf ihren Index verweisen:

>>>

>>> "Hello, {1}. You are {0}.".format(age, name)
'Hello, Eric. You are 74.'

Wenn Sie jedoch die Variablennamen einfügen, erhalten Sie den zusätzlichen Vorteil, dass Sie Objekte übergeben und dann Parameter und Methoden zwischen den geschweiften Klammern referenzieren können:

>>>

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(name=person['name'], age=person['age'])
'Hello, Eric. You are 74.'

Sie können auch + ** + verwenden, um diesen netten Trick mit Wörterbüchern auszuführen:

>>>

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(**person)
'Hello, Eric. You are 74.'

+ str.format () + ist definitiv ein Upgrade im Vergleich zur% -Formatierung, aber es sind nicht nur Rosen und Sonnenschein.

Warum str.format () nicht großartig ist

Code mit + str.format () + ist viel leichter lesbar als Code mit% -Formatierung, aber + str.format () + kann immer noch sehr ausführlich sein, wenn Sie mit mehreren Parametern und längeren Zeichenfolgen arbeiten. Schau dir das an:

>>>

>>> first_name = "Eric"
>>> last_name = "Idle"
>>> age = 74
>>> profession = "comedian"
>>> affiliation = "Monty Python"
>>> print(("Hello, {first_name} {last_name}. You are {age}. " +
>>>        "You are a {profession}. You were a member of {affiliation}.") \
>>>        .format(first_name=first_name, last_name=last_name, age=age, \
>>>                profession=profession, affiliation=affiliation))
'Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.'

Wenn Sie die Variablen hatten, die Sie in einem Wörterbuch an "+ .format () " übergeben wollten, können Sie sie einfach mit " .format (* *some_dict) +" entpacken und die Werte per Schlüssel in der Zeichenfolge referenzieren. Aber es muss einen besseren Weg geben, dies zu tun.

f-Strings: Eine neue und verbesserte Methode zum Formatieren von Strings in Python

Die gute Nachricht ist, dass F-Strings hier sind, um den Tag zu retten. Sie schneiden! Sie würfeln! Sie machen Julienne Pommes! Okay, sie machen keines dieser Dinge, aber sie erleichtern die Formatierung. Sie haben sich der Party in Python 3.6 angeschlossen. Sie können alles darüber in PEP 498 lesen, das von Eric V. geschrieben wurde. Smith im August 2015.

F-Strings werden auch als "formatierte String-Literale" bezeichnet. Sie sind String-Literale mit einem "+ f " am Anfang und geschweiften Klammern mit Ausdrücken, die durch ihre Werte ersetzt werden. Die Ausdrücke werden zur Laufzeit ausgewertet und dann mit dem Protokoll ` format +` formatiert. Wie immer sind die Python docs Ihr Freund, wenn Sie mehr erfahren möchten.

Hier sind einige Möglichkeiten, wie F-Strings Ihnen das Leben erleichtern können.

Einfache Syntax

Die Syntax ähnelt der, die Sie mit + str.format () + verwendet haben, ist jedoch weniger ausführlich. Schauen Sie sich an, wie leicht dies lesbar ist:

>>>

>>> name = "Eric"
>>> age = 74
>>> f"Hello, {name}. You are {age}."
'Hello, Eric. You are 74.'

Es wäre auch gültig, einen Großbuchstaben "+ F +" zu verwenden:

>>>

>>> F"Hello, {name}. You are {age}."
'Hello, Eric. You are 74.'

Liebst du schon F-Strings? Ich hoffe, dass Sie am Ende dieses Artikels https://twitter.com/dbader_org/status/992847368440561664 [+ >>> F" Ja! "+] Antworten.

Beliebige Ausdrücke

Da F-Strings zur Laufzeit ausgewertet werden, können Sie alle gültigen Python-Ausdrücke in sie einfügen. Dies ermöglicht es Ihnen, einige raffinierte Dinge zu tun.

Sie könnten etwas ziemlich Unkompliziertes tun, wie folgt:

>>>

>>> f"{2* 37}"
'74'

Sie können aber auch Funktionen aufrufen. Hier ist ein Beispiel:

>>>

>>> def to_lowercase(input):
...     return input.lower()

>>> name = "Eric Idle"
>>> f"{to_lowercase(name)} is funny."
'eric idle is funny.'

Sie haben auch die Möglichkeit, eine Methode direkt aufzurufen:

>>>

>>> f"{name.lower()} is funny."
'eric idle is funny.'

Sie können sogar Objekte verwenden, die aus Klassen mit F-Strings erstellt wurden. Stellen Sie sich vor, Sie hätten die folgende Klasse:

class Comedian:
    def __init__(self, first_name, last_name, age):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age

    def __str__(self):
        return f"{self.first_name} {self.last_name} is {self.age}."

    def __repr__(self):
        return f"{self.first_name} {self.last_name} is {self.age}. Surprise!"

Sie können dies tun:

>>>

>>> new_comedian = Comedian("Eric", "Idle", "74")
>>> f"{new_comedian}"
'Eric Idle is 74.'

https://realpython.com/operator-function-overloading/[Die Methoden + str () + und + repr () + behandeln, wie Objekte als Zeichenfolgen dargestellt werden. Sie müssen also sicherstellen, dass Sie nehmen mindestens eine dieser Methoden in Ihre Klassendefinition auf. Wenn Sie eine auswählen müssen, wählen Sie "+ repr () ", da diese anstelle von " str () +" verwendet werden kann.

Die von + str () + zurückgegebene Zeichenfolge ist die informelle Zeichenfolgendarstellung eines Objekts und sollte lesbar sein. Die von + repr () + zurückgegebene Zeichenfolge ist die offizielle Darstellung und sollte eindeutig sein. Das Aufrufen von "+ str () " und " repr () " ist der direkten Verwendung von " str () " und " repr () +" vorzuziehen.

Standardmäßig verwenden f-Strings "+ str () ", aber Sie können sicherstellen, dass sie " repr () " verwenden, wenn Sie das Konvertierungsflag "! R +" einschließen:

>>>

>>> f"{new_comedian}"
'Eric Idle is 74.'
>>> f"{new_comedian!r}"
'Eric Idle is 74. Surprise!'

Wenn Sie einen Teil der Konversation lesen möchten, die dazu führte, dass F-Strings vollständige Python-Ausdrücke unterstützen, können Sie dies tun: https://mail.python.org/pipermail/python-ideas/2015-July/034726.html [ Hier].

Mehrzeilige f-Saiten

Sie können mehrzeilige Zeichenfolgen haben:

>>>

>>> name = "Eric"
>>> profession = "comedian"
>>> affiliation = "Monty Python"
>>> message = (
...     f"Hi {name}. "
...     f"You are a {profession}. "
...     f"You were in {affiliation}."
... )
>>> message
'Hi Eric. You are a comedian. You were in Monty Python.'

Denken Sie jedoch daran, dass Sie vor jeder Zeile einer mehrzeiligen Zeichenfolge ein "+ f +" einfügen müssen. Der folgende Code funktioniert nicht:

>>>

>>> message = (
...     f"Hi {name}. "
...     "You are a {profession}. "
...     "You were in {affiliation}."
... )
>>> message
'Hi Eric. You are a {profession}. You were in {affiliation}.'

Wenn Sie nicht vor jeder einzelnen Zeile ein "+ f +" einfügen, haben Sie nur normale, alte Saiten mit Gartenvielfalt und keine glänzenden, neuen, ausgefallenen F-Saiten.

Wenn Sie Zeichenfolgen über mehrere Zeilen verteilen möchten, haben Sie auch die Möglichkeit, eine Rückgabe mit einem + \ + zu umgehen:

>>>

>>> message = f"Hi {name}. " \
...           f"You are a {profession}. " \
...           f"You were in {affiliation}."
...
>>> message
'Hi Eric. You are a comedian. You were in Monty Python.'

Dies ist jedoch der Fall, wenn Sie "+" "" + "verwenden:

>>>

>>> message = f"""
...     Hi {name}.
...     You are a {profession}.
...     You were in {affiliation}.
... """
...
>>> message
'\n    Hi Eric.\n    You are a comedian.\n    You were in Monty Python.\n'

Informationen zu Einrückungsrichtlinien finden Sie unter PEP 8.

Geschwindigkeit

Das + f + in f-Strings kann genauso gut für "schnell" stehen.

f-Strings sind schneller als% -Formatierung und + str.format () +. Wie Sie bereits gesehen haben, sind f-Strings Ausdrücke, die zur Laufzeit ausgewertet werden, und keine konstanten Werte. Hier ist ein Auszug aus den Dokumenten:

_ „F-Strings bieten eine Möglichkeit, Ausdrücke mit einer minimalen Syntax in String-Literale einzubetten. Es sollte beachtet werden, dass ein f-String wirklich ein zur Laufzeit ausgewerteter Ausdruck ist, kein konstanter Wert. Im Python-Quellcode ist eine f-Zeichenfolge eine Literalzeichenfolge mit dem Präfix "+ f +", die Ausdrücke in geschweiften Klammern enthält. Die Ausdrücke werden durch ihre Werte ersetzt. “ (Source) _

Zur Laufzeit wird der Ausdruck in den geschweiften Klammern in einem eigenen Bereich ausgewertet und dann mit dem String-Literal-Teil des F-Strings zusammengesetzt. Die resultierende Zeichenfolge wird dann zurückgegeben. Das ist alles was es braucht.

Hier ist ein Geschwindigkeitsvergleich:

>>>

>>> import timeit
>>> timeit.timeit("""name = "Eric"
... age = 74
... '%s is %s.' % (name, age)""", number = 10000)
0.003324444866599663

>>>

>>> timeit.timeit("""name = "Eric"
... age = 74
... '{} is {}.'.format(name, age)""", number = 10000)
0.004242089427570761

>>>

>>> timeit.timeit("""name = "Eric"
... age = 74
... f'{name} is {age}.'""", number = 10000)
0.0024820892040722242

Wie Sie sehen können, haben F-Strings die Nase vorn.

Dies war jedoch nicht immer der Fall. Als sie zum ersten Mal implementiert wurden, hatten sie einige https://stackoverflow.com/questions/37365311/why-are-literal-formatted-strings-so-slow-in-python-3-6-alpha-now-fixed-in -3-6 [Geschwindigkeitsprobleme] und musste schneller als + str.format () + gemacht werden. Ein spezieller https://bugs.python.org/issue27078 [+ BUILD_STRING + opcode] wurde eingeführt.

Python f-Strings: Die lästigen Details

Nachdem Sie nun alles darüber erfahren haben, warum F-Strings großartig sind, möchten Sie sicher raus und sie verwenden. Hier sind einige Details, die Sie beachten sollten, wenn Sie sich in diese schöne neue Welt wagen.

Anführungszeichen

Sie können verschiedene Arten von Anführungszeichen in den Ausdrücken verwenden. Stellen Sie einfach sicher, dass Sie nicht die gleiche Art von Anführungszeichen an der Außenseite der F-Zeichenfolge verwenden, die Sie im Ausdruck verwenden.

Dieser Code funktioniert:

>>>

>>> f"{'Eric Idle'}"
'Eric Idle'

Dieser Code funktioniert auch:

>>>

>>> f'{"Eric Idle"}'
'Eric Idle'

Sie können auch dreifache Anführungszeichen verwenden:

>>>

>>> f"""Eric Idle"""
'Eric Idle'

>>>

>>> f'''Eric Idle'''
'Eric Idle'

Wenn Sie feststellen, dass Sie sowohl an der Innen- als auch an der Außenseite der Zeichenfolge dieselbe Art von Anführungszeichen verwenden müssen, können Sie mit + \ + maskieren:

>>>

>>> f"The \"comedian\" is {name}, aged {age}."
'The "comedian" is Eric Idle, aged 74.'

Wörterbücher

Wenn Sie von Anführungszeichen sprechen, achten Sie darauf, wenn Sie mit Wörterbüchern arbeiten. Wenn Sie einfache Anführungszeichen für die Schlüssel des Wörterbuchs verwenden möchten, denken Sie daran, dass Sie doppelte Anführungszeichen für die F-Zeichenfolgen verwenden, die die Schlüssel enthalten.

Das wird funktionieren:

>>>

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f"The comedian is {comedian['name']}, aged {comedian['age']}."
The comedian is Eric Idle, aged 74.

Dies ist jedoch ein heißes Durcheinander mit einem Syntaxfehler:

>>>

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f'The comedian is {comedian['name']}, aged {comedian['age']}.'
  File "<stdin>", line 1
    f'The comedian is {comedian['name']}, aged {comedian['age']}.'
                                    ^
SyntaxError: invalid syntax

Wenn Sie um die Wörterbuchschlüssel dieselbe Art von Anführungszeichen verwenden wie außerhalb der F-Zeichenfolge, wird das Anführungszeichen am Anfang des ersten Wörterbuchschlüssels als Ende der Zeichenfolge interpretiert.

Hosenträger

Um eine Klammer in Ihrer Zeichenfolge erscheinen zu lassen, müssen Sie doppelte Klammern verwenden:

>>>

>>> f"{{74}}"
'{74}'

Beachten Sie, dass die Verwendung dreifacher Klammern dazu führt, dass Ihre Zeichenfolge nur einzelne Klammern enthält:

>>>

>>> f"{{{74}}}"
'{74}'

Sie können jedoch mehr Zahnspangen anzeigen, wenn Sie mehr als dreifache Zahnspangen verwenden:

>>>

>>> f"{{{{74}}}}"
'{{74}}'

Backslashes

Wie Sie bereits gesehen haben, können Sie Backslash-Escapezeichen im String-Teil eines F-Strings verwenden. Sie können jedoch keine Backslashes verwenden, um im Ausdrucksteil einer F-Zeichenfolge zu maskieren:

>>>

>>> f"{\"Eric Idle\"}"
  File "<stdin>", line 1
    f"{\"Eric Idle\"}"
                      ^
SyntaxError: f-string expression part cannot include a backslash

Sie können dies umgehen, indem Sie den Ausdruck vorher auswerten und das Ergebnis in der f-Zeichenfolge verwenden:

>>>

>>> name = "Eric Idle"
>>> f"{name}"
'Eric Idle'

Ausdrücke sollten keine Kommentare enthalten, die das Symbol "+ # +" verwenden. Sie erhalten einen Syntaxfehler:

>>>

>>> f"Eric is {2 *37 #Oh my!}."
  File "<stdin>", line 1
    f"Eric is {2* 37 #Oh my!}."
                                ^
SyntaxError: f-string expression part cannot include '#'

Gehen Sie weiter und formatieren Sie!

Sie können weiterhin die älteren Methoden zum Formatieren von Zeichenfolgen verwenden. Mit F-Zeichenfolgen haben Sie jetzt eine präzisere, lesbarere und bequemere Methode, die sowohl schneller als auch weniger fehleranfällig ist. Die Vereinfachung Ihres Lebens mithilfe von F-Strings ist ein guter Grund, Python 3.6 zu verwenden, wenn Sie den Wechsel noch nicht vorgenommen haben. (Wenn Sie noch Python 2 verwenden, vergessen Sie nicht, dass 2020 bald hier sein wird!)

Laut Zen of Python sollte „[t] hier eins sein - und vorzugsweise nur Ein offensichtlicher Weg, dies zu tun. “ Obwohl F-Strings nicht die einzige Möglichkeit für Sie sind, Strings zu formatieren, sind sie in einer hervorragenden Position, um diese eine offensichtliche Möglichkeit zu werden, die Arbeit zu erledigen.

Weitere Lektüre

Wenn Sie eine ausführliche Diskussion über die Interpolation von Zeichenfolgen lesen möchten, besuchen Sie PEP 502. Der Entwurf von PEP 536 enthält weitere Gedanken zur Zukunft der F-Strings.

*Kostenloser PDF-Download:* https://realpython.com/bonus/python-cheat-sheet-short/[Python 3 Cheat Sheet]

Weitere Informationen zu Strings finden Sie in den folgenden Artikeln:

Viel Spaß beim Pythoning!