So schreiben Sie lesbare Python-Funktionen, auch wenn Sie Anfänger sind

Bild vom Autor

# Einführung

Sie haben Ihr erstes geschrieben Python Funktion. Es funktioniert. Sie führen es aus, es erzeugt die richtige Ausgabe und Sie spüren den Erfolgsrausch. Dann schaut man es sich zwei Wochen später noch einmal an und denkt: „Was bringt das überhaupt?“

Beim Schreiben lesbarer Python-Funktionen geht es nicht darum, klug oder fortgeschritten zu sein. Es geht darum, Funktionen zu schreiben, die ihre Absicht klar kommunizieren, ihre Verantwortlichkeiten sauber handhaben und der nächsten Particular person die Arbeit erleichtern.

Lassen Sie uns lernen, wie man Funktionen schreibt, die sich wie gute Prosa lesen, und nicht wie kryptische Rätsel, die der Leser nur schwer verstehen kann.

🔗 Den Code finden Sie auf GitHub.

# 1. Benennen Sie Ihre Funktionen so, als würden Sie es einem Freund erklären

Funktionsnamen sind das Erste, was Menschen lesen. Ein guter Title sagt Ihnen genau, was die Funktion tut, ohne dass Sie den darin enthaltenen Code lesen müssen.

Schlechtes Beispiel:

def proc(d):
    return sum(d) / len(d)

Gutes Beispiel:

def calculate_average(numbers):
    return sum(numbers) / len(numbers)

Der Funktionsname calculate_average verwendet ein Verb („berechnen“), das Ihnen mitteilt, dass eine Aktion ausgeführt wird, gefolgt von dem, was es berechnet („durchschnittlich“). Die Parameternummern weisen deutlich darauf hin, dass eine Sammlung numerischer Werte erwartet wird.

Der Funktionskörper verwendet sum(numbers) um alle Werte zu addieren und len(numbers) um sie zu zählen, dann dividiert man, um den Durchschnitt zu erhalten. Jeder, der diesen Code liest, versteht sofort, was er tut, ohne dass Kommentare oder Dokumentation erforderlich sind.

# 2. Verwenden Sie beschreibende Parameternamen

Einbuchstabige Variablen ersparen möglicherweise das Tippen, kosten aber Verständnis. Parameter sind die Eingaben Ihrer Funktion. Machen Sie additionally deutlich, was Sie erwarten.

Schlechtes Beispiel:

def low cost(p, r):
    return p * (1 - r)

Gutes Beispiel:

def apply_discount(original_price, discount_rate):
    return original_price * (1 - discount_rate)

Jetzt liest jemand apply_discount(100, 0.2) versteht, dass Sie 20 % Rabatt auf 100 erhalten. Der Code ist selbstdokumentierend. Sie müssen die Funktionsdefinition nicht überprüfen, um zu verstehen, welche Argumente übergeben werden müssen.

# 3. Halten Sie die Funktionen kurz und konzentriert

Funktionen sollten eine Sache intestine machen. Wenn Ihre Funktion mehrere Verantwortlichkeiten hat, wird es schwierig, sie zu testen, wiederzuverwenden und zu verstehen. Teilen Sie additionally komplexe Logik in kleinere, fokussierte Funktionen auf.

Schlechtes Beispiel:

def process_order(gadgets, customer_email, discount_code):
    # Calculate whole

    subtotal = sum(merchandise("worth") * merchandise("amount") for merchandise in gadgets)

    # Apply low cost

    if discount_code == "SAVE10":
        low cost = 0.10
    elif discount_code == "SAVE20":
        low cost = 0.20
    else:
        low cost = 0
    whole = subtotal * (1 - low cost)

    # Ship electronic mail

    topic = f"Order Affirmation"
    physique = f"Your order whole is ${whole:.2f}"
    send_email(customer_email, topic, physique)

    return whole

Gutes Beispiel:

def calculate_order_subtotal(gadgets):
    return sum(merchandise("worth") * merchandise("amount") for merchandise in gadgets)


def get_discount_rate(discount_code):
    discount_rates = {"SAVE10": 0.10, "SAVE20": 0.20}
    return discount_rates.get(discount_code, 0)


def apply_discount_to_subtotal(subtotal, discount_rate):
    return subtotal * (1 - discount_rate)


def send_order_confirmation_email(customer_email, whole):
    topic = "Order Affirmation"
    physique = f"Your order whole is ${whole:.2f}"
    send_email(customer_email, topic, physique)


def process_order(gadgets, customer_email, discount_code):
    subtotal = calculate_order_subtotal(gadgets)
    discount_rate = get_discount_rate(discount_code)
    whole = apply_discount_to_subtotal(subtotal, discount_rate)
    send_order_confirmation_email(customer_email, whole)
    return whole

Jetzt hat jede Funktion einen einzigen, klaren Zweck. Das Wichtigste process_order Die Funktion liest sich wie ein Rezept: Zwischensumme berechnen, Rabatt erhalten, anwenden, E-Mail senden, Gesamtsumme zurückgeben.

# 4. Fügen Sie Docstrings hinzu, um den Zweck zu erklären

