Najprostszym sposobem jest prawdopodobnie sum(1 for _ in gen) gdzie gen jest Twoim generatorem.

def count(iter):
    return sum(1 for _ in iter)

Albo jeszcze lepiej:

def count(iter):
    try:
        return len(iter)
    except TypeError:
        return sum(1 for _ in iter)

Jeśli nie jest iteracyjna, rzuci TypeError.

Lub, jeśli chcesz policzyć coś konkretnego w generatorze:

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)

Możesz użyć enumerate (), aby zapętlić wygenerowany strumień danych, a następnie zwrócić ostatnią liczbę -- liczbę pozycji.

#!/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

Rozwiązanie Kamila Kisiela jest o wiele lepsze:

def count_iterable(i):
    return sum(1 for e in i)

Użyj reduce (function, iterable[, initializer]) dla wydajnego pamięci rozwiązania czysto funkcjonalnego:

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

Z definicji, tylko podzbiór generatorów powróci po określonej liczbie argumentów (ma predefiniowaną Długość), a nawet wtedy, tylko podzbiór tych skończonych generatorów ma przewidywalny koniec (dostęp do generatora może mieć skutki uboczne, które mogłyby zatrzymać generator wcześniej).

Jeśli chcesz zaimplementować metody length dla swojego generatora, musisz najpierw zdefiniować, co uważasz za "Długość" (czy jest to całkowita liczba elementów? ilość pozostałych elementów?), następnie zapakuj swój generator w klasę. Oto przykład:

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

Oto jak go używać:

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]

Spróbuj more_itertools pakiet dla prostego rozwiązania. Przykład:

>>> import more_itertools

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

>>> more_itertools.ilen(it)
5

Zobacz ten post dla innego przykładu.

To jest hack, ale jeśli naprawdę chcesz mieć len pracę nad ogólnym iterable( zużywając go w sposób), możesz utworzyć własną wersję len.

Funkcja len jest zasadniczo równoważna następującym (choć implementacje zazwyczaj zapewniają pewne optymalizacje, aby uniknąć dodatkowego wyszukiwania):

def len(iterable):
    return iterable.__len__()

Dlatego możemy zdefiniować nasze new_len, aby spróbować tego, a jeśli __len__ nie istnieje, policz liczbę elementów samodzielnie, zużywając iterable:

def new_len(iterable):
    try:
      return iterable.__len__()
    except AttributeError:
      return sum(1 for _ in iterable)

The powyższe działa w Pythonie 2/3 i (o ile wiem) powinny obejmować każdy możliwy rodzaj iterable.

Więc dla tych, którzy chcieliby poznać podsumowanie tej dyskusji. Ostateczne wyniki za zliczanie wyrażenia generatora o długości 50 milionów za pomocą:

• len(list(gen)),
• len([_ for _ in gen]),
• sum(1 for _ in gen),
• ilen(gen) (from more_itertool),
• reduce(lambda c, i: c + 1, gen, 0),

Posortowane według wydajności wykonania (w tym zużycia pamięci), zaskoczy Cię:

```

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

Więc, len(list(gen)) jest najczęstsze i mniej zużywalne pamięci