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.

Bild von kostenlospik

Statistische Funktionen sind der Grundstein für die Gewinnung aussagekräftiger Erkenntnisse aus Rohdaten. Python bietet Statistikern und Datenwissenschaftlern ein leistungsstarkes Toolkit zum Verstehen und Analysieren von Datensätzen. Bibliotheken wie NumPy, Pandas und SciPy bieten eine umfassende Funktionssuite. In diesem Handbuch werden 10 wichtige statistische Funktionen in Python innerhalb dieser Bibliotheken erläutert.

Bibliotheken für die statistische Analyse

Python bietet viele Bibliotheken, die speziell für statistische Analysen entwickelt wurden. Drei der am häufigsten verwendeten sind NumPy, Pandas und SciPy stats.

• NumPy: Die Abkürzung steht für Numerical Python. Diese Bibliothek bietet Unterstützung für Arrays, Matrizen und eine Reihe mathematischer Funktionen.
• Pandas: Pandas ist eine Bibliothek zur Datenbearbeitung und -analyse, die bei der Arbeit mit Tabellen und Zeitreihendaten hilfreich ist. Sie basiert auf NumPy und bietet zusätzliche Funktionen zur Datenbearbeitung.
• SciPy-Statistiken: Die Abkürzung steht für Scientific Python. Diese Bibliothek wird für wissenschaftliche und technische Berechnungen verwendet. Sie bietet eine große Anzahl von Wahrscheinlichkeitsverteilungen, statistischen Funktionen und Hypothesentests.

Python-Bibliotheken müssen heruntergeladen und in die Arbeitsumgebung importiert werden, bevor sie verwendet werden können. Um eine Bibliothek zu installieren, verwenden Sie das Terminal und den Befehl pip set up. Sobald sie installiert ist, kann sie mit der Importanweisung in Ihr Python-Skript oder Jupyter-Pocket book geladen werden. NumPy wird normalerweise importiert als npPandas als pdund normalerweise wird nur das Statistikmodul aus SciPy importiert.

pip set up numpy
pip set up pandas
pip set up scipy

import numpy as np
import pandas as pd
from scipy import stats

Wenn verschiedene Funktionen mit mehr als einer Bibliothek berechnet werden können, wird Beispielcode für die jeweilige Bibliothek angezeigt.

1. Mittelwert (Durchschnitt)

Der Mittelwert, auch Durchschnitt genannt, ist die grundlegendste statistische Kennzahl. Er liefert einen zentralen Wert für eine Reihe von Zahlen. Mathematisch gesehen ist er die Summe aller Werte geteilt durch die Anzahl der vorhandenen Werte.

mean_numpy = np.imply(information) 
mean_pandas = pd.Sequence(information).imply()

2. Median

Der Median ist ein weiteres Maß für die zentrale Tendenz. Er wird berechnet, indem der mittlere Wert des Datensatzes angegeben wird, wenn alle Werte in der richtigen Reihenfolge sortiert sind. Im Gegensatz zum Mittelwert wird er nicht von Ausreißern beeinflusst. Dies macht ihn zu einem robusteren Maß für schiefe Verteilungen.

median_numpy = np.median(information) 
median_pandas = pd.Sequence(information).median()

3. Standardabweichung

Die Standardabweichung ist ein Maß für die Variation oder Streuung in einem Wertesatz. Sie wird anhand der Differenzen zwischen jedem Datenpunkt und dem Mittelwert berechnet. Eine niedrige Standardabweichung zeigt an, dass die Werte im Datensatz eher nahe am Mittelwert liegen, während eine größere Standardabweichung anzeigt, dass die Werte stärker gestreut sind.

std_numpy = np.std(information) 
std_pandas = pd.Sequence(information).std()

4. Perzentile

Perzentile geben die relative Stellung eines Wertes innerhalb eines Datensatzes an, wenn alle Daten der Reihe nach sortiert sind. Beispielsweise ist das 25. Perzentil der Wert, unter dem 25 % der Daten liegen. Der Median wird technisch als das 50. Perzentil definiert.

Perzentile werden mithilfe der NumPy-Bibliothek berechnet und die jeweiligen Perzentile müssen in die Funktion aufgenommen werden. Im Beispiel werden das 25., 50. und 75. Perzentil berechnet, aber jeder Perzentilwert zwischen 0 und 100 ist gültig.

percentiles = np.percentile(information, (25, 50, 75))

5. Korrelation

