python - 如何检查可迭代对象是否允许多次通过？

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 的子类，但不幸的是，并不是所有的都可以。这是基于对象实现的接口(interface)而不是它们“声明的”的答案。

简答:

你所说的“容器”，即一个可以多次迭代的列表/元组，而不是一个会耗尽的生成器，通常会同时实现 __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的iterable。例如，生成质数的函数。如果需要，您可以多次重复生成，但是拥有检索第 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

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

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