Python von Anfang an

Erste Schritte & Installation

In diesem Abschnitt lernst du, was du brauchst, um mit Python zu starten. Du erfährst, wie du Python auf dem Computer installierst, wie du prüfst, ob die Installation erfolgreich war und welchen Befehl du im Terminal eingibst, um Python zu benutzen. Das gibt dir eine stabile Basis, damit du später eigene Skripte ausführen kannst.

Um Python zu installieren, lädst du die passende Version von der offiziellen Python-Seite herunter und folgst dabei dem Installationsassistenten. Wichtig ist, beim Setup die Option "Add Python to PATH" zu aktivieren, damit du Python später direkt im Terminal aufrufen kannst.

Was ist das Terminal?
Das Terminal (auf Windows auch „Eingabeaufforderung" oder „PowerShell" genannt) ist ein Fenster, in dem du deinen Computer per Texteingabe steuern kannst – ohne Maus, nur mit Befehlen. Auf Windows öffnest du es mit der Tastenkombination Windows-Taste + R, dann cmd eingeben und Enter drücken. Auf macOS findest du es unter Programme → Dienstprogramme → Terminal.

Was bedeutet „Add Python to PATH"?
PATH ist eine Liste von Ordnern, in denen dein Computer nach Programmen sucht, wenn du einen Befehl eingibst. Wenn Python dort eingetragen ist, findet dein Computer es automatisch, egal in welchem Ordner du dich im Terminal befindest. Ohne PATH müsstest du bei jedem Aufruf den genauen Speicherort von Python eingeben – sehr umständlich.

REPL vs. Skript-Dateien: Wenn du im Terminal nur python3 eingibst, landest du im interaktiven Modus (auch REPL genannt, erkennbar an den >>>). Hier wird jeder Befehl beim Drücken der Enter-Taste sofort ausgeführt. Für größere Programme schreibt man den Code jedoch in eine Datei mit der Endung .py (z. B. mein_code.py) und führt diese über das Terminal mit python3 mein_code.py aus.

Nach der Installation kannst du prüfen, ob alles korrekt eingerichtet ist, indem du im Terminal python --version oder python3 --version eingibst. Wenn du eine Version zurückbekommst, ist Python erfolgreich installiert. Danach kannst du Python starten, indem du python oder python3 im Terminal eingibst. In der Python-Eingabeaufforderung kannst du direkt Code ausführen, zum Beispiel print("Hallo").

Dieses Kapitel hilft dir also, die Umgebung für die nächsten Kapitel vorzubereiten. Wenn Python und Visual Studio Code korrekt eingerichtet sind, kannst du später ohne technische Probleme mit den Übungen arbeiten und deine ersten Programme direkt testen.

Offizielle Seiten: Python & Visual Studio Code

Einfaches Beispiel im Terminal

# macOS / Linux
python3 --version
python3
>>> print("Hallo")
Hallo
>>> exit()

# Windows
python --version
python
>>> print("Hallo")
Hallo
>>> exit()

Kapitel 1: Warum Python?

Python ist eine gute Wahl für den Einstieg, weil es sehr gut lesbar ist und du mit wenigen Zeilen schon verständliche Ergebnisse erzeugen kannst. Du lernst hier, warum Python in vielen Bereichen eingesetzt wird und warum es sich für Anfänger besonders gut eignet. Die erste Ausgabe mit print() zeigt dir direkt, dass du bereits mit kleinen Schritten interessante Ergebnisse erzielen kannst.

Wo wird Python überall eingesetzt?
Python steckt in vielen Dingen, die du täglich nutzt: YouTube, Instagram und Netflix nutzen Python für ihre Server. Wissenschaftler verwenden es für Berechnungen und Datenanalyse. Viele Spiele und Animationen werden damit gesteuert. Selbst die Raumfahrtbehörde NASA setzt Python ein. Du lernst also keine Spielzeugsprache, sondern etwas Echtes und Nützliches.

Was kannst du damit bauen?
Als Einsteiger kannst du schon nach wenigen Kapiteln eigene kleine Spiele, Taschenrechner, Rätsel-Programme oder Notizzettel-Apps bauen. Später sind Webseiten, automatische Downloads, Chatbots oder sogar eigene KI-Experimente möglich. Der beste Weg: Einfach anfangen und neugierig bleiben!

Der Interpreter: Python ist eine sogenannte Interpretersprache. Das bedeutet, dass ein Hilfsprogramm (der Interpreter) deinen Code Zeile für Zeile von oben nach unten liest und sofort ausführt. Es muss nicht erst umständlich übersetzt werden, was das Ausprobieren extrem schnell macht.

Kommentare helfen dir, deinen Code zu erklären, ohne dass Python sie ausführt. In Python beginnst du einen Kommentar mit #. Das ist praktisch, wenn du später sehen möchtest, was eine Zeile machen soll oder wenn du dir Notizen im Code festhalten willst. Du kannst Kommentare auch nutzen, um Codezeilen vorübergehend "auszukommentieren" (zu deaktivieren), wenn du etwas anderes testen willst.

print("Hallo, Welt!")

# Das ist ein Kommentar
# Er wird von Python nicht ausgeführt
print("Das ist sichtbar")

# print("Das wird übersprungen")  <- Diese Zeile wird nicht ausgeführt

Weiterführende Informationen: W3Schools – Python Einführung

Kapitel 2: Variablen

Stell dir eine Variable wie eine beschriftete Schachtel vor: Du packst einen Wert hinein (z.B. eine Zahl oder einen Text), gibst der Schachtel einen Namen und kannst den Inhalt später jederzeit wieder herausnehmen oder austauschen. So kannst du Informationen wie einen Namen, ein Alter oder einen Punktestand im Programm speichern und immer wieder verwenden.

Regeln für Variablennamen: In Python solltest du deine Variablen immer klein schreiben und Wörter mit einem Unterstrich verbinden (das nennt man snake_case, z. B. lieblings_farbe). Zudem dürfen Variablennamen niemals mit einer Zahl beginnen oder Leerzeichen enthalten. Auch reservierte Wörter wie if, for oder class sind verboten.

Was passiert bei einem Tippfehler im Variablennamen?
Wenn du eine Variable benutzt, die du noch nicht erstellt (oder falsch geschrieben) hast, wirft Python einen NameError: "name 'puntze' is not defined". Das ist einer der häufigsten Anfängerfehler. Prüfe in solchen Fällen, ob der Name überall genau gleich geschrieben ist – Python unterscheidet Groß- und Kleinbuchstaben (Name und name sind zwei verschiedene Variablen!).

Texte zusammensetzen (Konkatenation):
Mit dem +-Operator kannst du Texte aneinanderhängen. Mit * kannst du einen Text mehrfach wiederholen:

vorname = "Mia"
nachname = "Müller"
voller_name = vorname + " " + nachname   # Ergibt: "Mia Müller"
print(voller_name)

trennlinie = "-" * 20   # Ergibt: "--------------------"
print(trennlinie)

In Python gibt es verschiedene Datentypen, zum Beispiel str für Text, int für ganze Zahlen, float für Kommazahlen und bool für Wahrheitswerte (True / False). Manchmal möchtest du einen Wert von einem Typ in einen anderen umwandeln, zum Beispiel einen Text in eine Zahl oder eine Zahl in Text. Dafür nutzt du Funktionen wie int(), float() und str().

name = "Mia"
age = 13
preis = 4.99
ist_einsteiger = True

# Typumwandlungen (Typecasting)
alter_text = "16"
alter_zahl = int(alter_text)

text_aus_zahl = str(age)
print(type(name))
print(type(age))
print(type(preis))
print(type(ist_einsteiger))
print(alter_zahl)
print(text_aus_zahl)

Kleiner Vorausblick – f-Strings:
Um Variablen direkt in einen Text einzubauen, nutzt du in Python sogenannte f-Strings. Schreibe einfach ein f vor die Anführungszeichen und setze die Variable in geschweifte Klammern:

name = "Mia"
alter = 13
print(f"Ich heiße {name} und bin {alter} Jahre alt.")

In Kapitel 3 lernst du f-Strings ausführlicher kennen.

Weiterführende Informationen: W3Schools – Python Variablen

Kapitel 3: Eingaben, Ausgaben & Operatoren

Mit input() kannst du ein Programm interaktiv machen, indem es den Nutzer nach Informationen fragt. Danach nutzt du print(), um die Antwort sichtbar zu machen. So lernst du den grundlegenden Dialog zwischen Programm und Benutzer kennen und siehst sofort, wie Python auf Eingaben reagiert.

Moderne Ausgabe mit f-Strings: Um Text und Variablen besonders einfach miteinander zu verknüpfen, nutzt man in Python sogenannte f-Strings (Formatted Strings). Du schreibst einfach ein kleines f direkt vor deine Anführungszeichen und kannst Variablen dann bequem in geschweiften Klammern {variable} direkt in den Text einbauen.

Wichtig ist: input() gibt immer einen Text (String) zurück. Wenn du von einem Benutzer eine Zahl möchtest, musst du den Text mit int() oder float() in den passenden Datentyp umwandeln. Dadurch kann dein Programm die Eingabe rechnen oder vergleichen.

Was passiert, wenn jemand etwas Falsches eingibt?
Wenn dein Programm int(input(...)) erwartet, der Nutzer aber z.B. "hallo" eingibt, stürzt das Programm mit einem ValueError ab. In Kapitel 10 lernst du mit try / except, wie du solche Fehler abfangen kannst.