Die Korrelation zwischen zwei Variablen beschreibt die Stärke und Richtung ihrer Beziehung. Es ist das Ausmaß, in dem sich eine Variable ändert, wenn sich die andere ändert. Der Korrelationskoeffizient reicht von -1 bis 1, wobei -1 eine perfekte damaging Korrelation, 1 eine perfekte constructive Korrelation und 0 keine lineare Beziehung zwischen den Variablen anzeigt.

corr_numpy = np.corrcoef(x, y) 
corr_pandas = pd.Sequence(x).corr(pd.Sequence(y))

6. Kovarianz

Kovarianz ist ein statistisches Maß, das das Ausmaß darstellt, in dem sich zwei Variablen gemeinsam ändern. Sie gibt nicht die Stärke der Beziehung an, wie dies bei einer Korrelation der Fall ist, aber sie gibt die Richtung der Beziehung zwischen den Variablen an. Sie ist auch der Schlüssel zu vielen statistischen Methoden, die die Beziehungen zwischen Variablen untersuchen, wie z. B. der Hauptkomponentenanalyse.

cov_numpy = np.cov(x, y) 
cov_pandas = pd.Sequence(x).cov(pd.Sequence(y))

7. Schiefe

Die Schiefe misst die Asymmetrie der Verteilung einer kontinuierlichen Variable. Eine Schiefe von Null bedeutet, dass die Daten symmetrisch verteilt sind, wie etwa bei der Normalverteilung. Die Schiefe hilft dabei, potenzielle Ausreißer im Datensatz zu identifizieren, und die Herstellung der Symmetrie ist eine Voraussetzung für einige statistische Methoden und Transformationen.

skew_scipy = stats.skew(information) 
skew_pandas = pd.Sequence(information).skew()

8. Kurtosis

Kurtosis wird oft zusammen mit Schiefe verwendet und beschreibt, wie groß die Fläche in den Enden einer Verteilung im Verhältnis zur Normalverteilung ist. Sie wird verwendet, um das Vorhandensein von Ausreißern anzuzeigen und die Gesamtform der Verteilung zu beschreiben, z. B. ob sie stark spitz (leptokurtisch genannt) oder flacher (platykurtisch genannt) ist.

kurt_scipy = stats.kurtosis(information) 
kurt_pandas = pd.Sequence(information).kurt()

9. T-Check

Ein T-Check ist ein statistischer Check, mit dem ermittelt wird, ob zwischen den Mittelwerten zweier Gruppen ein signifikanter Unterschied besteht. Oder im Fall eines Einstichproben-T-Assessments kann er verwendet werden, um zu ermitteln, ob der Mittelwert einer Stichprobe signifikant von einem vorgegebenen Populationsmittelwert abweicht.

Dieser Check wird mit dem Statistikmodul in der SciPy-Bibliothek ausgeführt. Der Check liefert zwei Ausgabeteile, die T-Statistik und den P-Wert. Wenn der P-Wert kleiner als 0,05 ist, wird das Ergebnis im Allgemeinen als statistisch signifikant angesehen, wenn die beiden Mittelwerte voneinander abweichen.

t_test, p_value = stats.ttest_ind(data1, data2)
onesamp_t_test, p_value = stats.ttest_1samp(information, popmean = 0)

10. Chi-Quadrat

Der Chi-Quadrat-Check wird verwendet, um zu bestimmen, ob ein signifikanter Zusammenhang zwischen zwei kategorialen Variablen wie Berufsbezeichnung und Geschlecht besteht. Der Check verwendet auch das Statistikmodul innerhalb der SciPy-Bibliothek und erfordert die Eingabe sowohl der beobachteten als auch der erwarteten Daten. Ähnlich wie beim t-Check liefert die Ausgabe sowohl eine Chi-Quadrat-Teststatistik als auch einen p-Wert, der mit 0,05 verglichen werden kann.

chi_square_test, p_value = stats.chisquare(f_obs=noticed, f_exp=anticipated)

Zusammenfassung

In diesem Artikel wurden 10 wichtige statistische Funktionen in Python hervorgehoben, aber es gibt noch viele weitere in verschiedenen Paketen, die für spezifischere Anwendungen verwendet werden können. Die Nutzung dieser Instruments für Statistiken und Datenanalysen ermöglicht es Ihnen, aussagekräftige Erkenntnisse aus Ihren Daten zu gewinnen.

