📚

Listen

Informatik · Python · Klassen 10–13 · PRIMM-Methode

Python Interaktiv Kl. 10–13

🎯 Worum geht's? Klasse 10–13 · 3 Unterrichtsstunden

Nach dieser Seite kannst du …

Schleifen über Listen Schritt für Schritt verfolgen
mit Indizes, len() und append() arbeiten
Standardalgorithmen erkennen: Summe, Maximum, Zählen, Umkehren, Suchen, Sortieren
eigene Funktionen mit Listen schreiben

Vorwissen: Variablen, for- und while-Schleifen, Funktionen

📝 Aufgaben

Jede Aufgabe hat fünf Schritte: Predict › Run › Investigate › Modify › Make. Wähle eine Aufgabe aus – oder nutze oben die Leiste „Aufgaben: 1, 2, 3 …“.

0

⚡ Gesammelte XP

0

✅ Aufgaben abgeschlossen

0

🔥 Streak (Tage)

–

🎯 Genauigkeit

📐 Das Wichtigste in Kürze

a = [4, 7, 2] – eine Liste; a[0] ist das erste Element, len(a) die Länge.
for i in range(len(a)): läuft über alle Indizes, for wert in a: über alle Werte.
[0] * 5 ergibt [0, 0, 0, 0, 0]; a.append(x) hängt x hinten an.
Eine Funktion, die a[i] = … setzt, verändert die übergebene Liste selbst.

In den Make-Aufgaben sollst du die Algorithmen selbst programmieren – fertige Helfer wie sum, max, sort oder count sind dort nicht erlaubt.

🏅 Zuletzt verdiente Badges

🔮 Predict

Aufgabe 1 – Werte aufsummieren

Analysiere die Funktion, ohne sie auszuführen.

def berechne(a):
    x = 0
    for i in range(len(a)):
        x = x + a[i]
    return x

print(berechne([4, 7, 2, 9]))

Was wird ausgegeben?

x wird in jedem Durchlauf um a[i] größer.

▶️ Run – Durchläufe verfolgen

Trage nach jedem Durchlauf den Wert von x ein. Eingabe: [4, 7, 2, 9]

Schritt	`i`	`a[i]`
Start	–	–
1	0	4
2	1	7
3	2	2
4	3	9

Neuer Wert = alter Wert von x plus a[i].

🔍 Investigate

Was liefert berechne([])?

Wie oft läuft die Schleife bei einer Liste der Länge n?

✏️ Modify

Ändere die Funktion so, dass sie das Produkt aller Elemente berechnet. Für [4, 7, 2, 9] soll 504 herauskommen.

Mit welchem Startwert darf ein Produkt beginnen, damit die erste Multiplikation nichts verfälscht?

🛠️ Make

Schreibe verarbeite(a): Sie gibt den größten Wert der Liste zurück – ohne max().

Merke dir den bisher größten Wert – starte mit dem ersten Element – und vergleiche jedes weitere damit.

🔮 Predict

Aufgabe 2 – Umkehren

Welche Liste gibt die Funktion zurück?

def transformiere(a):
    b = [0] * len(a)
    for i in range(len(a)):
        b[len(a) - 1 - i] = a[i]
    return b

print(transformiere([1, 2, 3, 4, 5]))

Was wird ausgegeben?

Berechne den Zielindex len(a) - 1 - i für i = 0 und i = 1.

▶️ Run – Ergebnisliste

Trage ein, was am Ende in b steht.

	`b[0]`	`b[1]`	`b[2]`	`b[3]`	`b[4]`
Wert

Welcher Index von b wird bei i = 2 beschrieben?

Bei i = 0 wird b[4] beschrieben, bei i = 1 b[3] …

🔍 Investigate

Verändert transformiere die übergebene Liste a?

Was ist len(a) - 1 - i für len(a) = 5 und i = 4?

✏️ Modify

Passe die Funktion so an, dass sie nur die Elemente an geraden Indizes (0, 2, 4, …) zurückgibt: [10, 20, 30, 40, 50] → [10, 30, 50].

Hänge nur an, wenn der Index gerade ist – wie prüfst du das mit %?

🛠️ Make

Schreibe kombiniere(a, b): eine neue Liste mit erst allen Elementen von a, dann von b – mit Schleifen und append (ohne a + b).

Lege eine leere Liste an, hänge in einer Schleife alle Werte von a an, dann in einer zweiten alle von b.

🔮 Predict

Aufgabe 3 – Häufigkeiten zählen

Jeder Wert dient als Index in einer Zählliste.

