Question

在python 2.7.3中添加str类成员时遇到了一个奇怪的性能问题。我知道访问局部变量更快，但是，在下面的问题中，两个循环之间的速度差异超过100倍。访问a.accum_的那个开始快但速度慢，好像str iadd 是长度为str的O（n ^ 2）。

有谁知道原因？

# Fast ( < 1sec):
accum = str()
for ii in range(1000000):
    if (ii % 10000) == 0:
        print 'fast cnt', ii
    accum += 'zzzzz\n'

# Much slower ( > 5 mins):
class Foo:
    pass
a = Foo()
a.accum_ = str()
for ii in range(1000000):
    if (ii % 10000) == 0:
        print 'slow cnt', ii
    a.accum_ += 'zzzzz\n'

Answer 1

对于第一个例子，很明显它是单引用优化的情况（实际上有两个引用：一个来自对象本身，一个LOAD_FAST; unicode_concatenate将尝试将其减少为1使用此PyUnicode_Append函数将控制传递给unicode_modifiable之前由CPython执行：

static int
unicode_modifiable(PyObject *unicode)
{
    assert(_PyUnicode_CHECK(unicode));
    if (Py_REFCNT(unicode) != 1)
        return 0;
    if (_PyUnicode_HASH(unicode) != -1)
        return 0;
    if (PyUnicode_CHECK_INTERNED(unicode))
        return 0;
    if (!PyUnicode_CheckExact(unicode))
        return 0;
#ifdef Py_DEBUG
    /* singleton refcount is greater than 1 */
    assert(!unicode_is_singleton(unicode));
#endif
    return 1;
}

但在第二种情况下，实例数据存储在Python dict而不是简单变量中，因此事情变得与众不同。

a.accum_ += 'foo'

实际上需要预取a.accum_的值并将其存储到堆栈中。所以，现在字符串有至少三个引用：一个来自实例字典，一个来自DUP_TOP，另一个来自PyObject_GetAttr LOAD_ATTR。因此，Python无法优化这种情况，因为就地修改其中一个也会影响其他引用。

>>> class A:
    pass
...
>>> a = A()
>>> def func():
    a.str = 'spam'
    print a.str
    return '_from_func'
...
>>> a.str = 'foo'
>>> a.str += func()
spam

您希望此处的输出为'spam_from_func'，但它会有所不同，因为在调用a.str之前，Python存储了func()的原始值。

>>> a.str
'foo_from_func'

字节代码：

>>> import dis
>>> def func_class():
        a = Foo()
        a.accum = ''
        a.accum += 'zzzzz\n'
...
>>> dis.dis(func_class)
  2           0 LOAD_GLOBAL              0 (Foo)
              3 CALL_FUNCTION            0 (0 positional, 0 keyword pair)
              6 STORE_FAST               0 (a)

  3           9 LOAD_CONST               1 ('')
             12 LOAD_FAST                0 (a)
             15 STORE_ATTR               1 (accum)

  4          18 LOAD_FAST                0 (a)
             21 DUP_TOP
             22 LOAD_ATTR                1 (accum)
             25 LOAD_CONST               2 ('zzzzz\n')
             28 INPLACE_ADD
             29 ROT_TWO
             30 STORE_ATTR               1 (accum)
             33 LOAD_CONST               0 (None)
             36 RETURN_VALUE

请注意，此优化是在around 2004（CPython 2.4）中完成的，以防止用户访问慢a += b或a = a + b，因此它主要用于简单变量，仅当下一条指令为STORE_FAST（局部变量），STORE_DEREF（闭包）和{时才有效{1}}。这不是一般解决方案，the best way to do this in Python is to create a list and join its items using str.join。

CPython实现细节：如果STORE_NAME和s都是字符串，那么某些Python实现（如CPython）通常可以就地执行表单t或s = s + t的分配优化。什么时候适用时，此优化使二次运行时间更少有可能。此优化既是版本又是实现依赖。对于性能敏感的代码，最好使用 s += t方法，确保一致的线性连接跨版本和实现的性能。

Answer 2

Python字符串是不可变的，因此不能具有__iadd__方法。您在第一个示例中看到的是CPython解释器的微优化。在第一个例子中，解释器注意到它有一个局部变量，其引用计数为1.因此，解释器可以在适当的位置修改字符串。即使这违反了str的合同，但在执行该计划期间的任何时候都不会明显违反此合同。

在后一个例子中，这个微优化没有实现，这就是它如此缓慢的原因。看起来可以应用优化，所以我不确定它为什么没有被应用。

通常，如果构建字符串，请整理列表中的子字符串，然后使用str.join创建最终产品。

python成员str性能太慢

2 个答案: