5  Schreiben von wiederverwendbarem Code mithilfe von Funktionen

Dieses Tutorial ist das vierte in einer Reihe zur Einführung in die Programmierung und Datenanalyse mit der Python-Programmiersprache. Diese Tutorials basieren auf einem praktischen, programmbasierten Ansatz. Der beste Weg, das Material zu erlernen, besteht darin, den Code auszuführen und mit den Beispielen zu experimentieren.

Die folgenden Themen werden in diesem Tutorial behandelt:

• Funktionen erstellen und verwenden
• Erstellen von Funktionen in Python
• Übung - Datenanalyse für die Urlaubsplanung

5.1 Funktionen erstellen und verwenden

5.1.1 Grundlagen

Eine Funktion ist ein wiederverwendbarer Satz von Anweisungen. Eine Funktion nimmt eine oder mehrere Eingaben entgegen, führt bestimmte Operationen aus und gibt häufig eine Ausgabe zurück. Python bietet viele integrierte Funktionen wie print und ermöglicht Ihnen auch die Definition eigener Funktionen.

today = "Saturday"
print("Today is", today)

Today is Saturday

Sie können eine neue Funktion mit dem Keyword def definieren.

def say_hello():
    print('Hello there!')
    print('How are you?')

Beachten Sie die runden Klammern oder Parenthesen () und den Doppelpunkt : nach dem Namen der Funktion. Beide sind wesentliche Teile der Syntax zur Definition einer Funktion. Der Körper der Funktion kann eine oder mehrere Anweisungen enthalten, die ausgeführt werden sollen, wenn die Funktion aufgerufen wird. Ähnlich wie bei bedingten Anweisungen und Schleifen, müssen die Anweisungen durch 4 Leerzeichen eingerückt werden.

Die Anweisungen im Körper einer Funktion werden nicht ausgeführt, wenn eine Funktion definiert wird. Um die Anweisungen auszuführen, müssen wir die Funktion aufrufen oder aktivieren.

say_hello()

Hello there!
How are you?

5.1.2 Funktionsargumente

Funktionen können auch einen oder mehrere Werte als Eingaben akzeptieren (auch bekannt als Argumente oder Parameter). Argumente helfen uns, flexible Funktionen zu schreiben, die dieselbe Operation für verschiedene Werte ausführen können. Darüber hinaus können Funktionen mit dem Keyword return auch einen Wert als Ergebnis zurückgeben, der in einer Variablen gespeichert oder in anderen Ausdrücken verwendet werden kann.

Hier ist eine Funktion, die die geraden Zahlen aus einer Liste herausfiltert.

def filter_even(number_list):
    result_list = []
    for number in number_list:
        if number % 2 == 0:
            result_list.append(number)
    return result_list

Können Sie anhand des Codes verstehen, was die Funktion bewirkt? Wenn nicht, versuchen Sie, jede Zeile der Funktion innerhalb einer Codezelle mit einer Liste von Zahlen als number_list auszuführen.

even_list = filter_even([1, 2, 3, 4, 5, 6, 7])

even_list

[2, 4, 6]

5.2 Erstellen von Funktionen in Python

Als Programmierer verbringen Sie den Großteil Ihrer Zeit mit dem Schreiben und Verwenden von Funktionen, und Python bietet viele Funktionen, um Ihre Funktionen leistungsstark und flexibel zu gestalten. Lassen Sie uns einige davon untersuchen, indem wir ein Problem lösen:

Radha plant den Kauf eines Hauses, das 1.260.000 Dollar kostet. Sie erwägt zwei Optionen zur Finanzierung ihres Kaufs:

• Option 1: Sofortige Anzahlung von 300.000 Dollar und einen 8-jährigen Kredit mit einem Zinssatz von 10% pro Jahr (monatlich zusammengesetzt) für den verbleibenden Betrag.
• Option 2: Ein 10-jähriger Kredit mit einem Zinssatz von 8% (monatlich zusammengesetzt) für den gesamten Betrag.

Beide Kredite müssen in gleichen monatlichen Raten (EMIs) zurückgezahlt werden. Welcher Kredit hat unter den beiden die niedrigere EMI?

Da wir die EMIs für zwei Kreditoptionen vergleichen müssen, könnte es hilfreich sein, eine Funktion zu definieren, die die EMI für einen Kredit berechnet, unter Berücksichtigung von Eingaben wie den Kosten des Hauses, der Anzahlung, der Dauer des Kredits, dem Zinssatz usw. Wir werden diese Funktion Schritt für Schritt aufbauen.

Beginnen wir mit einer einfachen Funktion, die die EMI für die gesamten Kosten des Hauses berechnet, unter der Annahme, dass der Kredit innerhalb eines Jahres zurückgezahlt werden muss und es keine Zinsen oder Anzahlung gibt.

def loan_emi(amount):
    emi = amount / 12
    print('The EMI is ${}'.format(emi))

loan_emi(1260000)

The EMI is $105000.0

5.2.1 Lokale Variablen und “Scope”

Fügen wir ein zweites Argument hinzu, um die Laufzeit des Darlehens in Monaten zu berücksichtigen.

def loan_emi(amount, duration):
    emi = amount / duration
    print('The EMI is ${}'.format(emi))

Beachten Sie, dass die innerhalb der Funktion definierte Variable emi außerhalb der Funktion nicht zugänglich ist. Das Gleiche gilt für die Parameter amount und duration. Dies sind alles lokale Variablen, die innerhalb des Geltungsbereichs der Funktion liegen.

Scope: Der Geltungsbereich bezieht sich auf den Bereich innerhalb des Codes, in dem eine bestimmte Variable sichtbar ist. Jede Funktion (oder Klassendefinition) definiert einen Geltungsbereich innerhalb von Python. Variablen, die in diesem Bereich definiert sind, werden als lokale Variablen bezeichnet. Variablen, die überall verfügbar sind, werden als globale Variablen bezeichnet. Die Regeln des Geltungsbereichs ermöglichen es Ihnen, die gleichen Variablennamen in verschiedenen Funktionen zu verwenden, ohne Werte von einer zur anderen zu teilen.

emi

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[10], line 1
----> 1 emi

NameError: name 'emi' is not defined

amount

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[36], line 1
----> 1 amount

NameError: name 'amount' is not defined

duration

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[37], line 1
----> 1 duration

NameError: name 'duration' is not defined

Wir können nun einen Kredit mit einer Laufzeit von 6 Jahren mit einem Kredit mit einer Laufzeit von 10 Jahren vergleichen (unter der Annahme, dass keine Anzahlung oder Zinsen erfolgt).

loan_emi(1260000, 8*12)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[38], line 1
----> 1 loan_emi(1260000, 8*12)

TypeError: loan_emi() missing 1 required positional argument: 'rate'

loan_emi(1260000, 10*12)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[39], line 1
----> 1 loan_emi(1260000, 10*12)

TypeError: loan_emi() missing 1 required positional argument: 'rate'

5.2.2 Rückgabewerte

Wie zu erwarten ist, ist der EMI für den 6-Jahres-Kredit höher als für den 10-Jahres-Kredit. Im Moment geben wir das Ergebnis aus, aber es wäre besser, es zurückzugeben und die Ergebnisse zum einfacheren Vergleich in Variablen zu speichern. Wir können dies mit der return-Anweisung tun

def loan_emi(amount, duration):
    emi = amount / duration
    return emi

emi1 = loan_emi(1260000, 8*12)

emi2 = loan_emi(1260000, 10*12)

emi1

13125.0

emi2

10500.0

5.2.3 Optionale Argumente

Fügen wir nun ein weiteres Argument hinzu, um die sofortige Anzahlung zu berücksichtigen. Wir machen dies zu einem optionalen Argument mit dem Standardwert 0.

def loan_emi(amount, duration, down_payment=0):
    loan_amount = amount - down_payment
    emi = loan_amount / duration
    return emi

emi1 = loan_emi(1260000, 8*12, 3e5)

emi1

10000.0

emi2 = loan_emi(1260000, 10*12)

emi2

10500.0

Als nächstes fügen wir die Zinsberechnung in die Funktion ein. Hier ist die Formel zur Berechnung des EMI für einen Kredit:

