Kurs
30 coole Python-Tricks für besseren Code mit Beispielen
Python-Kenntnisse sind in den letzten Jahren immer gefragter geworden. Um dich bei der Entwicklung deiner Python-Programmierkenntnisse zu unterstützen, haben wir 30 coole Python-Tricks zusammengestellt, mit denen du deinen Code verbessern kannst. Versuche, in den nächsten 30 Tagen jeden Tag eine zu lernen, und sieh dir unseren Beitrag über die besten Praktiken in Python an, um sicherzustellen, dass dein Code der beste der Welt ist.
Wenn deine Python-Kenntnisse noch nicht ausreichen, kannst du sie mit unserem Lernpfad für Python auffrischen.
#1 Schneiden
a = "Hello World!"
print(a[::-1])
"""
!dlroW olleH
"""
Slicing ist eine Funktion in Python, die sich auf die Indizierung stützt, um den Zugriff auf eine Teilmenge einer Sequenz zu ermöglichen. Ein Index ist einfach die Position eines Elements in einer Folge. Wenn der Sequenztyp veränderbar ist, kannst du Slicing verwenden, um Daten zu extrahieren und zu verändern.
Hinweis: Wir können das Slicing auch für eine unveränderliche Sequenz verwenden, aber der Versuch, das Slicing zu ändern, führt zu einem TypeError.
Das Format, in dem Slices implementiert werden, ist: sequence[start:stop:step]. Wenn in den Parametern start, stop und step keine Werte angegeben sind, werden die Standardwerte für die Sequenz verwendet. Die Standardeinstellungen sind:
- "start" ist standardmäßig auf 0 gesetzt
- "stop" gibt die Länge der Sequenz vor
- "step" ist standardmäßig 1, wenn sie nicht angegeben werden.
Wenn du sequence[start:stop] angibst, werden die Elemente vom Startindex bis zum Stoppindex- 1 zurückgegeben (der Stoppindex wird nicht berücksichtigt).
Wir können auch negative Indizes übergeben, die dazu verwendet werden können, die Reihenfolge umzukehren. Zum Beispiel ist in einer Liste mit 4 Elementen der 0. Index auch der -4 Index und der letzte Index ist auch -1. Im obigen Beispielcode wurde dieses Wissen auf den Schrittparameter der Sequenz angewendet. Daher wurde die Zeichenkette rückwärts gedruckt, beginnend mit dem Ende der Sequenz bis zum Index 0.
#2 Inplace Swap / Simultane Zuweisung
a = 10
b = 5
print(f"First: {a, b}")
"""
First: (10, 5)
"""
a, b = b, a + 2
print(f"Second: {a, b}")
"""
Second: (5, 12)
"""
Wenn dein erster Eindruck war, dass der Wert von b 7 statt 12 sein würde, bist du in die Falle des Vertauschens an Ort und Stelle getappt.
In Python können wir Iterables in einer einzigen Zuweisung durch automatisches Auspacken in Variablen entpacken. Zum Beispiel:
a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)
"""
1
2
3
"""
Wir können auch mehrere Werte in einer einzigen Variablen mit * zusammenfassen - dieser Python-Trick wird Packing genannt. Unten siehst du ein Beispiel für die Verpackung.
a, b* = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""
Durch die Kombination von automatischem Ein- und Auspacken entsteht eine Technik, die als simultane Zuordnung bekannt ist. Wir können die gleichzeitige Zuweisung verwenden, um einer Reihe von Variablen eine Reihe von Werten zuzuweisen.
#3 Liste vs. Tupel
import sys
a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)
print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")
"""
List size: 112 bytes
Tuple size: 96 bytes
"""
Die meisten Python-Programmierer sind mit der Datenstruktur Liste vertraut. Das Gleiche kann man von Tupeln nicht sagen. Sie sind beide iterabel, ermöglichen Indizierung und erlauben die Speicherung heterogener Datentypen. Es gibt jedoch Situationen, in denen die Verwendung eines Tupels einer Liste vorzuziehen ist.
Erstens sind Listen veränderbar, das heißt, wir können sie nach Belieben verändern:
a = [1,2,3,4,5]
a[2] = 8
print(a)
"""
[1,2,8,4,5]
"""
Tupel hingegen sind unveränderlich, d.h. der Versuch, sie zu ändern, führt zu einem TypeError.
Aus diesem Grund sind Tupel speichereffizienter, da Python den richtigen Speicherblock für die Daten zuweisen kann. Im Gegensatz dazu muss bei einer Liste zusätzlicher Speicher zugewiesen werden, nur für den Fall, dass wir sie erweitern - das nennt man dynamische Speicherzuweisung.
TLDR; In Szenarien, in denen die Daten nicht geändert werden sollen, sollte eine Tupel-Datenstruktur aus Speichergründen einer Liste vorgezogen werden. Tupel sind auch schneller als Listen.
In diesem Tutorial erfährst du mehr über Python-Datenstrukturen.
#4 Generatoren
a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))
print(a)
print(b)
"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""
List comprehensions sind die Python-Methode, um eine Liste aus einer anderen Iterablen zu erstellen - das geht viel schneller als eine for-Schleife. Aber was passiert, wenn du die Klammern versehentlich von [] in () änderst? Du bekommst ein Generator-Objekt.
In Python erzeugen abgerundete Klammern mit Listenverstehenslogik ein sogenanntes Generatorobjekt. Generatoren sind eine besondere Art von Iterablen. Im Gegensatz zu Listen speichern sie ihre Gegenstände nicht. Stattdessen speichern sie Anweisungen, um jedes Element der Reihe nach zu erzeugen und den aktuellen Stand der Iterationen.
Jedes Element wird nur auf Anfrage mit einer Technik namens " lazy evaluation" erzeugt. Der Hauptvorteil dieses Python-Tipps mit einem Generator ist, dass er weniger Speicherplatz benötigt, da nicht die gesamte Sequenz auf einmal erstellt wird.
#5 Aliasing
a = [1, 2, 3, 4 ,5]
b = a
# Change the 4th index in b
b[4] = 7
print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.
"""
2278459070720
2278459070720
[1, 2, 3, 4, 7]
"""
Python ist eine objektorientierte Programmiersprache - alles ist ein Objekt. Die Zuweisung eines Objekts zu einem Bezeichner bedeutet also, dass ein Verweis auf das Objekt erstellt wird.
Wenn wir einen Bezeichner einem anderen Bezeichner zuordnen, haben wir am Ende zwei Bezeichner, die auf dasselbe Objekt verweisen. Das ist ein Konzept, das als Aliasing bekannt ist. Änderungen an einem Alias wirken sich auf den anderen aus. Manchmal ist dieses Verhalten erwünscht, aber oft überrascht es uns auch unvorbereitet.
Eine Möglichkeit, dieses Problem zu umgehen, ist der Verzicht auf Aliasing bei der Verwendung von veränderbaren Objekten. Eine andere Lösung könnte darin bestehen, statt einer Referenz einen Klon des Originalobjekts zu erstellen.
Die einfachste Art, einen Klon zu erstellen, ist das Slicing:
b = a[:]
Dadurch wird ein neuer Verweis auf ein Listenobjekt im Bezeichner b erstellt.
Du könntest dir viele andere Lösungen ausdenken, zum Beispiel list(a) aufrufen, wenn du die Daten einem anderen Bezeichner zuweist, und die copy() -Methode verwenden.
#6 Der "not"-Operator
a = []
print(not a)
"""
True
"""
Unser nächster Python-Tipp zeigt dir, wie du mit dem not-Operator ganz einfach überprüfen kannst, ob deine Datenstruktur leer ist. Pythons integrierte not ist ein logischer Operator, der True zurückgibt, wenn der Ausdruck nicht wahr ist, oder er gibt False zurück - er kehrt den Wahrheitswert von booleschen Ausdrücken und Objekten um.
Du kannst es auch in einer if-Anweisung verwenden:
if not a:
# do something...
Wenn a ist Wahr dann ist die not Operator zurück Falschzurück, und umgekehrt.
Es ist schwierig, sich das vorzustellen, also probiere es aus.
#7 F-Saiten
first_name = "John"
age = 19
print(f"Hi, I'm {first_name} and I'm {age} years old!")
"""
Hi, I'm John and I'm 19 years old!
"""
Gelegentlich müssen wir ein String-Objekt formatieren; Python 3.6 hat eine coole Funktion namens f-strings eingeführt, um diesen Prozess zu vereinfachen. Es ist hilfreich zu verstehen, wie Strings vor der neuen Version formatiert wurden, um die neue Methode besser zu verstehen.
So wurden die Strings früher formatiert:
first_name = "John"
age = 19
print("Hi, I'm {} and I'm {} years old!".format(first_name, age))
"""
Hi, I'm John and I'm 19 years old!
"""
Im Wesentlichen ist die neue Art der Formatierung schneller, lesbarer, prägnanter und schwieriger falsch zu machen.
Eine andere Möglichkeit, f-Strings zu verwenden, ist, den Namen eines Bezeichners zusammen mit dem Wert zu drucken. Dies wurde in Python 3.8 eingeführt.
x = 10
y = 20
print(f"{x = }, {y = }")
"""
x = 10, y = 20
"""
In diesem Tutorial über die Formatierung von F-Zeichenfolgen in Python erfährst du mehr.
#8 Der Parameter "end" der Druckfunktionen
a = ["english", "french", "spanish", "german", "twi"]
for language in a:
print(language, end=" ")
"""
english french spanish german twi
"""
Es ist durchaus üblich, eine print Anweisung zu verwenden, ohne einen ihrer optionalen Parameter zu definieren. Daher wissen viele Pythonistas nicht, dass du die Ausgabe bis zu einem gewissen Grad kontrollieren kannst.
Ein optionaler Parameter, den wir ändern können, ist end. Der Parameter end gibt an, was am Ende eines Aufrufs einer drucken Anweisung angezeigt werden soll.
Die Vorgabe für end ist "\n", was Python anweist, eine neue Zeile zu beginnen. Im obigen Code haben wir es in ein Leerzeichen geändert. So werden bei der Ausgabe alle Elemente unserer Liste in derselben Zeile ausgegeben.
#9 Anhängen an Tupel
a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)
"""
(1, 2, [1, 2, 3, 4])
"""
Wir wissen bereits, dass Tupel unveränderlich sind - siehe Python-Trick #3 Liste vs. Liste. Tupel. Der Versuch, den Status eines Tupels zu ändern, würde einen TypeError auslösen. Aber wenn du dir ein Tupel-Objekt als eine Folge von Namen vorstellst, die mit Objekten verknüpft sind, die nicht geändert werden können, siehst du die Dinge vielleicht anders.
Die ersten beiden Elemente unseres Tupels sind Ganzzahlen - sie sind unveränderlich. Das letzte Element unseres Tupels ist eine Liste, ein veränderbares Objekt in Python.
Wenn wir unsere Liste nur als einen weiteren Namen in einer Sequenz mit einer Bindung an ein Objekt betrachten, das nicht geändert werden kann, dann würden wir erkennen, dass die Liste immer noch innerhalb des Tupels geändert werden kann.
Würden wir dir empfehlen, dies in der Praxis zu tun? Wahrscheinlich nicht, aber es ist gut, das zu wissen!
#10 Zusammenführung von Wörterbüchern
a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}
a_and_b = a | b
print(a_and_b)
"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""
In Python 3.9 und höher ist es möglich, Wörterbücher mit | (bitweises ODER) zusammenzuführen. Zu diesem speziellen Python-Trick gibt es nicht viel mehr zu sagen, als dass er viel lesbarer ist!
#11 Ternärer Operator / Bedingungsausdrücke
condition = True
name = "John" if condition else "Doe"
print(name)
"""
John
"""
Im obigen Code siehst du einen sogenannten ternären Operator - er wird auch als bedingter Ausdruck unter Namen bezeichnet. Wir verwenden ternäre Operatoren, um Dinge danach zu bewerten, ob eine Bedingung Wahr oder Falsch.
Wir hätten unseren obigen Code auch wie folgt schreiben können:
condition = True
if condition:
name = "John"
else:
name = "Doe"
print(name)
"""
John
"""
Obwohl beide Codesätze zu demselben Ergebnis führen, können wir mit der ternären Bedingung einen viel kürzeren und klareren Code schreiben. Für Pythonisten ist das die "pythonischere" Art, Code zu schreiben.
#12 Duplikate aus Listen entfernen
a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))
"""
[1, 2, 3, 4, 5, 6, 7]
"""
Der einfachste Weg, doppelte Elemente aus einer Liste zu entfernen, ist die Umwandlung der Liste in eine Menge (und dann wieder zurück in eine Liste, wenn du möchtest).
Basierend auf der Veränderbarkeit sind Sets und Listen in Python recht ähnlich. Wir können in beiden Datenstrukturen nach Belieben Elemente hinzufügen und entfernen, aber sie sind trotzdem extrem unterschiedlich.
Listen sind geordnet, nullbasiert, indiziert und veränderbar. Mengen sind ungeordnet und unindiziert. Die Elemente in einer Menge müssen von einem unveränderlichen Typ sein, auch wenn die Menge selbst veränderbar ist - der Versuch, ein Element über einen Index abzurufen oder ein Element zu verändern, führt zu einem Fehler.
Ein weiterer wichtiger Unterschied zwischen Sets und Listen ist, dass Sets keine Duplikate enthalten können. Das hat uns geholfen, die doppelten Elemente aus unserer Liste zu entfernen.
#13 Eigenständige Unterstreichung
>>> print(_)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
>>> 1 + 2
3
>>> print(_)
3
Der Unterstrich (_) ist in Python ein zulässiger Bezeichner und kann daher verwendet werden, um auf ein Objekt zu verweisen. Aber underscore hat noch eine andere Aufgabe: das Ergebnis der letzten Auswertung zu speichern.
In der Dokumentation steht: "Der interaktive Interpreter stellt das Ergebnis der letzten Auswertung in der Variablen _ zur Verfügung. (Sie ist im Modul builtins gespeichert, zusammen mit eingebauten Funktionen wie print)."
Da wir dem Unterstrich vor dem Aufruf in der ersten Zeile kein Objekt zugewiesen haben, haben wir einen Fehler erhalten. Als wir jedoch die Ausgabe von 1 + 2 berechneten, speicherte der interaktive Interpreter das Ergebnis im Bezeichner _ für uns.
#14 Unterstreichen, um Werte zu ignorieren
for _ in range(100):
print("The index doesn't matter")
"""
The index doesn't matter
The index doesn't matter
...
"""
Im Python-Tipp Nr. 13 haben wir erfahren, dass der interaktive Interpreter das letzte Ergebnis einer Auswertung im Unterstrich (_) zur Verfügung stellt, aber das ist nicht sein einziger Anwendungsfall.
Wir können sie auch verwenden, um Objekte zu repräsentieren, die uns nicht interessieren oder die wir später im Programm nicht mehr brauchen würden. Das ist wichtig, weil die Verwendung eines Bezeichners anstelle eines Unterstrichs (_) zu einem F841-Fehler führt, wenn wir versuchen, unser Programm zu linting. Ein F841-Fehler besagt einfach, dass ein lokaler Variablenname zugewiesen wurde, aber nicht im Programm verwendet wurde, was eine schlechte Praxis ist.
#15 Hintere Unterstriche
list_ = [0, 1, 2, 3, 4]
global_ = "Hi there"
Ein weiterer Grund für die Verwendung des Unterstrichs (_) in Python ist es, Konflikte mit Python-Schlüsselwörtern zu vermeiden.
In PEP 8 wird erwähnt, dass ein nachgestellter Unterstrich (_) "per Konvention verwendet werden sollte, um Konflikte mit Python-Schlüsselwörtern zu vermeiden." Außerdem heißt es: "Es ist in der Regel besser, einen einzelnen Unterstrich am Ende anzuhängen, als eine Abkürzung oder eine Rechtschreibverfälschung zu verwenden. Daher ist list_ besser als lst."
#16 Führende Unterstriche
class Example:
def __init__(self):
self._internal = 2
self.external = 20
Erfahrene Python-Programmierer neigen oft dazu, einem Bezeichner oder Methodennamen einen Unterstrich voranzustellen - und das aus gutem Grund.
Der Unterstrich, der einem Bezeichner oder einer Methode vorangestellt ist, hat eine versteckte Bedeutung: Diese Variable oder Methode ist nur für den internen Gebrauch bestimmt. Im Wesentlichen handelt es sich um einen Haftungsausschluss für andere Programmierer, der in PEP 8 definiert wurde, aber von Python nicht durchgesetzt wird. Führende Unterstriche sind also ein schwacher Indikator.
Im Gegensatz zu Java gibt es in Python keine strenge Unterscheidung zwischen privaten und öffentlichen Variablen. Mit anderen Worten: Sie hat nur deshalb eine Bedeutung, weil die Python-Gemeinschaft zugestimmt hat, dass sie eine Bedeutung hat. Ihre Einbeziehung hat keinen Einfluss auf das Verhalten deiner Programme.
#17 Underscore Visual
Hier ist der letzte Tipp zum Unterstrich; Bis jetzt haben wir drei verschiedene Anwendungsfälle für den Unterstrich behandelt, aber du kannst dir unser Tutorial ansehen, um mehr über die Rolle des Unterstrichs (_) in Python zu erfahren.
number = 1_500_000
print(number)
"""
15000000
"""
Eine weitere Möglichkeit, den Unterstrich zu verwenden, ist die Verwendung als visuelles Trennzeichen für die Gruppierung von Ziffern in Ganzzahl-, Fließkomma- und komplexen Zahlenliteralen - dies wurde in Python 3.6 eingeführt.
Die Idee war, die Lesbarkeit von langen Literalen zu verbessern oder von Literalen, deren Wert eindeutig in Teile zerlegt werden sollte - mehr darüber kannst du in PEP 515 lesen.
#18 __name__ == "__main__"
if __name__ == "__main__":
print("Read on to understand what is going on when you do this.")
"""
print("Read on to understand what is going on when you do this.")
"""
Die Wahrscheinlichkeit ist groß, dass du diese Syntax schon in mehreren Python-Programmen gesehen hast. Python verwendet einen speziellen Namen namens "__main__" und setzt ihn auf einen Bezeichner namens __name__, wenn die ausgeführte Python-Datei das Hauptprogramm ist.
Wenn wir uns entscheiden, das im Screenshot gezeigte Modul in ein anderes Modul (Python-Datei) zu importieren und diese Datei auszuführen, wird die Wahrheit des Ausdrucks in unserem Code falsch sein. Das liegt daran, dass beim Import aus einem anderen Modul der __name__-Bezeichner auf den Namen des Moduls (Python-Datei) gesetzt wird.
#19 Die Methode 'setdefault'
import pprint
text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"
counts = {}
for word in text.split():
counts.setdefault(word, 0)
counts[word] += 1
pprint.pprint(counts)
"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"
Du möchtest vielleicht einen Wert für verschiedene Schlüssel in einem Wörterbuch festlegen. Zum Beispiel, wenn du die Anzahl der Wörter in einem Korpus verfolgst. Die übliche Vorgehensweise ist wie folgt:
- Prüfe, ob der Schlüssel im Wörterbuch existiert
- Wenn ja, erhöhe den Wert um 1.
- Wenn das nicht der Fall ist, füge sie hinzu und setze den Wert auf 1.
So sieht es im Code aus:
counts = {}
for word in text.split():
if word in counts:
counts[word] += 1
else:
counts[word] = 1
Eine prägnantere Methode ist die Verwendung der setdefault() -Methode für dein Wörterbuchobjekt.
Das erste Argument, das an die Methode übergeben wird, ist der Schlüssel, auf den wir prüfen wollen. Das zweite Argument, das übergeben wird, ist der Wert, auf den der Schlüssel gesetzt werden soll, wenn er noch nicht im Wörterbuch vorhanden ist - wenn der Schlüssel vorhanden ist, gibt die Methode den Schlüsselwert zurück. Sie würde also nicht geändert werden.
#20 Übereinstimmende Regex
import re
number = re.compile(r"(0?)(\+44)?\d(10)")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")
print(num_1.group())
print(num_2.group())
"""
'+447999999999'
'07999999999'
"""
Mit regulären Ausdrücken kannst du ein Textmuster angeben, nach dem gesucht werden soll. Die meisten Menschen wissen, dass man mit der Tastenkombination STRG + F (Windows) nach etwas suchen kann, aber wie soll man es finden, wenn man nicht genau weiß, wonach man sucht? Die Antwort ist, nach Mustern zu suchen.
Britische Nummern zum Beispiel folgen einem ähnlichen Muster: Sie haben eine Null am Anfang und zehn Ziffern oder +44 anstelle von Null und zehn Ziffern - der zweite Fall zeigt an, dass es sich um das internationale Format handelt.
Reguläre Ausdrücke sind eine große Zeitersparnis. Wenn wir statt der Regex Regeln für die Instanzen in unserem Bild kodieren würden, könnte das bis zu 10+ Zeilen Code erfordern.
Zu lernen, wie reguläre Ausdrücke funktionieren, ist wichtig, auch wenn du keinen Code schreibst. Die meisten modernen Texteditoren und Textverarbeitungsprogramme erlauben es dir, reguläre Ausdrücke zum Suchen und Ersetzen von Merkmalen zu verwenden.
#21 Regex Pipe
import re
heros = re.compile(r"Super(man|woman|human)")
h1 = heros.search("This will find Superman")
h2 = heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")
print(h1.group())
print(h2.group())
print(h3.group())
"""
Superman
Superwoman
Superhuman
"""
Reguläre Ausdrücke haben ein spezielles Zeichen namens Pipe(|), mit dem du einen von vielen Ausdrücken abgleichen kannst, und sie können überall verwendet werden. Das ist besonders praktisch, wenn du mehrere ähnliche Muster hast.
Zum Beispiel haben "Superman", "Superwoman" und "Superhuman" alle die gleiche Vorsilbe. So kannst du die Pfeife nutzen, um den Teil des Musters beizubehalten, der immer wiederkehrt, und die Teile ändern, die anders sein sollen. So sparst du wieder einmal wertvolle Zeit.
Aber Achtung: Wenn alle Ausdrücke, die du abgleichen möchtest, im selben Text vorkommen, wird das erste Vorkommen des passenden Textes zurückgegeben - d.h. "Ein Beispieltext, der Superwoman, Superman, Superhuman enthält", würde Superwoman zurückgeben.
#22 Der Parameter 'sep' der Druckfunktion
day = "04"
month = "10"
year = "2022"
print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")
"""
04 10 2022
04/10/2022
04.10.2022
"""
Die Zahl der Python-Programmierer/innen, die nicht wissen, was die print() -Funktion alles kann, ist erschreckend. Wenn "Hello World" dein erstes Programm war, war die print() -Funktion wahrscheinlich eine der ersten eingebauten Funktionen, die du beim Erlernen von Python behandelt hast. Wir verwenden print(), um formatierte Nachrichten auf dem Bildschirm anzuzeigen, aber die Funktion print() kann noch viel mehr.
Im obigen Code haben wir verschiedene Möglichkeiten gezeigt, wie wir unsere formatierte Nachricht anzeigen können. Der sep-Parameter ist ein optionales Argument in der print() -Funktion, mit dem wir angeben können, wie Objekte getrennt werden sollen, wenn wir mehr als eines einschließen.
Standardmäßig werden sie durch ein Leerzeichen getrennt, aber wir haben diese Funktionalität mit unseren Druckanweisungen geändert - eine, bei der sep auf "" gesetzt ist, und eine andere, bei der sep auf "." gesetzt ist .
#23 Lambda Functions
def square(num:int) -> int:
return num ** 2
print(f"Function call: {square(4)}")
"""
Function call: 16
"""
square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""
Lambda-Funktionen führen dich zu den Dingen, die du mit Python auf mittlerem bis fortgeschrittenem Niveau machen kannst - lerne Python für Fortgeschrittene mit diesem Kurs. Sie sehen auf den ersten Blick kompliziert aus, aber sie sind ganz einfach.
In unserem Beispielcode haben wir nur ein Argument verwendet, aber wir hätten auch mehrere verwenden können:
square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""
Mit dem Schlüsselwort lambda können wir kleine, beschränkte, anonyme Funktionen in einer Zeile erstellen. Sie verhalten sich wie eine normale Funktion, die mit dem Schlüsselwort def deklariert wird, nur dass diese Funktionen keinen Namen haben.
#24 Die "Swapcase"-Methode
string = "SoMe RaNDoM sTriNg"
print(string.swapcase())
"""
sOmE rAndOm StRInG
"""
Die swapcase() -Methode wird auf ein String-Objekt angewendet, damit wir in einer einzigen Codezeile die Großbuchstaben in Kleinbuchstaben und umgekehrt ändern können. Es gibt nicht viele Anwendungsfälle für die Methode swapcase(), aber es ist gut zu wissen.
#25 Die 'isalnum' Methode
password = "ABCabc123"
print(password.isalnum())
"""
True
"""
Nehmen wir an, wir erstellen ein Programm, bei dem die Benutzer ein Passwort eingeben müssen, das aus einer Kombination von Zahlen und Buchstaben bestehen muss. Wir können dies in einer Zeile Code tun, indem wir die Funktion isalnum() für die String-Instanz aufrufen.
Die Methode prüft, ob alle Zeichen Teil des Alphabets (A-Za-z) und der Ziffern (0-9) sind. Ein Leerzeichen oder ein Symbol (!#%$&? etc.) gibt Falsch.
#26 Behandlung von Ausnahmen
def get_ration(x:int, y:int) -> int:
try:
ratio = x/y
except: ZeroDivisionError:
y = y + 1
ratio = x/y
return ratio
print(get_ratio(x=400, y=0))
"""
400.0
"""
Python-Programme brechen ab, wenn sie auf einen Fehler stoßen.
Manchmal wollen wir dieses Verhalten nicht, zum Beispiel wenn ein Endbenutzer mit unserem Code interagiert. Wie schlimm wäre es, wenn unser Code in einem solchen Fall vorzeitig abgebrochen würde?
Es gibt ein paar Denkansätze, wie man mit dem Ausnahmefall umgehen kann. Die meisten Python-Programmiererinnen und -Programmierer sind der Meinung, dass es einfacher ist, um Vergebung zu bitten, als um Erlaubnis zu bitten. Das bedeutet, dass sie lieber einen ausgelösten Fehler abfangen, indem sie einen umgebenden Kontext bereitstellen, der in der Lage ist, eine Ausnahme zu behandeln. Dahinter steht die Überlegung, dass es keinen Sinn macht, Zeit damit zu verschwenden, sich gegen alle möglichen Ausnahmefälle abzusichern.
Das gilt aber nur, wenn es einen Mechanismus gibt, um ein Problem zu bewältigen, nachdem es aufgetreten ist.
#27 Die Unterschiede in Listen erkennen
list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))
print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")
"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""
Hier sind drei verschiedene Methoden, um die Differenz zwischen zwei Listen in Python zu vergleichen.
Hinweis: Wenn du nicht mit Sicherheit weißt, dass Liste_1 eine Teilmenge von Liste_2 ist, ist Lösung 1 nicht dasselbe wie die anderen beiden Lösungen.
#28 Args & Kwargs
def some_function(*args, **kwargs):
print(f"Args: {args}")
print(f"Kwargs: {kwargs}")
some_function(1, 2, 3, a=4, b=5, c=6)
"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""
Wir verwenden *args und **kwargs als Parameter für eine Funktion, wenn wir nicht wissen, wie viele Variablen unsere Funktion erwarten soll.
Mit dem Parameter *args können wir einer Funktion eine variable Anzahl von Parametern übergeben, wenn sie nicht mit Schlüsselwörtern versehen ist (d.h. die Parameter, die wir übergeben, benötigen keinen zugehörigen Namen). Der Parameter **kwargs hingegen ermöglicht es uns, einer Funktion eine beliebige Anzahl von Parametern mit Schlüsselwörtern zu übergeben.
In Wahrheit sind die Wörter *args und **kwargs nicht so magisch: Die wahre Magie steckt in den Sternchen (*). Das bedeutet, dass wir jedes beliebige Wort nach den Sternchen hätten verwenden können, aber die Verwendung von args und kwargs ist gängige Praxis und wird von Python-Entwicklern durchgesetzt.
#29 Die Ellipse
print(...)
"""
Ellipsis
"""
def some_function():
...
# Alternative solution
def another_function():
pass
Das Ellipsis ist ein Python-Objekt, das durch die Angabe einer Folge von drei Punkten (...) oder durch den Aufruf des Objekts selbst (Ellipsis) aufgerufen werden kann.
Die wichtigste Anwendung ist der Zugriff auf und das Slicen von mehrdimensionalen Arrays, z. B. in NumPy:
import numpy as np
arr = np.array([[2,3], [1,2], [9,8]])
print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])
"""
[[2 3]
[1 2]
[9 8]]
"""
Eine andere Verwendung von Ellipsis ist als Platzhalter in einer nicht implementierten Funktion.
Das heißt, du könntest Ellipsis, ..., oder pass, und sie wären alle noch gültig.
#30 Listenverständnis
even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)
"""
[2, 4, 6, 8]
"""
Unser letzter Python-Trick sind List Comprehensions, eine elegante Methode, um eine Liste aus einer anderen Sequenz zu erstellen. Mit ihnen kannst du eine ausgefeilte Logik und Filterung durchführen, wie wir es im obigen Code getan haben.
Es gibt andere Wege, um das gleiche Ziel zu erreichen; wir hätten zum Beispiel eine Lambda-Funktion wie folgt verwenden können:
even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""
Einige Pythonistas würden jedoch argumentieren, dass diese Lösung viel weniger lesbar ist als das Listenverständnis.
In diesem Tutorial erfährst du mehr über Python List Comprehensions.
Top Python Kurse
Kurs
Funktionen in Python schreiben
Kurs