30 coole Python-Tricks für besser lesbaren Code – mit Beispielen

Die Nachfrage nach Python-Kompetenzen ist in den letzten Jahren stark gestiegen. Um dir beim Ausbau deiner Python-Programmierung zu helfen, haben wir 30 coole Python-Tricks kuratiert, mit denen du deinen Code verbesserst. Lerne 30 Tage lang jeden Tag einen Trick und wirf einen Blick auf unsere Python-Best Practices, damit dein Code wirklich überzeugt. 

Wenn deine Python-Grundlagen noch Luft nach oben haben, frische sie mit unserem Python Skill Track auf.

Tricks zu Sequenzen & Datenstrukturen

#1 Slicing

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

"""
!dlroW olleH
"""

Slicing ist ein Python-Feature auf Basis von Indizes, mit dem du Teilbereiche einer Sequenz auslesen kannst. Ein Index ist die Position eines Elements in der Sequenz. Bei veränderlichen (mutable) Sequenztypen kannst du mit Slicing Daten nicht nur extrahieren, sondern auch verändern. 

Hinweis: Auch bei unveränderlichen (immutable) Sequenzen ist Slicing möglich – ein Änderungsversuch am Slice wirft jedoch einen TypeError. 

Die Syntax für Slices lautet: sequence[start:stop:step]. Lässt du start, stop und step weg, greifen die Standardwerte: 

• „start“ ist standardmäßig 0 
• „stop“ ist standardmäßig die Länge der Sequenz
• „step“ ist standardmäßig 1. 

Bei sequence[start:stop] erhältst du die Elemente vom Startindex bis stop - 1 (der Stop-Index selbst ist ausgeschlossen). 

Du kannst auch negative Indizes verwenden, etwa zum Umdrehen einer Sequenz. In einer Liste mit 4 Elementen entspricht der Index 0 auch -4, und der letzte Index ist -1. Im obigen Beispiel wurde dieses Wissen im step-Parameter genutzt: Der String wird rückwärts von hinten bis Index 0 ausgegeben.   

#2 In-place-Tausch / 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 spontan erwartet hast, dass b den Wert 7 statt 12 hat, bist du in die In-place-Tausch-Falle getappt. 

In Python können wir Iterables per automatischem Unpacking in einer einzigen Zuweisung Variablen zuordnen. Zum Beispiel: 

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

"""
1
2
3
"""

Mit * lassen sich mehrere Werte in einer Variable sammeln – das nennt sich Packing. Beispiel:  

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

Die Kombination aus Packing und Unpacking ermöglicht die gleichzeitige Zuweisung. So ordnest du einer Reihe von Variablen in einem Schritt eine Reihe von Werten zu.

#3 Listen 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 Pythonistas kennen Listen. Weniger geläufig sind Tupel. Beide sind iterierbar, erlauben Indizierung und können heterogene Datentypen enthalten. Es gibt jedoch Situationen, in denen Tupel der Liste vorzuziehen sind. 

Listen sind veränderlich – wir können sie anpassen: 

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

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

Tupel sind dagegen unveränderlich; ein Änderungsversuch führt zu einem TypeError. 

Dadurch sind Tupel speichereffizienter: Python kann den exakt benötigten Speicher blocken. Listen hingegen reservieren zusätzlichen Speicher für mögliche Erweiterungen – dynamische Speicherallokation. 

Kurz gesagt: Wenn Daten nicht geändert werden sollen, sind Tupel aus Speicher- und Performancegründen oft besser als Listen. 

Mehr zu Python-Datenstrukturen findest du hier. 

#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 der pythonische Weg, aus einem Iterable eine Liste zu bauen – deutlich schneller als eine for-Schleife. Verwechselst du eckige [] mit runden Klammern (), erhältst du einen Generator.

Runde Klammern mit der Comprehension-Logik erzeugen ein Generatorobjekt. Generatoren sind spezielle Iterables: Sie speichern nicht alle Elemente, sondern nur die Anweisung zur Erzeugung des nächsten Elements und den aktuellen Zustand der Iteration.

