Python-Spickzettel: Syntax, Befehle und eingebaute Funktionen in Tabellen
Die Syntax von Python beruht auf Einrückungen statt geschweifter Klammern: Der Block nach einem Doppelpunkt wird um 4 Leerzeichen eingerückt. Die Grundlagen sind Variablen ohne Typdeklaration, Bedingungen if/elif/else, Schleifen for und while, Funktionen mit def sowie die eingebauten Funktionen print, len, range, input, type und die Methoden für Strings, Listen und Dictionaries.
Dieser Python-Spickzettel fasst auf einer Seite zusammen, was Sie in den ersten Monaten ständig brauchen: Python-Syntax, Schleifen, eingebaute Funktionen, Methoden für Strings, Listen und Dictionaries sowie Terminalbefehle. Jede Tabelle ist ein kurzes Nachschlagewerk mit praktischen Beispielen, die Sie direkt in der REPL ausprobieren können.
Grundlagen der Python-Syntax
Das wichtigste Merkmal der Sprache: Blöcke werden durch Einrückung gekennzeichnet, nicht durch Klammern. Nach einer Zeile mit Doppelpunkt (if, for, def, class) werden die folgenden Zeilen um 4 Leerzeichen eingerückt. Tabulatoren und Leerzeichen dürfen nicht gemischt werden — sonst erhalten Sie einen IndentationError.
| Konstruktion | Beispiel | Erläuterung |
|---|---|---|
| Kommentar | # Text | alles nach # bis zum Zeilenende wird ignoriert |
| Variable | age = 25 | kein Typ wird deklariert, der Wert bestimmt ihn |
| Mehrfachzuweisung | a, b = 1, 2 | Entpacken; Werte tauschen: a, b = b, a |
| Ausgabe | print("Hallo", name) | die Argumente werden durch ein Leerzeichen getrennt |
| Eingabe | s = input("Name: ") | liefert immer eine Zeichenkette |
| f-String | f"{name}: {price:.2f}" | Einsetzen von Ausdrücken und Formatierung |
| Typannotation | count: int = 0 | Hinweis für IDE und Prüfwerkzeuge, beim Start nicht geprüft |
| Leerer Block | pass | Platzhalter, wo die Syntax einen Rumpf verlangt |
| Import | from math import sqrt | Einbinden eines Moduls oder eines Namens daraus |
Datentypen
| Typ | Literal | Veränderbar |
|---|---|---|
int | 42, 1_000_000 | nein |
float | 3.14, 1e-3 | nein |
bool | True, False | nein |
str | "Text", 'Text', """mehrzeilig""" | nein |
list | [1, 2, 3] | ja |
tuple | (1, 2), (1,) | nein |
dict | {"a": 1} | ja |
set | {1, 2}, leer — set() | ja |
NoneType | None | — |
Operatoren
| Gruppe | Operatoren | Beispiel → Ergebnis |
|---|---|---|
| Arithmetik | + - * / // % ** | 7 // 2 → 3, 7 % 2 → 1, 2 ** 10 → 1024 |
| Vergleich | == != < > <= >= | 1 < x < 10 — Vergleichskette |
| Logik | and or not | x or "Standard" |
| Zugehörigkeit | in, not in | "a" in "abc" → True |
| Identität | is, is not | x is None |
| Zuweisung | += -= *= /=, := | if (n := len(s)) > 10: ... |
Bedingungen und Musterabgleich
if score >= 90:
grade = "A"
elif score >= 70:
grade = "B"
else:
grade = "C"
status = "erwachsen" if age >= 18 else "kind" # ternärer Operator
match command:
case "start":
print("Start")
case "stop" | "exit":
print("Stopp")
case _:
print("Unbekannter Befehl")
Falsch sind False, None, 0, eine leere Zeichenkette und leere Sammlungen. Deshalb schreibt man statt if len(items) > 0 einfach if items.
Schleifen in Python: Syntax von for und while
Die for-Schleife
Syntax der for-Schleife in Python: for variable in folge: und der eingerückte Rumpf. Die Schleife durchläuft jedes iterierbare Objekt — eine Zeichenkette, eine Liste, ein Dictionary, eine Datei, range.
for i in range(5): # 0 1 2 3 4
print(i)
for i in range(10, 0, -2): # 10 8 6 4 2
print(i)
for i, fruit in enumerate(["Apfel", "Birne"], start=1):
print(i, fruit)
for name, score in zip(names, scores):
print(name, score)
for key, value in prices.items():
print(key, value)
Die while-Schleife
attempts = 3
while attempts > 0:
password = input("Passwort: ")
if password == "geheim":
print("Anmeldung erfolgreich")
break
attempts -= 1
else:
print("Versuche aufgebraucht") # läuft, wenn kein break kam
| Befehl | Was er tut |
|---|---|
break | verlässt die Schleife vorzeitig |
continue | springt zur nächsten Iteration |
else an einer Schleife | läuft, wenn die Schleife ohne break endete |
range(stop), range(start, stop, step) | Zahlenfolge, stop ist nicht enthalten |
Comprehensions
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100)) # Generatorausdruck
Funktionen
def greet(name: str, greeting: str = "Hallo") -> str:
"""Gibt eine Begrüßung zurück."""
return f"{greeting}, {name}!"
def total(*args, **kwargs):
return sum(args), kwargs
square = lambda x: x * x
print(greet("Anna")) # Hallo, Anna!
print(greet("Anna", greeting="Servus")) # Servus, Anna!
| Element | Bedeutung |
|---|---|
def f(a, b=1) | Parameter mit Standardwert |
*args | beliebig viele Positionsargumente (Tupel) |
**kwargs | beliebig viele benannte Argumente (Dictionary) |
return | gibt einen Wert zurück; ohne ihn liefert die Funktion None |
lambda x: ... | kurze anonyme Funktion aus einem einzigen Ausdruck |
global, nonlocal | Ändern einer Variablen aus einem äußeren Gültigkeitsbereich |
Verwenden Sie keine veränderbaren Standardwerte wie def f(items=[]): Die Liste wird nur einmal erzeugt und sammelt sich über die Aufrufe hinweg. Richtig ist items=None und darin if items is None: items = [].
Eingebaute Funktionen in Python
Die eingebauten Funktionen stehen ohne Import zur Verfügung. Es sind die Grundfunktionen, die in fast jedem Skript vorkommen.
| Funktion | Was sie tut | Beispiel → Ergebnis |
|---|---|---|
print() | gibt Werte aus | print(1, 2, sep="-") → 1-2 |
input() | liest eine Zeile von der Tastatur | int(input()) |
len() | Länge einer Sammlung oder Zeichenkette | len("abc") → 3 |
type() | Typ eines Objekts | type(3.0) → <class 'float'> |
isinstance() | Typprüfung | isinstance(5, int) → True |
int() float() str() bool() | Typumwandlung | int("42") → 42 |
list() tuple() set() dict() | Erzeugen von Sammlungen | list("ab") → ['a', 'b'] |
range() | Zahlenbereich | list(range(3)) → [0, 1, 2] |
enumerate() | Paare (Index, Element) | list(enumerate("ab")) → [(0, 'a'), (1, 'b')] |
zip() | verbindet Folgen paarweise | list(zip([1, 2], "ab")) → [(1, 'a'), (2, 'b')] |
sum() min() max() | Summe, Minimum, Maximum | max([3, 7, 1]) → 7 |
abs() round() | Betrag und Runden | round(3.14159, 2) → 3.14 |
sorted() | neue sortierte Liste | sorted(words, key=len, reverse=True) |
reversed() | Iterator in umgekehrter Reihenfolge | list(reversed([1, 2])) → [2, 1] |
map() filter() | Funktion anwenden / filtern | list(map(str, [1, 2])) → ['1', '2'] |
any() all() | mindestens einer / alle wahr | all(x > 0 for x in nums) |
open() | öffnet eine Datei | open("a.txt", encoding="utf-8") |
help() dir() | Hilfe und Liste der Attribute | help(str.split), dir(list) |
id() hash() | Kennung und Hashwert eines Objekts | hash("a") |
Das praktischste Nachschlagewerk haben Sie immer dabei: die Funktion help() in der REPL. help(dict) zeigt alle Methoden eines Dictionaries mit Beschreibung, dir(obj) die Liste der verfügbaren Namen.
Methoden für Strings
Syntax von Zeichenketten in Python: Eine Zeichenkette ist unveränderlich, jede Methode liefert eine neue Zeichenkette. Slices funktionieren wie bei Listen: s[1:4], s[::-1] dreht die Zeichenkette um.
| Methode | Beispiel → Ergebnis |
|---|---|
upper() lower() | "Py".upper() → 'PY' |
capitalize() title() | "hello world".title() → 'Hello World' |
strip() lstrip() rstrip() | " hi \n".strip() → 'hi' |
split(sep) | "a,b,c".split(",") → ['a', 'b', 'c'] |
join(iterable) | "-".join(["a", "b"]) → 'a-b' |
replace(old, new) | "Hut".replace("H", "B") → 'But' |
find() index() | "hello".find("l") → 2; ohne Treffer -1 (bei index gibt es einen Fehler) |
count() | "banana".count("a") → 3 |
startswith() endswith() | "file.py".endswith(".py") → True |
isdigit() isalpha() isspace() | "123".isdigit() → True |
removeprefix() removesuffix() | "test_a".removeprefix("test_") → 'a' |
zfill() center() ljust() | "7".zfill(3) → '007' |
format() | "{} + {}".format(1, 2) → '1 + 2' |
Befehle für Listen in Python
Eine Liste ist eine veränderbare, geordnete Sammlung. Die meisten Methoden ändern die Liste direkt und liefern None zurück, deshalb ist a = a.sort() ein häufiger Fehler.
| Operation | Was sie tut | Beispiel |
|---|---|---|
append(x) | fügt am Ende hinzu | a.append(4) |
extend(iter) | fügt alle Elemente hinzu | a.extend([5, 6]) |
insert(i, x) | fügt an einem Index ein | a.insert(0, "erste") |
remove(x) | entfernt das erste Vorkommen des Werts | a.remove(3) |
pop(i) | entfernt und liefert ein Element (standardmäßig das letzte) | last = a.pop() |
clear() | leert die Liste | a.clear() |
index(x) | Index des ersten Vorkommens | a.index("b") |
count(x) | Anzahl der Vorkommen | a.count(1) |
sort() | sortiert direkt | a.sort(key=str.lower) |
reverse() | kehrt direkt um | a.reverse() |
copy() | flache Kopie | b = a.copy() |
del a[i] | Löschen per Index oder Slice | del a[1:3] |
| Slices | a[start:stop:step] | a[-1] — das letzte, a[:3] — die ersten drei |
Methoden für Dictionaries in Python
| Operation | Was sie tut | Beispiel |
|---|---|---|
d[key] | Wert zu einem Schlüssel, fehlt der Schlüssel — KeyError | d["name"] |
get(key, default) | Wert oder Ersatzwert | d.get("age", 0) |
d[key] = value | hinzufügen oder ändern | d["city"] = "Berlin" |
keys() values() items() | Schlüssel, Werte, Paare | for k, v in d.items(): |
update() | mit einem anderen Dictionary zusammenführen | d.update({"a": 1}) |
d1 | d2 | neues zusammengeführtes Dictionary | merged = defaults | user |
pop(key, default) | entfernt und liefert den Wert | d.pop("tmp", None) |
popitem() | entfernt das zuletzt hinzugefügte Paar | d.popitem() |
setdefault(key, value) | liefert den Wert, legt ihn bei fehlendem Schlüssel an | d.setdefault("tags", []).append("py") |
key in d | prüft, ob der Schlüssel existiert | if "name" in d: |
dict.fromkeys() | Dictionary aus Schlüsseln mit einem Wert | dict.fromkeys("abc", 0) |
len(d), del d[key] | Größe und Löschen | del d["old"] |
Tupel und Mengen
| Operation | Beispiel → Ergebnis |
|---|---|
| Entpacken eines Tupels | x, y = (3, 4) |
| Zur Menge hinzufügen | s.add(5), entfernen — s.discard(5) |
| Vereinigung / Schnitt | {1, 2} | {2, 3} → {1, 2, 3}; {1, 2} & {2, 3} → {2} |
| Differenz | {1, 2} - {2} → {1} |
| Doppelte aus einer Liste entfernen | list(dict.fromkeys(items)) — unter Beibehaltung der Reihenfolge |
Ausnahmen und Dateien
try:
number = int(input("Zahl: "))
except ValueError as err:
print("Das ist keine Zahl:", err)
else:
print("Erfolg")
finally:
print("Wird immer ausgeführt")
with open("data.txt", "w", encoding="utf-8") as f:
f.write("Zeile\n")
with open("data.txt", encoding="utf-8") as f:
for line in f:
print(line.rstrip())
| Ausnahme | Wann sie auftritt |
|---|---|
SyntaxError, IndentationError | Fehler in der Syntax oder bei der Einrückung |
NameError | Name nicht definiert (Tippfehler) |
TypeError | Operation mit ungeeignetem Typ: "1" + 1 |
ValueError | richtiger Typ, aber falscher Wert: int("abc") |
IndexError, KeyError | Index oder Schlüssel nicht vorhanden |
FileNotFoundError | Datei nicht gefunden |
ZeroDivisionError | Division durch null |
Klassen
from dataclasses import dataclass
class Dog:
def __init__(self, name: str):
self.name = name
def bark(self) -> str:
return f"{self.name}: Wau!"
@dataclass
class Point:
x: float
y: float
print(Dog("Waldi").bark()) # Waldi: Wau!
print(Point(1, 2)) # Point(x=1, y=2)
Eingebaute Module in Python
Die Standardbibliothek kommt mit dem Interpreter — es genügt ein import.
| Modul | Wofür | Beispiel |
|---|---|---|
math | Mathematik | math.sqrt(16) → 4.0 |
random | Zufallszahlen | random.randint(1, 6), random.choice(items) |
datetime | Datum und Uhrzeit | datetime.date.today() |
pathlib | Pfade und Dateien | Path("data").glob("*.csv") |
os, sys | System, Umgebungsvariablen, Argumente | os.environ.get("HOME"), sys.argv |
json | JSON lesen und schreiben | json.loads(text), json.dumps(obj, ensure_ascii=False) |
csv | CSV-Tabellen | csv.DictReader(f) |
collections | Counter, defaultdict, deque | Counter("banana").most_common(1) → [('a', 3)] |
itertools | Kombinationen und Verkettung von Iteratoren | itertools.chain(a, b) |
re | reguläre Ausdrücke | re.findall(r"\d+", s) |
time | Pausen und Zeitmessung | time.sleep(1), time.perf_counter() |
asyncio | asynchroner Code | asyncio.run(main()) |
In Python 3.15 gibt es den verzögerten Import (PEP 810): lazy import pandas as pd verschiebt das Laden des Moduls bis zum ersten Zugriff, sodass ein Skript mit schweren Abhängigkeiten deutlich schneller startet.
Python-Befehle im Terminal
Die Anfragen zu „Python-Befehlen“ betreffen den Start des Interpreters und die Installation von Bibliotheken. Unter Windows schreibt man statt python3 meist python oder py.
| Befehl | Was er tut |
|---|---|
python3 --version | zeigt die Version |
python3 | öffnet die interaktive Konsole REPL (Beenden mit exit()) |
python3 script.py | startet eine Datei |
python3 -c "print(2 + 2)" | führt eine einzelne Zeile aus |
python3 -m venv .venv | legt eine virtuelle Umgebung an |
source .venv/bin/activate / .venv\Scripts\activate | aktiviert die Umgebung (Linux, macOS / Windows) |
python3 -m pip install requests | installiert ein Paket |
pip list, pip freeze > requirements.txt | listet Pakete auf und speichert sie |
pip install -r requirements.txt | installiert Abhängigkeiten aus einer Datei |
python3 -m http.server 8000 | einfacher Webserver im aktuellen Ordner |
uv init, uv add requests, uv run main.py | Projekt, Abhängigkeit und Start über den Manager uv |
Typische Fehler von Einsteigern
- Vergleich mit
=— in einer Bedingung braucht man==; ein einzelnes=ist eine Zuweisung. - Vergessener Doppelpunkt nach
if,for,defführt zu einemSyntaxError. - Addition von Zeichenkette und Zahl:
"Alter: " + 25ist ein Fehler, schreiben Sief"Alter: {25}". - Liste während des Durchlaufs ändern — durchlaufen Sie eine Kopie
for x in a[:]oder bauen Sie eine neue Liste auf. input()liefert eine Zeichenkette — für Rechnungen mitint()oderfloat()umwandeln.
Fazit
Die Syntax von Python beruht auf Einrückungen, Doppelpunkten und einem kleinen Satz an Konstruktionen: Bedingungen, Schleifen for und while, Funktionen, Klassen. Ergänzen Sie diese um zwei Dutzend eingebaute Funktionen und die Methoden für Strings, Listen und Dictionaries — und Sie decken den größten Teil der alltäglichen Aufgaben ab. Bewahren Sie den Spickzettel auf; wenn die Tabellen vertraut sind, gehen Sie zu Modulen und Asynchronität über. Alles davon wird im Kurs „Python 3.15: vom Anfänger zum Profi“ Schritt für Schritt praktisch durchgegangen.
Häufige Fragen
Wie viele Leerzeichen gehören zur Einrückung in Python?
Nach dem Standard PEP 8 sind es 4 Leerzeichen pro Ebene. Wichtig ist, dass man es im gesamten Block einheitlich macht und Tabulatoren nicht damit mischt.
Worin unterscheidet sich eine Liste von einem Tupel?
Eine Liste ist veränderbar, man kann sie ergänzen und direkt sortieren; ein Tupel ist unveränderlich und eignet sich deshalb als Dictionary-Schlüssel und für feste Wertesätze.
Wie sehe ich alle Methoden eines Objekts direkt in Python?
Rufen Sie dir(obj) für die Liste der Namen und help(obj) für die Beschreibung auf — help(str) zeigt zum Beispiel alle Methoden von Zeichenketten.
Worin unterscheidet sich sort() von sorted()?
Die Methode list.sort() sortiert die Liste selbst und liefert None, die Funktion sorted() gibt eine neue Liste zurück und arbeitet mit jeder iterierbaren Sammlung.
Braucht man ein Semikolon am Ende einer Zeile?
Nein. Ein Semikolon ist nur dann erlaubt, wenn mehrere Anweisungen in einer Zeile stehen; im normalen Code schreibt man jede Anweisung in eine eigene Zeile.
Dieses Thema wird im Kurs „Python 3.15: от новичка до профи“ ausführlich mit Praxis behandelt.
- Python 3.15 с нуля и для опытных: что нового и как учить
- Python 3.15: установка, REPL и первый скрипт за десять минут
- Переменные, числа и строки в Python: f-строки и t-строки
- Условия, циклы и match/case в Python: управляем ходом программы
- Списки, кортежи, словари и множества: frozendict в Python 3.15