30 coole Python-Tricks für besseren Code mit Beispielen

Die Nachfrage nach Python-Programmierkenntnissen ist in den letzten Jahren echt gestiegen. Um dir beim Lernen von Python zu helfen, haben wir 30 coole Python-Tricks zusammengestellt, mit denen du deinen Code verbessern kannst. Versuch, in den nächsten 30 Tagen jeden Tag etwas Neues zu lernen, und schau dir unseren Beitrag zu den Best Practices für Python an, um sicherzustellen, dass dein Code top ist. 

Wenn deine Python-Kenntnisse nicht so gut sind, kannst du sie auch mit unserem Python Skill Lernpfad verbessern.

#1 Schneiden

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Slicing ist eine Funktion in Python, die auf Indizierung basiert und es Leuten ermöglicht, auf einen Teil einer Sequenz zuzugreifen. Ein Index ist einfach die Position eines Elements in einer Reihenfolge. Wenn der Sequenztyp veränderbar ist, kannst du Slicing nutzen, um Daten zu extrahieren und zu ändern. 

Anmerkung: Wir können Slicing auch bei einer unveränderlichen Sequenz anwenden, aber wenn wir versuchen, das Slice zu ändern, kommt es zu einem TypeError. 

Das Format, in dem Slices umgesetzt werden, ist: sequence[start:stop:step]. Wenn du keine Werte für die Parameter „start“, „stop“ und „step“ angibst, werden die Standardwerte verwendet. Die Standardeinstellungen sind: 

• „start“ ist standardmäßig auf 0 eingestellt. 
• „stop“ ist standardmäßig auf die Länge der Sequenz eingestellt.
• „step“ ist standardmäßig auf 1 gesetzt, wenn nichts anderes angegeben wird. 

Wenn du sequence[start:stop] angibst, werden die Elemente vom Startindex bis zum Stoppindex-1zurückgegeben (der Stoppindex ist nicht dabei). 

Wir können auch negative Indizes übergeben, die zum Umkehren der Reihenfolge verwendet werden können. In einer Liste mit vier Elementen ist der Index 0 zum Beispiel auch der Index -4, und der letzte Index ist auch -1. Im obigen Beispielcode wurde dieses Wissen auf den Parameter „step“ der Sequenz angewendet. Deshalb wurde die Zeichenfolge rückwärts gedruckt, beginnend vom Ende der Sequenz bis zum Index 0.   

#2 Inplace-Swap / Gleichzeitige 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 du zuerst gedacht hast, dass der Wert von b 7 statt 12 ist, bist du auf den In-Place-Swap reingefallen. 

In Python können wir iterierbare Objekte mit automatischem Entpacken in einer einzigen Zuweisung 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 mit * in einer einzigen Variablen zusammenfassen – dieser Python-Trick heißt „Packing”. Hier ist ein Beispiel für das Packen.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

Wenn man automatisches Packen und Auspacken kombiniert, kommt eine Technik raus, die man als simultane Zuweisung bezeichnet. Wir können die simultane Zuweisung nutzen, 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: 52 bytes
Tuple size: 40 bytes
"""

Die meisten Python-Programmierer kennen die Listen-Datenstruktur. Das Gleiche kann man von Tupeln nicht sagen. Beide sind iterierbar, lassen sich indizieren und ermöglichen die Speicherung von unterschiedlichen Datentypen. Aber es gibt Situationen, in denen ein Tupel besser ist als eine Liste. 

Also, Listen sind veränderbar, was heißt, dass wir sie nach Belieben anpassen können: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Tupel hingegen sind unveränderlich, was bedeutet, dass der Versuch, sie zu ändern, einen TypeError auslöst. 

Deshalb sind Tupel speichereffizienter, weil Python den richtigen Speicherblock für die Daten zuweisen kann. Im Gegensatz dazu muss bei einer Liste zusätzlicher Speicherplatz reserviert werden, falls wir sie erweitern – das nennt man dynamische Speicherzuweisung. 

TLDR; Wenn du nicht willst, dass die Daten geändert werden, solltest du aus Speicherplatzgründen lieber eine Tupel-Datenstruktur statt einer Liste nehmen. Tupel sind auch schneller als Listen. 

Lerne in diesem Tutorial 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>
"""

