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


Getting number of elements in an iterator in Python

通常，是否有一种有效的方法可以知道Python的迭代器中有多少个元素，而无需遍历每个元素并进行计数？

相关讨论

此代码应工作：

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

尽管它确实遍历每个项目并计算它们，但这是最快的方法。

当迭代器没有项目时，它也适用：

1
2
>>> sum(1 for _ in range(0))
0
相关讨论

不行，不可能

例：

1
2
3
4
5
6
7
8
import random

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

iterator = gen(10)

iterator的长度是未知的，直到您遍历为止。

相关讨论

不，任何方法都将要求您解决所有结果。你可以做

1
iter_length = len(list(iterable))

但是在无限迭代器上运行该函数当然永远不会返回。它还将消耗迭代器，并且如果要使用其内容，则需要将其重置。

告诉我们您要解决的实际问题可能会帮助我们找到实现目标的更好方法。

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

1
sum(1 for _ in iterable)

如另一个人所张贴。这样可以避免将其保留在内存中。

相关讨论

您不能(除非特定迭代器的类型实现了某些特定方法才能实现)。

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

1
2
3
4
5
6
7
8
9
10
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)。

相关讨论

均田。您可以检查__length_hint__方法，但要警告(至少gsnedders指出，至少在Python 3.4之前)，这是一个未记录的实现细节(跟随消息中的消息)，可能会消失或召唤鼻恶魔。

否则，不会。迭代器只是一个仅公开next()方法的对象。您可以根据需要多次调用它，它们最终可能会或可能不会提高StopIteration。幸运的是，这种行为在大多数情况下对编码员是透明的。 :)

相关讨论

我喜欢基数软件包，它非常轻巧，并根据可迭代性尝试使用可能的最快实现。

用法：

1
2
3
4
5
6
7
8
9
10
>>> 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()实现如下：

1
2
3
4
5
6
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

迭代器只是一个对象，该对象具有要由某种缓冲区或流读取的下一个对象的指针，就像LinkedList一样，在其中迭代之前，您不知道自己拥有多少东西。迭代器之所以具有效率，是因为它们所做的只是告诉您引用之后是什么，而不是使用索引(但是如您所见，您失去了查看下一步有多少个条目的能力)。

相关讨论

因此，对于那些想了解该讨论摘要的人。使用以下方法计算长度为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

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

("列表，秒"，1.9684218849870376)

2：test_list_compr.py:8：0.867 KiB

1
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

1
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

1
2
3
4
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

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

('reduce，sec'，13.436614598002052)
```

因此，len(list(gen))是最频繁且消耗较少的内存

关于您的原始问题，答案仍然是，通常没有办法知道Python中迭代器的长度。

鉴于您的问题是由pysam库的应用程序引起的，我可以给出一个更具体的答案：我是PySAM的贡献者，而最终的答案是SAM / BAM文件未提供对齐读取的确切数目。也无法从BAM索引文件中轻松获得此信息。最好的办法是在读取多个对齐方式并根据文件的总大小外推后，通过使用文件指针的位置来估计对齐的大概数量。这足以实现进度条，但不足以在恒定时间内计算路线的方法。

快速基准：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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))

结果：

1
2
3
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是必经之路。

有两种方法可以获取计算机上"某物"的长度。

第一种方法是存储计数-这需要接触文件/数据的任何东西来修改它(或仅公开接口的类-但归结为同一件事)。

另一种方法是遍历它并计算它的大小。

尽管通常不可能执行所要求的操作，但是在对项目进行迭代之后，对迭代的项目数进行计数通常还是有用的。为此，您可以使用jaraco.itertools.Counter或类似的名称。这是一个使用Python 3和rwt加载程序包的示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ 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
1
2
3
4
def count_iter(iter):
    sum = 0
    for _ in iter: sum += 1
    return sum

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

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

相关讨论

通常的做法是将这种类型的信息放在文件头中，并让pysam允许您访问此信息。我不知道格式，但是您检查过API吗？

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