Python-Begriffe verstehen
Variable, Dictionary, List Comprehension, Decorator – klingt nach Fachchinesisch? Ist es aber nicht. Dieses Lexikon erklärt alle wichtigen Python-Begriffe so, dass jeder sie versteht. Kein Vorwissen nötig.
Jeder Begriff enthält eine Kurzdefinition, eine ausführliche Erklärung, eine Analogie aus dem Alltag und ein konkretes Code-Beispiel – für verschiedene Lernstile.
Die wichtigsten Begriffe
Diese 8 Begriffe bilden das Fundament für alles Weitere. Sie sind die Basis, auf der du alle anderen Konzepte verstehen wirst.
Was bedeutet das konkret?
Variablen speichern Daten unter einem Namen. Du erstellst sie mit name = wert. Python erkennt automatisch, ob es sich um Text, Zahlen oder Wahrheitswerte handelt — du musst den Typ nicht vorher angeben (im Gegensatz zu Java oder C).
Die Analogie
Stell dir eine Schubladenkommode vor. Auf der einen steht "Lieblingsfarbe", und drinnen ist "Blau". Auf der anderen steht "Alter" mit "16". Variablen funktionieren genau so: Name auf der Schublade, Wert drinnen.
Warum ist das wichtig?
Ohne Variablen könntest du keine Daten speichern, verarbeiten oder wiederverwenden. Jede Berechnung, jeder Nutzername, jedes Ergebnis landet in einer Variable. Sie sind der Anfang von allem.
Beispiel
name = "Lisa"
alter = 16
print(f"Hallo {name}, du bist {alter} Jahre alt.")
Was macht eine Funktion?
Du definierst eine Funktion mit def name():. Alles, was eingerückt darunter steht, gehört zur Funktion. Du kannst ihr Werte übergeben (Parameter) und sie kann ein Ergebnis zurückgeben (return).
Die Analogie
Eine Funktion ist wie ein Rezept im Kochbuch. Du schreibst es einmal auf: "Nimm 2 Eier, schlage sie auf, rühre...". Jedes Mal, wenn du ein Omelett willst, rufst du das Rezept auf — du musst es nicht jedes Mal neu erfinden.
Warum ist das wichtig?
Funktionen sind das Herzstück sauberen Codes. Sie verhindern Kopieren-Einfügen, machen Programme übersichtlicher und erleichtern das Testen. In Python sind fast alle Befehle eigentlich Funktionen — print(), len(), input().
Beispiel
def begruessung(name):
return f"Hallo {name}!"
print(begruessung("Max"))
print(begruessung("Lisa"))
Was kannst du mit Listen machen?
Listen erstellst du mit eckigen Klammern: [1, 2, 3]. Du greifst mit dem Index zu: liste[0] gibt das erste Element. Mit append(), remove(), sort() veränderst du die Liste. Listen sind veränderbar (mutable).
Die Analogie
Eine Liste ist wie eine Einkaufsliste auf Papier. Du kannst Punkte hinzufügen, durchstreichen, umsortieren — die Reihenfolge bleibt erhalten. Im Gegensatz zu einem Set (Menge), wo die Reihenfolge egal ist.
Warum ist das wichtig?
Listen sind die am häufigsten verwendete Datenstruktur in Python. Sie speichern Nutzer, Produkte, Highscores, Zeilen aus einer Datei — fast alles, was mehrere Elemente hat, landet in einer Liste.
Beispiel
noten = [4.5, 5.0, 3.5, 5.5]
noten.append(5.0)
durchschnitt = sum(noten) / len(noten)
print(f"Durchschnitt: {durchschnitt}")
Wie funktioniert es?
if prüft eine Bedingung. Ist sie wahr, wird der eingerückte Block ausgeführt. elif (else if) prüft eine Alternative. else fängt alle anderen Fälle ab. Vergiss den Doppelpunkt : nicht!
Die Analogie
Ein Verkehrsschild: Wenn rot → anhalten. Wenn gelb → vorbereiten. Wenn grün → fahren. Genau so funktionieren Bedingungen: Das Programm schaut, was gerade zutrifft, und handelt danach.
Warum ist das wichtig?
Ohne Bedingungen wären Programme stur und vorhersehbar. If/else ermöglicht echte Entscheidungen: Ist der Nutzer alt genug? Ist das Passwort korrekt? Ist das Spiel vorbei? Fast jedes Programm braucht Bedingungen.
Beispiel
alter = 15
if alter >= 16:
print("Du darfst Moped fahren")
elif alter >= 14:
print("Fast! Noch 2 Jahre")
else:
print("Geduld ist eine Tugend")
Wie funktioniert sie?
for element in sammlung: nimmt jedes Element der Sammlung und führt den Code-Block damit aus. Mit range(5) zählst du von 0 bis 4. Die Einrückung bestimmt, was zur Schleife gehört.
Die Analogie
Ein Lehrer, der eine Klassenliste durchgeht und jedem Schüler eine Note gibt. Er sagt nicht "Schüler 1, dann Schüler 2..." — er geht einfach die Liste durch. Genau das macht die for-Schleife.
Warum ist das wichtig?
Schleifen sparen unendlich viel Code. Statt 100 Mal print() zu schreiben, schreibst du eine Schleife. Sie sind essenziell für Listen, Dateien, Spiele-Loops und Datenverarbeitung.
Beispiel
namen = ["Anna", "Ben", "Clara"]
for name in namen:
print(f"Hallo {name}!")
for i in range(3):
print(f"Runde {i+1}")
Was macht ein Dictionary?
Du erstellst es mit geschweiften Klammern: {"name": "Max", "alter": 16}. Mit dict["name"] holst du den Wert. Du kannst Schlüssel-Wert-Paare hinzufügen, ändern und löschen. Die Schlüssel müssen eindeutig sein.
Die Analogie
Ein richtiges Wörterbuch: Du schlägst ein Wort (Schlüssel) nach und findest die Bedeutung (Wert). Du suchst nicht nach der 247. Seite, sondern nach dem Wort selbst. Das ist der entscheidende Unterschied zur Liste.
Warum ist das wichtig?
Dictionaries sind perfekt für strukturierte Daten: Nutzerprofile, Konfigurationen, JSON-APIs, Quiz-Antworten. Sie machen Code lesbarer, weil du nutzer["email"] statt daten[3] schreibst.
Beispiel
nutzer = {
"name": "Lisa",
"alter": 17,
"stadt": "Wien"
}
print(f"{nutzer['name']} wohnt in {nutzer['stadt']}")
Was ist OOP?
Objektorientierte Programmierung (OOP) verpackt Daten und Funktionen zusammen. class Hund: definiert den Bauplan. __init__ ist der Konstruktor, der beim Erstellen aufgerufen wird. self bezieht sich auf das aktuelle Objekt.
Die Analogie
Eine Klasse ist wie der Bauplan eines Hauses. Der Bauplan sagt: 3 Zimmer, Küche, Bad. Aber du wohnst nicht im Bauplan — du baust konkrete Häuser daraus. Jedes Haus (Objekt) hat eigene Farben, Bewohner, Adresse.
Warum ist das wichtig?
OOP hilft, komplexe Programme zu strukturieren. PyBuddy ist ein Objekt. Ein Spieler im Game ist ein Objekt. Ohne Klassen würdest du Daten und Funktionen manuell verknüpfen — chaotisch und fehleranfällig.
Beispiel
class Hund:
def __init__(self, name):
self.name = name
def bellen(self):
return f"{self.name} sagt: Wuff!"
bello = Hund("Bello")
print(bello.bellen())
f vor den Anführungszeichen. Du kannst direkt Variablen und Ausdrücke in geschweiften Klammern einbauen — elegant, lesbar und schnell.
Wie funktioniert es?
Statt "Hallo " + name schreibst du f"Hallo {name}". In den geschweiften Klammern kannst du auch Ausdrücke verwenden: f"Summe: {a + b}". Du kannst sogar Formatierungen angeben: f"{preis:.2f} €" für 2 Dezimalstellen.
Die Analogie
Ein f-string ist wie eine Lückentext-Vorlage: "Hallo [NAME], du bist [ALTER] Jahre alt." Du füllst die Lücken automatisch aus — statt den Text Stück für Stück zusammenzusetzen.
Warum ist das wichtig?
f-strings sind der moderne, empfohlene Weg in Python, Strings zu formatieren. Sie sind schneller als .format() und lesbarer als String-Konkatenation mit +. Du wirst sie in fast jedem Python-Programm sehen.
Beispiel
name = "Max"
alter = 16
print(f"Hallo {name}!")
print(f"Nächstes Jahr bist du {alter + 1}")
print(f"{name:*^10}") # ***Max***
A 2 Begriffe
Argument
Ein Wert, den du einer Funktion übergibst. print("Hallo") — "Hallo" ist das Argument. Funktionen können beliebig viele Argumente annehmen.
def begruessen(name):
print(f"Hallo {name}!")
begruessen("Max") # "Max" ist das ArgumentAttribut
Eine Variable, die zu einem Objekt gehört. In einer Klasse sind Attribute die Daten des Objekts: self.name = "Max" — name ist ein Attribut.
class Hund:
def __init__(self, name):
self.name = name # Attribut
bello = Hund("Bello")
print(bello.name) # "Bello"B 3 Begriffe
Bool / Boolean
Ein Wahrheitswert: entweder True oder False. Entscheidend für Bedingungen und Vergleiche. Alles in Python ist "truthy" oder "falsy".
ist_aktiv = True
hat_geld = False
if ist_aktiv and not hat_geld:
print("Aktiv, aber pleite")
print(bool(0)) # False
print(bool("Hallo")) # Truebreak
Bricht eine Schleife sofort ab. Wenn eine Bedingung erfüllt ist, springt Python aus der Schleife heraus — nützlich für Suchen und frühe Abbrüche.
for i in range(10):
if i == 5:
break # Schleife beenden
print(i)
# Ausgabe: 0, 1, 2, 3, 4Built-in Funktion
Eine Funktion, die Python von Haus aus mitbringt: print(), len(), input(), range(), type() — ohne Import verfügbar.
text = "Hallo Welt"
print(len(text)) # 10
print(type(text))
print(max(3, 7, 2)) # 7
print(sum([1,2,3])) # 6C 3 Begriffe
class
Definiert einen Bauplan für Objekte. Mit class Hund: erstellst du eine Vorlage, aus der du beliebig viele Hunde-Objekte erzeugen kannst. Basis der Objektorientierung.
class Katze:
def __init__(self, name):
self.name = name
def miauen(self):
return f"{self.name} sagt Miau!"
mimi = Katze("Mimi")
print(mimi.miauen())continue
Überspringt den Rest der aktuellen Schleifen-Runde und startet sofort die nächste. Im Gegensatz zu break bricht die Schleife nicht komplett ab.
for i in range(1, 6):
if i == 3:
continue # Ueberspringe 3
print(i)
# Ausgabe: 1, 2, 4, 5Comprehension
Kompakte Schreibweise für Listen, Dictionaries und Sets: [x*2 for x in liste] — elegant, schnell und pythonic. Eine Zeile statt mehrerer.
zahlen = [1, 2, 3, 4, 5]
quadrate = [x**2 for x in zahlen]
gerade = [x for x in zahlen if x % 2 == 0]
print(quadrate) # [1, 4, 9, 16, 25]
print(gerade) # [2, 4]D 4 Begriffe
Decorator (@)
Eine Funktion, die eine andere Funktion "verpackt" und erweitert. @staticmethod oder eigene Decorator — fortgeschrittenes Konzept für sauberen Code.
import time
def timer(func):
def wrapper(*args):
start = time.time()
result = func(*args)
print(f"Dauer: {time.time()-start:.4f}s")
return result
return wrapper
@timer
def langsame_funktion():
time.sleep(1)Dictionary (dict)
Speichert Schlüssel-Wert-Paare: {"name": "Max", "alter": 16}. Schneller Zugriff über den Schlüssel. Perfekt für strukturierte Daten und JSON.
nutzer = {
"name": "Lisa",
"alter": 17,
"stadt": "Wien"
}
print(nutzer["name"])
nutzer["email"] = "lisa@mail.at"
print(nutzer.get("telefon", "Nicht angegeben"))Docstring
Ein Dokumentations-String direkt unter einer Funktion oder Klasse. Mit drei Anführungszeichen: """Beschreibung""". Wird von Tools wie help() angezeigt.
def flaeche(breite, hoehe):
"""Berechnet die Flaeche.
Args:
breite: Breite in cm
hoehe: Hoehe in cm
Returns:
Flaeche in cm2
"""
return breite * hoeheDunder / Magic Method
Methoden mit doppelten Unterstrichen: __init__, __str__, __len__. Sie definieren, wie Objekte sich verhalten — z.B. was passiert, wenn du print(objekt) aufrufst.
class Buch:
def __init__(self, titel):
self.titel = titel
def __str__(self):
return f"Buch: {self.titel}"
def __len__(self):
return len(self.titel)
b = Buch("Python")
print(str(b)) # Buch: Python
print(len(b)) # 6E 4 Begriffe
elif
"Else if" — Prüft eine weitere Bedingung, wenn das if falsch war. Du kannst beliebig viele elifs verwenden, um mehrere Fälle abzudecken.
note = 2
if note == 1:
print("Sehr gut!")
elif note == 2:
print("Gut!")
elif note == 3:
print("Befriedigend")
else:
print("Mehr Uebung noetig")else
Fängt alle Fälle ab, die nicht von if oder elif erfasst wurden. Optional — aber oft sinnvoll für Standardverhalten oder Fehlermeldungen.
alter = 15
if alter >= 16:
print("Du darfst Moped fahren")
else:
print(f"Noch {16 - alter} Jahre warten")enumerate()
Gibt bei einer Schleife Index UND Wert zurück: for i, name in enumerate(liste):. Praktisch, wenn du die Position jedes Elements brauchst.
fruechte = ["Apfel", "Banane", "Kirsche"]
for index, frucht in enumerate(fruechte, start=1):
print(f"{index}. {frucht}")
# 1. Apfel
# 2. Banane
# 3. KirscheException
Ein Fehler, der den normalen Programmfluss unterbricht. Mit try/except fängst du sie ab und reagierst darauf — statt dass das Programm abstürzt.
try:
zahl = int(input("Zahl: "))
ergebnis = 100 / zahl
print(ergebnis)
except ValueError:
print("Das war keine Zahl!")
except ZeroDivisionError:
print("Division durch Null!")F 5 Begriffe
File I/O
Das Lesen und Schreiben von Dateien. with open("datei.txt") as f: öffnet eine Datei sicher. Wichtig für Datenspeicherung und -verarbeitung.
# Schreiben
with open("notiz.txt", "w") as f:
f.write("Hallo Welt!\n")
# Lesen
with open("notiz.txt", "r") as f:
inhalt = f.read()
print(inhalt)float
Ein Datentyp für Kommazahlen: 3.14, -0.5, 2.0. Intern als Gleitkommazahl gespeichert — beachte Rundungsfehler bei sehr genauen Berechnungen!
pi = 3.14159
preis = 19.99
print(f"Pi = {pi:.2f}") # Pi = 3.14
print(f"Preis: {preis} Euro")
print(type(pi))for-Schleife
Wiederholt Code für jedes Element einer Sammlung. Die häufigste Schleifenart in Python — elegant und einfach zu lesen.
namen = ["Anna", "Ben", "Clara"]
for name in namen:
print(f"Hallo {name}!")
# Mit range
for i in range(1, 4):
print(f"Runde {i}")f-string
Formatierter String mit eingebauten Variablen: f"Hallo {name}". Der moderne, empfohlene Weg, Strings in Python zu formatieren.
name = "Max"
alter = 16
note = 1.5
print(f"Hallo {name}!")
print(f"In 5 Jahren: {alter + 5}")
print(f"Note: {note:.1f}")
print("=" * 20)Funktion (def)
Ein benannter Code-Block, der wiederverwendet werden kann. Definiert mit def, optional mit Parametern und Rückgabewert via return.
def quadrat(zahl):
return zahl ** 2
def begruessen(name, sprache="de"):
if sprache == "de":
return f"Hallo {name}!"
return f"Hello {name}!"
print(quadrat(4))
print(begruessen("Lisa", "en"))G 2 Begriffe
Generator
Eine Funktion mit yield statt return. Sie produziert Werte "on demand" — speichersparend für große Datenmengen. Einmal durchlaufen, dann erschöpft.
def zaehle_bis(n):
for i in range(1, n + 1):
yield i
for zahl in zaehle_bis(5):
print(zahl)
# Speichereffizient!
quadrate = (x**2 for x in range(1000000))global
Macht eine Variable außerhalb einer Funktion veränderbar. Wird oft als "Code-Smell" betrachtet — lieber Werte übergeben und zurückgeben.
counter = 0
def erhoehe():
global counter
counter += 1
print(f"Counter: {counter}")
erhoehe() # Counter: 1
erhoehe() # Counter: 2H 1 Begriff
Hash / Hashable
Ein Wert, der eine feste "Identitätsnummer" hat und sich nicht ändert. Strings und Zahlen sind hashable (gültig als Dictionary-Schlüssel), Listen nicht.
mein_set = {1, 2, 3}
mein_set.add(4)
# Nicht hashable (veraenderlich)
# liste = [1, 2]
# mein_set.add(liste) # TypeError!I 5 Begriffe
if / elif / else
Bedingte Ausführung: Wenn eine Bedingung wahr ist, wird der Code-Block ausgeführt. Die Grundlage für Entscheidungen in Programmen.
temperatur = 25
if temperatur > 30:
print("Zu heiss!")
elif temperatur > 20:
print("Angenehm")
else:
print("Zu kalt")import
Lädt externe Module oder Bibliotheken in dein Programm: import random oder from math import sqrt. Python hat tausende verfügbare Module.
import random
import math
from datetime import datetime
wuerfel = random.randint(1, 6)
wurzel = math.sqrt(16)
jetzt = datetime.now()
print(f"Wuerfel: {wuerfel}")
print(f"Wurzel: {wurzel}")Index
Die Position eines Elements in einer Liste. Python beginnt bei 0: liste[0] ist das erste Element. Negative Indizes zählen vom Ende: liste[-1] ist das letzte.
farben = ["Rot", "Gruen", "Blau"]
print(farben[0]) # Rot
print(farben[-1]) # Blau
print(farben[1:3]) # [Gruen, Blau]
print(farben.index("Gruen")) # 1int
Der Datentyp für Ganzzahlen: 42, -7, 0. Python kann beliebig große Ganzzahlen verarbeiten — ohne Überlauf wie in anderen Sprachen.
alter = 16
# Konvertierung
text = "42"
zahl = int(text)
print(zahl + 8) # 50
print(type(alter))
print(10 // 3) # 3Iterable
Ein Objekt, das man Element für Element durchlaufen kann: Listen, Strings, Dictionaries, Sets. Alles, was in einer for-Schleife funktioniert.
for char in "Python":
print(char)
for key in {"a": 1, "b": 2}:
print(key)
# Alles Iterables: String, Liste, Dict, Tuple, SetJ 2 Begriffe
join()
Fügt Listen-Elemente zu einem String zusammen: ",".join(["a", "b", "c"]) ergibt "a,b,c". Eine String-Methode — umgekehrt zu split().
woerter = ["Python", "ist", "toll"]
satz = " ".join(woerter)
print(satz) # Python ist toll
print("a,b,c".split(",")) # [a, b, c]JSON
Ein universelles Datenformat für den Datenaustausch. Python kann JSON mit json.load() und json.dump() nahtlos in Dictionaries umwandeln.
import json
daten = {"name": "Max", "alter": 16}
with open("daten.json", "w") as f:
json.dump(daten, f, indent=2)
with open("daten.json", "r") as f:
geladen = json.load(f)K 3 Begriffe
Key (Dictionary)
Der "Name" in einem Schlüssel-Wert-Paar. Muss eindeutig und unveränderlich (hashable) sein. Strings und Zahlen sind die häufigsten Key-Typen.
nutzer = {"name": "Lisa", "alter": 17}
print(list(nutzer.keys()))
print(list(nutzer.values()))
for key, value in nutzer.items():
print(f"{key}: {value}")Klasse (class)
Bauplan für Objekte. Verpackt Daten (Attribute) und Funktionen (Methoden) zusammen. Die Basis der objektorientierten Programmierung in Python.
class Auto:
def __init__(self, marke, farbe):
self.marke = marke
self.farbe = farbe
def beschreibung(self):
return f"Ein {self.farbe}es {self.marke}"
mein_auto = Auto("VW", "blau")
print(mein_auto.beschreibung())*args / **kwargs
Empfangen beliebig viele Argumente: *args als Tupel, **kwargs als Dictionary. Flexible Funktionssignaturen für fortgeschrittene Patterns.
def profil_anzeigen(**daten):
for key, value in daten.items():
print(f"{key}: {value}")
profil_anzeigen(name="Max", alter=16, stadt="Wien")
# Beliebig viele benannte Argumente!L 4 Begriffe
Lambda
Eine anonyme, einzeilige Funktion: quadrat = lambda x: x**2. Kompakt für kleine Operationen — oft mit map(), filter() oder sorted() verwendet.
quadrat = lambda x: x ** 2
print(quadrat(5)) # 25
spieler = [{"name": "Anna", "punkte": 95}]
spieler.sort(key=lambda s: s["punkte"])len()
Gibt die Länge eines Objekts zurück: Anzahl Elemente in einer Liste, Zeichen in einem String, Einträge in einem Dictionary. Eine der am häufigsten genutzten Built-in Funktionen.
text = "Hallo Welt"
zahlen = [1, 2, 3, 4, 5]
print(len(text)) # 10
print(len(zahlen)) # 5
if len(zahlen) > 0:
print("Liste hat Eintraege")Liste (list)
Geordnete, veränderbare Sammlung von Werten. Erstellt mit eckigen Klammern. Die wichtigste Datenstruktur in Python für nahezu alle Anwendungsfälle.
aufgaben = ["Python", "CSS", "HTML"]
aufgaben.append("JavaScript")
print(aufgaben[0])
print(aufgaben[-1])
print(len(aufgaben))
for i, a in enumerate(aufgaben):
print(f"{i+1}. {a}")Loop / Schleife
Wiederholt Code mehrmals. for für Sammlungen, while für bedingte Wiederholung. Die effizienteste Art, repetitive Aufgaben zu automatisieren.
# for-Schleife
for i in range(5):
print(i)
# while-Schleife
zahl = 1
while zahl <= 5:
print(zahl)
zahl += 1
# Endlosschleife mit Abbruch
while True:
if input("Exit? ") == "Exit":
breakM 4 Begriffe
Methode
Eine Funktion, die zu einem Objekt gehört. liste.append("x") oder string.upper() — aufgerufen mit einem Punkt nach dem Objekt.
text = "Hallo Welt"
print(text.upper())
print(text.replace("Welt", "Python"))
zahlen = [3, 1, 4]
zahlen.sort()
print(zahlen) # [1, 3, 4]Modul
Eine Python-Datei, die Funktionen und Klassen enthält. Mit import lädst du sie in dein Programm. Python hat ein riesiges Ökosystem an Modulen.
# hilfen.py
def durchschnitt(zahlen):
return sum(zahlen) / len(zahlen)
if __name__ == "__main__":
print(durchschnitt([1, 2, 3]))
# main.py
import hilfen
print(hilfen.durchschnitt([4, 5, 6]))Mutable / Immutable
Mutable (veränderbar): Listen, Dictionaries, Sets. Immutable (unveränderlich): Strings, Tupel, Zahlen. Veränderbare Objekte können nach der Erstellung noch geändert werden.
# Mutable (veraenderlich)
liste = [1, 2, 3]
liste.append(4)
print(liste) # [1, 2, 3, 4]
# Immutable (unveraenderlich)
text = "Hallo"
text = text.lower() # Neues Objekt!__main__
Der Einstiegspunkt eines Python-Programms. if __name__ == "__main__": stellt sicher, dass Code nur beim direkten Start ausgeführt wird — nicht beim Import.
# hilfen.py
def addiere(a, b):
return a + b
if __name__ == "__main__":
print(addiere(2, 3))
# main.py
import hilfen
# Der Test-Code oben laeuft NICHT!N 2 Begriffe
None
Python's Version von "nichts". Ein Funktion ohne return gibt automatisch None zurück. Nützlich, um "noch kein Wert" zu signalisieren.
def gruessen(name):
print(f"Hallo {name}!")
# Kein return
ergebnis = gruessen("Max")
print(ergebnis) # NoneNamespace
Ein "Namensraum", in dem Variablennamen eindeutig sind. Jedes Modul, jede Funktion und jede Klasse hat ihren eigenen Namespace — das verhindert Namenskollisionen.
name = "Global"
def funktion():
name = "Lokal"
print(name) # Lokal
funktion()
print(name) # GlobalO 3 Begriffe
OOP
Objektorientierte Programmierung: Code wird in Objekten organisiert, die Daten und Funktionen kombinieren. Klassen, Vererbung, Polymorphismus — die Basis großer Programme.
class Tier:
def __init__(self, name):
self.name = name
def laut(self):
return "..."
class Hund(Tier):
def laut(self):
return "Wuff!"
bello = Hund("Bello")
print(bello.laut()) # Wuff!open()
Öffnet eine Datei zum Lesen oder Schreiben. Kombiniert mit with für sichere Dateioperationen: with open("datei.txt") as f: — schließt automatisch.
# Lesen
with open("datei.txt", "r") as f:
inhalt = f.read()
# Schreiben
with open("datei.txt", "w") as f:
f.write("Neuer Text")
# Anhaengen
with open("log.txt", "a") as f:
f.write("Neuer Eintrag\n")Operator
Zeichen für Berechnungen und Vergleiche: +, -, *, /, ==, !=, >, and, or, not. Die Bausteine aller Ausdrücke in Python.
a = 10
b = 3
print(a + b) # 13
print(a // b) # 3
print(a % b) # 1
print(a > b) # True
print(a == 10) # TrueP 5 Begriffe
Parameter
Ein Platzhalter in einer Funktionsdefinition: def greet(name): — name ist der Parameter. Beim Aufruf wird ein Argument übergeben, das den Parameter füllt.
def begruessen(name, sprache="de"):
if sprache == "de":
return f"Hallo {name}!"
return f"Hello {name}!"
print(begruessen("Max"))
print(begruessen("Lisa", "en"))pip
Python's Paketmanager. Installiert externe Bibliotheken: pip install requests. Das Tor zu Pythons riesigem Ökosystem von über 400.000 Paketen.
# Paket installieren
$ pip install requests
# Alle installierten Pakete
$ pip list
# In virtueller Umgebung
$ python -m venv venv
$ source venv/bin/activateprint()
Gibt Text in der Konsole aus. Die erste Funktion, die jeder Python-Lerner kennenlernt. Mit sep und end kannst du das Verhalten anpassen.
name = "Max"
alter = 16
print("Hallo", name)
print(f"Hallo {name}!")
print("a", "b", "c", sep="-") # a-b-c@property
Macht eine Methode zu einem lesbaren Attribut. @name.setter erlaubt kontrolliertes Setzen. Elegant für gekapselte Klassen-Attribute.
class Kreis:
def __init__(self, radius):
self._radius = radius
@property
def flaeche(self):
return 3.14159 * self._radius ** 2
k = Kreis(5)
print(k.flaeche) # 78.54PyBuddy
Dein Projekt im Python Classic Kurs — ein KI-Assistent, den du Kapitel für Kapitel erweiterst. Vom einfachen Chatbot bis zum interaktiven Helfer mit Datei-I/O.
# Dein PyBuddy CLI Projekt
import pybuddy
pybuddy.begruessen("Max")R 4 Begriffe
range()
Erzeugt eine Zahlenfolge: range(5) → 0,1,2,3,4. range(2, 10, 2) → 2,4,6,8. Der beste Freund der for-Schleife für Zählaufgaben.
# 0 bis 4
for i in range(5):
print(i)
# 1 bis 5
for i in range(1, 6):
print(i)
# Nur gerade
for i in range(0, 10, 2):
print(i)Rekursion
Eine Funktion, die sich selbst aufruft. Braucht immer eine Abbruchbedingung, sonst Endlos-Loop. Elegant für Baumstrukturen und mathematische Probleme.
def fakultaet(n):
if n <= 1:
return 1
return n * fakultaet(n - 1)
print(fakultaet(5)) # 120
# 5! = 5 * 4 * 3 * 2 * 1 = 120return
Gibt einen Wert aus einer Funktion zurück und beendet sie. Ohne return gibt eine Funktion None zurück. Das Herzstück der Datenverarbeitung.
def addiere(a, b):
return a + b
def ist_gueltig(alter):
if alter >= 18:
return True
return False
print(addiere(5, 3)) # 8
print(ist_gueltig(20)) # Trueraise
Löst selbst eine Exception aus: raise ValueError("Ungültige Eingabe"). Nützlich, um Fehler früh zu erkennen und klare Fehlermeldungen zu geben.
def teilen(a, b):
if b == 0:
raise ValueError("Nicht durch Null!")
return a / b
try:
print(teilen(10, 0))
except ValueError as e:
print(f"Fehler: {e}")S 6 Begriffe
self
Bezieht sich auf das aktuelle Objekt in einer Klasse. Der erste Parameter jeder Methode (außer statischen). self.name greift auf das Attribut des Objekts zu.
class Schueler:
def __init__(self, name):
self.name = name
def vorstellen(self):
return f"Ich bin {self.name}"
max = Schueler("Max")
print(max.vorstellen()) # Ich bin MaxSet
Eine ungeordnete Sammlung ohne Duplikate. {1, 2, 3} oder set(liste). Perfekt für Mengenoperationen wie Vereinigung und Schnittmenge.
zahlen = {1, 2, 3, 3, 3}
print(zahlen) # {1, 2, 3}
a = {1, 2, 3}
b = {3, 4, 5}
print(a | b) # {1, 2, 3, 4, 5}
print(a & b) # {3}Slicing
Ausschneiden von Teilen: liste[0:3] → Elemente 0 bis 2. text[::-1] → Text rückwärts. Eine der elegantesten Python-Funktionen.
text = "Python ist toll"
zahlen = [0, 1, 2, 3, 4, 5]
print(text[0:6]) # Python
print(text[::-1]) # llot tsi nohtyP
print(zahlen[1:4]) # [1, 2, 3]
print(zahlen[::2]) # [0, 2, 4]String (str)
Text in Python: "Hallo Welt". Unveränderlich (immutable) und extrem vielseitig. Methoden wie .upper(), .split(), .replace() machen Textverarbeitung einfach.
name = "Python"
print(name.upper())
print(name.replace("P", "J"))
print(f"Ich lerne {name}")
print(" hallo ".strip())SyntaxError
Ein Fehler, der auftritt, wenn die Grammatik von Python verletzt wird: Vergessener Doppelpunkt, falsche Einrückung, fehlende Klammer. Die häufigste Anfänger-Fehlerquelle.
# KORREKT
def begruessen(name):
return f"Hallo {name}!"
# FEHLER: Vergessener Doppelpunkt
def begruessen(name)
return "Hallo!"
# SyntaxError: expected :@staticmethod / @classmethod
Methoden, die kein self brauchen. @staticmethod ist eine normale Funktion in einer Klasse. @classmethod bekommt die Klasse selbst übergeben (cls).
class Mathe:
@staticmethod
def addiere(a, b):
return a + b
print(Mathe.addiere(5, 3)) # 8T 4 Begriffe
try / except
Fängt Fehler ab, damit das Programm nicht abstürzt. try: versucht etwas, except: reagiert auf den Fehler. Optional mit else und finally.
try:
datei = open("daten.txt")
inhalt = datei.read()
except FileNotFoundError:
print("Datei nicht gefunden!")
inhalt = "Standardwert"
finally:
print("Wird immer ausgefuehrt")Tupel (tuple)
Wie eine Liste, aber unveränderlich: (1, 2, 3). Nach der Erstellung können keine Elemente hinzugefügt oder entfernt werden. Sicherer für konstante Daten.
koordinaten = (10, 20)
farbe = (255, 128, 0)
print(koordinaten[0]) # 10
x, y = koordinaten
print(f"x={x}, y={y}")
# Tupel sind immutable!type()
Gibt den Datentyp eines Werts zurück: type(42) → <class 'int'>. Mit isinstance() prüfst du, ob ein Wert einen bestimmten Typ hat.
name = "Lisa"
alter = 16
print(type(name)) # <class str>
print(type(alter)) # <class int>
if type(alter) is int:
print("Ganzzahl!")Type Hinting
Optionale Typ-Angaben für bessere Lesbarkeit: def add(a: int, b: int) -> int:. Python erzwingt sie nicht, aber IDE und Tools nutzen sie für bessere Unterstützung.
from typing import List, Dict
def summe(zahlen: List[int]) -> int:
return sum(zahlen)
print(summe([1, 2, 3])) # 6V 3 Begriffe
Variable
Eine benannte Speicherbox für Daten. Der Grundbaustein jedes Programms. Python erkennt den Datentyp automatisch — keine Deklaration nötig.
name = "Max"
alter = 16
# Mehrfachzuweisung
x, y, z = 1, 2, 3
print(f"{name} ist {alter} Jahre alt")venv
Virtual Environment — ein isolierter Python-Arbeitsbereich. Jedes Projekt bekommt seine eigenen Bibliotheken. Verhindert Versionskonflikte zwischen Projekten.
# Virtuelle Umgebung erstellen
$ python -m venv venv
# Aktivieren
$ venv\Scripts\activate # Windows
$ source venv/bin/activate # Mac/Linux
$ pip install requestsVererbung
Eine Klasse erbt Attribute und Methoden von einer anderen: class Hund(Tier):. Vermeidet Code-Wiederholung und ermöglicht Spezialisierung.
class Tier:
def __init__(self, name):
self.name = name
class Hund(Tier):
def laut(self):
return "Wuff!"
class Katze(Tier):
def laut(self):
return "Miau!"
for tier in [Hund("Bello"), Katze("Mimi")]:
print(f"{tier.name}: {tier.laut()}")W 3 Begriffe
while-Schleife
Wiederholt Code, solange eine Bedingung wahr ist. Braucht eine Abbruchbedingung, sonst Endlosschleife. Gut für unbekannte Anzahl von Wiederholungen.
antwort = ""
while antwort != "ja":
antwort = input("Nochmal? ")
# Mit Zaehler
countdown = 3
while countdown > 0:
print(countdown)
countdown -= 1
print("Los!")with-Statement
Sorgt für sauberes Ressourcen-Management: with open("datei.txt") as f:. Schließt die Datei automatisch — auch bei Fehlern. Sauberer und sicherer.
# Automatisches Schliessen
with open("daten.txt", "r") as f:
inhalt = f.read()
# f ist hier bereits geschlossen!Walrus Operator (:=)
Zuweisung UND Rückgabe in einem Schritt: if (n := len(text)) > 10:. Spart Zeilen, aber kann die Lesbarkeit beeinträchtigen. Seit Python 3.8 verfügbar.
# Ohne Walrus
name = input("Name: ")
while name != "exit":
print(f"Hallo {name}!")
name = input("Name: ")
# Mit Walrus
while (name := input("Name: ")) != "exit":
print(f"Hallo {name}!")Z 1 Begriff
zip()
Kombiniert mehrere Listen paarweise: zip(namen, alter) → ("Max", 16), ("Lisa", 17). Häufig mit for name, age in zip(...) verwendet.
namen = ["Anna", "Ben"]
noten = [1, 2]
for name, note in zip(namen, noten):
print(f"{name}: Note {note}")
woerterbuch = dict(zip(namen, noten))
print(woerterbuch) # {Anna: 1, Ben: 2}