假设我们有一个字符串列表，并且我们想通过串联此列表中的所有元素来创建一个字符串。像这样：
Android Studio 3.3.1
Build #AI-182.5107.16.33.5264788, built on January 29, 2019
JRE: 1.8.0_152-release-1248-b01 amd64
JVM: OpenJDK 64-Bit Server VM by JetBrains s.r.o
Linux 4.15.0-45-generic
由于字符串是不可变的对象，我希望python创建一个新的str对象并在每次迭代时复制result和element的内容。它使def foo(str_lst):
result = ''
for element in str_lst:
result += element
return result
的时间变得很复杂，M是每个元素的长度，N是列表的大小。
但是，我的实验表明它可以线性运行。
O(M * N^2)我怀疑python在后台使用了像stringbuffer之类的东西。因此，它不会在每次迭代时都创建新对象。
现在考虑稍微不同的实现。唯一的区别是一个额外的任务。
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
我知道def foo2(str_lst):
result = ''
for element in str_lst:
result += element
temp = result # new added line
return result
行不会创建新对象。 temp = result仅指向同一对象。因此，这个小变化不会对性能产生太大影响。
temp但是，有很大的不同。看起来foo2函数是O（N ^ 2）而foo是O（N）。
我的问题是python如何在字符串连接中实现线性时间而不破坏其他语言组件（如不可变对象分配）？多余的线对性能有多大影响？我在cpython实现中进行了一些搜索，但找不到确切的位置。
更新
这是行分析结果。
foo函数的结果
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函数的结果
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
以某种方式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行的性能。
答案 0 :(得分：6)
使用另一个名称指向相同的对象会破坏优化。优化基本上是通过resizing the string object并将其附加到位来实现的。如果对该对象有多个引用，则不能在不影响另一引用的情况下调整大小。由于字符串是不可变的，因此，这将是实现的严重缺陷。
temp = result
增加了result命名的字符串对象的引用计数，从而阻止了优化。
在PyUnicode_Append函数中可以看到在+=情况下执行的检查的完整列表（最终转换为unicode_modifiable）。除其他事项外，它还会检查对象的引用计数是否等于1，没有被intern并且不是字符串子类。
如果您需要更详尽的清单，the if statement中还有另外几笔支票可以保护这种优化。
尽管这不是您问题的基本问题，但未来的读者可能会对如何有效执行字符串连接感到好奇。除了有关S.O的类似问题外，Python FAQ also has an entry还在这里。
答案 1 :(得分：3)
实际上，您正在观察的行为取决于操作系统上C运行时的内存分配器的行为。
CPython进行了优化，如果unicode对象只有一个引用，则可以就地更改-没有人会注册unicode对象暂时失去其不变性。有关更多详细信息，请参见我的答案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)。
因此，不应依赖此优化来避免二次运行时间。