Funktionen in

Über Funktionen

Eine function ist ein Block aus organisiertem, wiederverwendbarem Code, der eine bestimmte Aufgabe erfüllt. Functions sorgen für mehr Modularität in deiner Anwendung und eine hohe Wiederverwendung von Code. Python hat, wie andere Programmiersprachen, integrierte Funktionen (print, map und so weiter), die direkt verfügbar sind. Du kannst auch deine eigenen Funktionen definieren. Diese werden user-defined functions genannt. Funktionen können etwas so Einfaches tun wie eine Nachricht auf der Konsole auszugeben, oder sie können recht komplex sein.

Um den Code innerhalb einer Funktion auszuführen, musst du die Funktion aufrufen. Dazu verwendest du den Funktionsnamen gefolgt von runden Klammern [()]. Daten, die als arguments bezeichnet werden, kannst du an die Funktion übergeben, indem du sie in die runden Klammern setzt. Eine Funktionsdefinition kann null oder mehr parameters enthalten. Parameter legen fest, welche Argumente die Funktion akzeptiert. Ein Parameter legt fest, welcher Typ von Argument übergeben werden soll. Das Argument ist der tatsächliche Wert, der beim Aufruf der Funktion übergeben wird. Funktionen können je nach den an die Parameter übergebenen Argumenten unterschiedliche Aufgaben erfüllen.

Eine Funktion kann mit dem Schlüsselwort return auch einen Wert zurückgeben. Der von der Funktion zurückgegebene Wert wird als return value bezeichnet. Der Rückgabewert wird an den Aufrufer der Funktion zurückgegeben.

Definition

In Python werden Funktionen mit dem Schlüsselwort def erstellt. Auf die Funktionsdefinition folgen der Funktionsname und runde Klammern [()]. In den runden Klammern werden die Parameter angegeben, getrennt durch Kommas. Nach der schließenden Klammer trennt der Doppelpunkt (:) die Funktionssignatur vom Funktionskörper.

Der Funktionskörper ist ein Block aus Code, der ausgeführt wird, wenn die Funktion aufgerufen wird. Der Funktionskörper ist eingerückt. Die Einrückung ist wichtig, weil Python sich darauf verlässt, um zu wissen, wo dieser Block endet. Mithilfe des Schlüsselworts return kann ein Wert aus der Funktion zurückgegeben werden, den der Aufrufer der Funktion dann verwenden kann.

def function_name(parameter1, parameter2, ...):
    # function body
    return parameter1 + parameter2

Wir können auch eine Funktion ohne Parameter oder Rückgabewert definieren.

def function_name():
    # function body
    pass

Beachte, dass die Funktion einen Körper braucht, auch wenn dieser nichts tut. Sonst erzeugt der Versuch, das Programm auszuführen, einen Einrückungsfehler:

>>> def my_bodyless_func():
...      

File ~/temp.py:1
    
    ^
IndentationError: expected an indented block

Eine Funktion aufrufen

Um eine Funktion aufzurufen, verwendest du den Funktionsnamen gefolgt von runden Klammern [()]. Die an die Funktion übergebenen Parameter stehen in den runden Klammern, getrennt durch Kommas.

Betrachte die folgende Funktion:

def greet():
    print("Hello")

Die obige Funktion lässt sich mit der folgenden Syntax aufrufen:

>>> greet()
Hello

Parameter und ihre Argumente

Argumente sind Werte, die beim Aufruf an die Funktion übergeben werden. Sie können von jedem Datentyp sein, auch andere Funktionen oder Klassen.

Definieren wir eine Funktion add, die zwei Zahlen addiert:

def add(first, second):
    print(first + second)

Die Parameter first und second legen fest, welche Argumente die Funktion add akzeptiert. (Es sei darauf hingewiesen, dass die Wörter parameter und argument oft austauschbar verwendet werden, wenn auch ungenau.) Beim Aufruf der Funktion werden die Argumente an die Funktion übergeben. Wir müssen Argumente für beide Parameter übergeben, sonst wird ein TypeError ausgelöst.

>>> add(2, 3)
5

# Function can be called multiple times, with different parameters
>>> add(4, 3)
7
>>> add(5, 6)
11

