在Python中获取迭代器中的元素数量

Question

有没有一种有效的方法可以知道Python中迭代器中有多少元素，一般情况下，没有遍历每个元素并进行计数？

Answer 1

此代码应该有效：

>>> iter = (i for i in range(50))
>>> sum(1 for _ in iter)
50

虽然它会迭代每个项目并计算它们，但这是最快的方法。

它也适用于迭代器没有项目的时候：

>>> sum(1 for _ in range(0))
0

Answer 2

没有。这是不可能的。

示例：

import random

def gen(n):
    for i in xrange(n):
        if random.randint(0, 1) == 0:
            yield i

iterator = gen(10)

iterator的长度在您迭代之前是未知的。

Answer 3

不，任何方法都需要您解决每个结果。你可以做到

iter_length = len(list(iterable))

但是在无限迭代器上运行它当然永远不会返回。它也将消耗迭代器，如果你想使用它，它将需要重置。

告诉我们您尝试解决的真正问题可能有助于我们找到更好的方法来实现您的实际目标。

编辑：使用list()会立即将整个可迭代内容读入内存，这可能是不可取的。另一种方法是做

sum(1 for _ in iterable)

正如另一个人发布的那样。这样可以避免将其留在记忆中。

Answer 4

你不能（除了特定迭代器的类型实现了一些使它成为可能的特定方法）。

通常，您只能通过使用迭代器来计算迭代器项。可能是最有效的方法之一：

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替换为zip）。

Answer 5

有点儿。您可以检查__length_hint__方法，但要注意（至少在Python 3.4中，正如gsnedders帮助指出的那样）它是undocumented implementation detail（following message in thread） ，这可能很好地消失或召唤鼻子恶魔。

否则，不。迭代器只是一个只暴露next()方法的对象。您可以根据需要多次调用它，它们可能会或可能不会最终提升StopIteration。幸运的是，这种行为大部分时间对编码人员来说是透明的。 ：）

Answer 6

迭代器只是一个对象，它有一个指向下一个要被某种缓冲区或流读取的对象的指针，它就像一个LinkedList，在你迭代它们之前你不知道你有多少东西。迭代器应该是高效的，因为他们只是通过引用而不是使用索引来告诉你接下来是什么（但是你看到你失去了查看接下来有多少条目的能力）。

Answer 7

我喜欢这个cardinality包，它非常轻量级，并尝试使用可用的最快实现，具体取决于迭代。

用法：

>>> import cardinality
>>> cardinality.count([1, 2, 3])
3
>>> cardinality.count(i for i in range(500))
500
>>> def gen():
...     yield 'hello'
...     yield 'world'
>>> cardinality.count(gen())
2

实际count()实施如下：

def count(iterable):
    if hasattr(iterable, '__len__'):
        return len(iterable)

    d = collections.deque(enumerate(iterable, 1), maxlen=1)
    return d[0][0] if d else 0

Answer 8

关于你原来的问题，答案仍然是通常无法知道Python中迭代器的长度。

鉴于你的问题是由pysam库的应用推动的，我可以给出一个更具体的答案：我是PySAM的贡献者，而最终的答案是SAM / BAM文件没有提供准确的对齐计数读取。这个信息也不容易从BAM索引文件中获得。最好的方法是在读取多个对齐之后使用文件指针的位置估计对齐的近似数量，并根据文件的总大小进行外推。这足以实现进度条，但不是在恒定时间内计算对齐的方法。

Answer 9

快速基准：

import collections
import itertools

def count_iter_items(iterable):
    counter = itertools.count()
    collections.deque(itertools.izip(iterable, counter), maxlen=0)
    return next(counter)

def count_lencheck(iterable):
    if hasattr(iterable, '__len__'):
        return len(iterable)

    d = collections.deque(enumerate(iterable, 1), maxlen=1)
    return d[0][0] if d else 0

def count_sum(iterable):           
    return sum(1 for _ in iterable)

iter = lambda y: (x for x in xrange(y))

%timeit count_iter_items(iter(1000))
%timeit count_lencheck(iter(1000))
%timeit count_sum(iter(1000))

结果：

