blocks|key|973947|text|不是的。这不可能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|973948|示例：|973949|import+random

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

iterator+=+gen(10)|code-block|syntax|javascript|973950|在遍历iterator之前，它的长度是未知的。|offset|length|style|CODE|973951|entityMap^0|0|0|0|3|8|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

No. It's not possible.

Example:

<pre><code>import random

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

iterator = gen(10)
</code></pre>

Length of <code>iterator</code> is unknown until you iterate through it.

blocks|key|973851|text|不，任何方法都需要你解析每一个结果。你可以做到|type|unstyled|depth|inlineStyleRanges|entityRanges|data|973852|iter_length+=+len(list(iterable))|code-block|syntax|javascript|973853|但是在无限迭代器上运行它当然永远不会返回。它还将消耗迭代器，如果您想使用内容，则需要对其进行重置。|973854|告诉我们您试图解决的实际问题可能会帮助我们找到更好的方法来实现您的实际目标。|973855|编辑:使用list()会一次将整个可迭代内容读取到内存中，这可能是不可取的。另一种方法是|offset|length|style|CODE|973856|sum(1+for+_+in+iterable)|973857|就像另一个人发布的那样。这将避免将其保存在内存中。|973858|entityMap^0|0|0|0|0|5|6|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

No, any method will require you to resolve every result. You can do 

<pre><code>iter_length = len(list(iterable))
</code></pre>

but running that on an infinite iterator will of course never return. It also will consume the iterator and it will need to be reset if you want to use the contents.

Telling us what real problem you're trying to solve might help us find you a better way to accomplish your actual goal.

Edit: Using <code>list()</code> will read the whole iterable into memory at once, which may be undesirable. Another way is to do

<pre><code>sum(1 for _ in iterable)
</code></pre>

as another person posted. That will avoid keeping it in memory.

blocks|key|1188414|text|您不能(除非特定迭代器的类型实现了一些特定的方法，从而使其成为可能)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1188415|通常，您只能通过使用迭代器来计算迭代器项。可能是最有效的方法之一：|1188416|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)|code-block|syntax|javascript|1188417|(对于Python3.x，将itertools.izip替换为zip)。|offset|length|style|CODE|1188418|entityMap^0|0|0|0|E|E|V|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

You cannot (except the type of a particular iterator implements some specific methods that make it possible).

Generally, you may count iterator items only by consuming the iterator. One of probably the most efficient ways:

<pre><code>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)
</code></pre>

(For Python 3.x replace <code>itertools.izip</code> with <code>zip</code>).

blocks|key|974377|text|我喜欢这方面的cardinality包，它非常轻量级，并尝试使用最快的实现，这取决于迭代器。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|974378|用法：|974379|>>>+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|code-block|syntax|javascript|974380|实际的count()实现如下：|style|CODE|974381|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|974382|entityMap|0|LINK|mutability|MUTABLE|url|http://cardinality.readthedocs.org/en/latest/^0|7|B|0|0|0|0|3|7|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@$A|15|B|16|M|N]]|9|@]|C|$]]|$1|O|3|P|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

I like the <a href="http://cardinality.readthedocs.org/en/latest/" rel="noreferrer">cardinality</a> package for this, it is very lightweight and tries to use the fastest possible implementation available depending on the iterable.

Usage:

<pre><code>&gt;&gt;&gt; import cardinality
&gt;&gt;&gt; cardinality.count([1, 2, 3])
3
&gt;&gt;&gt; cardinality.count(i for i in range(500))
500
&gt;&gt;&gt; def gen():
... yield 'hello'
... yield 'world'
&gt;&gt;&gt; cardinality.count(gen())
2
</code></pre>

The actual <code>count()</code> implementation is as follows:

<pre><code>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
</code></pre>

blocks|key|974422|text|一个快速基准：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|974423|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))

%25timeit+count_iter_items(iter(1000))
%25timeit+count_lencheck(iter(1000))
%25timeit+count_sum(iter(1000))|code-block|syntax|javascript|974424|结果：|974425|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|974426|也就是说，简单的count_iter_items是可行的。|974427|针对python3进行调整：|974428|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)|974429|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

A quick benchmark:

<pre><code>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))
</code></pre>

The results:

<pre><code>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
</code></pre>

I.e. the simple count_iter_items is the way to go.

Adjusting this for python3:

<pre><code>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)
</code></pre>

blocks|key|1188188|text|迭代器只是一个对象，它有一个指向下一个要被某种缓冲区或流读取的对象的指针，它就像一个LinkedList，在这里你不知道你有多少东西，直到你迭代它们。迭代器应该是高效的，因为它们所做的一切都是通过引用而不是使用索引来告诉您下一步是什么(但正如您所看到的，您无法看到下一步有多少条目)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1188189|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

An iterator is just an object which has a pointer to the next object to be read by some kind of buffer or stream, it's like a LinkedList where you don't know how many things you have until you iterate through them. Iterators are meant to be efficient because all they do is tell you what is next by references instead of using indexing (but as you saw you lose the ability to see how many entries are next).

