Python ist eine der beliebtesten Programmiersprachen der Welt. Sie wird in der Webentwicklung, Datenanalyse, künstlichen Intelligenz und Automatisierung eingesetzt. Python wurde bewusst so entworfen, dass der Code leicht lesbar ist – fast wie normales Englisch. Das macht Python zur idealen Sprache für den Einstieg in die Programmierung.

Bevor du programmieren kannst, brauchst du Python auf deinem Computer. Die Installation dauert nur wenige Minuten.

Windows

Mac

Auf macOS ist häufig eine ältere Python-Version vorinstalliert. Lade trotzdem die aktuelle Version von python.org herunter und installiere sie – genau wie bei Windows.

IDLE ist ein einfacher Editor, der automatisch mit Python installiert wird. Er eignet sich perfekt für den Einstieg, weil du sofort Code eingeben und ausführen kannst.

Der Befehl print() gibt Text auf dem Bildschirm aus. Er ist der einfachste und wichtigste Befehl zum Starten.

print("Hallo Welt!")

Tippe genau diesen Befehl in die IDLE-Konsole ein und drücke Enter. Python gibt aus:

Hallo Welt!

Herzlichen Glückwunsch – du hast gerade dein erstes Python-Programm geschrieben!

Die Konsole ist praktisch zum Testen, aber für längere Programme erstellst du eine Datei. So geht’s in IDLE:

# Mein erstes Python-Skript
print("Hallo Welt!")
print("Ich lerne Python.")
print("Das macht Spass!")

Python kann rechnen! Probiere folgende Eingaben in der Konsole aus:

>>> 5 + 3
8
>>> 10 - 4
6
>>> 3 * 7
21
>>> 20 / 4
5.0

print("Hallo!")
print("Ich heiße Python.")
print("Schön, dich kennenzulernen.")

Jeder Wert in Python hat einen Typ. Die drei wichtigsten Typen für den Anfang sind:

Du kannst den Typ eines Werts mit type() herausfinden:

print(type(42))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("Hallo"))  # <class 'str'>

Eine VariableEin benannter Speicherplatz, in dem du einen Wert ablegen kannst – wie ein beschriftetes Gefäß. ist wie ein beschriftetes Gefäß: Du gibst ihr einen Namen und füllst sie mit einem Wert. Später kannst du den Wert über den Namen wieder abrufen.

name = "Anna"
alter = 30
groesse = 1.72

print(name)     # Anna
print(alter)    # 30
print(groesse)  # 1.72

Regeln für Variablennamen

Du kannst den Wert einer Variable jederzeit überschreiben:

punkte = 10
print(punkte)   # 10

punkte = punkte + 5
print(punkte)   # 15

Zusätzlich gibt es abgekürzte Schreibweisen:

Ein StringEine Zeichenkette – also Text in Anführungszeichen. Kann Buchstaben, Zahlen und Sonderzeichen enthalten. ist Text in Anführungszeichen. Du kannst einfache '...' oder doppelte "..." verwenden:

vorname = "Max"
nachname = 'Mustermann'

# Strings verbinden (Konkatenation)
ganzer_name = vorname + " " + nachname
print(ganzer_name)  # Max Mustermann

f-Strings – Variablen in Text einbauen

Die eleganteste Art, Variablen in einen Text einzubauen, sind f-Strings. Setze ein f vor die Anführungszeichen und schreibe Variablen in geschweifte Klammern:

name = "Anna"
alter = 30

print(f"Hallo, ich bin {name} und {alter} Jahre alt.")
# Hallo, ich bin Anna und 30 Jahre alt.

Mit input() kannst du den Benutzer nach einer Eingabe fragen. Die Eingabe wird immer als String zurückgegeben:

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

Manchmal musst du einen Wert von einem Typ in einen anderen umwandeln:

# String zu Zahl
text = "42"
zahl = int(text)      # 42 als Ganzzahl
komma = float(text)   # 42.0 als Kommazahl

# Zahl zu String
zahl = 100
text = str(zahl)      # "100" als Text

Stell dir eine ListeEine geordnete Sammlung von Werten in eckigen Klammern. Jedes Element hat eine Position (Index), die bei 0 beginnt. wie eine Einkaufsliste vor: Du schreibst mehrere Einträge untereinander, und jeder Eintrag hat eine feste Position. In Python schreibst du Listen in eckigen Klammern:

farben = ["rot", "blau", "gruen"]
zahlen = [10, 20, 30, 40]
gemischt = ["Hallo", 42, 3.14, True]