Listenkomprimierungen sind die Python-Art, eine Liste aus einem anderen iterierbaren Objekt zu erstellen – das geht viel schneller als mit einer for-Schleife. Aber was passiert, wenn du aus Versehen die Klammern von [] zu () änderst? Du bekommst ein Generatorobjekt.

In Python machen runde Klammern mit Listenverständnis-Logik ein sogenanntes Generatorobjekt. Generatoren sind eine spezielle Art von Iterierbaren. Anders als Listen speichern sie ihre Elemente nicht. Stattdessen speichern sie Anweisungen, um jedes Element der Reihe nach zu generieren, sowie den aktuellen Stand der Iterationen.

Jedes Element wird nur bei Bedarf mit einer Technik namens „Lazy Evaluation“ generiert. Der Hauptvorteil dieses Python-Tipps mit einem Generator ist, dass er weniger Speicher braucht, weil nicht die ganze 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.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python ist eine objektorientierte Programmiersprache – alles ist ein Objekt. Also, wenn du ein Objekt einem Identifikator zuordnest, machst du eine Referenz auf das Objekt. 

Wenn wir eine Kennung einer anderen Kennung zuweisen, haben wir am Ende zwei Kennungen, die auf dasselbe Objekt verweisen. Das ist ein Konzept, das man als Aliasing bezeichnet. Änderungen an einem Alias wirken sich auch auf den anderen aus. Manchmal ist dieses Verhalten erwünscht, aber oft überrascht es uns einfach. 

Eine Möglichkeit, das zu umgehen, ist, bei der Verwendung von veränderbaren Objekten auf Aliasing zu verzichten. Eine andere Möglichkeit wäre, einen Klon des Originalobjekts zu erstellen, statt nur eine Referenz. 

Der einfachste Weg, einen Klon zu erstellen, ist das Slicing zu nutzen: 

b = a[:] 

Dadurch wird eine neue Referenz auf ein Listenobjekt im Bezeichner b erstellt. 

Du könntest viele andere Lösungen finden, wie zum Beispiel list(a) aufzurufen, wenn du die Daten einem anderen Bezeichner zuweist, und die Methode copy() zu verwenden. 

#6 Der Operator „not“

a = []
print(not a)

"""
True
"""

Unser nächster Python-Tipp ist die einfachste Methode, um mit dem Operator „not“ zu checken, ob deine Datenstruktur leer ist. Python's integrierte not ist ein logischer Operator, der „True“ zurückgibt, wenn der Ausdruck nicht wahr ist, und andernfalls „False“ – er kehrt den Wahrheitswert von booleschen Ausdrücken und Objekten um.  

Eine andere Möglichkeit, wie du es sehen kannst, ist in einer if-Anweisung: 

if not a:
    # do something... 

Wenn a ist wahr , dann ist das nicht gibt der Operator False, und umgekehrt. 

