Python-Funktionen

Eine Funktion ist ein benannter Codeblock, der eine Aufgabe erfüllt. Eingebaute Funktionen wie print() und input() stellen dir bereits nützliche Aufgaben zum Aufrufen bereit; mit def kannst du eigene erstellen. Ein guter Name macht aus mehreren Arbeitszeilen einen Aufruf, der beschreibt, was getan werden soll.

Kopf und Körper schreiben

def greet():
    print("Hello!")
    print("Welcome to Python.")

greet()
greet()

Der Kopf beginnt mit def, danach folgen der Name, runde Klammern und ein Doppelpunkt. Die eingerückten Zeilen bilden den Körper. Verwende vier Leerzeichen pro Einrückungsebene. Die nicht eingerückten greet()-Zeilen liegen außerhalb der Funktion und sind daher Aufrufe im Hauptprogramm.

Wenn Python die Definition erreicht, erstellt es die Funktion und gibt ihr den Namen greet. Noch wird keine der beiden Meldungen ausgegeben. Der erste Aufruf beginnt bei der ersten Zeile des Körpers und gibt „Hello!“ gefolgt von „Welcome to Python.“ aus. Der zweite Aufruf beginnt den Körper erneut und gibt dieselben zwei Zeilen aus. Insgesamt entstehen vier Ausgabezeilen.

Ein Name und ein Aufruf sind verschieden

Die runden Klammern in greet() machen daraus einen Aufruf, obwohl diese Funktion keine Eingaben braucht. Eine Zeile, die nur greet enthält, verweist auf die Funktion und führt nichts aus. print(greet) zeigt eine Beschreibung des Funktionsobjekts einschließlich einer Speicheradresse an; es führt die Begrüßung nicht aus.

Python muss eine Definition ausgeführt haben, bevor ein Aufruf ihren Namen verwendet. Beginnt eine Datei mit greet() und definiert greet erst danach, löst die erste Zeile NameError: name 'greet' is not defined aus. Setze die Definition über den Aufruf auf Modulebene.

Namen wählen, die die Aufgabe erklären

Verwende kleingeschriebene Wörter, die durch Unterstriche verbunden sind, etwa print_receipt oder convert_to_miles. Namen dürfen Buchstaben, Ziffern und Unterstriche enthalten, aber nicht mit einer Ziffer beginnen oder ein reserviertes Wort wie return sein. Die Groß- und Kleinschreibung wird beachtet: greet und Greet sind verschiedene Namen.

Halte eingebaute Namen verfügbar. Nach input = "yes" verweist der Name input auf Text, daher löst input("Name? ") den Fehler TypeError: 'str' object is not callable aus. Nennst du die Variable answer, bleibt die eingebaute Funktion zugänglich.

Zuerst die Struktur korrigieren

Ein fehlender Doppelpunkt im Kopf führt zu SyntaxError: expected ':'. Ein leerer oder nicht eingerückter Körper führt zu einem IndentationError. Auch eine geplante Funktion braucht eine Anweisung; pass ist ein Platzhalter, der nichts tut:

def print_receipt():
    pass

print_receipt()

Dieses Programm läuft ohne Ausgabe. Der Aufruf erreicht pass und dann das Ende des Körpers. Ersetze den Platzhalter durch die eigentliche Aufgabe, sobald du sie implementieren willst. Wenn eine Zeile zum Körper gehören sollte, aber zum falschen Zeitpunkt ausgeführt wird, prüfe ihre Einrückung, bevor du den Aufruf änderst.

Ein Programm mit Funktionen führt nicht jeden Körper in der Reihenfolge aus, in der er auf der Seite steht. Ein Aufruf ändert den Programmablauf: Python wechselt in die aufgerufene Funktion, beendet deren Arbeit und setzt den aufrufenden Code direkt nach diesem Aufruf fort.

Einen Aufruf in einen weiteren Aufruf verfolgen

def line():
    print("----------")

def banner():
    line()
    print("  REPORT")
    line()

print("Start")
banner()
print("End")

Zuerst definiert Python line und banner. Keiner der beiden Körper wird ausgeführt. Die nächste Anweisung gibt „Start“ aus. Der Aufruf von banner() wechselt in dessen Körper, dessen erste Anweisung line() aufruft.

Python wechselt nun in line, gibt „----------“ aus und erreicht das Ende. Es kehrt zur nächsten Anweisung in banner zurück, die „ REPORT“ ausgibt. Der zweite Aufruf von line() gibt eine weitere gestrichelte Linie aus. Schließlich endet banner, sodass das Hauptprogramm fortgesetzt wird und „End“ ausgibt.

Die Ausgabe lautet:

Start
----------
  REPORT
----------
End

Nicht abgeschlossene Aufrufe verfolgen

Während line läuft, wartet banner auf dessen Ende. Auch das Hauptprogramm wartet auf banner. Python erfasst diese nicht abgeschlossenen Aufrufe im Aufrufstapel. Der innerste aktive Aufruf endet zuerst, und jeder aufrufende Code wird bei seiner eigenen nächsten Anweisung fortgesetzt.

Nummeriere für eine Ablaufverfolgung auf Papier die Zeilen des Programms. Notiere eine Zeile eines Funktionskörpers erst, wenn der Ablauf sie durch einen Aufruf erreicht. Markiere bei jedem Aufruf, wo es weitergeht. Schreibe die Ausgabe auf, wenn das zugehörige print ausgeführt wird, und behalte Leerzeichen und Zeilenumbrüche bei. So trennst du den Weg durch den Code von der erzeugten Ausgabe.

