Question

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

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

其中sTable是一个字符串。

我把它改为：

sTable += '\n' + GetRow()

我注意到该表现在出现在六秒。

然后我把它改为：

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

基于these Python performance tips（仍然是六秒）。

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

Answer 1

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

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

Python尝试帮助并优化字符串连接;在使用strobj += otherstrobj和strobj = strobj + otherstringobj时，但在涉及超过2个字符串时无法应用此优化。

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

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

因此，如果只有2个字符串引用，并且下一个运算符是STORE_FAST之一（设置局部变量），STORE_DEREF（设置由关闭的函数引用的变量）或{ {1}}（设置一个全局变量），受影响的变量当前引用相同的字符串，然后清除该目标变量以减少对堆栈的引用数量。

这就是为什么您的原始代码无法完全使用此优化的原因。表达式的第一部分是STORE_NAME，下一个操作是另一个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)

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

1 个答案: