Python Grundlagen

1. Variablen und Datentypen

Grundlegende Datentypen

# Python kennt verschiedene Datentypen
alter = 18                    # int (Ganzzahl)
preis = 19.95                # float (Fliesskommazahl)
name = "Max Mustermann"     # str (String)
ist_student = True           # bool (Boolean)
                        

Python erkennt Datentypen automatisch (dynamische Typisierung). Die wichtigsten Typen sind int, float, str und bool.

2. Kommentare

Verschiedene Arten von Kommentaren

# Das ist ein einzeiliger Kommentar

# Mehrere einzeilige Kommentare
# können auch untereinander stehen

"""
Das ist ein mehrzeiliger Kommentar
oder auch Docstring genannt.
Wird oft für Dokumentation verwendet.
"""

def beispiel_funktion():
    """Diese Funktion macht etwas Tolles."""
    pass
                        

Kommentare helfen, Code zu erklären. Verwende # für einzeilige und """...""" für mehrzeilige Kommentare.

3. Typumwandlung (Casting)

Zwischen Datentypen konvertieren

# String zu Zahl
text = "25"
zahl = int(text)              # 25 (als Ganzzahl)
kommazahl = float(text)       # 25.0 (als Float)

# Zahl zu String
alter = 18
text = str(alter)             # "18" (als String)

# Zu Boolean
print(bool(1))               # True
print(bool(0))               # False
print(bool(""))              # False (leerer String)
print(bool("Text"))         # True
                        

Mit int(), float(), str() und bool() können Datentypen umgewandelt werden.

4. Operatoren

Arithmetische Operatoren

a = 10
b = 3

print(a + b)    # Addition: 13
print(a - b)    # Subtraktion: 7
print(a * b)    # Multiplikation: 30
print(a / b)    # Division: 3.333...
print(a // b)   # Ganzzahlige Division: 3
print(a % b)    # Modulo (Rest): 1
print(a ** b)   # Potenz: 1000
                        

Vergleichsoperatoren

x = 5
y = 10

print(x == y)   # Gleich: False
print(x != y)   # Ungleich: True
print(x < y)    # Kleiner: True
print(x > y)    # Grösser: False
print(x <= y)   # Kleiner oder gleich: True
print(x >= y)   # Grösser oder gleich: False
                        

Logische Operatoren

a = True
b = False

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

# Praktisches Beispiel
alter = 20
if alter >= 18 and alter < 65:
    print("Erwachsen und im Arbeitsleben")
                        

5. Boolean-Logik

Wahrheitswerte verstehen

# Werte die als False gelten (Falsy)
print(bool(0))           # False
print(bool(""))          # False (leerer String)
print(bool([]))         # False (leere Liste)
print(bool(None))       # False

# Werte die als True gelten (Truthy)
print(bool(1))           # True
print(bool("Text"))      # True
print(bool([1, 2]))     # True

# Praktische Verwendung
name = input("Dein Name: ")
if name:  # Prüft ob String nicht leer ist
    print(f"Hallo {name}!")
else:
    print("Du hast keinen Namen eingegeben")
                        

In Python können viele Werte als True oder False interpretiert werden. Das nennt man "Truthy" und "Falsy".

6. Ein- und Ausgabe

Ausgabe mit print()

# Konsolenausgabe
print("Hallo du da!")
print("Mein erstes Python Programm")
print("Ich bin", 18, "Jahre alt")

# Mit separators und end
print("A", "B", "C", sep="-")  # A-B-C
print("Hallo", end=" ")
print("Welt")              # Hallo Welt (auf einer Zeile)
                        

Ausgabe:
Hallo du da!
Mein erstes Python Programm
Ich bin 18 Jahre alt
A-B-C
Hallo Welt

Eingabe mit input()

# Benutzereingabe
name = input("Wie heisst du? ")
print(f"Hallo {name}!")

alter = int(input("Wie alt bist du? "))
print(f"In 5 Jahren bist du {alter + 5} Jahre alt")
                        

Mit input() liest man Eingaben vom Benutzer. Das Ergebnis ist immer ein String und muss ggf. mit int() oder float() konvertiert werden.

7. If-Else Bedingungen

Einfache Verzweigungen

punkte = 85

if punkte >= 90:
    print("Sehr gut!")
elif punkte >= 70:
    print("Gut!")
else:
    print("Mehr üben!")
                        

Ausgabe: Gut!

Python verwendet Einrückungen (4 Leerzeichen) statt Klammern. elif ist die Abkürzung für "else if".

🎮 Interaktive Demo

Klicke auf den Button!

8. For-Schleife

Wiederholung mit for

# Zählen von 1 bis 5
for i in range(1, 6):
    print(i)

# Über eine Liste iterieren
fruechte = ["Apfel", "Banane", "Orange"]
for frucht in fruechte:
    print(f"Ich mag {frucht}")
                        

Ausgabe:
1
2
3
4
5
Ich mag Apfel
Ich mag Banane
Ich mag Orange

🎮 Interaktive Demo

Klicke auf den Button!

9. While-Schleife

Wiederholung mit Bedingung

# Countdown
zahl = 5
while zahl > 0:
    print(zahl)
    zahl -= 1
print("Start!")
                        

Ausgabe:
5
4
3
2
1
Start!

Die while-Schleife läuft so lange, wie die Bedingung True ist. Achte darauf, dass die Bedingung irgendwann False wird!

10. Break und Continue

Schleifenkontrolle

# break: Schleife sofort beenden
for i in range(1, 11):
    if i == 5:
        break
    print(i)  # Gibt 1,2,3,4 aus

print("\n---\n")

# continue: Aktuelle Iteration überspringen
for i in range(1, 6):
    if i == 3:
        continue
    print(i)  # Gibt 1,2,4,5 aus (3 wird übersprungen)
                        

Ausgabe:
1
2
3
4
---
1
2
4
5

break beendet die Schleife komplett, continue springt zur nächsten Iteration.

11. pass und None

Platzhalter im Code

# pass: Macht nichts, ist nur ein Platzhalter
def todo_funktion():
    pass  # Wird später implementiert

for i in range(5):
    pass  # Leere Schleife

if True:
    pass  # Leerer if-Block

# None: Repräsentiert "Nichts" oder "kein Wert"
ergebnis = None

def gibt_nichts_zurueck():
    print("Hallo")
    # return None ist implizit

x = gibt_nichts_zurueck()
print(x)  # None

if x is None:
    print("x hat keinen Wert")
                        

pass ist ein Platzhalter wenn Python Code erwartet. None repräsentiert das Fehlen eines Wertes.

12. Listen

Arbeiten mit Listen

# Liste erstellen und bearbeiten
zahlen = [1, 2, 3, 4, 5]
print(zahlen[0])           # Erstes Element: 1
print(zahlen[-1])          # Letztes Element: 5

zahlen.append(6)          # Hinzufügen
zahlen.remove(3)          # Entfernen
print(len(zahlen))        # Länge: 5
print(zahlen[1:4])       # Slicing: [2, 4, 5]
                        

Listen sind veränderbare Sammlungen. Index beginnt bei 0, negative Indizes zählen von hinten.

13. Slicing (Ausschnitte)

Elemente aus Listen und Strings extrahieren

# Format: [start:stop:step]
zahlen = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(zahlen[2:5])     # [2, 3, 4] (von Index 2 bis 4)
print(zahlen[:3])       # [0, 1, 2] (vom Anfang bis 2)
print(zahlen[7:])      # [7, 8, 9] (von 7 bis Ende)
print(zahlen[:])       # [0...9] (komplette Liste)

# Mit Schrittweite (step)
print(zahlen[::2])     # [0, 2, 4, 6, 8] (jedes 2.)
print(zahlen[::-1])    # [9, 8, 7...0] (rückwärts)

# Auch mit Strings
text = "Python"
print(text[0:3])      # "Pyt"
print(text[::-1])     # "nohtyP" (umgekehrt)
                        

Slicing nutzt die Syntax [start:stop:step]. Stop ist exklusiv. Negative Werte zählen von hinten.

14. Dictionaries

Key-Value Paare

# Dictionary erstellen
person = {
    "name": "Max",
    "alter": 18,
    "stadt": "Zürich"
}

print(person["name"])      # Max
person["alter"] = 19       # Wert ändern
person["email"] = "max@email.ch"  # Neuer Eintrag

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

Dictionaries speichern Daten als Key-Value Paare. Sehr nützlich für strukturierte Daten!

15. Tupel und Sets

Weitere Datenstrukturen

# Tupel (unveränderlich)
koordinaten = (10, 20)
x, y = koordinaten  # Unpacking
print(f"x = {x}, y = {y}")

# Set (keine Duplikate)
farben = {"rot", "grün", "blau", "rot"}
print(farben)  # {'rot', 'grün', 'blau'}

farben.add("gelb")
farben.remove("rot")
print("grün" in farben)  # True
                        

Tupel sind unveränderliche Listen. Sets enthalten keine Duplikate und sind schnell bei Mitgliedschaftstests.

16. Funktionen

Eigene Funktionen definieren

# Funktion ohne Parameter
def gruesse():
    print("Hallo!")

# Funktion mit Parametern und Rückgabewert
def addiere(a, b):
    return a + b

# Mit Standardwerten
def begruessung(name="Gast"):
    print(f"Hallo {name}!")

# Funktionen aufrufen
gruesse()                  # Hallo!
ergebnis = addiere(5, 3)
print(ergebnis)            # 8
begruessung()             # Hallo Gast!
begruessung("Max")      # Hallo Max!
                        

Funktionen helfen, Code zu strukturieren und wiederzuverwenden. Mit def werden Funktionen definiert.

17. Scope (Geltungsbereich)

Lokale und globale Variablen

# Globale Variable
x = 10

def funktion1():
    # Lokale Variable (nur in der Funktion sichtbar)
    y = 5
    print(f"Innen - x: {x}, y: {y}")

funktion1()
print(f"Aussen - x: {x}")
# print(y)  # Fehler! y existiert hier nicht

# Global-Keyword verwenden
counter = 0

def zaehle():
    global counter  # Zugriff auf globale Variable
    counter += 1
    print(f"Counter: {counter}")

zaehle()  # Counter: 1
zaehle()  # Counter: 2
                        

Variablen haben einen Geltungsbereich. Lokale Variablen existieren nur innerhalb der Funktion, globale überall.

18. Enumerate und Zip

Nützliche Funktionen für Iterationen

# enumerate: Index mitführen
fruechte = ["Apfel", "Banane", "Orange"]

for index, frucht in enumerate(fruechte):
    print(f"{index}: {frucht}")
# 0: Apfel
# 1: Banane
# 2: Orange

# Mit Start-Index
for nr, frucht in enumerate(fruechte, start=1):
    print(f"{nr}. {frucht}")

# zip: Mehrere Listen kombinieren
namen = ["Max", "Anna", "Tom"]
alter = [18, 20, 19]

for name, age in zip(namen, alter):
    print(f"{name} ist {age} Jahre alt")
                        

enumerate() gibt Index und Wert zurück. zip() kombiniert mehrere Listen element-weise.

19. String-Formatierung

Verschiedene Formatierungsmethoden

name = "Max"
alter = 18
preis = 19.99

# 1. F-Strings (modern, empfohlen)
print(f"Ich bin {name} und {alter} Jahre alt")
print(f"Preis: {preis:.2f} CHF")  # 2 Dezimalstellen

# 2. format() Methode
print("Ich bin {} und {} Jahre alt".format(name, alter))
print("Ich bin {0} und {1} Jahre alt".format(name, alter))
print("Ich bin {n} und {a} Jahre alt".format(n=name, a=alter))

# 3. %-Formatierung (älter)
print("Ich bin %s und %d Jahre alt" % (name, alter))

# Nützliche Formatierungen
print(f"{name:10}")      # Linksbündig, 10 Zeichen
print(f"{name:>10}")      # Rechtsbündig
print(f"{name:^10}")      # Zentriert
                        

F-Strings sind die modernste und lesbarste Art der Formatierung in Python.

20. String-Methoden

Wichtige String-Operationen

text = "  Python ist cool!  "

print(text.upper())         # "  PYTHON IST COOL!  "
print(text.lower())         # "  python ist cool!  "
print(text.strip())         # "Python ist cool!" (ohne Leerzeichen)
print(text.replace("cool", "super"))
print(text.split())         # ['Python', 'ist', 'cool!']
print(len(text))            # 21

# Weitere nützliche Methoden
print("Python".startswith("Py"))    # True
print("Python".endswith("on"))      # True
print("123".isdigit())              # True
print("-".join(["a", "b", "c"]))    # "a-b-c"
                        

Strings haben viele nützliche Methoden. F-Strings (f"") sind die moderne Art der Formatierung.

21. Listen-Comprehensions

Elegante Listen erstellen

# Traditioneller Weg
quadrate = []
for i in range(1, 6):
    quadrate.append(i ** 2)

# Mit List Comprehension
quadrate = [i ** 2 for i in range(1, 6)]
print(quadrate)  # [1, 4, 9, 16, 25]

# Mit Bedingung
gerade = [x for x in range(10) if x % 2 == 0]
print(gerade)    # [0, 2, 4, 6, 8]

# Verschachtelt (Matrix)
matrix = [[i*j for j in range(3)] for i in range(3)]
print(matrix)
                        

List Comprehensions sind eine kompakte Art, Listen zu erstellen. Sehr pythonisch!

22. Lambda-Funktionen

Kurze anonyme Funktionen

# Lambda-Funktion
quadrat = lambda x: x ** 2
print(quadrat(5))  # 25

# Mit map() verwenden
zahlen = [1, 2, 3, 4, 5]
quadrate = list(map(lambda x: x ** 2, zahlen))
print(quadrate)  # [1, 4, 9, 16, 25]

# Mit filter() verwenden
gerade = list(filter(lambda x: x % 2 == 0, zahlen))
print(gerade)    # [2, 4]

# Mit sorted() verwenden
woerter = ["Banane", "Apfel", "Kiwi"]
sortiert = sorted(woerter, key=lambda x: len(x))
print(sortiert)  # ['Kiwi', 'Apfel', 'Banane']
                        

Lambda-Funktionen sind kurze, einzeilige Funktionen ohne Namen. Nützlich für einfache Operationen mit map(), filter() etc.

23. Module und Imports

Externe Module verwenden

# Gesamtes Modul importieren
import random
zufallszahl = random.randint(1, 10)

# Spezifische Funktionen importieren
from math import sqrt, pi
wurzel = sqrt(16)          # 4.0
print(pi)                  # 3.141592...

# Mit Alias importieren
import datetime as dt
heute = dt.date.today()

# Alle Funktionen importieren (nicht empfohlen)
from math import *
                        

Python hat viele eingebaute Module. Mit import können zusätzliche Funktionen geladen werden.

24. Fehlerbehandlung

Try-Except Blöcke

# Fehler abfangen
try:
    zahl = int(input("Gib eine Zahl ein: "))
    ergebnis = 10 / zahl
    print(f"Ergebnis: {ergebnis}")
except ValueError:
    print("Das ist keine gültige Zahl!")
except ZeroDivisionError:
    print("Division durch 0 nicht möglich!")
except Exception as e:
    print(f"Ein Fehler ist aufgetreten: {e}")
finally:
    print("Programm beendet")
                        

Mit try-except können Fehler abgefangen werden, ohne dass das Programm abstürzt. finally wird immer ausgeführt.

25. Datei-Operationen

Dateien lesen und schreiben

# Datei schreiben
with open("test.txt", "w") as datei:
    datei.write("Hallo Welt!\n")
    datei.write("Python macht Spass!")

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

# Zeile für Zeile lesen
with open("test.txt", "r") as datei:
    for zeile in datei:
        print(zeile.strip())

# An Datei anhängen
with open("test.txt", "a") as datei:
    datei.write("\nNeue Zeile")
                        

Das with Statement sorgt dafür, dass Dateien automatisch geschlossen werden. Modi: "r"=lesen, "w"=schreiben, "a"=anhängen.

26. Klassen und Objekte

Objektorientierte Programmierung

class Person:
    def __init__(self, name, alter):
        self.name = name
        self.alter = alter
    
    def vorstellen(self):
        print(f"Ich bin {self.name} und {self.alter} Jahre alt")
    
    def geburtstag(self):
        self.alter += 1
        print(f"Happy Birthday! Jetzt {self.alter} Jahre")

# Objekt erstellen
person1 = Person("Max", 18)
person1.vorstellen()
person1.geburtstag()
                        

Klassen sind Baupläne für Objekte. __init__ ist der Konstruktor, self bezieht sich auf das Objekt selbst.