• P ist der Darlehensbetrag (Eng: principal)
• n ist die Anzahl der Monate
• r ist der Zinssatz pro Monat

Die Ableitung dieser Formel würde den Rahmen dieses Tutorials sprengen.

def loan_emi(amount, duration, rate, down_payment=0):
    loan_amount = amount - down_payment
    emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)
    return emi

Beachten Sie, dass beim Definieren der Funktion erforderliche Argumente wie cost, duration und rate vor optionalen Argumenten wie down_payment stehen müssen.

Berechnen wir den EMI für Option 1

loan_emi(1260000, 8*12, 0.1/12, 3e5)

14567.19753389219

Bei der Berechnung des EMI für Option 2 müssen wir das Argument down_payment nicht einbeziehen.

loan_emi(1260000, 10*12, 0.08/12)

15287.276888775077

5.2.4 Named arguments

Der Aufruf einer Funktion mit vielen Argumenten kann oft verwirrend sein und ist anfällig für menschliche Fehler. Zur besseren Übersichtlichkeit bietet Python die Möglichkeit, Funktionen mit named arguments aufzurufen. Der Funktionsaufruf kann auch in mehrere Zeilen aufgeteilt werden.

emi1 = loan_emi(
    amount=1260000, 
    duration=8*12, 
    rate=0.1/12, 
    down_payment=3e5
)

emi1

14567.19753389219

emi2 = loan_emi(amount=1260000, duration=10*12, rate=0.08/12)

emi2

15287.276888775077

5.2.5 Module und Bibliotheksfunktionen

Wir können bereits erkennen, dass die EMI für Option 1 niedriger zu sein scheint als die EMI für Option 2. Es wäre jedoch schön, den Betrag auf volle Dollar aufzurunden, anstatt Ziffern nach dem Dezimalpunkt einzubeziehen. Um dies zu erreichen, könnten wir eine Funktion schreiben, die eine Zahl nehmen und auf die nächste ganze Zahl aufrunden kann (z.B. wird 1,2 auf 2 aufgerundet). Das wäre eine gute Übung zum Ausprobieren!

Da das Aufrunden von Zahlen jedoch eine ziemlich häufige Operation ist, stellt Python dafür eine Funktion bereit (zusammen mit Tausenden von anderen Funktionen) als Teil der Python-Standardbibliothek. Funktionen sind in Module organisiert, die importiert werden müssen, um die Funktionen, die sie enthalten, zu nutzen.

Module: Module sind Dateien, die Python-Code enthalten (Variablen, Funktionen, Klassen usw.). Sie bieten eine Möglichkeit, den Code für große Python-Projekte in Dateien und Ordnern zu organisieren. Ein Modul oder eine spezifische Funktion/Klasse/Variable aus einem Modul muss importiert werden, bevor es in einem Python-Skript oder Notebook verwendet werden kann. Dies bietet Kapselung (encapsulation) und vermeidet Namenskonflikte zwischen Ihrem Code und einem Modul oder zwischen Modulen.

Um unsere EMI-Beträge aufzurunden, können wir die Funktion ceil (kurz für ceiling) aus dem math Modul verwenden. Lassen Sie uns das Modul importieren und es verwenden, um die Zahl 1,2 aufzurunden.

import math

help(math.ceil)

Help on built-in function ceil in module math:

ceil(x, /)
    Return the ceiling of x as an Integral.
    
    This is the smallest integer >= x.

math.ceil(1.2)

2

Lassen Sie uns nun die Funktion math.ceil innerhalb der Funktion home_loan_emi verwenden, um den EMI-Betrag aufzurunden.

Die Verwendung von Funktionen zum Erstellen anderer Funktionen ist eine großartige Möglichkeit, Code wiederverzuwenden und komplexe Geschäftslogik zu implementieren, während der Code klein, verständlich und überschaubar bleibt. Idealerweise sollte eine Funktion nur eine Sache machen, und nur eine. Wenn Sie feststellen, dass Sie innerhalb einer einzigen Funktion zu viele Dinge tun, sollten Sie in Erwägung ziehen, sie in 2 oder mehr kleinere, unabhängige Funktionen aufzuteilen. Als Faustregel gilt, dass Sie versuchen sollten, Ihre Funktionen auf 10 Zeilen Code oder weniger zu beschränken. Gute Programmierer schreiben immer kleine, einfache und lesbare Funktionen.