Mehr Möglichkeiten mit f-Strings:
In geschweiften Klammern kannst du nicht nur Variablen einsetzen, sondern auch direkt rechnen oder Zahlen formatieren:

preis = 4.987
print(f"Preis: {preis:.2f} €")   # Auf 2 Nachkommastellen runden → 4.99 €

punkte = 42
max_punkte = 100
print(f"Ergebnis: {punkte}/{max_punkte} ({punkte/max_punkte*100:.0f}%)")
# Ausgabe: Ergebnis: 42/100 (42%)

name = input("Wie heißt du? ")
# Ausgabe mit f-String
print(f"Hallo {name}, schön dich kennenzulernen!")

alter_text = input("Wie alt bist du? ")
alter = int(alter_text)
print(f"Nächstes Jahr wirst du {alter + 1} Jahre alt.")

Kleines Beispiel: Begrüßung

name = input("Wie heißt du? ")
print("Hallo", name)

Kleines Beispiel: Zahlen addieren

zahl1 = int(input("Erste Zahl: "))
zahl2 = int(input("Zweite Zahl: "))
print("Summe:", zahl1 + zahl2)

Arithmetische Operatoren:
Mit Operatoren kannst du in Python rechnen. Neben den bekannten vier Grundrechenarten gibt es drei weitere nützliche Operatoren:

• + – Addition
• - – Subtraktion
• * – Multiplikation
• / – Division (Ergebnis immer als Kommazahl, z.B. 17 / 5 = 3.4)
• // – Ganzzahldivision (Ergebnis ohne Rest, z.B. 17 // 5 = 3)
• % – Modulo (gibt den Rest einer Division zurück, z.B. 17 % 5 = 2)
• ** – Potenz (z.B. 2 ** 8 = 256)

Was ist Modulo % und wozu brauche ich es?
Der Modulo-Operator gibt den Rest zurück, der nach einer ganzzahligen Division übrig bleibt. Zum Beispiel: 17 % 5 ergibt 2, weil 17 = 3 × 5 + 2. Das klingt nach einer Kleinigkeit, ist aber einer der nützlichsten Operatoren überhaupt: Du kannst damit prüfen, ob eine Zahl gerade oder ungerade ist (zahl % 2 == 0), ob sie durch eine andere Zahl teilbar ist, oder Werte zyklisch "umschlagen" lassen (z.B. für Uhrzeiten oder Spielpositionen).

a = int(input("Erste Zahl: "))
b = int(input("Zweite Zahl: "))

print(f"{a} + {b} = {a + b}")    # Addition
print(f"{a} - {b} = {a - b}")    # Subtraktion
print(f"{a} * {b} = {a * b}")    # Multiplikation
print(f"{a} / {b} = {a / b}")    # Division
print(f"{a} // {b} = {a // b}")  # Ganzzahldivision
print(f"{a} % {b} = {a % b}")    # Modulo (Rest)
print(f"{a} ** {b} = {a ** b}")  # Potenz

Erweiterte Zuweisung (Kurzschreibweise):
Sehr häufig möchte man eine Variable um einen Wert erhöhen oder verringern. Dafür gibt es eine kürzere Schreibweise:

punkte = int(input("Startpunkte: "))
punkte += 5    # entspricht: punkte = punkte + 5
punkte -= 2    # entspricht: punkte = punkte - 2
punkte *= 3    # entspricht: punkte = punkte * 3
print(f"Endpunkte: {punkte}")

Nützliche String-Methoden:
Texte (Strings) haben in Python eingebaute Hilfsfunktionen, die du direkt mit einem Punkt dahinter aufrufst:

• .upper() – Alle Buchstaben groß: "hallo".upper() → "HALLO"
• .lower() – Alle Buchstaben klein: "HALLO".lower() → "hallo"
• .strip() – Leerzeichen am Anfang und Ende entfernen: " hi ".strip() → "hi"