Hilfsfunktionen definieren, bevor sie gebraucht werden

Die Definition einer Hilfsfunktion darf unter der Definition der aufrufenden Funktion stehen:

def show_report():
    draw_line()
    print("Ready")

def draw_line():
    print("====")

show_report()

Das funktioniert, weil beide Definitionen ausgeführt wurden, bevor der abschließende Aufruf in show_report wechselt. Python sucht draw_line, wenn der Körper die Funktion tatsächlich aufruft. Würde show_report() über def draw_line(): verschoben, würde der Aufruf fehlschlagen, sobald er die fehlende Hilfsfunktion verwenden will.

Wiederholte Aufrufe beginnen von vorn

Ein Aufruf innerhalb einer Schleife wechselt bei jeder Wiederholung in den Körper:

for i in range(3):
    line()

Mit der ersten Definition von line gibt dies die gestrichelte Linie dreimal aus. Die Funktion beginnt bei jedem Aufruf mit ihrer ersten Anweisung im Körper.

Schlägt ein Aufruf fehl, zeigt Python einen Traceback. Seine letzte Zeile nennt den Fehlertyp und die Meldung. Die Aufrufeinträge darüber reichen vom äußersten noch nicht abgeschlossenen Aufruf bis zur Zeile, in der der Fehler auftrat. Lies zuerst den letzten Fehler und prüfe dann die innerste Zeile und den zugehörigen Aufruf. So findest du sowohl die fehlgeschlagene Operation als auch den Weg, auf dem sie ihre Daten erhielt.

Eine Funktion lässt sich für verschiedene Eingaben wiederverwenden, wenn ihr Kopf die benötigten Werte benennt. Diese Namen sind Parameter. Der aufrufende Code liefert Argumente, also die tatsächlich für einen bestimmten Aufruf verwendeten Werte.

Werte Namen zuordnen

def rectangle_area(width, height):
    print("Area:", width * height)

rectangle_area(4, 2.5)
rectangle_area(3, 7)

Die Parameter sind width und height. Im ersten Aufruf sind die Argumente 4 und 2.5. Positionsargumente werden von links nach rechts zugeordnet: width erhält 4 und height erhält 2,5. Der Körper gibt „Area: 10.0“ aus. Der nächste Aufruf gibt denselben Parameternamen neue Werte und gibt „Area: 21“ aus.

Jeder Parameter wirkt innerhalb dieses Aufrufs als Variable. Du musst width und height nicht vorher zuweisen; der Aufruf liefert ihre Werte. Eine Funktion ohne Parameter braucht trotzdem leere runde Klammern in ihrer Definition und in ihren Aufrufen.

Die Reihenfolge kann die Bedeutung ändern

def describe_pet(animal, name):
    print(name, "is a", animal)

describe_pet("cat", "Milo")
describe_pet("Milo", "cat")

Der erste Aufruf gibt „Milo is a cat“ aus. Der zweite gibt „cat is a Milo“ aus. Beide Aufrufe sind gültiges Python, daher weist kein Fehler auf die vertauschte Bedeutung hin. Lies die Reihenfolge im Kopf, bevor du Positionsargumente wählst, besonders wenn mehrere Parameter dieselbe Art von Wert annehmen.

Argumente können Ausdrücke sein

Python wertet jeden Argumentausdruck aus, bevor der Körper beginnt. Bei side = 6 übergibt der Aufruf rectangle_area(side, side) zweimal 6 und gibt „Area: 36“ aus. Der Variablenname im aufrufenden Code muss mit keinem der Parameternamen übereinstimmen. Der Aufruf rectangle_area(side + 1, 2) übergibt 7 und 2; er übergibt nicht den Text „side + 1“.

Einen Fehler bei der Argumentanzahl lesen

Jeder Parameter ohne Standardwert braucht ein Argument. Für die obige Flächenfunktion gilt:

Der erste Aufruf löst TypeError: rectangle_area() missing 1 required positional argument: 'height' aus. Der zweite löst TypeError: rectangle_area() takes 2 positional arguments but 3 were given aus. Prüfe den Kopf der genannten Funktion und zähle dann, wie der Aufruf ihre Parameter belegt.

Die für die Aufgabe benötigte Art von Wert übergeben

Python schreibt keinen Datentyp vor, nur weil ein Parameter width heißt. rectangle_area("4", 2) gibt „Area: 44“ aus, weil die Multiplikation von Text mit einer ganzen Zahl diesen Text wiederholt. Da input() Text zurückgibt, wandle numerische Eingaben vor der Übergabe um:

width = float(input("Width: "))
rectangle_area(width, 2)

Hier wandelt float() den eingegebenen Text in eine Zahl um, bevor die Flächenfunktion ihn erhält.

Ein Schlüsselwortargument nennt im Aufruf den Parameter, für den es bestimmt ist. Das macht einen Aufruf leichter lesbar, wenn mehrere Werte verwechselt werden könnten. Python ordnet das Schlüsselwort dem Namen im Kopf zu, statt seine Position zu verwenden.

Nach Namen zuordnen

def describe_pet(animal, name):
    print(name, "is a", animal)