Mehrnaz Siavoshi hat einen Grasp in Datenanalyse und arbeitet hauptberuflich als Biostatistikerin an der Entwicklung komplexer maschineller Lernverfahren und statistischer Analysen im Gesundheitswesen. Sie hat Erfahrung mit KI und hat an der College of the Individuals Universitätskurse in Biostatistik und maschinellem Lernen unterrichtet.

Bild vom Autor

Wir alle schreiben Funktionen, wenn wir in Python programmieren. Aber schreiben wir unbedingt Intestine Funktionen? Nun, lasst es uns herausfinden.

Mit Funktionen in Python können Sie modularen Code schreiben. Wenn Sie eine Aufgabe haben, die Sie an mehreren Stellen ausführen müssen, können Sie die Logik der Aufgabe in eine Python-Funktion packen. Und Sie können die Funktion jedes Mal aufrufen, wenn Sie diese bestimmte Aufgabe ausführen müssen. So einfach der Einstieg in Python-Funktionen auch scheint, das Schreiben wartbarer und leistungsfähiger Funktionen ist nicht so einfach.

Aus diesem Grund werden wir einige Vorgehensweisen untersuchen, die Ihnen dabei helfen, sauberere und leicht zu wartende Python-Funktionen zu schreiben. Lassen Sie uns beginnen …

1. Schreiben Sie Funktionen, die nur eine Sache tun

Beim Schreiben von Funktionen in Python ist es oft verlockend, alle zugehörigen Aufgaben in einer einzigen Funktion zusammenzufassen. Dies kann Ihnen zwar dabei helfen, Dinge schnell zu programmieren, wird jedoch in naher Zukunft die Wartung Ihres Codes nur mühsam machen. Dies erschwert nicht nur das Verständnis dessen, was eine Funktion tut, sondern führt auch zu anderen Problemen, wie z. B. zu vielen Parametern (mehr dazu später!).

Als bewährte Vorgehensweise sollten Sie immer versuchen, Ihre Funktion nur eine Sache – eine Aufgabe – ausführen zu lassen und diese intestine zu machen. Aber manchmal müssen Sie für eine einzelne Aufgabe möglicherweise eine Reihe von Unteraufgaben abarbeiten. Wie entscheiden Sie additionally, ob und wie die Funktion umgestaltet werden soll?

Es hängt davon ab Was Anhand der Aufgaben, die die Funktion ausführen soll, und der Komplexität der Aufgabe können Sie die Trennung der Belange zwischen den Unteraufgaben erarbeiten. Und dann ermitteln Sie eine geeignete Ebene, auf der Sie die Funktion in mehrere Funktionen umgestalten können – wobei sich jede auf eine bestimmte Unteraufgabe konzentriert.

Refactoring-Funktionen | Bild vom Autor

Hier ist ein Beispiel. Schauen Sie sich die Funktion an analyze_and_report_sales:

# fn. to investigate gross sales knowledge, calculate gross sales metrics, and write it to a file
def analyze_and_report_sales(knowledge, report_filename):
	total_sales = sum(merchandise('value') * merchandise('amount') for merchandise in knowledge)
	average_sales = total_sales / len(knowledge)
    
	with open(report_filename, 'w') as report_file:
    	    report_file.write(f"Whole Gross sales: {total_sales}n")
    	    report_file.write(f"Common Gross sales: {average_sales}n")
    
	return total_sales, average_sales

Es ist ganz einfach zu erkennen, dass es in zwei Funktionen umgestaltet werden kann: eine zum Berechnen der Verkaufskennzahlen und eine andere zum Schreiben der Verkaufskennzahlen in eine Datei wie folgt:

# refactored into two funcs: one to calculate metrics and one other to put in writing gross sales report
def calculate_sales_metrics(knowledge):
	total_sales = sum(merchandise('value') * merchandise('amount') for merchandise in knowledge)
	average_sales = total_sales / len(knowledge)
	return total_sales, average_sales

def write_sales_report(report_filename, total_sales, average_sales):
	with open(report_filename, 'w') as report_file:
    	    report_file.write(f"Whole Gross sales: {total_sales}n")
    	    report_file.write(f"Common Gross sales: {average_sales}n")

Jetzt ist es einfacher, Probleme mit der separaten Berechnung von Verkaufsmetriken und Dateivorgängen zu beheben. Und hier ist ein Beispiel für einen Funktionsaufruf:

knowledge = ({'value': 100, 'amount': 2}, {'value': 200, 'amount': 1})
total_sales, average_sales = calculate_sales_metrics(knowledge)
write_sales_report('sales_report.txt', total_sales, average_sales)

Sie sollten die Datei „sales_report.txt“ mit den Verkaufsmetriken in Ihrem Arbeitsverzeichnis sehen können. Dies ist ein einfaches Beispiel für den Einstieg, aber es ist besonders hilfreich, wenn Sie an komplexeren Funktionen arbeiten.

2. Fügen Sie Typhinweise hinzu, um die Wartbarkeit zu verbessern

Python ist eine dynamisch typisierte Sprache. Sie müssen additionally für die Variablen, die Sie erstellen, keine Typen deklarieren. Sie können jedoch Typhinweise hinzufügen, um den erwarteten Datentyp für Variablen anzugeben. Wenn Sie die Funktion definieren, können Sie die erwarteten Datentypen für die Parameter und die Rückgabewerte hinzufügen.

Da Python zur Laufzeit keine Typen erzwingt, hat das Hinzufügen von Typhinweisen zur Laufzeit keine Auswirkungen. Die Verwendung von Typhinweisen hat jedoch dennoch Vorteile, insbesondere im Hinblick auf die Wartbarkeit:

• Das Hinzufügen von Typhinweisen zu Python-Funktionen dient als Inline-Dokumentation und vermittelt eine bessere Vorstellung davon, was die Funktion macht und welche Werte sie verbraucht und zurückgibt.
• Wenn Sie Ihren Funktionen Typhinweise hinzufügen, können Sie Ihre IDE so konfigurieren, dass diese Typhinweise genutzt werden. So erhalten Sie hilfreiche Warnungen, wenn Sie versuchen, in einem oder mehreren Funktionsaufrufen ein Argument ungültigen Typs zu übergeben, Funktionen zu implementieren, deren Rückgabewerte nicht dem erwarteten Typ entsprechen, und dergleichen. So können Sie Fehler im Vorfeld minimieren.
• Sie können non-compulsory statische Typprüfer verwenden wie meinPy um Fehler früher zu erkennen, anstatt zuzulassen, dass durch Typ-Inkonsistenzen subtile Bugs entstehen, die schwer zu debuggen sind.

Hier ist eine Funktion, die Bestelldetails verarbeitet:

# fn. to course of orders
def process_orders(orders):
	total_quantity = sum(order('amount') for order in orders)
	total_value = sum(order('amount') * order('value') for order in orders)
	return {
    	'total_quantity': total_quantity,
    	'total_value': total_value
	}

Fügen wir der Funktion nun Typhinweise wie folgt hinzu:

# modified with sort hints
from typing import Checklist, Dict

def process_orders(orders: Checklist(Dict(str, float | int))) -> Dict(str, float | int):
	total_quantity = sum(order('amount') for order in orders)
	total_value = sum(order('amount') * order('value') for order in orders)
	return {
    	'total_quantity': total_quantity,
    	'total_value': total_value
	}

Mit der modifizierten Model erfahren Sie, dass die Funktion eine Liste von Wörterbüchern aufnimmt. Die Schlüssel des Wörterbuchs sollten alle Zeichenfolgen sein und die Werte können entweder Ganzzahlen oder Gleitkommawerte sein. Die Funktion gibt auch ein Wörterbuch zurück. Sehen wir uns einen Beispielfunktionsaufruf an:

# Pattern knowledge
orders = (
	{'value': 100.0, 'amount': 2},
	{'value': 50.0, 'amount': 5},
	{'value': 150.0, 'amount': 1}
)

# Pattern perform name
consequence = process_orders(orders)
print(consequence)

Hier ist die Ausgabe:

{'total_quantity': 8, 'total_value': 600.0}

In diesem Beispiel helfen uns Typhinweise, eine bessere Vorstellung davon zu bekommen, wie die Funktion funktioniert. In Zukunft werden wir Typhinweise für alle besseren Versionen von Python-Funktionen hinzufügen, die wir schreiben.

3. Akzeptieren Sie nur die Argumente, die Sie wirklich brauchen

Wenn Sie Anfänger sind oder gerade Ihre erste Entwicklerrolle übernommen haben, ist es wichtig, beim Definieren der Funktionssignatur an die verschiedenen Parameter zu denken. Es ist durchaus üblich, zusätzliche Parameter in die Funktionssignatur einzuführen, die die Funktion nie wirklich verarbeitet.