def loan_emi(amount, duration, rate, down_payment=0):
    loan_amount = amount - down_payment
    emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)
    emi = math.ceil(emi)
    return emi

emi1 = loan_emi(
    amount=1260000, 
    duration=8*12, 
    rate=0.1/12, 
    down_payment=3e5
)

emi1

14568

emi2 = loan_emi(amount=1260000, duration=10*12, rate=0.08/12)

emi2

15288

Vergleichen wir die EMIs und zeigen Sie eine Meldung für die Option mit dem niedrigeren EMI an.

if emi1 < emi2:
    print("Option 1 has the lower EMI: ${}".format(emi1))
else:
    print("Option 2 has the lower EMI: ${}".format(emi2))

Option 1 has the lower EMI: $14568

5.2.6 Funktionen wiederverwenden und verbessern

Jetzt wissen wir mit Sicherheit, dass Option 1 von den beiden Optionen die niedrigere EMI aufweist. Was aber noch besser ist, ist, dass wir jetzt eine praktische Funktion loan_emi haben, mit der sich viele andere ähnliche Probleme mit nur wenigen Codezeilen lösen lassen. Versuchen wir es mit ein paar weiteren Problemen.

F: Shaun zahlt derzeit einen Wohnungsbaukredit für ein Haus zurück, das er vor einigen Jahren gekauft hat. Die Kosten für das Haus betrugen $800,000. Shaun leistete eine Anzahlung von 25% der Kosten und finanzierte den verbleibenden Betrag mit einem 6-Jahres-Darlehen mit einem Zinssatz von 7% pro Jahr (monatlich verzinst). Shaun kauft jetzt ein Auto im Wert von $60,000, das er plant, mit einem 1-jährigen Darlehen mit einem Zinssatz von 12% pro Jahr zu finanzieren. Beide Kredite werden in EMIs zurückgezahlt. Wie hoch ist die gesamte monatliche Zahlung, die Shaun zur Kreditrückzahlung leistet?

Diese Frage ist nun mit der von uns bereits definierten Funktion loan_emi einfach zu lösen.

cost_of_house = 800000
home_loan_duration = 6*12 # months
home_loan_rate = 0.07/12 # monthly
home_down_payment = .25 * 800000

emi_house = loan_emi(amount=cost_of_house,
                     duration=home_loan_duration,
                     rate=home_loan_rate, 
                     down_payment=home_down_payment)

emi_house

10230

cost_of_car = 60000
car_loan_duration = 1*12 # months
car_loan_rate = .12/12 # monthly

emi_car = loan_emi(amount=cost_of_car, 
                   duration=car_loan_duration, 
                   rate=car_loan_rate)

emi_car

5331

print("Shaun makes a total monthly payment of ${} towards loan repayments.".format(emi_house+emi_car))

Shaun makes a total monthly payment of $15561 towards loan repayments.

5.2.7 Exceptions und try-except

F: Wenn Sie sich 100.000 US-Dollar mit einem 10-jährigen Darlehen mit einem Zinssatz von 9 % pro Jahr leihen, wie hoch ist dann der Gesamtbetrag, den Sie am Ende als Zinsen zahlen?

Eine Möglichkeit, dieses Problem zu lösen, besteht darin, die EMIs für zwei Kredite zu vergleichen: einen mit dem angegebenen Zinssatz und einen mit einem Zinssatz von 0 %. Der gezahlte Gesamtzins ist dann einfach die Summe der monatlichen Differenzen über die Laufzeit des Darlehens.

emi_with_interest = loan_emi(amount=100000, duration=10*12, rate=0.09/12)
emi_with_interest

1267

emi_without_interest = loan_emi(amount=100000, duration=10*12, rate=0./12)
emi_without_interest

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[70], line 1
----> 1 emi_without_interest = loan_emi(amount=100000, duration=10*12, rate=0./12)
      2 emi_without_interest