describe_pet(name="Milo", animal="cat")
describe_pet(animal="cat", name="Milo")

Beide Aufrufe geben „Milo is a cat“ aus. Die Reihenfolge der Schlüsselwortargumente kann sich ändern, weil jeder Wert den Parameter benennt, den er belegt. Nach demselben Prinzip ist rectangle_area(width=4, height=2.5) lesbar, ohne nachzusehen, welche Abmessung zuerst kam.

Ein Schlüsselwort ist keine neue Variable im aufrufenden Code. In describe_pet(name="Milo", animal="cat") leitet name= den Wert „Milo“ an den Parameter. Es weist „Milo“ keiner Variablen namens name auf Modulebene zu. Schreibe Schlüsselwortargumente nach dem üblichen Python-Stil ohne Leerzeichen um =.

Positions- und Schlüsselwortargumente kombinieren

describe_pet("cat", name="Milo")

Das erste Argument belegt animal anhand seiner Position. Das Schlüsselwort belegt name, sodass jeder Parameter genau einen Wert erhält. Positionsargumente müssen zuerst stehen. Der Aufruf describe_pet(name="Milo", "cat") wird mit SyntaxError: positional argument follows keyword argument abgelehnt.

Um einen gemischten Aufruf zu prüfen, belege die Positionen zunächst von links nach rechts und ordne dann die Schlüsselwörter zu. Prüfe, dass keine Position zweimal belegt wird und keine erforderliche Position leer bleibt.

Doppelte oder unbekannte Schlüsselwörter korrigieren

Die doppelte Belegung löst TypeError: describe_pet() got multiple values for argument 'animal' aus. Der Schreibfehler löst TypeError: describe_pet() got an unexpected keyword argument 'nmae' aus. Vergleiche die Namen Zeichen für Zeichen; auch Groß- und Kleinschreibung sind wichtig. Die Reihenfolge der Argumente zu ändern behebt keine doppelte Zuweisung an einen Parameter.

Schlüsselwörter in eingebauten Funktionen erkennen

print("a", "b", "c", sep="-")
print("Loading", end="...")
print("done")

Die erste Zeile gibt „a-b-c“ aus. sep liefert den Text zwischen den angezeigten Werten. Die nächsten beiden Aufrufe erzeugen „Loading...done“ in einer Zeile: end ersetzt den üblichen Zeilenumbruch nach „Loading“.

Einige eingebaute Funktionen akzeptieren ebenfalls benannte Argumente; zum Beispiel ergibt round(3.14159, ndigits=2) den Wert 3,14. Verwende die für die aufgerufene Funktion dokumentierten Parameternamen. Ein selbst erfundenes beschreibendes Wort wird nicht erkannt, nur weil es zur Aufgabe zu passen scheint.

Ein Standardwert ermöglicht es einem Aufruf, ein Argument wegzulassen, wenn eine häufige Wahl geeignet ist. Schreibe den Standardwert im Kopf neben seinen Parameter. Ein übergebenes Argument setzt den Standardwert für diesen Aufruf außer Kraft.

Einen Parameter optional machen

def greet(name, greeting="Hello"):
    print(greeting + ",", name + "!")

greet("Ana")
greet("Ana", "Welcome")
greet("Ana", greeting="Hi")

Die Ausgabe lautet „Hello, Ana!“, „Welcome, Ana!“ und „Hi, Ana!“. name ist erforderlich, weil es keinen Standardwert hat. greet() löst daher einen TypeError aus, obwohl der andere Parameter optional ist.

In diesen Köpfen stehen erforderliche Parameter vor Parametern mit Standardwerten. def greet(greeting="Hello", name): ist ungültig. Python meldet einen Syntaxfehler, weil ein Parameter ohne Standardwert auf einen mit Standardwert folgt. Verschiebe name vor greeting, damit er erforderlich bleibt.

Eine optionale Einstellung ändern

def order_coffee(size, shots=1, milk="none"):
    print(size, "coffee,", shots, "shot(s), milk:", milk)

order_coffee("large", milk="oat")

Dies gibt „large coffee, 1 shot(s), milk: oat“ aus. Das Schlüsselwort erreicht milk, während shots bei 1 bleibt. Ein Positionsaufruf order_coffee("medium", 2) ändert shots und belässt milk bei „none“. Die Zuordnung nach Position überspringt keinen optionalen Parameter, um den nächsten zu erreichen.

Auch eingebaute Funktionen bieten Standardwerte: Ein gewöhnliches print() trennt Werte durch ein Leerzeichen und endet mit einem Zeilenumbruch. round(3.7) ergibt die ganze Zahl 4; round(3.14159, 2) fordert zwei Nachkommastellen an und ergibt 3,14.

Standardwerte werden bei der Ausführung der Definition erstellt

rate = 0.05

def price_with_tax(price, tax_rate=rate):
    return price * (1 + tax_rate)

rate = 0.08
print(price_with_tax(100))
print(price_with_tax(100, rate))

Der Standardwert speichert 0,05, wenn def ausgeführt wird. Eine spätere Änderung von rate ändert diesen gespeicherten Standardwert nicht. Die Aufrufe geben „105.0“ und „108.0“ aus: Nur der zweite übergibt ausdrücklich den neuen Satz.

Versehentlich gemeinsam genutzte Listen vermeiden

