Python 为什么从串联列表创建集合比使用“.update”更快？

在试图回答这个问题时，我做了一些性能分析，得出了一个有点令人惊讶的结论

使用

令我惊讶的是，

set（A+B+C）

是最快的，尽管它创建了一个包含3000000个元素的中间列表

.update

和

itertools.chain

都比较慢，即使它们都不复制任何列表

这是怎么回事

---

编辑：在第二台机器（OS X 10.10.5、Python 2.7.10、2.5GHz Core i7）上，我运行了以下脚本（向前和向后运行测试以避免排序效果）：

---

现在

set（A+B+C）

显然更快了，结果也相当稳定——很难把这仅仅归结为测量误差。反复运行此脚本会产生类似的结果。

在我的Win 7 SP1机器上，我得到的结果与您不同，这并不令人惊讶，因为我的Win 7 SP1机器使用了与Python 2.7.10类似的处理器，其中

set（a+B+C）

似乎是实现这一目标最慢的方法。在重新启用垃圾收集和Python 3.4.3的情况下也获得了类似的结果

我使用了自己的基于

timeit

的性能评估试验台，得到了以下结果：

10 loops, best of 3: 579 msec per loop
10 loops, best of 3: 726 msec per loop
10 loops, best of 3: 775 msec per loop
10 loops, best of 3: 761 msec per loop
10 loops, best of 3: 737 msec per loop
10 loops, best of 3: 555 msec per loop

最快到最慢的执行速度（Python 2.7.10）
（10次执行，最好3次重复）
组（A）；s、 更新（B）；s、 更新（C）：4.787919秒，相对速度1.00x，速度慢0.00%
设置（A）。更新（B，C）：6.463666秒，相对速度1.35倍，慢35.00%
设置（itertools.链（A、B、C））：6.743028秒，相对速度1.41x，慢40.83%
设定（A+B+C）：8.030483秒，相对速度1.68x，速度慢67.72%

基准代码：

from __future__ import print_function
import sys
from textwrap import dedent
import timeit

N = 10  # Number of executions of each "algorithm"
R = 3  # number of Repeations of executions

# common setup for all algorithms (not timed)
setup = dedent("""
    import itertools
    import gc
    import random

    try:
        xrange
    except NameError:
        xrange = range

    random.seed(0)
    n = 1000000  # number of elements in each list
    A = [random.randrange(1<<30) for _ in xrange(n)]
    B = [random.randrange(1<<30) for _ in xrange(n)]
    C = [random.randrange(1<<30) for _ in xrange(n)]

    # gc.enable()  # to (re)enable garbage collection if desired
""")

algorithms = {
    "set(A+B+C)": dedent("""
        s = set(A+B+C)
    """),

    "set(A); s.update(B); s.update(C)": dedent("""
        s = set(A); s.update(B); s.update(C)
    """),

    "set(itertools.chain(A,B,C))": dedent("""
        s = set(itertools.chain(A,B,C))
        """),

    "set(A).update(B,C)": dedent("""
        s = set(A).update(B,C)
        """),
}

# execute and time algorithms, collecting results
timings = [
    (label,
     min(timeit.repeat(algorithms[label], setup=setup, repeat=R, number=N)),
    ) for label in algorithms
]

print('fastest to slowest execution speeds (Python {}.{}.{})\n'.format(
        *sys.version_info[:3]),
        '  ({:,d} executions, best of {:d} repetitions)\n'.format(N, R))

longest = max(len(timing[0]) for timing in timings)  # length of longest label
ranked = sorted(timings, key=lambda t: t[1])  # ascending sort by execution time
fastest = ranked[0][1]
for timing in ranked:
    print("{:>{width}} : {:9.6f} secs, rel speed {:4.2f}x, {:6.2f}% slower".
            format(timing[0], timing[1], round(timing[1]/fastest, 2),
                   round((timing[1]/fastest - 1) * 100, 2), width=longest))