print(farben)  # ['rot', 'blau', 'gruen']

Jedes Element in einer Liste hat eine Nummer – den Index. Wichtig: Python beginnt bei 0 zu zählen!

tiere = ["Hund", "Katze", "Vogel", "Fisch"]

print(tiere[0])   # Hund   (erstes Element)
print(tiere[1])   # Katze  (zweites Element)
print(tiere[-1])  # Fisch  (letztes Element)

Anders als Strings sind Listen veränderbar (mutable). Du kannst Elemente hinzufügen, entfernen und ändern:

Elemente hinzufügen

einkauf = ["Brot", "Milch"]

einkauf.append("Eier")       # Am Ende anhaengen
print(einkauf)  # ['Brot', 'Milch', 'Eier']

einkauf.insert(1, "Butter")  # An Position 1 einfuegen
print(einkauf)  # ['Brot', 'Butter', 'Milch', 'Eier']

Elemente entfernen

einkauf.remove("Milch")     # Bestimmtes Element entfernen
print(einkauf)  # ['Brot', 'Butter', 'Eier']

letztes = einkauf.pop()      # Letztes Element entfernen und zurueckgeben
print(letztes)  # Eier

Elemente ändern und sortieren

noten = [3, 1, 4, 2]
noten[0] = 5         # Erstes Element aendern
print(noten)         # [5, 1, 4, 2]

noten.sort()          # Aufsteigend sortieren
print(noten)         # [1, 2, 4, 5]

noten.sort(reverse=True)  # Absteigend sortieren
print(noten)         # [5, 4, 2, 1]

Du hast in Modul 02 bereits int(), float() und str() kennengelernt. Hier kommen weitere Umwandlungen dazu:

# String in Liste umwandeln
buchstaben = list("Python")
print(buchstaben)  # ['P', 'y', 't', 'h', 'o', 'n']

# String aufteilen (split)
satz = "Ich lerne Python"
woerter = satz.split()
print(woerter)  # ['Ich', 'lerne', 'Python']

# Liste zu String verbinden (join)
zusammen = " - ".join(woerter)
print(zusammen)  # Ich - lerne - Python

Ein BooleanEin Datentyp mit genau zwei möglichen Werten: True (wahr) oder False (falsch). Wird für Bedingungen und Entscheidungen verwendet. ist der einfachste Datentyp in Python: Er kennt nur zwei Werte – True (wahr) und False (falsch). Stell dir einen Lichtschalter vor: an oder aus, nichts dazwischen.

ist_sonnig = True
regnet_es = False

print(type(ist_sonnig))  # <class 'bool'>

Vergleichsoperatoren vergleichen zwei Werte und liefern True oder False zurück:

Mit if kannst du Code nur dann ausführen, wenn eine Bedingung wahr ist:

alter = 20

if alter >= 18:
    print("Du bist volljaehrig.")

Mit else legst du fest, was passiert, wenn die Bedingung nicht erfüllt ist:

alter = 15

if alter >= 18:
    print("Du bist volljaehrig.")
else:
    print("Du bist minderjaehrig.")

Genau einer der beiden Blöcke wird immer ausgeführt – nie beide.

Mit elif (kurz für „else if“) kannst du weitere Bedingungen prüfen:

note = 2

if note == 1:
    print("Sehr gut!")
elif note == 2:
    print("Gut!")
elif note == 3:
    print("Befriedigend.")
elif note <= 5:
    print("Noch bestanden.")
else:
    print("Nicht bestanden.")

Python prüft die Bedingungen von oben nach unten. Sobald eine zutrifft, wird der zugehörige Block ausgeführt und der Rest übersprungen.

Du kannst Bedingungen kombinieren:

alter = 25
hat_ausweis = True

if alter >= 18 and hat_ausweis:
    print("Einlass gewaehrt.")
else:
    print("Kein Einlass.")

Stell dir vor, du willst die Zahlen 1 bis 100 ausgeben. Ohne Schleife bräuchtest du 100 print()-Befehle. Mit einer Schleife reichen 2 Zeilen. Schleifen wiederholen einen Codeblock, solange eine Bedingung erfüllt ist – oder für jedes Element einer Liste.

Die while-Schleife wiederholt Code, solange eine Bedingung wahr ist:

zaehler = 1

while zaehler <= 5:
    print(f"Durchlauf {zaehler}")
    zaehler += 1

