Question

我有两个函数返回生成器：

def f1():
    return (i for i in range(1000))

def f2():
    return ((yield i) for i in range(1000))

显然，从f2()返回的生成器的速度是f1()的两倍：

Python 3.6.5 (default, Apr  1 2018, 05:46:30) 
[GCC 7.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit, dis
>>> timeit.timeit("list(f1())", globals=globals(), number=1000)
0.057948426001530606
>>> timeit.timeit("list(f2())", globals=globals(), number=1000)
0.09769760200288147

我试图用dis看看发生了什么，但无济于事：

>>> dis.dis(f1)
  2           0 LOAD_CONST               1 (<code object <genexpr> at 0x7ffff7ec6d20, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('f1.<locals>.<genexpr>')
              4 MAKE_FUNCTION            0
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               3 (1000)
             10 CALL_FUNCTION            1
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 RETURN_VALUE
>>> dis.dis(f2)
  2           0 LOAD_CONST               1 (<code object <genexpr> at 0x7ffff67a25d0, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('f2.<locals>.<genexpr>')
              4 MAKE_FUNCTION            0
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               3 (1000)
             10 CALL_FUNCTION            1
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 RETURN_VALUE

显然，dis的结果是相同的。

那为什么从f1()返回生成器比从f2()返回生成器更快？调试此错误的正确方法是什么？显然dis在这种情况下会失败。

编辑1：

及时使用next()代替list()会反转结果（或者在某些情况下它们是相同的）：

>>> timeit.timeit("next(f1())", globals=globals(), number=10**6)
1.0030477920008707
>>> timeit.timeit("next(f2())", globals=globals(), number=10**6)
0.9416838550023385

编辑2：

显然，这是Python中的错误，已在3.8中修复。参见yield in list comprehensions and generator expressions

内部包含yield的生成器实际上产生两个值。

Answer 1

生成器表达式中的产量实际上是一个错误，如this related question中所述。

如果您想真正了解dis发生了什么，则需要对代码对象的co_const[0]进行反思，所以：

>>> dis.dis(f1.__code__.co_consts[1])
  2           0 LOAD_FAST                0 (.0)
        >>    3 FOR_ITER                11 (to 17)
              6 STORE_FAST               1 (i)
              9 LOAD_FAST                1 (i)
             12 YIELD_VALUE
             13 POP_TOP
             14 JUMP_ABSOLUTE            3
        >>   17 LOAD_CONST               0 (None)
             20 RETURN_VALUE
>>> dis.dis(f2.__code__.co_consts[1])
  2           0 LOAD_FAST                0 (.0)
        >>    3 FOR_ITER                12 (to 18)
              6 STORE_FAST               1 (i)
              9 LOAD_FAST                1 (i)
             12 YIELD_VALUE
             13 YIELD_VALUE
             14 POP_TOP
             15 JUMP_ABSOLUTE            3
        >>   18 LOAD_CONST               0 (None)
             21 RETURN_VALUE

因此，它产生两次。

Answer 2

也许是因为f2返回的生成器返回的元素数是原来的两倍。

只要看看会发生什么：

>>> def f2():
    return ((yield i) for i in range(10))
>>> g = f2()
>>> print([i for i in g])
[0, None, 1, None, 2, None, 3, None, 4, None, 5, None, 6, None, 7, None, 8, None, 9, None]

在生成器中使用yield会在每个实际项之后返回一个None元素。

Answer 3

您对f2()的表述是使我感到不寻常的第一件事。以大多数人会产生（双关语意）非常不同的结果的方式编写f2()：

import timeit

def f1():
    return (i for i in range(1000))

def f2():
    for i in range(1000):
        yield i

res1 = timeit.timeit("list(f1())", globals=globals(), number=1000)
print(res1)  # 0.05318646361085916
res2 = timeit.timeit("list(f2())", globals=globals(), number=1000)
print(res2)  # 0.05284952304875785

所以两者似乎同样快。

正如其他人在回答中所说，这可能与您的f2()返回两倍的元素这一事实有关。

Python：为什么一个生成器在内部具有“ yield”的情况下会比其他生成器快？

3 个答案: