发电机输出长度[重复]

Question

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.，似乎我在尝试时犯了一个错误，它工作正常。给您添麻烦了。

Answer 1

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

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, 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)

('减少，秒'，13.436614598002052) ```

所以，len(list(gen)) 是最频繁且更少的内存消耗

Answer 2

这是一个 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，并且（据我所知）应该涵盖所有可能的迭代类型。

Answer 3

尝试more_itertools 包以获得简单的解决方案。示例：

>>> import more_itertools

>>> it = iter("abcde")                                         # sample generator
>>> it
<str_iterator at 0x4ab3630>

>>> more_itertools.ilen(it)
5

另一个应用示例请参见this post。

Answer 4

没有，因为在一般情况下您无法做到 - 如果您有一个惰性无限生成器怎么办？例如：

def fib():
    a, b = 0, 1
    while True:
        a, b = b, a + b
        yield a

这永远不会终止，但会生成斐波那契数。拨打next()，您可以获得任意数量的斐波那契数。

如果您确实需要知道项目的数量，那么无论如何您都无法线性地遍历它们一次，因此只需使用不同的数据结构，例如常规列表。

Answer 5

可以使用 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)

Answer 6

使用reduce(function, iterable[, initializer]) 获得内存高效的纯功能解决方案：

>>> iter = "This string has 30 characters."
>>> reduce(lambda acc, e: acc + 1, iter, 0)
30

Answer 7

根据定义，只有一部分生成器会在一定数量的参数之后返回（具有预定义的长度），即使这样，这些有限生成器中也只有一部分具有可预测的结束（访问生成器可以有边- 可以更早停止生成器的效果）。

如果你想为你的生成器实现长度方法，你必须首先定义你认为的“长度”（它是元素的总数吗？剩余元素的数量？），然后将你的生成器包装在一个类中.这是一个例子：

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]

Answer 8

最简单的方法可能就是sum(1 for _ in gen)，其中 gen 是您的生成器。

Answer 9

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)