Best Practices in Python

Dieser Artikel erklärt Best Practices in Python.

Wir erklären Python Best Practices anhand von echten Codebeispielen und zeigen Wege, lesbaren und wartbaren Code zu schreiben.

YouTube Video

Best Practices in Python

Lesbarkeit zur obersten Priorität machen

Schauen wir uns zuerst das Thema 'Lesbarkeit zur obersten Priorität machen' an.

Python ist eine Sprache, die 'Lesbarkeit' hoch schätzt. Schreiben Sie zuerst Code, dessen Absicht auf einen Blick klar ist.

1# Bad example: unclear variable names
2a = 10
3b = 5
4c = a * b

In diesem Code vermitteln die Variablennamen ihre Bedeutung nicht, sodass andere später viel Zeit zum Verstehen benötigen.

1# Good example: descriptive variable names
2price = 10
3quantity = 5
4total_cost = price * quantity

Indem Sie Variablennamen aussagekräftig machen, dient Ihr Code selbst als Dokumentation.

Schreiben Sie expliziten Code

Als nächstes betrachten wir 'expliziten Code schreiben'.

In Python wird 'explizite Absicht' gegenüber 'implizitem Verhalten' bevorzugt.

1# Bad example: implicit truthy check
2if data:
3    process(data)

In diesem Code ist unklar, was bei data erwartet wird – das begünstigt Fehler.

1# Good example: explicit condition
2if len(data) > 0:
3    process(data)

Durch explizite Bedingungen entspricht die Absicht des Codes der Spezifikation.

Funktionen klein halten und nur auf eine Aufgabe fokussieren

Schauen wir als nächstes auf 'Funktionen klein halten und auf eine Aufgabe fokussieren'.

Wenn eine Funktion zu viele Aufgaben übernimmt, werden Testen und Wartung erschwert.

1# Bad example: doing too many things
2def handle_user(user):
3    save_to_database(user)
4    send_email(user)
5    write_log(user)

In diesem Code sind Prozesse eng miteinander verknüpft, wodurch Wiederverwendung und Änderungen erschwert werden.

1# Good example: single responsibility
2def save_user(user):
3    save_to_database(user)
4
5def notify_user(user):
6    send_email(user)
7
8def log_user(user):
9    write_log(user)

Durch das Aufteilen von Funktionen werden deren Aufgaben klar und das Testen vereinfacht.

Verwenden Sie aktiv Typannotationen

Schauen wir als nächstes auf 'aktive Verwendung von Typannotationen'.

Typannotationen dienen als Dokumentation und sind ein hilfreiches Werkzeug zur Fehlervermeidung.

1# Bad example: Without type hints
2def add(a, b):
3    return a + b

In diesem Code sind die Typen von Argumenten und Rückgabewerten unklar, wodurch Fehlgebrauch wahrscheinlicher wird.

1# Good example: With type hints
2def add(a: int, b: int) -> int:
3    return a + b

Mit Typannotationen verbessern sich Auto-Vervollständigung der IDE, statische Analyse und Lesbarkeit deutlich.

Geben Sie explizit die Möglichkeit zurück, None zurückzugeben

Als nächstes betrachten wir 'die explizite Angabe der Möglichkeit, None zurückzugeben'.

Funktionen, die eventuell None zurückgeben, werden von Nutzern oft übersehen.

1# Bad example: Ambiguous return value
2def find_user(user_id):
3    if user_id == 1:
4        return {"id": 1, "name": "Alice"}
5    return None

In diesem Code ist unklar, ob ein Rückgabewert existiert.

1# Good example: explicit return type
2from typing import Optional, Dict, Any
3
4def find_user(user_id: int) -> Optional[Dict[str, Any]]:
5    if user_id == 1:
6        return {"id": 1, "name": "Alice"}
7    return None

Mit Optional können Sie die Möglichkeit ausdrücken, dass None als Typ zurückgegeben werden kann.

Fangen Sie Ausnahmen nicht zu allgemein ab

Als nächstes sehen wir uns 'Ausnahmen nicht zu breit abfangen' an.

Die Ausnahmebehandlung sollte im Wesentlichen nur das Notwendige abfangen.

1# Bad example: catching all exceptions
2try:
3    result = int(value)
4except Exception:
5    result = 0

Dieser Code könnte Fehler verbergen, die eigentlich bemerkt werden sollten.

1# Good example: catch specific exception
2try:
3    result = int(value)
4except ValueError:
5    result = 0

Durch das Einschränken der abgefangenen Fehler übersehen Sie keine unerwarteten Probleme.

Ressourcen sicher mit dem with-Statement verwalten

Schauen wir uns als nächstes 'Ressourcen sicher mit dem with-Statement verwalten' an.

Ressourcen wie Dateien und Sperren müssen immer zuverlässig freigegeben werden.

1# Bad example: manual close
2file = open("data.txt")
3content = file.read()
4file.close()

In diesem Code wird close() bei einer Ausnahme möglicherweise nicht aufgerufen.

1# Good example: using context manager
2with open("data.txt") as file:
3    content = file.read()

Durch die Verwendung eines with-Statements erfolgt das Aufräumen auch bei Ausnahmen zuverlässig.

Listenkomprehensionen angemessen verwenden

Sehen wir uns als nächstes 'angemessene Verwendung von Listenkomprehensionen' an.

Einfache Umwandlungsprozesse können prägnant mit Listenkomprehensionen geschrieben werden.

1# Bad example: Verbose loop
2squares = []
3for i in range(10):
4    squares.append(i * i)

In diesem Code ist der Kernprozess schwer zu erkennen.

1# Good example: Clear list comprehension
2squares = [i * i for i in range(10)]

Durch angemessene Verwendung von Listenkomprehensionen steigt die Lesbarkeit des Codes.

Vermeiden Sie Magic Numbers

Als nächstes betrachten wir 'Magic Numbers vermeiden'.

Direktes Schreiben von Zahlen und Zeichenfolgen macht ihre Bedeutung unklar.

1# Bad example: magic number
2if status == 404:
3    handle_not_found()

In diesem Code wird angenommen, dass Sie die Bedeutung von 404 kennen.

1# Good example: named constant
2NOT_FOUND = 404
3
4if status == NOT_FOUND:
5    handle_not_found()

Durch Benennung werden Absichten klar.

Schreiben Sie Code, der wartbar ist – nicht nur, der 'funktioniert'

Abschließend betrachten wir 'Code schreiben, der wartbar ist – nicht nur, der funktioniert.'.

Wichtig ist, dass Ihr zukünftiges Ich oder andere den Code lesen können.

1# Bad example: Hard to maintain
2def f(x):
3    return x * 1.08 + 100

In diesem Code ist die Spezifikation nicht aus dem Code ersichtlich.

1# Good example: Easy to maintain
2TAX_RATE = 1.08
3BASE_FEE = 100
4
5def calculate_total(price: float) -> float:
6    return price * TAX_RATE + BASE_FEE

Durch Sinn in den Namen wird der Code zur Spezifikation.

Zusammenfassung

Python Best Practices laufen darauf hinaus, verständlichen anstatt raffinierten Code zu schreiben. Durch kleine Gewohnheiten entsteht langlebiger Code mit weniger Fehlern.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video