如何检查迭代是否允许多次传递？

Question

在Python 3中,如何检查对象是否是容器(而不是只允许一次传递的迭代器)？

这是一个例子:

def renormalize(cont):
    '''
    each value from the original container is scaled by the same factor
    such that their total becomes 1.0
    '''
    total = sum(cont)
    for v in cont:
        yield v/total

list(renormalize(range(5))) # [0.0, 0.1, 0.2, 0.3, 0.4]
list(renormalize(k for k in range(5))) # [] - a bug!

显然,当renormalize函数接收到生成器表达式时,它不能按预期工作.它假设它可以多次遍历容器,而生成器只允许一次通过它.

理想情况下,我想这样做:

def renormalize(cont):
    if not is_container(cont):
      raise ContainerExpectedException
    # ...

我该如何实施is_container？

我想我可以检查参数是否为空,因为我们正在开始第二次通过它.但是这种方法不适用于更复杂的功能,在第二次传递开始的时候并不明显.此外,我宁愿将验证放在函数入口处,而不是放在函数内部(并在修改函数时将其移动).

我当然可以renormalize使用一次通过迭代器重写函数以正常工作.但这需要将输入数据复制到容器中.复制数以百万计的大型列表"以防它们不是列表"的性能影响是荒谬的.

编辑:我的原始示例使用了一个weighted_average函数:

def weighted_average(c):
    '''
    returns weighted average of a container c
    c contains values and weights in tuples
    weights don't need to sum up 1 (automatically renormalized)
    '''
    return sum((v * w for v, w in c)) / sum((w for v, w in c))

weighted_average([(0,1), (1,1)]) #0.5 
weighted_average([(k, 1) for k in range(2)]) #0.5
weighted_average((k, 1) for k in range(2)) #mistake

但这不是最好的例子,因为weighted_average使用单次传递的重写版本无论如何都可能更好:

def weighted_average(it):
    '''
    returns weighted average of an iterator it
    it yields values and weights in tuples
    weights don't need to sum up 1 (automatically renormalized)
    '''
    total_value = 0
    total_weight = 0
    for v, w in it:
        total_value += v
        total_weight += w
    return total_value / total_weight

Answer 1

尽管所有的可迭代对象都应该是 Collections.Iterable 的子类，但不幸的是，并非所有的迭代器都如此。这是基于对象实现的接口而不是它们“声明”的接口的答案。

简短回答：

正如您所说的“容器”，即可以多次迭代的列表/元组，而不是一个将被耗尽的生成器，通常会同时实现__iter__和__getitem__。因此你可以这样做：

>>> def is_container_iterable(o):
...     return hasattr(o, '__iter__') and hasattr(o, '__getitem__')
... 
>>> is_container_iterable([])
True
>>> is_container_iterable(())
True
>>> is_container_iterable({})
True
>>> is_container_iterable(range(5))
True
>>> is_container_iterable(iter([]))
False

长答案：

但是，您可以创建一个不会耗尽且不支持getitem 的迭代。例如，生成素数的函数。如果需要，您可以多次重复生成，但拥有检索第 1065 个素数的函数将需要大量计算，因此您可能不想支持这一点。:-)

那么有没有更“靠谱”的方式呢？

好吧，所有可迭代对象都将实现一个__iter__返回迭代器的函数。迭代器将有一个__next__函数。这就是迭代时使用的内容。重复调用__next__最终会耗尽迭代器。

因此，如果它有一个__next__函数，它就是一个迭代器，并且会被耗尽。

>>> def foo():
...    for x in range(5):
...        yield x
... 
>>> f = foo()
>>> f.__next__
<method-wrapper '__next__' of generator object at 0xb73c02d4>

还不是迭代器的迭代器不会有__next__函数，但会实现一个__iter__函数，该函数将返回一个迭代器：

>>> r = range(5)
>>> r.__next__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'range' object has no attribute '__next__'
>>> ri = iter(r)
>>> ri.__next__
<method-wrapper '__next__' of range_iterator object at 0xb73bef80>

因此，您可以检查该对象是否具有__iter__，但它不具有__next__。

>>> def is_container_iterable(o):
...     return hasattr(o, '__iter__') and not hasattr(o, '__next__')
... 
>>> is_container_iterable(())
True
>>> is_container_iterable([])
True
>>> is_container_iterable({})
True
>>> is_container_iterable(range(5))
True
>>> is_container_iterable(iter(range(5)))
False

迭代器还有一个__iter__函数，它将返回 self。

>>> iter(f) is f
True
>>> iter(r) is r
False
>>> iter(ri) is ri
True

因此，您可以执行以下检查变体：

>>> def is_container_iterable(o):
...     return iter(o) is not o
... 
>>> is_container_iterable([])
True
>>> is_container_iterable(())
True
>>> is_container_iterable({})
True
>>> is_container_iterable(range(5))
True
>>> is_container_iterable(iter([]))
False

如果您实现一个返回损坏的迭代器的对象，并且当您再次调用 iter() 时不会返回 self ，那么就会失败。但是你的（或第三方模块）代码实际上做错了事情。

它确实取决于创建一个迭代器，并因此调用对象__iter__，这在理论上可能会产生副作用，而上面的 hasattr 调用不应该有副作用。好的，所以它调用了可以有的getattribute 。但你可以这样解决这个问题：

>>> def is_container_iterable(o):
...     try:
...         object.__getattribute__(o, '__iter__')
...     except AttributeError:
...         return False
...     try:
...         object.__getattribute__(o, '__next__')
...     except AttributeError:
...         return True
...     return False
... 
>>> is_container_iterable([])
True
>>> is_container_iterable(())
True
>>> is_container_iterable({})
True
>>> is_container_iterable(range(5))
True
>>> is_container_iterable(iter(range(5)))
False

这是相当安全的，并且应该在所有情况下都可以工作，除非对象生成__next__或__iter__动态__getattribute__调用，但如果你这样做，你就疯了。:-)

本能地我更喜欢的版本是iter(o) is o，但我从来没有需要这样做，所以这不是基于经验。