在计算机上有两种方法来获取“某物”的长度。

第一种方法是存储一个计数——这需要任何接触文件/数据的东西来修改它(或者一个只公开接口的类——但归根结底是一样的)。

另一种方法是遍历它并计算它有多大。

假设，您希望在不遍历的情况下计算项的数量，这样迭代器就不会耗尽，稍后可以再次使用它。这是可能的复制或深度复制

import copy

def get_iter_len(iterator):
    return sum(1 for _ in copy.copy(iterator))

###############################################

iterator = range(0, 10)
print(get_iter_len(iterator))

if len(tuple(iterator)) > 1:
    print("Finding the length did not exhaust the iterator!")
else:
    print("oh no! it's all gone")

输出是“查找长度没有耗尽迭代器!”

可选的(并且不明智的)，你可以像下面这样为内置的len函数添加阴影:

import copy

def len(obj, *, len=len):
    try:
        if hasattr(obj, "__len__"):
            r = len(obj)
        elif hasattr(obj, "__next__"):
            r = sum(1 for _ in copy.copy(obj))
        else:
            r = len(obj)
    finally:
        pass
    return r

我认为有必要建立一个微观基准来比较这里提到的不同方法的运行时间。

免责声明:我使用simple_benchmark(我编写的库)进行基准测试，还包括iteration_utilities。Count_items(由我编写的第三方库中的函数)。

为了提供更有区别的结果，我做了两个基准测试，一个只包括不构建中间容器的方法，另一个包括以下方法:

from simple_benchmark import BenchmarkBuilder
import more_itertools as mi
import iteration_utilities as iu

b1 = BenchmarkBuilder()
b2 = BenchmarkBuilder()

@b1.add_function()
@b2.add_function()
def summation(it):
    return sum(1 for _ in it)

@b1.add_function()
def len_list(it):
    return len(list(it))

@b1.add_function()
def len_listcomp(it):
    return len([_ for _ in it])

@b1.add_function()
@b2.add_function()
def more_itertools_ilen(it):
    return mi.ilen(it)

@b1.add_function()
@b2.add_function()
def iteration_utilities_count_items(it):
    return iu.count_items(it)

@b1.add_arguments('length')
@b2.add_arguments('length')
def argument_provider():
    for exp in range(2, 18):
        size = 2**exp
        yield size, [0]*size

r1 = b1.run()
r2 = b2.run()

import matplotlib.pyplot as plt

f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=[15, 18])
r1.plot(ax=ax2)
r2.plot(ax=ax1)
plt.savefig('result.png')

结果如下:

它使用log-log-轴，以便可以检查所有范围(小值，大值)。由于这些图是用于定性比较的，因此实际值并不太有趣。一般来说，y轴(垂直)表示时间，x轴(水平)表示输入“可迭代对象”中的元素数量。纵轴上越低表示越快。

上图显示了不使用中间列表的方法。这表明iteration_utilities方法是最快的，其次是more_itertools，最慢的是使用sum(1 for _ in iterator)。

下面的图还包括在中间列表上使用len()的方法，一次使用列表，一次使用列表推导式。使用len(list)的方法在这里是最快的，但与iteration_utilities方法的区别几乎可以忽略不计。使用理解式的方法比直接使用列表的方法慢得多。

总结

这里提到的任何方法都依赖于输入的长度，并且迭代遍历可迭代对象中的每个元素。没有迭代就无法获得长度(即使迭代是隐藏的)。

如果你不想要第三方扩展，那么使用len(list(iterable))绝对是测试过的方法中最快的方法，但是它会生成一个中间列表，可能会使用更多的内存。

如果你不介意额外的包，那么iteration_utilities。Count_items几乎和len(list(…))函数一样快，但不需要额外的内存。

但是需要注意的是，微基准测试使用列表作为输入。基准测试的结果可能不同，这取决于您想要获取的迭代对象的长度。我还用range和一个简单的生成器表达式进行了测试，趋势非常相似，但我不能排除时间不会因输入类型而改变。

这在理论上是不可能的:事实上，这就是“停止问题”。

证明

相反，假设可以使用函数len(g)来确定任何生成器g的长度(或无限长度)。

对于任何程序P，现在让我们将P转换为生成器g(P): 对于P中的每个返回点或出口点，产生一个值而不是返回它。

如果len(g(P)) ==无穷大，P不会停止。

这解决了暂停问题，这是不可能的，见维基百科。矛盾。

因此，如果不对泛型生成器进行迭代(==实际运行整个程序)，就不可能对其元素进行计数。

更具体地说，考虑

def g():
    while True:
        yield "more?"

长度是无限的。这样的发生器有无穷多个。

虽然一般情况下不可能按照要求去做，但在迭代了多少项之后，对它们进行迭代的次数进行计数通常仍然是有用的。为此，您可以使用jaraco.itertools.Counter或类似的方法。下面是一个使用python3和rwt加载包的例子。

$ rwt -q jaraco.itertools -- -q
>>> import jaraco.itertools
>>> items = jaraco.itertools.Counter(range(100))
>>> _ = list(counted)
>>> items.count
100
>>> import random
>>> def gen(n):
...     for i in range(n):
...         if random.randint(0, 1) == 0:
...             yield i
... 
>>> items = jaraco.itertools.Counter(gen(100))
>>> _ = list(counted)
>>> items.count
48

不能(除非特定迭代器的类型实现了一些特定的方法，使之成为可能)。

通常，只能通过使用迭代器来计数迭代器项。最有效的方法之一:

import itertools
from collections import deque

def count_iter_items(iterable):
    """
    Consume an iterable not reading it into memory; return the number of items.
    """
    counter = itertools.count()
    deque(itertools.izip(iterable, counter), maxlen=0)  # (consume at C speed)
    return next(counter)

(对于Python 3。X替换itertools。Izip with zip)。