Python 101 - Theorie-Skript

1. Einführung in Python

Python ist eine interpretierte, hochrangige Programmiersprache, die sich durch ihre einfache und lesbare Syntax auszeichnet. Sie wurde 1991 von Guido van Rossum entwickelt und ist heute eine der beliebtesten Programmiersprachen weltweit.

Einfach erklärt: Python ist wie eine Sprache, mit der du dem Computer Anweisungen gibst. Anders als andere Programmiersprachen ist Python besonders leicht zu lesen und zu verstehen - fast wie normaler englischer Text.

Beim Schreiben von Programmen muss man aber vor Allem bei der Rechtschreibung vorsichtig sein. Der Computer ist beim lesen sehr genau und wir das Programm bei Tippfehlern nicht ausführen können. Man nennt die Rechtschreibung beim Programmieren auch Syntax.

Wir werden mit dem Programm Thonny Programmieren. Hier eine Übersicht:

• Blau: Kommandozeile -> Hier siehst du Text-Resultate und Fehler deiner Programme
• Grün: Editor -> Hier schreibst du dein Programm
• Rot: Datei-Menu -> Hier kannst du Dateien öffnen und speichern
• Orange: Start-Knopf -> Damit führst du dein Programm aus.

1.1 Das erste Programm

print("Hello, World!")

Die print()-Funktion gibt Text auf der Konsole aus.

1.2 Kommentare

Kommentare dienen der Dokumentation und werden vom Interpreter ignoriert:

# Dies ist ein einzeiliger Kommentar

"""
Dies ist ein
mehrzeiliger Kommentar
"""

Du kannst Kommentare nutzen, um dir Notizen zu machen, z.B. für die nächste Lektion.

1.3 Wie führt Python Code aus?

Einfach erklärt: Python liest deinen Code wie ein Buch - von oben nach unten, Zeile für Zeile. Der Computer führt jede Anweisung nacheinander aus.

print("Erste Zeile")
print("Zweite Zeile")
print("Dritte Zeile")

Ausgabe:

Erste Zeile
Zweite Zeile
Dritte Zeile

Der Computer startet bei Zeile 1, führt sie aus, geht dann zu Zeile 2, führt sie aus, und so weiter bis zum Ende des Programms.

1.4 Einrückung (Indentation)

Sehr wichtig: In Python ist die Einrückung (die Leerzeichen am Anfang einer Zeile) Teil der Syntax!

# Richtig
if alter >= 18:
    print("Du bist volljährig")
    print("Du darfst wählen")

# Falsch - Fehler!
if alter >= 18:
print("Du bist volljährig")  # Keine Einrückung = Fehler

Regeln für Einrückung:

• Verwende immer 4 Leerzeichen (oder eine Tab-Taste)
• Alle Zeilen, die zu einem Block gehören (z.B. in einer if-Anweisung oder Funktion), müssen gleich weit eingerückt sein
• Einrückung zeigt, welcher Code zusammengehört

def begruessung():
    print("Hallo!")      # 4 Leerzeichen Einrückung
    print("Willkommen")  # 4 Leerzeichen Einrückung

print("Programmende")    # 0 Leerzeichen - gehört nicht zur Funktion

1.5 Errors / Fehler

Beim Programmieren machen alle Fehler. Ständig. Fehler erkennen, finden & beheben ist mindestens ein genau so grosser Teil des Programmierens wie Code schreiben. Habe also keine Angst Fehler zu machen.

Bei einem Fehler stürzt das Programm ab und du bekommst eine Fehlermeldung. In Thonny wird die Fehlermeldung in der Kommandozeile unten angezeigt. Die sehen zwar etwas kryptisch aus, du musst aber lediglich eine Hand voll dieser Meldungen kennen. Ein Fehler in Thonny sieht z.B. so aus:

Das ^ Zeichen zeigt dir bei vielen Fehlern genau, wo im Code der Fehler liegt (grüner Pfeil). Die Fehlermeldung (blau markiert) sagt dir etwas über die Art des Fehlers und die Zeile. Im obigen Beispiel ist das Problem, dass das Schlusszeichen fehlt.

Für den Moment reicht es, wenn du folgende Fehler-Namen kennst:

• Syntax-Fehler -> Rechtschreibefehler. Es fehlt ein Zeichen oder ein ungültiges Zeichen steht irgendwo.
• Name-Fehler -> Du hast einen Namen/Ausdruck verwendet, den Python nicht kennt.
• Indentation-Fehler -> Einrückungsfehler. Eine Stelle ist falsch eingerückt.