print("Fertig!")

Ausgabe:

Durchlauf 1
Durchlauf 2
Durchlauf 3
Durchlauf 4
Durchlauf 5
Fertig!

Die for-Schleife geht eine Sammlung (z. B. eine Liste) Element für Element durch:

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

for frucht in fruechte:
    print(f"Ich mag {frucht}")

Ausgabe:

Ich mag Apfel
Ich mag Banane
Ich mag Kirsche

Mit range() erzeugst du eine Folge von Zahlen – perfekt für for-Schleifen:

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

# Zahlen 1 bis 5
for i in range(1, 6):
    print(i)    # 1, 2, 3, 4, 5

# Jede zweite Zahl von 0 bis 10
for i in range(0, 11, 2):
    print(i)    # 0, 2, 4, 6, 8, 10

Mit break springst du sofort aus der Schleife heraus. Mit continue überspringst du den Rest des aktuellen Durchlaufs und machst mit dem nächsten weiter:

# break: Bei 5 aufhoeren
for i in range(1, 11):
    if i == 5:
        break
    print(i)    # 1, 2, 3, 4

# continue: Ungerade ueberspringen
for i in range(1, 11):
    if i % 2 != 0:
        continue
    print(i)    # 2, 4, 6, 8, 10

Du kannst Schleifen ineinander setzen. Die innere Schleife läuft für jeden Durchlauf der äußeren komplett durch:

for zeile in range(1, 4):
    for spalte in range(1, 4):
        print(f"{zeile}x{spalte}={zeile*spalte}", end="  ")
    print()  # Neue Zeile

Ausgabe:

1x1=1  1x2=2  1x3=3
2x1=2  2x2=4  2x3=6
3x1=3  3x2=6  3x3=9

Stell dir vor, du musst an 10 Stellen in deinem Programm eine Begrüßung ausgeben. Ohne Funktionen kopierst du den Code 10 Mal. Mit einer FunktionEin wiederverwendbarer Codeblock, den du mit einem Namen aufrufst. Definiert mit def. schreibst du den Code einmal und rufst ihn beliebig oft auf.

Eine Funktion definierst du mit def, gefolgt vom Namen und Klammern:

def begruessung():
    print("Hallo und willkommen!")
    print("Schoen, dass du da bist.")

# Funktion aufrufen
begruessung()
begruessung()  # Kann beliebig oft aufgerufen werden

Parameter machen Funktionen flexibel. Du übergibst Werte, mit denen die Funktion arbeitet:

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

begruessung("Anna")   # Hallo, Anna!
begruessung("Max")    # Hallo, Max!

Mehrere Parameter

def steckbrief(name, alter, stadt):
    print(f"{name} ist {alter} Jahre alt und wohnt in {stadt}.")

steckbrief("Anna", 30, "Berlin")

Standardwerte (Default-Parameter)

def begruessung(name, sprache="de"):
    if sprache == "de":
        print(f"Hallo, {name}!")
    else:
        print(f"Hello, {name}!")

begruessung("Anna")            # Hallo, Anna! (Standard: de)
begruessung("Max", "en")      # Hello, Max!

print() gibt Text auf dem Bildschirm aus, aber der Wert geht „verloren“. Mit return gibt die Funktion einen Wert zurück, den du weiterverwenden kannst:

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

summe = addiere(5, 3)
print(summe)       # 8

# Direkt verwenden
print(addiere(10, 20))  # 30

Variablen, die innerhalb einer Funktion erstellt werden, existieren nur dort – das nennt man lokalen Scope:

def meine_funktion():
    nachricht = "Ich bin lokal"
    print(nachricht)  # Funktioniert

meine_funktion()
# print(nachricht)  # FEHLER! nachricht existiert hier nicht

Variablen außerhalb von Funktionen sind global und können überall gelesen (aber nicht verändert) werden:

gruss = "Hallo"  # Global

def zeige_gruss():
    print(gruss)  # Liest die globale Variable

zeige_gruss()  # Hallo

Eine Funktion kann sich selbst aufrufen – das nennt man Rekursion. Das klassische Beispiel ist die Fakultät (5! = 5 × 4 × 3 × 2 × 1 = 120):

def fakultaet(n):
    if n <= 1:
        return 1
    return n * fakultaet(n - 1)

print(fakultaet(5))  # 120

Bisher gehen alle Daten verloren, sobald dein Programm endet. Mit Dateien kannst du Daten dauerhaft speichern – egal ob Texte, Ergebnisse oder Einstellungen. Das ist die Grundlage für praktisch jedes reale Programm.

