LU01c - Funktionale Programmierung

Funktionale Programmierung ist ein Paradigma, das Funktionen als primäre Bausteine verwendet, Unveränderlichkeit von Daten fördert und einen deklarativen Stil betont. Es zielt darauf ab, Code klarer und vorhersagbarer zu gestalten.

1. Funktionen als Erste Klasse: Sie können wie jede andere Variable behandelt werden.

2. Unveränderlichkeit: Einmal erstellte Daten werden nicht geändert.

3. Deklarative Natur: Der Code beschreibt, was zu tun ist, nicht wie.

Bevor wir über funktionale Programmierung sprechen, muss geklärt sein, was hier überhaupt mit „Funktion„ gemeint ist. Denn das, was viele Sprachen „Funktion“ nennen, ist streng genommen oft eine Prozedur.

# Prozedur: gibt nichts zurück, wirkt nach aussen (Konsolenausgabe)
def zeige_summe(zahlen):
    print(sum(zahlen))
 
# Funktion: liefert einen Wert, verändert nichts ausserhalb
def berechne_summe(zahlen):
    return sum(zahlen)
 
zahlen = [1, 2, 3, 4, 5]
 
r1 = zeige_summe(zahlen)        # Ausgabe: 15
r2 = berechne_summe(zahlen)     # keine Ausgabe
 
print(r1)                       # None   ← die Prozedur liefert nichts zurück
print(r2)                       # 15     ← die Funktion liefert das Ergebnis

Nur Funktionen im obigen Sinn lassen sich gefahrlos kombinieren, wiederverwenden und testen. Vergleichen Sie:

# Prozedur mit globalem Zustand
total = 0
 
def addiere_zum_total(x):
    global total
    total += x
 
addiere_zum_total(5)
addiere_zum_total(5)
print(total)                    # 10 – das Ergebnis hängt von der Vorgeschichte ab
 
 
# Funktion ohne globalen Zustand
def addiere(a, b):
    return a + b
 
print(addiere(5, 5))            # 10
print(addiere(5, 5))            # 10 – immer dasselbe, egal wie oft

Der entscheidende Punkt: addiere(5, 5) kann man im Kopf jederzeit durch 10 ersetzen, ohne dass sich am Programm etwas ändert. Bei addiere_zum_total(5) geht das nicht – man muss den bisherigen Verlauf des Programms kennen, um zu wissen, was passiert. Genau diese Ersetzbarkeit heisst referenzielle Transparenz und ist der Grund, warum funktionaler Code leichter zu testen und zu verstehen ist.

• Methode: Eine Funktion oder Prozedur, die zu einem Objekt gehört. In Python gut am Punkt erkennbar: liste.append(4). Methoden verändern typischerweise den Zustand ihres Objekts – sind also meist Prozeduren.
• Mathematische Funktion: Bildet jede Eingabe eindeutig auf genau eine Ausgabe ab und tut sonst nichts. Genau dieses Ideal greift die funktionale Programmierung mit dem Begriff der pure function auf (siehe LU02).

liste = [3, 1, 2]
print(liste.sort())     # None       ← Prozedur (Methode): verändert die Liste
print(liste)            # [1, 2, 3]
 
liste2 = [3, 1, 2]
print(sorted(liste2))   # [1, 2, 3]  ← Funktion: liefert eine neue Liste
print(liste2)           # [3, 1, 2]  ← Original bleibt unverändert

Deklarative Programmierung ist ein übergeordnetes Konzept, das funktional, logisch und einigen anderen Paradigmen gemeinsam ist. Es betont die Beschreibung der gewünschten Ergebnisse, ohne spezifische Anweisungen zu geben, wie diese Ergebnisse erreicht werden sollen.

Quadrieren einer Liste in Python auf funktionale Weise:

def quadrat(x):
    return x**2
 
zahlen = [1, 2, 3, 4, 5]
quadrate = map(quadrat, zahlen)
print(list(quadrate)) # Ausgabe: [1, 4, 9, 16, 25]

Funktionen sind das Herzstück der funktionalen Programmierung:

def anwenden(f, wert):
    return f(wert)
 
quadrat = lambda x: x**2
ergebnis = anwenden(quadrat, 5)
print(ergebnis) # Ausgabe: 25

Hier passiert etwas Bemerkenswertes: quadrat wird wie ein normaler Wert in einer Variablen abgelegt und als Argument weitergegeben. Das meint Funktionen als Erste Klasse (first-class). Eine Funktion wie anwenden, die selbst eine Funktion entgegennimmt oder zurückgibt, nennt man höherwertige Funktion (higher-order function).

Die Unveränderlichkeit fördert sauberen, nachvollziehbaren Code:

original_liste = [1, 2, 3]
neue_liste = original_liste + [4] # Original bleibt unverändert

Ein deklarativer Ansatz beschreibt, was getan werden soll:

# Deklarativ
summe = sum(zahlen)

Deklarative Programmierung ist ein breiteres Konzept, das die funktionale Programmierung einschliesst. Während die funktionale Programmierung sich auf die Verwendung von Funktionen und Unveränderlichkeit konzentriert, bezieht sich die deklarative Programmierung auf die Abstraktion des „wie„ und konzentriert sich auf das „was“.

def zeige_durchschnitt(zahlen):
    print(sum(zahlen) / len(zahlen))

© Kevin Maurizi