不使用 globals() 或 locals()

在 python-dev 上的讨论 [4] 中，提出了一些使用 locals() 和 globals() 或其等效项的解决方案。所有这些都有各种问题。其中包括引用未在闭包中使用的变量。考虑一下

>>> 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'

这会返回一个错误，因为编译器没有在闭包中添加对 x 的引用。您需要手动添加对 x 的引用才能使其工作

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

此外，使用 locals() 或 globals() 会引入信息泄漏。一个能够访问调用者的 locals() 或 globals() 的被调用例程可以访问比执行字符串插值所需更多信息。

Guido 指出 [5]，任何用于改进字符串插值的解决方案都不会在其实现中使用 locals() 或 globals()。（这并不禁止用户传递 locals() 或 globals()，它只是不需要它，也不允许在后台使用这些函数。）

转义序列

反斜杠不能出现在 f-string 的表达式部分，因此您不能使用它们，例如，在 f-string 中转义引号。

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

您可以在表达式中使用不同类型的引号。

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

反斜杠转义可以出现在 f-string 的字符串部分。

请注意，在结果字符串值中显示字面大括号的正确方法是将大括号加倍。

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

与 Python 中的所有原始字符串一样，原始 f-string 不会进行转义处理。

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

由于 Python 的字符串标记规则，f-string f'abc {a['x']} def' 是无效的。标记器将其解析为 3 个标记：f'abc {a['、x 和 ']} def'。就像普通字符串一样，这无法通过使用原始字符串来解决。有多种正确的方法可以编写此 f-string：使用不同的引号字符。

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

或使用三引号。

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

代码等价性

实现 f-string 的确切代码未指定。但是，可以保证任何转换为字符串的嵌入值都将使用该值的 __format__ 方法。这与 str.format() 用于将值转换为字符串的机制相同。

例如，这段代码

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

可能会被评估为

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

表达式求值

从字符串中提取的表达式在 f-string 出现的上下文中进行评估。这意味着表达式可以完全访问局部和全局变量。可以使用任何有效的 Python 表达式，包括函数和方法调用。

因为 f-string 在源代码中字符串出现的位置进行评估，所以 f-string 没有额外的表现力。也没有额外的安全问题：您也可以编写相同的表达式，而不在 f-string 内。

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

等价于

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

表达式使用等效于 ast.parse('(' + expression + ')', '<fstring>', 'eval') [7] 的方式进行解析。

请注意，由于表达式在评估之前被隐式括号括起来，因此表达式可以包含换行符。例如

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

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

格式说明符

格式说明符也可以包含已评估的表达式。这允许以下代码

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

一旦格式说明符中的表达式（如果需要）被评估，格式说明符就不会被 f-string 评估器解释。就像在 str.format() 中一样，它们只是传递到正在格式化的对象的 __format__() 方法中。

连接字符串

相邻的 f-string 和普通字符串将连接在一起。普通字符串在编译时连接，f-string 在运行时连接。例如，表达式

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

生成值

'ab10{c}str< hi >de'

虽然这种运行时连接的确切方法未指定，但上述代码可能会评估为

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

每个 f-string 在连接到相邻的 f-string 之前都会被完全评估。这意味着这个

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

是一个语法错误，因为第一个 f-string 不包含结束大括号。

错误处理

处理 f-string 时可能会发生编译时或运行时错误。编译时错误仅限于扫描 f-string 时可以检测到的错误。这些错误都会引发 SyntaxError。

不匹配的大括号

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

无效的表达式

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

运行时错误发生在评估 f-string 内部的表达式时。请注意，f-string 可以多次评估，有时可以工作，有时会引发错误。

>>> 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

或

>>> 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-string 中的表达式按从左到右的顺序进行评估。只有当表达式具有副作用时才能检测到这一点。

>>> 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]

python-ideas 讨论

python-ideas 上的大多数讨论 [8] 集中在三个问题上

• 如何表示 f-string，
• 如何在 f-string 中指定表达式的放置位置，以及
• 是否允许完整的 Python 表达式。

>>> 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}'

其他语言中的类似支持

维基百科对其他编程语言中的字符串插值进行了很好的讨论 [9]。此功能在许多语言中实现，并具有各种语法和限制。

f-字符串和 str.format 表达式之间的区别

在 str.format() 中允许的有限表达式和在 f-string 中允许的完整表达式之间有一个细微的差别。区别在于如何执行索引查找。在 str.format() 中，看起来不像数字的索引值将转换为字符串。

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

请注意，索引值在字典中查找时会转换为字符串 'a'。

但是，在 f-string 中，您需要使用 'a' 值的字面量。

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

此差异是必需的，否则您将无法使用变量作为索引值。

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

请参阅 [10] 以了解更多讨论。正是这一观察结果导致在 f-string 中支持完整的 Python 表达式。

此外，str.format() 理解的有限表达式不必是有效的 Python 表达式。例如

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

因此，str.format() 的“表达式解析器”不适合在实现 f-string 时使用。

三引号 f-字符串

允许使用三引号 f-string。这些字符串的解析方式与普通的三引号字符串相同。解析和解码后，将应用正常的 f-string 逻辑，并对每个值调用 __format__()。

原始 f-字符串

可以组合使用原始 f-string 和 f-string。例如，它们可以用于构建正则表达式。

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

此外，原始 f-string 可以与三引号字符串组合。

没有二进制 f-字符串

由于我们不支持 bytes.format()，因此您不能将 'f' 与 'b' 字符串文字组合。主要问题是对象的 __format__() 方法可能会返回与字节字符串不兼容的 Unicode 数据。

二进制 f-string 首先需要为 bytes.format() 提供解决方案。这个想法过去曾被提出，最近一次是在 PEP 461 中。对这种功能的讨论通常建议以下两种方法：

• 添加一个像 __bformat__() 这样的方法，以便对象可以控制如何将其转换为字节，或者
• 让 bytes.format() 不像 str.format() 那样通用或可扩展。

如果需要此类功能，这两者在未来都将作为选项保留。

!s、!r 和 !a 是冗余的

!s、!r 和 !a 转换不是严格必需的。因为在 f-string 中允许任意表达式，所以这段代码

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

与

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

类似地，!s 可以替换为对 str() 的调用，!a 可以替换为对 ascii() 的调用。

然而，为了最大程度地减少与str.format()的差异，本 PEP 支持!s、!r和!a。在str.format()中需要!s、!r和!a，因为它不允许执行任意表达式。

表达式内的 lambda 函数

由于 lambda 使用':'字符，因此它们不能出现在表达式中的括号之外。冒号被解释为格式说明符的开始，这意味着 lambda 表达式的开始被识别并且语法无效。由于在 f-string 表达式中没有对普通 lambda 的实际用途，因此这并没有被视为很大的限制。

如果您必须使用 lambda，则可以在括号内使用它们。

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

不能与 'u' 组合使用

在 Python 3.3 中，PEP 414添加了“u”前缀，作为一种简化与 Python 2.7 源代码兼容性的方法。由于 Python 2.7 永远不会支持 f-string，因此能够将“f”前缀与“u”结合起来没有任何好处。