Eine Liste enthält Elemente, und append fügt derselben Liste ein Element hinzu. Bei einer Liste als Standardwert teilen sich alle Aufrufe, die das Argument auslassen, diese Liste:

def add_item(item, basket=[]):
    basket.append(item)
    print(basket)

add_item("apple")
add_item("pear")

Dies gibt ['apple'] und dann ['apple', 'pear'] aus. Die Standardliste wurde einmal erstellt, nicht einmal pro Aufruf. Um für jedes weggelassene Argument eine neue Liste zu erstellen, verwende None als Signal:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    print(basket)

Nun geben diese beiden Aufrufe ['apple'] und ['pear'] aus. Eine ausdrücklich übergebene Liste wird weiterhin wie übergeben verwendet. Beschreibe optionale Parameter und ihre Standardwerte im Docstring, damit der aufrufende Code weiß, welche Werte beim Weglassen gewählt werden.

Eine Funktion kann dem aufrufenden Code ein Ergebnis zur Verwendung geben. Die return-Anweisung beendet den Aufruf und gibt dessen Wert zurück. An der aufrufenden Stelle steht der Aufruf für diesen Rückgabewert.

Ergebnisse speichern und kombinieren

def rectangle_area(width, height):
    return width * height

area = rectangle_area(4, 2.5)
print(area)
print(rectangle_area(3, 4) + rectangle_area(2, 5))

Der erste Aufruf gibt 10,0 zurück, das area zugewiesen wird; das erste print zeigt es an. In der letzten Zeile geben die beiden Aufrufe 12 und 10 zurück. Python addiert diese Ergebnisse und gibt „22“ aus. Die Funktion selbst enthält kein print und kann daher sowohl ein gespeichertes Ergebnis als auch einen Teil einer größeren Rechnung liefern.

Ein Rückgabewert kann auch in einer Bedingung geprüft oder an eine andere Funktion übergeben werden. So wird die Aufgabe der Berechnung von der Entscheidung des aufrufenden Codes getrennt, wie das Ergebnis verwendet wird.

Ausgabe und Rückgabe haben verschiedene Aufgaben

def double_print(n):
    print(n * 2)

result = double_print(5)
print(result)

Der Aufruf zeigt „10“ an, aber die angezeigte Zahl wird nicht als Ergebnis zurückgegeben. double_print erreicht das Ende seines Körpers und gibt daher None zurück. Die letzte Zeile gibt deshalb „None“ aus.

double_print(5) + 1 gibt zuerst „10“ aus und löst dann TypeError: unsupported operand type(s) for +: 'NoneType' and 'int' aus. Ersetze den Körper durch return n * 2, wenn der aufrufende Code die verdoppelte Zahl braucht. Eine Funktion, die nur eine Wirkung wie die Anzeige einer Meldung erzeugen soll, kann sinnvollerweise None zurückgeben; solche Funktionen heißen manchmal Funktionen ohne nutzbaren Rückgabewert. Eine Funktion mit einem nutzbaren Rückgabeergebnis heißt manchmal Funktion mit nutzbarem Rückgabewert.

Beim ersten ausgeführten return anhalten

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32
    print("Converted")

print(to_fahrenheit(20))

Dies gibt „68.0“ aus. Das print im Körper wird nie erreicht, weil return den Aufruf bereits beendet hat. Entferne diese unerreichbare Anweisung oder verschiebe eine notwendige Aktion vor die Rückgabe. Die Umrechnung gibt Gleitkommazahlen zurück, weil / eine Gleitkommazahl erzeugt. Die Eingaben 100 und -40 ergeben 212,0 und -40,0.

Ein einzelnes return ohne Ausdruck beendet ebenfalls einen Aufruf und gibt None zurück. Jeder Funktionsaufruf hat ein Ergebnis, auch wenn kein nutzbarer Wert geliefert wurde.

Ergebnisse in einer Programmdatei sichtbar machen

Ein allein stehendes rectangle_area(3, 4) berechnet in einer Datei 12 und verwirft dann das ungenutzte Ergebnis. Verwende print(rectangle_area(3, 4)), um es anzuzeigen, oder weise es einer Variablen zu. Die interaktive Shell zeigt Ergebnisse von Ausdrücken außer None an, sodass ein erfolgreicher Versuch in der Shell anders aussehen kann als die Ausführung derselben Zeile in einer Datei.

Verschiedene Eingaben können verschiedene Antworten brauchen. Eine Funktion kann mehrere return-Anweisungen haben, aber ein Aufruf endet bei der ersten, die er ausführt. Verfolge den tatsächlichen Weg durch ihre Zweige und Schleifen, um das Ergebnis zu finden.

Überlappende Tests anordnen

