Fünf Techniken für Python, um von der Liste zur zip()-Funktion abzuleiten

In diesem Artikel stellt der Autor 5 Methoden vor. Vielleicht wissen wir zu Beginn noch nicht viel darüber, aber diese 5 Fähigkeiten sind im tatsächlichen Kampf sehr praktisch.

String-Operationen

Ein String ist im Wesentlichen ein Tupel, aber es gibt viele „Operationen“ für Strings. Die intuitivsten sind die +- und *-Operationen für Strings, die Wiederholung bzw. Verkettung darstellen.

>>> my_string = "Hi Medium..!"
>>> print(my_string * 2)
Hi Medium..!Hi Medium..!
>>> print(my_string + " I love Python" * 2)
Hi Medium..! I love Python I love Python

Wenn Sie außerdem die umgekehrte Zeichenfolge erhalten möchten, können Sie [::-1] auch direkt zur Indizierung verwenden:

>>> print(my_string[::-1])
!..muideM iH>>> my_list = [1,2,3,4,5]
>>> print(my_list[::-1])
[5, 4, 3, 2, 1]

Wenn die Listenelemente alle Zeichenfolgen sind, dann wir kann schnell die Methode „join()“ verwenden, um alle Elemente miteinander zu verbinden:

>>> word_list = ["awesome", "is", "this"]
>>> print(' '.join(word_list[::-1]) + '!')
this is awesome!

Wie oben verwenden wir die Methode .join(), um die Listenelemente zu verbinden, wobei 『 』 angibt, dass die Verbindungsmethode ein Leerzeichen ist . Tatsächlich wird diese Methode bei der Verarbeitung natürlicher Sprache häufig verwendet. Wenn wir beispielsweise den Satz in Zeichen aufteilen, muss bei der Nachverarbeitungszusammenführung join () verwendet werden.

Verwandte Empfehlungen: „Python-Grundlagen-Tutorial“

Listenverständnisse

Wenn Sie nicht wissen, wie man Listen verwendet Wenn Sie noch Verständnis haben, dann lernen Sie es schnell. Wie der Autor dieses Artikels sagte: „Als ich diese Methode zum ersten Mal lernte, hat sich meine ganze Welt verändert.“ Sie ist nicht nur schneller als gewöhnliche Methoden, sondern auch sehr intuitiv. Wenn Sie eine Liste durchlaufen und einige Berechnungen durchführen möchten, verwenden Sie diese.

Wir beginnen mit der Definition einer einfachen Funktion, die eine Variable quadriert und 5 hinzufügt:

>>> def stupid_func(x):
>>>     return x**2 + 5

Wenn wir diese Funktion auf ungerade Elemente in der Liste anwenden möchten, verwenden Sie kein Listenverständnis Im Falle einer Formel schreiben wir sie normalerweise in der folgenden Form:

>>> my_list = [1, 2, 3, 4, 5]
>>> new_list = []
>>> for x in my_list:
>>>     if x % 2 != 0:
>>>         new_list.append(stupid_func(x))
>>> print(new_list)
[6, 14, 30]

Aber jetzt, da wir ein Listenverständnis haben, kann der obige Code entsprechend geändert werden zu:

>>> my_list = [1, 2, 3, 4, 5]
>>> print([stupid_func(x) for x in my_list if x % 2 != 0])
[6, 14, 30]

Allgemeine Syntax des Listenverständnisses Es kann als [Ausdruck für Element in der Liste] ausgedrückt werden. Wenn Sie einige boolesche bedingte Anweisungen hinzufügen möchten, kann die obige Syntax in [Ausdruck für Element in der Liste, wenn bedingt] geändert werden.

>>> for item in list:
>>>     if conditional:
>>>         expression

Das obige Listenverständnis kann weiter vereinfacht werden, das heißt, es ist nicht erforderlich, eine neue Funktion zu definieren.

>>> print([x ** 2 + 5 for x in my_list if x % 2 != 0])
[6, 14, 30]

Lambda und Karte

Lambda ist eine anonyme Funktion, sie sieht vielleicht etwas seltsam aus, aber wenn man sie erst einmal verstanden hat, wird sie sehr intuitiv und leistungsstark.

Im Allgemeinen sind Lambda-Funktionen relativ klein und es ist nicht erforderlich, Funktionsnamen zu definieren. Warum brauchen Sie also anonyme Funktionen? Vereinfacht gesagt führt Lambda am häufigsten einige intuitive Vorgänge aus. Es sind keine Standardfunktionsdefinitionen erforderlich und es ist nicht erforderlich, dass neue Funktionsnamen erneut aufgerufen werden.

