Schreiben Sie keine Python-Einzeiler, die niemand versteht

Ich habe nichts dagegen, Python-Einzeiler zu schreiben. Aber manchmal machen wir es sehr schwer, unseren Code zu lesen und zu verstehen. Manchmal verstehen wir den Code, den wir schreiben, nach ein paar Wochen nicht. Oft können Python-Einzeiler verlockend sein – weil sie elegant und kurz aussehen und Spaß machen. Aber wenn Sie später versuchen, sie zu debuggen wird es oft schwierig sie zu durchschauen. Die Situation wird sich noch verschlimmern, da wir manchmal nicht verstehen können, welche Logik wir schreiben.

Geben Sie einfachem Code immer Vorrang vor prägnantem Code.

1. Die Lesbarkeit kann leiden

Der Code, den wir schreiben, wird meistens von anderen gelesen. Versuchen Sie also, den Code einfach zu halten, damit er von jedem leicht verstanden werden kann. Wenn ein Einzeiler mehrere Vorgänge gleichzeitig kombiniert, wird es für Sie und alle anderen sehr schwierig sein, ihn zu verstehen.

Es wird sich eher wie ein Rätsel anfühlen, das es zu lösen gilt.

Zum Beispiel:

Ergebnis = [x**2 für x im Bereich(20) wenn x % 2 == 0]

Wie Sie sehen können, ist es kompakt. Es macht 3 Dinge gleichzeitig: Es iteriert über den Bereich, prüft dann, ob die Zahl gerade oder ungerade ist, und quadriert dann die Zahl.

Aber wenn wir es aufteilen… Dann wird es klarer werden.

Quadrate = []
für x im Bereich(20):
 wenn x % 2 == 0:
 Quadrate. Anhängen(x**2)

2. Das Debuggen wird zum Albtraum

Wenn wir mehrere Dinge in einer Zeile tun, dann wird es für uns sehr schwierig sein zu verstehen, wo etwas schief läuft.

Wenn wir zum Beispiel versuchen, diesen Einzeiler zu debuggen:

result = {key: Wert für key, Wert in zip(keys, values) if key.startswith('a') und Wert > 10}

In diesem Fall wird das Debuggen sehr schwierig sein, da es schwierig sein wird, zu verstehen, wo das Problem liegt. Es kann ein Problem mit vorliegen.zip() oder mit der Bedingung startswith() sein.

Aber wir können es nicht leicht verstehen.

3. Sie können den Code in Zukunft nicht mehr verstehen

Wenn Sie sich Ihren alten Code ansehen, den Sie vor einer Woche, einem Monat oder einem Jahr geschrieben haben, wird es für Sie schwierig werden, ihn zu verstehen. Es wird Ihnen schwer fallen, die Logik zu verstehen, die Sie angewendet haben.

Wie man diese Einzeiler vermeidet

Lassen Sie mich erklären, wie wir solche Szenarien vermeiden können:

1. Machen Sie es einfach, indem Sie es aufschlüsseln

Wenn wir unsere Logik in mehreren Zeilen schreiben, wird sie leicht zu verstehen und zu debuggen.

Anstatt also dies zu schreiben:

filtered_square = [x**2 für x in Zahlen, wenn x > 0 und x % 2 == 0]

Schreiben Sie es besser so:

positive_numbers = [x für x in Zahlen wenn x > 0 ist]
even_numbers = [x für x in positive_numbers wenn x % 2 == 0]
Quadrate = [x**2 für x in even_numbers]

2. Versuchen Sie, beschreibende Namen für die Variablen zu verwenden

Benennen Sie die Variablen nicht wie x oder y. Machen Sie sie klarer. Versuchen Sie einfach zu erklären, was in der Variablen gespeichert ist.

Also, anstatt so zu schreiben:

Ergebnis = Summe([x für x in Daten, wenn x > Schwellenwert])

Besser:

filtered_values = [Wert für den Wert in den Daten, wenn der Wert den Schwellenwert >]
gesamt = Summe(filtered_values)

3. Kommentieren Sie einfach Ihren Code

Wenn wir einen Einzeiler schreiben müssen, der mehrere Operationen kombiniert, dann versuchen Sie, dies durch Hinzufügen eines Kommentars zu erklären. Wann immer also jemand es liest, wird er es leicht verstehen können.

# Gerade Zahlen filtern und dann quadrieren result
= [x**2 für x in Zahlen if x % 2 == 0]

Aber es ist besser, wenn Sie es aufteilen, um es einfach zu machen.

4. Versuchen Sie, Funktionen zu verwenden

Wenn eine Logik so oft wiederholt wird, dann erstellen Sie eine Funktion für diese Logik.

Zum Beispiel:

def is_valid_number(x):
 Rückgabe von x > 0 und x % 2 == 0

def square_number(x):
 Rückgabe von x**2
Ergebnis = [square_number(x) für x in Zahlen wenn is_valid_number(x)]

5. Vermeiden Sie einfach verschachtelte Verständnisse

Wir verwenden oft verschachteltes Verständnis für unsere Aufgaben. Machen Sie es nicht so:

matrix = [[x*y für y im Bereich(5)] für x im Bereich(5)]

Es sieht beeindruckend aus… Aber für jemanden wie einen Anfänger kann es verwirrend sein. Schreiben Sie also so:

matrix = []
für x im Bereich(5):
 Zeile = []
 für y im Bereich(5):
 Zeile. append(x * y)
 Matrix. append(Zeile)

6. Versuchen Sie, die Fehler sorgfältig zu behandeln

Wenn wir versuchen, die gesamte Logik in einer Zeile anzuwenden, dann kümmern wir uns nicht um die Fehlerbehandlung. Es wird einfach ignoriert.

Zum Beispiel schreiben wir so:

Ergebnis = [1 / x für x in Zahlen wenn x != 0]

Aber was passiert, wenn Zahlen einen nicht-numerischen Wert enthalten? Wir wenden keinen Mechanismus an, um diesen Fehler zu behandeln.

Gehen Sie also so vor:

results = []
für x in Zahlen:
 try:
 if x != 0:
 results.append(1 / x)
 except TypeError:
 pass

Fazit

Wenn Sie also das nächste Mal einen Python-Einzeiler schreiben, fragen Sie sich einfach, ob Sie diesen Code nach einer Woche oder einem Monat verstehen können.

Wenn Ihre Antwort „NEIN“ lautet, dann ist es einfach so und sie sollten den Code neu formulieren.

Weiterer informativer Beitrag: Top 10 Microservices-Pattern, die Sie 2025 kennen sollten