Wenn sichergestellt wird, dass die Funktion nur die tatsächlich erforderlichen Argumente annimmt, bleiben Funktionsaufrufe insgesamt sauberer und wartungsfreundlicher. In einem ähnlichen Zusammenhang ist zu beachten, dass zu viele Parameter in der Funktionssignatur die Wartung ebenfalls erschweren. Wie additionally definieren Sie einfach zu wartende Funktionen mit der richtigen Anzahl von Parametern?

Wenn Sie eine Funktionssignatur mit einer wachsenden Anzahl von Parametern schreiben, besteht der erste Schritt darin, alle nicht verwendeten Parameter aus der Signatur zu entfernen. Wenn auch nach diesem Schritt zu viele Parameter vorhanden sind, gehen Sie zurück zu Tipp Nr. 1: Teilen Sie die Aufgabe in mehrere Unteraufgaben auf und refaktorisieren Sie die Funktion in mehrere kleinere Funktionen. Dies hilft dabei, die Anzahl der Parameter unter Kontrolle zu halten.

Behalten Sie num_params unter Kontrolle | Bild vom Autor

Es ist Zeit für ein einfaches Beispiel. Hier enthält die Funktionsdefinition zur Berechnung der Schülernoten die teacher Parameter, der nie verwendet wird:

# takes in an arg that is by no means used!
def process_student_grades(student_id, grades, course_name, teacher'):
	average_grade = sum(grades) / len(grades)
	return f"Scholar {student_id} achieved a mean grade of {average_grade:.2f} in {course_name}."

Sie können die Funktion neu schreiben, ohne teacher Parameter wie folgt:

# higher model!
def process_student_grades(student_id: int, grades: record, course_name: str) -> str:
	average_grade = sum(grades) / len(grades)
	return f"Scholar {student_id} achieved a mean grade of {average_grade:.2f} in {course_name}."

# Utilization
student_id = 12345
grades = (85, 90, 75, 88, 92)
course_name = "Arithmetic"
consequence = process_student_grades(student_id, grades, course_name)
print(consequence)

Hier ist die Ausgabe des Funktionsaufrufs:

Scholar 12345 achieved a mean grade of 86.00 in Arithmetic.

4. Erzwingen Sie Nur-Schlüsselwort-Argumente, um Fehler zu minimieren

In der Praxis akzeptieren die meisten Python-Funktionen mehrere Argumente. Sie können Argumente an Python-Funktionen als Positionsargumente, Schlüsselwortargumente oder eine Mischung aus beidem übergeben. Lesen Sie Python-Funktionsargumente: Ein definitiver Leitfaden für eine schnelle Überprüfung der Funktionsargumente.

Einige Argumente sind von Natur aus positionell. Manchmal können Funktionsaufrufe, die nur positionelle Argumente enthalten, jedoch verwirrend sein. Dies gilt insbesondere dann, wenn die Funktion mehrere Argumente desselben Datentyps annimmt, von denen einige erforderlich und einige non-compulsory sind.

Wie Sie sich erinnern, werden bei Positionsargumenten die Argumente an die Parameter in der Funktionssignatur in der Dasselbe Reihenfolge, in der sie im Funktionsaufruf erscheinen. Änderungen in der Reihenfolge der Argumente können additionally zu subtilen Fehlern führen.

Es ist oft hilfreich, Non-compulsory Argumente Nur Schlüsselwort. Dadurch wird auch das Hinzufügen optionaler Parameter viel einfacher – ohne bestehende Aufrufe zu unterbrechen.

Hier ist ein Beispiel. Die process_payment Funktion nimmt eine optionale description Zeichenfolge:

# instance fn. for processing transaction
def process_payment(transaction_id: int, quantity: float, forex: str, description: str = None):
	print(f"Processing transaction {transaction_id}...")
	print(f"Quantity: {quantity} {forex}")
	if description:
    		print(f"Description: {description}")

Angenommen, Sie möchten die optionale description ein reines Schlüsselwortargument. So können Sie es machen:

# implement keyword-only arguments to reduce errors
# make the non-compulsory `description` arg keyword-only
def process_payment(transaction_id: int, quantity: float, forex: str, *, description: str = None):
	print(f"Processing transaction {transaction_id}:")
	print(f"Quantity: {quantity} {forex}")
	if description:
    		print(f"Description: {description}")

Betrachten wir einen Beispielfunktionsaufruf:

process_payment(1234, 100.0, 'USD', description='Cost for companies')

Dies gibt aus:

Processing transaction 1234...
Quantity: 100.0 USD
Description: Cost for companies

Versuchen Sie nun, alle Argumente als Positionsargumente zu übergeben:

# throws error as we attempt to go in additional positional args than allowed!
process_payment(5678, 150.0, 'EUR', 'Bill cost') 

Sie erhalten die folgende Fehlermeldung:

Traceback (most up-to-date name final):
  File "/house/balapriya/better-fns/tip4.py", line 9, in 
	process_payment(1234, 150.0, 'EUR', 'Bill cost')
TypeError: process_payment() takes 3 positional arguments however 4 got

5. Geben Sie keine Hear aus Funktionen zurück; verwenden Sie stattdessen Generatoren

Es ist durchaus üblich, Python-Funktionen zu schreiben, die Sequenzen wie z. B. eine Liste von Werten generieren. Sie sollten jedoch möglichst vermeiden, Hear von Python-Funktionen zurückzugeben. Stattdessen können Sie sie als Generatorfunktionen neu schreiben. Generatoren verwenden eine verzögerte Auswertung; sie liefern additionally Elemente der Sequenz bei Bedarf, anstatt alle Werte im Voraus zu berechnen. Lesen Sie Erste Schritte mit Python-Generatoren für eine Einführung in die Funktionsweise von Generatoren in Python.

Nehmen wir als Beispiel die folgende Funktion, die die Fibonacci-Folge bis zu einer bestimmten Obergrenze generiert:

# returns a listing of Fibonacci numbers
def generate_fibonacci_numbers_list(restrict):
	fibonacci_numbers = (0, 1)
	whereas fibonacci_numbers(-1) + fibonacci_numbers(-2) <= restrict:
    		fibonacci_numbers.append(fibonacci_numbers(-1) + fibonacci_numbers(-2))
	return fibonacci_numbers

Es handelt sich um eine rekursive Implementierung, die rechenintensiv ist und das Auffüllen und Zurückgeben der Liste erscheint ausführlicher als nötig. Hier ist eine verbesserte Model der Funktion, die Generatoren verwendet:

# use mills as an alternative
from typing import Generator

def generate_fibonacci_numbers(restrict: int) -> Generator(int, None, None):
	a, b = 0, 1
	whereas a <= restrict:
    		yield a
    	a, b = b, a + b

In diesem Fall gibt die Funktion ein Generatorobjekt zurück, das Sie dann durchlaufen können, um die Elemente der Sequenz zu erhalten:

restrict = 100
fibonacci_numbers_generator = generate_fibonacci_numbers(restrict)
for num in fibonacci_numbers_generator:
	print(num)

Hier ist die Ausgabe:

0
1
1
2
3
5
8
13
21
34
55
89

Wie Sie sehen, kann die Verwendung von Generatoren insbesondere bei großen Eingabegrößen viel effizienter sein. Außerdem können Sie mehrere Generatoren miteinander verketten, sodass Sie mit Generatoren effiziente Datenverarbeitungspipelines erstellen können.

Einpacken

Und das struggle’s. Den gesamten Code finden Sie auf GitHub. Hier ist eine Übersicht über die verschiedenen Tipps, die wir besprochen haben:

• Schreiben Sie Funktionen, die nur eine Sache tun
• Fügen Sie Typhinweise hinzu, um die Wartbarkeit zu verbessern
• Akzeptieren Sie nur die Argumente, die Sie wirklich brauchen
• Erzwingen Sie Argumente, die nur aus Schlüsselwörtern bestehen, um Fehler zu minimieren
• Geben Sie keine Hear von Funktionen zurück; verwenden Sie stattdessen Generatoren

Ich hoffe, Sie fanden sie hilfreich! Wenn Sie diese Vorgehensweisen beim Schreiben von Python-Funktionen nicht bereits ausprobieren, sollten Sie sie ausprobieren. Viel Spaß beim Programmieren!

Bala Priya C ist Entwicklerin und technische Redakteurin aus Indien. Sie arbeitet gerne an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessens- und Fachgebiete umfassen DevOps, Datenwissenschaft und natürliche Sprachverarbeitung. Sie liest, schreibt, programmiert und trinkt gerne Kaffee! Derzeit arbeitet sie daran, ihr Wissen zu lernen und mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt auch ansprechende Ressourcenübersichten und Programmier-Tutorials.