1.6 Debugging 🐛

Ein bug in einem Computerprogramm bezeichnet normalerweise einen Fehler, der das Programm nicht zwingend komplett zum Absturz bringt aber trotzdem halt ein Fehler ist. Eine falsche Berechnung einer Note, eine komische Anzeige, etc. Um diese Fehler zu finden und beheben reichen Fehlermeldungen manchmal nicht aus. In diesem Fall hilft uns der Debugger (Ent-käferer).

Was ist ein Debugger?

Ein Debugger ist ein Werkzeug, das deinen Code Schritt für Schritt ausführt, sodass du genau sehen kannst, was passiert. In Thonny ist ein einfacher Debugger eingebaut.

Debugger in Thonny nutzen

1. Programm im Debug-Modus starten:

• Klicke auf das Käfer-Symbol (🐛) oder drücke Ctrl+F5
• Dein Programm startet, stoppt aber nach der ersten Zeile

2. Wichtige Debug-Buttons:

• Step Over (F6): Führt die aktuelle Zeile aus und geht zur nächsten
• Step Into (F7): Geht in eine Funktion hinein (wenn die Zeile eine Funktion aufruft)
• Step Out (F8): Verlässt die aktuelle Funktion
• Resume (F9): Führt das Programm bis zum Ende (oder nächsten Breakpoint) aus

Die Buttons siehst du im Screenshot oben markiert.

3. Variablen beobachten:

• Im Variables-Fenster (öffnen über Ansicht > Variablen) siehst du alle aktuellen Variablen und ihre Werte
• Die Werte ändern sich, während du durch den Code gehst

Debugging-Strategie: Variablen-Tabelle

Wenn du keinen Debugger hast, kannst du auf Papier eine Tabelle erstellen:

Beispiel-Code:

x = 5
y = 10
x = x + y
y = x - y

Variablen-Tabelle:

Zeile	Code	x	y	Notiz
1	x = 5	5	-	x wird erstellt
2	y = 10	5	10	y wird erstellt
3	x = x + y	15	10	x = 5 + 10
4	y = x - y	15	5	y = 15 - 10

Diese Methode hilft dir:

• Den Programmfluss zu verstehen
• Fehler in deiner Logik zu finden
• Zu verstehen, wie sich Variablen ändern

Tipp: Wenn dein Code nicht funktioniert, gehe ihn Zeile für Zeile durch und schreibe die Variablenwerte auf. Oft findest du so den Fehler!

2. Die Turtle 🐢

Die turtle ist ein Teil von Python, der zum lernen gedacht ist. Ein Turtle-Programm startet immer mit der folgenden Zeile, damit Python weiss, dass es ein graphisches Turtle-Fenster öffnen soll:

from turtle import *

Turtle Befehle

In einem Turtle Programm kannst du die Schildkröte (sieht leider nur aus wie ein Dreieck) mit Befehlen bewegen und so Formen zeichnen. Die Schildkröte kennt die folgenden Befehle:

• forward(zahl) -> Die Turtle bewegt sich um zahl Schritte nach vorne.
• back(zahl) -> Die Turtle bewegt sich um zahl Schritte nach hinten.
• left(zahl) / right(zahl) -> Die Turtle dreht sich um zahl Grad nach links oder rechts.
• home() -> Die Turtle geht zurück zum Ausgangspunkt
• up() -> Die Turtle hebt den Stift an. Sie kann nun bewegt werden ohne einen Strich zu hinterlassen
• down() -> Die Turtle senkt den Stift wieder ab. Sie zeichnet wieder.
• color("farbe") -> Bestimme die Farbe des Stifts. Gültige Farben findest du hier

Ein Turtle-Programm könnte also z.B. so aussehen:

from turtle import *

forward(50)
left(90)
up()
forward(40)
left(90)
down()
color('red')
forward(30)
left(90)
up()
forward(20)
left(90)
down()
forward(10)

Kannst du die gezeichnete Form auf einem Papier korrekt zeichnen?

2. Variablen und Datentypen

Einfach erklärt: Variablen sind wie beschriftete Schubladen, in denen du Werte aufbewahren kannst. Datentypen beschreiben, welche Art von Wert in der Schublade liegt - eine Zahl, ein Text, oder etwas anderes.

2.1 Variablen

Variablen sind Container für Daten. In Python müssen Variablen nicht deklariert werden:

name = "Anna"
alter = 16
groesse = 1.65

Namensregeln für Variablen:

• Müssen mit Buchstaben oder Unterstrich beginnen
• Können Buchstaben, Zahlen und Unterstriche enthalten
• Sind case-sensitive (name ≠ Name)
• Sollten aussagekräftig sein

2.2 Grundlegende Datentypen

Integer (Ganzzahlen)

x = 42
y = -17

Float (Gleitkommazahlen)

pi = 3.14159
temperatur = -5.5

String (Zeichenketten)

vorname = "Max"
nachname = 'Mustermann'
satz = """Dies ist ein
mehrzeiliger String"""

Boolean (Wahrheitswerte)

ist_wahr = True
ist_falsch = False

2.3 Typ-Konvertierung

x = "42"
y = int(x)      # String zu Integer: 42
z = float(x)    # String zu Float: 42.0
a = str(100)    # Integer zu String: "100"

3. Operatoren

Einfach erklärt: Operatoren sind wie mathematische Symbole. Mit ihnen kannst du rechnen (+, -, *, /), Werte vergleichen (==, <, >) oder logische Entscheidungen treffen (and, or, not).

3.1 Arithmetische Operatoren

a = 10
b = 3

addition = a + b        # 13
subtraktion = a - b     # 7
multiplikation = a * b  # 30
division = a / b        # 3.333...
ganzzahl_division = a // b  # 3
modulo = a % b          # 1 (Rest)
potenz = a ** b         # 1000

3.2 Vergleichsoperatoren

x = 5
y = 10

x == y    # False (gleich)
x != y    # True (ungleich)
x < y     # True (kleiner)
x > y     # False (größer)
x <= y    # True (kleiner oder gleich)
x >= y    # False (größer oder gleich)

3.3 Logische Operatoren

a = True
b = False

a and b   # False (UND)
a or b    # True (ODER)
not a     # False (NICHT)

4. Kontrollstrukturen

Einfach erklärt: Kontrollstrukturen erlauben es deinem Programm, Entscheidungen zu treffen. "Wenn dies, dann das" - genau wie du im Alltag Entscheidungen triffst. Mit if kannst du Code nur ausführen, wenn eine Bedingung erfüllt ist.

4.1 if-Anweisungen

alter = 16

if alter >= 18:
    print("Du bist volljährig")
elif alter >= 16:
    print("Du darfst Mofa fahren")
else:
    print("Du bist noch zu jung")

Wichtig: Einrückung (Indentation) ist in Python syntaktisch relevant!

4.2 Vergleichsketten

x = 5
if 0 < x < 10:
    print("x liegt zwischen 0 und 10")

5. Schleifen

Einfach erklärt: Schleifen wiederholen Code automatisch mehrmals. Statt denselben Code 100 Mal zu schreiben, sagst du dem Computer einfach: "Mach das 100 Mal". Das spart Zeit und macht deinen Code übersichtlicher.

5.1 for-Schleife

Die for-Schleife iteriert über eine Sequenz:

# Über eine Liste iterieren
fruechte = ["Apfel", "Banane", "Kirsche"]
for frucht in fruechte:
    print(frucht)

# Über einen Zahlenbereich iterieren
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)

# range mit Start, Stop und Schritt
for i in range(2, 10, 2):  # 2, 4, 6, 8
    print(i)

5.2 while-Schleife

Die while-Schleife läuft, solange eine Bedingung wahr ist:

zaehler = 0
while zaehler < 5:
    print(zaehler)
    zaehler += 1

5.3 break und continue

# break beendet die Schleife
for i in range(10):
    if i == 5:
        break
    print(i)  # 0, 1, 2, 3, 4

# continue überspringt die aktuelle Iteration
for i in range(5):
    if i == 2:
        continue
    print(i)  # 0, 1, 3, 4

6. Funktionen

Einfach erklärt: Funktionen sind wie Rezepte. Du schreibst einmal auf, wie etwas gemacht wird, und kannst es dann immer wieder verwenden. Funktionen helfen dir, deinen Code zu organisieren und Wiederholungen zu vermeiden.

Funktionen sind wiederverwendbare Codeblöcke.

6.1 Funktionen definieren

def begruessung():
    print("Hallo!")

begruessung()  # Aufruf der Funktion

6.2 Parameter und Argumente

def begruessung(name):
    print(f"Hallo, {name}!")

begruessung("Anna")  # Ausgabe: Hallo, Anna!

6.3 Rückgabewerte

def addiere(a, b):
    return a + b

ergebnis = addiere(5, 3)  # 8

