Keine Verwendung von globals() oder locals()

In den Diskussionen auf python-dev [4] wurden eine Reihe von Lösungen präsentiert, die locals() und globals() oder deren Äquivalente verwendeten. All diese haben verschiedene Probleme. Zu diesen gehören das Referenzieren von Variablen, die ansonsten nicht in einem Closure verwendet werden. Betrachten Sie

>>> def outer(x):
...     def inner():
...         return 'x={x}'.format_map(locals())
...     return inner
...
>>> outer(42)()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in inner
KeyError: 'x'

Dies gibt einen Fehler zurück, da der Compiler keine Referenz auf x innerhalb des Closures hinzugefügt hat. Sie müssen manuell eine Referenz auf x hinzufügen, damit dies funktioniert

>>> def outer(x):
...     def inner():
...         x
...         return 'x={x}'.format_map(locals())
...     return inner
...
>>> outer(42)()
'x=42'

Darüber hinaus führt die Verwendung von locals() oder globals() zu einem Informationsleck. Eine aufgerufene Routine, die Zugriff auf die locals() oder globals() des Aufrufers hat, hat Zugriff auf weitaus mehr Informationen als zur String-Interpolation benötigt werden.

Guido erklärte [5], dass jede Lösung für eine bessere String-Interpolation locals() oder globals() nicht in ihrer Implementierung verwenden würde. (Dies verbietet Benutzern nicht, locals() oder globals() zu übergeben, es erfordert es nur nicht und erlaubt auch nicht die Verwendung dieser Funktionen im Hintergrund.)

Escape-Sequenzen

Backslashes dürfen nicht innerhalb der Ausdrucksteile von f-Strings vorkommen, sodass Sie sie beispielsweise nicht verwenden können, um Anführungszeichen innerhalb von f-Strings zu maskieren

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

Sie können eine andere Art von Anführungszeichen innerhalb des Ausdrucks verwenden

>>> f'{"quoted string"}'
'quoted string'

Backslash-Escapes dürfen innerhalb der Zeichenkettenanteile eines f-Strings vorkommen.

Beachten Sie, dass der richtige Weg, um eine literale geschweifte Klammer im resultierenden Zeichenkettenwert zu erhalten, die Verdoppelung der Klammer ist

>>> f'{{ {4*10} }}'
'{ 40 }'
>>> f'{{{4*10}}}'
'{40}'

Wie bei allen Raw-Strings in Python wird bei Raw-f-Strings keine Escape-Verarbeitung durchgeführt

>>> fr'x={4*10}\n'
'x=40\\n'

Aufgrund der String-Tokenisierungsregeln von Python ist der f-String f'abc {a['x']} def' ungültig. Der Tokenizer zerlegt dies in 3 Token: f'abc {a[', x und ']} def'. Genau wie bei normalen Zeichenketten kann dies nicht durch die Verwendung von Raw-Strings behoben werden. Es gibt eine Reihe von korrekten Möglichkeiten, diesen f-String zu schreiben: mit einem anderen Anführungszeichen

f"abc {a['x']} def"

Oder mit dreifachen Anführungszeichen

f'''abc {a['x']} def'''

Code-Äquivalenz

Der genaue Code zur Implementierung von f-Strings ist nicht spezifiziert. Es wird jedoch garantiert, dass jeder eingebettete Wert, der in eine Zeichenkette konvertiert wird, die __format__-Methode dieses Wertes verwendet. Dies ist derselbe Mechanismus, den str.format() zur Konvertierung von Werten in Zeichenketten verwendet.

Zum Beispiel dieser Code

f'abc{expr1:spec1}{expr2!r:spec2}def{expr3}ghi'

Könnte ausgewertet werden als

'abc' + format(expr1, spec1) + format(repr(expr2), spec2) + 'def' + format(expr3) + 'ghi'

Auswertung von Ausdrücken

Die Ausdrücke, die aus der Zeichenkette extrahiert werden, werden im Kontext ausgewertet, in dem der f-String aufgetreten ist. Das bedeutet, dass der Ausdruck vollen Zugriff auf lokale und globale Variablen hat. Jeder gültige Python-Ausdruck kann verwendet werden, einschließlich Funktions- und Methodenaufrufen.

Da die f-Strings dort ausgewertet werden, wo die Zeichenkette im Quellcode erscheint, gibt es mit f-Strings keine zusätzliche Ausdrucksmöglichkeit. Es gibt auch keine zusätzlichen Sicherheitsbedenken: Sie hätten denselben Ausdruck auch außerhalb eines f-Strings schreiben können.

>>> def foo():
...   return 20
...
>>> f'result={foo()}'
'result=20'

Entspricht

>>> 'result=' + str(foo())
'result=20'

Ausdrücke werden mit dem Äquivalent von ast.parse('(' + expression + ')', '<fstring>', 'eval') geparast [7].