Hinweis: Wenn du bei einer Zahleneingabe statt einer Zahl einen Text eingibst (z.B. „hallo"), bricht Python mit einer Fehlermeldung ab (ValueError). Das ist ganz normal – Python kann „hallo" nicht in eine Zahl umwandeln. In Kapitel 10 lernst du, solche Fehler mit try und except sauber abzufangen. Bis dahin: Gib bei Zahleneingaben immer eine Zahl ein.

Weiterführende Informationen: W3Schools – Python Ein- und Ausgabe

Kapitel 4: Funktionen

Funktionen helfen dir, Code übersichtlicher und wiederverwendbar zu machen. Statt dieselbe Logik immer wieder neu zu schreiben, kannst du sie in eine Funktion packen und später mit unterschiedlichen Eingaben aufrufen.

Standardparameter: Du kannst einem Parameter einen Standardwert geben, der benutzt wird, wenn beim Aufruf nichts übergeben wird (z.B. name="Gast"). Das ist praktisch, wenn ein Wert meistens gleich ist, aber gelegentlich angepasst werden soll.

Lokale Variablen (Scope): Stell dir eine Funktion wie einen abgeschlossenen Raum vor. Variablen, die du innerhalb der Funktion erstellst, existieren nur in diesem Raum — sobald die Funktion fertig ist, verschwinden sie wieder. Von außen kann man nicht auf sie zugreifen. Das verhindert, dass Variablen aus verschiedenen Funktionen sich gegenseitig durcheinanderbringen.

Das DRY-Prinzip:
DRY steht für Don't Repeat Yourself – "Wiederhole dich nicht". Wenn du merkst, dass du denselben Code an mehreren Stellen schreibst, ist das ein Zeichen, dass eine Funktion helfen würde. Du schreibst den Code einmal, gibst ihm einen Namen und rufst ihn überall dort auf, wo du ihn brauchst. Das macht deinen Code kürzer, übersichtlicher und leichter zu korrigieren.

Mehrere Rückgabewerte:
Eine Funktion kann mit return auch mehrere Werte auf einmal zurückgeben. Python verpackt sie automatisch in ein sogenanntes Tupel, das du direkt entpacken kannst:

def min_max(zahlen):
    return min(zahlen), max(zahlen)

# Die eckigen Klammern [] sind eine Liste – die lernst du in Kapitel 7 genauer kennen.
kleinste, groesste = min_max([3, 1, 7, 4, 9, 2])
print(f"Kleinste: {kleinste}, Größte: {groesste}")
# Ausgabe: Kleinste: 1, Größte: 9

Mehrere Rückgabewerte – was passiert da?
Die Funktion gibt zwei Werte gleichzeitig zurück – das nennt sich ein Tupel. Mit der Schreibweise kleinste, groesste = min_max(...) werden die zwei Werte direkt in zwei separate Variablen aufgeteilt. Das nennt man Entpacken.

# Vereinfachtes Beispiel:
def zwei_zahlen():
    return 10, 20          # gibt ein Tupel (10, 20) zurück

a, b = zwei_zahlen()       # a = 10, b = 20
print(a)                   # 10
print(b)                   # 20

# Funktion mit Standardparameter
def begruessen(name="Gast"):
    return f"Hallo {name}!"

print(begruessen("Mia"))   # Ausgabe: Hallo Mia!
print(begruessen())        # Ausgabe: Hallo Gast!


# Funktion mit Parametern und Rückgabewert
def addieren(a, b):
    ergebnis = a + b       # 'ergebnis' ist lokal und außerhalb nicht sichtbar
    return ergebnis

print(addieren(3, 5))      # Ausgabe: 8

Weiterführende Informationen: W3Schools – Python Funktionen

Kapitel 5: Module & der import-Befehl

Python bringt von Haus aus viele eingebaute Funktionen mit – print(), int(), len() und andere. Darüber hinaus gibt es Hunderte von sogenannten Modulen: fertige Werkzeugkästen, die du bei Bedarf "laden" kannst. Mit dem import-Befehl sagst du Python: "Hol mir diesen Werkzeugkasten!" – danach stehen dir alle Funktionen darin zur Verfügung.

Zwei Schreibweisen für den Import:

import math              # Das ganze Modul laden
print(math.sqrt(25))     # Zugriff immer mit "math." davor → 5.0

from math import sqrt    # Nur eine bestimmte Funktion laden
print(sqrt(25))          # Kein "math." nötig → 5.0

Die erste Schreibweise (import math) ist meist besser lesbar, weil man immer sieht, woher eine Funktion stammt. Die zweite (from math import sqrt) spart Tipparbeit, wenn man nur eine einzige Funktion oft braucht.

Das math-Modul – Mathematik-Werkzeugkasten:
Mit import math bekommst du Zugriff auf Funktionen und Konstanten, die über die Grundrechenarten hinausgehen:

• math.sqrt(x) – Quadratwurzel (z.B. math.sqrt(25) → 5.0)
• math.pi – Die Kreiszahl π ≈ 3.14159…
• math.floor(x) – Abrunden zur nächsten ganzen Zahl (z.B. math.floor(3.9) → 3)
• math.ceil(x) – Aufrunden (z.B. math.ceil(3.1) → 4)
• math.pow(x, y) – Potenz als Kommazahl (z.B. math.pow(2, 8) → 256.0)
• math.log(x) – Natürlicher Logarithmus; math.log(x, basis) für andere Basen

import math

radius = float(input("Radius eines Kreises: "))
umfang  = 2 * math.pi * radius
flaeche = math.pi * radius ** 2
print(f"Umfang:  {umfang:.2f} cm")
print(f"Fläche:  {flaeche:.2f} cm²")

# Wurzel und Runden
zahl = 50
print(f"Wurzel aus {zahl}: {math.sqrt(zahl):.4f}")
print(f"Abgerundet:  {math.floor(math.sqrt(zahl))}")
print(f"Aufgerundet: {math.ceil(math.sqrt(zahl))}")

Das random-Modul – Zufallszahlen:
Mit import random erzeugst du Zufallszahlen – ideal für Spiele, Simulationen oder zufällige Ausgaben. Du wirst dieses Modul in Kapitel 10 (Mini-Projekt Ratespiel) und Kapitel 15 (Würfelspiel) nochmals einsetzen.

Kurzer Vorausblick: Das Wort import random lädt ein fertiges Python-Werkzeug, das Zufallszahlen erzeugen kann. Wie import genau funktioniert, lernst du in Kapitel 5. Hier reicht es zu wissen: Diese Zeile aktiviert die Zufallszahlen-Funktion.

import random

# Zufällige ganze Zahl zwischen 1 und 100
zahl = random.randint(1, 100)
print(f"Zufallszahl: {zahl}")

# Zwei Würfel simulieren (je 1–6)
wuerfel1 = random.randint(1, 6)
wuerfel2 = random.randint(1, 6)
print(f"Würfelwurf: {wuerfel1} und {wuerfel2} → Summe: {wuerfel1 + wuerfel2}")

# Kommazahl zwischen 0.0 und 1.0
print(f"Zufallswert 0–1: {random.random():.4f}")

Das datetime-Modul – Datum und Uhrzeit:
Mit import datetime bekommst du Zugriff auf das aktuelle Datum und die Uhrzeit – nützlich z.B. für Zeitstempel, Tagebücher oder Countdowns.

import datetime

heute = datetime.date.today()
print(f"Heute ist: {heute}")               # z.B. 2026-05-28

jetzt = datetime.datetime.now()
print(f"Aktuelle Uhrzeit: {jetzt.hour}:{jetzt.minute:02d} Uhr")

# Wochentag-Nummer ausgeben (0 = Montag, 6 = Sonntag)
tag_nummer = heute.weekday()
print(f"Wochentag-Nummer: {tag_nummer}  (0 = Montag, 6 = Sonntag)")

Das time-Modul – Pausen im Programm:
Mit time.sleep(sekunden) hältst du dein Programm für eine bestimmte Zeit an. Das ist nützlich für Countdown-Animationen oder um Meldungen nacheinander erscheinen zu lassen:

import time

print("Programm startet in...")
print("3...")
time.sleep(1)
print("2...")
time.sleep(1)
print("1...")
time.sleep(1)
print("Los geht's!")
# Mit Schleifen (Kapitel 8) lässt sich das kürzer schreiben.

Überblick: Welches Modul wofür?

• math – Mathematische Funktionen (Wurzel, π, Runden)
• random – Zufallszahlen und zufällige Auswahl
• datetime – Datum und Uhrzeit
• time – Pausen und Zeitmessung
• os – Dateisystem und Ordner-Aktionen (mehr in Kapitel 11)
• csv – CSV-Tabellen lesen und schreiben (mehr in Kapitel 11)
• sqlite3 – Datenbankzugriff (mehr in Kapitel 13)

Alle diese Module gehören zur sogenannten Python Standard Library – sie sind bereits mit Python installiert, du brauchst nichts extra herunterzuladen. Daneben gibt es Tausende von externen Paketen (z.B. openpyxl für Excel oder requests für Webanfragen), die du mit dem Befehl pip install paketname im Terminal nachinstallierst.

Weiterführende Informationen: W3Schools – Python Module

Kapitel 6: Wenn-Dann-Bedingungen

Bedingungen ermöglichen es einem Programm, Entscheidungen zu treffen. Mit if, else und elif kannst du prüfen, ob etwas wahr ist, und abhängig davon einen anderen Ablauf starten. Das ist ein zentraler Schritt, um Programme „intelligent“ reagieren zu lassen.

Wichtig: Die Einrückung (Indentation)
Im Gegensatz zu vielen anderen Programmiersprachen nutzt Python keine Klammern, um zu zeigen, welcher Code zu einer Bedingung gehört. Stattdessen nutzt Python Einrückungen (in der Regel 4 Leerzeichen oder ein Tabulator). Der eingerückte Codeblock unter einem if wird nur dann ausgeführt, wenn die Bedingung wahr ist. Achte immer genau darauf!

Häufiger Anfängerfehler: = statt ==
Ein einzelnes = ist eine Zuweisung (du speicherst etwas in eine Variable). Ein doppeltes == ist ein Vergleich (du prüfst, ob zwei Dinge gleich sind). Wenn du in einem if versehentlich = schreibst, bekommst du eine Fehlermeldung – gut, denn so merkst du es sofort!

Ein Vergleich prüft, ob zwei Werte gleich, größer oder kleiner sind. Mit ==, >, <, >= und <= formulierst du diese Regeln. Du kannst außerdem mehrere Bedingungen mit and (beide müssen wahr sein) und or (mindestens eine muss wahr sein) verbinden.

Der not-Operator und verkettete Vergleiche:
Mit not kannst du eine Bedingung umkehren – aus True wird False und umgekehrt. Außerdem erlaubt Python elegante verkettete Vergleiche, die fast wie normale Mathematik aussehen:

eingeloggt = False
if not eingeloggt:
    print("Bitte erst einloggen!")

# Verketteter Vergleich: kürzer als "punkte >= 10 and punkte <= 12"
punkte = 11
if 10 <= punkte <= 12:
    print("Sehr gut!")

alter = int(input("Wie alt bist du? "))
if alter >= 13:
    print("Du darfst dieses Tutorial machen!")
else:
    print("Noch ein bisschen Geduld")

punktzahl = 8
if punktzahl >= 10 and punktzahl <= 12:
    print("Sehr gut!")
elif punktzahl >= 7:
    print("Gut gemacht!")
else:
    print("Noch Übung nötig")

Kleines Beispiel: Einfache Prüfung

punktzahl = 11
if punktzahl >= 10:
    print("Sehr gut!")
else:
    print("Versuch es noch einmal")

Weiterführende Informationen: W3Schools – Python Bedingungen

Kapitel 7: Listen / Arrays

Listen sind praktische Container, die mehrere Werte an einem Ort speichern. Du kannst auf einzelne Elemente zugreifen, neue Werte hinzufügen und ganze Gruppen von Daten zusammen bearbeiten. Das ist besonders hilfreich, wenn du später mit vielen Einträgen arbeiten möchtest.

In Python beginnt eine Liste mit einem eckigen Klammerpaar. Du erreichst einzelne Elemente über ihre Position, zum Beispiel fruechte[0] für das erste Element. Wichtig: In der Informatik beginnt das Zählen immer bei null (0)!

Negativer Index und Slicing:
Mit negativen Zahlen kannst du von hinten zählen: liste[-1] gibt das letzte Element zurück, liste[-2] das vorletzte. Mit einem Doppelpunkt kannst du außerdem einen Bereich (ein sogenanntes „Slice") aus der Liste herausschneiden:

spiele = ["Mario", "Minecraft", "Tetris", "Zelda", "Pokémon"]
print(spiele[-1])      # Ausgabe: Pokémon (letztes Element)
print(spiele[1:3])     # Ausgabe: ['Minecraft', 'Tetris'] (Index 1 bis 2)
print(spiele[:2])      # Ausgabe: ['Mario', 'Minecraft'] (die ersten zwei)
print(spiele[2:])      # Ausgabe: ['Tetris', 'Zelda', 'Pokémon'] (ab Index 2)

Listen sortieren:
Mit .sort() sortierst du eine Liste direkt (sie wird verändert). Mit sorted() bekommst du eine neue, sortierte Kopie — die Original-Liste bleibt unverändert:

punkte = [42, 7, 99, 15, 3]
punkte.sort()           # Liste wird direkt sortiert
print(punkte)           # [3, 7, 15, 42, 99]

namen = ["Mia", "Aaron", "Leon"]
sortierte_namen = sorted(namen)   # Original bleibt unberührt
print(sortierte_namen)  # ['Aaron', 'Leon', 'Mia']

Wichtige Listen-Aktionen:

• append(wert): Fügt ein Element am Ende hinzu.
• insert(position, wert): Fügt ein Element an einer genauen Stelle ein.
• remove(wert): Löscht das angegebene Element aus der Liste.
• len(liste): Zeigt an, wie viele Elemente in der Liste sind.
• in: Prüft, ob ein Element in einer Liste existiert (gibt True oder False zurück).

fruechte = ["Apfel", "Banane", "Kirsche"]
print(fruechte[0])       # Ausgabe: Apfel

fruechte.append("Orange")
fruechte.insert(1, "Erdbeere")  # Erdbeere wird an Position 1 (nach Apfel) geschoben
fruechte.remove("Banane")

print(fruechte)
print(f"Länge der Liste: {len(fruechte)}")

if "Apfel" in fruechte:
    print("Ja, Äpfel sind auf der Einkaufsliste!")

Kleines Beispiel: Lieblingsspiele ausgeben
Hinweis: Die for-Schleife lernst du in Kapitel 8 ausführlich kennen – hier siehst du schon einen ersten Vorgeschmack, wie man alle Elemente einer Liste der Reihe nach ausgibt.

spiele = ["Mario", "Minecraft", "Tetris"]
for spiel in spiele:
    print(spiel)

Weiterführende Informationen: W3Schools – Python Listen

Kapitel 8: Schleifen

Schleifen wiederholen einen Codeabschnitt so lange, bis eine Bedingung erfüllt ist oder eine feste Anzahl von Durchläufen erreicht wurde. Damit kannst du Aufgaben wie das Anzeigen mehrerer Einträge, das Wiederholen von Fragen oder das Verarbeiten von Datenlisten deutlich einfacher lösen.

Eine for-Schleife ist gut, wenn du im Vorfeld weißt, wie oft etwas ausgeführt werden soll (z. B. "5-mal" oder "für jedes Element einer Liste"). Eine while-Schleife läuft so lange weiter, wie eine Bedingung wahr ist (z. B. "so lange das Spiel läuft").

Was bedeutet for i in range(5)?
range(5) erzeugt die Zahlenfolge 0, 1, 2, 3, 4 — also genau 5 Schritte, beginnend bei 0. Das i ist eine normale Variable (kurz für "Index"), die in jedem Durchlauf automatisch den nächsten Wert aus der Folge bekommt. Du kannst sie auch anders nennen, z.B. schritt oder zahl — i ist nur eine weit verbreitete Abkürzung.

range() mit Start, Stop und Schritt:
range() kann bis zu drei Werte entgegennehmen: range(start, stop, schritt). Damit kannst du z.B. nur gerade Zahlen oder Zahlen rückwärts erzeugen:

for i in range(0, 10, 2):   # 0, 2, 4, 6, 8
    print(i)

for i in range(10, 0, -1):  # 10, 9, 8, ... 1 (Countdown!)
    print(i)

Index und Wert gleichzeitig: enumerate()
Wenn du beim Durchlaufen einer Liste sowohl den Wert als auch seine Position brauchst, hilft enumerate(). Das erspart dir eine extra Zählvariable:

spiele = ["Mario", "Minecraft", "Tetris"]
for nummer, spiel in enumerate(spiele, start=1):
    print(f"{nummer}. {spiel}")
# Ausgabe:
# 1. Mario
# 2. Minecraft
# 3. Tetris

Loop-Steuerung mit break und continue: Mit dem Befehl break kannst du eine Schleife sofort komplett abbrechen (auch wenn die Bedingung eigentlich noch wahr ist). Mit continue springst du sofort zum nächsten Schleifendurchlauf und überspringst den restlichen Code darunter für diese Runde.

# for-Schleife mit range()
for i in range(5):
    print("Schritt", i)

# Eine Liste durchlaufen
fruechte = ["Apfel", "Banane", "Kirsche"]
for frucht in fruechte:
    print(frucht)

# while-Schleife mit break
versuch = 0
while True:
    print("Noch ein Versuch...")
    versuch += 1
    if versuch >= 3:
        print("Maximale Versuche erreicht!")
        break  # Schleife wird sofort beendet

Weiterführende Informationen: W3Schools – Python Schleifen

Kapitel 9: Dictionaries / Wörterbücher

Eine Liste speichert Werte in einer bestimmten Reihenfolge – du erreichst sie über ihre Position (0, 1, 2 …). Ein Dictionary geht einen Schritt weiter: Es speichert Daten als Schlüssel-Wert-Paare. Statt einer Zahl gibst du jedem Wert einen aussagekräftigen Namen – zum Beispiel "Mia" statt 0.

Vergleich Liste vs. Dictionary:

punkte_liste = [12, 8, 15]                          # Zugriff über Position: punkte_liste[0]
punkte_dict  = {"Mia": 12, "Leon": 8, "Sara": 15}  # Zugriff über Namen: punkte_dict["Mia"]

Dictionary erstellen und lesen:

person = {
    "name": "Mia",
    "alter": 13,
    "lieblingstier": "Katze"
}

print(person["name"])    # Ausgabe: Mia
print(person["alter"])   # Ausgabe: 13

Einträge hinzufügen und ändern:
Du fügst einen neuen Eintrag hinzu, indem du einfach einen neuen Schlüssel zuweist. Existiert der Schlüssel schon, wird der Wert überschrieben:

person["klasse"] = "7b"   # neuer Eintrag
person["alter"] = 14      # bestehenden Wert ändern
print(person)
# {'name': 'Mia', 'alter': 14, 'lieblingstier': 'Katze', 'klasse': '7b'}

Eintrag löschen:

del person["lieblingstier"]
print(person)

Prüfen ob ein Schlüssel vorhanden ist:
Genau wie bei Listen kannst du mit in prüfen, ob ein Schlüssel im Dictionary existiert:

if "name" in person:
    print("Name ist bekannt:", person["name"])

Über alle Einträge iterieren mit .items():
Mit .items() bekommst du bei jedem Schleifendurchlauf sowohl den Schlüssel als auch den Wert:

punkte = {"Mia": 12, "Leon": 8, "Sara": 15}

for name, wert in punkte.items():
    print(f"{name} hat {wert} Punkte")
# Ausgabe:
# Mia hat 12 Punkte
# Leon hat 8 Punkte
# Sara hat 15 Punkte

Nur Schlüssel oder nur Werte:

print(list(punkte.keys()))    # ['Mia', 'Leon', 'Sara']
print(list(punkte.values()))  # [12, 8, 15]

Wann Dictionary, wann Liste?
Nutze eine Liste, wenn die Reihenfolge wichtig ist oder du viele gleichartige Werte sammelst.
Nutze ein Dictionary, wenn jeder Wert einen eigenen Namen (Schlüssel) haben soll und du schnell danach suchen willst.

Weiterführende Informationen: W3Schools – Python Dictionaries

Kapitel 10: Mini-Projekt – Zahl erraten

Ein kleines Ratespiel zeigt gut, wie du Eingaben, Bedingungen und Schleifen zusammenbringen kannst. Der Computer wählt eine Zahl, du gibst eine Vermutung ein, und das Programm gibt dir Hinweise, ob die Zahl zu klein oder zu groß ist.

Das import-Statement: Python bringt viele eingebaute Funktionen mit, aber um spezielle Dinge (wie Zufallszahlen) zu nutzen, importieren wir zusätzliche "Module". Mit import random laden wir das Zufalls-Modul. Die Funktion random.randint(1, 10) wählt dann eine zufällige ganze Zahl zwischen 1 und 10 aus.

Weitere nützliche Funktionen aus dem random-Modul:

import random

# Zufälliges Element aus einer Liste wählen
farben = ["rot", "grün", "blau", "gelb"]
print(random.choice(farben))      # z.B. "blau"

# Liste zufällig durchmischen
karten = [1, 2, 3, 4, 5, 6, 7, 8]
random.shuffle(karten)
print(karten)                     # z.B. [5, 2, 8, 1, 3, 7, 4, 6]

# Kommazahl zwischen 0.0 und 1.0
print(random.random())            # z.B. 0.7382...

Fehler abfangen mit try / except:
Im Ratespiel haben wir try / except eingebaut. Das Prinzip: Python versucht (try) den eingerückten Code auszuführen. Tritt dabei ein Fehler auf, springt Python in den except-Block statt abzustürzen. ValueError tritt genau dann auf, wenn int() etwas bekommt, das keine Zahl ist.

import random

zahl = random.randint(1, 10)
versuche = 0

print("Ich habe mir eine Zahl zwischen 1 und 10 ausgedacht. Kannst du sie erraten?")

while True:
    eingabe = input("Rate eine Zahl: ")
    try:
        versuch = int(eingabe)
    except ValueError:
        print("Bitte gib eine ganze Zahl ein (z.B. 5)!")
        continue
    versuche += 1
    if versuch < zahl:
        print("Deine Zahl ist zu klein!")
    elif versuch > zahl:
        print("Deine Zahl ist zu groß!")
    else:
        print(f"Herzlichen Glückwunsch! Du hast die Zahl in {versuche} Versuch(en) erraten!")
        break

Weiterführende Informationen: W3Schools – Python random-Modul

Kapitel 11: Dateioperationen

Bisher haben alle deine Programme ihre Daten nur im Arbeitsspeicher gehalten – sobald das Programm endet, ist alles weg. Mit Dateioperationen kannst du Texte, Listen oder Notizen dauerhaft auf dem Computer speichern und beim nächsten Programmstart wieder einlesen. Das ist zum Beispiel praktisch für ein Tagebuch, eine Highscore-Liste oder einfach gespeicherte Einstellungen.

Das with-Statement – Dateien sicher öffnen:
In Python öffnet man Dateien am besten mit with open(...) as datei:. Das with-Statement sorgt dafür, dass die Datei nach dem eingerückten Block automatisch wieder geschlossen wird – auch wenn ein Fehler passiert. Du musst dir also keine Gedanken ums manuelle Schließen machen.

Zeichenkodierung mit encoding="utf-8":
Wenn dein Text deutsche Umlaute (ä, ö, ü, ß) enthält, kann es auf manchen Computern – besonders unter Windows – zu Darstellungsfehlern kommen. Die Lösung: Gib beim Öffnen immer encoding="utf-8" an. UTF-8 ist ein weltweiter Standard, der alle Sonderzeichen korrekt speichert:

with open("notizen.txt", "w", encoding="utf-8") as datei:
    datei.write("Heute war schön – Äpfel, Öl und Züge!\n")

with open("notizen.txt", "r", encoding="utf-8") as datei:
    print(datei.read())

Alle Zeilen auf einmal laden mit readlines():
Statt zeilenweise über die Datei zu iterieren, kannst du mit readlines() alle Zeilen als Liste einlesen. Jede Zeile ist dann ein eigener Listeneintrag (noch mit \n am Ende):

with open("notizen.txt", "r", encoding="utf-8") as datei:
    zeilen = datei.readlines()   # Liste aller Zeilen

print(f"Die Datei hat {len(zeilen)} Zeilen.")
print(zeilen[0].strip())         # Erste Zeile ohne \n

Relative und absolute Dateipfade:
Wenn du open("notizen.txt") schreibst, sucht Python die Datei im selben Ordner, in dem du das Skript ausführst (relativer Pfad). Einen absoluten Pfad gibst du mit dem vollständigen Speicherort an, z.B. open("C:/Benutzer/Mia/notizen.txt") auf Windows oder open("/Users/mia/notizen.txt") auf macOS. Für den Einstieg reicht der relative Pfad immer aus.

Die drei Datei-Modi:

• "w" (write) – Erstellt die Datei neu. Falls sie schon existiert, wird sie überschrieben.
• "r" (read) – Öffnet die Datei zum Lesen. Funktioniert nur, wenn die Datei bereits existiert.
• "a" (append) – Öffnet die Datei und hängt neuen Text am Ende an, ohne den bisherigen Inhalt zu löschen.

# Datei schreiben ("w" = write)
with open("notizen.txt", "w") as datei:
    datei.write("Erste Notiz\n")   # \n erzeugt einen Zeilenumbruch
    datei.write("Zweite Notiz\n")
print("Datei wurde erstellt!")

# Datei lesen ("r" = read) – gesamten Inhalt auf einmal
with open("notizen.txt", "r") as datei:
    inhalt = datei.read()
print(inhalt)

# Datei zeilenweise lesen
with open("notizen.txt", "r") as datei:
    for zeile in datei:
        print(zeile.strip())   # .strip() entfernt das \n am Zeilenende

# Text anhängen ("a" = append) – bestehender Inhalt bleibt erhalten
with open("notizen.txt", "a") as datei:
    datei.write("Dritte Notiz\n")

Dateien und Ordner verwalten mit os und shutil:
Python bringt zwei sehr nützliche Module für Datei- und Ordneroperationen mit: os für einfache Dateiinfos und Ordner-Aktionen, und shutil (shell utilities) für Kopieren und Verschieben.

• os.path.exists("datei.txt") – Prüft, ob eine Datei oder ein Ordner existiert.
• os.listdir(".") – Listet alle Dateien im aktuellen Ordner auf ("." steht für "hier").
• os.remove("datei.txt") – Löscht eine Datei.
• os.makedirs("ordner") – Erstellt einen neuen Ordner.
• shutil.copy("quelle.txt", "ziel.txt") – Kopiert eine Datei.

import os
import shutil

# Prüfen ob eine Datei existiert
if os.path.exists("notizen.txt"):
    print("Die Datei existiert!")

# Datei kopieren (z.B. als Backup)
shutil.copy("notizen.txt", "notizen_backup.txt")
print("Backup erstellt!")

# Alle Dateien im aktuellen Ordner anzeigen
print("Dateien im Ordner:")
for dateiname in os.listdir("."):
    print(f"  {dateiname}")

# Datei löschen
os.remove("notizen_backup.txt")
print("Backup gelöscht.")

Mini-Beispiel: Einfaches Notizbuch
Dieses Programm kombiniert alles: Notizen anhängen, alle Notizen anzeigen:

import os

DATEINAME = "notizbuch.txt"

while True:
    aktion = input("Was möchtest du? (schreiben / lesen / beenden): ")

    if aktion == "schreiben":
        notiz = input("Deine Notiz: ")
        with open(DATEINAME, "a") as datei:
            datei.write(notiz + "\n")
        print("Notiz gespeichert!")

    elif aktion == "lesen":
        if os.path.exists(DATEINAME):
            with open(DATEINAME, "r") as datei:
                print("\n--- Alle Notizen ---")
                print(datei.read())
        else:
            print("Noch keine Notizen vorhanden.")

    elif aktion == "beenden":
        print("Tschüss!")
        break

CSV-Dateien lesen und schreiben:
CSV steht für Comma-Separated Values (kommagetrennte Werte). Es ist ein weit verbreitetes Dateiformat für Tabellen: jede Zeile ist ein Datensatz, und die Werte werden durch Kommas getrennt. CSV-Dateien können sowohl von Python als auch von Excel oder LibreOffice Calc geöffnet werden – ideal, um Daten auszutauschen.

Python bringt das eingebaute Modul csv mit – du brauchst also nichts extra zu installieren:

import csv

# CSV-Datei schreiben
with open("noten.csv", "w", newline="", encoding="utf-8") as datei:
    writer = csv.writer(datei)
    writer.writerow(["Name", "Fach", "Note"])   # Kopfzeile
    writer.writerow(["Mia", "Mathe", 1])
    writer.writerow(["Leon", "Englisch", 2])
    writer.writerow(["Sara", "Sport", 1])
print("CSV-Datei erstellt!")

# CSV-Datei lesen
with open("noten.csv", "r", encoding="utf-8") as datei:
    reader = csv.reader(datei)
    for zeile in reader:
        print(zeile)
# Ausgabe: ['Name', 'Fach', 'Note']
#          ['Mia', 'Mathe', '1']
#          ['Leon', 'Englisch', '2'] ...

Was bedeutet newline=""?
Beim Schreiben von CSV-Dateien unter Windows kann es ohne diesen Parameter zu doppelten Leerzeilen kommen. newline="" verhindert das – es ist eine Besonderheit des csv-Moduls und sollte immer angegeben werden.

Mit csv.DictWriter und csv.DictReader kannst du CSV-Daten als Wörterbücher lesen und schreiben – praktischer, weil du die Spalten direkt beim Namen nennen kannst:

import csv

# Mit DictWriter schreiben – Spaltennamen statt Positionen
with open("schueler.csv", "w", newline="", encoding="utf-8") as datei:
    felder = ["Name", "Alter", "Klasse"]
    writer = csv.DictWriter(datei, fieldnames=felder)
    writer.writeheader()
    writer.writerow({"Name": "Mia", "Alter": 13, "Klasse": "7b"})
    writer.writerow({"Name": "Leon", "Alter": 14, "Klasse": "8a"})

# Mit DictReader lesen – jede Zeile als Dictionary
with open("schueler.csv", "r", encoding="utf-8") as datei:
    reader = csv.DictReader(datei)
    for zeile in reader:
        print(f"{zeile['Name']} ist {zeile['Alter']} Jahre alt (Klasse {zeile['Klasse']}).")

pip install openpyxl

import openpyxl

# Neue Excel-Datei erstellen
mappe = openpyxl.Workbook()
blatt = mappe.active        # Das erste Tabellenblatt
blatt.title = "Noten"       # Blatt umbenennen

# Kopfzeile schreiben
blatt.append(["Name", "Fach", "Note"])

# Datenzeilen schreiben
blatt.append(["Mia", "Mathe", 1])
blatt.append(["Leon", "Englisch", 2])
blatt.append(["Sara", "Sport", 1])

mappe.save("noten.xlsx")
print("Excel-Datei gespeichert!")

import openpyxl

mappe = openpyxl.load_workbook("noten.xlsx")
blatt = mappe.active

print(f"Tabellenblatt: {blatt.title}")
print(f"Zeilen: {blatt.max_row}, Spalten: {blatt.max_column}")

for zeile in blatt.iter_rows(values_only=True):
    print(zeile)
# Ausgabe: ('Name', 'Fach', 'Note')
#          ('Mia', 'Mathe', 1)
#          ('Leon', 'Englisch', 2) ...

Weiterführende Informationen: W3Schools – Python Dateioperationen

Kapitel 12: Klassen und Objekte (OOP)

In der Programmierung nutzt man oft Klassen, um Dinge aus der echten Welt oder aus einem Spiel darzustellen. Das nennt man Objektorientierte Programmierung (OOP). Eine Klasse ist wie ein Bauplan (z.B. der Bauplan für ein Auto oder eine Spielfigur), und das Objekt ist das fertige Ding, das nach diesem Bauplan gebaut wurde (z.B. ein roter VW Golf oder deine Spielfigur "Mia").

Warum brauchen wir Klassen überhaupt?
Stell dir vor, du programmierst ein Spiel mit vielen Spielern. Ohne Klassen müsstest du für jeden Spieler einzelne Variablen anlegen – das wird schnell unübersichtlich:

# Ohne Klassen – unübersichtlich und fehleranfällig
spieler1_name   = "Mia"
spieler1_punkte = 12
spieler2_name   = "Leon"
spieler2_punkte = 8
# ... für 100 Spieler ein Alptraum ...

Mit einer Klasse schreibst du den Bauplan einmal und kannst daraus beliebig viele Objekte erstellen – jedes mit eigenen Werten, aber denselben Fähigkeiten:

# Mit einer Klasse – übersichtlich und wiederverwendbar
spieler1 = Spieler("Mia", 12)
spieler2 = Spieler("Leon", 8)
# ... so viele wie du willst

OOP hat drei wichtige Stärken, die du in diesem Kapitel kennenlernen wirst:

• Kapselung: Daten (Attribute) und Verhalten (Methoden) eines Dings bleiben zusammen in einer Klasse – klar strukturiert und ordentlich.
• Vererbung: Eine Klasse kann von einer anderen erben und ihre Fähigkeiten übernehmen, ohne alles neu schreiben zu müssen.
• Polymorphismus: Verschiedene Klassen können dieselbe Methode haben, die sich aber unterschiedlich verhält – z.B. sprechen() beim Hund ("Wau!") und bei der Katze ("Miau!").

Eine Klasse besteht meistens aus zwei Teilen:

• Eigenschaften (Attribute): Daten, die das Objekt beschreiben (z.B. Name, Lebenspunkte, Farbe).
• Methoden (Funktionen): Aktionen, die das Objekt ausführen kann (z.B. rennen, Punkte sammeln, sich vorstellen).

Der Konstruktor (__init__) und self: Wenn wir ein neues Objekt aus einer Klasse erstellen, wird automatisch eine spezielle Funktion aufgerufen: __init__. Sie "initialisiert" (erstellt) das Objekt mit seinen Startwerten. Das Wort self ist ein Platzhalter für das jeweilige Objekt selbst und sorgt dafür, dass die Eigenschaften auch genau zu diesem Objekt gehören.

Was passiert Schritt für Schritt, wenn du mia = Spieler("Mia", 12) schreibst?

1. Python sieht das Wort Spieler und sucht den gleichnamigen Bauplan (die Klasse).
2. Python ruft automatisch __init__ auf und übergibt "Mia" für name und 12 für punkte.
3. self verweist auf das neue Objekt, das gerade entsteht. self.name = "Mia" klebt den Wert also fest an dieses Objekt.
4. Das fertige Objekt wird in der Variable mia gespeichert.

Ab diesem Punkt kannst du mia.name, mia.punkte und alle Methoden der Klasse mit einem Punkt dahinter aufrufen.

Die __str__-Methode – lesbare Ausgabe:
Wenn du ein Objekt direkt mit print() ausgibst, zeigt Python normalerweise etwas wie <__main__.Spieler object at 0x...> – das ist wenig hilfreich. Mit der speziellen Methode __str__ kannst du festlegen, was ausgegeben werden soll:

class Spieler:
    def __init__(self, name, punkte):
        self.name = name
        self.punkte = punkte

    def __str__(self):
        return f"Spieler {self.name} ({self.punkte} Punkte)"

mia = Spieler("Mia", 42)
print(mia)   # Ausgabe: Spieler Mia (42 Punkte)

# Wir definieren den Bauplan "Spieler"
class Spieler:
    # Der Konstruktor legt fest, was jeder Spieler von Anfang an haben muss
    def __init__(self, name, punkte):
        self.name = name          # Eigenschaft: Name
        self.punkte = punkte      # Eigenschaft: Punkte

    # Eine Methode, damit sich der Spieler vorstellen kann
    def vorstellen(self):
        print(f"Hallo! Ich bin {self.name} und habe {self.punkte} Punkte.")

    # Eine Methode, um Punkte hinzuzufügen
    def punkt_sammeln(self, anzahl):
        self.punkte += anzahl
        print(f"{self.name} hat {anzahl} Punkte gesammelt! Neuer Stand: {self.punkte}")

# Jetzt erstellen wir ein konkretes Objekt (eine "Instanz") aus dem Bauplan:
mia = Spieler("Mia", 12)
mia.vorstellen()          # Ausgabe: Hallo! Ich bin Mia und habe 12 Punkte.

# Mia sammelt Punkte
mia.punkt_sammeln(5)      # Ausgabe: Mia hat 5 Punkte gesammelt! Neuer Stand: 17

Objekte sind voneinander unabhängig:
Jedes Objekt hat seine eigenen Attributwerte. Wenn du mia.punkte veränderst, bleibt leon.punkte völlig unberührt – auch wenn beide aus demselben Bauplan stammen:

mia  = Spieler("Mia", 12)
leon = Spieler("Leon", 8)

mia.punkt_sammeln(10)   # Mia hat jetzt 22 Punkte
print(leon.punkte)      # Leon ist unverändert: 8

Klassen-Variable vs. Instanz-Variable:
Eine Instanz-Variable (mit self.) gehört genau einem Objekt und kann für jede Instanz anders sein. Eine Klassen-Variable wird direkt in der Klasse ohne self definiert und ist für alle Objekte der Klasse gleich. Das ist nützlich, um z.B. zu zählen, wie viele Objekte insgesamt erstellt wurden:

class Spieler:
    anzahl = 0     # Klassen-Variable: gemeinsam für alle Spieler

    def __init__(self, name, punkte):
        self.name   = name      # Instanz-Variable: gehört nur diesem Spieler
        self.punkte = punkte
        Spieler.anzahl += 1     # bei jedem neuen Spieler hochzählen

mia  = Spieler("Mia", 12)
leon = Spieler("Leon", 8)
print(Spieler.anzahl)           # Ausgabe: 2

Vererbung – ein Bauplan für Spezialfälle:
Eine Klasse kann von einer anderen Klasse erben – sie bekommt dann automatisch alle Eigenschaften und Methoden der Elternklasse und kann noch eigene hinzufügen. Das ist nützlich, wenn zwei Dinge vieles gemeinsam haben, sich aber in einigen Punkten unterscheiden:

class Fahrzeug:
    def __init__(self, marke, geschwindigkeit):
        self.marke = marke
        self.geschwindigkeit = geschwindigkeit

    def beschreiben(self):
        print(f"{self.marke} fährt {self.geschwindigkeit} km/h.")

class Elektroauto(Fahrzeug):   # erbt von Fahrzeug
    def __init__(self, marke, geschwindigkeit, reichweite):
        super().__init__(marke, geschwindigkeit)  # Elternklasse initialisieren
        self.reichweite = reichweite

    def laden(self):
        print(f"{self.marke} lädt gerade. Reichweite: {self.reichweite} km.")

tesla = Elektroauto("Tesla", 250, 500)
tesla.beschreiben()   # geerbt von Fahrzeug
tesla.laden()         # eigene Methode

Polymorphismus – gleicher Name, unterschiedliches Verhalten:
"Polymorphismus" klingt kompliziert, ist aber ein einfaches Konzept: Verschiedene Klassen können eine Methode mit demselben Namen haben, die sich aber unterschiedlich verhält. Du kannst dann alle Objekte gleich behandeln, ohne zu wissen, welcher genaue Typ dahintersteckt – Python sucht automatisch die richtige Version:

class Hund:
    def sprechen(self):
        return "Wau!"

class Katze:
    def sprechen(self):
        return "Miau!"

class Vogel:
    def sprechen(self):
        return "Piep!"

tiere = [Hund(), Katze(), Vogel()]
for tier in tiere:
    print(tier.sprechen())
# Ausgabe:
# Wau!
# Miau!
# Piep!

Alle drei Klassen haben eine Methode sprechen(), aber jede tut etwas anderes – das ist Polymorphismus in Aktion. In der Vererbung kannst du Methoden der Elternklasse in der Kindklasse mit super() erweitern oder einfach komplett überschreiben.

Warum ist das alles nützlich? Mit dem Bauplan kannst du beliebig viele Spieler erstellen, die alle ihre eigenen Werte haben, aber sich genau gleich verhalten:

# Ein zweiter Spieler nach demselben Bauplan
leon = Spieler("Leon", 8)
leon.vorstellen()         # Ausgabe: Hallo! Ich bin Leon und habe 8 Punkte.

Weiterführende Informationen: W3Schools – Python Klassen

Kapitel 13: SQL in Python & Datenbanken

Warum eine Datenbank statt einer Datei?
In Kapitel 11 hast du gelernt, Daten dauerhaft in Textdateien zu speichern – das funktioniert gut für einfache Fälle. Sobald du aber viele Einträge verwalten, gezielt suchen, filtern oder sortieren möchtest, stoßen Textdateien schnell an ihre Grenzen. Eine Datenbank speichert Daten strukturiert in Tabellen – ähnlich wie eine Excel-Tabelle – und erlaubt dir, mit wenigen Befehlen genau die Zeilen zu finden, die du brauchst, ohne die gesamte Datei durchlesen zu müssen.

Was ist SQL?
SQL steht für Structured Query Language (strukturierte Abfragesprache). Es ist eine einfache Sprache, mit der du einer Datenbank sagen kannst, was sie tun soll: Tabellen erstellen, Daten speichern, auslesen oder löschen. Mit nur 4–5 SQL-Befehlen kannst du schon sehr viel machen.

Die wichtigsten SQL-Befehle:

• CREATE TABLE – Erstellt eine neue Tabelle und legt ihre Spalten fest.
• INSERT INTO – Fügt eine neue Zeile (einen neuen Eintrag) in eine Tabelle ein.
• SELECT – Liest Daten aus einer Tabelle aus. SELECT * bedeutet "alle Spalten".
• WHERE – Filtert Ergebnisse nach einer Bedingung (z.B. nur Einträge mit mehr als 900 Punkten).
• DELETE – Löscht Einträge aus einer Tabelle.

Datentypen in SQL:
Jede Spalte in einer Tabelle bekommt einen Typ, der festlegt, was darin gespeichert werden darf:

• INTEGER – Ganze Zahlen (z.B. 1, 42, -5)
• TEXT – Texte (z.B. "Mario", "Mia")
• REAL – Kommazahlen (z.B. 4.99, 1.5)

SQLite – eine Datenbank direkt in Python:
Python bringt das Modul sqlite3 bereits mit – du musst nichts extra installieren. SQLite speichert die gesamte Datenbank in einer einzigen Datei auf deinem Computer (z.B. spiele.db). Das ist ideal für kleinere Projekte und perfekt zum Lernen.

Verbindung, Cursor und Commit – die drei Grundbausteine:

• Verbindung (conn): Öffnet die Datenbankdatei (oder erstellt sie, falls sie noch nicht existiert). Wie das Öffnen eines Notizbuchs.
• Cursor (cur): Dein "Stift" – er führt SQL-Befehle aus. Mit cur.execute("...") gibst du der Datenbank Anweisungen.
• Commit (conn.commit()): Speichert alle Änderungen dauerhaft. Ohne Commit gehen eingefügte Daten beim Schließen verloren – wie ein Dokument, das man vergisst zu speichern!

Der ?-Platzhalter – Daten sicher einfügen:
Wenn du Werte aus deinem Programm in eine SQL-Anweisung einbauen willst, nutze immer ein Fragezeichen ? als Platzhalter. Den echten Wert übergibst du als zweites Argument in einem Tupel (das sind die Klammern hinter dem SQL-Text):

# RICHTIG: Wert über ? übergeben
cur.execute("INSERT INTO spiele (name) VALUES (?)", ("Tetris",))

# FALSCH: Wert direkt in den Text einbauen – kann zu Fehlern führen!
# cur.execute("INSERT INTO spiele (name) VALUES ('" + name + "')")

Das ? stellt sicher, dass Sonderzeichen im Text die Datenbank nicht durcheinanderbringen. Immer so machen!

Das komplette Beispiel – Schritt für Schritt:

import sqlite3

# Schritt 1: Verbindung aufbauen (erstellt spiele.db, falls nötig)
conn = sqlite3.connect("spiele.db")
cur = conn.cursor()

# Schritt 2: Tabelle erstellen – nur wenn sie noch nicht existiert
#   id:   automatische Zahl, wird von SQLite vergeben (Primärschlüssel)
#   name: ein Textfeld
cur.execute("CREATE TABLE IF NOT EXISTS spiele (id INTEGER PRIMARY KEY, name TEXT)")

# Schritt 3: Einträge hinzufügen
cur.execute("INSERT INTO spiele (name) VALUES (?)", ("Tetris",))
cur.execute("INSERT INTO spiele (name) VALUES (?)", ("Minecraft",))

# Schritt 4: Änderungen dauerhaft speichern!
conn.commit()

# Schritt 5: Alle Einträge auslesen
print("Alle Spiele in der Datenbank:")
for row in cur.execute("SELECT id, name FROM spiele"):
    print(f"  ID {row[0]}: {row[1]}")

# Schritt 6: Verbindung sauber schließen
conn.close()

Daten filtern mit WHERE:
Mit WHERE kannst du gezielt nach Einträgen suchen, die eine bestimmte Bedingung erfüllen – wie eine Suchfunktion für deine Datenbank:

import sqlite3

conn = sqlite3.connect("highscores.db")
cur = conn.cursor()

cur.execute("CREATE TABLE IF NOT EXISTS scores (id INTEGER PRIMARY KEY, spieler TEXT, punkte INTEGER)")
cur.execute("INSERT INTO scores (spieler, punkte) VALUES (?, ?)", ("Mia", 1200))
cur.execute("INSERT INTO scores (spieler, punkte) VALUES (?, ?)", ("Leon", 820))
cur.execute("INSERT INTO scores (spieler, punkte) VALUES (?, ?)", ("Sara", 950))
conn.commit()

# WHERE filtert: nur Einträge mit mehr als 900 Punkten
print("Spieler mit über 900 Punkten:")
for row in cur.execute("SELECT spieler, punkte FROM scores WHERE punkte > 900"):
    print(f"  {row[0]}: {row[1]} Punkte")

conn.close()
# Ausgabe:
#   Mia: 1200 Punkte
#   Sara: 950 Punkte

Ergebnisse sortieren mit ORDER BY und begrenzen mit LIMIT:
Mit ORDER BY bestimmst du, in welcher Reihenfolge die Ergebnisse kommen. ASC steht für aufsteigend (kleinster Wert zuerst), DESC für absteigend (größter Wert zuerst). Mit LIMIT n gibst du an, wie viele Zeilen maximal zurückgeliefert werden sollen – praktisch für eine Top-Liste:

import sqlite3
conn = sqlite3.connect("highscores.db")
cur = conn.cursor()

# Alle Spieler – Bester zuerst
for row in cur.execute("SELECT spieler, punkte FROM scores ORDER BY punkte DESC"):
    print(f"  {row[0]}: {row[1]} Punkte")

# Nur die Top-2 anzeigen
print("\nTop 2:")
for row in cur.execute("SELECT spieler, punkte FROM scores ORDER BY punkte DESC LIMIT 2"):
    print(f"  {row[0]}: {row[1]} Punkte")

conn.close()

Aggregatfunktionen – Auswertungen über ganze Spalten:
SQL kann eine gesamte Spalte in einem einzigen Befehl auswerten. Das Ergebnis ist immer eine einzige Zahl, die alle Zeilen zusammenfasst:

• COUNT(*) – Anzahl aller gefundenen Zeilen.
• MAX(spalte) – Der größte Wert in der Spalte.
• MIN(spalte) – Der kleinste Wert.
• AVG(spalte) – Der Durchschnittswert.
• SUM(spalte) – Die Summe aller Werte.

import sqlite3
conn = sqlite3.connect("highscores.db")
cur = conn.cursor()

cur.execute("SELECT COUNT(*), MAX(punkte), MIN(punkte), AVG(punkte) FROM scores")
row = cur.fetchone()   # fetchone() holt genau eine Ergebniszeile zurück
print(f"Spieler gesamt:    {row[0]}")
print(f"Höchste Punkte:    {row[1]}")
print(f"Niedrigste Punkte: {row[2]}")
print(f"Durchschnitt:      {row[3]:.1f}")

conn.close()

Ergebnisse abrufen: fetchone() und fetchall():
Neben der for-Schleife gibt es zwei weitere Wege, Zeilen aus einer Abfrage zu holen:

• cur.fetchone() – Gibt genau eine Zeile zurück (oder None, wenn kein Treffer). Ideal, wenn du genau einen Eintrag erwartest.
• cur.fetchall() – Gibt alle verbleibenden Zeilen auf einmal als Liste von Tupeln zurück. Praktisch, wenn du die Ergebnisse mehrfach weiterverarbeiten willst.

import sqlite3
conn = sqlite3.connect("highscores.db")
cur = conn.cursor()

# fetchone: nur den Besten holen
cur.execute("SELECT spieler, punkte FROM scores ORDER BY punkte DESC")
bester = cur.fetchone()
print(f"Platz 1: {bester[0]} mit {bester[1]} Punkten")

# fetchall: alle Einträge als Liste
cur.execute("SELECT spieler, punkte FROM scores")
alle = cur.fetchall()    # z.B. [('Mia', 1200), ('Leon', 820), ('Sara', 950)]
print(f"{len(alle)} Spieler insgesamt.")
for spieler, punkte in alle:
    print(f"  {spieler}: {punkte}")

conn.close()

Was ist eine relationale Datenbank?
Bisher haben wir immer nur eine einzige Tabelle benutzt. Eine relationale Datenbank geht einen Schritt weiter: Sie besteht aus mehreren Tabellen, die miteinander verbunden sind. Das ist nützlich, wenn du zusammengehörige Daten sauber trennen willst – zum Beispiel Spieler in einer Tabelle und ihre Highscores in einer anderen.

Drei wichtige Begriffe:

• Primärschlüssel (Primary Key): Eine Spalte, deren Wert jede Zeile eindeutig identifiziert – so wie eine Schülernummer. Meistens heißt sie id und wird automatisch von SQLite vergeben.
• Fremdschlüssel (Foreign Key): Eine Spalte, die auf den Primärschlüssel einer anderen Tabelle zeigt. Dadurch werden die zwei Tabellen miteinander verknüpft.
• Beziehung: Die Verbindung zwischen zwei Tabellen über Primär- und Fremdschlüssel.

Beispiel: Spieler und ihre Highscores in zwei Tabellen
Die spieler_id in der Highscores-Tabelle verweist auf die id in der Spieler-Tabelle – das ist die Verbindung:

Tabelle: spieler                   Tabelle: highscores
+----+--------+                    +----+------------+-------+
| id | name   |                    | id | spieler_id | score |
+----+--------+                    +----+------------+-------+
| 1  | Mia    | <============+     | 1  | 1          | 950   |  -- Gehört Mia (id 1)
| 2  | Leon   | <=========+  |     | 2  | 2          | 820   |  -- Gehört Leon (id 2)
+----+--------+           |  +==== | 3  | 1          | 1200  |  -- Gehört auch Mia
                          +======= | 4  | 2          | 750   |  -- Gehört auch Leon

So kann Mia beliebig viele Highscores haben, ohne dass ihr Name mehrfach in der Spieler-Tabelle gespeichert werden muss. Das spart Platz und verhindert Fehler.

Tabellen verbinden mit JOIN:
Mit JOIN kannst du zwei Tabellen in einer einzigen Abfrage kombinieren – du bekommst Zeilen zurück, die Daten aus beiden Tabellen zusammenführen. Das ON dahinter legt fest, über welche Spalten die Verbindung hergestellt wird:

import sqlite3
conn = sqlite3.connect("game.db")
cur = conn.cursor()

cur.execute("CREATE TABLE IF NOT EXISTS spieler (id INTEGER PRIMARY KEY, name TEXT)")
cur.execute("CREATE TABLE IF NOT EXISTS highscores (id INTEGER PRIMARY KEY, spieler_id INTEGER, score INTEGER)")

cur.execute("INSERT INTO spieler (name) VALUES (?)", ("Mia",))
cur.execute("INSERT INTO spieler (name) VALUES (?)", ("Leon",))
cur.execute("INSERT INTO highscores (spieler_id, score) VALUES (?, ?)", (1, 950))
cur.execute("INSERT INTO highscores (spieler_id, score) VALUES (?, ?)", (2, 820))
cur.execute("INSERT INTO highscores (spieler_id, score) VALUES (?, ?)", (1, 1200))
conn.commit()

# JOIN: Spielernamen aus 'spieler' mit Scores aus 'highscores' verknüpfen
for row in cur.execute("""
    SELECT spieler.name, highscores.score
    FROM highscores
    JOIN spieler ON highscores.spieler_id = spieler.id
    ORDER BY highscores.score DESC
"""):
    print(f"  {row[0]}: {row[1]} Punkte")
# Ausgabe:
#   Mia: 1200 Punkte
#   Mia:  950 Punkte
#   Leon: 820 Punkte

conn.close()

Daten aktualisieren mit UPDATE:
Mit UPDATE kannst du bestehende Einträge verändern. Kombiniere es immer mit WHERE, sonst werden alle Zeilen geändert!

import sqlite3
conn = sqlite3.connect("spiele.db")
cur = conn.cursor()

# Punktzahl von Mia auf 1500 setzen
cur.execute("UPDATE scores SET punkte = 1500 WHERE spieler = ?", ("Mia",))
conn.commit()
conn.close()

Einträge löschen mit DELETE:
Mit DELETE FROM entfernst du Zeilen aus einer Tabelle. Auch hier immer WHERE angeben, sonst wird die gesamte Tabelle geleert!

import sqlite3
conn = sqlite3.connect("spiele.db")
cur = conn.cursor()

# Nur den Eintrag von Leon löschen
cur.execute("DELETE FROM scores WHERE spieler = ?", ("Leon",))
conn.commit()
conn.close()

Weiterführende Informationen: W3Schools – Python SQLite

Exkurs: MariaDB – Datenbanken auf dem Server

SQLite ist ideal zum Lernen und für kleine Projekte – aber in der echten Welt laufen Datenbanken meistens auf einem Server. Das bekannteste System dafür ist MariaDB (eine offene, kostenlose Weiterentwicklung von MySQL). Es wird in Millionen von Webseiten, Apps und Unternehmensanwendungen eingesetzt – zum Beispiel hinter WordPress, Wikipedia oder vielen Online-Shops.

SQLite vs. MariaDB – wann nimmt man was?

Merkmal              SQLite                    MariaDB
──────────────────────────────────────────────────────────────
Speicherort          Eine Datei (.db)          Läuft als Server-Prozess
Installation         Nichts nötig (in Python)  Server + Python-Paket nötig
Mehrere Nutzer       Nein (nur ein Zugriff)    Ja (viele gleichzeitig)
Benutzerverwaltung   Keine                     Benutzer & Rechte
Einsatzgebiet        Lernen, kleine Projekte   Web-Apps, Produktionssysteme
Python-Platzhalter   ?                         %s

MariaDB installieren – je nach Betriebssystem:
MariaDB läuft als eigenständiger Server-Prozess auf deinem Computer. Die Installation unterscheidet sich je nach System:

• Windows: Lade den offiziellen Installer von mariadb.org/download herunter. Beim Setup kannst du ein Root-Passwort festlegen. Nach der Installation läuft MariaDB als Windows-Dienst automatisch im Hintergrund.
• macOS: Am einfachsten über den Paketmanager Homebrew:
  brew install mariadb – danach mit brew services start mariadb starten. Alternativ gibt es auch einen offiziellen macOS-Installer auf mariadb.org.
• Linux (Debian/Ubuntu): Über den Paketmanager:
  sudo apt install mariadb-server – der Server startet danach automatisch. Mit sudo mariadb-secure-installation kannst du ein Root-Passwort setzen.

Prüfe danach im Terminal, ob der Server läuft: mariadb --version bzw. mysql --version sollte eine Versionsnummer ausgeben.

Den Python-Connector installieren:
Python kann nicht direkt mit MariaDB sprechen – du brauchst ein zusätzliches Paket. Installiere es einmalig im Terminal (auf allen Betriebssystemen gleich):

pip install mysql-connector-python

Verbindung herstellen:
Im Gegensatz zu SQLite (wo du einfach einen Dateinamen angibst) musst du bei MariaDB Serveradresse, Benutzername, Passwort und Datenbankname angeben. Wenn MariaDB lokal läuft und du beim Setup ein Root-Passwort gesetzt hast, trägst du es bei password ein:

import mysql.connector

conn = mysql.connector.connect(
    host="localhost",         # lokaler Server: immer "localhost"
    user="root",              # Standardbenutzer (bei eigener Installation)
    password="dein_passwort", # das beim Setup gewählte Passwort
    database="tutorial"       # Datenbankname – muss vorher angelegt werden!
)
cur = conn.cursor()
print("Verbindung erfolgreich!")

Datenbank anlegen (einmalig):
Bevor du dich mit einer Datenbank verbinden kannst, muss sie existieren. Das geht entweder direkt im MariaDB-Terminal (mariadb -u root -p, dann CREATE DATABASE tutorial;) oder bequem per Python-Code – verbinde dich dazu ohne database-Parameter:

import mysql.connector

# Erst ohne database verbinden, dann anlegen
conn = mysql.connector.connect(host="localhost", user="root", password="dein_passwort")
cur = conn.cursor()
cur.execute("CREATE DATABASE IF NOT EXISTS tutorial")
print("Datenbank 'tutorial' bereit.")
conn.close()

Der wichtigste Unterschied zu SQLite: %s statt ?
Der Platzhalter für Werte heißt bei MariaDB/MySQL %s statt ? – das ist die einzige große Änderung im Code. Alles andere (Tabellen erstellen, INSERT, SELECT, WHERE, JOIN) funktioniert mit denselben SQL-Befehlen wie bei SQLite:

# SQLite:   cur.execute("INSERT INTO t (name) VALUES (?)", ("Mia",))
# MariaDB:  cur.execute("INSERT INTO t (name) VALUES (%s)", ("Mia",))

Vollständiges Beispiel – Highscore-Tabelle mit MariaDB:

import mysql.connector

conn = mysql.connector.connect(
    host="localhost", user="root", password="", database="tutorial"
)
cur = conn.cursor()

# Tabelle anlegen
cur.execute("""
    CREATE TABLE IF NOT EXISTS scores (
        id      INTEGER PRIMARY KEY AUTO_INCREMENT,
        spieler TEXT    NOT NULL,
        punkte  INTEGER NOT NULL
    )
""")

# Einträge hinzufügen – Platzhalter ist %s, nicht ?
spieler = [("Mia", 1200), ("Leon", 820), ("Sara", 950)]
cur.executemany("INSERT INTO scores (spieler, punkte) VALUES (%s, %s)", spieler)
conn.commit()

# Alle Spieler – bester zuerst
print("Highscore-Liste:")
cur.execute("SELECT spieler, punkte FROM scores ORDER BY punkte DESC")
for row in cur.fetchall():
    print(f"  {row[0]}: {row[1]} Punkte")

# Aggregatfunktionen
cur.execute("SELECT COUNT(*), MAX(punkte), AVG(punkte) FROM scores")
row = cur.fetchone()
print(f"\nSpieler: {row[0]}, Höchste: {row[1]}, Durchschnitt: {row[2]:.1f}")

conn.close()

executemany() – mehrere Zeilen auf einmal einfügen:
Statt execute() mehrfach aufzurufen, kannst du mit executemany() eine Liste von Tupeln auf einmal übergeben. Das ist kürzer und schneller, wenn du viele Zeilen einfügen willst.

AUTO_INCREMENT statt INTEGER PRIMARY KEY:
Bei MariaDB heißt die automatische ID-Vergabe AUTO_INCREMENT (statt SQLites automatischer Zählweise). Das Ergebnis ist dasselbe: jede neue Zeile bekommt automatisch eine eindeutige Nummer.

Typische Stolpersteine beim Umstieg von SQLite auf MariaDB:

• %s statt ? als Platzhalter – der häufigste Fehler.
• Die Datenbank muss vorher angelegt worden sein – SQLite erstellt die Datei automatisch, MariaDB nicht.
• Der Server muss laufen – wenn XAMPP gestoppt ist, schlägt die Verbindung sofort fehl.
• AUTO_INCREMENT statt implizitem Primärschlüssel bei SQLite.

Weiterführende Informationen: W3Schools – MySQL/MariaDB Tutorial