Das Schlüsselwort with öffnet eine Datei und schließt sie automatisch, wenn du fertig bist. Das ist die sicherste Methode:

with open("meine_datei.txt", "r") as datei:
    inhalt = datei.read()
    print(inhalt)

Zeile für Zeile lesen

with open("meine_datei.txt", "r") as datei:
    for zeile in datei:
        print(zeile.strip())  # strip() entfernt Zeilenumbrueche

# Neue Datei erstellen / ueberschreiben
with open("ausgabe.txt", "w") as datei:
    datei.write("Zeile 1\n")
    datei.write("Zeile 2\n")

# An bestehende Datei anhaengen
with open("ausgabe.txt", "a") as datei:
    datei.write("Zeile 3\n")

CSV (Comma-Separated Values) ist ein verbreitetes Format für Tabellendaten. Python hat ein eingebautes csv-Modul dafür:

CSV lesen

import csv

with open("daten.csv", "r") as datei:
    leser = csv.reader(datei)
    for zeile in leser:
        print(zeile)  # Jede Zeile ist eine Liste

CSV schreiben

import csv

daten = [
    ["Name", "Alter", "Stadt"],
    ["Anna", "30", "Berlin"],
    ["Max", "25", "Hamburg"]
]

with open("personen.csv", "w", newline="") as datei:
    schreiber = csv.writer(datei)
    for zeile in daten:
        schreiber.writerow(zeile)

Wenn deine Datei Umlaute oder Sonderzeichen enthält, kann es zu Problemen kommen. Verwende dann encoding="utf-8":

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

Slicing lässt dich einen Ausschnitt aus einer Liste herausholen, ohne die Originalliste zu verändern:

buchstaben = ["a", "b", "c", "d", "e"]

print(buchstaben[1:4])   # ['b', 'c', 'd']  (Index 1 bis 3)
print(buchstaben[:3])    # ['a', 'b', 'c']  (Anfang bis Index 2)
print(buchstaben[2:])    # ['c', 'd', 'e']  (Index 2 bis Ende)
print(buchstaben[::2])   # ['a', 'c', 'e']  (jedes zweite Element)
print(buchstaben[::-1])  # ['e', 'd', 'c', 'b', 'a']  (umgekehrt)

List Comprehension ist eine kompakte Schreibweise, um aus einer bestehenden Liste eine neue zu erzeugen:

# Klassisch mit for-Schleife
quadrate = []
for i in range(1, 6):
    quadrate.append(i ** 2)

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

Mit Bedingung filtern

zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
gerade = [x for x in zahlen if x % 2 == 0]
print(gerade)  # [2, 4, 6, 8, 10]

Ein DictionaryEine Sammlung von Schlüssel-Wert-Paaren in geschweiften Klammern. Zugriff über den Schlüssel statt über einen Index. speichert Daten als Paare: Jeder Schlüssel hat einen Wert. Stell es dir wie ein Wörterbuch vor – du schlägst ein Wort (Schlüssel) nach und bekommst die Definition (Wert).

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

print(person["name"])   # Anna
print(person["alter"])  # 30

Elemente hinzufügen und ändern

person["beruf"] = "Entwicklerin"   # Neues Paar hinzufuegen
person["alter"] = 31                # Wert aendern
del person["stadt"]                 # Paar loeschen

print(person)  # {'name': 'Anna', 'alter': 31, 'beruf': 'Entwicklerin'}

Durch ein Dictionary iterieren

for schluessel, wert in person.items():
    print(f"{schluessel}: {wert}")

Ein TupelWie eine Liste, aber unveränderlich (immutable). Einmal erstellt, können Elemente nicht hinzugefügt, entfernt oder geändert werden. sieht aus wie eine Liste, wird aber mit runden Klammern geschrieben und kann nicht verändert werden:

koordinate = (48.1, 11.6)
print(koordinate[0])  # 48.1
print(koordinate[1])  # 11.6

# Das geht NICHT:
# koordinate[0] = 50.0  # TypeError!

Bisher hast du mit einfachen Datentypen (Zahlen, Strings, Listen) und Funktionen gearbeitet. Aber was, wenn du ein „Auto“ mit Farbe, Geschwindigkeit und Tank darstellen willst? Dafür brauchst du einen eigenen Datentyp – eine KlasseEin Bauplan für Objekte. Definiert, welche Eigenschaften (Attribute) und Fähigkeiten (Methoden) ein Objekt hat..