from\uuuuu future\uuuuu导入打印功能
导入系统
从textwrap导入dedent
导入时间信息
N=10#每个“算法”的执行次数
R=3#重复执行次数
#所有算法的通用设置（非定时）
setup=dedent（“”）
进口itertools
导入gc
随机输入
尝试：
润智
除名称错误外：
xrange=范围
随机种子（0）
n=1000000#每个列表中的元素数
A=[random.randrange（1我唯一能做的猜测是，第一种情况是在一个已知长度的列表中传递，因此可能集合构造可以更明智地选择初始的底层内存需求，而不是另外两种情况，即集合被创建并调整两次大小（第二种情况）或者使用迭代器创建，在迭代器中它可能会在内部调整多次大小。除非它们更改
set\u init
，否则它似乎不是这样工作的。只需直接调用
set\u update\u internal
，它只会在元素上循环。（我会从
hg.python.org
中提取，但目前该服务器似乎已关闭）相关：无法在OS X上的Python2.7上复制；所有三个测试都显示出相当大的变化，并且没有一个是明显的赢家。只有10次重复和非常长的运行时间（10次测试约8秒），您捕获了大量噪音。当我将
n
降低到1000，并重复10k次时，
set.update（）
version以合理的一致性获胜。
SETUP='import itertools
import random
n=1000000
random.seed(0)
A = [random.randrange(1<<30) for _ in xrange(n)]
B = [random.randrange(1<<30) for _ in xrange(n)]
C = [random.randrange(1<<30) for _ in xrange(n)]'

python -m timeit -s "$SETUP" 'set(A+B+C)'
python -m timeit -s "$SETUP" 's = set(A); s.update(B); s.update(C)'
python -m timeit -s "$SETUP" 's = set(itertools.chain(A,B,C))'

python -m timeit -s "$SETUP" 's = set(itertools.chain(A,B,C))'
python -m timeit -s "$SETUP" 's = set(A); s.update(B); s.update(C)'
python -m timeit -s "$SETUP" 'set(A+B+C)'

10 loops, best of 3: 579 msec per loop
10 loops, best of 3: 726 msec per loop
10 loops, best of 3: 775 msec per loop
10 loops, best of 3: 761 msec per loop
10 loops, best of 3: 737 msec per loop
10 loops, best of 3: 555 msec per loop

from __future__ import print_function
import sys
from textwrap import dedent
import timeit

N = 10  # Number of executions of each "algorithm"
R = 3  # number of Repeations of executions

# common setup for all algorithms (not timed)
setup = dedent("""
    import itertools
    import gc
    import random

    try:
        xrange
    except NameError:
        xrange = range

    random.seed(0)
    n = 1000000  # number of elements in each list
    A = [random.randrange(1<<30) for _ in xrange(n)]
    B = [random.randrange(1<<30) for _ in xrange(n)]
    C = [random.randrange(1<<30) for _ in xrange(n)]

    # gc.enable()  # to (re)enable garbage collection if desired
""")

algorithms = {
    "set(A+B+C)": dedent("""
        s = set(A+B+C)
    """),

    "set(A); s.update(B); s.update(C)": dedent("""
        s = set(A); s.update(B); s.update(C)
    """),

    "set(itertools.chain(A,B,C))": dedent("""
        s = set(itertools.chain(A,B,C))
        """),

    "set(A).update(B,C)": dedent("""
        s = set(A).update(B,C)
        """),
}

# execute and time algorithms, collecting results
timings = [
    (label,
     min(timeit.repeat(algorithms[label], setup=setup, repeat=R, number=N)),
    ) for label in algorithms
]

print('fastest to slowest execution speeds (Python {}.{}.{})\n'.format(
        *sys.version_info[:3]),
        '  ({:,d} executions, best of {:d} repetitions)\n'.format(N, R))

longest = max(len(timing[0]) for timing in timings)  # length of longest label
ranked = sorted(timings, key=lambda t: t[1])  # ascending sort by execution time
fastest = ranked[0][1]
for timing in ranked:
    print("{:>{width}} : {:9.6f} secs, rel speed {:4.2f}x, {:6.2f}% slower".
            format(timing[0], timing[1], round(timing[1]/fastest, 2),
                   round((timing[1]/fastest - 1) * 100, 2), width=longest))