使用集合文字可以更快地设置包含

Question

在下面的I time中10_000_000检查10是否在{0, ..., 9}

在第一个检查中，我使用一个中间变量，在第二个检查中，我使用一个文本

import timeit

x = 10
s = set(range(x))
number = 10 ** 7

stmt = f'my_set = {s} ; {x} in my_set'
print(f'eval "{stmt}"')
print(timeit.timeit(stmt=stmt, number=number))

stmt = f'{x} in {s}'
print(f'eval "{stmt}"')
print(timeit.timeit(stmt=stmt, number=number))

输出：

eval "my_set = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} ; 10 in my_set"
1.2576093
eval "10 in {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}"
0.20336140000000036

为什么第二个要快得多（大约是5-6倍）？Python是否执行了一些运行时优化，例如，如果对文本进行了包含检查？或者，这可能是由于垃圾收集（因为它是一个字面上的python垃圾，在使用后立即收集）

Answer 1

在第一个测试中，您没有测试相同的两件事情，除了成员资格测试之外，您还对两个任务和查找进行计时：

In [1]: import dis
   ...: x = 10
   ...: s = set(range(x))

In [2]: dis.dis("x in s")
  1           0 LOAD_NAME                0 (x)
              2 LOAD_NAME                1 (s)
              4 CONTAINS_OP              0
              6 RETURN_VALUE

In [3]: dis.dis("my_set = s; x in my_set")
  1           0 LOAD_NAME                0 (s)
              2 STORE_NAME               1 (my_set)
              4 LOAD_NAME                2 (x)
              6 LOAD_NAME                1 (my_set)
              8 CONTAINS_OP              0
             10 POP_TOP
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

# By request
In [4]: dis.dis("s = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 10 in s")
  1           0 BUILD_SET                0
              2 LOAD_CONST               0 (frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}))
              4 SET_UPDATE               1
              6 STORE_NAME               0 (s)
              8 LOAD_CONST               1 (10)
             10 LOAD_NAME                0 (s)
             12 CONTAINS_OP              0
             14 POP_TOP
             16 LOAD_CONST               2 (None)
             18 RETURN_VALUE

使用文本和x in s之间的实际区别在于后者需要在全局中执行查找，即，区别是LOAD_NAME与LOAD_CONST：

In [5]: dis.dis("10 in {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}")
  1           0 LOAD_CONST               0 (10)
              2 LOAD_CONST               1 (frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}))
              4 CONTAINS_OP              0
              6 RETURN_VALUE

时代：

In [6]: %timeit x in s
28.5 ns ± 0.792 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit 10 in {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
20.3 ns ± 0.384 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)