Beachten Sie, dass Ausdrücke Zeilenumbrüche enthalten können, da der Ausdruck vor der Auswertung in implizite Klammern eingeschlossen wird. Zum Beispiel

>>> x = 0
>>> f'''{x
... +1}'''
'1'

>>> d = {0: 'zero'}
>>> f'''{d[0
... ]}'''
'zero'

Format-Spezifizierer

Format-Spezifizierer können ebenfalls ausgewertete Ausdrücke enthalten. Dies ermöglicht Code wie

>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal('12.34567')
>>> f'result: {value:{width}.{precision}}'
'result:      12.35'

Sobald Ausdrücke in einem Format-Spezifizierer ausgewertet wurden (falls erforderlich), werden Format-Spezifizierer nicht vom f-String-Evaluator interpretiert. Genau wie in str.format() werden sie lediglich an die __format__()-Methode des zu formatierenden Objekts übergeben.

Verketten von Zeichenketten

Nebeneinander liegende f-Strings und reguläre Zeichenketten werden verkettet. Reguläre Zeichenketten werden zur Kompilierzeit verkettet und f-Strings zur Laufzeit. Zum Beispiel der Ausdruck

>>> x = 10
>>> y = 'hi'
>>> 'a' 'b' f'{x}' '{c}' f'str<{y:^4}>' 'd' 'e'

ergibt den Wert

'ab10{c}str< hi >de'

Während die genaue Methode dieser Laufzeitverkettung nicht spezifiziert ist, könnte der obige Code ausgewertet werden zu

'ab' + format(x) + '{c}' + 'str<' + format(y, '^4') + '>de'

Jeder f-String wird vollständig ausgewertet, bevor er an benachbarte f-Strings angehängt wird. Das bedeutet, dass dies

>>> f'{x' f'}'

Ein Syntaxfehler ist, da der erste f-String keine schließende Klammer enthält.

Fehlerbehandlung

Beim Verarbeiten von f-Strings können Fehler zur Kompilierzeit oder zur Laufzeit auftreten. Kompilierzeitfehler beschränken sich auf Fehler, die beim Scannen eines f-Strings erkannt werden können. Diese Fehler lösen alle SyntaxError aus.

Nicht übereinstimmende Klammern

>>> f'x={x'
  File "<stdin>", line 1
SyntaxError: f-string: expecting '}'

Ungültige Ausdrücke

>>> f'x={!x}'
  File "<stdin>", line 1
SyntaxError: f-string: empty expression not allowed

Laufzeitfehler treten bei der Auswertung der Ausdrücke innerhalb eines f-Strings auf. Beachten Sie, dass ein f-String mehrmals ausgewertet werden kann und manchmal funktioniert und ein anderes Mal einen Fehler auslöst

>>> d = {0:10, 1:20}
>>> for i in range(3):
...     print(f'{i}:{d[i]}')
...
0:10
1:20
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyError: 2

oder

>>> for x in (32, 100, 'fifty'):
...   print(f'x = {x:+3}')
...
'x = +32'
'x = +100'
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ValueError: Sign not allowed in string format specifier

Führende und abschließende Leerzeichen in Ausdrücken werden ignoriert

Zur besseren Lesbarkeit werden führende und abschließende Leerzeichen in Ausdrücken ignoriert. Dies ist ein Nebeneffekt des Einschließens des Ausdrucks in Klammern vor der Auswertung.

Auswertungsreihenfolge von Ausdrücken

Die Ausdrücke in einem f-String werden von links nach rechts ausgewertet. Dies ist nur erkennbar, wenn die Ausdrücke Seiteneffekte haben

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

Diskussion zu python-ideas

Die meisten Diskussionen auf python-ideas [8] konzentrierten sich auf drei Punkte

• Wie f-Strings gekennzeichnet werden,
• Wie die Position von Ausdrücken in f-Strings spezifiziert wird und
• Ob volle Python-Ausdrücke erlaubt werden sollen.

>>> f'Column={col_idx+1}'
>>> f'number of items: {len(items)}'

>>> col_number = col_idx+1
>>> f'Column={col_number}'
>>> n_items = len(items)
>>> f'number of items: {n_items}'

>>> f'mapping is { {a:b for (a, b) in ((1, 2), (3, 4))} }'
'mapping is {1: 2, 3: 4}'

Ähnliche Unterstützung in anderen Sprachen

Wikipedia hat eine gute Diskussion über String-Interpolation in anderen Programmiersprachen [9]. Dieses Feature ist in vielen Sprachen mit einer Vielzahl von Syntaxen und Einschränkungen implementiert.

Unterschiede zwischen f-String- und str.format-Ausdrücken

Es gibt einen kleinen Unterschied zwischen den eingeschränkten Ausdrücken, die in str.format() erlaubt sind, und den vollen Ausdrücken, die in f-Strings erlaubt sind. Der Unterschied liegt darin, wie Index-Lookups durchgeführt werden. In str.format() werden Indexwerte, die nicht wie Zahlen aussehen, in Zeichenketten konvertiert

