MINT lernen

Programmierparadigmen

Zehn interaktive Übungen zu imperativem, objektorientiertem, deklarativem und funktionalem Programmieren — von AFB I bis AFB III.

Dein Fortschritt:
0 / 0 Aufgaben
1

Übungsaufgaben

Zehn interaktive Übungen zum Klicken, Ziehen und Knobeln — von AFB I bis AFB III. Jede Übung gibt dir sofort Rückmeldung, und nach dem Prüfen erklärt eine kurze Notiz die Lösung.

A1
Paradigma und Kernidee
AFB I

Verbinde jedes Paradigma mit seiner Kernidee.

Klicke links einen Eintrag an und dann rechts den passenden — es entsteht eine Verbindungslinie. Mit der Tastatur: Enter zum Auswählen, ↑/↓ zum Wandern.
Imperativ und deklarativ sind Gegenpole: wie gegen was. Prozedural ist imperativ mit Gliederung in Funktionen, objektorientiert bündelt zusätzlich Daten und Methoden, funktional verzichtet auf veränderliche Zustände.
A2
Stimmt's? — Fünferserie
AFB I

Fünf Behauptungen über Programmierparadigmen.

5 Aussagen nacheinander. Eine falsche Einschätzung reicht — dann startest du die Serie mit „Neue Runde“ neu.
Aussage 1 von 5

Paradigmen sind Denkstile: Befehle und Zustand (imperativ), Prozeduren, Objekte, Beschreibung des Ergebnisses (deklarativ) oder Funktionen ohne Seiteneffekte.
A3
Welcher Stil steckt dahinter?
AFB I

Ordne jeden Schnipsel dem Paradigma zu, für das er typisch ist.

Ziehe jede Karte in den passenden Korb — oder wähle sie mit Enter aus und drücke dann die Ziffer des Korbs (0 legt sie zurück).
1imperativ
2objektorientiert
3deklarativ
4funktional
Zuweisungen, die eine Variable verändern, und Schleifen sind typisch imperativ. Objekt erzeugen und Methode aufrufen: objektorientiert. SQL und HTML beschreiben ein Ergebnis: deklarativ. map und filter erzeugen neue Listen, ohne die alte zu verändern: funktional.
A4
Die Reihenfolge macht den Zustand
AFB II

Imperativ heißt: Jede Anweisung ändert den Zustand. Bringe die Zeilen so in eine Reihenfolge, dass das Programm 40 ausgibt.

Ziehe die Karten in die richtige Reihenfolge — mit der Tastatur: ↑/↓ verschiebt, Shift+↑/↓ wechselt nur den Fokus.
1print(x)
2x = x * 3
3x = 10
4x = x - 5
5x = x + 5
10 + 5 = 15, 15 · 3 = 45, 45 − 5 = 40. Nur diese Reihenfolge führt zu 40 — beginnt man z. B. mit x - 5, entsteht 20. Im imperativen Stil bestimmt die Reihenfolge der Zustandsänderungen das Ergebnis.
A5
Zwei Objekte, ein Bauplan
AFB II

Was gibt das objektorientierte Programm aus?

Python
class Zaehler:
    def __init__(self):
        self.wert = 0
    def klick(self):
        self.wert = self.wert + 1

a = Zaehler()
b = Zaehler()
a.klick()
a.klick()
b.klick()
a.klick()
print(a.wert * 10 + b.wert)
Rechne selbst und trage das Ergebnis ein — Enter prüft direkt.
Jedes Objekt hat seine eigenen Attributwerte: a wurde dreimal geklickt (a.wert = 3), b einmal (b.wert = 1). 3 · 10 + 1 = 31. Typischer Fehler: annehmen, beide Objekte teilen sich einen Zähler (dann käme 44 heraus).
A6
Wie oder was?
AFB II

Setze die Fachbegriffe ein — ein Wort bleibt übrig.

Wort anklicken, dann Lücke anklicken (oder umgekehrt) — mit Tab und Enter geht es genauso. Ein Klick auf eine gefüllte Lücke legt das Wort zurück.

Beim Programmieren schreibst du Schritt für Schritt vor, wie der Rechner zum Ergebnis kommt. Beim Programmieren beschreibst du nur, was herauskommen soll. Ein bekanntes Beispiel dafür ist die Abfragesprache . Beim Programmieren setzt du ein Programm aus Funktionen zusammen, die keine haben — sie verändern nichts außerhalb von sich selbst.

„Bytecode“ bleibt übrig: Das ist ein Zwischencode beim Übersetzen (3.1.2) und hat mit dem Denkstil eines Programms nichts zu tun.
A7
Mix: Paradigma, Typen, Übersetzung
AFB II

Verbinde dein Wissen aus 3.1.2 und 3.1.3 mit den Paradigmen. Welche Aussagen stimmen?

Mehrere Antworten sind richtig. Markiere alle zutreffenden und klicke dann auf „Prüfen“.
Paradigma, Typisierung und Übersetzungsart sind drei unabhängige Eigenschaften. C wird kompiliert, ist aber prozedural (Klassen kamen erst mit C++). Python wird interpretiert und ist trotzdem objektorientiert nutzbar. JavaScript ist wie Python und C# eine Multiparadigmen-Sprache.
A8
Eine Funktion mit Seiteneffekt
AFB III

Die Funktion naechste verändert mit global die Variable zaehler außerhalb von sich selbst. Verfolge die Aufrufe.

Python
zaehler = 0

def naechste(x):
    global zaehler
    zaehler = zaehler + 1
    return x + zaehler

a = naechste(10)
b = naechste(10)
c = naechste(10) + naechste(10)
Rechne die Kette Schritt für Schritt: Erst wenn ein Schritt stimmt, wird der nächste freigeschaltet. Enter prüft.
  1. Wert von a
  2. Wert von b
  3. Wert von c
  4. Wert von zaehler am Ende
Gleiche Eingabe, verschiedene Ergebnisse: 11, 12, dann 13 + 14 = 27. Grund ist der Seiteneffekt — jeder Aufruf erhöht zaehler. Genau das vermeidet der funktionale Stil: Eine reine Funktion würde für naechste(10) immer denselben Wert liefern.
A9
Fehler im Lernzettel
AFB III

Selin hat einen Lernzettel zu den Paradigmen geschrieben. Drei Zeilen sind falsch.

In diesem Text stecken Fehler. Klicke genau die falschen Zeilen an — die richtigen musst du stehen lassen.
Die häufigste Verwechslung ist Klasse und Objekt: Die Klasse beschreibt, welche Attribute und Methoden es gibt; erst das Objekt hat konkrete Werte.
A10
Wie lang ist die Liste?
AFB III

Welche Zahl gibt das Programm aus?

Python
zahlen = [4, 8, 15, 16, 23, 42]

def ist_gross(z):
    return z > 10

gross = list(filter(ist_gross, zahlen))
print(len(zahlen))
Schiebe den Regler auf deine Antwort — Pfeiltasten bewegen ihn feiner. Nach dem Prüfen siehst du den Trefferbereich.
0 10
Trick: 6 — nicht 4. Gefragt ist die Länge von zahlen, nicht von gross. filter arbeitet funktional: Es erzeugt eine neue Liste [15, 16, 23, 42] und lässt die ursprüngliche Liste unverändert.