Question

我正在尝试在python中编写一个程序来使用类似于在Haskell中编写素数程序时使用的逻辑生成素数（在他们的网站顶部找到的那个）。我写了以下两个生成器函数。

def integers():
    i=2
    while True:
        yield i
        i+=1

def primes(li):
    x=li
    while True:
        i=next(x)
        y=(j for j in x if %i!=0)
        yield i
        x=y

整数是数字2,3,4,5的生成器... 所以我的猜测是

a=primes(integers())

应该为素数给出一个生成器，但它没有提供任何排序。这是我得到的输出。

>>> next(a)
2
>>> next(a)
3
>>> next(a)
4
>>> next(a)
5
>>> next(a)
6

有什么建议吗？

Answer 1

嗯，你不会在Python中使用这种方法，你通常会避免递归。但这是一个有点等同的实现，在itertools：

的帮助下

>>> from itertools import count, chain
>>> def filter_primes(integers):
...     p = next(integers)
...     yield from chain([p], filter_primes(x for x in integers if x%p !=0))
...
>>> primes = filter_primes(count(2))
>>> next(primes)
2
>>> next(primes)
3
>>> next(primes)
5
>>> next(primes)
7
>>> next(primes)
11
>>> next(primes)
13
>>> next(primes)
17
>>> next(primes)
19
>>> next(primes)
23
>>> next(primes)
29

使用更多itertools帮助来获取前20个：

>>> primes = filter_primes(count(2))
>>> list(islice(primes, 20))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]
>>>

Answer 2

您的代码看起来很合理。它不起作用，因为它做出了令人惊讶的错误假设：生成器表达式关闭它使用的值。

相反，(j for j in x if j % i != 0)不会关闭i！这就是为什么在执行过程中稍后更改i 会更改过滤表达式。而不是针对连续素数构建一堆过滤器，整个生成器链会在每个步骤发生变化以进行过滤最后生成的值。

演示：

>>> v = 1
>>> gen = (x for x in itertools.count() if x % v == 0)
>>> print next(gen), next(gen), next(gen)
0 1 2
>>> v = 3
>>> print next(gen), next(gen), next(gen)
3 6 9

递归解决方案是一种明显的解决方法。

另一种方法是使用执行闭包的lambda（cf IIFE）：

def primes(source):
    while True:
        value = next(source)
        yield value
        source = (lambda v: (j for j in source if j % v != 0))(value)

这样可行，但它会产生与直接递归相同的开销，并且读起来更糟。但它不会花掉调用堆栈。

使用生成器在python中使用素数

2 个答案: