为什么变量1 + =变量2比变量1 =变量1 +变量2快得多？

Question

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

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

sTable字符串在哪里。

我将其更改为：

sTable += '\n' + GetRow()

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

然后我将其更改为：

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

基于这些Python性能提示（仍为6秒）。

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

Answer 1

这+=与使用就地与+二进制添加无关。您没有告诉我们整个故事。您的原始版本连接了3个字符串，而不仅仅是两个：

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

Python尝试提供帮助并优化字符串连接；使用strobj += otherstrobj和时都可以使用strobj = strobj + otherstringobj，但是当涉及两个以上的字符串时，它将无法应用此优化。

Python中的字符串是不可变的 正常 ，但如果是左手字符串对象的任何其他引用 和 它反正是反弹，那么Python欺骗和 变异的字符串
。这样可以避免每次连接时都必须创建新的字符串，并且可以大大提高速度。

这在字节码评估循环中实现。无论使用时BINARY_ADD对两个字符串和使用时INPLACE_ADD对两个字符串，Python的代表级联到一个特殊的辅助函数string_concatenate()。为了能够通过更改字符串来优化串联，首先需要确保该字符串没有对其的其他引用。如果只堆栈和原始变量引用它，然后可以做到这一点，
并 在 接下来的 操作将取代原来的变量引用。

因此，如果对字符串只有2个引用，并且下一个运算符是STORE_FAST（设置局部变量），STORE_DEREF（设置由函数闭包引用的变量）或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后跟一个LOAD_NAME用于访问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

我们剩下的就是一家INPLACE_ADD商店。现在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

这个故事的寓意是，您不应该首先使用字符串连接。从其他字符串的负载中构建新字符串的正确方法是使用列表，然后使用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