Cell In[60], line 3, in loan_emi(amount, duration, rate, down_payment)
      1 def loan_emi(amount, duration, rate, down_payment=0):
      2     loan_amount = amount - down_payment
----> 3     emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)
      4     emi = math.ceil(emi)
      5     return emi

ZeroDivisionError: float division by zero

Etwas scheint schief gelaufen zu sein! Wenn man sich die Fehlermeldung oben genau ansieht, sagt Python uns genau, was falsch gelaufen ist. Python wirft einen ZeroDivisionError mit einer Nachricht, die anzeigt, dass wir versuchen, eine Zahl durch Null zu teilen. Dies ist eine Exception, die die weitere Ausführung des Programms stoppt.

Exception: Auch wenn eine Anweisung oder ein Ausdruck syntaktisch korrekt ist, kann er einen Fehler verursachen, wenn versucht wird, ihn auszuführen. Während der Ausführung erkannte Fehler werden Ausnahmen (exceptions) genannt. Exceptions stoppen typischerweise die weitere Ausführung des Programms, es sei denn, sie werden im Programm mit try-except Anweisungen behandelt.

Python bietet viele built-in Exceptions, die geworfen werden, wenn eingebaute Operatoren, Funktionen oder Methoden auf eine falsche Weise verwendet werden (Link). Sie können auch Ihre eigene benutzerdefinierte Exception definieren, indem Sie die Exception-Klasse erweitern (dazu später mehr).

Mit den Anweisungen try und except können Sie eine Ausnahme behandeln. Hier ist ein Beispiel:

try:
    print("Now computing the result..")
    result = 5 / 0
    print("Computation was completed successfully")
except ZeroDivisionError:
    print("Failed to compute result because you were trying to divide by zero")
    result = None

print(result)

Now computing the result..
Failed to compute result because you were trying to divide by zero
None

Wenn eine Ausnahme in dem Code innerhalb eines try Blocks auftritt, werden die restlichen Anweisungen in dem Block übersprungen und die except Anweisung wird ausgeführt. Wenn die Art der geworfenen Ausnahme mit der Art der Ausnahme übereinstimmt, die durch die except Anweisung behandelt wird, dann wird der Code innerhalb des except Blocks ausgeführt und die Programmausführung kehrt dann zum normalen Ablauf zurück.

Sie können auch mehr als einen Typ von Ausnahme mit mehreren except Anweisungen behandeln. Erfahren Sie hier mehr über Ausnahmen.

Lassen Sie uns die loan_emi Funktion erweitern, um try-except zu verwenden, um das Szenario zu behandeln, in dem der Zinssatz 0% beträgt. Es ist üblich, Änderungen/Erweiterungen an Funktionen im Laufe der Zeit vorzunehmen, wenn neue Szenarien und Anwendungsfälle auftreten. Es macht Funktionen flexibler & leistungsfähiger.

def loan_emi(amount, duration, rate, down_payment=0):
    loan_amount = amount - down_payment
    try:
        emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)
    except ZeroDivisionError:
        emi = loan_amount / duration
    emi = math.ceil(emi)
    return emi

Wir können die aktualisierte Funktion loan_emi verwenden, um unser Problem zu lösen.

F: Wenn Sie sich 100.000 US-Dollar mit einem 10-jährigen Darlehen mit einem Zinssatz von 9 % pro Jahr leihen, wie hoch ist dann der Gesamtbetrag, den Sie am Ende als Zinsen zahlen?

emi_with_interest = loan_emi(amount=100000, duration=10*12, rate=0.09/12)
emi_with_interest

1267

emi_without_interest = loan_emi(amount=100000, duration=10*12, rate=0)
emi_without_interest

834

total_interest = (emi_with_interest - emi_without_interest) * 10*12

print("The total interest paid is ${}.".format(total_interest))

The total interest paid is $51960.

5.2.8 Funktionen mit Docstrings dokumentieren

Mit einem Docstring können wir unserer Funktion Dokumentation hinzufügen. Ein Docstring ist einfach ein String, der als erste Anweisung im Funktionskörper erscheint und von der Funktion help verwendet wird. Ein guter Docstring beschreibt, was die Funktion tut, und bietet einige Erklärungen zu den Argumenten.

