Über Python für Schleife

Das Ziel dieser Geschichte

• Wissen, was eine Python for-Schleife ist (ich bin neugierig)
• Kennen Sie den Unterschied zwischen Listeneinschlussnotation und Generatorausdruck

für Schleife

for_loop.py

for i in [0, 1, 2, 3, 4]:
    print(i)

Wenn du rennst

% python for_loop.py
0
1
2
3
4

for i inIch möchte wissen, wie das Ding dahinter benutzt wird. (Im obigen Beispiel scheinen die Elemente von "[0, 1, 2, 3, 4]" der Reihe nach extrahiert worden zu sein.)

Versuchen Sie, ein schönes Objekt einzulegen

Mal sehen, wie es in Bezug auf den Laufzeitfehler getroffen wird

duck.py

class Duck(object):
    pass


if __name__ == '__main__':
    for i in Duck():
        print(i)

Wenn ich es starte, werde ich wütend, wenn es nicht iterierbar ist

% python duck.py
Traceback (most recent call last):
  File "duck.py", line 6, in <module>
    for i in Duck():
TypeError: 'Duck' object is not iterable

• iterable ist ein Objekt mit der Methode `__ iter__ ()`
• Aufgrund dieser Definition glaube ich es vorerst

Versuchen Sie, iterable zu implementieren

Mir wurde gesagt, ich solle es implementieren, also werde ich es implementieren. Aber geben Sie einfach ein leeres Objekt zurück

duck.py

class DuckIter(object):
    def __init__(self):
        pass


class Duck(object):
    def __iter__(self):
        return DuckIter()


if __name__ == '__main__':
    for i in Duck():
        print(i)

Der Fehler hat sich geändert (ein Schritt vorwärts!)

% python duck.py
Traceback (most recent call last):
  File "duck.py", line 12, in <module>
    for i in Duck():
TypeError: iter() returned non-iterator of type 'DuckIter'

• Iterator ist ein Objekt mit einer next () `` Methode
• Für Python3 die Methode `__next__ ()`

Versuchen Sie, den Iterator zu implementieren

Versuche dreimal zu quietschen.

duck.py

class DuckIter(object):
    def __init__(self):
        self._count = 3

    def next(self):
        if self._count > 0:
            self._count -= 1
            return "quack"
        raise StopIteration()


class Duck(object):
    def __iter__(self):
        return DuckIter()


if __name__ == '__main__':
    for i in Duck():
        print(i)

Keine Fehler mehr beim Ausführen

% python duck.py
quack
quack
quack

Die Ente klingelte!

Ente tippen

If it walks like a duck and quacks like a duck, it must be a duck https://ja.wikipedia.org/wiki/ダック・タイピング

Das Objekt selbst bestimmt, was das Objekt tun kann (Unabhängig davon, welche Erbschaft sie haben)

Im Fall des vorherigen Beispiels

• Duck: Es wurde als iterabel angesehen, da es eine `__ iter__ ()` Methode hat.
• DuckIter: Es wurde als Iterator angesehen, da es eine next () `` `Methode hat.

Dies ermöglichte es uns, die for-Schleife zu drehen:

for i in Duck():
    print(i)

Diese Notation entspricht in etwa der folgenden

iter = Duck().__iter__()
while True:
    try:
        i = iter.next()
        print(i)
    except StopIteration:
        break

Mit anderen Worten, der Verarbeitungsablauf der for-Schleife

1. Holen Sie sich Iterator
2. Rufen Sie die next () -Methode des Iterators auf
3. Wenn es sich nicht um StopIteration handelt, führen Sie "process in loop" aus und fahren Sie erneut mit 2. fort.

Ein bisschen Übung

Lassen Sie uns ein Objekt mit Iterator in umgekehrter Reihenfolge aus der Liste erstellen

>>> lst = [0, 1, 2, 3, 4]
>>> rev = RevList(lst)
>>> for r in rev:
...     print(r)
...
4
3
2
1
0

Trinkgeld:

• Jetzt können Sie "Objekt mit" next () Methode" mit `` iter ()` `` erhalten
• `next ()` kehrt vom Ende der ursprünglichen Liste zurück

