Python提供了一种很好的方法来获取渴望的可迭代的长度len(x)。但是我找不到任何类似于生成器理解和函数所代表的惰性迭代的东西。当然，写下这样的东西并不难：
def iterlen(x):
n = 0
try:
while True:
next(x)
n += 1
except StopIteration: pass
return n
但是我无法摆脱我重新实现自行车的感觉。
（当我输入这个函数时，一个想法让我大吃一惊：也许真的没有这样的功能，因为它“摧毁”了它的论点。虽然不是我的情况的问题。
P.S。：关于第一个答案 - 是的，像len(list(x))之类的东西也会起作用，但这会大大增加记忆的使用。
P.P.S。：重新检查......无视P.S.，似乎我在尝试时犯了一个错误，它运作正常。抱歉，麻烦。
答案 0 :(得分：220)
最简单的方法可能只是sum(1 for _ in gen)，其中gen是你的发电机。
答案 1 :(得分：32)
没有一个，因为你不能在一般情况下这样做 - 如果你有一个懒惰的无限发电机怎么办？例如：
def fib():
a, b = 0, 1
while True:
a, b = b, a + b
yield a
这永远不会终止，但会产生斐波那契数字。您可以通过调用next()获得尽可能多的Fibonacci数字。
如果你真的需要知道有多少项，那么你无论如何都不能线性地迭代它们，所以只需使用不同的数据结构，例如常规列表。
答案 2 :(得分：17)
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)
答案 3 :(得分：7)
您可以使用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)
答案 4 :(得分：5)
使用reduce(function, iterable[, initializer])获取内存高效的纯功能解决方案：
>>> iter = "This string has 30 characters."
>>> reduce(lambda acc, e: acc + 1, iter, 0)
30
答案 5 :(得分：4)
那么，对于那些想要了解该讨论摘要的人。使用以下方法计算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)，按执行性能（包括内存消耗）排序，会让你感到惊讶：
```
gen = (i for i in data*1000); t0 = monotonic(); len(list(gen))
（＆＃39; list，sec＆＃39;，1.9684218849870376）
gen = (i for i in data*1000); t0 = monotonic(); len([i for i in gen])
（＆＃39; list_compr，sec＆＃39;，2.5885991149989422）
gen = (i for i in data*1000); t0 = monotonic(); sum(1 for i in gen); t1 = monotonic()
（＆＃39; sum，sec＆＃39;，3.441088170016883）
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)
（＆＃39; ilen，sec＆＃39;，9.812256851990242）
gen = (i for i in data*1000); t0 = monotonic(); reduce(lambda counter, i: counter + 1, gen, 0)
（＆＃39; reduce，sec＆＃39;，13.436614598002052） ```
因此，len(list(gen))是最常见且耗能较少的内存消耗品
答案 6 :(得分：2)
根据定义，只有一定数量的生成器会在一定数量的参数（具有预定长度）后返回，即便如此，只有这些有限生成器的子集具有可预测的结束（访问生成器可以有侧面） - 可以提前停止发电机的影响。）
如果你想为你的生成器实现长度方法，你必须首先定义你认为的“长度”（它是元素的总数？剩余元素的数量？），然后将你的生成器包装在一个类中。这是一个例子：
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]
答案 7 :(得分：2)
尝试more_itertools包以获得简单的解决方案。例如：
>>> import more_itertools
>>> it = iter("abcde") # sample generator
>>> it
<str_iterator at 0x4ab3630>
>>> more_itertools.ilen(it)
5
有关其他应用示例，请参阅this post。
答案 8 :(得分：1)
这是一个黑客攻击，但是如果你真的希望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中，并且（据我所知）应该涵盖所有可想象的迭代类型。