Wie list() verbrauchen __iter__ ohne __len__ aufzurufen?

Question

Ich habe eine Klasse mit einem __iter__ und einem __len__ Methoden. Letzterer verwendet Ersteres, um alle Elemente zu zählen.

Es funktioniert wie folgt aus:

class A: 
    def __iter__(self): 
     print("iter") 
     for _ in range(5): 
      yield "something" 

    def __len__(self): 
     print("len") 
     n = 0 
     for _ in self: 
      n += 1 
     return n 

Nun, wenn wir zum Beispiel nehmen die Länge einer Instanz druckt len und iter, wie erwartet:

>>> len(A()) 
len 
iter 
5 

Aber wenn wir list() nennen es nennt beide __iter__ und __len__:

>>> list(A()) 
len 
iter 
iter 
['something', 'something', 'something', 'something', 'something'] 

Es funktioniert wie erwartet, wenn wir einen Generator Ausdruck machen :

>>> list(x for x in A()) 
iter 
['something', 'something', 'something', 'something', 'something'] 

ich würde davon ausgehen list(A()) und list(x for x in A()) funktionieren gleich, aber sie nicht.

Beachten Sie, dass es zuerst erscheint __iter__ zu nennen, dann __len__, dann Schleife über den Iterator:

class B: 
    def __iter__(self): 
     print("iter") 

     def gen(): 
      print("gen") 
      yield "something" 

     return gen() 

    def __len__(self): 
     print("len") 
     return 1 

print(list(B())) 

Ausgang:

iter 
len 
gen 
['something'] 

---

Wie kann ich list() nicht __len__ anrufen damit der Iterator meiner Instanz nicht zweimal verbraucht wird? Ich könnte z.B. a length oder size Methode und man würde dann A().size() anrufen, aber das ist weniger Python.

Ich habe versucht, die Länge in __iter__ und cachen es zu berechnen, so dass nachfolgende Aufrufe __len__ nicht wieder iter müssen aber list() Anrufe __len__ ohne zu wiederholen beginnen so funktioniert es nicht.

Beachten Sie, dass ich in meinem Fall an sehr großen Datensammlungen arbeite, so dass das Zwischenspeichern aller Elemente keine Option ist.

Answer 1

Es ist eine sichere Wette, dass der list() Konstruktor erkennt, dass len() verfügbar ist und es um Aufruf Speicher für die Liste vorbelegt.

Ihre Implementierung ist ziemlich vollständig rückwärts. Sie implementieren __len__() mithilfe von __iter__(), was Python nicht erwartet. Die Erwartung ist, dass len() eine schnelle, effiziente Möglichkeit ist, die Länge im Voraus zu bestimmen.

Ich glaube nicht, dass Sie list(A()) überzeugen können, nicht len zu rufen. Wie Sie bereits festgestellt haben, können Sie einen Zwischenschritt anlegen, der verhindert, dass len aufgerufen wird.

Sie sollten das Ergebnis definitiv zwischenspeichern, wenn die Reihenfolge unveränderlich ist. Wenn es so viele Dinge gibt, wie Sie spekulieren, gibt es keinen Sinn len mehr als einmal zu berechnen.

Answer 2

Sie müssen __len__ nicht implementieren.Für eine Klasse, die iterable ist, es muss nur entweder von unten implementieren:

• __iter__, die ein iterator oder ein generator wie in Ihrer Klasse gibt A & B
• __getitems__, solange es IndexError erhöht, wenn der Index außerhalb des zulässigen Bereichs

Schlag Code funktioniert immer noch:

class A: 
    def __iter__(self): 
     print("iter") 
     for _ in range(5): 
      yield "something" 

print list(A()) 

Welche Ausgänge:

iter 
['something', 'something', 'something', 'something', 'something']