Es ist nicht ganz einfach, das zu verstehen, also probier's einfach mal 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!
"""

Manchmal müssen wir vielleicht ein String-Objekt formatieren. Python 3.6 hat eine coole Funktion namens f-Strings eingeführt, um das einfacher zu machen. Es hilft, zu wissen, wie Strings vor der neuen Version formatiert wurden, um die neue Methode besser zu verstehen. 

So wurden Zeichenfolgen 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 Grunde ist die neue Formatierung schneller, übersichtlicher, knapper und weniger anfällig für Fehler.

Eine andere Verwendung von f-Strings ist, einen Bezeichnernamen zusammen mit dem Wert auszudrucken. Das wurde in Python 3.8 eingeführt.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Schau dir dieses Tutorial zur F-String-Formatierung in Python an, um mehr zu erfahren. 

#8 Der Parameter „end“ der Druckfunktionen

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Es ist ziemlich üblich, einen print Anweisung zu benutzen, ohne irgendwelche ihrer optionalen Parameter festzulegen. Deshalb wissen viele Python-Nutzer nicht, dass man die Ausgabe bis zu einem gewissen Grad steuern kann.

Ein optionaler Parameter, den wir ändern können, ist „end“. Der Parameter „end“ sagt uns, was am Ende eines Aufrufs eines print angezeigt werden soll. 

Die Standardeinstellung für „end“ ist „\n“, was Python sagt, dass es eine neue Zeile anfangen soll. Im Code oben haben wir es in ein Leerzeichen geändert. So werden alle Elemente unserer Liste in derselben Zeile ausgegeben.

#9 An Tupel anhängen

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Wir wissen schon, dass Tupel unveränderlich sind – siehe Python-Trick #3 Liste vs. Tupel-. Der Versuch, den Zustand eines Tupels zu ändern, würde einen TypeError auslösen. Wenn du dir ein Tupelobjekt aber als eine Folge von Namen vorstellst, die mit Objekten verbunden sind, die nicht geändert werden können, siehst du die Sache vielleicht anders.

Die ersten beiden Elemente unseres Tupels sind ganze Zahlen – sie sind unveränderlich. Das letzte Element unseres Tupels ist eine Liste, ein veränderbares Objekt in Python.

Wenn wir unsere Liste einfach als einen weiteren Namen in einer Sequenz mit einer Bindung an ein Objekt betrachten, das nicht geändert werden kann, würden wir feststellen, dass die Liste trotzdem innerhalb des Tupels geändert werden kann.

Würden wir dir empfehlen, das in der Praxis zu machen? Wahrscheinlich nicht, aber es ist eine dieser Sachen, die man einfach wissen sollte!

#10 Wörterbücher zusammenführen

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}
"""

Ab Python 3.9 kann man Wörterbücher mit | (bitweises ODER) zusammenführen. Zu diesem speziellen Python-Trick gibt's nicht viel mehr zu sagen, außer dass es eine viel besser lesbare Lösung ist!  

#11 Ternärer Operator / Bedingungsausdrücke 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

Im Code oben siehst du einen sogenannten ternären Operator – der wird auch als bedingter Ausdruck bezeichnet. Wir benutzen ternäre Operatoren, um Dinge zu bewerten, je nachdem, ob eine Bedingung erfüllt ist oder nicht. wahr oder falsch.

Wir hätten unseren Code oben auch so schreiben können:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Auch wenn beide Codes dasselbe Ergebnis liefern, sieh dir mal an, wie wir mit der ternären Bedingung einen viel kürzeren und übersichtlicheren Code schreiben können. Das ist, was Python-Fans als die „Pythonic“-Art des Programmierens bezeichnen würden. 

#12 Duplikate aus Listen löschen

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 Liste in eine Menge umzuwandeln (und dann wieder in eine Liste, wenn du willst).

Aufgrund ihrer Veränderbarkeit sind Sets und Listen in Python ziemlich ähnlich. Wir können nach Belieben Elemente zu beiden Datenstrukturen hinzufügen oder daraus entfernen, aber sie sind trotzdem extrem unterschiedlich.

Listen sind geordnet, haben eine Null-basierte Indizierung und sind veränderbar. Sets sind nicht sortiert und nicht indiziert. Die Elemente in einem Set müssen unveränderlich sein, auch wenn das Set selbst veränderbar ist – wenn du versuchst, ein Element über einen Index abzurufen oder ein Element zu ändern, kommt es zu einem Fehler.

Ein weiterer wichtiger Unterschied zwischen Mengen und Listen ist, dass Mengen keine Duplikate haben dürfen. Das hat uns geholfen, die doppelten Elemente aus unserer Liste zu entfernen.

#13 Alleinstehender Unterstrich 

>>> 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, sodass man ihn verwenden kann, um auf ein Objekt zu verweisen. Aber underscore hat noch eine andere Aufgabe: Es speichert das Ergebnis der letzten Auswertung.

In der Doku steht, dass „der interaktive Interpreter das Ergebnis der letzten Auswertung in der Variablen _ verfügbar macht. (Es ist im Modul „builtins“ gespeichert, zusammen mit integrierten Funktionen wie „print“).