Jedes Element wird erst bei Bedarf erzeugt (Lazy Evaluation). Vorteil: deutlich weniger Speicher, da die Sequenz nicht komplett vorab aufgebaut 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 objektorientiert – alles ist ein Objekt. Eine Zuweisung an einen Bezeichner erzeugt daher eine Referenz auf dasselbe Objekt. 

Weist du einen Bezeichner einem anderen zu, verweisen beide auf dasselbe Objekt – das nennt man Aliasing. Änderungen über das eine Alias wirken sich auf das andere aus. Manchmal gewünscht, oft eine Falle. 

Umgehen lässt sich das, indem du bei veränderlichen Objekten Aliasing vermeidest oder stattdessen eine Kopie anlegst. 

Am einfachsten kopierst du per Slicing: 

b = a[:] 

So erhält b eine neue Listenreferenz. 

Alternativen sind list(a) oder die copy()-Methode. 

#6 Der Operator „not“

a = []
print(not a)

"""
True
"""

Der einfachste Weg zu prüfen, ob eine Datenstruktur leer ist, ist der logische Operator not. Er liefert True, wenn der Ausdruck nicht wahr ist, sonst False – sprich: Er invertiert den Wahrheitswert.  

Häufig in if-Bedingungen zu sehen: 

if not a:
    # do something... 

Ist a True, ergibt not False – und umgekehrt. 

Etwas ungewohnt am Anfang – probier es aus.

Tricks zu Strings & Ausgabe

#7 F-Strings

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

Seit Python 3.6 gibt es F-Strings, die das Formatieren von Strings deutlich vereinfachen. Wer die alten Methoden kennt, weiß den Zugewinn an Lesbarkeit und Geschwindigkeit zu schätzen. 

Früher sah das so aus: 

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

F-Strings sind schneller, lesbarer, kürzer und weniger fehleranfällig.

Seit Python 3.8 kannst du damit auch Bezeichner inklusive Name ausgeben:

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

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

Mehr im Tutorial zu F-Strings in Python. 

#8 Der „end“-Parameter von print()

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

"""
english french spanish german twi
"""

Viele nutzen print ohne optionale Parameter – dabei kannst du die Ausgabe steuern.

Ein optionaler Parameter ist end. Er legt fest, was am Ende eines print-Aufrufs ausgegeben wird. 

Standard ist "\n" für einen Zeilenumbruch. Im Beispiel setzen wir stattdessen ein Leerzeichen, sodass alle Listenelemente in einer Zeile erscheinen.

#9 An Tupel „anhängen“

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

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

Tupel sind unveränderlich – siehe Trick #3 Listen vs. Tupel. Ein Änderungsversuch am Tupel wirft einen TypeError. Denkst du ein Tupel jedoch als Sequenz von Namen mit Bindungen zu Objekten, die nicht ausgetauscht werden dürfen, sieht es anders aus.

Die ersten beiden Elemente sind ints – unveränderlich. Das letzte Element ist eine Liste – veränderlich.

Die Bindung im Tupel bleibt unverändert, aber das Listenobjekt selbst darf intern modifiziert werden.

Empfehlen wir das im Alltag? Eher nicht – aber gut zu wissen.

#10 Dictionaries mergen

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

Seit Python 3.9 kannst du Dictionaries mit | (bitweises OR) zusammenführen. Kurz, klar, gut lesbar! 

Code-Style & Syntax-Tricks

#11 Ternärer Operator / bedingte Ausdrücke 

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

print(name)

"""
John
"""

Hier siehst du den ternären Operator (bedingter Ausdruck). Damit wählst du abhängig von True oder False zwischen zwei Ausdrücken.

Alternativ ginge auch:

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

print(name)
"""
John
"""

Beide Varianten liefern dasselbe – der ternäre Ausdruck ist kürzer und oft lesbarer. Sehr pythonisch. 

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

Am einfachsten entfernst du Duplikate, indem du die Liste in ein Set und bei Bedarf wieder zurück in eine Liste konvertierst.

Listen und Sets sind beide veränderlich, unterscheiden sich aber grundlegend.

