为什么variable1 + = variable2比variable1 = variable1 + variable2快得多?

我继承了一些Python代码,这些代码用于创建巨大的表(最多19列,每行5000行)。 花了九秒钟时间在屏幕上绘制了表格。 我注意到每一行都是使用以下代码添加的:

sTable = sTable + '\n' + GetRow()

其中sTable是字符串。

我将其更改为:

sTable += '\n' + GetRow()

我注意到桌子现在出现了六秒钟。

然后我将其更改为:

sTable += '\n%s' % GetRow()

基于这些Python性能提示(仍为6秒)。

由于调用了大约5000次,因此突出了性能问题。 但是为什么会有如此大的差异呢? 为什么编译器没有在第一个版本中发现问题并对其进行优化?

1个解决方案
89 votes

这与使用原位'\n'.join(lst)sTable二进制添加无关。 您没有告诉我们整个故事。 您的原始版本连接了3个字符串,而不仅仅是两个:

sTable = sTable + '\n' + sRow  # simplified, sRow is a function call

Python尝试提供帮助并优化字符串连接; 使用'\n'.join(lst)sTable时都可以,但是当涉及两个以上的字符串时,它不能应用此优化。

Python字符串通常是不可变的,但是如果没有其他对左侧字符串对象的引用,并且该字符串仍在反弹,则Python会欺骗并更改该字符串。 这样可以避免每次连接时都必须创建新的字符串,并且可以大大提高速度。

这在字节码评估循环中实现。 在两个字符串上使用'\n'.join(lst)以及在两个字符串上使用'\n'.join(lst)时,Python都将串联委托给特殊的辅助函数'\n'.join(lst)。为了能够通过使字符串发生变异来优化串联,首先需要确保该字符串没有其他引用 对它 如果只有堆栈和原始变量引用,则可以完成此操作,接下来的操作将替换原始变量引用。

因此,如果仅对该字符串有2个引用,并且下一个运算符是'\n'.join(lst)(设置局部变量),sTable(设置封闭函数引用的变量)或sRow(设置全局变量)和受影响的变量之一 当前引用相同的字符串,然后清除该目标变量以将引用数减少到仅1(堆栈)。

这就是为什么您的原始代码无法完全使用此优化的原因。 表达式的第一部分是'\n'.join(lst),下一个操作是另一个'\n'.join(lst)

>>> import dis
>>> dis.dis(compile(r"sTable = sTable + '\n' + sRow", '<stdin>', 'exec'))
  1           0 LOAD_NAME                0 (sTable)
              3 LOAD_CONST               0 ('\n')
              6 BINARY_ADD          
              7 LOAD_NAME                1 (sRow)
             10 BINARY_ADD          
             11 STORE_NAME               0 (sTable)
             14 LOAD_CONST               1 (None)
             17 RETURN_VALUE        

第一个'\n'.join(lst)后跟一个sTable,以访问sRow变量,而不是存储操作。 第一个BINARY_ADD必须始终产生一个新的字符串对象,随着sTable的增长,它会变得越来越大,并且创建这个新的字符串对象所花费的时间越来越多。

您将此代码更改为:

sTable += '\n%s' % sRow

删除了第二个串联。 现在字节码是:

>>> dis.dis(compile(r"sTable += '\n%s' % sRow", '<stdin>', 'exec'))
  1           0 LOAD_NAME                0 (sTable)
              3 LOAD_CONST               0 ('\n%s')
              6 LOAD_NAME                1 (sRow)
              9 BINARY_MODULO       
             10 INPLACE_ADD         
             11 STORE_NAME               0 (sTable)
             14 LOAD_CONST               1 (None)
             17 RETURN_VALUE        

我们只剩下一个'\n'.join(lst)和一个商店。 现在可以就地更改sTable,而不会导致更大的新字符串对象。

您将获得与以下相同的速度差:

sTable = sTable + ('\n%s' % sRow)

这里。

计时试用显示了不同之处:

>>> import random
>>> from timeit import timeit
>>> testlist = [''.join([chr(random.randint(48, 127)) for _ in range(random.randrange(10, 30))]) for _ in range(1000)]
>>> def str_threevalue_concat(lst):
...     res = ''
...     for elem in lst:
...         res = res + '\n' + elem
... 
>>> def str_twovalue_concat(lst):
...     res = ''
...     for elem in lst:
...         res = res + ('\n%s' % elem)
... 
>>> timeit('f(l)', 'from __main__ import testlist as l, str_threevalue_concat as f', number=10000)
6.196403980255127
>>> timeit('f(l)', 'from __main__ import testlist as l, str_twovalue_concat as f', number=10000)
2.3599119186401367

这个故事的寓意是,您不应该首先使用字符串连接。 从其他字符串的负载中构建新字符串的正确方法是使用列表,然后使用'\n'.join(lst)

table_rows = []
for something in something_else:
    table_rows += ['\n', GetRow()]
sTable = ''.join(table_rows)

这仍然更快:

>>> def str_join_concat(lst):
...     res = ''.join(['\n%s' % elem for elem in lst])
... 
>>> timeit('f(l)', 'from __main__ import testlist as l, str_join_concat as f', number=10000)
1.7978830337524414

但您不能仅使用'\n'.join(lst)来击败:

>>> timeit('f(l)', 'from __main__ import testlist as l, nl_join_concat as f', number=10000)
0.23735499382019043
Martijn Pieters answered 2020-01-13T19:57:20Z
translate from https://stackoverflow.com:/questions/25503703/why-is-variable1-variable2-much-faster-than-variable1-variable1-variable2