Python Functions Tutorial

Standard-Argumente

Standardargumente sind diejenigen, die einen Standardwert annehmen, wenn während des Funktionsaufrufs kein Argumentwert übergeben wird. Du kannst diesen Standardwert mit dem Zuweisungsoperator = zuweisen, so wie im folgenden Beispiel:

Erforderliche Argumente

Wie der Name schon verrät, sind die erforderlichen Argumente einer UDF diejenigen, die dort enthalten sein müssen. Diese Argumente müssen während des Funktionsaufrufs und in genau der richtigen Reihenfolge übergeben werden, so wie im folgenden Beispiel:

Du brauchst Argumente, die sowohl den a als auch den b Parametern entsprechen, um die Funktion ohne Fehler aufrufen zu können. Wenn du a und b vertauschst, wird das Ergebnis nicht anders ausfallen, aber vielleicht schon, wenn du plus() wie folgt änderst:

Schlüsselwort-Argumente

Wenn du sicherstellen willst, dass du alle Parameter in der richtigen Reihenfolge aufrufst, kannst du das Schlüsselwort arguments in deinem Funktionsaufruf verwenden. Du verwendest diese, um die Argumente durch ihren Parameternamen zu identifizieren. Nehmen wir das Beispiel von oben, um das etwas zu verdeutlichen:

Beachte, dass du mit den Schlüsselwörtern Argumente auch die Reihenfolge der Parameter vertauschen kannst und trotzdem das gleiche Ergebnis erhältst, wenn du deine Funktion ausführst:

Variable Anzahl von Argumenten

In Fällen, in denen du die genaue Anzahl der Argumente, die du einer Funktion übergeben willst, nicht kennst, kannst du die folgende Syntax mit *args verwenden:

Das Sternchen (*) wird vor den Variablennamen gesetzt, der die Werte aller Nicht-Schlüsselwort-Variablenargumente enthält. Beachte hier, dass du genauso gut *varint, *var_int_args oder einen anderen Namen an die Funktion plus() hättest übergeben können.

Tipp: Versuche, *args durch einen anderen Namen zu ersetzen, der das Sternchen enthält. Du wirst sehen, dass der obige Code weiterhin funktioniert!

Du siehst, dass die obige Funktion die eingebaute Python-Funktion sum() nutzt, um alle Argumente zu summieren, die an plus() übergeben werden. Wenn du dies vermeiden und die Funktion komplett selbst erstellen möchtest, kannst du diese Alternative verwenden:

Globale vs. lokale Variablen

Im Allgemeinen haben Variablen, die innerhalb eines Funktionskörpers definiert sind, einen lokalen Geltungsbereich, während Variablen, die außerhalb definiert sind, einen globalen Geltungsbereich haben. Das bedeutet, dass lokale Variablen innerhalb eines Funktionsblocks definiert sind und nur innerhalb dieser Funktion aufgerufen werden können, während globale Variablen von allen Funktionen in deinem Skript aufgerufen werden können:

Du wirst sehen, dass du eine NameError bekommst, die besagt, dass die name 'total' is not defined, wenn du versuchst, die lokale Variable total auszudrucken, die innerhalb des Funktionskörpers definiert wurde. Die Variable init hingegen kann problemlos ausgedruckt werden.

Anonyme Funktionen in Python

Anonyme Funktionen werden in Python auch Lambda-Funktionen genannt, denn anstatt sie mit dem Standardschlüsselwort def zu deklarieren, verwendest du das Schlüsselwort lambda.

In dem obigen DataCamp Light Chunk ist lambda x: x*2 die anonyme oder Lambda-Funktion. x ist das Argument und x*2 ist der Ausdruck oder die Anweisung, die ausgewertet und zurückgegeben wird. Das Besondere an dieser Funktion ist, dass sie keinen Namen hat, wie die Beispiele, die du im ersten Teil dieses Funktions-Tutorials gesehen hast. Wenn du die obige Funktion in eine UDF schreiben müsstest, würde das Ergebnis folgendermaßen aussehen:

def double(x):
  return x*2

Betrachten wir ein weiteres Beispiel für eine Lambda-Funktion, bei der du mit zwei Argumenten arbeitest:

Du verwendest anonyme Funktionen, wenn du für einen kurzen Zeitraum eine namenlose Funktion benötigst, die zur Laufzeit erstellt wird. In bestimmten Kontexten ist dies relevant, wenn du mit filter(), map() und reduce() arbeitest:

Die Funktion filter() filtert, wie der Name schon sagt, die ursprüngliche Eingabeliste my_list auf der Grundlage eines Kriteriums >10. Mit map() wendest du dagegen eine Funktion auf alle Elemente der Liste my_list an. In diesem Fall multiplizierst du alle Elemente mit 2.

Beachte, dass die Funktion reduce() Teil der Bibliothek functools ist. Du wendest diese Funktion kumulativ auf die Elemente der Liste my_list an, von links nach rechts, und reduzierst die Folge auf einen einzigen Wert, in diesem Fall 55.

Mit main() als Funktion

Wenn du Erfahrung mit anderen Programmiersprachen wie Java hast, wirst du wissen, dass die Funktion main benötigt wird, um Funktionen auszuführen. Wie du in den Beispielen oben gesehen hast, ist das für Python nicht unbedingt nötig. Es kann jedoch praktisch sein, eine main() Funktion in dein Python-Programm einzubauen, um deinen Code logisch zu strukturieren - alle wichtigen Komponenten sind in dieser main() Funktion enthalten.

Du kannst ganz einfach eine main() Funktion definieren und sie genauso aufrufen, wie du es mit allen anderen Funktionen oben getan hast:

So wie es jetzt aussieht, wird der Code deiner main() Funktion jedoch aufgerufen, wenn du sie als Modul importierst. Damit das nicht passiert, rufst du die Funktion main() auf, wenn du __name__ == '__main__' aufrufst.

Das bedeutet, dass der Code des obigen Codeabschnitts zu:

Beachte, dass du neben der Funktion __main__ auch eine Funktion __init__ hast, die eine Instanz einer Klasse oder eines Objekts initialisiert. Einfach gesagt, fungiert er als Konstruktor oder Initialisierer und wird automatisch aufgerufen, wenn du eine neue Instanz einer Klasse erstellst. Mit dieser Funktion wird das neu erstellte Objekt dem Parameter self zugewiesen, den du weiter oben in diesem Lernprogramm gesehen hast. Sieh dir das folgende Beispiel an:

class Dog:
    """    
    Requires:
    legs - Legs so that the dog can walk.
    color - A color of the fur.
    """

    def __init__(self, legs, color):
        self.legs = legs
        self.color = color
        
    def bark(self):
        bark = "bark" * 2
        return bark

if __name__ == "__main__":
    dog = Dog(4, "brown")
    bark = dog.bark()
    print(bark)