Listen sind geordnet, nullbasiert indiziert und veränderlich. Sets sind ungeordnet und nicht indiziert. Elemente in einem Set müssen unveränderlich sein; ein Zugriff per Index oder das Ändern eines Elements führt zu einem Fehler.

Wichtig: Sets erlauben keine Duplikate – so verschwinden doppelte Werte automatisch.

#13 Alleinstehender Unterstrich 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Der Unterstrich (_) ist ein gültiger Bezeichner in Python, kann aber noch mehr: Im interaktiven Interpreter speichert _ das Ergebnis der letzten Auswertung.

Laut Doku stellt der Interpreter das letzte Ergebnis in _ bereit (im builtins-Modul, neben Funktionen wie print).

Ohne vorheriges Ergebnis ist _ zunächst nicht definiert – nach 1 + 2 steht dort 3. 

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

Neben der Interpreter-Funktion kannst du _ auch als Platzhalter für Werte nutzen, die dich nicht interessieren und die du nicht weiterverwendest. So vermeidest du z. B. beim Linting einen F841-Fehler (Variable zugewiesen, aber nie benutzt).

#15 Nachgestellter Unterstrich

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

Ein weiterer Einsatz des Unterstrichs (_) ist das Vermeiden von Konflikten mit Python-Schlüsselwörtern. 

PEP 8 empfiehlt dafür einen einzelnen nachgestellten Unterstrich. Zitat: „list_ ist besser als lst.“

#16 Vorgehender Unterstrich

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

Erfahrene Pythonistas präfixen interne Attribute/Methoden gern mit Unterstrich.

Das ist ein konventioneller Hinweis gemäß PEP 8: „nur intern verwenden“. Python erzwingt das nicht – es ist eine schwache Sichtbarkeitsmarkierung.

Im Gegensatz zu Java gibt es keinen harten Unterschied zwischen „private“ und „public“. Es ist Community-Konvention und ändert das Laufzeitverhalten nicht.

#17 Unterstrich als Trenner

Zum Abschluss der Unterstrich-Tricks: Weitere Einsatzzwecke findest du im Tutorial zur Rolle des Unterstrichs in Python. 

number = 1_500_000
print(number)

"""
15000000
"""

Seit Python 3.6 kannst du Unterstriche als visuelle Zifferngruppierung in Ganzzahlen, Fließkommazahlen und komplexen Literalen nutzen. 

Das erhöht die Lesbarkeit langer Zahlen – Details in PEP 515.

Code-Style & Syntax-Tricks

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

Diese Zeile hast du sicher schon oft gesehen: Python setzt beim Ausführen eines Skripts den speziellen Namen "__main__" auf den Bezeichner __name__, wenn die Datei direkt gestartet wird.

Wird das Modul hingegen importiert, ist die Bedingung falsch – dann entspricht __name__ dem Modulnamen (Dateinamen). 

#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 willst Zählwerte für Wörter in einem Dictionary pflegen. Klassisch würdest du: 

1. Prüfen, ob der Schlüssel existiert
2. Falls ja: Wert um 1 erhöhen
3. Falls nein: Schlüssel anlegen und auf 1 setzen

Im Code sähe das so aus:

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

Kürzer geht es mit setdefault() auf dem Dictionary.

Erstes Argument ist der zu prüfende Schlüssel. Zweites Argument ist der Standardwert, falls der Schlüssel noch nicht existiert. Existiert er bereits, wird der aktuelle Wert zurückgegeben und nicht überschrieben.

Tricks zur Programmstruktur

#20 Regex-Matching

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

Reguläre Ausdrücke erlauben die Suche nach Textmustern. Suchen per STRG+F ist nett – aber wenn du nicht genau weißt, wonach du suchst, helfen Muster.  

Beispiel: Britische Telefonnummern folgen einem Schema – führende 0 plus zehn Ziffern oder statt der 0 ein +44 plus zehn Ziffern (internationale Schreibweise). 

Regex spart enorm Zeit. Die entsprechenden Regeln ohne Regex zu codieren, würde schnell 10+ Zeilen benötigen. 

