1. Einführung in Python

Einführung in Python

Die Programmiersprache dieses Schuljahres ist Python. Dieses Kapitel legt die Basis: Es richtet die Werkzeuge ein und behandelt die Grundkonstrukte der Sprache, also Variablen, Datentypen, Verzweigungen, Schleifen, Funktionen, Listen und Dictionaries. Wer diese Konzepte bereits aus einer anderen Programmiersprache kennt, liest das Kapitel als kompakte Wiederholung in neuer Syntax; wer sie noch nicht sicher beherrscht, findet hier alles, was die folgenden Kapitel voraussetzen.

Programmierkonzepte sind sprachunabhängig. Eine Verzweigung, eine Schleife oder eine Funktion funktioniert in jeder Sprache nach demselben Prinzip, nur die Schreibweise unterscheidet sich. Es lohnt sich daher, beim Lernen zwischen dem Konzept und seiner Python-Schreibweise zu unterscheiden. Diese Trennung zahlt sich spätestens dann aus, wenn Sie im Berufsleben die nächste Sprache lernen.

Warum Python?

Python zählt seit Jahren zu den meistverwendeten Programmiersprachen. Für den Unterricht sprechen drei praktische Gründe dafür:

• Die Syntax ist knapp und gut lesbar. Python-Programme kommen mit wenig Sonderzeichen aus und lassen sich fast wie englischer Text lesen.
• Python läuft direkt am Rechner. Ein Programm ist eine einzelne Textdatei, die im Terminal gestartet wird; es braucht weder Browser noch Projektgerüst.
• Das Ökosystem ist umfangreich. Für Bildbearbeitung, Datenanalyse, Automatisierung und maschinelles Lernen existieren fertige Bibliotheken. In der Medientechnik dient Python außerdem als Skriptsprache in Programmen wie Blender, GIMP und Krita.

Werkzeuge einrichten

1. Python installieren. Laden Sie die aktuelle Version 3.x von python.org herunter. Unter Windows beim Installieren das Häkchen bei “Add python.exe to PATH” setzen, sonst findet das Terminal Python später nicht. Unter Linux ist Python meist vorinstalliert.

2. Installation prüfen. Öffnen Sie ein Terminal und führen Sie aus:

   python --version

   Erwartete Ausgabe: Python 3.12.x oder neuer. Auf manchen Systemen heißt der Befehl python3.

3. VS Code vorbereiten. Installieren Sie in VS Code die Erweiterung Python von Microsoft. Sie liefert Syntaxhervorhebung, Autovervollständigung und einen Ausführen-Knopf.

4. Erstes Skript ausführen. Legen Sie eine Datei hello.py an:

   name = input("What is your name? ")
   print(f"Hello, {name}!")

   Ausführen im Terminal mit python hello.py oder über den Ausführen-Knopf in VS Code.

input() liest eine Zeile von der Tastatur, print() schreibt ins Terminal. Damit sind Ein- und Ausgabe für Konsolenprogramme bereits vollständig abgedeckt.

Skripte unter Linux und WSL direkt ausführbar machen

Unter Linux (und in der WSL, dem Windows Subsystem for Linux) lässt sich ein Python-Skript wie ein eigenständiges Programm starten, ohne python davor zu tippen. Dazu braucht es zwei Dinge: eine Shebang-Zeile als allererste Zeile der Datei und das Ausführungsrecht.

#!/usr/bin/env python3

name = input("What is your name? ")
print(f"Hello, {name}!")

chmod +x hello.py       # grant execute permission (needed once)
./hello.py              # run it like any other program

Die Zeile #!/usr/bin/env python3 (gesprochen “Shebang”, von sharp + bang für #!) teilt dem Betriebssystem mit, welcher Interpreter die Datei ausführen soll. Der Umweg über env hat einen Grund: Statt einen festen Pfad wie /usr/bin/python3 einzubrennen, sucht env den Interpreter über die PATH-Variable. Das Skript läuft damit auch dort, wo Python woanders installiert ist, etwa in einer virtuellen Umgebung. Zwei Regeln dazu: Die Shebang-Zeile muss wirklich Zeile 1 sein (davor darf nicht einmal eine Leerzeile stehen), und für Python selbst ist sie ein gewöhnlicher Kommentar; unter Windows ohne WSL wird sie schlicht ignoriert, das Skript bleibt also überall lauffähig. Nach diesem Muster funktionieren übrigens die meisten Kommandozeilenwerkzeuge unter Linux; viele davon sind nichts anderes als Python-Skripte mit Shebang.

Die REPL: Ausdrücke interaktiv testen

Der Befehl python ohne Dateinamen startet die REPL (Read-Eval-Print-Loop), eine interaktive Umgebung: Sie geben einen Ausdruck ein, Python wertet ihn sofort aus und zeigt das Ergebnis.

>>> 2 ** 10
1024
>>> "ab" * 3
'ababab'
>>> len("media")
5
>>> 7 / 2
3.5
>>> 7 // 2
3

Die REPL eignet sich, um Sprachdetails zu klären, bevor sie in ein Skript übernommen werden: Was liefert "abc".upper()? Welchen Typ hat 7 / 2? Solche Fragen beantwortet ein Versuch in der REPL schneller als jede Suche. Verlassen wird sie mit exit() oder Strg+D (Windows: Strg+Z und Enter).

In den Beispielen dieses Skriptums kennzeichnet der Prompt >>> Eingaben in der REPL; Zeilen ohne Prompt sind die Ausgabe von Python.

IPython: die bessere REPL

Wer viel in der REPL arbeitet, installiert sich mit pip install ipython die erweiterte Variante IPython (Start mit dem Befehl ipython). Sie bietet Syntaxhervorhebung, komfortable Autovervollständigung mit der Tabulatortaste, eine durchsuchbare Eingabehistorie über Sitzungen hinweg und eingebaute Hilfen: len? zeigt die Dokumentation einer Funktion, %timeit expression misst Laufzeiten. Die Standard-REPL bleibt für schnelle Tests völlig ausreichend; IPython lohnt sich, sobald die Experimente länger werden. Dieselbe Technik steckt übrigens hinter Jupyter-Notebooks, die Ihnen in Datenanalyse-Kontexten begegnen werden.

Variablen und Datentypen

Eine Variable entsteht in Python durch die erste Zuweisung. Eine Deklaration mit Schlüsselwort oder Typangabe gibt es nicht:

age = 16
price = 19.90
name = "Ada"
is_valid = True
result = None

Der Datentyp hängt am Wert, nicht an der Variablen (dynamische Typisierung). Die wichtigsten Grundtypen:

Typ	Bedeutung	Beispiele
int	Ganzzahl	42, -3, 2 ** 100
float	Gleitkommazahl	3.14, -0.5
str	Zeichenkette	"Hello", 'a'
bool	Wahrheitswert	True, False
NoneType	”kein Wert”	None

Drei Punkte verdienen Beachtung:

• Python unterscheidet Ganzzahlen (int) und Kommazahlen (float). Ganzzahlen sind dabei beliebig groß: 2 ** 1000 liefert ein exaktes Ergebnis mit 302 Stellen.
• Die Wahrheitswerte schreiben sich groß: True und False.
• None steht für die Abwesenheit eines Wertes, etwa als Ergebnis einer Funktion, die nichts zurückgibt.

Den Typ eines Wertes ermittelt die Funktion type(), Umwandlungen erledigen int(), float() und str():

>>> type(7 / 2)
<class 'float'>
>>> int("42") + 1
43
>>> float("3.5") * 2
7.0

Konstanten im strengen Sinn kennt Python nicht. Per Konvention werden Variablen, die nicht verändert werden sollen, in Großbuchstaben geschrieben, etwa VAT_RATE = 0.20. Die Einhaltung dieser Vereinbarung prüft niemand automatisch; sie ist Teil der Programmierdisziplin.

Namenskonventionen

Der offizielle Stil-Leitfaden PEP 8 legt die Schreibweisen fest: Variablen und Funktionen in snake_case (Kleinbuchstaben, Wörter durch Unterstriche getrennt, etwa frame_count oder calculate_area), Konstanten in UPPER_CASE, Klassennamen in PascalCase. Halten Sie diese Konventionen von Anfang an ein; sie sind in der Python-Welt verbindlicher Standard und werden auch bei der Beurteilung von Abgaben berücksichtigt.

In diesem Unterricht gilt zusätzlich: Bezeichner und Kommentare werden auf Englisch geschrieben. Das entspricht der Praxis in praktisch allen professionellen Projekten.

Namenskonventionen sind der Anfang eines größeren Themas: Zu fast jedem Konstrukt dieses Kapitels gibt es eine Schreibweise, die in der Python-Welt als die übliche gilt. Was eine Lösung in diesem Sinn pythonic macht, sammelt Anhang A als Nachschlagewerk.

Operatoren

Die Grundrechenarten entsprechen der üblichen Mathematik-Notation. Zusätzlich gibt es einige Operatoren, die gerne übersehen werden:

Operator	Bedeutung	Beispiel	Ergebnis
/	Division (immer float)	7 / 2	3.5
//	Ganzzahldivision	7 // 2	3
%	Rest (Modulo)	7 % 2	1
**	Potenz	2 ** 8	256
== / !=	gleich / ungleich	1 == "1"	False
< <= > >=	Vergleiche	3 <= 3	True
and / or / not	logische Verknüpfung	not False	True

Ein Inkrement-Operator ++ existiert nicht; Zähler werden mit count += 1 erhöht. Die logischen Operatoren sind ausgeschriebene Wörter, was Bedingungen gut lesbar macht:

if age >= 16 and not is_member:
    print("Regular ticket required.")

Vergleiche liefern immer einen bool, und == vergleicht ohne versteckte Typumwandlung: 1 == "1" ist False, weil Zahl und String verschiedene Typen sind.

Einrückung ist Syntax

Python gruppiert zusammengehörige Anweisungen nicht mit Klammern, sondern über die Einrückung. Ein Doppelpunkt eröffnet einen Block, alle gleich weit eingerückten Zeilen darunter gehören dazu, die erste wieder ausgerückte Zeile beendet ihn:

if age >= 18:
    print("adult")
    print("allowed to vote")
print("this line always runs")

Üblich sind 4 Leerzeichen pro Ebene; VS Code setzt das automatisch um. Das Mischen von Tabulatoren und Leerzeichen führt zu einem IndentationError. Die Konsequenz dieser Regel: Die sichtbare Struktur des Codes und seine tatsächliche Struktur stimmen in Python zwangsläufig überein. Falsch eingerückter Code läuft entweder gar nicht oder tut sichtbar etwas anderes als beabsichtigt.

Verzweigungen

if grade == 1:
    print("Sehr gut")
elif grade == 2:
    print("Gut")
elif grade in (3, 4):
    print("Bestanden")
else:
    print("Nicht genügend")

Mehrfachverzweigungen verwenden das Schlüsselwort elif. Die Bedingung benötigt keine Klammern. Der Operator in prüft, ob ein Wert in einer Aufzählung oder Liste enthalten ist, und ersetzt Ketten aus or-Vergleichen.

Schleifen

Die while-Schleife wiederholt, solange eine Bedingung gilt:

attempts = 0
while attempts < 3:
    print(f"attempt {attempts + 1}")
    attempts += 1

Die for-Schleife iteriert über eine Sequenz. Für Zahlenfolgen liefert range() diese Sequenz:

for i in range(5):
    print(i)            # 0, 1, 2, 3, 4

colors = ["red", "green", "blue"]
for color in colors:
    print(color)

range(5) zählt von 0 bis 4; die Obergrenze ist nicht enthalten. range(1, 11) zählt 1 bis 10, range(10, 0, -1) rückwärts von 10 bis 1. Werden Index und Wert gemeinsam benötigt, liefert enumerate() beides:

for i, color in enumerate(colors):
    print(f"{i}: {color}")

break verlässt die Schleife vorzeitig, continue springt zum nächsten Durchlauf. Beide sollten sparsam eingesetzt werden, weil sie den Kontrollfluss schwerer nachvollziehbar machen.

Funktionen

Funktionen bündeln Anweisungen unter einem Namen, nehmen Parameter entgegen und liefern mit return ein Ergebnis:

def rectangle_area(width, height):
    """Return the area of a rectangle."""
    return width * height


def greet(name="guest"):
    return f"Hello, {name}!"


print(rectangle_area(4, 3))     # 12
print(greet())                  # Hello, guest!
print(greet("Ada"))             # Hello, Ada!

Der String direkt unter der def-Zeile ist ein Docstring, die eingebaute Kurzbeschreibung einer Funktion. Werkzeuge wie die REPL (help(rectangle_area)) und VS Code zeigen ihn an. Ab sofort gilt: Jede nicht triviale Funktion bekommt einen Docstring.

Nicht jede Funktion liefert ein Ergebnis. Manche tun einfach etwas (etwas ausgeben, eine Datei schreiben, eine Liste verändern); andere Sprachen nennen so etwas eine Prozedur, Python macht keinen formalen Unterschied:

def print_header(title):
    """Print a section header to the terminal."""
    print("=" * 40)
    print(title)
    print("=" * 40)

Eine Funktion ohne return liefert automatisch den Wert None; result = print_header("Report") ist also erlaubt, result ist danach aber None, ein beliebter versteckter Fehler. Ein nacktes return ohne Wert ist ebenfalls zulässig und beendet die Funktion vorzeitig, etwa um einen Sonderfall früh abzuhandeln.

Parameter können Standardwerte haben (name="guest"). Beim Aufruf dürfen Argumente benannt werden, was bei mehreren Parametern die Lesbarkeit deutlich verbessert:

def scale(width, height, factor=1.0, keep_aspect_ratio=True):
    ...

scale(1920, 1080, factor=0.5)

Weiterführend: Type Hints

Python prüft Typen erst zur Laufzeit, aber die Sprache erlaubt es, die erwarteten Typen zu notieren. Diese Type Hints stehen mit Doppelpunkt hinter Parametern und Variablen, der Rückgabetyp nach einem Pfeil:

def frames_to_seconds(frames: int, fps: int = 25) -> float:
    return frames / fps


max_attempts: int = 3
names: list[str] = ["intro", "main", "outro"]

Zwei Dinge muss man dazu wissen. Erstens:

1. Python erzwingt die Hints nicht. Der Aufruf frames_to_seconds("abc") wird nicht von der Sprache abgefangen; die Annotation ist zunächst nur Dokumentation.
2. Werkzeuge nehmen die Hints sehr wohl ernst. VS Code liefert damit präzisere Autovervollständigung und markiert Typfehler bereits beim Tippen, und eigenständige Prüfer wie mypy machen aus den Hints eine echte statische Typprüfung, vor dem Programmlauf.

Einen Schritt weiter geht die Bibliothek pydantic: Sie nutzt die Hints zur Laufzeit und prüft damit echte Daten, etwa eingelesenes JSON, gegen die annotierte Struktur; unpassende Werte werden abgelehnt statt still übernommen. Pydantic ist der De-facto-Standard für Datenvalidierung in Python (unter anderem baut das Web-Framework FastAPI darauf auf). In professionellen Python-Projekten sind Type Hints deshalb heute weit verbreitet, und Sie werden ihnen in jeder Bibliotheksdokumentation begegnen (sorted(iterable, key=...) und Co. sind so dokumentiert).

