如何在 Python 中制作重复生成器

Question

如何在 Python 中制作重复生成器，例如 xrange？例如，如果我这样做：

>>> m = xrange(5)
>>> print list(m)
>>> print list(m)

我两次得到相同的结果——数字 0..4。但是，如果我尝试使用相同的产量：

>>> def myxrange(n):
...   i = 0
...   while i < n:
...     yield i
...     i += 1
>>> m = myxrange(5)
>>> print list(m)
>>> print list(m)

第二次尝试迭代 m 时，我什么也没得到——一个空列表。

有没有一种简单的方法来创建像 xrange 这样的重复生成器，或者生成器理解？我找到了a workaround on a Python tracker issue，它使用装饰器将生成器转换为迭代器。每次您开始使用它时都会重新启动，即使您上次没有使用所有值，就像 xrange 一样。我也想出了自己的装饰器，基于相同的想法，它实际上返回一个生成器，但可以在抛出 StopIteration 异常后重新启动：

@decorator.decorator
def eternal(genfunc, *args, **kwargs):
  class _iterable:
    iter = None
    def __iter__(self): return self
    def next(self, *nargs, **nkwargs):
      self.iter = self.iter or genfunc(*args, **kwargs):
      try:
        return self.iter.next(*nargs, **nkwargs)
      except StopIteration:
        self.iter = None
        raise
  return _iterable()

有没有更好的方法来解决这个问题，只使用 yield 和/或生成器理解？还是 Python 内置的东西？所以我不需要推出自己的类和装饰器？

更新

comment by u0b34a0f6ae 指出了我误会的根源：

xrange(5) 不返回迭代器，它创建一个 xrange 对象。 xrange 对象可以多次迭代，就像字典一样。

我的“永恒”函数完全是错误的树，就像一个迭代器/生成器（__iter__ 返回自身）而不是一个集合/xrange（__iter__ 返回一个新迭代器）。

Answer 1

不直接。允许生成器用于实现协同程序、资源管理等的部分灵活性在于它们始终是一次性的。一旦运行，生成器就不能重新运行。您必须创建一个新的生成器对象。

但是，您可以创建自己的类来覆盖__iter__()。它就像一个可重复使用的生成器：

def multigen(gen_func):
    class _multigen(object):
        def __init__(self, *args, **kwargs):
            self.__args = args
            self.__kwargs = kwargs
        def __iter__(self):
            return gen_func(*self.__args, **self.__kwargs)
    return _multigen

@multigen
def myxrange(n):
   i = 0
   while i < n:
     yield i
     i += 1
m = myxrange(5)
print list(m)
print list(m)

Answer 2

使用 itertools 超级简单。

import itertools

alist = [1,2,3]
repeatingGenerator = itertools.cycle(alist)

print(next(generatorInstance)) #=> yields 1
print(next(generatorInstance)) #=> yields 2
print(next(generatorInstance)) #=> yields 3
print(next(generatorInstance)) #=> yields 1 again!

Answer 3

如果你写了很多这些，John Millikin 的答案是最干净的。

但如果你不介意添加 3 行和一些缩进，你可以在没有自定义装饰器的情况下完成。这构成了 2 个技巧：

1. [通常有用：] 您可以轻松地使类可迭代，而无需实现 .next() - 只需为__iter__(self) 使用生成器！

2. 您可以在函数内定义一次性类，而不是使用构造函数。

=>

def myxrange(n):
    class Iterable(object):
        def __iter__(self):
            i = 0
            while i < n:
                yield i
                i += 1
    return Iterable()

小字：我没有测试性能，生成这样的类可能是浪费。但是很棒;-)

Answer 4

我认为答案是“不”。我可能错了。可能是在 2.6 中您可以使用生成器做一些时髦的新事情，包括参数和异常处理，这将允许您想要的东西。但这些功能主要用于实现半延续。

为什么你不想拥有自己的类或装饰器？为什么要创建一个返回生成器而不是类实例的装饰器？

Answer 5

您可以使用第三方工具 more_itertools.seekable 重置迭代器。

通过> pip install more_itertools安装。

import more_itertools as mit


def myxrange(n):
    """Yield integers."""
    i = 0
    while i < n:
        yield i
        i += 1

m = mit.seekable(myxrange(5))
print(list(m))
m.seek(0)                                              # reset iterator
print(list(m))
# [0, 1, 2, 3, 4]
# [0, 1, 2, 3, 4]

注意：在推进迭代器时内存消耗会增加，所以要小心包装大型迭代器。

Answer 6

使用这个解决方案：

>>> myxrange_ = lambda x: myxrange(x)
>>> print list(myxrange_(5))
... [0, 1, 2, 3, 4]
>>> print list(myxrange_(5))
... [0, 1, 2, 3, 4]

>>> for number in myxrange_(5):
...     print number
... 
    0
    1
    2
    3
    4
>>>

并带有装饰器：

>>> def decorator(generator):
...     return lambda x: generator(x)
...
>>> @decorator
>>> def myxrange(n):
...   i = 0
...   while i < n:
...     yield i
...     i += 1
...
>>> print list(myxrange(5))
... [0, 1, 2, 3, 4]
>>> print list(myxrange(5))
... [0, 1, 2, 3, 4]
>>>

简单。