Python 提供了一种很好的方法来获取急切迭代的长度，len(x)即。但是对于由生成器理解和函数表示的惰性迭代，我找不到任何类似的东西。当然，写这样的东西并不难：
def iterlen(x):
n = 0
try:
while True:
next(x)
n += 1
except StopIteration: pass
return n
但我无法摆脱我正在重新实现自行车的感觉。
（当我输入函数时，我突然想到：也许真的没有这样的函数，因为它“破坏”了它的论点。不过，这对我来说不是问题）。
PS：关于第一个答案 - 是的，类似的东西len(list(x))也可以，但这会大大增加内存的使用。
PPS：重新检查...忽略PS，似乎我在尝试时犯了一个错误，它工作正常。抱歉，添麻烦了。
最简单的方法可能就是sum(1 for _ in gen)gen 是你的生成器。
对于那些想知道该讨论摘要的人。使用以下方法计算 5000 万长度的生成器表达式的最终最高得分：
len(list(gen)),len([_ for _ in gen]),sum(1 for _ in gen),ilen(gen)（来自more_itertools），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))是最频繁和更少的内存消耗
没有，因为在一般情况下您无法做到 - 如果您有一个惰性无限生成器怎么办？例如：
def fib():
a, b = 0, 1
while True:
a, b = b, a + b
yield a
这永远不会终止，但会生成斐波那契数。您可以通过调用获得任意数量的斐波那契数字next()。
如果您确实需要知道项目的数量，那么无论如何您都无法线性迭代它们一次，因此只需使用不同的数据结构，例如常规列表。
def count(iter):
return sum(1 for _ in iter)
或者更好：
def count(iter):
try:
return len(iter)
except TypeError:
return sum(1 for _ in iter)
如果它不可迭代，它将抛出一个TypeError.
或者，如果您想计算生成器中的特定内容：
def count(iter, key=None):
if key:
if callable(key):
return sum(bool(key(x)) for x in iter)
return sum(x == key for x in iter)
try:
return len(iter)
except TypeError:
return sum(1 for _ in iter)
您可以使用 enumerate() 循环遍历生成的数据流，然后返回最后一个数字——项目数。
我尝试将 itertools.count() 与 itertools.izip() 一起使用，但没有运气。这是我想出的最好/最短的答案：
#!/usr/bin/python
import itertools
def func():
for i in 'yummy beer':
yield i
def icount(ifunc):
size = -1 # for the case of an empty iterator
for size, _ in enumerate(ifunc()):
pass
return size + 1
print list(func())
print 'icount', icount(func)
# ['y', 'u', 'm', 'm', 'y', ' ', 'b', 'e', 'e', 'r']
# icount 10
Kamil Kisiel 的解决方案要好得多：
def count_iterable(i):
return sum(1 for e in i)
根据定义，只有一部分生成器会在一定数量的参数（具有预定义的长度）之后返回，即使这样，这些有限生成器中也只有一部分具有可预测的结束（访问生成器可能会产生副作用可以更早地停止发电机）。
如果你想为你的生成器实现长度方法，你必须首先定义你认为的“长度”（它是元素的总数吗？剩余元素的数量？），然后将你的生成器包装在一个类中。这是一个例子：
class MyFib(object):
"""
A class iterator that iterates through values of the
Fibonacci sequence, until, optionally, a maximum length is reached.
"""
def __init__(self, length):
self._length = length
self._i = 0
def __iter__(self):
a, b = 0, 1
while not self._length or self._i < self._length:
a, b = b, a + b
self._i += 1
yield a
def __len__(self):
"This method returns the total number of elements"
if self._length:
return self._length
else:
raise NotImplementedError("Infinite sequence has no length")
# or simply return None / 0 depending
# on implementation
以下是如何使用它：
In [151]: mf = MyFib(20)
In [152]: len(mf)
Out[152]: 20
In [153]: l = [n for n in mf]
In [154]: len(l)
Out[154]: 20
In [155]: l
Out[155]:
[1,
1,
2,
...
6765]
In [156]: mf0 = MyFib(0)
In [157]: len(mf0)
---------------------------------------------------------------------------
NotImplementedError Traceback (most recent call last)
<ipython-input-157-2e89b32ad3e4> in <module>()
----> 1 len(mf0)
/tmp/ipython_edit_TWcV1I.py in __len__(self)
22 return self._length
23 else:
---> 24 raise NotImplementedError
25 # or simply return None / 0 depending
26 # on implementation
NotImplementedError:
In [158]: g = iter(mf0)
In [159]: l0 = [g.next(), g.next(), g.next()]
In [160]: l0
Out[160]: [1, 1, 2]
使用reduce(function, iterable[, initializer])获得内存高效的纯函数解决方案：
>>> iter = "This string has 30 characters."
>>> reduce(lambda acc, e: acc + 1, iter, 0)
30
尝试该more_itertools软件包以获得简单的解决方案。例子：
>>> import more_itertools
>>> it = iter("abcde") # sample generator
>>> it
<str_iterator at 0x4ab3630>
>>> more_itertools.ilen(it)
5
有关另一个应用示例，请参见这篇文章。
这是一个 hack，但如果你真的想len处理一个通用的可迭代对象（顺便使用它），你可以创建自己的len.
该len函数本质上等同于以下函数（尽管实现通常会提供一些优化以避免额外的查找）：
def len(iterable):
return iterable.__len__()
因此，我们可以定义我们的new_len来尝试，如果__len__不存在，则通过使用可迭代来自己计算元素的数量：
def new_len(iterable):
try:
return iterable.__len__()
except AttributeError:
return sum(1 for _ in iterable)
以上适用于 Python 2/3，并且（据我所知）应该涵盖所有可能的迭代类型。