def auswerten(werte):
    z = [0] * 6          # Index 0 bleibt ungenutzt
    for w in werte:
        z[w] = z[w] + 1
    return z

ergebnis = auswerten([3, 1, 2, 3, 1, 3, 2])
print(ergebnis[3])

Was wird ausgegeben?

Zähle, wie oft die 3 in der Eingabe vorkommt.

▶️ Run – Zählliste

Trage ein, was am Ende in z steht.

	[0]	[1]	[2]	[3]	[4]	[5]
`z`

Jeder Wert aus der Eingabe erhöht genau ein Feld um 1. Felder, die nie getroffen werden, bleiben 0.

🔍 Investigate

Was passiert bei auswerten([6])?

Warum hat z sechs Felder statt fünf?

✏️ Modify

Ergänze finde_haeufigsten(werte): Sie gibt den häufigsten Wert zurück. Für [3, 1, 2, 3, 1, 3, 2] → 3.

Merke dir den größten bisher gesehenen Zähler – und den Index i, zu dem er gehört.

🛠️ Make

Schreibe zaehle_vorkommen(a, x): Wie oft kommt x in a vor? (ohne count)

Ein Zähler, eine Schleife, ein Vergleich mit x.

🔮 Predict

Aufgabe 4 – Ein Durchlauf Bubblesort

Nachbarn werden verglichen und bei Bedarf getauscht.

def durchlauf(a):
    for i in range(len(a) - 1):
        if a[i] > a[i + 1]:
            a[i], a[i + 1] = a[i + 1], a[i]

zahlen = [5, 3, 8, 1, 4]
durchlauf(zahlen)
print(zahlen)

Was wird ausgegeben?

Vergleiche immer nur zwei Nachbarn und arbeite mit der schon veränderten Liste weiter.

▶️ Run – Nach jedem Schritt

Trage die Liste nach jedem Schleifendurchlauf ein.

`i`	Vergleich	[0]	[1]	[2]	[3]	[4]
Start	–	5	3	8	1	4
0	5 > 3?
1	5 > 8?
2	8 > 1?
3	8 > 4?

Getauscht wird nur, wenn der linke Nachbar größer ist. a[i], a[i + 1] = a[i + 1], a[i] tauscht zwei Werte.

🔍 Investigate

Warum läuft die Schleife nur bis len(a) - 1?

Was ist nach einem Durchlauf sicher?

✏️ Modify

Ändere die Bedingung so, dass der Durchlauf das kleinste Element nach hinten bringt (absteigende Sortierung).

Die Bedingung entscheidet, wann getauscht wird. Was muss gelten, damit kleine Werte nach hinten wandern?

🛠️ Make

Schreibe sortiere(a): vollständiger Bubblesort, der die Liste aufsteigend sortiert (ohne sort).

Wiederhole den Durchlauf aus Predict mehrmals – wie oft ist nötig, damit alles an seinem Platz ist?

🔮 Predict

Aufgabe 5 – Sieb des Eratosthenes

Die Funktion markiert alle Zahlen bis n.

def markiere(n):
    m = [False, False] + [True] * (n - 1)
    p = 2
    while p * p <= n:
        if m[p]:
            for k in range(p * p, n + 1, p):
                m[k] = False
        p = p + 1
    return m

m = markiere(20)
print(m[9])

Was wird ausgegeben – ist 9 als Primzahl markiert?

Am Ende ist m[k] genau dann True, wenn k eine Primzahl ist.

▶️ Run – Markierungen für n = 10

Trage für markiere(10) True oder False ein.

k	0	1	2	3	4	5	6	7	8	9	10
`m[k]`

0 und 1 sind keine Primzahlen. Gestrichen werden die Vielfachen von 2 (ab 4) und von 3 (ab 9).

🔍 Investigate

def markiere(n):
    m = [False, False] + [True] * (n - 1)
    p = 2
    while p * p <= n:
        if m[p]:
            for k in range(p * p, n + 1, p):
                m[k] = False
        p = p + 1
    return m

Was bedeutet range(p * p, n + 1, p)?

Warum darf die äußere Schleife bei p * p > n aufhören?

✏️ Modify

Ergänze sammle_primzahlen(n): eine Liste aller Primzahlen bis n. Für 20 → [2, 3, 5, 7, 11, 13, 17, 19].

Gehe über alle Indizes k von m und hänge k an, wenn m[k] wahr ist.

🛠️ Make

Schreibe pruefe_zahl(n): True, wenn n eine Primzahl ist – durch Probedivision (ohne Sieb).