Stell dir eine Klasse wie einen Bauplan vor und ein Objekt wie das fertige Produkt: Aus dem Bauplan „Auto“ kannst du beliebig viele Autos bauen – jedes mit eigenen Werten für Farbe, Marke und Kilometerstand.

class Hund:
    def __init__(self, name, rasse):
        self.name = name
        self.rasse = rasse

    def bellen(self):
        print(f"{self.name} sagt: Wuff!")

# Objekte erstellen
hund1 = Hund("Bello", "Labrador")
hund2 = Hund("Rex", "Schaeferhund")

print(hund1.name)   # Bello
hund1.bellen()       # Bello sagt: Wuff!
hund2.bellen()       # Rex sagt: Wuff!

__init__ ist eine spezielle Methode, die automatisch aufgerufen wird, wenn du ein neues Objekt erstellst. Hier setzt du die Startwerte (Attribute):

class Konto:
    def __init__(self, inhaber, kontostand=0):
        self.inhaber = inhaber
        self.kontostand = kontostand

    def einzahlen(self, betrag):
        self.kontostand += betrag
        print(f"{betrag} EUR eingezahlt. Neuer Stand: {self.kontostand} EUR")

    def abheben(self, betrag):
        if betrag > self.kontostand:
            print("Nicht genug Guthaben!")
        else:
            self.kontostand -= betrag
            print(f"{betrag} EUR abgehoben. Neuer Stand: {self.kontostand} EUR")

mein_konto = Konto("Anna", 100)
mein_konto.einzahlen(50)   # 50 EUR eingezahlt. Neuer Stand: 150 EUR
mein_konto.abheben(200)    # Nicht genug Guthaben!

Mit Vererbung kannst du eine neue Klasse erstellen, die alle Eigenschaften und Methoden einer bestehenden Klasse übernimmt:

class Tier:
    def __init__(self, name):
        self.name = name

    def sprechen(self):
        print(f"{self.name} macht ein Geraeusch.")

class Katze(Tier):  # Katze erbt von Tier
    def sprechen(self):  # Methode ueberschreiben
        print(f"{self.name} sagt: Miau!")

class Hund(Tier):
    def sprechen(self):
        print(f"{self.name} sagt: Wuff!")

tiere = [Katze("Minka"), Hund("Bello")]
for tier in tiere:
    tier.sprechen()

Ausgabe:

Minka sagt: Miau!
Bello sagt: Wuff!

class Produkt:
    def __init__(self, name, preis):
        self.name = name
        self.preis = preis

    def __str__(self):
        return f"{self.name}: {self.preis} EUR"

p = Produkt("Laptop", 999)
print(p)  # Laptop: 999 EUR

Ein Modul ist einfach eine Python-Datei (.py), die Funktionen, Klassen oder Variablen enthält. Statt alles in eine riesige Datei zu quetschen, teilst du deinen Code in logische Einheiten auf. Außerdem kannst du auf tausende fertige Module zurückgreifen, die andere Programmierer geschrieben haben.

# Ganzes Modul importieren
import math
print(math.sqrt(16))   # 4.0
print(math.pi)          # 3.141592653589793

# Einzelne Funktionen importieren
from math import sqrt, pi
print(sqrt(25))   # 5.0 (ohne math. davor)

# Modul mit Alias importieren
import math as m
print(m.sqrt(9))   # 3.0

Python wird mit einer riesigen Sammlung von Modulen geliefert – der Standardbibliothek. Hier die drei nützlichsten für den Anfang:

math – Mathematik

import math

print(math.sqrt(144))      # 12.0 (Quadratwurzel)
print(math.ceil(3.2))      # 4   (aufrunden)
print(math.floor(3.9))     # 3   (abrunden)
print(math.pow(2, 10))     # 1024.0 (Potenz)

random – Zufallszahlen

import random

print(random.randint(1, 6))       # Zufallszahl 1-6 (Wuerfel)
print(random.choice(["A", "B", "C"]))  # Zufaelliges Element

karten = ["Herz", "Karo", "Pik", "Kreuz"]
random.shuffle(karten)   # Liste mischen
print(karten)

os – Betriebssystem-Funktionen

import os

print(os.getcwd())           # Aktuelles Verzeichnis
print(os.listdir("."))       # Dateien im Verzeichnis
print(os.path.exists("test.py"))  # Existiert die Datei?