10000 loops, best of 3: 35.4 µs per loop
10000 loops, best of 3: 40.2 µs per loop
10000 loops, best of 3: 50.7 µs per loop

即。简单的count_iter_items是要走的路。

Answer 10

有两种方法可以在计算机上获得“某事”的长度。

第一种方法是存储一个计数 - 这需要触及文件/数据的任何东西来修改它（或者只是暴露接口的类 - 但它归结为同样的东西）。

另一种方法是迭代它并计算它有多大。

Answer 11

那么，对于那些想要了解该讨论摘要的人。使用以下方法计算5000万个生成器表达式的最终得分：

• len(list(gen))，
• len([_ for _ in gen])，
• sum(1 for _ in gen),
• ilen(gen)（来自more_itertool），
• reduce(lambda c, i: c + 1, gen, 0)，

按执行性能（包括内存消耗）排序，会让你感到惊讶：

```

1：test_list.py:8:0.492 KiB

gen = (i for i in data*1000); t0 = monotonic(); len(list(gen))

（'list，sec'，1.9684218849870376）

2：test_list_compr.py:8:0.867 KiB

gen = (i for i in data*1000); t0 = monotonic(); len([i for i in gen])

（'list_compr，sec'，2.5885991149989422）

3：test_sum.py:8:0.859 KiB

gen = (i for i in data*1000); t0 = monotonic(); sum(1 for i in gen); t1 = monotonic()

（'sum，sec'，3.441088170016883）

4：more_itertools / more.py:413：1.266 KiB

d = deque(enumerate(iterable, 1), maxlen=1)

test_ilen.py:10: 0.875 KiB
gen = (i for i in data*1000); t0 = monotonic(); ilen(gen)

（'ilen，sec'，9.812256851990242）

5：test_reduce.py:8:0.859 KiB

gen = (i for i in data*1000); t0 = monotonic(); reduce(lambda counter, i: counter + 1, gen, 0)

（'reduce，sec'，13.436614598002052） ```

因此，len(list(gen))是最常见且耗能较少的内存消耗品

Answer 12

一种简单的方法是使用 set() 内置函数：

iter = zip([1,2,3],['a','b','c'])
print(len(set(iter)) # set(iter) = {(1, 'a'), (2, 'b'), (3, 'c')}
Out[45]: 3

或

iter = range(1,10)
print(len(set(iter)) # set(iter) = {1, 2, 3, 4, 5, 6, 7, 8, 9}
Out[47]: 9

Answer 13

我认为有一个微基准比较这里提到的不同方法的运行时间是值得的。

免责声明：我将 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-axis 以便可以检查所有范围（小值、大值）。由于这些图用于定性比较，因此实际值不太有趣。通常，y 轴（垂直）表示时间，x 轴（水平）表示输入“可迭代”中的元素数量。纵轴越低表示速度越快。

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

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

总结

这里提到的任何方法都显示了对输入长度的依赖，并迭代了可迭代对象中的任何元素。没有迭代就没有办法得到长度（即使迭代是隐藏的）。

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

如果您不介意额外的包，那么 iteration_utilities.count_items 几乎与 len(list(...)) 函数一样快，但不需要额外的内存。

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

Answer 14

虽然一般不可能做出被要求的事情，但是在 之后计算有多少项被重复过来仍然很有用。迭代了他们。为此，您可以使用jaraco.itertools.Counter或类似内容。这是使用Python 3和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

Answer 15

def count_iter(iter):
    sum = 0
    for _ in iter: sum += 1
    return sum

Answer 16

这违反了迭代器的定义，迭代器是指向对象的指针，以及有关如何到达下一个对象的信息。

迭代器不知道在终止之前它能够迭代多少次。这可能是无限的，所以无限可能是你的答案。

Answer 17

通常的做法是将此类信息放在文件头中，并让pysam为您提供访问权限。我不知道格式，但您检查了API吗？

正如其他人所说，你无法知道迭代器的长度。

Answer 18

大概，您希望不迭代地对项目数进行计数，以免迭代器用尽，以后再使用它。 copy或deepcopy

可以实现

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")

输出为“ Finding the length did not exhaust the iterator!”

（可选）（并且不建议），您可以按如下所示隐藏内置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