blocks|key|1188353|text|关于你最初的问题，答案仍然是，一般来说，没有办法知道Python中迭代器的长度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1188354|假设您的问题是由pysam库的一个应用程序引起的，我可以给出一个更具体的答案:我是PySAM的贡献者，确切的答案是SAM/BAM文件不提供对齐读取的确切计数。这些信息也不容易从BAM索引文件中获得。最好的方法是通过在读取多个对齐之后使用文件指针的位置并基于文件的总大小进行外推来估计近似对齐的数目。这足以实现一个进度条，但不是一个在恒定时间内计算对齐的方法。|1188355|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Regarding your original question, the answer is still that there is no way in general to know the length of an iterator in Python.

Given that you question is motivated by an application of the pysam library, I can give a more specific answer: I'm a contributer to PySAM and the definitive answer is that SAM/BAM files do not provide an exact count of aligned reads. Nor is this information easily available from a BAM index file. The best one can do is to estimate the approximate number of alignments by using the location of the file pointer after reading a number of alignments and extrapolating based on the total size of the file. This is enough to implement a progress bar, but not a method of counting alignments in constant time.

blocks|key|1188233|text|有两种方法可以在计算机上获得“某物”的长度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1188234|第一种方法是存储计数-这需要任何接触文件/数据的东西来修改它(或者只公开接口的类--但它归结为相同的事情)。|1188235|另一种方法是迭代它并计算它有多大。|1188236|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

There are two ways to get the length of "something" on a computer.

The first way is to store a count - this requires anything that touches the file/data to modify it (or a class that only exposes interfaces -- but it boils down to the same thing).

The other way is to iterate over it and count how big it is.

blocks|key|1188625|text|一种简单的方法是使用set()内置函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1188626|iter+=+zip([1,2,3],['a','b','c'])
print(len(set(iter))+#+set(iter)+=+{(1,+'a'),+(2,+'b'),+(3,+'c')}
Out[45]:+3|code-block|syntax|javascript|1188627|或|1188628|iter+=+range(1,10)
print(len(set(iter))+#+set(iter)+=+{1,+2,+3,+4,+5,+6,+7,+8,+9}
Out[47]:+9|1188629|entityMap^0|A|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

One simple way is using <code>set()</code> built-in function:
<pre><code>iter = zip([1,2,3],['a','b','c'])
print(len(set(iter)) # set(iter) = {(1, 'a'), (2, 'b'), (3, 'c')}
Out[45]: 3
</code></pre>
or
<pre><code>iter = range(1,10)
print(len(set(iter)) # set(iter) = {1, 2, 3, 4, 5, 6, 7, 8, 9}
Out[47]: 9
</code></pre>

blocks|key|974152|text|通常的做法是将这种类型的信息放在文件头中，并由pysam为您提供访问权限。我不知道格式，但是你检查过API了吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|974153|正如其他人所说，你不能从迭代器中知道长度。|974154|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It's common practice to put this type of information in the file header, and for pysam to give you access to this. I don't know the format, but have you checked the API?

As others have said, you can't know the length from the iterator.

blocks|key|974327|text|这与迭代器的定义背道而驰，迭代器是指向对象的指针，加上有关如何到达下一个对象的信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|974328|迭代器不知道在终止之前它还能迭代多少次。这可能是无限的，所以无限可能是你的答案。|974329|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

This is against the very definition of an iterator, which is a pointer to an object, plus information about how to get to the next object.

An iterator does not know how many more times it will be able to iterate until terminating. This could be infinite, so infinity might be your answer.

blocks|key|1188464|text|def+count_iter(iter):
++++sum+=+0
++++for+_+in+iter:+sum+%2B=+1
++++return+sum|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1188465|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def count_iter(iter):
 sum = 0
 for _ in iter: sum += 1
 return sum
</code></pre>

blocks|key|1188579|text|假设您希望在不遍历的情况下计算项的数量，这样迭代器就不会耗尽，稍后再使用它。使用copy或deepcopy可以做到这一点|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1188580|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")|code-block|syntax|javascript|1188581|输出是"Finding+the+length+did+not+exhaust+the+iterator!“|1188582|您可以选择(也是不明智的)隐藏内置的len函数，如下所示：|1188583|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|1188584|entityMap^0|14|4|19|8|0|0|4|1C|0|I|3|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

Presumably, you want count the number of items without iterating through, so that the iterator is not exhausted, and you use it again later. This is possible with <code>copy</code> or <code>deepcopy</code>

<pre><code>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)) &gt; 1:
 print("Finding the length did not exhaust the iterator!")
else:
 print("oh no! it's all gone")
</code></pre>

The output is "<code>Finding the length did not exhaust the iterator!</code>"

Optionally (and unadvisedly), you can shadow the built-in <code>len</code> function as follows:

<pre><code>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
</code></pre>

Is there an efficient way to know how many elements are in an iterator in Python, in general, without iterating through each and counting?

Getting number of elements in an iterator in Python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

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

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

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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