Da wir dem Unterstrich vor dem Aufruf in der ersten Zeile kein Objekt zugewiesen haben, haben wir eine Fehlermeldung bekommen. Als wir aber 1 + 2 gerechnet haben, hat der interaktive Interpreter das Ergebnis für uns im Identifikator _ gespeichert. 

#14 Unterstrich zum Ignorieren von Werten

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

In Python-Tipp Nr. 13 haben wir gesehen, dass der interaktive Interpreter das letzte Ergebnis einer Auswertung im Unterstrich-Bezeichner (_) verfügbar macht, aber das ist nicht die einzige Möglichkeit, ihn zu nutzen.

Wir können es auch nutzen, um Sachen darzustellen, die uns egal sind oder die wir später im Programm nicht mehr brauchen. Das ist wichtig, weil die Verwendung eines Bezeichners anstelle eines Unterstrichs (_) einen F841-Fehler auslöst, wenn wir versuchen, unser Programm zu linting. Ein F841-Fehler bedeutet einfach, dass ein lokaler Variablenname zugewiesen wurde, aber im Programm nicht benutzt wurde, was echt schlecht ist.

#15 Nachgestellte Unterstriche

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Anknüpfend an die letzten beiden Tricks, die Verwendung des Unterstrichs (_) in Python, ist ein weiterer Zweck davon, Konflikte mit Python-Schlüsselwörtern zu vermeiden. 

PEP 8 sagt, dass ein nachgestellter Unterstrich (_) „nach Konvention verwendet werden sollte, um Konflikte mit Python-Schlüsselwörtern zu vermeiden”. Es heißt auch, dass es meistens besser ist, einen Unterstrich am Ende hinzuzufügen, statt eine Abkürzung oder eine falsche Schreibweise zu verwenden. Also ist list_ besser als lst.

#16 Führende Unterstriche

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Du wirst oft feststellen, dass erfahrene Python-Programmierer dazu neigen, Identifikatoren oder Methodennamen mit einem Unterstrich zu beginnen – und das aus gutem Grund.

Der Unterstrich vor einem Bezeichner oder einer Methode hat eine versteckte Bedeutung: Diese Variable oder Methode ist nur für den internen Gebrauch gedacht. Im Grunde ist es ein Hinweis für andere Programmierer, der in PEP 8 festgelegt wurde, aber von Python nicht erzwungen wird. Also, führende Unterstriche sind ein schwacher Indikator.

Anders als Java macht Python keinen großen Unterschied zwischen privaten und öffentlichen Variablen. Mit anderen Worten: Es hat nur deshalb eine Bedeutung, weil die Python-Community sich darauf geeinigt hat, dass es eine Bedeutung hat. Das macht keinen Unterschied, wie deine Programme laufen.

#17 Unterstreichung Visual

Hier ist der letzte Tipp zu Unterstrichen: Bisher 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 andere Möglichkeit, den Unterstrich zu nutzen, ist als visuelles Trennzeichen für die Gruppierung von Ziffern in ganzzahligen, Gleitkomma- und komplexen Zahlenliteralen – das wurde in Python 3.6 eingeführt. 

Die Idee war, die Lesbarkeit von langen Literalen oder Literalen, deren Wert klar in Teile getrennt werden sollte, zu verbessern – mehr dazu findest du in PEP 515.

