字符串格式：% 与 .format 与 f 字符串文字

Question

字符串格式化方法有多种：

• Python <2.6: "Hello %s" % name
• Python 2.6+: "Hello {}".format(name) （使用 str.format）
• Python 3.6+：f"{name}" （使用 f 字符串）

哪个更好，适用于什么情况？

---

1. 以下方法的结果相同，那么有什么区别呢？

   <前><代码>名称=“爱丽丝” “你好 %s” % 姓名 “你好{0}”.format(名称) f“你好{名字}” # 使用命名参数： “你好 %(kwarg)s” % {'kwarg': 名称} “你好{kwarg}”.format(kwarg=名称) f“你好{名字}”

2. 何时运行字符串格式化，以及如何避免运行时性能损失？

---

_{如果您尝试关闭只是寻找格式化字符串的方法的重复问题，请使用如何放置变量的字符串内的值？.}

Answer 1

要回答你的第一个问题... .format 在很多方面似乎更复杂。 % 的一个令人烦恼的事情是它如何接受变量或元组。您可能认为以下内容总是有效：

"Hello %s" % name

但是，如果 name 恰好是 (1, 2, 3)，它将抛出 TypeError >。为了保证它总是打印出来，你需要做

"Hello %s" % (name,)   # supply the single argument as a single-item tuple

一些很丑陋的事情。 .format 不存在这些问题。同样在您给出的第二个示例中， .format 示例看起来更加简洁。

仅将其用于向后兼容 Python 2.5。

---

要回答第二个问题，字符串格式化与任何其他操作同时发生 - 当评估字符串格式化表达式时。 Python 不是一种惰性语言，它会在调用函数之前计算表达式，因此表达式 log.debug("some debug info: %s" % some_info) 首先会计算字符串，例如 “一些调试信息：roflcopters 处于活动状态”，然后该字符串将传递给 log.debug()。

Answer 2

模运算符（ % ）无法做到的事情，据我所知：

tu = (12,45,22222,103,6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*tu)

结果

12 22222 45 22222 103 22222 6 22222

非常有用。

另一点：format()作为一个函数，可以用作其他函数中的参数：

li = [12,45,78,784,2,69,1254,4785,984]
print map('the number is {}'.format,li)   

print

from datetime import datetime,timedelta

once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)

gen =(once_upon_a_time +x*delta for x in xrange(20))

print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))

结果：

['the number is 12', 'the number is 45', 'the number is 78', 'the number is 784', 'the number is 2', 'the number is 69', 'the number is 1254', 'the number is 4785', 'the number is 984']

2010-07-01 12:00:00
2010-07-14 20:20:00
2010-07-28 04:40:00
2010-08-10 13:00:00
2010-08-23 21:20:00
2010-09-06 05:40:00
2010-09-19 14:00:00
2010-10-02 22:20:00
2010-10-16 06:40:00
2010-10-29 15:00:00
2010-11-11 23:20:00
2010-11-25 07:40:00
2010-12-08 16:00:00
2010-12-22 00:20:00
2011-01-04 08:40:00
2011-01-17 17:00:00
2011-01-31 01:20:00
2011-02-13 09:40:00
2011-02-26 18:00:00
2011-03-12 02:20:00

Answer 3

假设您使用 Python 的 logging 模块，您可以将字符串格式化参数作为参数传递给 .debug() 方法，而不是自己进行格式化：

log.debug("some debug info: %s", some_info)

这可以避免执行除非记录器实际记录了某些内容，否则进行格式化。

Answer 4

从 Python 3.6 (2016) 开始，您可以使用 f-strings< /em> 替换变量：

>>> origin = "London"
>>> destination = "Paris"
>>> f"from {origin} to {destination}"
'from London to Paris'

请注意 f" 前缀。如果您在 Python 3.5 或更早版本中尝试此操作，您将收到 SyntaxError。

请参阅 < a href="https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings" rel="noreferrer">https://docs.python.org/3.6/reference/lexical_analysis.html# f 字符串

Answer 5

PEP 3101 建议替换 % 运算符Python 3 中采用了新的高级字符串格式，这将是默认设置。

Answer 6

不过请注意，刚才我在尝试将现有代码中所有 % 替换为 .format 时发现了一个问题：'{}' .format(unicode_string) 将尝试对 unicode_string 进行编码，并且可能会失败。

只要看看这个 Python 交互式会话日志：

Python 2.7.2 (default, Aug 27 2012, 19:52:55) 
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
; s='й'
; u=u'й'
; s
'\xd0\xb9'
; u
u'\u0439'