Jede Python-Datei ist automatisch ein Modul. Erstelle eine Datei und importiere sie aus einer anderen:

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

def quadrat(zahl):
    return zahl ** 2

import hilfsfunktionen

print(hilfsfunktionen.begruessung("Anna"))  # Hallo, Anna!
print(hilfsfunktionen.quadrat(5))          # 25

Programme stürzen ab, wenn etwas Unerwartetes passiert – der Benutzer gibt Text statt einer Zahl ein, eine Datei existiert nicht, oder eine Division durch Null wird versucht. Mit ExceptionEin Fehler, der während der Programmausführung auftritt. Kann mit try/except abgefangen werden, statt das Programm abstürzen zu lassen.-Behandlung kannst du solche Fälle abfangen und eine sinnvolle Reaktion programmieren.

try:
    zahl = int(input("Gib eine Zahl ein: "))
    print(f"Deine Zahl: {zahl}")
except ValueError:
    print("Das war keine gueltige Zahl!")

Wenn der Code im try-Block einen Fehler verursacht, springt Python zum passenden except-Block. Wenn kein Fehler auftritt, wird except übersprungen.

try:
    datei = open("daten.txt", "r")
    inhalt = datei.read()
    zahl = int(inhalt)
except FileNotFoundError:
    print("Datei nicht gefunden!")
except ValueError:
    print("Dateiinhalt ist keine Zahl!")

Der finally-Block wird immer ausgeführt – egal ob ein Fehler auftrat oder nicht. Ideal für Aufräumarbeiten:

try:
    datei = open("daten.txt", "r")
    inhalt = datei.read()
except FileNotFoundError:
    print("Datei nicht gefunden!")
finally:
    print("Aufraeumarbeiten erledigt.")

Mit raise kannst du bewusst einen Fehler auslösen – z. B. wenn eine Funktion ungültige Werte bekommt:

def set_alter(alter):
    if alter < 0:
        raise ValueError("Alter kann nicht negativ sein!")
    return alter

try:
    set_alter(-5)
except ValueError as e:
    print(f"Fehler: {e}")  # Fehler: Alter kann nicht negativ sein!

class GuthabenError(Exception):
    pass

def abheben(kontostand, betrag):
    if betrag > kontostand:
        raise GuthabenError(f"Zu wenig Guthaben! Verfuegbar: {kontostand} EUR")
    return kontostand - betrag

try:
    abheben(100, 200)
except GuthabenError as e:
    print(e)  # Zu wenig Guthaben! Verfuegbar: 100 EUR

Ein SetEine ungeordnete Sammlung von eindeutigen Elementen. Doppelte Werte werden automatisch entfernt. ist wie eine Schachtel, in die jeder Gegenstand nur einmal passt. Perfekt, wenn du Duplikate loswerden willst:

farben = {"rot", "blau", "rot", "gruen", "blau"}
print(farben)  # {'rot', 'blau', 'gruen'} - Duplikate entfernt!

# Aus Liste ein Set machen (Duplikate entfernen)
namen = ["Anna", "Max", "Anna", "Lisa", "Max"]
einzigartig = set(namen)
print(einzigartig)  # {'Anna', 'Max', 'Lisa'}

Set-Operationen

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)   # {1, 2, 3, 4, 5, 6}  Vereinigung
print(a & b)   # {3, 4}              Schnittmenge
print(a - b)   # {1, 2}              Differenz

Eine Queue (Warteschlange) funktioniert nach dem FIFO-Prinzip: First In, First Out – wer zuerst kommt, wird zuerst bedient. Genau wie eine Warteschlange an der Kasse.

from collections import deque

warteschlange = deque()

# Hinten anstellen
warteschlange.append("Anna")
warteschlange.append("Max")
warteschlange.append("Lisa")

# Vorne bedienen
naechster = warteschlange.popleft()
print(naechster)        # Anna (war zuerst da)
print(warteschlange)     # deque(['Max', 'Lisa'])

Eine Priority Queue bedient nicht den Ältesten, sondern den mit der höchsten Priorität (= niedrigste Zahl) zuerst:

import heapq

aufgaben = []
heapq.heappush(aufgaben, (3, "Emails checken"))
heapq.heappush(aufgaben, (1, "Server-Fehler beheben"))
heapq.heappush(aufgaben, (2, "Meeting vorbereiten"))

# Wichtigste Aufgabe zuerst
wichtigste = heapq.heappop(aufgaben)
print(wichtigste)  # (1, 'Server-Fehler beheben')

