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

Question

在下面的时间里，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)