Multiparadigmatische Nutzung von Programmierparadigmen

Rekursion und Schleifenstrukturen

In imperativen Programmen ist die Nutzung von Schleifenstrukturen wie while und for ein gängiges Programmierkonzept. Zum Beispiel zur Bestimmung der Fakultät:

#Python
def fakultaet(n):
    ergebnis = 1
    while(n>0):
        ergebnis = ergebnis * n
        n = n-1
    return ergebnis

In funktionalen Programmen sind diese Programmierkonzepte jedoch nicht möglich. Anstelle dieser verwendet man Rekursion.

Aufgabe 1: Rekursion

(a) Ergänze den fehlenden Racket-Code ... zur Erstellung einer rekursiven Fakultätsberechnung.

;Racket
(define fakultaet
  (lambda (n)
    (if [= n 0]
        1
        ...)))

Rekursion ist jedoch kein Alleinstellungsmerkmal funktionaler Sprachen, sondern kann in imperativen Sprachen analog verwendet werden.

(b) Schreibe in dein Python-Programm eine Funktion fakultaetRek, die die Fakultätsberechnung rekursiv durchführt.

Funktionen höherer Ordnung und Anonyme Funktionen

Ein weiteres wichtiges Programmierkonzept der funktionalen Programmierung stellen Funktionen höherer Ordnung dar. Also all die Funktionen, die Funktionen als Übergabedaten erhalten oder als Rückgabedaten liefern.

Das funktionale Konzept, Funktionen wie andere Daten zu behandeln und sie entsprechend als Werte übergeben oder zurückgeben zu können, ist so mächtig und praktisch, dass es inzwischen auch in viele imperative Programmiersprachen integriert wurde.

Aufgabe 2: Funktionen höherer Ordnung in Python

(a) Überlege, welche Ausgabe das untenstehende Python-Programm produziert und überprüfe deine Vermutung.

#Python
def erhoehe(x):
    return x + 1

def wendeAn(f,x):
    return f(x)

y = wendeAn(erhoehe,2)
print(y)

(b) Insbesondere Listenfunktionen wie map und filter finden sich explizit in vielen imperativen Sprachen wieder. Überlege, welche Ausgabe die untenstehende Python-Zeile produziert und überprüfe deine Vermutung.

#Python
zahlenliste = [1, 2, 3, 4]
print( list(map(erhoehe, zahlenliste)) )

Zur Nutzung der Listenfunktionen haben wir in Racket häufig anonyme Funktionen übergeben, zum Beispiel:

;Racket
(define zahlenliste (list 1 2 3 4))
(filter (lambda (x) (< x 3)) zahlenliste)

Auch das ist mittlerweile in Python möglich:

#Python
zahlenliste = [1, 2, 3, 4]
print( list(filter(lambda x: x < 3, zahlenliste)) )

(c) Schreibe einen Python-Befehl, der dir in einer Liste jeden Wert um zwei verringert. Nutze hierfür eine anonyme Funktion.

Records vs. Klassen und Objekte

Zur Strukturierung von imperativen Programmen kommen häufig Klassen und Objekte zum Einsatz. Betrachtet man beispielsweise die Klasse Schuelerin in Python:

#Python
class Schuelerin:
    def __init__(self, name, jgs, noten):
        self.name = name
        self.jgs = jgs
        self.noten = noten #Liste

    def durchschnitt(self):
        if len(self.noten)==0:
            return 0
        return sum(self.noten) / len(self.noten)

Die Klasse besitzt mit name, jgs und noten drei veränderbare Attribute und mit durchschnitt eine Methode, mit welcher der Notendurchschnitt der im Attribut noten gespeicherten Liste berechnet werden kann.

Eine beispielhafte Verwendung der Klasse in Form des Objekts lea lässt sich wie folgt umsetzen:

#Python
lea = Schuelerin("Lea", 12, [13, 3, 11, 9, 8])
print(lea.durchschnitt())

Aufgabe 3: Records

Im funktionalen Programmierparadigma finden sich keine Klassen und Objekte. Um Daten zu strukturieren und zusammenzusetzen können hier Records genutzt werden:

;Racket
(define-record schuelerin
  make-schuelerin
  (schuelerin-name string)
  (schuelerin-jgs natural)
  (schuelerin-note (list-of natural)))


(define lea (make-schuelerin "Lea" 12 (list 13 3 11 9 8)))

Records bieten im Gegensatz zu Klassen keine Möglichkeit, Methoden zu integrieren. Um die Daten der Records zu verarbeiten, müssen entsprechend Funktionen genutzt werden.

(a) Schreibe eine Racket-Funktion durchschnitt-schuelerin, die den Durchschnitt eines übergebenen schuelerin-Records zurückgibt.

Multiparadigmatische Programmiersprachen

Wie du gesehen hast, kann man viele funktionale Konzepte auch in Python umsetzen. Tatsächlich ist es möglich, mit Python komplett funktional zu programmieren. Indem man unter anderem gänzlich auf die Nutzung von veränderbaren Variablen verzichtet. Wie das im Detail funktioniert, kannst du dir in diesem inf-schule-Kapitel anschauen. Man nennt Python daher auch eine multiparadigmatische Sprache, da mit dieser verschiedene Programmierparadigmen genutzt werden können.

Die von uns in diesem Kapitel verwendete Racket-Version erlaubt zwar nur funktionale Konzepte, es gibt jedoch auch Racket-Versionen, die ebenfalls multiparadigmatisch sind. So kann man in diesen beispielsweise mit dem Operator set! Definitionen verändern oder auch Klassen und Objekte erstellen.