Zahlen bis 1 sind keine Primzahlen. Prüfe dann alle Teiler ab 2, solange teiler * teiler <= n gilt.

🔮 Predict

Aufgabe 6 – Umkehren mit zwei Zeigern

Zwei Zeiger laufen von außen nach innen.

def bearbeite(a):
    l = 0
    r = len(a) - 1
    while l < r:
        a[l], a[r] = a[r], a[l]
        l = l + 1
        r = r - 1

zahlen = [1, 2, 3, 4, 5, 6]
bearbeite(zahlen)
print(zahlen)

Was wird ausgegeben?

Nach jedem Tausch rücken beide Zeiger einen Schritt nach innen.

▶️ Run – Zwei Zeiger

Trage nach jedem Tausch l, r (nach dem Weiterrücken) und die Liste ein.

Tausch	`l`	`r`	[0]	[1]	[2]	[3]	[4]	[5]
Start	0	5	1	2	3	4	5	6
1.
2.
3.

Getauscht werden immer a[l] und a[r]; danach l + 1 und r - 1.

🔍 Investigate

Warum while l < r und nicht l <= r?

Wie viele Tauschvorgänge gibt es bei einer Liste der Länge n?

✏️ Modify

Ergänze eine Bedingung: Getauscht wird nur, wenn a[l] < 4 ist. Die Zeiger rücken trotzdem weiter.

Die Bedingung umschließt nur den Tausch – das Weiterrücken der Zeiger muss immer passieren.

🛠️ Make

Schreibe pruefe_symmetrie(a) mit zwei Zeigern: [1, 2, 3, 2, 1] → True, [1, 2, 3] → False.

Vergleiche von außen nach innen. Schon ein Unterschied genügt für False.

🔮 Predict

Aufgabe 7 – Gleitendes Fenster

Die Funktion addiert immer k benachbarte Werte.

def gleite(a, k):
    erg = []
    for i in range(len(a) - k + 1):
        s = 0
        for j in range(i, i + k):
            s = s + a[j]
        erg.append(s)
    return erg

print(gleite([1, 3, 5, 2, 4], 3))

Was wird ausgegeben?

Das erste Fenster umfasst die Werte an den Indizes 0, 1 und 2.

▶️ Run – Fenster

Trage die Summe jedes Fensters ein.

`i`	Fenster	`erg[i]`
0	1 + 3 + 5
1	3 + 5 + 2
2	5 + 2 + 4

Addiere jeweils die drei Werte des Fensters.

🔍 Investigate

Wie viele Fenster gibt es bei Länge 5 und k = 3?

Wie nennt man diese Technik?

✏️ Modify

Passe gleite an: statt der Summe das Maximum jedes Fensters.

Starte s mit dem ersten Wert des Fensters und ersetze die Addition durch einen Vergleich.

🛠️ Make

Schreibe finde_position(a): den Index des größten Elements (bei Gleichstand der kleinere). [3, 7, 7, 2] → 1.

Merke dir den Index des bisher größten Elements. Mit > (statt >=) bleibt bei Gleichstand der kleinere Index.

🔮 Predict

Aufgabe 8 – Paar mit Zielsumme

Die Liste ist sortiert. Gesucht sind zwei Werte mit der Summe ziel.

def suche(a, ziel):
    l = 0
    r = len(a) - 1
    while l < r:
        s = a[l] + a[r]
        if s == ziel:
            return True
        elif s < ziel:
            l = l + 1
        else:
            r = r - 1
    return False

print(suche([1, 4, 6, 8, 11], 10))

Was wird ausgegeben?

Ist die Summe zu groß, wird r kleiner; ist sie zu klein, wird l größer.

▶️ Run – Schritt für Schritt

Trage jeden Schleifendurchlauf ein. Aktion: l+1, r-1 oder True.

Schritt	`l`	`r`	`s`	Aktion
1
2
3
4

Schritt 1: 1 + 11 = 12 ist größer als 10.

🔍 Investigate

Warum funktioniert das nur bei sortierten Listen?

Wie viele Schleifendurchläufe gibt es höchstens bei Länge n?

✏️ Modify

Ändere suche: Statt True/False soll sie den Index des linken Partners zurückgeben, sonst -1.

Was soll statt True und statt False zurückkommen?

🛠️ Make

Schreibe binaer_suche(a, ziel) für eine sortierte Liste: Index von ziel oder -1 – durch Halbieren (ohne index oder in).

Halte die Grenzen l und r fest und schau in die Mitte. Ist der Wert dort zu klein, suchst du rechts weiter, sonst links.

🔮 Predict

Aufgabe 9 – Sortieren durch Einfügen

