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

Question

我继承了一些Python代码，这些代码用于创建大型表格(最多19列宽，5000行)。花了9秒将表格绘制到屏幕上。我注意到每一行都是使用以下代码添加的：

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

其中sTable是一个字符串。

我将其更改为：

sTable += '\n' + GetRow()

我注意到这个表现在出现在six seconds中。

然后我把它改成：

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

基于these Python performance tips (仍为6秒)。

因为它被调用了大约5000次，所以它突出了性能问题。但是为什么会有这么大的差异呢？为什么编译器没有发现第一个版本中的问题并对其进行优化？

Answer 1

这不是关于使用inplace +=还是+ binary add。你没有告诉我们整个故事。您的原始版本连接了3个字符串，而不仅仅是两个：

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

Python试图帮助并优化字符串连接；在使用strobj += otherstrobj和strobj = strobj + otherstringobj时都是如此，但当涉及2个以上的字符串时，它不能应用这种优化。

Python字符串是不可变的，通常是，但是如果没有对左侧string对象的其他引用，并且无论如何它都会被重新绑定，那么Python就会欺骗和更改字符串。这避免了每次连接时都必须创建一个新的字符串，这可以大大提高速度。

这是在字节码评估循环中实现的。无论是在使用BINARY_ADD on two strings时还是在使用INPLACE_ADD on two strings时，Python都会将连接委托给一个特殊的辅助函数string_concatenate()。为了能够通过改变字符串来优化连接，它首先需要确保字符串没有对它的其他引用；如果只有堆栈和原始变量引用它，那么可以这样做，和下一个操作将替换原始变量引用。

因此，如果只有2个对字符串的引用，并且下一个运算符是STORE_FAST (设置局部变量)、STORE_DEREF (设置由closed over函数引用的变量)或STORE_NAME (设置全局变量)之一，并且受影响的变量当前引用相同的字符串，那么该目标变量将被清除，以将引用的数量减少到堆栈中的1个。

这就是为什么你的原始代码不能充分利用这个优化。表达式的第一部分是sTable + '\n'，下一个操作是另一个BINARY_ADD

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

第一个BINARY_ADD后面跟一个用于访问sRow变量的LOAD_NAME，而不是一个存储操作。第一个BINARY_ADD必须总是产生一个新的string对象，并且随着sTable的增长越来越大，创建这个新的string对象需要越来越多的时间。

您已将此代码更改为：

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        

我们剩下的就是一个INPLACE_ADD，后面跟着一个商店。现在可以就地修改sTable，而不会产生更大的新string对象。

你会得到相同的速度差异：

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

这个故事的寓意是，你一开始就不应该使用字符串连接。从加载的其他字符串构建新字符串的正确方法是使用列表，然后使用str.join()

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