Python – 09 Algorithmen und Abschlussübung

1. Algorithmen verstehen

Anforderungen an einen Algorithmus

Damit ein Lösungsverfahren überhaupt als Algorithmus gilt, muss es vier Anforderungen erfüllen (vgl. inf-schule – Anforderungen an ein Lösungsverfahren und inf-schule – Fachkonzept Algorithmus):

Algorithmen im Alltag

Algorithmen begegnen dir nicht nur am Computer. Auch im Alltag folgst du oft Schritt-für-Schritt-Anleitungen:

• Kochrezept — z. B. für Kartoffelpüree: Zutaten, Reihenfolge der Schritte, Kochzeiten.
• Bauanleitung — z. B. für einen Papierflieger: Falten in einer bestimmten Reihenfolge.
• Wegbeschreibung — “An der Ampel rechts, dann zweite Straße links.”

Beispiel: Algorithmus “Größte Zahl finden”

Problem: Finde die größte Zahl in einer Liste.

Algorithmus (Pseudocode):

1. Setze maximum = erstes Element der Liste
2. Für jedes Element in der Liste:
   a. Wenn Element > maximum:
      - Setze maximum = Element
3. Gib maximum zurück

Python-Implementierung:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def finde_maximum(zahlen: list[int]) -> int:
    """Findet die größte Zahl in einer Liste."""
    maximum = zahlen[0]

    for zahl in zahlen:
        if zahl > maximum:
            maximum = zahl

    return maximum

# Test
meine_zahlen = [23, 5, 89, 12, 67, 3]
print(finde_maximum(meine_zahlen))  # Ausgabe: 89

2. Bausteine von Algorithmen

Jeder Algorithmus — egal wie kompliziert — setzt sich aus zwei Sorten von Anweisungen zusammen (vgl. inf-schule – Bausteine von Algorithmen):

Elementaranweisungen

Das sind die “Grundaktionen” des Bearbeiters. In Python sind das z. B.:

• Eine Variable zuweisen: maximum = zahlen[0]
• Etwas ausgeben: print(...)
• Eine Methode aufrufen: liste.append(zahl)

Kontrollanweisungen

Sie steuern, in welcher Reihenfolge die Elementaranweisungen ausgeführt werden. Es gibt drei Grundtypen:

3. Darstellung von Algorithmen

Ein und derselbe Algorithmus lässt sich auf verschiedene Arten darstellen (vgl. inf-schule – Darstellung von Algorithmen). Wir nutzen das Beispiel “Größte Zahl finden” und zeigen es in vier Formen:

a) Umgangssprache

Lege die erste Zahl als Maximum fest. Gehe dann jede weitere Zahl durch und ersetze das Maximum, falls die Zahl größer ist. Am Ende ist das Maximum die größte Zahl.

Vorteil: Leicht zu lesen. Nachteil: Ungenau, kann mehrdeutig sein.

b) Pseudocode

Vorgabe: Eine Liste von Zahlen
SETZE maximum = erstes Element
FÜR jede Zahl in der Liste:
    WENN Zahl > maximum DANN
        SETZE maximum = Zahl
GIB maximum zurück

Vorteil: Strukturiert wie Code, aber sprachunabhängig. Nachteil: Nicht direkt ausführbar.

c) Struktogramm (Nassi-Shneiderman-Diagramm)

Ein Struktogramm zeigt die Verschachtelung von Kontrollstrukturen als gestapelte Blöcke. Mermaid bietet keine native Nassi-Shneiderman-Notation, mit dem experimentellen block-beta-Diagramm lässt sich die Struktur aber annähern:

Um diese Diagramme besser zu verstehen, lies in dieser PDF nach: Struktogramme.pdf (Quelle: )

Vorteil: Verschachtelung sichtbar, kompakt. Tipp: Für korrekte Struktogramme im Unterricht eignet sich das Tool strukto.io.

d) Flussdiagramm

    flowchart TD
    Start([Start]) --> Init["maximum = zahlen[0]"]
    Init --> Check{noch eine Zahl<br/>in der Liste?}
    Check -- Ja --> Compare{zahl &gt; maximum?}
    Check -- Nein --> Out["gib maximum zurück"]
    Compare -- Ja --> Update["maximum = zahl"]
    Compare -- Nein --> Check
    Update --> Check
    Out --> Ende([Ende])
  