s 只是一个字符串（称为“字节数组”）在 Python3 中）并且 u 是一个 Unicode 字符串（在 Python3 中称为“字符串”）：

; '%s' % s
'\xd0\xb9'
; '%s' % u
u'\u0439'

当您将​​ Unicode 对象作为参数提供给 % 运算符时，它将生成一个 Unicode 字符串即使原始字符串不是 Unicode：

; '{}'.format(s)
'\xd0\xb9'
; '{}'.format(u)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'latin-1' codec can't encode character u'\u0439' in position 0: ordinal not in range(256)

但 .format 函数将引发“UnicodeEncodeError”：

; u'{}'.format(s)
u'\xd0\xb9'
; u'{}'.format(u)
u'\u0439'

并且仅当原始字符串是 Unicode 时，它​​才可以正常使用 Unicode 参数。

; '{}'.format(u'i')
'i'

或者如果参数字符串可以转换为字符串（所谓的“字节数组”）

Answer 7

根据我的测试，% 的性能比 format 更好。

测试代码：

Python 2.7.2：

import timeit
print 'format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')")
print '%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')")

结果：

> format: 0.470329046249
> %: 0.357107877731

Python 3.5.2

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))

结果

> format: 0.5864730989560485
> %: 0.013593495357781649

在Python2中，差异很小，而在Python3中，%比format快得多。

感谢@Chris Cogdon 提供的示例代码。

编辑1：

2019年7月在Python 3.7.2中再次测试。

结果：

> format: 0.86600608
> %: 0.630180146

没有太大区别。我猜Python正在逐渐改进。

编辑2：

有人在评论中提到python 3的f-string后，我在python 3.7.2下对以下代码进行了测试：

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))
print('f-string:', timeit.timeit("f'{1}{1.23}{\"hello\"}'"))

结果：

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

看来f-string仍然比 % 慢，但比格式。

Answer 8

.format 的另一个优点（我在答案中没有看到）：它可以采用对象属性。

In [12]: class A(object):
   ....:     def __init__(self, x, y):
   ....:         self.x = x
   ....:         self.y = y
   ....:         

In [13]: a = A(2,3)

In [14]: 'x is {0.x}, y is {0.y}'.format(a)
Out[14]: 'x is 2, y is 3'

或者，作为关键字参数：

In [15]: 'x is {a.x}, y is {a.y}'.format(a=a)
Out[15]: 'x is 2, y is 3'

据我所知，这是不可能的 % 。

Answer 9

正如我今天发现的，通过 % 格式化字符串的旧方法不支持开箱即用的 Decimal（Python 的十进制定点和浮点算术模块）。

示例（使用 Python 3.3.5）：

#!/usr/bin/env python3

from decimal import *

getcontext().prec = 50
d = Decimal('3.12375239e-24') # no magic number, I rather produced it by banging my head on my keyboard

print('%.50f' % d)
print('{0:.50f}'.format(d))

输出：

0.00000000000000000000000312375239000000009907464850
0.00000000000000000000000312375239000000000000000000

当然可能有解决方法，但您仍然可以考虑立即使用 format() 方法。

Answer 10

如果你的 python >= 3.6，F 字符串格式的文字就是你的新朋友。

它更简单、更干净、性能也更好。

In [1]: params=['Hello', 'adam', 42]

In [2]: %timeit "%s %s, the answer to everything is %d."%(params[0],params[1],params[2])
448 ns ± 1.48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [3]: %timeit "{} {}, the answer to everything is {}.".format(*params)
449 ns ± 1.42 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit f"{params[0]} {params[1]}, the answer to everything is {params[2]}."
12.7 ns ± 0.0129 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

Answer 11

附带说明一下，使用带有日志记录的新样式格式并不一定会影响性能。您可以将任何对象传递给实现 __str__ 魔术方法的 logging.debug、logging.info 等。当日志记录模块决定必须发出消息对象（无论它是什么）时，它会在执行此操作之前调用 str(message_object)。所以你可以这样做：

import logging


class NewStyleLogMessage(object):
    def __init__(self, message, *args, **kwargs):
        self.message = message
        self.args = args
        self.kwargs = kwargs

    def __str__(self):
        args = (i() if callable(i) else i for i in self.args)
        kwargs = dict((k, v() if callable(v) else v) for k, v in self.kwargs.items())

        return self.message.format(*args, **kwargs)

N = NewStyleLogMessage