Insertion Sort fügt jedes Element an die richtige Stelle im vorderen, sortierten Teil ein.

def insertion_sort(a):
    for i in range(1, len(a)):
        key = a[i]
        j = i - 1
        while j >= 0 and a[j] > key:
            a[j + 1] = a[j]
            j = j - 1
        a[j + 1] = key

zahlen = [5, 2, 8, 1, 3]
insertion_sort(zahlen)
print(zahlen)

Was wird ausgegeben?

Es ist ein Sortierverfahren – in welche Richtung sortiert es?

▶️ Run – Nach jedem Durchlauf

Trage die Liste nach jedem Durchlauf der äußeren Schleife ein.

`i`	[0]	[1]	[2]	[3]	[4]
Start	5	2	8	1	3
1
2
3
4

In Durchlauf i wird a[i] als key gemerkt; größere Elemente links davon rücken nach rechts, dann kommt key in die Lücke.

🔍 Investigate

Wie viele Vergleiche braucht Insertion Sort für eine schon sortierte Liste der Länge n?

Was unterscheidet Insertion Sort von Bubblesort?

✏️ Modify

Ändere Insertion Sort so, dass er absteigend sortiert (größtes Element zuerst).

Die Bedingung der while-Schleife entscheidet, welche Elemente nach rechts rücken.

🛠️ Make

Schreibe selection_sort(a): Suche in jedem Durchlauf das Minimum des unsortierten Rests und tausche es nach vorne (ohne sort oder min).

Äußere Schleife: Position i, die gefüllt wird. Innere Schleife: Index des kleinsten Elements im Rest suchen. Dann tauschen.

🔮 Predict

Aufgabe 10 – Zusammenführen (Merge)

Zwei sortierte Listen werden zu einer sortierten Liste zusammengeführt.

def merge(a, b):
    c = []
    i = 0
    j = 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            c.append(a[i])
            i = i + 1
        else:
            c.append(b[j])
            j = j + 1
    while i < len(a):
        c.append(a[i])
        i = i + 1
    while j < len(b):
        c.append(b[j])
        j = j + 1
    return c

print(merge([1, 3, 5], [2, 4, 6]))

Was wird ausgegeben?

Es wird immer das kleinere der beiden vorderen Elemente übernommen.

▶️ Run – Merge verfolgen

Trage für jeden Schritt i, j (vor dem Vergleich) und den übernommenen Wert ein.

Schritt	`i`	`j`	übernommen
1
2
3
4
5
6 (Rest)	3

Vergleiche immer a[i] mit b[j]; nur der Zeiger der übernommenen Liste rückt weiter.

🔍 Investigate

Welche Voraussetzung müssen a und b erfüllen?

Wie viele Schritte braucht merge für Listen der Länge m und n?

✏️ Modify

Ändere merge so, dass ein Wert, der in beiden Listen vorkommt, nur einmal übernommen wird.

Behandle den Fall a[i] == b[j] getrennt: Wert einmal übernehmen und beide Zeiger weiterrücken.

🛠️ Make

Schreibe merge_sort(a): Teile die Liste in zwei Hälften, sortiere beide rekursiv und führe sie mit merge zusammen. [5, 2, 8, 1, 3] → [1, 2, 3, 5, 8].

Basisfall: Länge 0 oder 1. Sonst in der Mitte teilen (a[:mitte], a[mitte:]), beide Hälften rekursiv sortieren und mit merge zusammenführen.

🏅 Deine Badges

Verdiente Badges leuchten auf.

📊 Statistik

↺ Zurücksetzen

Alle gespeicherten Daten werden gelöscht.

📄 Arbeitsblatt erstellen

Wähle aus, welche Bereiche auf das Arbeitsblatt kommen. Es enthält dann alle … Aufgaben dieser Seite aus diesen Bereichen – mit Kästchen zum Ankreuzen, leeren Tabellen und Platz zum Schreiben, ohne Lösungen und Tipps.

Bereiche für das Arbeitsblatt 🔮 Predict – vorhersagen, was der Code macht ▶️ Run – Werte Zeile für Zeile in die Tabelle eintragen 🔍 Investigate – untersuchen, warum der Code so arbeitet ✏️ Modify – Code gezielt verändern 🛠️ Make – eigene Methode schreiben

Aufgabe gelöst!

Listen

📝 Aufgaben

📐 Das Wichtigste in Kürze

🏅 Zuletzt verdiente Badges

🏅 Deine Badges

📊 Statistik

↺ Zurücksetzen

📄 Arbeitsblatt erstellen