Was ist der kürzeste Weg, um die Anzahl der Elemente in einem Generator / Iterator zu zählen?

Wenn ich die Anzahl der Elemente in einem Iterable haben möchte, ohne mich um die Elemente selbst zu kümmern, wie würde ich das pythonisch erreichen? Im Moment würde ich definieren

def ilen(it):
    return sum(itertools.imap(lambda _: 1, it))    # or just map in Python 3

aber ich verstehe, dass lambdaes fast als schädlich angesehen wird und lambda _: 1sicherlich nicht schön ist.

(Der Anwendungsfall hierfür ist das Zählen der Anzahl der Zeilen in einer Textdatei, die einem regulären Ausdruck entsprechen, d grep -c. H. )

Aufrufe von itertools.imap()in Python 2 oder map()in Python 3 können durch entsprechende Generatorausdrücke ersetzt werden:

sum(1 for dummy in it)

Dies verwendet auch einen Lazy-Generator, sodass keine vollständige Liste aller Iteratorelemente im Speicher erstellt wird.

Methode, die bedeutend schneller ist als sum(1 for i in it)wenn die Iterable lang sein kann (und nicht bedeutend langsamer, wenn die Iterable kurz ist), während das Verhalten des festen Speicher-Overheads beibehalten wird (im Gegensatz zu len(list(it))), um Swap-Thrashing und Neuzuweisungs-Overhead für größere Eingaben zu vermeiden:

# On Python 2 only, get zip that lazily generates results instead of returning list
from future_builtins import zip

from collections import deque
from itertools import count

def ilen(it):
    # Make a stateful counting iterator
    cnt = count()
    # zip it with the input iterator, then drain until input exhausted at C level
    deque(zip(it, cnt), 0) # cnt must be second zip arg to avoid advancing too far
    # Since count 0 based, the next value is the count
    return next(cnt)

Wie len(list(it))es führt die Schleife in C - Code auf CPython ( deque, countund zipsind in C alle implementiert); Das Vermeiden der Ausführung von Bytecode pro Schleife ist normalerweise der Schlüssel zur Leistung in CPython.

Es ist überraschend schwierig, faire Testfälle für den Leistungsvergleich zu finden ( listCheats, __length_hint__die für Iterables mit beliebiger Eingabe wahrscheinlich nicht verfügbar sind, itertoolsFunktionen, die nicht bereitgestellt werden , verfügen __length_hint__häufig über spezielle Betriebsmodi, die schneller arbeiten, wenn der Wert in jeder Schleife zurückgegeben wird wird freigegeben / freigegeben, bevor der nächste Wert angefordert wird, was dequemit maxlen=0will do). Der Testfall, den ich verwendet habe, bestand darin, eine Generatorfunktion zu erstellen, die eine Eingabe übernimmt und einen Generator auf C-Ebene zurückgibt, dem spezielle itertoolsOptimierungen für Rückgabecontainer fehlten, oder __length_hint__Python 3.3 zu verwenden yield from:

def no_opt_iter(it):
    yield from it

Verwenden Sie dann ipython %timeitMagie (ersetzen Sie 100 durch verschiedene Konstanten):

>>> %%timeit -r5 fakeinput = (0,) * 100
... ilen(no_opt_iter(fakeinput))

Wenn die Eingabe nicht groß genug ist, len(list(it))um Speicherprobleme zu verursachen, dauert meine Lösung auf einer Linux-Box mit Python 3.5 x64 etwa 50% länger als def ilen(it): return len(list(it))unabhängig von der Eingabelänge.

Für die kleinsten Eingänge bedeuten die Einrichtungskosten für das Aufrufen von deque/ zip/ count/, nextdass es auf diese Weise unendlich länger dauert als def ilen(it): sum(1 for x in it)(ungefähr 200 ns mehr auf meinem Computer für einen Eingang der Länge 0, was einer Steigerung von 33% gegenüber dem einfachen sumAnsatz entspricht), aber für Bei längeren Eingaben dauert es ungefähr die Hälfte der Zeit pro zusätzlichem Element. Bei Eingaben der Länge 5 sind die Kosten gleich, und irgendwo im Bereich der Länge 50-100 ist der anfängliche Overhead im Vergleich zur tatsächlichen Arbeit nicht wahrnehmbar. Der sumAnsatz dauert ungefähr doppelt so lange.

Grundsätzlich sollten Sie diese Lösung verwenden, wenn die Speichernutzung oder Eingaben keine begrenzte Größe haben und Sie mehr Wert auf Geschwindigkeit als auf Kürze legen. Wenn Eingaben begrenzt und klein sind, len(list(it))ist dies wahrscheinlich am besten, und wenn sie unbegrenzt sind, aber Einfachheit / Kürze zählt, würden Sie verwenden sum(1 for x in it).

Ein kurzer Weg ist:

def ilen(it):
    return len(list(it))

Wenn Sie viele Elemente generieren (z. B. Zehntausende oder mehr), kann das Einfügen in eine Liste zu einem Leistungsproblem werden. Dies ist jedoch ein einfacher Ausdruck der Idee, bei der die Leistung in den meisten Fällen keine Rolle spielt.

more_itertoolsist eine Bibliothek eines Drittanbieters, die ein ilenTool implementiert . pip install more_itertools

import more_itertools as mit


mit.ilen(x for x in range(10))
# 10

Ich mag das Kardinalitätspaket dafür, es ist sehr leicht und versucht, die schnellstmögliche Implementierung zu verwenden, die je nach Iterable verfügbar ist.

Verwendung:

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

Dies wären meine Entscheidungen, entweder die eine oder die andere:

print(len([*gen]))
print(len(list(gen)))