Antwort 1

• Befolgen Sie die Tipps gehorsam
• Kopieren Sie nicht die ursprüngliche Liste, sondern beziehen Sie sich darauf

class RevListIter(object):
    def __init__(self, lst):
        self._orig = lst
        self._i = len(lst)

    def next(self):
        if self._i > 0:
            self._i -= 1
            return self._orig[self._i]
        raise StopIteration()


class RevList(object):
    def __init__(self, lst):
        self._orig = lst

    def __iter__(self):
        return RevListIter(self._orig)


if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    rev = RevList(lst)
    for r in rev:
        print(r)

Antwort 2

• Erstellen Sie eine Liste in umgekehrter Reihenfolge mit Slices von Schritt = -1
• Gibt den Iterator für diese Liste zurück

class RevList(object):
    def __init__(self, lst):
        self._orig = lst

    def __iter__(self):
        return self._orig[::-1].__iter__()


if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    rev = RevList(lst)
    for r in rev:
        print(r)

Unterschied zwischen den beiden Antworten

• Antwort 1 erstellt jedes Mal ein Element, wenn es verwendet wird, nicht wenn es erstellt wird.
• Antwort 2 generiert beim Erstellen des Iterators eine Liste in umgekehrter Reihenfolge

Listeneinschlussnotation und Generatordarstellung

Eine andere Praxis

Erstellen wir einen Iterator, der jedes Element einer Liste von Ganzzahlen quadriert

>>> lst = [0, 1, 2, 3, 4]
>>>für mich in etwas(lst):
...     print(i)
...
0
1
4
9
16

Zwei Beispielantworten

>>> lst = [0, 1, 2, 3, 4]
>>> for i in [x*x for x in lst]:
...     print(i)
...
0
1
4
9
16
>>> for i in (x*x for x in lst):
...     print(i)
...
0
1
4
9
16

Beides sind Lösungen. Lassen Sie uns den Unterschied zwischen den beiden sehen.

Listeneinschlussnotation

Notation

[f(x) for x in lst]

Beispielcode

list_comprehension.py

def f(x):
    print("%d*%d" % (x, x))
    return x*x

if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    x = [f(x) for x in lst]
    print(type(x))
    for i in x:
        print(i)

Ausführungsergebnis

% python list_comprehension.py
0*0
1*1
2*2
3*3
4*4
<type 'list'>
0
1
4
9
16

• Rückgabeliste
• Vor Schleife berechnen und Ergebnisliste erstellen
• In einer for-Schleife rufen Sie einfach die Werte der Reihe nach ab

Generatordarstellung

Notation

(f(x) for x in lst)

Beispielcode

generator_expression.py

def f(x):
    print("%d*%d" % (x, x))
    return x*x

if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    x = (f(x) for x in lst)
    print(type(x))
    for i in x:
        print(i)

Ausführungsergebnis

% python generator_expression.py
<type 'generator'>
0*0
0
1*1
1
2*2
4
3*3
9
4*4
16

• Gibt einen Generator zurück
• Wird vor Verwendung der In-for-Schleife nicht berechnet
• Wird jedes Mal berechnet, wenn ein Wert in einer for-Schleife abgerufen wird

Zusammenfassung

• Python tippt Enten
• Durch die Implementierung von __iter__ () , next () `wird iterable abgeschlossen.
• In Python3 `` `__next () __```
• For loop ruft die Werte in der Reihenfolge vom Iterator ab und dreht den Prozess
• Notation, um von der Liste iterierbar zu machen
• Listenverständnis: Berechnen Sie beim Erstellen und Generieren einer Ergebnisliste
• Generatorausdruck: Beim Erstellen nicht berechnen. Wird bei jeder Verwendung berechnet
• Verwandte: Kartenfunktion
• In Python2 entspricht dies dem Listenverständnis → gibt die Liste zurück
• In Python3 entspricht der Generatorausdruck → den Iterator