Funktionsnamen sagen Ihnen, was eine Funktion tut, aber Dokumentzeichenfolgen erklären, warum es existiert, was es erwartet und was es zurückgibt. Dies ist besonders hilfreich bei komplexer Logik oder nicht offensichtlichem Verhalten.

Gutes Beispiel:

def calculate_shipping_cost(weight_kg, distance_km, is_express=False):
    """
    Calculate delivery price primarily based on bundle weight and distance.

    Args:
        weight_kg (float): Bundle weight in kilograms
        distance_km (float): Delivery distance in kilometers
        is_express (bool): Whether or not to make use of categorical delivery (default: False)

    Returns:
        float: Whole delivery price in {dollars}

    Instance:
        >>> calculate_shipping_cost(5.0, 100, is_express=True)
        45.50
    """
    base_rate = 2.50
    per_kg_rate = 1.20
    per_km_rate = 0.15
    express_multiplier = 2.0 if is_express else 1.0

    price = (
        base_rate + (weight_kg * per_kg_rate) + (distance_km * per_km_rate)
    ) * express_multiplier
    return spherical(price, 2)

Der Dokumentstring erklärt, was jeder Parameter bedeutet, welcher Typ er sein sollte und was die Funktion zurückgibt. Jeder, der diese Funktion verwendet, weiß genau, wie er sie aufruft, ohne die Implementierung zu lesen.

# 5. Verwenden Sie klare Variablennamen innerhalb von Funktionen

Ebenso wie Parameter sollten auch interne Variablen beschreibend sein. Lassen Sie die Leute keine Abkürzungen entschlüsseln oder raten, was tmp oder x repräsentiert.

Schlechtes Beispiel:

def calc_bmi(w, h):
    h_m = h / 100
    res = w / (h_m**2)
    return spherical(res, 1)

Gutes Beispiel:

def calculate_bmi(weight_kg, height_cm):
    height_meters = height_cm / 100
    bmi = weight_kg / (height_meters**2)
    return spherical(bmi, 1)

Die Variable height_meters sagt Ihnen genau, welche Konvertierung stattgefunden hat. Und wie man sieht, die Variable bmi Enthält die Berechnung des Physique-Mass-Index (BMI).

# 6. Vermeiden Sie magische Zahlen; Verwenden Sie stattdessen benannte Konstanten

In Ihrem Code verstreute Zahlen sind „magisch“, was bedeutet, dass ihr Zweck unklar ist. Geben Sie ihnen aussagekräftige Namen, damit die Leser ihre Bedeutung verstehen.

Schlechtes Beispiel:

def calculate_late_fee(days_overdue):
    if days_overdue <= 7:
        return days_overdue * 2
    else:
        return 14 + (days_overdue - 7) * 5

Gutes Beispiel:

def calculate_late_fee(days_overdue):
    DAILY_FEE_FIRST_WEEK = 2
    GRACE_PERIOD_DAYS = 7
    BASE_FEE_AFTER_GRACE = 14
    DAILY_FEE_AFTER_GRACE = 5

    if days_overdue <= GRACE_PERIOD_DAYS:
        return days_overdue * DAILY_FEE_FIRST_WEEK
    else:
        days_after_grace = days_overdue - GRACE_PERIOD_DAYS
        return BASE_FEE_AFTER_GRACE + (days_after_grace * DAILY_FEE_AFTER_GRACE)

Nun ist die Gebührenstruktur klar. Die Konstanten dokumentieren Ihre Geschäftsregeln. Wenn sich die Tarife ändern, aktualisieren Sie einen eindeutig benannten Wert, anstatt nach mysteriösen Zahlen zu suchen.

# 7. Verwenden Sie Typhinweise zur Verdeutlichung

Tipphinweise informieren den Leser welche Typen Ihre Funktion erwartet und zurückgibt. Dies verhindert Verwirrung und erkennt Fehler frühzeitig. Es empfiehlt sich, Typhinweise in Ihre Funktionen einzufügen.

Gutes Beispiel:

def format_user_greeting(user_name: str, age: int, is_member: bool = False) -> str:
    membership_status = "member" if is_member else "visitor"
    return f"Good day {user_name}, age {age}. You're a {membership_status}."

Die Typhinweise machen es deutlich: user_name ist eine Zeichenfolge, age ist eine ganze Zahl, is_member ist ein Boolescher Wert mit dem Standardwert Falseund die Funktion gibt eine Zeichenfolge zurück. Ihre integrierten Entwicklungsumgebungen (IDEs) können diese Informationen nutzen, um eine bessere automatische Vervollständigung und Fehlerprüfung bereitzustellen.

# Abschluss

Lesbare Funktionen sind nicht schwieriger zu schreiben. Sie erfordern lediglich, dass Sie an Ihren Benutzer denken. Jede Wahl, die Sie treffen – Namen, Struktur, Kommentare – hilft oder erschwert das Verständnis.

Das Ziel ist kein perfekter Code. Es ist Code, der klar kommuniziert. Code, der die nächste Particular person dazu bringt, zu sagen: „Ah, ich verstehe“ statt „Was macht das wirklich?“ Das ist lesbarer Code, den Sie vom ersten Tag an schreiben können.

Im nächsten Artikel erfahren Sie, wie Sie saubere Python-Klassen schreiben. Bis dahin programmieren Sie weiter!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.