7. Funktionen und Klassen

7. Funktionen und Klassen#

Funktionen und Klassen sind Pythons primäre Möglichkeit, Codeblöcke für wiederholte Ausführungen zu speichern.

Funktionen#

Funktionen sind eine Möglichkeit, einem bestimmten Codeblock einen Namen zu geben, sodass er wiederholt mit unterschiedlichen Startwerten (Inputs) ausgeführt werden kann.

Jede Funktion beginnt mit einer Kopfzeile, die das Schlüsselwort “def” enthält, gefolgt vom Namen der Funktion. Danach müssen runde Klammern folgen, in denen die benötigten Eingaben stehen. Ein Doppelpunkt folgt danach, und der dazugehörige Funktions-Codeblock wird eingerückt, genauso wie bei Schleifen und Bedingungen. Der Codeblock endet normalerweise mit einem “return”-Statement, das angibt, was die Funktion zurückgibt. Die Funktion kann dann mit ihrem Namen und den gewünschten Eingabewerten in Klammern aufgerufen werden.

Beispiel: Wenn wir eine Funktion erstellen wollen, die den Wert von x^2 + 2 zurückgibt, wobei x unser Input ist:

def example_function(x):
    result = x ** 2 + 2
    return result

function_result = example_function(2)
print(function_result)

Man kann einer Funktion auch mehrere Eingabewerte geben. Wenn wir z. B. x^k + 2 berechnen wollen:

def example_function(x, k):
    result = x ** k + 2
    return result

function_result = example_function(2, 3)
print(function_result)

Wir können auch Standardwerte für Eingaben im Funktionskopf festlegen. Hier ein Beispiel mit k=2 als Standardwert:

def example_function(x, k=2):
    result = x ** k + 2
    return result

# Standardwert
function_result = example_function(2) # k muss nicht angegeben werden
print(function_result)

# Anderer Wert als der Standard:
function_result = example_function(2, 3) # k wird angegeben
print(function_result)

6
10

Wenn Funktionen viele Eingabevariablen haben, möchte man manchmal nur eine bestimmte davon ändern. Das geht, indem man die entsprechende Variable beim Funktionsaufruf explizit angibt:

def example_function(x, a=1, b=1, c=1, d=1, e=1, f=1, k=2):
    result = x ** k + 2
    return result

function_result = example_function(2, k=3) # Nur k wird geändert
print(function_result)

Wenn man seine Funktionen beschreiben möchte (hilfreich für andere Nutzer), kann man Docstrings verwenden. Diese werden direkt nach dem Funktionskopf mit drei Anführungszeichen erstellt:

def example_function(x, k=2):
    """Dies ist eine Beispiel-Funktion. Sie berechnet x^k + 2
    Args:
        x: Die Zahl, für die der Ausdruck berechnet wird.
        k: Der Exponent
    Returns:
        x^k + 2
    """
    result = x ** k + 2
    return result

print(help(example_function))

Help on function example_function in module __main__:

example_function(x, k=2)
    Dies ist eine Beispiel-Funktion. Sie berechnet x^k + 2
    Args:
        x: Die Zahl, für die der Ausdruck berechnet wird.
        k: Der Exponent
    Returns:
        x^k + 2

None

Übung 1#

Schreibe eine Funktion namens add_five, die eine Zahl als Eingabe nimmt und diese Zahl plus fünf zurückgibt. Führe sie mit einer beliebigen Zahl aus, um zu testen, ob sie funktioniert.

# Dein Code hier

Übung 2#

Schreibe eine Funktion namens power_plus_two, die zwei Eingaben x und k nimmt und x hoch k plus 2 zurückgibt. Rufe die Funktion mit den Werten x = 3, k = 2 auf.

# Dein Code hier

Klassen#

Note

Die Namen von Klassen werden normalerweise großgeschrieben, während Funktions- und Variablennamen klein geschrieben werden.

Klassen sind größere Strukturen, die mehrere Funktionen und Variablen speichern können. Dies dient oft dazu, ein zusammenhängendes Objekt zu erstellen, das komplexe Operationen mit mehreren Funktionen durchführen kann.

Klassen werden mit einer Kopfzeile wie “class Klassen_Name” erstellt. Jede Klasse muss eine Initialisierungsfunktion “init(self, …)” enthalten.

Die Unterstriche deuten darauf hin, dass diese Funktion nicht direkt vom Nutzer verändert werden soll.
Der Parameter “self” wird in (fast) jeder Funktion einer Klasse verwendet. Damit kann man innerhalb der Klasse auf andere Funktionen und Variablen zugreifen.

Beispiel: Wir erstellen eine Klasse, die bei der Initialisierung eine Variable x als Input nimmt. Dann definieren wir zwei Funktionen: Eine berechnet x^k, die andere x^k+m. Die zweite ruft die erste auf:

class Example_Class:
    def __init__(self, x):
        self.x = x  # self setzt eine Klassenvariable

    def exponential(self, k=2):
        result = self.x ** k  # Zugriff auf self.x
        return result

    def exponential_plus_m(self, k=2, m=2):
        exponential_result = self.exponential(k)  # Aufruf interner Funktion
        result = exponential_result + m
        return result

exponential_calculator = Example_Class(x=2)
result1 = exponential_calculator.exponential(k=3)
print(result1)
result2 = exponential_calculator.exponential_plus_m(k=3, m=4)
print(result2)
print(exponential_calculator.x)

8
12
2

Wie du siehst, rufen wir Funktionen und Variablen innerhalb der Klasse über einen Punkt-Zugriff auf das Objekt auf.

Übung 3#

Schreibe eine Klasse namens Calculator, die eine Zahl x in der Methode __init__ übernimmt. Erstelle zwei Methoden:

square: gibt x zum Quadrat zurück.
add_number: nimmt ein Argument und gibt die Summe von x und diesem Argument zurück.

Erzeuge dann ein Objekt von Calculator mit x = 4 und rufe beide Methoden auf.

# Dein Code hier

Übung 4#

Erweitere die Calculator-Klasse aus Übung 3 um eine Methode multiply_and_add, die x mit einer Zahl m multipliziert und eine weitere Zahl a addiert. Rufe sie mit m = 3 und a = 2 auf.

# Dein Code hier