摘要：问题描述：一般来说，是否有一种有效的方法可以知道 Python 中迭代器中有多少个元素，而无需遍历每个元素并进行计数？解决方案 1：该代码应该可以工作：>>> iter = (i for i in range(50)) >>> sum(1 for _ in iter) 50...

问题描述：

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

解决方案 1：

该代码应该可以工作：

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

虽然它确实会遍历每个项目并对其进行计数，但这是最快的方法。

当迭代器没有项目时它也有效：

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

当然，它会因为无限的输入而永远运行，所以请记住迭代器可以是无限的：

>>> sum(1 for _ in itertools.count())
[nothing happens, forever]

另外，请注意，这样做会耗尽迭代器，并且进一步尝试使用它时将看不到任何元素。这是 Python 迭代器设计不可避免的后果。如果要保留元素，则必须将它们存储在列表或类似的东西中。

解决方案 2：

不，这不可能。

例子：

import random

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

iterator = gen(10)

iterator除非你对其进行迭代，否则其长度是未知的。

解决方案 3：

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

iter_length = len(list(iterable))

但在无限迭代器上运行它当然不会返回。它还会消耗迭代器，如果您想使用内容，则需要重置它。

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

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

sum(1 for _ in iterable)

就像另一个人发的一样。这样可以避免将其保留在内存中。

解决方案 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）。

解决方案 5：

有点。您可以检查该__length_hint__方法，但请注意（至少在 Python 3.4 之前，正如 gsnedders 有益地指出的那样）这是一个未记录的实现细节（以下是线程中的消息），它很可能会消失或召唤鼻恶魔。

否则，不行。迭代器只是一个只公开next()方法的对象。您可以根据需要多次调用它，它们最终可能会也可能不会引发StopIteration。幸运的是，这种行为大多数时候对程序员来说是透明的。:)

解决方案 6：

因此，对于那些想知道该讨论摘要的人来说。使用以下方法计算 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：测试列表.py:8: 0.492 KiB
=======================

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


（'列表，秒'，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，秒'，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()


（'总和，秒'，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)


（'伊伦，秒'，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)


（'减少，秒'，13.436614598002052）```


那么，`len(list(gen))`最常用且内存消耗最少的




## 解决方案 7：

 
快速基准测试：

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: 37.2 µs per loop
10000 loops, best of 3: 47.6 µs per loop
10000 loops, best of 3: 61 µs per loop


即简单的 count_iter_items 是可行的方法。


针对 python3 进行调整：

61.9 µs ± 275 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
74.4 µs ± 190 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
82.6 µs ± 164 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)




## 解决方案 8：

 
我喜欢这个基数包，它非常轻量，并尝试根据可迭代对象使用最快的实现。


用法：

import cardinality
cardinality.count([1, 2, 3])

cardinality.count(i for i in range(500))

500

def gen():

... yield 'hello'
... yield 'world'

cardinality.count(gen())


实际`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




## 解决方案 9：

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




## 解决方案 10：

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


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




## 解决方案 11：

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


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


另一种方法是对其进行迭代并计算其大小。




## 解决方案 12：

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


免责声明：我正在使用`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')


结果是：


![在此处输入图片描述](https://i.sstatic.net/XDbLF.jpg)


它使用对数对数轴，以便可以检查所有范围（小值、大值）。由于这些图用于定性比较，因此实际值不太有趣。通常，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`一个简单的生成器表达式进行了测试，趋势非常相似，但我不能排除时间不会根据输入类型而改变。




## 解决方案 13：

 
我决定在现代版本的 Python 上重新运行基准测试，发现基准测试结果几乎完全相反


我运行了以下命令：