def loan_emi(amount, duration, rate, down_payment=0):
    """Calculates the equal montly installment (EMI) for a loan.
    
    Arguments:
        amount - Total amount to be spent (loan + down payment)
        duration - Duration of the loan (in months)
        rate - Rate of interest (monthly)
        down_payment (optional) - Optional intial payment (deducted from amount)
    """
    loan_amount = amount - down_payment
    try:
        emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)
    except ZeroDivisionError:
        emi = loan_amount / duration
    emi = math.ceil(emi)
    return emi

Im obigen docstring haben wir einige zusätzliche Informationen bereitgestellt, dass sowohl die duration als auch die rate in Monaten gemessen werden. Sie könnten sogar erwägen, die Argumente duration_months und rate_monthly zu benennen, um jegliche Verwirrung zu vermeiden. Können Sie sich andere Möglichkeiten vorstellen, wie die Funktion verbessert werden kann?

help(loan_emi)

Help on function loan_emi in module __main__:

loan_emi(amount, duration, rate, down_payment=0)
    Calculates the equal montly installment (EMI) for a loan.
    
    Arguments:
        amount - Total amount to be spent (loan + down payment)
        duration - Duration of the loan (in months)
        rate - Rate of interest (monthly)
        down_payment (optional) - Optional intial payment (deducted from amount)

5.3 Übung - Datenanalyse für die Urlaubsplanung

Sie planen eine Freizeitreise (Urlaub) und müssen entscheiden, welche Stadt Sie besuchen möchten. Sie haben 4 Städte in die engere Auswahl genommen und die Kosten für den Rückflug, die täglichen Hotelkosten und die wöchentlichen Mietwagenkosten ermittelt (ein Auto muss für ganze Wochen gemietet werden, auch wenn Sie das Auto vor Ende einer Woche zurückgeben).

Stadt	Rückflug ($)	Hotel pro Tag ($)	Wöchentliche Autovermietung ($)
Paris	200	20	200
London	250	30	120
Dubai	370	15	80
Mumbai	450	10	70

Beantworten Sie die folgenden Fragen anhand der oben genannten Daten:

1. Wenn Sie eine 1-wöchige Reise planen, welche Stadt sollten Sie besuchen, um das wenigste Geld auszugeben?
2. Wie ändert sich die Antwort auf die vorherige Frage, wenn Sie die Dauer der Reise auf 4 Tage, 10 Tage oder 2 Wochen ändern?
3. Wenn Ihr Gesamtbudget für die Reise $1000 beträgt, welche Stadt sollten Sie besuchen, um die Dauer Ihrer Reise zu maximieren? Welche Stadt sollten Sie besuchen, wenn Sie die Dauer minimieren möchten?
4. Wie ändert sich die Antwort auf die vorherige Frage, wenn Ihr Budget $600, $2000 oder $1500 beträgt?

Hinweis: Um diese Fragen zu beantworten, könnte es hilfreich sein, eine Funktion cost_of_trip mit relevanten Eingaben wie Flugkosten, Hotelpreis, Mietwagenpreis und Dauer der Reise zu definieren. Die Funktion math.ceil könnte nützlich sein, um die Gesamtkosten der Autovermietung zu berechnen.

# Verwenden Sie diese Zellen, um die Frage zu beantworten – bauen Sie die Funktion Schritt für Schritt auf

5.4 Weiterführende Literatur und Referenzen

Hier sind noch einige weitere Themen, die Sie lernen könnten:

• Funktionen mit einer beliebigen Anzahl von Argumenten (*args und **kwargs)
• Definition von Funktionen innerhalb von Funktionen (und Closures)
• Eine Funktion, die sich selbst aufruft (Rekursion)
• Funktionen, die andere Funktionen als Argumente akzeptieren oder andere Funktionen zurückgeben
• Funktionen, die andere Funktionen verbessern (Dekorateure)

Im Folgenden finden Sie einige Ressourcen, um mehr über Funktionen in Python zu erfahren:

• Python Tutorial bei W3Schools
• Praktische Python Programmierung
• Python offizielle Dokumentation