Vorteil: Gut für Wiederholungen und Verzweigungen, intuitiv lesbar.

4. Konzeptuelle Aufgaben (vor dem Programmieren)

Diese Aufgaben übst du mit Stift und Papier oder im Klassengespräch. Sie schärfen das Verständnis, bevor wir Code schreiben.

SOLANGE weder Weiß noch Schwarz schachmatt:
    führe abwechselnd (beginnend mit Weiß) einen Zug aus

versuche = 0
WIEDERHOLE:
    würfle eine Zahl von 1 bis 6
    versuche = versuche + 1
BIS gewürfelte Zahl == 6
gib versuche aus

n = 2
WIEDERHOLE für immer:
    WENN n eine Primzahl ist:
        gib n aus
    n = n + 1

Lösungshinweise zeigen

• a) Schach: Die Schritte sind nicht eindeutig (welcher Zug?) und das Verfahren könnte unendlich laufen (Patt-Wiederholungen). → kein klassischer Algorithmus, eher ein Spielrahmen.
• b) Würfeln: Ausführbar und eindeutig. Endlichkeit ist nicht garantiert (theoretisch könnte die 6 nie fallen), aber mit Wahrscheinlichkeit 1 endet es. → meist als Algorithmus akzeptiert (“fast sicher endlich”).
• c) Primzahlen: Verletzt Endlichkeit (WIEDERHOLE für immer). Nur als Ausgabe-Schleife brauchbar, nicht als Algorithmus mit Ergebnis.

5. Programmier-Aufgaben

1

print(berechne_summe([1, 2, 3, 4, 5]))  # Soll 15 ausgeben

Lösung zeigen

1 2 3 4 5 6 7 8 9 10 11 12

def berechne_summe(zahlen: list[int]) -> int: """Berechnet die Summe aller Zahlen in einer Liste.""" summe = 0 for zahl in zahlen: summe += zahl return summe # Test print(berechne_summe([1, 2, 3, 4, 5])) # Ausgabe: 15 print(berechne_summe([10, 20, 30])) # Ausgabe: 60

1

print(berechne_durchschnitt([10, 20, 30]))  # Soll 20.0 ausgeben

Lösung zeigen

1 2 3 4 5 6 7 8 9 10 11

def berechne_durchschnitt(zahlen: list[int | float]) -> float: """Berechnet den Durchschnitt aller Zahlen in einer Liste.""" summe = berechne_summe(zahlen) anzahl = len(zahlen) durchschnitt = summe / anzahl return durchschnitt # Test print(berechne_durchschnitt([10, 20, 30])) # Ausgabe: 20.0 print(berechne_durchschnitt([5, 10, 15, 20])) # Ausgabe: 12.5

1

print(filtere_gerade([1, 2, 3, 4, 5, 6]))  # Soll [2, 4, 6] ausgeben

Lösung zeigen

1 2 3 4 5 6 7 8 9 10 11 12 13

def filtere_gerade(zahlen: list[int]) -> list[int]: """Filtert alle geraden Zahlen aus einer Liste.""" gerade_zahlen = [] for zahl in zahlen: if zahl % 2 == 0: gerade_zahlen.append(zahl) return gerade_zahlen # Test print(filtere_gerade([1, 2, 3, 4, 5, 6])) # Ausgabe: [2, 4, 6] print(filtere_gerade([10, 15, 20, 25, 30])) # Ausgabe: [10, 20, 30]

1
2
3

print(validiere_passwort("Hallo123"))   # True
print(validiere_passwort("hallo"))      # False (zu kurz, keine Zahl, kein Großbuchstabe)
print(validiere_passwort("Hallo"))      # False (keine Zahl)

Lösung zeigen

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