In den Beispielen dieses Skriptums verzichten wir aus Gründen der Kompaktheit meist auf Hints; in eigenen Projekten dürfen Sie sie jederzeit verwenden, und spätestens bei größeren Programmen mit mehreren Modulen zahlen sie sich aus.

Listen

Die Liste ist die wichtigste Datenstruktur in Python: eine geordnete, veränderbare Sammlung von Werten. Sie ist Pythons Antwort auf das, was in anderen Programmiersprachen Array heißt (etwa in C, Java oder JavaScript), mit zwei Unterschieden zum klassischen Array: Eine Liste wächst und schrumpft dynamisch (keine feste Größe bei der Erzeugung), und sie darf Werte verschiedener Typen mischen. Wer aus einer anderen Sprache kommt, kann also überall dort zur Liste greifen, wo dort ein Array stünde; die Konzepte Indexzugriff, Länge und Durchlaufen per Schleife übertragen sich eins zu eins. Echte Arrays mit festem Elementtyp existieren in Python auch (das Modul array, für numerische Berechnungen die Bibliothek NumPy), spielen im Alltag aber erst bei großen Datenmengen eine Rolle.

durations = [240, 180, 320]

durations.append(150)       # append at the end
durations[0]                # 240 (first element)
durations[-1]               # 150 (last element)
len(durations)              # 4
320 in durations            # True
durations.sort()            # sort in place

Der Zugriff über eckige Klammern beginnt bei Index 0. Negative Indizes zählen vom Ende: [-1] ist das letzte Element, [-2] das vorletzte. Slicing schneidet Teilbereiche heraus, wobei die Obergrenze nicht enthalten ist:

>>> values = [10, 20, 30, 40, 50]
>>> values[1:3]
[20, 30]
>>> values[:2]
[10, 20]
>>> values[2:]
[30, 40, 50]

Slicing funktioniert auch mit Strings, was bei Dateinamen regelmäßig nützlich ist:

>>> filename = "preview_final_v2.png"
>>> filename[-4:]
'.png'

List Comprehensions

Für das häufigste Listen-Muster überhaupt, eine neue Liste aus einer bestehenden Sequenz zu bauen, hat Python eine eigene Kurzschreibweise. Der klassische Weg führt über Schleife und append:

squares = []
for x in range(1, 11):
    squares.append(x * x)

Die List Comprehension drückt dasselbe in einer Zeile aus:

squares = [x * x for x in range(1, 11)]

Gelesen wird sie fast wie ein Satz: “die Liste aller x * x für x von 1 bis 10”. Mit einem angehängten if wird zusätzlich gefiltert:

>>> durations = [240, 180, 320, 45, 150]
>>> [d for d in durations if d >= 180]
[240, 180, 320]
>>> names = ["intro", "MAIN", "Outro"]
>>> [name.lower() for name in names]
['intro', 'main', 'outro']

Der allgemeine Aufbau lautet [ausdruck for element in sequenz if bedingung], wobei der if-Teil optional ist. Comprehensions sind in Python allgegenwärtig und gelten als guter Stil, solange sie auf einen Blick lesbar bleiben; sobald mehrere Bedingungen oder Verschachtelungen nötig werden, ist die ausgeschriebene Schleife die bessere Wahl (siehe auch Anhang A).

Tupel

Neben der Liste kennt Python eine zweite Sequenz, die außerhalb der Python-Welt kaum ein Gegenstück hat: das Tupel. Es wird mit runden Klammern geschrieben und verhält sich beim Lesen wie eine Liste, ist aber unveränderbar (immutable). Nach der Erzeugung lässt sich kein Element mehr austauschen, hinzufügen oder entfernen:

>>> resolution = (1920, 1080)
>>> resolution[0]
1920
>>> len(resolution)
2
>>> resolution[0] = 1280
TypeError: 'tuple' object does not support item assignment