# Passing an incorrect number of parameters will raise a `TypeError`
>>> add(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'second'

>>> add(2, 3, 4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes 2 positional arguments but 3 were given

Rückgabewert

Der Rückgabewert ist ein Wert, der an den Aufrufer der Funktion zurückgegeben wird. Ein return value kann jeden Datentyp haben, auch andere Funktionen oder Klassen. Der Aufrufer der Funktion kann ihn verwenden, um weitere Operationen auszuführen. Wenn eine Funktion keinen return value explizit definiert, gibt der Python-Interpreter den Wert None zurück.

Definieren wir eine Funktion add:

def add(first, second):
    return first + second

Wir können den Rückgabewert in einer Variablen speichern und ihn dann ausgeben:

>>> result = add(2, 3)
>>> print(result)
5
# Type of result is `int`
>>> type(result)
<class 'int'>

# We can also perform operations on the return value
>>> result * 2
10

# A function without an explicit return value will return `None`
>>> def log(message):
    print(message)

# Hello is printed because of print(message), but return value is `None`
>>> return_value = log("Hello")
Hello
>>> return_value
None

Die Verwendung von return beendet die Funktion sofort und gibt den Wert an den Aufrufer zurück.

>>> def show(first, second):
    print(first)
    return first
    print(second)

# second never gets printed, because the function exits after the return statement
>>> show(1, 2)
1

Modularität

Komplexe Programme lassen sich in kleinere Teile zerlegen. Verschiedene Funktionen können verwendet werden, um verschiedene konkrete Aufgaben zu erfüllen.

Angenommen, ein Programm muss die folgenden Aufgaben erfüllen:

• Berechne den Flächeninhalt eines Kreises
• Berechne den Flächeninhalt eines Rechtecks
• Berechne den Flächeninhalt eines Dreiecks

Wir können das Programm in kleinere Teile zerlegen.

def circle_area(radius):
    return 3.14 * radius * radius

def rectangle_area(length, breadth):
    return length * breadth

def triangle_area(base, height):
    return 0.5 * base * height

Jetzt können wir die Funktionen in der Reihenfolge aufrufen, die wir wollen.

>>> circle_area(2)
12.56
>>> triangle_area(2, 3)
3.0
>>> rectangle_area(2, 3)
6
>>> rectangle_area(1, 2) + circle_area(2) + triangle_area(1, 2)
15.56

Gültigkeitsbereich von Variablen

Wenn eine Variable (oder ein Name) innerhalb einer Funktion definiert wird, ist sie nur innerhalb des Gültigkeitsbereichs der Funktion (oder des lokalen Namensraums) zugänglich, selbst wenn es außerhalb des Gültigkeitsbereichs der Funktion eine Variable mit demselben Namen gibt.

Variablen, die außerhalb einer Funktion auf Modulebene definiert werden, gehören zum globalen Namensraum. Variablen, die außerhalb einer Funktion, aber innerhalb einer umschließenden Funktion oder Klasse definiert werden, gehören zum nonlocal-Namensraum.

Python verwendet die LEGB-Regel (Local, Enclosing, Global, Built-in), um Variablennamen während der Ausführung eines Programms aufzulösen:

1. Suche im lokalen (oder Funktions-)Namensraum.
2. Suche im umschließenden (oder nonlocal-)Namensraum, wenn ein Name nicht im lokalen gefunden wird.
3. Suche im globalen Namensraum (Modulebene), wenn der Name nicht im nonlocal-/umschließenden gefunden wird.
4. Suche im built-in- (programm- oder pythonweiten) Namensraum, wenn der Name nicht im globalen gefunden wird.

Bleibt der Name unaufgelöst, löst Python eine NameError exception aus.

# Global namespace.
general_favorite = "apples"


def alices_favorite():
   # Local namespace.  
   favorite = "cherries"
   
   # This works because Python will eventually find general_favorite in the global namespace.
   # Python will find 'print' in the built-in namespace.
   print(f'Alice has always liked {favorite}, but most people like {general_favorite}.')

   
def our_favorite_fruits():
    # Enclosing or nonlocal namespace.
    yours = "peaches"
    
    def my_favorite():
        # Local namespace.
        mine = "pears"
        
        # This works because Python will eventually find 'yours' in the enclosing/nonlocal namespace.
        print(f'My favorite is {mine}, but you like {yours} instead.')
        
        # This works because Python will eventually find 'general_favorite' in the global namespace.
        print(f'Everyone seems to like {general_favorite}')
    
    # This function is in the local namespace of the 'our_favorite_fruits' function.  
    my_favorite()

    
# This will raise NameError: name 'favorite' is not defined, because the variable favorite is local to alices_favorite.
print(favorite)

Wenn wir einen Variablennamen außerhalb des lokalen Gültigkeitsbereichs der Funktion zugänglich machen wollen (oder eine Variable ändern wollen, die außerhalb des Gültigkeitsbereichs der Funktion definiert wurde), müssen wir entweder das Schlüsselwort global oder nonlocal verwenden.

Die Verwendung des Schlüsselworts global weist Python an, die Suche im globalen Namensraum zu beginnen. Zuweisungen an die Variable ändern dann die globale Variable, statt eine lokale Version zu erzeugen. Wenn global verwendet wird, um eine Variable zu deklarieren, wird die Variable dem globalen Namensraum hinzugefügt. Daher sollte global mit Vorsicht verwendet werden, denn das Hinzufügen oder Ändern einer globalen Variablen kann Auswirkungen auf jeden anderen Code haben, der ihren Wert verwendet.

Das Schlüsselwort nonlocal weist Python an, die Variable im nonlocal- oder umschließenden Namensraum zu suchen oder dort anzulegen. Es wird verwendet, wenn eine Funktion in einer anderen Funktion oder Klasse verschachtelt ist und Zugriff auf die Variablen und den Gültigkeitsbereich der äußeren Funktion braucht.

Funktionen als First-Class-Objekte

In Python können Funktionen Variablen zugewiesen und als Argumente an andere Funktionen übergeben werden. Sie können als Rückgabewerte verwendet werden. Funktionen können auch in eine Sequenz (list, tuple usw.) gelegt oder als Wert in ein dict eingesetzt werden. Funktionen können überall dort verwendet werden, wo auch jedes andere Objekt verwendet werden kann. Der Grund dafür ist, dass Funktionen First-Class-Objekte sind. Als solche tragen sie besondere Attribute und können sogar das Abrufen und Setzen eigener benutzerdefinierter Attribute definieren.

# print is a function

# A function can be assigned to a variable.
>>> function_as_variable = print
>>> function_as_variable("Hello")
Hello
>>> type(fake_print)
<class 'builtin_function_or_method'>

# Functions can be passed as an argument to another function.
>>> def check_print(func):
    func("Hello")
>>> check_print(print)
Hello

# Function can be used as an item in a sequence.
>>> my_list = [print, "Hello"]
>>> my_list[0]("Hello")
Hello

# Functions can be used as a value in a dictionary.
>>> my_dict = {"key": print}
>>> my_dict["key"]("Hello")
Hello

# Functions can be returned from a function.
>>> def return_func():
    return print
>>> return_func()("Hello")
Hello

Funktionen können auch in andere Funktionen verschachtelt werden.

def outer():
    num = 10
    
    # This is a nested, or "inner" function.
    def inner():
        print(num)
    
    # Outer function calling inner function
    inner()

Die innere Funktion kann auf die in der äußeren Funktion definierte Variable num zugreifen.

>>> outer()
10

Besondere Attribute

Funktionen in Python haben besondere Attribute. Einige davon sind:

• __name__: Name der Funktion
• __doc__: Dokumentations-String der Funktion
• __module__: Modul, in dem die Funktion definiert ist
• __globals__: Dictionary der globalen Variablen in der Funktion
• __code__: Codeobjekt, das die Anweisungen der Funktion enthält

>>> def add(first, second):
      return first + second

# Function name
>>> print.__name__
'print'
>>> len.__name__
'len'
>>> add.__name__
'add'

# Function documentation
>>> abs.__doc__
'Return the absolute value of the argument.'

# Module
>>> len.__module__
'builtins'
>>> add.__module__
'__main__'

Die vollständige Liste der Funktionsattribute findest du unter Python DataModel.