Manchmal weißt du nicht im Voraus, wie viele Werte eine Funktion bekommt. Mit *args akzeptiert deine Funktion beliebig viele Argumente:

def summe(*args):
    ergebnis = 0
    for zahl in args:
        ergebnis += zahl
    return ergebnis

print(summe(1, 2, 3))        # 6
print(summe(10, 20, 30, 40))  # 100

def steckbrief(**kwargs):
    for schluessel, wert in kwargs.items():
        print(f"{schluessel}: {wert}")

steckbrief(name="Anna", alter=30, stadt="Berlin")

Ausgabe:

name: Anna
alter: 30
stadt: Berlin

Du kennst bereits sort() und sorted(). Mit dem key-Parameter steuerst du, wonach sortiert wird:

woerter = ["Banane", "Apfel", "Kirsche", "Dattel"]

# Nach Laenge sortieren
nach_laenge = sorted(woerter, key=len)
print(nach_laenge)  # ['Apfel', 'Banane', 'Dattel', 'Kirsche']

# Personen nach Alter sortieren
personen = [
    {"name": "Max", "alter": 25},
    {"name": "Anna", "alter": 30},
    {"name": "Lisa", "alter": 22}
]

nach_alter = sorted(personen, key=lambda p: p["alter"])
for p in nach_alter:
    print(f"{p['name']}: {p['alter']}")

Eine Lambda-Funktion ist eine kleine, anonyme Funktion in einer Zeile. Sie eignet sich für einfache Berechnungen, die du nur einmal brauchst:

# Normale Funktion
def verdopple(x):
    return x * 2

# Gleiche Funktion als Lambda
verdopple = lambda x: x * 2

print(verdopple(5))  # 10

map() wendet eine Funktion auf jedes Element an. filter() filtert Elemente nach einer Bedingung:

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

# Jede Zahl verdoppeln
verdoppelt = list(map(lambda x: x * 2, zahlen))
print(verdoppelt)  # [2, 4, 6, 8, 10]

# Nur gerade Zahlen behalten
gerade = list(filter(lambda x: x % 2 == 0, zahlen))
print(gerade)  # [2, 4]

Python hat ein eingebautes Modul für Datum und Uhrzeit. Damit kannst du das aktuelle Datum abrufen, Zeiträume berechnen und Datumsangaben formatieren:

from datetime import datetime, date, timedelta

# Aktuelles Datum und Uhrzeit
jetzt = datetime.now()
print(jetzt)  # 2026-03-15 14:30:22.123456

# Nur das Datum
heute = date.today()
print(heute)  # 2026-03-15

# Einzelne Teile abrufen
print(heute.year)   # 2026
print(heute.month)  # 3
print(heute.day)    # 15

Datum formatieren mit strftime()

jetzt = datetime.now()
print(jetzt.strftime("%d.%m.%Y"))        # 15.03.2026
print(jetzt.strftime("%H:%M Uhr"))       # 14:30 Uhr
print(jetzt.strftime("%A, %d. %B %Y"))  # Sunday, 15. March 2026

Mit Zeiträumen rechnen (timedelta)

from datetime import date, timedelta

heute = date.today()
in_einer_woche = heute + timedelta(days=7)
print(f"In einer Woche: {in_einer_woche}")

geburtstag = date(2026, 12, 24)
tage_bis = (geburtstag - heute).days
print(f"Noch {tage_bis} Tage bis Weihnachten!")

Du kennst bereits f-Strings aus Modul 02. Hier lernst du erweiterte Formatierungsoptionen:

preis = 49.9
name = "Python-Buch"

# Zwei Nachkommastellen
print(f"Preis: {preis:.2f} EUR")  # Preis: 49.90 EUR

# Rechtsbuendig in 20 Zeichen
print(f"{name:>20}")  #          Python-Buch

# Tausender-Trennzeichen
gross = 1234567
print(f"{gross:,}")  # 1,234,567

# Prozentwert
anteil = 0.75
print(f"{anteil:.0%}")  # 75%

Ein defaultdict erstellt automatisch einen Standardwert, wenn du auf einen noch nicht vorhandenen Schlüssel zugreifst:

from collections import defaultdict

# Woerter zaehlen
text = "der hund mag den hund und der hund mag knochen"
zaehler = defaultdict(int)  # Standard: 0

for wort in text.split():
    zaehler[wort] += 1