def validiere_passwort(passwort: str) -> bool: """Prüft, ob ein Passwort den Sicherheitsanforderungen entspricht.""" # Prüfung 1: Länge if len(passwort) < 8: return False # Prüfung 2: Enthält Zahl hat_zahl = False for zeichen in passwort: if zeichen.isdigit(): hat_zahl = True break if not hat_zahl: return False # Prüfung 3: Enthält Großbuchstaben hat_grossbuchstabe = False for zeichen in passwort: if zeichen.isupper(): hat_grossbuchstabe = True break if not hat_grossbuchstabe: return False # Alle Prüfungen bestanden return True # Tests print(validiere_passwort("Hallo123")) # Ausgabe: True print(validiere_passwort("hallo")) # Ausgabe: False print(validiere_passwort("Hallo")) # Ausgabe: False print(validiere_passwort("PASSWORD1")) # Ausgabe: True

Alternative elegantere Lösung:

1 2 3 4 5 6 7 8 9 10

def validiere_passwort(passwort: str) -> bool: """Prüft, ob ein Passwort den Sicherheitsanforderungen entspricht.""" # Alle Bedingungen prüfen lang_genug = len(passwort) >= 8 hat_zahl = any(zeichen.isdigit() for zeichen in passwort) hat_grossbuchstabe = any(zeichen.isupper() for zeichen in passwort) # Alle Bedingungen müssen wahr sein return lang_genug and hat_zahl and hat_grossbuchstabe

WENN n < 2: gib False zurück
FÜR i von 2 bis n-1:
    WENN n durch i teilbar:
        gib False zurück
gib True zurück

1
2
3
4

print(ist_primzahl(7))   # True
print(ist_primzahl(10))  # False
print(ist_primzahl(1))   # False
print(ist_primzahl(2))   # True

Lösung zeigen

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

def ist_primzahl(n: int) -> bool: """Prüft, ob n eine Primzahl ist.""" if n < 2: return False for i in range(2, n): if n % i == 0: return False return True # Tests print(ist_primzahl(7)) # True print(ist_primzahl(10)) # False print(ist_primzahl(1)) # False print(ist_primzahl(2)) # True def primzahlen_bis(grenze: int) -> list[int]: """Gibt alle Primzahlen bis zur Grenze (inklusive) zurück.""" primzahlen = [] for n in range(2, grenze + 1): if ist_primzahl(n): primzahlen.append(n) return primzahlen print(primzahlen_bis(20)) # [2, 3, 5, 7, 11, 13, 17, 19]

Effizienz-Tipp: Es genügt, bis √n zu testen — alles darüber liefert keine neuen Teiler. So wird der Algorithmus für große Zahlen viel schneller:

1 2 3 4 5 6 7

def ist_primzahl_schnell(n: int) -> bool: if n < 2: return False for i in range(2, int(n**0.5) + 1): if n % i == 0: return False return True

6. Abschlussaufgabe: Steckbrief-Programm

Jetzt kombinierst du alle Python-Grundlagen in einem größeren Projekt!

=== STECKBRIEF ===
Name: Anna Müller
Alter: 16
Lieblingsfach: Informatik
Mag Mathe: Ja
Mathe-Note: 2.3 - Das ist gut!
Hobbys: Programmieren, Basketball, Lesen
Motto: "Code is poetry"

Beispiel-Lösung zeigen

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

# 2025-12-12, Max Mustermann, Abschlussaufgabe Python 09 # Variablen mit Type Hints vorname: str = "Anna" nachname: str = "Müller" alter: int = 16 mag_mathe: bool = True lieblingsfach: str = "Informatik" hobbys: list[str] = ["Programmieren", "Basketball", "Lesen"] motto: str = "Code is poetry" note_mathe: float = 2.3 # Liste mit allen Daten steckbrief = [vorname, nachname, alter, mag_mathe, lieblingsfach, hobbys, motto, note_mathe] # Funktionen def berechne_geburtsjahr(alter: int) -> int: """Berechnet das ungefähre Geburtsjahr.""" aktuelles_jahr = 2026 # Passe das aktuelle Jahr ggf. an return aktuelles_jahr - alter def ist_gut_in_mathe(note: float) -> bool: """Prüft, ob die Mathe-Note gut ist (besser als 3.0).""" return note < 3.0 def zeige_steckbrief(daten: list) -> None: """Zeigt den Steckbrief formatiert an.""" print("=" * 30) print(" STECKBRIEF") print("=" * 30) print(f"Name: {daten[0]} {daten[1]}") print(f"Alter: {daten[2]} (geboren ca. {berechne_geburtsjahr(daten[2])})") print(f"Lieblingsfach: {daten[4]}") if daten[3]: print("Mag Mathe: Ja") else: print("Mag Mathe: Nein") mathe_note = daten[7] if ist_gut_in_mathe(mathe_note): print(f"Mathe-Note: {mathe_note} - Das ist gut!") else: print(f"Mathe-Note: {mathe_note} - Da geht noch was!") print(f"Hobbys: {', '.join(daten[5])}") print(f"Motto: \"{daten[6]}\"") print("=" * 30) # Programm ausführen zeige_steckbrief(steckbrief)

