6. Hochwertige Funktionen
6.1 Iteration
Wenn eine Liste oder ein Tupel angegeben ist, können wir die Liste oder das Tupel durch eine for-Schleife durchlaufen. Dieser Durchlauf wird als Iteration bezeichnet. In Python erfolgt die Iteration mit for...in.
Da dict nicht in der Reihenfolge einer Liste gespeichert wird, ist die Reihenfolge der iterierten Ergebnisse wahrscheinlich unterschiedlich. Standardmäßig iteriert dict über Schlüssel. Wenn Sie den Wert iterieren möchten, können Sie for value in d.values() verwenden. Wenn Sie Schlüssel und Wert gleichzeitig iterieren möchten, können Sie for k, v in d.items() verwenden.
Da Strings auch iterierbare Objekte sind, können sie auch in for-Schleifen verwendet werden:
|
>>> for ch in 'ABC':
... print(ch)
...
A
B
C
|
>>> für ch in „ABC“:
... print(ch)
|
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
|
...
|
>>> for i, value in enumerate(['A', 'B', 'C']):
... print(i, value)
...
0 A
1 B
2 C
|
A
B
C
|
Wie kann festgestellt werden, ob ein Objekt ein iterierbares Objekt ist? Die Methode besteht darin, anhand des iterierbaren Typs des Sammlungsmoduls zu beurteilen:
>>> aus Sammlungen iterierbar
|
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
|
>>> isinstance('abc', Iterable) # Ob str iterierbar ist
|
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
|
Wahr
>>> isinstance([1,2,3], Iterable) # Ob die Liste iterierbar ist
|
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
|
Wahr
|
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']
|
>>> isinstance(123, Iterable) # Ob die Ganzzahl iterierbar ist
Falsch
|
Was ist, wenn Sie eine Java-ähnliche Indexschleife in der Liste implementieren möchten? Die in Python integrierte Aufzählungsfunktion kann eine Liste in ein Index-Element-Paar umwandeln, sodass der Index und das Element selbst gleichzeitig in einer for-Schleife iteriert werden können:
>>> für i, Wert in enumerate(['A', 'B', 'C']):
|
>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
at 0x1022ef630>
|
... print(i, value)
...
0 A
1 B
2 C
|
6.2 Listenableitung
List Comprehensions sind eine sehr einfache, aber leistungsstarke integrierte Python-Generierung, die zum Erstellen von Listen verwendet werden kann.
Um eine Liste [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] zu erstellen, können Sie list(range(1, 11)) verwenden.
Geben Sie beim Schreiben eines Listengenerierungsausdrucks das Element x * ein Sie können nach der for-Schleife auch ein if-Urteil hinzufügen, sodass wir nur die Quadrate gerader Zahlen herausfiltern können:
|
>>> [x * x für x im Bereich(1, 11) wenn x % 2 == 0]
[4, 16, 36, 64, 100]
|
Sie können auch eine zweistufige Schleife verwenden, um ein vollständiges Arrangement zu generieren:
|
>>> [m + n für m in 'ABC' für n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
|
Bei der Listengenerierung können auch zwei Variablen zum Generieren einer Liste verwendet werden:
|
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v für k, v in d.items()]
['y=B', 'x=A', 'z=C']
|
Abschließend ändern Sie alle Zeichenfolgen in einer Liste in Kleinbuchstaben:
|
>>> L = ['Hallo', 'Welt', 'IBM', 'Apple']
>>> [s.lower() für s in L]
['hello', 'world', 'ibm', 'apple']
|
6.3 Generatorausdrücke
Wenn die Listenelemente nach einem bestimmten Algorithmus berechnet werden können, können nachfolgende Elemente während der Schleife kontinuierlich berechnet werden. In Python wird dieser Berechnungsmechanismus während der Schleife als Generator bezeichnet.
Es gibt viele Möglichkeiten, einen Generator zu erstellen. Die erste Methode ist sehr einfach. Ändern Sie einfach [] in () in einem Listengenerierungsausdruck, um einen Generator zu erstellen:
|
>>> L = [x * x für x im Bereich(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x für x im Bereich(10))
>>> g
bei 0x1022ef630>
|
Der einzige Unterschied zwischen der Erstellung von L und g besteht darin, dass [] und () eine Liste sind und g ein Generator ist. Wenn Sie sie einzeln ausdrucken möchten, können Sie den nächsten Rückgabewert des Generators über die Funktion next() abrufen. Wie bereits erwähnt, speichert der Generator den Algorithmus jedes Mal, wenn next(g) aufgerufen wird, bis das letzte Element berechnet ist. Wenn keine weiteren Elemente vorhanden sind, wird ein StopIteration-Fehler ausgegeben.
|
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
File "", line 1, in
StopIteration
|
>>> weiter(g)
0
|
>>> g = (x * x for x in range(10))
>>> for n in g:
... print(n)
...
0
1
4
9
16
25
36
49
64
81
|
>>> weiter(g)
|
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
|
1
>>> weiter(g)
4
>>> weiter(g)
9
|
>>> lax_coordinates = (33.9425, -118.408056)
>>> latitude, longitude = lax_coordinates # 元组拆包
>>> latitude
33.9425
>>> longitude
-118.408056
|
>>> weiter(g)
|
>>> divmod(20, 8) (2, 4)
>>> t = (20, 8)
>>> divmod(*t)
(2, 4)
>>> quotient, remainder = divmod(*t)
>>> quotient, remainder
(2, 4)
|
16
>>> weiter(g)
|
>>> import os
>>> _, filename = os.path.split('/home/luciano/.ssh/idrsa.pub')
>>> filename
'idrsa.pub’
|
25
>>> weiter(g)
|
>>> a, b, *rest = range(5)
>>> a, b, rest
(0, 1, [2, 3, 4])
>>> a, b, *rest = range(3)
>>> a, b, rest
(0, 1, [2])
>>> a, b, *rest = range(2)
>>> a, b, rest
(0, 1, [])
|
36
>>> weiter(g)
49
>>> weiter(g)
64
>>> weiter(g)
81
>>> weiter(g)
Traceback (letzter Anruf zuletzt):
Datei „“, Zeile 1, in
StopIteration
|
Der richtige Weg ist die Verwendung einer for-Schleife, da der Generator auch ein iterierbares Objekt ist:
|
>>> g = (x * x für x im Bereich(10))
>>> für n in g:
... print(n)
...
0
1
4
9
16
25
36
49
64
81
|
Eine andere Möglichkeit, einen Generator zu definieren. Wenn eine Funktionsdefinition das Schlüsselwort yield enthält, ist die Funktion keine gewöhnliche Funktion mehr, sondern ein Generator:
|
def fib(max):
n, a, b = 0, 0, 1
while n < max:<🎜>
<🎜>Ertrag b<🎜>
<🎜>a, b = b, a + b<🎜>
<🎜>n = n + 1<🎜>
<🎜> „Fertig“ zurückgeben<🎜>
|
<🎜>6.4 Tupel-Entpacken<🎜>
<🎜> Wir weisen die Elemente im Tupel ('Tokio', 2003, 32450, 0,66, 8014) jeweils den Variablen Stadt, Jahr, Einwohner, Einwohnerzahl und Fläche zu und schreiben alle Zuweisungen mit nur einer Deklarationszeile. In ähnlicher Weise ordnet ein %-Operator in der nächsten Zeile die Elemente im Passport-Tupel den Formatzeichenfolgenlücken in der Druckfunktion zu. Beides sind Anwendungen des Tupel-Entpackens. <🎜>
<🎜> Die bekannteste Form des Tupel-Entpackens ist die parallele Zuweisung, d. h. die Zuweisung der Elemente in einem iterierbaren Objekt zu einem Tupel, das aus entsprechenden Variablen besteht. <🎜>
<🎜> Parallele Zuordnung: <🎜>
|
<🎜>>>> lax_coordinates = (33,9425, -118,408056)
>>> Breitengrad, Längengrad = lax_coordinates # Tupel-Auspacken
>>> Breitengrad
33,9425
>>> Längengrad
-118.408056
|
Sie können den *-Operator verwenden, um ein iterierbares Objekt als Funktionsparameter zu teilen:
|
>>> divmod(20, 8) (2, 4)
>>> t = (20, 8)
>>> divmod(*t)
(2, 4)
>>> Quotient, Rest = divmod(*t)
>>> Quotient, Rest
(2, 4)
|
Der Zweck des Tupel-Entpackens besteht hier darin, einer Funktion zu ermöglichen, mehrere Werte in Form von Tupeln zurückzugeben, und dann kann der Code, der die Funktion aufruft, diese Rückgabewerte problemlos akzeptieren. Beispielsweise gibt die Funktion os.path.split() ein Tupel zurück, das aus dem Pfad und dem letzten Dateinamen (path, last_part) besteht:
|
>>> Betriebssystem importieren
>>> _, filename = os.path.split('/home/luciano/.ssh/idrsa.pub')
>>> Dateiname
'idrsa.pub’
|
In Python ist es eine klassische Methode, eine Funktion mit *args zu schreiben, um eine unbestimmte Anzahl von Parametern zu erhalten.
In Python 3 wurde dieses Konzept auf die parallele Zuweisung erweitert:
|
>>> a, b, *rest = range(5)
>>> a, b, Ruhe
(0, 1, [2, 3, 4])
>>> a, b, *rest = range(3)
>>> a, b, Ruhe
(0, 1, [2])
>>> a, b, *rest = range(2)
>>> a, b, Ruhe
(0, 1, [])
|
Bei der parallelen Zuweisung kann das *-Präfix nur vor einem Variablennamen verwendet werden, diese Variable kann jedoch an einer beliebigen Stelle im Zuweisungsausdruck erscheinen:
|
>>> a, *body, c, d = range(5)
>>> a, body, c, d
(0, [1, 2], 3, 4)
>>> *head, b, c, d = range(5)
>>> head, b, c, d
([0, 1], 2, 3, 4)
|
>>> a, *body, c, d = range(5)
>>> a, body, c, d
(0, [1, 2], 3, 4)
>>> *head, b, c, d = range(5)
>>> Kopf, b, c, d
([0, 1], 2, 3, 4)
|
Das obige ist der detaillierte Inhalt vonZusammenfassung des grundlegenden Python-Lernens (4). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