Das klingt zunächst nach einer Einschränkung, ist aber der eigentliche Zweck: Ein Tupel signalisiert “diese Werte gehören als Einheit zusammen und ändern sich nicht”. Eine Bildschirmauflösung, ein Koordinatenpaar oder ein RGB-Farbwert sind genau das; eine Liste von Songdauern dagegen nicht.

Tupel begegnen einem in Python ständig, oft ohne dass die Klammern sichtbar sind. Drei Stellen sind besonders wichtig:

Mehrere Rückgabewerte. Andere Sprachen brauchen dafür ein eigenes Objekt oder Zeiger-Parameter. Eine Python-Funktion gibt einfach mehrere Werte durch Komma getrennt zurück; technisch ist das ein Tupel:

def split_timecode(total_seconds):
    return total_seconds // 60, total_seconds % 60


minutes, seconds = split_timecode(355)      # 5, 55

Unpacking. Die letzte Zeile oben verteilt die Elemente eines Tupels in einem Schritt auf mehrere Variablen. Dasselbe Prinzip steckt hinter der Schleife über ein Dictionary (for key, value in song.items()) und hinter enumerate(), das bei jedem Durchlauf ein Paar aus Index und Wert liefert:

for index, name in enumerate(["intro", "main", "outro"]):
    print(f"{index}: {name}")

Auch der Tausch zweier Variablen kommt so ohne Hilfsvariable aus, weil rechts vom Gleichheitszeichen zuerst ein Tupel gebildet wird:

a, b = b, a

Schlüssel in Dictionaries. Weil ein Tupel unveränderbar ist, darf es als Schlüssel dienen, eine Liste nicht. Ein Sitzplan lässt sich damit direkt über das Koordinatenpaar adressieren:

seats = {(1, 3): "Ada", (2, 7): "Linus"}
seats[(1, 3)]               # 'Ada'

Zwei Stolperfallen zum Schluss. Ein Tupel mit einem Element braucht ein nachgestelltes Komma, sonst sind die Klammern nur eine gewöhnliche Klammerung: (5,) ist ein Tupel, (5) ist die Zahl 5. Und die Klammern sind beim Erzeugen oft optional, point = 3, 4 ergibt ebenfalls ein Tupel; ausgeschrieben liest sich der Code aber meist klarer.

Dictionaries

Ein Dictionary speichert Paare aus Schlüssel und Wert und bildet damit strukturierte Datensätze ab. Diese Datenstruktur existiert unter vielen Namen in praktisch jeder Sprache: Map in Java und C++ (HashMap, std::map), assoziatives Array in PHP, Hash in Ruby, Object beziehungsweise Map in JavaScript. Gemeint ist immer dasselbe Konzept: Statt über eine Position (Index 0, 1, 2, …) wird über einen frei gewählten Schlüssel zugegriffen, typischerweise einen String. Intern steckt dahinter eine Hashtabelle, weshalb der Zugriff auch bei tausenden Einträgen praktisch ohne Suchaufwand funktioniert.

song = {
    "title": "Bohemian Rhapsody",
    "duration": 355,
}

song["title"]               # access by key
song["year"] = 1975         # add a new key
"year" in song              # True

for key, value in song.items():
    print(f"{key}: {value}")

Der Zugriff auf einen nicht vorhandenen Schlüssel löst einen Fehler aus (KeyError); die Methode song.get("genre") liefert stattdessen None. Listen von Dictionaries sind das Standardmuster für tabellenartige Daten, etwa eine Liste von Songs mit jeweils Titel und Dauer. Dieses Muster wird uns beim Thema Dateien und Datenformate wieder begegnen.

f-Strings: formatierte Ausgabe

Ein f vor dem String erlaubt eingebettete Ausdrücke in geschweiften Klammern:

name = "Ada"
age = 16
print(f"{name} is {age} years old.")

In den Klammern darf jeder Ausdruck stehen, auch Rechnungen und Funktionsaufrufe. Zusätzlich beherrschen f-Strings Formatangaben nach einem Doppelpunkt:

price = 7.5
index = 7
print(f"{price:.2f}")       # 7.50   (two decimal places)
print(f"{index:03d}")       # 007    (zero-padded to three digits)

Gerade die Auffüllung mit Nullen ist im Medienbereich häufig gefragt, etwa für nummerierte Einzelbilder (frame_007.png).

Weiterführend: die Format-Mini-Sprache

Die Angaben nach dem Doppelpunkt sind eine eigene kleine Formatsprache mit dem Aufbau [Füllzeichen][Ausrichtung][Breite][,][.Präzision][Typ]. Die wichtigsten Möglichkeiten im Überblick, jeweils in der REPL nachvollziehbar:

Angabe	Beispiel	Ergebnis	Bedeutung
<	f"{'ok':<8}|"	ok |	linksbündig auf Breite 8
>	f"{'ok':>8}|"	ok|	rechtsbündig
^	f"{'ok':^8}|"	ok |	zentriert
Füllzeichen	f"{'ok':.^8}"	...ok...	beliebiges Zeichen vor der Ausrichtung
,	f"{1920 * 1080:,}"	2,073,600	Tausendertrennzeichen
.3f	f"{1 / 3:.3f}"	0.333	Gleitkommazahl, 3 Nachkommastellen
%	f"{0.756:.1%}"	75.6%	als Prozentwert
e	f"{48000:.2e}"	4.80e+04	wissenschaftliche Notation
x / X	f"{255:x}"	ff	hexadezimal (klein/groß)
#x	f"{255:#x}"	0xff	hexadezimal mit Präfix
b / o	f"{255:08b}"	11111111	binär (hier: 8 Stellen) / oktal
+	f"{5:+d}"	+5	Vorzeichen immer anzeigen
=	f"{value=}"	value=42	Ausdruck samt Ergebnis (praktisch beim Debuggen)