Regex lohnt sich selbst, wenn du nicht programmierst – viele Editoren unterstützen Suchen/Ersetzen mit Regex.

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

Mit der Pipe (|) matchst du eines von mehreren Mustern – ideal bei ähnlichen Varianten.

„Superman“, „Superwoman“ und „Superhuman“ teilen sich das Präfix. Per Pipe behältst du den gemeinsamen Teil und variierst nur das Ende – spart Zeit.

Wichtig: Treten mehrere gesuchte Varianten im selben Text auf, wird die erste Übereinstimmung zurückgegeben – in „… Superwoman, Superman, Superhuman“ also Superwoman.

#22 Der „sep“-Parameter von print()

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 Fähigkeiten von print() werden oft unterschätzt. Neben „Hello World“ kann die Funktion noch einiges mehr. 

Der optionale Parameter sep gibt an, wie mehrere Objekte getrennt werden sollen. 

Standard ist ein Leerzeichen. Im Beispiel setzen wir einmal "" und einmal ".".

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

Lambda-Funktionen führen dich in fortgeschrittenere Python-Konzepte – lerne mehr im Kurs Intermediate Python. Sie wirken zunächst komplex, sind aber simpel.

Im Beispiel nutzen wir ein Argument – mehrere sind ebenso möglich:

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

Kurz gesagt: Mit dem Schlüsselwort lambda definierst du kleine, anonyme Funktionen in einer Zeile. Sie verhalten sich wie mit def deklarierte Funktionen – nur ohne Namen.

#24 Die Methode „swapcase“

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

swapcase() kehrt Groß-/Kleinschreibung eines Strings um – in einer Zeile. Nischen-Use-Case, aber nett zu kennen.

#25 Die Methode „isalnum“

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

"""
True
"""

Dein Programm verlangt ein Passwort aus Buchstaben und Ziffern? Ein Aufruf von isalnum() auf dem String prüft genau das in einer Zeile.

Es wird geprüft, ob alle Zeichen alphanumerisch sind (A–Z, a–z, 0–9). Leerzeichen oder Symbole (!#%$&? etc.) liefern False.

#26 Exception Handling

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 beenden sich bei Fehlern.

Bei Interaktion mit Endnutzerinnen und Endnutzern ist das unerwünscht. Wie gehst du mit Ausnahmen um?

Viele Pythonistas folgen EAFP: „Easier to Ask Forgiveness than Permission“. Statt alles vorab abzusichern, fängst du Fehler ab und behandelst sie kontextbezogen. Das spart Aufwand – setzt aber voraus, dass du nach Eintritt des Fehlers sinnvoll reagieren kannst.

Gilt also nur, wenn du einen Mechanismus zum Umgang mit dem Problem hast.

#27 Unterschiede in Listen finden

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

Drei Wege, die Differenz zweier Listen zu bestimmen. 

Hinweis: Sofern list_1 kein echtes Subset von list_2 ist, unterscheidet sich Lösung 1 von 2 und 3.

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

Mit *args und **kwargs definierst du Funktionen mit variabler Argumentzahl. 

*args sammelt zusätzliche Positionsargumente als Tuple. **kwargs sammelt zusätzliche Schlüsselwortargumente als Dictionary.

Magisch sind nicht die Namen, sondern die Sternchen. Du könntest andere Bezeichner verwenden – args und kwargs sind jedoch gängige Konvention.

#29 Die Ellipsis

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis ist ein Python-Objekt, das du mit drei Punkten (...) oder dem Namen Ellipsis referenzierst.

Am bekanntesten ist es beim Indexing/Slicing in mehrdimensionalen NumPy-Arrays, z. B.:

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

Außerdem eignet es sich als Platzhalter in noch nicht implementierten Funktionen. 

Ob ..., Ellipsis oder pass – alles gültig.

#30 List Comprehension

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Zum Schluss: List Comprehensions – elegant, leistungsfähig, gut lesbar. Du kannst Logik und Filterung direkt integrieren, wie oben gezeigt.

Das geht auch anders – z. B. mit einer Lambda-Funktion:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Viele Pythonistas finden die Comprehension jedoch deutlich lesbarer.