py -m timeit -n 10000000 -s "it = iter(range(1000000))" -s "from collections import deque" -s "from itertools import count" -s "def itlen(x):" -s " return len(tuple(x))" -- "itlen(it)"
py -m timeit -n 10000000 -s "it = iter(range(1000000))" -s "from collections import deque" -s "from itertools import count" -s "def itlen(x):" -s " return len(list(x))" -- "itlen(it)"
py -m timeit -n 10000000 -s "it = iter(range(1000000))" -s "from collections import deque" -s "from itertools import count" -s "def itlen(x):" -s " return sum(map(lambda i: 1, x))" -- "itlen(it)"
py -m timeit -n 10000000 -s "it = iter(range(1000000))" -s "from collections import deque" -s "from itertools import count" -s "def itlen(x):" -s " return sum(1 for _ in x)" -- "itlen(it)"
py -m timeit -n 10000000 -s "it = iter(range(1000000))" -s "from collections import deque" -s "from itertools import count" -s "def itlen(x):" -s " d = deque(enumerate(x, 1), maxlen=1)" -s " return d0 if d else 0" -- "itlen(it)"
py -m timeit -n 10000000 -s "it = iter(range(1000000))" -s "from collections import deque" -s "from itertools import count" -s "def itlen(x):" -s " counter = count()" -s " deque(zip(x, counter), maxlen=0)" -s " return next(counter)" -- "itlen(it)"


这相当于对以下每个`itlen*(it)`功能进行计时：

it = iter(range(1000000))
from collections import deque
from itertools import count

def itlen1(x):
return len(tuple(x))
def itlen2(x):
return len(list(x))
def itlen3(x):
return sum(map(lambda i: 1, x))
def itlen4(x):
return sum(1 for _ in x)
def itlen5(x):
d = deque(enumerate(x, 1), maxlen=1)
return d0 if d else 0
def itlen6(x):
counter = count()
deque(zip(x, counter), maxlen=0)
return next(counter)


在配备 AMD Ryzen 7 5800H 和 16 GB RAM 的 Windows 11、Python 3.11 机器上，我得到了以下输出：

10000000 loops, best of 5: 103 nsec per loop
10000000 loops, best of 5: 107 nsec per loop
10000000 loops, best of 5: 138 nsec per loop
10000000 loops, best of 5: 164 nsec per loop
10000000 loops, best of 5: 338 nsec per loop
10000000 loops, best of 5: 425 nsec per loop


这表明`len(list(x))`和`len(tuple(x))`是并列的；其次是`sum(map(lambda i: 1, x))`；然后紧随其后；然后其他答案提到的和/或基数中使用的`sum(1 for _ in x)`其他更复杂的方法至少要慢两个倍。




## 解决方案 14：

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


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




## 解决方案 15：

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


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




## 解决方案 16：

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


**A：** `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


**B：** `list()`如果迭代器中有重复项

iter = (1,2,1,2,1,2,1,2)
print(len(list(iter)) # list(iter) = [1, 2, 1, 2, 1, 2, 1, 2]
Out[49]: 8

compare with set function

print(len(set(iter)) # set(iter) = {1, 2}
Out[51]: 2




## 解决方案 17：

 
虽然通常不可能按照要求执行操作，但在迭代完项目*后*计算迭代了多少个项目仍然很有用。为此，您可以使用jaraco.itertools.Counter或类似工具。以下是使用 Python 3 和pip-run加载包的示例。

$ pip-run 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




## 解决方案 18：

def count_iter(iter):

sum = 0
for _ in iter: sum += 1
return sum




## 解决方案 19：

 
假设您想要计算项目数而不进行迭代，这样迭代器就不会耗尽，稍后您还会使用它。这可以通过`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




## 解决方案 20：

 
**从理论上来说**这是不可能的：事实上，这就是停机问题。


证明
--


`g`矛盾地假设，使用函数，有可能确定任何生成器的长度（或无限长度）`len(g)`。


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


若`len(g(P)) == infinity`，P 不停止。


这解决了已知不可能实现的停机问题，请参阅维基百科。矛盾。




---


因此，如果不对通用生成器进行迭代（==实际运行程序），就不可能计算出它的元素数量。


更具体地说，考虑

def g():

while True:
    yield "more?"


长度是无限的。这样的生成器有无数个。

在 Python 中获取迭代器中的元素数量[重复]