Für die Medientechnik sind einige davon alte Bekannte in neuem Gewand: Hexadezimal ist die Schreibweise von Farbwerten (#ff8800 sind die Kanäle 255, 136, 0), rechtsbündige Breitenangaben erzeugen saubere Tabellenspalten in Konsolenausgaben, und {value=} erspart beim Debuggen das ewige print("value:", value). Die Angaben lassen sich kombinieren, etwa f"{price:>10,.2f}" für eine rechtsbündige Geldspalte mit Tausenderpunkt und zwei Nachkommastellen. Die vollständige Referenz findet sich in der Python-Dokumentation unter dem Stichwort Format Specification Mini-Language; dieses Kapitel verlangt nur :.2f und :03d aktiv, der Rest ist Nachschlagewissen.

Ein vollständiges Beispiel: Timecode-Berechnung

In der Videotechnik werden Positionen als Timecode HH:MM:SS:FF angegeben; FF ist dabei die Nummer des Einzelbilds (Frame) innerhalb der Sekunde. Das folgende Programm rechnet eine absolute Framenummer in einen Timecode um und kombiniert dabei die Bausteine dieses Kapitels:

def frames_to_timecode(frames, fps=25):
    """Convert an absolute frame number to a timecode HH:MM:SS:FF."""
    total_seconds = frames // fps
    remaining_frames = frames % fps
    hours = total_seconds // 3600
    minutes = (total_seconds % 3600) // 60
    seconds = total_seconds % 60
    return f"{hours:02d}:{minutes:02d}:{seconds:02d}:{remaining_frames:02d}"


user_input = input("Frame number: ")
frames = int(user_input)

if frames < 0:
    print("A negative frame number is not valid.")
else:
    print(f"Frame {frames} corresponds to {frames_to_timecode(frames)}")

Beobachtungen dazu:

• input() liefert immer einen String. Für Berechnungen muss int() (oder float()) den Text in eine Zahl umwandeln.
• Ganzzahldivision // und Rest % zerlegen die Gesamtzahl schrittweise in Stunden, Minuten, Sekunden und Frames. Dieses Muster taucht bei jeder Einheitenumrechnung auf.
• Die Formatangabe :02d erzeugt zweistellige Ausgabe mit führender Null.

Zur Kontrolle: Frame 90061 ergibt bei 25 fps den Timecode 01:00:02:11.

Häufige Fehlerquellen

Diese Fehler treten in den ersten Wochen erfahrungsgemäß am häufigsten auf:

1. input() liefert Strings. input("Number: ") * 2 verdoppelt nicht die Zahl, sondern den Text: aus "7" wird "77". Umwandlung mit int() nicht vergessen.
2. Groß- und Kleinschreibung. True, False und None beginnen mit Großbuchstaben; true ist ein NameError.
3. Der Doppelpunkt fehlt. Jede Zeile, die einen Block eröffnet (if, elif, else, for, while, def), endet mit :.
4. Uneinheitliche Einrückung. Kopierter Code bringt manchmal Tabulatoren mit, während die eigene Datei Leerzeichen verwendet. Die Fehlermeldung lautet IndentationError oder TabError.
5. = und == verwechselt. = weist zu, == vergleicht. if x = 5: ist in Python immerhin ein Syntaxfehler und fällt damit sofort auf.
6. len ist eine Funktion. Die Länge einer Liste oder eines Strings liefert len(values), nicht values.length.

Arbeitsweise für dieses Schuljahr

Testen Sie jedes Codebeispiel dieses Kapitels selbst in der REPL oder als Skript. Programmieren lernt man nicht durch Lesen, sondern durch Schreiben, Ausführen und Korrigieren. Die Aufgabe 01 (Spickzettel) systematisiert genau das: Jedes Konstrukt wird einmal selbst getippt, getestet und dokumentiert.

Wie es weitergeht: guter Python-Stil

Mit den Konstrukten dieses Kapitels lässt sich jedes Programm des Schuljahres schreiben. Wie man sie so einsetzt, dass der Code kurz, lesbar und für andere Python-Entwickler sofort verständlich ist, behandeln zwei Anhänge dieses Jahrgangs, die als ständige Begleiter gedacht sind:

• Anhang A: Was heißt “pythonic”? stellt für die häufigsten Muster die umständliche und die idiomatische Schreibweise gegenüber, vom Iterieren über Listen bis zum Öffnen von Dateien. Nützlich als Checkliste vor jeder Abgabe.
• Anhang B: The Zen of Python erklärt die Design-Philosophie hinter der Sprache, Zeile für Zeile. Der Text steckt als Osterei in Python selbst: Tippen Sie in der REPL einmal import this.

Lernergebnisse: Was Sie nach diesem Kapitel können sollten

Nach Abschluss dieses Kapitels sollten Schülerinnen und Schüler in der Lage sein:

• Anwenden: Python installieren, Skripte im Terminal und in VS Code ausführen und die REPL zum Testen von Ausdrücken nutzen.
• Nennen: die Grundtypen (int, float, str, bool, None) und die wichtigsten Operatoren samt ihrer Besonderheiten (/ vs. //, **, and/or/not) nennen.
• Anwenden: Programme mit Verzweigungen, Schleifen und Funktionen schreiben und dabei die Einrückungsregeln und PEP-8-Namenskonventionen einhalten.
• Anwenden: Listen und Dictionaries anlegen, verändern und mit Schleifen verarbeiten; Teilbereiche per Slicing entnehmen; einfache List Comprehensions lesen und schreiben.
• Verstehen: erklären, worin sich ein Tupel von einer Liste unterscheidet, und Unpacking bei mehreren Rückgabewerten und enumerate() einsetzen.
• Anwenden: Ein- und Ausgabe mit input(), print() und f-Strings (inklusive Formatangaben) umsetzen.

Passende Übungen

• Aufgabe 01 - Python-Spickzettel
• Aufgabe 02 - Alte Bekannte, neue Sprache