有各种不同的字符串格式化方法：
"Hello %s" % name"Hello {}".format(name) (使用str.format)f"{name}" (使用f-strings)哪个更好，适用于哪些情况？
以下这些方法有相同的结果，那么它们之间有什么区别？
name = "Alice"
"Hello %s" % name
"Hello {0}".format(name)
f"Hello {name}"
# Using named arguments:
"Hello %(kwarg)s" % {'kwarg': name}
"Hello {kwarg}".format(kwarg=name)
f"Hello {name}"
字符串格式化是在什么时候运行的，如何避免运行时的性能损失？
如果您正在尝试关闭一个寻找字符串格式化方法的重复问题，请使用如何将变量值放入字符串中？。
.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)将首先评估为例如"some debug info: roflcopters are active"，然后将该字符串传递给log.debug()。
log.debug("something: %s", x)时不会浪费时间，但是在使用log.debug("something: %s" % x)时会浪费时间。方法中将处理字符串格式化，如果不记录日志，则不会影响性能。像往常一样，Python会满足你的需求 =) - darkfeline'{0}, {0}'.format('test')做的事情一样。 - flying sheep% 占位符内部的“$”符号表示法。 - cfiprintf("%2$d", 1, 3) 打印出 "3"，那么这个在 POSIX 中有规定，而不是 C99。你引用的那个 man 页面指出："C99 标准不包括使用 '$' 的风格...”。 - Thanatos据我所知，取模运算符（%）无法完成以下操作：
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
map中使用旧的格式化方式。示例： map('some_format_string_%s'.__mod__, some_iterable) - agfgcc -std=c99 test.c -o test编译 printf("%2$s %1$s\n", "One", "Two");后，输出为Two One。但是我改正了：实际上这是 POSIX 扩展，而不是 C。我无法在 C/C++ 标准中再次找到它，尽管我之前认为它存在。即使使用'c90' std标志，该代码仍然有效。sprintf man page。这个 没有列出它，但允许库实现超集。替换 'C' 为 'Posix'，我的原始论点仍然有效。 - cfi假设您正在使用Python的logging模块，您可以将字符串格式化参数作为参数传递给.debug()方法，而不是自己进行格式化：
log.debug("some debug info: %s", some_info)
只有在记录器实际记录了内容时，该方法才会执行格式化操作。
log.debug("一些调试信息：%(this)s和%(that)s", dict(this='Tom', that='Jerry'))然而，即使在Python3.3中也不能在此处使用新的.format()语法，这很遗憾。 - Cito从Python 3.6（2016年）开始，您可以使用f-strings来替换变量:
>>> origin = "London"
>>> destination = "Paris"
>>> f"from {origin} to {destination}"
'from London to Paris'
请注意 f" 前缀。如果您在 Python 3.5 或之前尝试此操作，将会得到一个 SyntaxError 错误。
参见https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings
PEP 3101 建议在 Python 3 中用新的高级字符串格式化来替换 % 运算符，并使其成为默认选项。
.format 不会 替代 % 字符串格式化。 - Tobias但请注意，刚才在尝试将所有%替换为.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 中称为'byte array'），u 是一个Unicode字符串（在 Python3 中称为'string'）：
; '%s' % s
'\xd0\xb9'
; '%s' % u
u'\u0439'
%运算符时，它将生成一个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'
或者如果参数字符串可以转换为字符串（所谓的“字节数组”）
format方法的附加功能，否则没有理由更改正在工作的代码... - Tobias"p1=%s p2=%d" % "abc", 2或者"p1=%s p2=%s" % (tuple_p1_p2,)。你可能会认为这是编码者的问题，但我认为它只是奇怪的有缺陷的语法，虽然在快速脚本中看起来不错，但对于生产代码来说是不好的。 - wobmene%的性能比我测试中的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正在逐渐改进。
Edit 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仍比%慢但优于format。
str.format 提供了更多的功能（特别是类型专用的格式化，例如 '{0:%Y-%m-%d}'.format(datetime.datetime.utcnow())）。性能并非所有工作的绝对要求。使用正确的工具来完成任务。 - minhee% 运算符允许重用 printf 知识；字典插值是该原则的一个非常简单的扩展。 - Tobias.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'
据我所知，使用%无法实现这一点。
'x is {0}, y is {1}'.format(a.x, a.y)相比，这个看起来更加难以阅读。只有在a.x操作非常昂贵时才应使用它。 - dtheodor'x is {a.x}, y is {a.y}'.format(a=a)。这比两个示例都更易读。 - CivFan'x is {a.x}, y is {a.y}'.format(**vars()) - Jacklynn'{foo[bar]}'.format(foo={'bar': 'baz'})。 - Antoine PinsardYour order, number {order[number]} was processed at {now:%Y-%m-%d %H:%M:%S}, will be ready at about {order[eta]:%H:%M:%S}或任何他们希望的方式来提供。这比尝试使用旧的格式化器提供相同的功能要清晰得多。它使用户提供的格式字符串更加强大。 - Taywee我今天发现，通过使用%的旧方式格式化字符串不支持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()方法。
str(d)，而旧式格式化可能首先调用了float(d)。 - David Sandersstr(d)返回的是"3.12375239e-24"而不是"0.00000000000000000000000312375239000000000000000000"。 - Jacklynn如果你的Python版本大于等于3.6，F-string格式化字符串就是你的新朋友。
它更简单、更清晰，并且性能更好。
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)