6.4 Default-Parameter

def potenz(basis, exponent=2):
    return basis ** exponent

print(potenz(5))      # 25 (5^2)
print(potenz(5, 3))   # 125 (5^3)

6.5 Mehrere Rückgabewerte

def berechne(a, b):
    summe = a + b
    produkt = a * b
    return summe, produkt

s, p = berechne(4, 5)  # s=9, p=20

9. Listen

Einfach erklärt: Listen sind wie Einkaufslisten - du kannst mehrere Dinge in einer bestimmten Reihenfolge aufschreiben. Listen können wachsen oder schrumpfen, und du kannst jederzeit Elemente hinzufügen, entfernen oder ändern.

Listen sind geordnete, veränderbare Sammlungen von Elementen.

9.1 Listen erstellen

zahlen = [1, 2, 3, 4, 5]
gemischt = [1, "zwei", 3.0, True]
leer = []

9.2 Auf Elemente zugreifen

fruechte = ["Apfel", "Banane", "Kirsche"]

print(fruechte[0])   # "Apfel" (erstes Element)
print(fruechte[-1])  # "Kirsche" (letztes Element)

9.3 Listen-Slicing

zahlen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(zahlen[2:5])    # [2, 3, 4]
print(zahlen[:3])     # [0, 1, 2]
print(zahlen[7:])     # [7, 8, 9]
print(zahlen[::2])    # [0, 2, 4, 6, 8]
print(zahlen[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

9.4 Listen modifizieren

fruechte = ["Apfel", "Banane"]

# Element hinzufügen
fruechte.append("Kirsche")  # ["Apfel", "Banane", "Kirsche"]

# Element einfügen
fruechte.insert(1, "Mango")  # ["Apfel", "Mango", "Banane", "Kirsche"]

# Element entfernen
fruechte.remove("Banane")  # ["Apfel", "Mango", "Kirsche"]

# Letztes Element entfernen und zurückgeben
letztes = fruechte.pop()  # "Kirsche"

# Element an Index ändern
fruechte[0] = "Birne"

9.5 Nützliche Listen-Methoden

zahlen = [3, 1, 4, 1, 5, 9, 2, 6]

len(zahlen)       # 8 (Länge)
max(zahlen)       # 9 (Maximum)
min(zahlen)       # 1 (Minimum)
sum(zahlen)       # 31 (Summe)
zahlen.count(1)   # 2 (Häufigkeit)
zahlen.sort()     # Sortiert die Liste
zahlen.reverse()  # Kehrt die Reihenfolge um

9.6 List Comprehensions

Elegante Methode zum Erstellen von Listen:

# Quadratzahlen von 0 bis 9
quadrate = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Gerade Zahlen filtern
zahlen = [1, 2, 3, 4, 5, 6, 7, 8]
gerade = [x for x in zahlen if x % 2 == 0]
# [2, 4, 6, 8]

10. Dictionaries

Einfach erklärt: Dictionaries sind wie echte Wörterbücher - zu jedem Stichwort (Schlüssel) gehört eine Erklärung (Wert). Du kannst zum Beispiel Namen mit Telefonnummern verknüpfen oder Wörter mit ihren Übersetzungen.

Dictionaries speichern Schlüssel-Wert-Paare.

10.1 Dictionaries erstellen

person = {
    "name": "Anna",
    "alter": 16,
    "stadt": "Berlin"
}

10.2 Auf Werte zugreifen

print(person["name"])        # "Anna"
print(person.get("alter"))   # 16
print(person.get("email", "Nicht vorhanden"))  # Default-Wert

10.3 Dictionaries modifizieren

# Wert ändern
person["alter"] = 17

# Neues Paar hinzufügen
person["email"] = "anna@example.com"

# Paar entfernen
del person["stadt"]

# Alle Schlüssel, Werte oder Paare abrufen
person.keys()    # dict_keys(['name', 'alter', 'email'])
person.values()  # dict_values(['Anna', 17, 'anna@example.com'])
person.items()   # dict_items([('name', 'Anna'), ...])

10.4 Über Dictionaries iterieren

person = {"name": "Anna", "alter": 16, "stadt": "Berlin"}

# Über Schlüssel iterieren
for key in person:
    print(key, person[key])

# Über Schlüssel-Wert-Paare iterieren
for key, value in person.items():
    print(f"{key}: {value}")

7. Strings

Einfach erklärt: Strings sind Texte in deinem Programm. Python bietet viele nützliche Funktionen, um mit Texten zu arbeiten - wie umwandeln in Großbuchstaben, Teile ersetzen, oder nach bestimmten Wörtern suchen.

7.1 String-Operationen

text = "Python"

# Länge
len(text)  # 6

# Konkatenation
gruss = "Hallo " + "Welt"  # "Hallo Welt"

# Wiederholung
print("Ha" * 3)  # "HaHaHa"

# Zugriff auf Zeichen
text[0]   # "P"
text[-1]  # "n"

7.2 String-Methoden

text = "  Hallo Welt  "

text.upper()        # "  HALLO WELT  "
text.lower()        # "  hallo welt  "
text.strip()        # "Hallo Welt"
text.replace("Hallo", "Hi")  # "  Hi Welt  "
text.split()        # ["Hallo", "Welt"]

# Prüfungen
"Hallo".startswith("Ha")  # True
"Welt".endswith("lt")     # True
"123".isdigit()           # True
"abc".isalpha()           # True

7.3 String-Formatting

name = "Anna"
alter = 16

# f-Strings (empfohlen, Python 3.6+)
text = f"Ich bin {name} und {alter} Jahre alt."

# format()-Methode
text = "Ich bin {} und {} Jahre alt.".format(name, alter)

# %-Formatierung (veraltet)
text = "Ich bin %s und %d Jahre alt." % (name, alter)

8. Input und Output

Einfach erklärt: Input bedeutet "Eingabe" - dein Programm fragt den Benutzer nach Informationen. Output bedeutet "Ausgabe" - dein Programm zeigt Ergebnisse an oder speichert sie in Dateien. So kann dein Programm mit Menschen interagieren.

8.1 Benutzereingabe

name = input("Wie heißt du? ")
print(f"Hallo, {name}!")

# Zahlen einlesen (input() liefert immer String!)
alter = int(input("Wie alt bist du? "))

8.2 Dateien lesen und schreiben

# Datei schreiben
with open("daten.txt", "w") as datei:
    datei.write("Hallo Welt!\n")
    datei.write("Zweite Zeile\n")

# Datei lesen
with open("daten.txt", "r") as datei:
    inhalt = datei.read()
    print(inhalt)

# Zeilenweise lesen
with open("daten.txt", "r") as datei:
    for zeile in datei:
        print(zeile.strip())

11. Fehlerbehandlung

Einfach erklärt: Fehlerbehandlung ist wie ein Sicherheitsnetz. Wenn etwas schiefgeht (z.B. der Benutzer gibt Text statt einer Zahl ein), stürzt dein Programm nicht ab, sondern kann freundlich darauf reagieren und weiterlaufen.

11.1 try-except

try:
    zahl = int(input("Gib eine Zahl ein: "))
    ergebnis = 100 / zahl
    print(f"Ergebnis: {ergebnis}")
except ValueError:
    print("Das war keine gültige Zahl!")
except ZeroDivisionError:
    print("Division durch Null ist nicht erlaubt!")
except Exception as e:
    print(f"Ein Fehler ist aufgetreten: {e}")
finally:
    print("Dieser Block wird immer ausgeführt")

12. Best Practices

12.1 Code-Stil (PEP 8)

# Variablen: snake_case
meine_variable = 42

# Funktionen: snake_case
def berechne_summe(a, b):
    return a + b

# Konstanten: UPPER_CASE
PI = 3.14159

# Klassen: PascalCase (für fortgeschrittene Themen)
class MeineKlasse:
    pass

12.2 Lesbarkeit

# Schlecht
def f(x,y,z):return x*y+z

# Gut
def berechne_volumen(laenge, breite, hoehe):
    flaeche = laenge * breite
    volumen = flaeche * hoehe
    return volumen

12.3 Dokumentation

def fakultaet(n):
    """
    Berechnet die Fakultät einer Zahl.

    Args:
        n: Eine nicht-negative Ganzzahl

    Returns:
        Die Fakultät von n (n!)
    """
    if n == 0:
        return 1
    return n * fakultaet(n - 1)

Zusammenfassung

Du hast nun die Grundlagen von Python kennengelernt:

• ✅ Variablen und Datentypen
• ✅ Operatoren und Ausdrücke
• ✅ Kontrollstrukturen (if/else)
• ✅ Schleifen (for/while)
• ✅ Funktionen
• ✅ Listen und Dictionaries
• ✅ String-Verarbeitung
• ✅ Input/Output
• ✅ Fehlerbehandlung

Jetzt ist es Zeit, dein Wissen in den Übungen zu vertiefen!