#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.")
"""

Wahrscheinlich hast du diese Syntax schon in mehreren Python-Programmen gesehen. Python benutzt einen speziellen Namen namens „__main__“ und setzt ihn auf einen Bezeichner namens __name__, wenn die ausgeführte Python-Datei das Hauptprogramm ist.

Wenn wir das im Screenshot gezeigte Modul in ein anderes Modul (Python-Datei) importieren und diese Datei ausführen, ist der Ausdruck in unserem Code falsch. Das liegt daran, dass beim Importieren aus einem anderen Modul der Bezeichner __name__ 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 im Lernpfad die Anzahl der Wörter in einem Korpus ermittelst. Normalerweise geht man so vor: 

1. Schau mal, ob der Schlüssel im Wörterbuch drauf ist.
2. Wenn ja, erhöhe den Wert um 1.
3. Wenn nicht, füge es hinzu und setz den Wert auf 1.

So sieht das im Code aus:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Eine einfachere Möglichkeit dafür ist, die Methode setdefault() für dein Dictionary-Objekt zu nutzen.

Das erste Argument, das an die Methode übergeben wird, ist der Schlüssel, den wir überprüfen wollen. Das zweite übergebene Argument ist der Wert, den der Schlüssel haben soll, wenn er noch nicht im Wörterbuch ist – wenn der Schlüssel schon da ist, gibt die Methode den Schlüsselwert zurück. Also, es würde nicht geändert werden.

#20 Passende 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 Suchmuster für Text festlegen. Die meisten wissen, dass man mit STRG + F (Windows) nach Sachen suchen kann, aber wenn du nicht genau weißt, wonach du suchst, wie willst du es dann finden? Die Lösung ist, nach Mustern zu suchen.  

Die Nummern aus Großbritannien sehen ähnlich aus: Sie fangen mit einer Null und zehn Ziffern an oder mit +44 statt Null und zehn Ziffern – das zweite Beispiel zeigt, dass es sich um das internationale Format handelt. 

Reguläre Ausdrücke sparen echt viel Zeit. Wenn wir Regeln programmieren würden, um die Instanzen in unserem Bild zu erfassen, anstatt reguläre Ausdrücke zu verwenden, könnte das mehr als 10 Zeilen Code erfordern. 

Es ist echt wichtig zu wissen, wie reguläre Ausdrücke funktionieren, auch wenn du keinen Code schreibst. Die meisten modernen Texteditoren und Textverarbeitungsprogramme lassen dich reguläre Ausdrücke zum Suchen und Ersetzen von Elementen 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 echt praktisch, wenn du mehrere ähnliche Muster hast.

Zum Beispiel haben „Superman“, „Superwoman“ und „Superhuman“ alle das gleiche Präfix. Du kannst also die Pipe nutzen, um den Teil des Musters zu behalten, der immer wieder vorkommt, und die Teile ändern, die anders sein sollen. Wieder mal sparst du wertvolle Zeit.

Pass auf: Wenn alle Ausdrücke, die du finden willst, im selben Text vorkommen, wird der erste Text, der passt, angezeigt – also würde „Ein Beispieltext mit Superwoman, Superman, Superhuman“ Superwoman anzeigen.

#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 Anzahl der Python-Programmierer, die nicht wissen, was die print() -Funktion alles kann, ist echt erschreckend. Wenn „Hello World“ dein erstes Programm war, war die print() -Funktion wahrscheinlich eine der ersten eingebauten Funktionen, die du beim Lernen von Python kennengelernt hast. Wir benutzen print(), um formatierte Meldungen auf dem Bildschirm anzuzeigen, aber die print() -Funktion kann noch viel mehr. 

Im Code oben haben wir verschiedene Möglichkeiten gezeigt, wie wir unsere formatierte Nachricht anzeigen können. Der Parameter „sep“ ist ein optionales Argument in der Funktion „print()“, mit dem wir festlegen können, wie Objekte getrennt werden sollen, wenn wir mehr als eines einfügen. 

Standardmäßig werden sie durch ein Leerzeichen getrennt, aber wir haben diese Funktion mit unseren Druckanweisungen geändert – eine, bei der sep auf „“ gesetzt ist , und eine andere, bei der sep auf „.“ gesetzt ist .

#23 Lambda-Funktionen 

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
"""

Mit Lambda-Funktionen kommst du zu den etwas fortgeschritteneren Sachen, die du mit Python machen kannst – lerne in diesem Kurs Python für Fortgeschrittene. Auf den ersten Blick sehen sie kompliziert aus, aber eigentlich sind sie ziemlich einfach.

In unserem Beispielcode haben wir nur ein Argument benutzt, aber wir hätten auch mehrere nehmen können, wenn wir wollten:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