7. Flask-Abschlussaufgabe (Bonus)

Wenn du bereits Flask – 01 Erste Schritte, Flask – 02 Jinja Templating Grundlagen, Flask – 03 Jinja Schleifen und Listen und Flask – 04 Formulare und Datenverarbeitung durchgearbeitet hast, kannst du dein Steckbrief-Programm in eine vollwertige Web-Anwendung verwandeln!

Beispiel-Lösung zeigen

app.py:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

from flask import Flask, render_template, request app = Flask(__name__) # Liste zum Speichern der Steckbriefe (wird bei Neustart gelöscht) steckbriefe_liste = [] # Hilfsfunktionen (aus Python 09) def berechne_geburtsjahr(alter: int) -> int: """Berechnet das ungefähre Geburtsjahr.""" return 2025 - alter def validiere_alter(alter_str: str) -> bool: """Prüft, ob das Alter gültig ist.""" try: alter = int(alter_str) return 10 <= alter <= 100 except: return False @app.route("/") def home(): return render_template("home.html") @app.route("/steckbrief", methods=['GET', 'POST']) def steckbrief(): if request.method == 'POST': # Daten aus Formular holen vorname = request.form.get('vorname') nachname = request.form.get('nachname') alter_str = request.form.get('alter') lieblingsfach = request.form.get('lieblingsfach') mag_mathe = request.form.get('mag_mathe') == 'on' hobbys_str = request.form.get('hobbys') motto = request.form.get('motto') # Validierung fehler = [] if not vorname or not nachname: fehler.append("Vor- und Nachname müssen ausgefüllt sein") if not validiere_alter(alter_str): fehler.append("Alter muss zwischen 10 und 100 sein") if fehler: return render_template("steckbrief_formular.html", fehler=fehler) # Daten verarbeiten alter = int(alter_str) hobbys = [h.strip() for h in hobbys_str.split(',')] geburtsjahr = berechne_geburtsjahr(alter) # Steckbrief-Dictionary erstellen steckbrief_daten = { 'vorname': vorname, 'nachname': nachname, 'alter': alter, 'geburtsjahr': geburtsjahr, 'lieblingsfach': lieblingsfach, 'mag_mathe': mag_mathe, 'hobbys': hobbys, 'motto': motto } # In Liste speichern steckbriefe_liste.append(steckbrief_daten) return render_template("steckbrief_anzeige.html", steckbrief=steckbrief_daten) # GET-Request: Formular anzeigen return render_template("steckbrief_formular.html") @app.route("/alle-steckbriefe") def alle_steckbriefe(): return render_template("alle_steckbriefe.html", steckbriefe=steckbriefe_liste) if __name__ == "__main__": app.run(debug=True)

templates/base.html:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