def letter_grade(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    if score >= 70:
        return "C"
    return "F"

Für 85 ist der erste Test falsch und der zweite wahr. Die Funktion gibt „B“ zurück, ohne die übrigen Bedingungen zu prüfen. Für 42 sind alle drei Tests falsch, sodass das letzte return „F“ liefert. Getrennte if-Anweisungen funktionieren, weil jeder zutreffende Zweig den Aufruf beendet.

Hier muss der höchste Schwellenwert zuerst geprüft werden. Stünde score >= 70 zuerst, würde eine Punktzahl von 95 „C“ zurückgeben. Bei überlappenden Bereichen kann ein früh zutreffender allgemeiner Test eine spätere, genauere Antwort verdecken.

Den Pfad ohne zutreffenden Zweig abdecken

def sign(n):
    if n > 0:
        return "positive"
    elif n < 0:
        return "negative"
    return "zero"

Die letzte Zeile behandelt null. Ohne sie würde sign(0) das Ende erreichen und None zurückgeben. Verfolge eine Eingabe aus jedem Zweig und jeden verbleibenden Fall; würdest du nur positive und negative Eingaben testen, bliebe diese Lücke unentdeckt.

Einen booleschen Vergleich zurückgeben

def is_even(n):
    return n % 2 == 0

if is_even(10):
    print("Even")

Der Vergleich erzeugt bereits True oder False. is_even(10) gibt True zurück, während is_even(7) False zurückgibt. Verwende das Ergebnis direkt in einer Bedingung. Ein zusätzliches == True hilft dem Test nicht.

Eine Suche beenden, bevor kein Treffer gemeldet wird

def smallest_divisor(n):
    for d in range(2, n):
        if n % d == 0:
            return d
    return n

Für 91 scheitern die Kandidaten 2 bis 6, dann teilt 7 die Zahl ohne Rest. Die Rückgabe von 7 beendet sowohl die Schleife als auch die Funktion. Für 13 findet die Schleife keinen Teiler, sodass das letzte return 13 liefert.

Eine Primzahlprüfung muss die Suche nach einem erfolglosen Kandidaten fortsetzen können:

def is_prime(n):
    if n < 2:
        return False
    for d in range(2, n):
        if n % d == 0:
            return False
    return True

Das letzte True steht außerhalb der Schleife. Stünde es in einem else innerhalb der Schleife, würde die Funktion nach der Prüfung des ersten Kandidaten zurückkehren: 9 würde fälschlich akzeptiert, weil sie nicht durch 2 teilbar ist. Mit der korrigierten Funktion ergeben 9 und 1 den Rückgabewert False; 2, 7 und 97 ergeben True. Für 2 hat die Schleife keine Kandidaten und der Ablauf erreicht das letzte True.

Zwei Werte zurückgeben

def share(total, people):
    return total // people, total % people

each, left = share(17, 5)
print(each, left)

Der Aufruf gibt ein Tupel zurück, ein zusammengefasstes Ergebnis mit 3 und 2. Die Zuweisung entpackt es in zwei Namen, sodass die Ausgabe „3 2“ lautet. Die direkte Ausgabe des Aufrufs würde „(3, 2)“ zeigen. Die Anzahl der Namen muss mit der Anzahl der entpackten Werte übereinstimmen.

Aufrufe von innen nach außen kombinieren

def add(a, b):
    return a + b

def to_fahrenheit(celsius):
    return celsius * 9 / 5 + 32

print(to_fahrenheit(add(10, 15)))

add gibt zuerst 25 zurück. Dieser Wert wird zum Argument für to_fahrenheit, das 77,0 zurückgibt. Schließlich zeigt print „77.0“ an. Jeder innere Aufruf muss den Wert zurückgeben, den die nächste Funktion braucht.

Der Gültigkeitsbereich beschreibt, wo ein Name verwendet werden kann. Parameter und Namen, denen innerhalb einer Funktion Werte zugewiesen werden, sind lokal für den jeweiligen Aufruf der Funktion. Der aufrufende Code und eine Funktion können ähnliche Namen verwenden, ohne dieselben lokalen Variablen zu teilen.

Lokale Namen innerhalb ihres Aufrufs halten

def make_greeting():
    message = "Hi"
    print(message)

make_greeting()

Dies gibt „Hi“ aus. Ein zusätzliches print(message) nach dem Aufruf löst NameError: name 'message' is not defined aus: Der lokale Name ist dort nicht verfügbar. Um den Wert dem aufrufenden Code verfügbar zu machen, gib ihn zurück und speichere ihn:

def make_greeting():
    return "Hi"

message = make_greeting()
print(message)

Das message auf Modulebene ist eine neue Variable des aufrufenden Codes, die den Rückgabewert erhält. Die Funktion macht ihre eigenen lokalen Namen nicht außerhalb sichtbar.

Jeder Aufruf erhält neue lokale Variablen. Wenn ein Körper count = 0 setzt, 1 addiert und den Wert ausgibt, geben zwei Aufrufe „1“ und „1“ aus. Der zweite Aufruf setzt nicht mit dem Zählerstand des ersten fort. Auch verschiedene Funktionen können lokale Namen wie total unabhängig voneinander verwenden.

Verdeckung und Namenssuche verfolgen

x = 10

def show():
    x = 5
    print(x)

show()
print(x)

Die Ausgabe lautet „5“ und dann „10“. Das lokale x verdeckt das globale x innerhalb von show; die Zuweisung ändert den Wert auf Modulebene nicht. Eine globale Variable gehört zum Gültigkeitsbereich auf Modulebene der Datei. Gewöhnliche Zuweisungen außerhalb von Funktionen erstellen globale Variablen.

Bei einer auf Modulebene der Datei definierten Funktion sucht Python einen Namen unter ihren lokalen Namen, dann unter den globalen Namen der Datei und dann unter eingebauten Namen wie print. Der erste Treffer wird verwendet. Lokale und globale Namen sind daher verschiedene Stellen, die du prüfen kannst, wenn ein Wert falsch erscheint.

Die erneute Zuweisung an einen Parameter lässt den Namen des aufrufenden Codes unverändert

def add_bonus(points):
    points = points + 10
    print(points)

score = 50
add_bonus(score)
print(score)

points beginnt mit dem Wert 50. Die lokale erneute Zuweisung macht daraus 60, sodass die erste Ausgabe „60“ lautet. Das score des aufrufenden Codes ist weiterhin 50. Um diesen Namen ausdrücklich zu aktualisieren, verwende eine Funktion, die points + 10 zurückgibt, und schreibe dann score = add_bonus(score).

Eine Liste zu ändern ist eine andere Operation

Auf eine Liste kann über zwei Namen verwiesen werden:

def add_guest(guests, name):
    guests.append(name)

party = ["Ana"]
add_guest(party, "Ben")
print(party)

Der Parameter guests und die Variable party des aufrufenden Codes verweisen auf dieselbe Liste. append ändert den Inhalt dieser Liste, daher lautet die Ausgabe „['Ana', 'Ben']“. Eine Zuweisung guests = [] innerhalb der Funktion würde dagegen nur den lokalen Namen auf eine neue Liste verweisen lassen; party würde weiterhin auf die ursprüngliche Liste verweisen. Frag dich beim Nachvollziehen eines Listenarguments, ob die Zeile das gemeinsam referenzierte Objekt ändert oder nur einem lokalen Namen einen neuen Wert zuweist.

Eine Funktion kann einen globalen Namen ohne Deklaration lesen. Für die Zuweisung an einen Namen in ihrem Körper gilt eine andere Regel. Werden diese Operationen verwechselt, entsteht häufig ein UnboundLocalError.

Eine feste Einstellung lesen

TAX_RATE = 0.25

def tax(amount):
    return amount * TAX_RATE

print(tax(80))

Die Ausgabe lautet „20.0“. amount ist lokal; TAX_RATE wird aus den globalen Namen der Datei gelesen. Großbuchstaben kennzeichnen nach Konvention eine Konstante und zeigen an, dass das Programm die Einstellung unverändert lassen soll. Python erzwingt diese Konvention nicht.

Eine Zuweisung macht einen Namen im gesamten Körper lokal

total = 0

def add_to_total(amount):
    total = total + amount

add_to_total(5)

Die Zuweisung macht total in ganz add_to_total lokal. Um die rechte Seite zu berechnen, versucht Python, diesen lokalen Namen zu lesen, bevor er einen Wert hat. Es greift nicht auf das globale total zurück. Der Aufruf löst UnboundLocalError: cannot access local variable 'total' where it is not associated with a value aus.

Die Entscheidung beruht auf dem ganzen Körper, nicht nur auf bereits ausgeführten Zeilen. Auch ein Körper mit print(count) gefolgt von count = 10 behandelt count in der print-Zeile als lokal. Ein globales count kann den fehlenden lokalen Wert nicht liefern.

Eine beabsichtigte globale Zuweisung deklarieren

total = 0

def add_to_total(amount):
    global total
    total = total + amount

add_to_total(5)
add_to_total(7)
print(total)

Nun beziehen sich sowohl das Lesen als auch die Zuweisung auf den globalen Namen, sodass die Ausgabe „12“ lautet. Setze global total vor jede Verwendung von total in der Funktion. Die Verwendung des Namens vor seiner Deklaration ist ein Syntaxfehler.

Eine Deklaration allein erstellt keinen Wert. Eine nachfolgende Zuweisung kann eine globale Variable erstellen, die noch nicht existierte: Ein Funktionskörper mit global level und danach level = 1 erstellt beim Aufruf das globale level.

Die Änderung durch Eingaben und ein Ergebnis zeigen

Dieselbe laufende Summe lässt sich mit einer ausdrücklichen Schnittstelle schreiben:

def add_to_total(total, amount):
    return total + amount

total = 0
total = add_to_total(total, 5)
total = add_to_total(total, 7)
print(total)

Auch dies gibt „12“ aus. Jeder Aufruf zeigt, dass der alte Wert übergeben wird, und die Zuweisung zeigt, wohin der neue Wert gelangt. Du kannst add_to_total(10, 3) für sich prüfen, ohne vorher einen verborgenen globalen Zustand einzurichten. Wenn mehrere Funktionen denselben globalen Wert ändern, hängt ihr Verhalten von der Reihenfolge ihrer Ausführung ab.

Das Lesen einer gemeinsam referenzierten Liste und das Ändern ihres Inhalts nutzen die vorhandene Referenz. Den globalen Namen durch eine andere Liste zu ersetzen ist eine Zuweisung, daher gilt die Zuweisungsregel.

Wer eine Funktion aufruft, muss ihre Aufgabe kennen, ohne ihre gesamte Implementierung zu lesen. Ein Docstring liefert diese Beschreibung. Python erkennt eine Zeichenkette als Docstring der Funktion, wenn sie die erste Anweisung im Körper ist.

Zuerst eine kurze Beschreibung schreiben

def to_fahrenheit(celsius):
    """Convert a temperature from degrees Celsius to degrees Fahrenheit."""
    return celsius * 9 / 5 + 32

print(to_fahrenheit.__doc__)

Die Ausgabe ist der Satz innerhalb der Anführungszeichen. Python speichert den Docstring in __doc__; die dreifachen Anführungszeichen gehören nicht zum gespeicherten Satz. help(to_fahrenheit) zeigt die Beschreibung zusammen mit der Signatur to_fahrenheit(celsius) an. Übergib den Funktionsnamen an help, ohne die Funktion aufzurufen.

Üblich sind dreifache doppelte Anführungszeichen, auch für einen einzeiligen Docstring. Beginne mit einer Aufforderung wie „Gib die Fläche eines Rechtecks zurück.“ und ende mit einem Punkt. Halte eine kurze Beschreibung und ihre schließenden Anführungszeichen in einer Zeile. Du musst den Funktionsnamen und die Parameterliste nicht wiederholen, weil die Hilfeanzeige sie bereits enthält.

Einzelheiten ergänzen, wenn sie gebraucht werden

def split_bill(total, people, tip_rate=0.2):
    """Return each person's share of a bill, including the tip.

    total: the bill before the tip
    people: the number of people sharing the bill
    tip_rate: the tip as a fraction of the bill (default 0.2)
    """
    return total * (1 + tip_rate) / people

Die erste Zeile nennt das Ergebnis. Eine Leerzeile trennt sie von Einzelheiten zu den Eingaben. Der Standardwert ist als 0,2 dokumentiert, als Anteil der Rechnung. Das verhindert, dass jemand beim Aufruf 20 als vorgesehenen Wert für 20 % Trinkgeld versteht. Die schließenden Anführungszeichen eines mehrzeiligen Docstrings stehen in einer eigenen Zeile.

Für split_bill(84, 4) wendet die Funktion den Standardwert für das Trinkgeld an und gibt 25,2 zurück. Wer die Funktion aufruft, kann vor der Wahl der Argumente erfahren, was die drei Eingaben bedeuten. Gib Einheiten an, wenn sie wichtig sind, und beschreibe Wirkungen wie Ausgaben, damit sich sowohl das Ergebnis als auch das sichtbare Verhalten vorhersagen lassen.

Dokumentation und Kommentare unterscheiden

Eine Zeichenkette nach einer Zuweisung oder einer anderen Anweisung im Körper ist kein Docstring der Funktion. Sie ist ein ungenutzter Zeichenkettenausdruck, und __doc__ ist None, wenn kein Docstring als erste Anweisung existiert. Auch ein #-Kommentar wird nicht zur Hilfebeschreibung.

Schreibe die Zusammenfassung, während du die Aufgabe der Funktion festlegst. Wenn der Satz mehrere voneinander unabhängige Aktionen braucht, überlege erneut, ob die Funktion aufgeteilt werden sollte. Wenn du Parameter, Standardwerte, Rückgabewerte oder Ausgaben änderst, aktualisiere gleichzeitig den Docstring; wer die Funktion aufruft, verlässt sich auf ihn als Teil der Schnittstelle.

Zerlegung bedeutet, eine Aufgabe in kleinere Aufgaben aufzuteilen. Jede Funktion übernimmt eine Aufgabe mit klaren Eingaben und einem klaren Ergebnis oder einer klaren Wirkung. Das Hauptprogramm kann sich dann wie eine kurze Folge benannter Schritte lesen.

Daten planen, bevor du die Körper schreibst

Unterscheide für ein Programm, das das arithmetische Mittel von Testergebnissen und eine Buchstabennote ausgibt, drei Arten von Arbeit: Ergebnisse einlesen, ein arithmetisches Mittel berechnen und eine Note wählen. Entscheide, was jede Hilfsfunktion erhält und zurückgibt. Belasse die Ausgabe in main, wo die Ergebnisse zusammenkommen.

def get_score(prompt):
    return float(input(prompt))

def average(a, b, c):
    return (a + b + c) / 3

def letter_grade(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    if score >= 70:
        return "C"
    return "F"

def main():
    first = get_score("Test 1: ")
    second = get_score("Test 2: ")
    third = get_score("Test 3: ")
    avg = average(first, second, third)
    print("Average:", round(avg, 1), "Grade:", letter_grade(avg))

main()

Bei den Ergebnissen 78, 92 und 85 gibt average den Wert 85,0 zurück. Dieses Ergebnis wird zum Argument für letter_grade, das „B“ zurückgibt. Die Ausgabe lautet „Average: 85.0 Grade: B“.

main koordiniert die Reihenfolge; es muss nicht wissen, wie letter_grade seine Antwort wählt. Eine Funktion anhand ihrer Aufgabe und Schnittstelle zu verwenden, ohne jede Anweisung im Körper zu verfolgen, heißt prozedurale Abstraktion. Du verwendest print bereits auf diese Weise.

Eine klare Schnittstelle für den aufrufenden Code schaffen

Die Schnittstelle einer Funktion besteht aus ihrem Namen, ihren Parametern, ihrem Rückgabeergebnis und ihrem dokumentierten Verhalten. average(a, b, c) benötigt drei Zahlen und gibt ihr arithmetisches Mittel zurück. Der aufrufende Code muss keine Eingabeaufforderung lesen oder ausgegebenen Text auffangen, um diese Zahl zu erhalten. Du kannst die Berechnung umschreiben und dabei die vereinbarten Eingaben und die Ausgabe beibehalten; vorhandene Aufrufe funktionieren weiterhin.

Verwende Namen wie calculate_total und print_receipt für Aktionen und is_even oder has_discount für boolesche Fragen. Parameternamen wie price und quantity erklären, welche Werte an die jeweilige Stelle gehören. Namen aus einem Buchstaben können geeignet sein, wenn ihre Bedeutung klar ist, wie bei den drei Eingaben von average.

Wiederholungen in Parameter überführen

Wenn mehrere Teile eines Programms verschiedene Titel zwischen denselben Zeilen aus Gleichheitszeichen ausgeben, mache den Titel zu einem Parameter von print_heading(title). Die wiederholte Struktur gehört in einen Körper, der wechselnde Text in die Aufrufe. Eine spätere Änderung der Zeilenlänge braucht dann nur eine Bearbeitung.

Wähle die Grenzen von Funktionen so, dass Aufgaben leichter zu verstehen oder wiederzuverwenden sind. Wenn jede Anweisung in einem langen main steht, werden die kleineren Aufgaben verdeckt. Jeden einfachen Ausdruck in eine einmal verwendete Hilfsfunktion aufzuteilen, kann Namen hinzufügen, ohne die Lesbarkeit zu verbessern. Eine nützliche Prüfung ist, ob ein kurzer Satz jede Aufgabe und ihre Eingaben und Ausgaben beschreiben kann.

Beende die Datei nach allen Definitionen mit dem tatsächlichen Aufruf main(). Ein Programm, das nur Definitionen enthält, erstellt seine Funktionen und endet, ohne ihre Körper auszuführen.

Wenn du mehrere Funktionen erstellst, bevor du eine davon ausführst, ist ein Fehler schwerer zu finden. Inkrementelle Entwicklung bedeutet, ein kleines Stück zu schreiben, es zu prüfen und dann das nächste hinzuzufügen. So behältst du ein funktionierendes Programm und begrenzt die Menge an neuem Code, die du untersuchen musst.

Beim Planen einen Funktionsplatzhalter verwenden

Ein Funktionsplatzhalter hat den vorgesehenen Kopf und einen Platzhalterkörper. Ein Docstring und pass halten die Definition gültig, aber die Funktion gibt None zurück, bis du sie implementierst. Eine feste Rückgabe kann helfen, die Ausgabe des aufrufenden Codes zu prüfen, ohne zu behaupten, dass die eigentliche Berechnung bereits funktioniert.

Beginne mit einer berechnenden Hilfsfunktion, deren Ergebnis du unabhängig ermitteln kannst. Sobald sie korrekt arbeitet, verbinde sie mit der nächsten Hilfsfunktion. Verschiebe interaktive Eingaben, bis sich die Berechnungen mit direkten Aufrufen prüfen lassen.

Erwartete Ergebnisse vor der Ausführung festlegen

Mit den Funktionen average und letter_grade haben die Ergebnisse 70, 75 und 72 ein arithmetisches Mittel von etwa 72,33; ihre erwartete Note ist also „C“. Prüfe beide Stufen:

print(average(70, 75, 72))
print(letter_grade(average(70, 75, 72)) == "C")

Die Ausgaben lauten „72.33333333333333“ und „True“. Der Vergleich prüft die erwartete Note direkt. Betrachtet man nur die Ausgabe eines Programms, ohne unabhängig ein Ergebnis zu erwarten, kann eine plausible falsche Antwort unentdeckt bleiben.

Grenzen ebenso wie gewöhnliche Eingaben testen

Teste für einen Schwellenwert von 90 die Werte 90 und 89,9. Die korrekte Notenfunktion gibt „A“ und „B“ zurück. Lautete ihre erste Bedingung score > 90, würde nur die Prüfung genau an der Grenze zeigen, dass 90 fälschlich durchfällt.

Beziehe einen typischen Wert, genaue Grenzen, nahe Werte und extreme Eingaben ein, die die Funktion behandeln soll. Bei der Notenfunktion prüfen 70 und 0 die unterste Grenze für eine bestandene Note und den abschließenden „F“-Pfad. Eine Prüfung wie print(letter_grade(85) == "B") ist einfach, weil die Funktion einen Wert entgegennimmt und ihr Ergebnis zurückgibt.

Den Traceback lesen und den ankommenden Wert untersuchen

Angenommen, main ruft letter_grade(input("Score: ")) auf. Die Eingabe „85“ übergibt eine Zeichenkette an einen Vergleich mit einer Zahl. Der letzte Fehler lautet TypeError: '>=' not supported between instances of 'str' and 'int'. Der Traceback weist auf den Vergleich innerhalb der Hilfsfunktion, während eine frühere Aufrufzeile auf main weist.

Der Fehler tritt beim Vergleich auf, die Korrektur gehört aber dorthin, wo die Eingabe vorbereitet wird: Wandle sie vor der Übergabe mit float() um. Ein vorübergehendes print("letter_grade got", score) in der ersten Zeile hilft, eine unerwartete Eingabe zu erkennen. Ist ihr Datentyp unklar, untersuche den aufrufenden Code und die dort verwendete Umwandlung. Entferne Debug-Ausgaben, nachdem der Fehler behoben ist.

Anzeichen mit wahrscheinlichen Ursachen verbinden

Führe nach der Korrektur einer Hilfsfunktion die Prüfungen für ihre betroffenen Pfade und den aufrufenden Code, der sie mit dem Programm verbindet, erneut aus.