如何检查可迭代对象是否允许多次遍历？

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

最好的方法是使用抽象基类的结构：

def weighted_average(c):
    if not isinstance(c, collections.Sequence):
      raise ContainerExpectedException

Answer 2

你可以使用collections模块里定义的抽象基类，来检查it是否是collections.Iterator的一个实例。

if isinstance(it, collections.Iterator):
    # handle the iterator case

不过我个人觉得你写的那个友好的迭代器版本的加权平均，比用多个列表推导式和求和的版本要容易读得多。:-)

Answer 3

虽然所有可迭代的对象应该都要继承自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__方法，这个方法会返回自身。

>>> 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()时并不会返回自身，那这个检查就会失败。但这说明你的代码（或者第三方模块的代码）实际上是有问题的。

不过，这确实依赖于创建一个迭代器，因此需要调用对象的__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，但我从来没有需要这样做过，所以这并不是基于经验的。