>>> d = {'a': 10, 'b': 20}
>>> 'a={d[a]}'.format(d=d)
'a=10'

Beachten Sie, dass der Indexwert in den String 'a' konvertiert wird, wenn er im Dict nachgeschlagen wird.

In f-Strings müssten Sie jedoch ein Literal für den Wert von 'a' verwenden

>>> f'a={d["a"]}'
'a=10'

Dieser Unterschied ist erforderlich, da Sie sonst keine Variablen als Indexwerte verwenden könnten

>>> a = 'b'
>>> f'a={d[a]}'
'a=20'

Siehe [10] für eine weitere Diskussion. Diese Beobachtung führte zur Unterstützung vollständiger Python-Ausdrücke in f-Strings.

Darüber hinaus müssen die eingeschränkten Ausdrücke, die str.format() versteht, keine gültigen Python-Ausdrücke sein. Zum Beispiel

>>> '{i[";]}'.format(i={'";':4})
'4'

Aus diesem Grund ist der „Ausdrucks-Parser“ von str.format() nicht für die Implementierung von f-Strings geeignet.

Dreifach-zitierte f-Strings

Dreifach-zitierte f-Strings sind erlaubt. Diese Zeichenketten werden genauso geparst wie normale dreifach-zitierte Zeichenketten. Nach dem Parsen und Dekodieren wird die normale f-String-Logik angewendet und __format__() für jeden Wert aufgerufen.

Raw f-Strings

Raw- und f-Strings können kombiniert werden. Zum Beispiel können sie verwendet werden, um reguläre Ausdrücke zu erstellen

>>> header = 'Subject'
>>> fr'{header}:\s+'
'Subject:\\s+'

Zusätzlich können Raw-f-Strings mit dreifach-zitierten Zeichenketten kombiniert werden.

Keine binären f-Strings

Aus demselben Grund, aus dem wir bytes.format() nicht unterstützen, dürfen Sie ‚f‘ nicht mit ‚b‘-Zeichenkettenliteralen kombinieren. Das Hauptproblem ist, dass die __format__()-Methode eines Objekts Unicode-Daten zurückgeben kann, die nicht mit einer Bytes-Zeichenkette kompatibel sind.

Binäre f-Strings würden zunächst eine Lösung für bytes.format() erfordern. Diese Idee wurde in der Vergangenheit vorgeschlagen, zuletzt in PEP 461. Die Diskussionen über eine solche Funktion schlagen normalerweise entweder

• das Hinzufügen einer Methode wie __bformat__(), damit ein Objekt steuern kann, wie es in Bytes konvertiert wird, oder
• die Tatsache, dass bytes.format() nicht so allgemein oder erweiterbar ist wie str.format().

Beides bleibt als Option für die Zukunft, falls eine solche Funktionalität gewünscht wird.

!s, !r und !a sind redundant

Die Konvertierungen !s, !r und !a sind nicht streng erforderlich. Da beliebige Ausdrücke innerhalb der f-Strings erlaubt sind, ist dieser Code

>>> a = 'some string'
>>> f'{a!r}'
"'some string'"

Identisch mit

>>> f'{repr(a)}'
"'some string'"

Ebenso kann !s durch Aufrufe von str() und !a durch Aufrufe von ascii() ersetzt werden.

Jedoch werden !s, !r und !a von diesem PEP unterstützt, um die Unterschiede zu str.format() zu minimieren. !s, !r und !a sind in str.format() erforderlich, da diese die Ausführung beliebiger Ausdrücke nicht zulässt.

Lambdas innerhalb von Ausdrücken

Da Lambdas das Zeichen ':' verwenden, können sie außerhalb von Klammern in einem Ausdruck nicht vorkommen. Der Doppelpunkt wird als Beginn des Format-Spezifizierers interpretiert, was bedeutet, dass der Beginn des Lambda-Ausdrucks gesehen wird und syntaktisch ungültig ist. Da es keinen praktischen Nutzen für ein einfaches Lambda in einem f-String-Ausdruck gibt, wird dies nicht als große Einschränkung angesehen.

Wenn Sie der Meinung sind, dass Sie Lambdas verwenden müssen, können sie innerhalb von Klammern verwendet werden

>>> f'{(lambda x: x*2)(3)}'
'6'

Kann nicht mit „u“ kombiniert werden

Das ‚u‘-Präfix wurde in Python 3.3 in PEP 414 als Mittel zur Erleichterung der Quellcode-Kompatibilität mit Python 2.7 hinzugefügt. Da Python 2.7 niemals f-Strings unterstützen wird, gibt es keinen Vorteil daraus, das ‚f‘-Präfix mit ‚u‘ kombinieren zu können.