print(dict(zaehler))
# {'der': 2, 'hund': 3, 'mag': 2, 'den': 1, 'und': 1, 'knochen': 1}

IDLE ist perfekt für den Einstieg, aber für größere Projekte brauchst du mehr: automatische Vervollständigung, Fehlererkennung während des Tippens, Debugging-Werkzeuge und Projektverwaltung. PyCharm Community Edition ist kostenlos und bietet all das.

Die Kommandozeile (auch Terminal oder CMD) ist ein mächtiges Werkzeug. Du kannst Python-Skripte direkt ausführen, Pakete installieren und vieles mehr:

# Windows: Win+R, dann "cmd" eingeben
# Oder in PyCharm: View → Tool Windows → Terminal

python mein_skript.py

python --version
# Python 3.12.x

pip ist der Paketmanager von Python. Damit installierst du zusätzliche Bibliotheken, die andere Entwickler erstellt haben:

# Paket installieren
pip install requests

# Paket mit bestimmter Version
pip install requests==2.31.0

# Alle installierten Pakete anzeigen
pip list

# Paket deinstallieren
pip uninstall requests

Verschiedene Projekte brauchen oft verschiedene Versionen der gleichen Bibliothek. Mit einer virtuellen Umgebung bekommt jedes Projekt seine eigenen Pakete, ohne andere Projekte zu beeinflussen:

# Virtuelle Umgebung erstellen
python -m venv meine_umgebung

# Aktivieren (Windows)
meine_umgebung\Scripts\activate

# Aktivieren (Mac/Linux)
source meine_umgebung/bin/activate

# Jetzt pip verwenden - Pakete landen in der Umgebung
pip install requests

# Deaktivieren
deactivate

# Aktuelle Pakete in Datei speichern
pip freeze > requirements.txt

# Pakete aus Datei installieren (z.B. auf neuem Rechner)
pip install -r requirements.txt

Ein Jupyter Notebook ist ein interaktives Dokument, das Code-Zellen und Text-Zellen mischt. Du schreibst Python-Code in eine Zelle, führst sie aus und siehst das Ergebnis direkt darunter. Dazwischen kannst du Erklärungen, Überschriften und Bilder einfügen. Perfekt für Datenanalyse, Experimente und Dokumentation.

# Jupyter installieren
pip install notebook

# Jupyter starten
jupyter notebook

Nach dem Start öffnet sich dein Browser mit der Jupyter-Oberfläche. Von dort aus kannst du neue Notebooks erstellen.

Ein Notebook besteht aus Zellen. Jede Zelle hat einen Typ:

Wichtige Shortcuts

Markdown-Zellen nutzt du für Erklärungen und Überschriften. Die wichtigsten Formatierungen:

# Ueberschrift 1
## Ueberschrift 2
### Ueberschrift 3

**Fett** und *Kursiv*

- Aufzaehlungspunkt 1
- Aufzaehlungspunkt 2

`Code inline`

```python
# Code-Block
print("Hallo")
```

Der Kernel ist der Python-Prozess, der deinen Code ausführt. Wichtige Aktionen:

Web Scraping bedeutet, Daten automatisch von Webseiten zu extrahieren. Statt mühsam Informationen von Hand zu kopieren, schreibst du ein Python-Skript, das die Arbeit für dich erledigt. Typische Anwendungen: Preisvergleiche, Nachrichtensammlung, Datenanalyse.

pip install requests beautifulsoup4

import requests

antwort = requests.get("https://example.com")

print(antwort.status_code)  # 200 = OK
print(antwort.text[:200])    # Ersten 200 Zeichen des HTML-Codes

from bs4 import BeautifulSoup
import requests

antwort = requests.get("https://example.com")
suppe = BeautifulSoup(antwort.text, "html.parser")

# Seitentitel finden
print(suppe.title.text)  # Example Domain

# Alle Links finden
for link in suppe.find_all("a"):
    print(link.get("href"))

Wichtige BeautifulSoup-Methoden

Dieses Skript lädt eine Webseite herunter und extrahiert alle Überschriften:

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
antwort = requests.get(url)

if antwort.status_code == 200:
    suppe = BeautifulSoup(antwort.text, "html.parser")

    # Alle h1 und h2 Ueberschriften finden
    ueberschriften = suppe.find_all(["h1", "h2"])

    for h in ueberschriften:
        print(f"{h.name}: {h.text.strip()}")
else:
    print(f"Fehler: Status {antwort.status_code}")