Nehmen wir das obige Quadrat und addieren 5 als Beispiel. Zuvor haben wir eine Standardfunktion definiert, def dump_func(x), jetzt können wir die anonyme Lambda-Funktion ausprobieren:

>>> stupid_func = (lambda x : x ** 2 + 5)
>>> print([stupid_func(1), stupid_func(3), stupid_func(5)])
[6, 14, 30]

Warum tun wir das? den obigen Ausdruck verwenden? Ein großer Teil des Grundes liegt darin, dass wir, wenn wir einige einfache Operationen ausführen möchten, dies tun können, ohne eine echte Funktion zu definieren. Um beispielsweise Listenelemente zu sortieren, kann eine intuitive Möglichkeit darin bestehen, die Methode sorted() zu verwenden:

>>> my_list = [2, 1, 0, -1, -2]
>>> print(sorted(my_list))
[-2, -1, 0, 1, 2]

Diese kann standardmäßig nur von groß nach klein oder von klein nach groß sortieren, jedoch mit Hilfe von Lambda-Ausdrücken , können wir mehr Freiheit bei den Sortierkriterien erreichen. Wie unten gezeigt, möchten wir die Liste nach der kleinsten Quadratzahl sortieren, die mithilfe einer Lambda-Funktion definiert werden kann, um der Methode sorted() mitzuteilen, wie sortiert werden soll.

>>> print(sorted(my_list, key = lambda x : x ** 2))
[0, -1, 1, -2, 2]

Map ist eine einfache Funktion, die eine Funktion auf ein anderes Sequenzelement anwendet, beispielsweise eine Liste. Wenn wir zwei Listen haben und die entsprechenden Elemente der beiden Listen multiplizieren möchten, können wir diese Funktion mithilfe der Lambda-Funktion und der Karte schnell erreichen:

>>> print(list(map(lambda x, y : x * y, [1, 2, 3], [4, 5, 6])))
[4, 10, 18]

Der obige Code ist sehr elegant, wenn Sie dies nicht tun Verwenden Sie beide. Oder der allgemeine Ausdruck muss wie folgt geschrieben werden:

>>> x, y = [1, 2, 3], [4, 5, 6]
>>> z = []
>>> for i in range(len(x)):
>>>     z.append(x[i] * y[i])
>>> print(z)
[4, 10, 18]

Einzeilige bedingte Anweisung

Wenn wir bedingte Anweisungen verwenden, dann ist dies der Fall wahrscheinlich so geschrieben:

>>> x = int(input())
>>> if x >= 10:
>>>     print("Horse")
>>> elif 1 < x < 10:
>>>     print("Duck")
>>> else:
>>>     print("Baguette")

Aber tatsächlich können wir auch alle Bedingungen in der Druckfunktion schreiben, das heißt, die obigen 7 Codezeilen können äquivalent wie die folgende Zeile geschrieben werden:

print("Horse" if x >= 10 else "Duck" if 1 < x < 10 else "Baguette")

Das sieht wirklich prägnant aus, wenn Sie sich ansehen, was Sie zuvor geschrieben haben. Es gibt wirklich viele Codes, die in diese Art von Ausdruck geändert werden können.

zip()

Bei der Einführung der Funktion „map()“ haben wir ein Beispiel für die Anwendung einer bestimmten Funktion auf zwei parallele Listen gegeben und die Funktion „zip( )“ erstellt es einfacher, dies zu tun.

Wenn wir zwei Listen haben, enthält die erste Liste Vornamen und die zweite Liste Nachnamen. Mit der Funktion zip() können wir sie wie folgt zusammenfügen.

>>> first_names = ["Peter", "Christian", "Klaus"]
>>> last_names = ["Jensen", "Smith", "Nistrup"]
>>> print([' '.join(x) for x in zip(first_names, last_names)])
['Peter Jensen', 'Christian Smith', 'Klaus Nistrup']

Mit anderen Worten, zip wandelt zwei Listen gleicher Länge in Eins-zu-eins-Paare um, das heißt (("Peter", "Jensen"), ("Christian", "Smith"), („Klaus“, „Nistrup“)).

Das obige ist der detaillierte Inhalt vonFünf Techniken für Python, um von der Liste zur zip()-Funktion abzuleiten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!