Im Grunde genommen können wir mit dem Schlüsselwort „lambda“ kleine, eingeschränkte, anonyme Funktionen in einer Zeile erstellen. Sie funktionieren wie normale Funktionen, die mit dem Schlüsselwort „def“ deklariert werden, 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 Großbuchstaben in Kleinbuchstaben und umgekehrt in einer einzigen Codezeile ändern können. Es gibt nicht viele Anwendungsfälle für die Methode swapcase(), aber es ist gut, sie zu kennen.

#25 Die „isalnum“-Methode

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Nehmen wir mal an, wir machen ein Programm, bei dem die Leute ein Passwort eingeben müssen, das aus einer Mischung aus Zahlen und Buchstaben bestehen soll. Wir können das mit einer einzigen Codezeile machen, indem wir die Funktion isalnum() für die Zeichenfolge-Instanz aufrufen.

Die Methode checkt, ob alle Zeichen zum Alphabet (A-Za-z) gehören oder Zahlen (0-9) sind. Ein Leerzeichen oder Symbol (!#%$&? usw.) gibt Folgendes zurück Falsch.

#26 Umgang mit 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_ration(x=400, y=0))

"""
400.0
"""

Python-Programme hören auf zu laufen, 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 so einem Fall vorzeitig beendet würde?

Es gibt ein paar Ideen, wie man mit dem Sonderfall umgehen kann. Die meisten Python-Programmierer denken, dass es einfacher ist, um Verzeihung zu bitten, als um Erlaubnis zu fragen. Das heißt, sie fangen lieber einen ausgelösten Fehler ab, indem sie einen Kontext bereitstellen, der eine Ausnahme verarbeiten kann. Die Idee dahinter ist, dass es keinen Sinn macht, Zeit damit zu verschwenden, sich gegen alle möglichen Ausnahmen abzusichern.

Aber das klappt nur, wenn es einen Plan gibt, wie man mit einem Problem umgeht, wenn es passiert.

#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 den Unterschied zwischen zwei Listen in Python zu vergleichen. 

Anmerkung: Wenn du nicht sicher weißt, dass Liste_1 ein Teil von Liste_2 ist, dann 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 benutzen *args und **kwargs als Parameter für eine Funktion, wenn wir nicht wissen, wie viele Variablen unsere Funktion erwarten soll. 

Der Parameter *args lässt uns eine variable Anzahl von Parametern an eine Funktion übergeben, wenn er nicht als Schlüsselwort definiert ist (d. h., die übergebenen Parameter brauchen keinen zugehörigen Namen). Andererseits können wir mit dem Parameter **kwargs beliebig viele Schlüsselwortparameter an eine Funktion übergeben.

Eigentlich sind die Wörter *args und **kwargs gar nicht so magisch: Die wahre Magie steckt in den Sternchen (*). Das heißt, wir hätten jedes Wort nach den Sternchen nehmen können, aber die Verwendung von args und kwargs ist üblich und wird von Python-Entwicklern so gemacht. 

#29 Die Ellipse

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis ist ein Python-Objekt, das du durch eine Folge von drei Punkten (...) oder durch Aufruf des Objekts selbst (Ellipsis) starten kannst.

Am häufigsten wird es benutzt, um auf mehrdimensionale Arrays in NumPy zuzugreifen und sie zu zerlegen, zum Beispiel:

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]]
"""

Ellipsis kann aber auch als Platzhalter in einer noch nicht implementierten Funktion verwendet werden. 

Das heißt, du könntest Ellipsis, ... oder pass übergeben, und alle wären immer noch okay.

#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 Trick in Python sind Listenkomprimierungen, eine coole Methode, um aus einer anderen Sequenz eine Liste zu erstellen. Mit ihnen kannst du komplexe Logik und Filterung machen, wie wir es im Code oben gezeigt haben.

Es gibt auch andere Wege, um dasselbe 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]
"""

Aber einige Python-Fans würden sagen, dass diese Lösung viel schwerer zu lesen ist als die Listenkomprimierung.

Schau dir dieses Tutorial an, um mehr über Python-Listenkomprimierungen zu erfahren.