# Neither one of these messages are formatted (or calculated) until they're
# needed

# Emits "Lazily formatted log entry: 123 foo" in log
logging.debug(N('Lazily formatted log entry: {0} {keyword}', 123, keyword='foo'))


def expensive_func():
    # Do something that takes a long time...
    return 'foo'

# Emits "Expensive log entry: foo" in log
logging.debug(N('Expensive log entry: {keyword}', keyword=expensive_func))

这在Python 3文档中都有描述（https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles）。但是，它也适用于 Python 2.6 ( https://docs.python.org/2.6/library/logging.html#using-centric-objects-as-messages）。

使用此技术的优点之一，除了它与格式样式无关之外，还在于它允许使用惰性值，例如上面的函数 expense_func。这为 Python 文档中给出的建议提供了更优雅的替代方案：https: //docs.python.org/2.6/library/logging.html#optimization。

Answer 12

% 可能会有所帮助的一种情况是当您格式化正则表达式时。例如，

'{type_names} [a-z]{2}'.format(type_names='triangle|square')

引发IndexError。在这种情况下，您可以使用：

'%(type_names)s [a-z]{2}' % {'type_names': 'triangle|square'}

这可以避免将正则表达式编写为 '{type_names} [az]{{2}}'。当您有两个正则表达式时，这会很有用，其中一个正则表达式单独使用而不带格式，但两个正则表达式的串联都已格式化。

Answer 13

我想补充一点，从 3.6 版本开始，我们可以使用 fstrings，如下

foo = "john"
bar = "smith"
print(f"My name is {foo} {bar}")

所示

我的名字是约翰·史密斯

所有内容都转换为字符串

mylist = ["foo", "bar"]
print(f"mylist = {mylist}")

结果：

mylist = ['foo', 'bar']

你可以传递函数，就像其他格式的方法

print(f'Hello, here is the date : {time.strftime("%d/%m/%Y")}')

例如

您好，这是日期：2018年4月16日

Answer 14

Python 3.6.7 比较：

#!/usr/bin/env python
import timeit

def time_it(fn):
    """
    Measure time of execution of a function
    """
    def wrapper(*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        print("{0:.10f} seconds".format(t1 - t0))
    return wrapper


@time_it
def new_new_format(s):
    print("new_new_format:", f"{s[0]} {s[1]} {s[2]} {s[3]} {s[4]}")


@time_it
def new_format(s):
    print("new_format:", "{0} {1} {2} {3} {4}".format(*s))


@time_it
def old_format(s):
    print("old_format:", "%s %s %s %s %s" % s)


def main():
    samples = (("uno", "dos", "tres", "cuatro", "cinco"), (1,2,3,4,5), (1.1, 2.1, 3.1, 4.1, 5.1), ("uno", 2, 3.14, "cuatro", 5.5),) 
    for s in samples:
        new_new_format(s)
        new_format(s)
        old_format(s)
        print("-----")


if __name__ == '__main__':
    main()

输出：

new_new_format: uno dos tres cuatro cinco
0.0000170280 seconds
new_format: uno dos tres cuatro cinco
0.0000046750 seconds
old_format: uno dos tres cuatro cinco
0.0000034820 seconds
-----
new_new_format: 1 2 3 4 5
0.0000043980 seconds
new_format: 1 2 3 4 5
0.0000062590 seconds
old_format: 1 2 3 4 5
0.0000041730 seconds
-----
new_new_format: 1.1 2.1 3.1 4.1 5.1
0.0000092650 seconds
new_format: 1.1 2.1 3.1 4.1 5.1
0.0000055340 seconds
old_format: 1.1 2.1 3.1 4.1 5.1
0.0000052130 seconds
-----
new_new_format: uno 2 3.14 cuatro 5.5
0.0000053380 seconds
new_format: uno 2 3.14 cuatro 5.5
0.0000047570 seconds
old_format: uno 2 3.14 cuatro 5.5
0.0000045320 seconds
-----

Answer 15

对于 python 版本 >= 3.6（请参阅 PEP 498）

s1='albha'
s2='beta'

f'{s1}{s2:>10}'

#output
'albha      beta'

Answer 16

但一件事是，如果您有嵌套大括号，则不适用于格式，但 % 可以。

例子：

>>> '{{0}, {1}}'.format(1,2)
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    '{{0}, {1}}'.format(1,2)
ValueError: Single '}' encountered in format string
>>> '{%s, %s}'%(1,2)
'{1, 2}'
>>>