字符串格式：％vs. .format与F-string字面

Question

有各种字符串格式方法：

• Python＆lt; 2.6：“ Hello％S”％name
• Python 2.6+：“ Hello {}”。格式（name）＆nbsp; （使用 str.format.format）
• Python 3.6+：f“ {name}”＆nbsp; （使用f-strings）

哪个更好，在什么情况下？

---

1. 以下方法具有相同的结果，那么差异是什么？

     name =“ Alice”
   
   “ Hello％S”％名称
   “你好{0}”。格式（名称）
   f“你好{name}”
   
   ＃使用命名参数：
   “ Hello％（Kwarg）S”％{'Kwarg'：name}
   “你好{kwarg}”。格式（kwarg = name）
   f“你好{name}”
    

2. 字符串格式何时运行，如何避免运行时性能罚款？

---

如果您要关闭一个仅仅寻找一种格式化字符串的重复问题，请使用我如何放置变量字符串内的值？。

Answer 1

我会补充说，由于版本3.6，我们可以使用以下

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

fstrings

我叫约翰·史密斯

一切都转换为字符串

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

结果：

mylist = ['foo'，'bar']

您可以通过函数，就像其他格式中的方法

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

给予

你好，这是日期：16/04/2018

Answer 2

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 3

对于Python版本＆gt; = 3.6（请参阅 pep 498 ）

s1='albha'
s2='beta'

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

#output
'albha      beta'

Answer 4

但是，还有一件事是，如果您嵌套了卷曲式，则无法用于格式，但％将起作用。

例子：

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

Answer 5

要回答您的第一个问题... .format在许多方面似乎更复杂。关于％的烦人的事情也是它如何服用变量或元组。您可能会认为以下内容总是有效的：

"Hello %s" % name

但是，如果name恰好是（1，2，3），它将抛出type> typeerror。为了确保它总是打印，您需要做

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

这很丑陋。 .format没有这些问题。同样，在您给出的第二个示例中，.format示例看起来更干净。

仅将其向后兼容与Python 2.5。

---

为了回答您的第二个问题，当评估字符串格式表达式时，字符串格式与任何其他操作同时进行。 python不是一种懒惰的语言，在调用函数之前评估表达式，因此expession log.debug（“某些调试信息：％s“％some_info）将首先评估字符串，例如>“某些调试信息：roflcopter处于活动状态” ，然后该字符串将传递给log.debug（）。

Answer 6

Afaik：

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

非常有用。

另一点：格式（）作为一个函数，可以用作其他函数中的参数：

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 7

假设您正在使用Python的记录模块，则可以将字符串格式的参数作为参数传递给.debug（）方法而不是自己进行

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

格式格式化除非记录器实际记录某些内容。

Answer 8

从Python 3.6（2016）开始，您可以使用 替换变量：

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

f“前缀。

注意 a href =“ https://docs.python.org/3.6/reference/lexical_analysis.html#f-snrings” rel =“ noreferrer”> https://docs.python.org/3.6/reference/Rexical_analysis.htmllysis.htmll# f-strings

Answer 9

pep 3101 建议更换％操作员借助Python 3中的新的高级字符串格式化，将是默认值。

Answer 10

但是请小心，刚才我在尝试将所有％用.format中的所有％中发现时发现了一个问题： '{}' .format（unicode_string）将尝试编码unicode_string，并且可能会失败。

只需查看此python Interactive session log：

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只是一个字符串（称为'byte array''在python3中）和u是一个Unicode字符串（python3中称为'String'）：

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

当您将​​Unicode对象作为参数作为>％运算符时，它将产生一个Unicode String即使原始字符串不是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函数将引起“ unicodeCodeError”：

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

仅当原始字符串是Unicode时，它才能与Unicode参数一起使用。

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

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

Answer 11

％比我的测试中的格式提供了更好的性能。

测试代码：

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中，％在form中要快得多。

感谢@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 12

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

正如我今天发现的那样，通过％格式化字符串的旧方法不支持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.0000000000000000000000000312375239000000000000009907464850
0.0000000000000000000000000312375239000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

肯定可能有工作障碍，但您仍然可以立即考虑使用format（）立即使用。

Answer 14

如果您的python＆gt; = 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)

Answer 15

附带说明，您不必进行性能命中即可使用日志记录使用新样式格式。您可以将任何对象传递到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一起使用（“ noreferrer”> https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ）。

使用此技术的优点之一，除了其格式化式不可知论的事实是，它允许懒值quode> quode> pundy_func。这为这里的Python文档提供的建议提供了一种更优雅的替代方法： https： //docs.python.org/2.6/library/logging.html#optimization 。

Answer 16

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

'{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}}}'。当您有两个Regexes时，这可能很有用，其中一个是单独使用的，没有格式，但是两者的串联都格式化了。