<!DOCTYPE html> <html lang="de"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>{% block title %}Steckbrief-App{% endblock %}</title> <style> body { font-family: Arial, sans-serif; max-width: 800px; margin: 50px auto; padding: 20px; background-color: #f5f5f5; } .container { background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); } h1 { color: #333; } .fehler { background: #ffebee; color: #c62828; padding: 10px; border-radius: 5px; margin-bottom: 20px; } input, textarea, select { width: 100%; padding: 8px; margin: 5px 0 15px 0; border: 1px solid #ddd; border-radius: 4px; } button { background: #1976d2; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; } button:hover { background: #1565c0; } .steckbrief { border-left: 4px solid #1976d2; padding-left: 20px; margin: 20px 0; } </style> </head> <body> <div class="container"> {% block content %}{% endblock %} </div> </body> </html>

templates/steckbrief_formular.html:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

{% extends "base.html" %} {% block title %}Steckbrief erstellen{% endblock %} {% block content %} <h1>Steckbrief erstellen</h1> {% if fehler %} <div class="fehler"> <strong>Fehler:</strong> <ul> {% for fehler_text in fehler %} <li>{{ fehler_text }}</li> {% endfor %} </ul> </div> {% endif %} <form method="POST"> <label>Vorname:</label> <input type="text" name="vorname" required> <label>Nachname:</label> <input type="text" name="nachname" required> <label>Alter:</label> <input type="number" name="alter" min="10" max="100" required> <label>Lieblingsfach:</label> <input type="text" name="lieblingsfach" required> <label> <input type="checkbox" name="mag_mathe"> Mag Mathe </label> <label>Hobbys (komma-getrennt):</label> <textarea name="hobbys" rows="3" required></textarea> <label>Motto:</label> <input type="text" name="motto" required> <button type="submit">Steckbrief erstellen</button> </form> <p><a href="/alle-steckbriefe">Alle Steckbriefe anzeigen</a></p> {% endblock %}

templates/steckbrief_anzeige.html:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

{% extends "base.html" %} {% block title %}Steckbrief von {{ steckbrief.vorname }}{% endblock %} {% block content %} <h1>Steckbrief</h1> <div class="steckbrief"> <h2>{{ steckbrief.vorname }} {{ steckbrief.nachname }}</h2> <p><strong>Alter:</strong> {{ steckbrief.alter }} (geboren ca. {{ steckbrief.geburtsjahr }})</p> <p><strong>Lieblingsfach:</strong> {{ steckbrief.lieblingsfach }}</p> {% if steckbrief.mag_mathe %} <p><strong>Mag Mathe:</strong> Ja ✓</p> {% else %} <p><strong>Mag Mathe:</strong> Nein</p> {% endif %} <p><strong>Hobbys:</strong></p> <ul> {% for hobby in steckbrief.hobbys %} <li>{{ hobby }}</li> {% endfor %} </ul> <p><strong>Motto:</strong> "{{ steckbrief.motto }}"</p> </div> <p> <a href="/steckbrief">Neuen Steckbrief erstellen</a> | <a href="/alle-steckbriefe">Alle Steckbriefe anzeigen</a> </p> {% endblock %}

templates/alle_steckbriefe.html:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

{% extends "base.html" %} {% block title %}Alle Steckbriefe{% endblock %} {% block content %} <h1>Alle Steckbriefe</h1> {% if steckbriefe %} {% for sb in steckbriefe %} <div class="steckbrief"> <h3>{{ sb.vorname }} {{ sb.nachname }}</h3> <p>{{ sb.alter }} Jahre | {{ sb.lieblingsfach }}</p> </div> {% endfor %} {% else %} <p>Noch keine Steckbriefe vorhanden.</p> {% endif %} <p><a href="/steckbrief">Neuen Steckbrief erstellen</a></p> {% endblock %}

interessante Algorithmen

Dijkstra Algorithmus

Quellen im Überblick

Die theoretischen Inhalte und konzeptuellen Aufgaben (Abschnitte 1 – 4) wurden in Anlehnung an das frei verfügbare Schulbuch inf-schule.de entwickelt. Direkte Quellenangaben stehen jeweils am Anfang der betroffenen Abschnitte und Aufgaben. Alle Seiten zuletzt abgerufen am 2026-04-26.

• inf-schule – Algorithmusbegriff (Übersicht)
• inf-schule – Fachkonzept Algorithmus
• inf-schule – Ein Suchproblem
• inf-schule – Anforderungen an ein Lösungsverfahren
• inf-schule – Darstellung von Algorithmen
• inf-schule – Bausteine von Algorithmen
• inf-schule – Algorithmen im Alltag
• inf-schule – Übungen zum Algorithmusbegriff
• inf-schule – Themenbereich Algorithmen