Python 字符串连接内部细节

Question

假设我们有一个字符串列表，我们想通过连接该列表中的所有元素来创建一个字符串。像这样：

def foo(str_lst):
    result = ''
    for element in str_lst:
        result += element
    return result

由于字符串是不可变对象，我希望 python 创建一个新的 str 对象并在每次迭代时复制结果和元素的内容。它使O(M * N^2)的时间复杂度，M是每个元素的长度，N是列表的大小。

但是，我的实验表明它以线性时间运行。

N = 1000000 # 1 million
str_lst = ['a' for _ in range(N)]

foo(str_lst) # It takes around 0.5 seconds

N = 2000000 # 2 million
str_lst = ['a' for _ in range(N)]

foo(str_lst) # It takes around 1.0 seconds

N = 10000000 # 10 million
str_lst = ['a' for _ in range(N)]

foo(str_lst) # It takes around 5.3 seconds

我怀疑 python 在后台使用了类似 stringbuffer 的东西。因此，它不会在每次迭代时创建新对象。

现在考虑一个稍微不同的实现。唯一的区别是一项额外的任务。

def foo2(str_lst):
    result = ''
    for element in str_lst:
        result += element
        temp = result # new added line
    return result

我知道temp = result 行不会创建新对象。 temp 只是指向同一个对象。所以，这个小改动应该不会对性能产生太大影响。

N = 1000000 # 1 million
str_lst = ['a' for _ in range(N)]
foo(str_lst) # It takes around 0.5 seconds
foo2(str_lst) # It takes around 30 seconds

N = 2000000 # 2 million
str_lst = ['a' for _ in range(N)]
foo(str_lst) # It takes around 1 seconds
foo2(str_lst) # It takes around 129 seconds

但是，有很大的不同。看起来 foo2 函数是 O(N^2) 而 foo 是 O(N)。

我的问题是 python 如何在不破坏其他语言组件（如不可变对象分配）的情况下实现字符串连接的线性时间？以及那条额外的线如何对性能产生如此大的影响？我在 cpython 实现中搜索了一下，但找不到确切的位置。

更新

这是线路分析结果。

foo 函数的结果

Total time: 0.545577 s
File: <ipython-input-38-b9bb169e8fe0>
Function: foo at line 1

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
 1                                           def foo(str_lst):
 2         1          2.0      2.0      0.0      result = ''
 3   1000001     238820.0      0.2     43.8      for element in str_lst:
 4   1000000     306755.0      0.3     56.2          result += element
 5         1          0.0      0.0      0.0      return result

foo2 函数的结果

Total time: 30.6663 s
File: <ipython-input-40-34dd53670dd9>
Function: foo2 at line 1
Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
 1                                           def foo2(str_lst):
 2         1          2.0      2.0      0.0      result = ''
 3   1000001     299122.0      0.3      1.0      for element in str_lst:
 4   1000000   30033127.0     30.0     97.7          result += element
 5   1000000     413283.0      0.4      1.3          temp = result
 6         1          0.0      0.0      0.0      return result

不知何故，temp = result 行会影响result += element 行的性能。

Answer 1

使用另一个名称指向同一个对象会破坏优化。优化基本上是通过resizing the string object 并附加到位。如果您对该对象有多个引用，则无法在不影响另一个引用的情况下调整大小。由于字符串是不可变的，因此允许这样做将是实现的一个严重缺陷。

temp = result

增加了result 命名的字符串对象的引用计数，从而禁止优化。

在+=（最终转换为PyUnicode_Append）的情况下执行的检查的完整列表可以在unicode_modifiable 函数中看到。除其他外，它会检查对象的引用计数是否等于 1、它不是 inned 并且它不是字符串子类。

如果您想要更完整的列表，the if statement 中还有更多检查来保护此优化。

---

虽然不是您问题的基本问题，但未来的读者可能会对如何有效地执行字符串连接感到好奇。除了关于 S.O 的类似问题，Python FAQ also has an entry 对此。

Answer 2

实际上，您观察到的行为是由操作系统上 C 运行时的内存分配器的行为决定的。

CPython 有一个优化，如果 unicode-object 只有一个引用，它可以就地更改 - 没有人会注意到 unicode-object 暂时失去了它的不变性。请参阅我的回答 to this SO-question 了解更多详情。

在foo2 中，还有另一个对 unicode 对象 (temp) 的引用，它阻止了就地优化：就地更改它会破坏不变性，因为它可以通过temp 观察到.

但是，即使进行了就地优化，也不清楚为什么可以避免 O(n^2) 行为，因为 unicode 对象不会过度分配，因此必须在每次添加时扩展底层缓冲区，这天真地意味着一个副本每一步的全部内容（即O(n)）。

不过，大部分时间realloc（不同于malloc+copy）可以在O(1)中完成，因为如果分配的缓冲区后面的内存是空闲的，它可以用来扩展原来的无需复制。

---

一个有趣的细节是不能保证foo 将在O(n) 中运行：如果内存是碎片化的（例如在长时间运行的进程中）。 realloc 将无法在不复制数据的情况下扩展缓冲区，因此运行时间将变为 O(n^2)。

因此不应依赖这种优化来避免二次运行时间。