Python Spickzettel

Q: Was ist ein f-String in Python?

Ein f-String ist ein String-Literal mit vorangestelltem `f`, mit dem du Ausdrücke direkt in geschweiften Klammern einbetten kannst, etwa `f"Hello {name}, you have {count} messages"`. Python wertet jeden Ausdruck aus und fügt seinen Wert ein. Sie sind die klarste und schnellste Art, Strings in Python 3.6+ zu formatieren.

Zuletzt aktualisiert 27. Mai 2026

Live im Python-Playground ausprobieren Python kostenlos lernen

Grundlagen & Ausgabe

Variablen, Kommentare und Ausgabe auf dem Bildschirm.

Operation	Syntax
Eine Variable zuweisen	`x = 10`
Einen Wert ausgeben	`print("Hello")`
Mehrere Werte ausgeben	`print("x =", x)`
Einzeiliger Kommentar	`# this is a comment`
Eingabe lesen	`name = input("Name: ")`
Mehrfachzuweisung	`a, b = 1, 2`
Den Typ prüfen	`type(x)`

Datentypen

Die zentralen eingebauten Typen und wie man zwischen ihnen konvertiert.

Typ	Beispiel
Ganzzahl (`int`)	`age = 25`
Gleitkommazahl (`float`)	`price = 9.99`
Zeichenkette (`str`)	`name = "Ada"`
Boolescher Wert (`bool`)	`is_active = True`
Liste	`nums = [1, 2, 3]`
Tupel (unveränderlich)	`point = (4, 5)`
Dictionary	`user = {"id": 1}`
None / konvertieren	`value = None`, `int("7")`, `str(42)`

Strings & f-Strings

Text formatieren und bearbeiten.

Operation	Syntax
f-String-Interpolation	`f"Hi {name}, you are {age}"`
Länge	`len(text)`
Groß- / Kleinschreibung	`text.upper()`, `text.lower()`
Leerzeichen entfernen	`text.strip()`
Ersetzen	`text.replace("a", "b")`
In eine Liste aufteilen	`text.split(",")`
Eine Liste zusammenfügen	`", ".join(items)`
Zeichen ausschneiden	`text[0:3]`
Enthält	`"py" in text`

Listen

Geordnete, veränderliche Sequenzen.

Operation	Syntax
Erstellen	`nums = [1, 2, 3]`
Zugriff per Index	`nums[0]`, letztes: `nums[-1]`
Am Ende hinzufügen	`nums.append(4)`
An Index einfügen	`nums.insert(0, 9)`
Einen Wert entfernen	`nums.remove(2)`
Per Index herausnehmen	`nums.pop()`
Ausschneiden	`nums[1:3]`
An Ort und Stelle sortieren	`nums.sort()`
Länge	`len(nums)`

Dictionaries

Schlüssel-Wert-Paare für schnelle Lookups.

Operation	Syntax
Erstellen	`user = {"id": 1, "name": "Ada"}`
Auf einen Wert zugreifen	`user["name"]`
Sicherer Zugriff (kein Fehler)	`user.get("age", 0)`
Einen Schlüssel hinzufügen / aktualisieren	`user["age"] = 25`
Einen Schlüssel löschen	`del user["age"]`
Auf einen Schlüssel prüfen	`"name" in user`
Über Schlüssel & Werte iterieren	`for k, v in user.items():`
Alle Schlüssel / Werte	`user.keys()`, `user.values()`

Kontrollfluss

Bedingungen und Schleifen.

Operation	Syntax
If / elif / else	`if x > 0:` … `elif x == 0:` … `else:`
For-Schleife über eine Liste	`for item in items:`
For-Schleife über einen Range	`for i in range(5):`
While-Schleife	`while x < 10:`
Schleife mit Index	`for i, v in enumerate(items):`
Break / continue	`break`, `continue`
Ternärer Ausdruck	`y = 1 if x else 0`

Funktionen

Wiederverwendbare Codeblöcke definieren.

Operation	Syntax
Eine Funktion definieren	`def greet(name):`
Einen Wert zurückgeben	`return name.upper()`
Standardargument	`def greet(name="World"):`
Schlüsselwortargumente	`greet(name="Ada")`
Variable Argumente	`def f(args, *kwargs):`
Lambda (anonym)	`square = lambda x: x * x`
Docstring	`"""What this does."""`

List Comprehensions

Listen, Mengen und Dicts in einem einzigen Ausdruck erstellen.

Operation	Syntax
Eine Liste abbilden	`[x * 2 for x in nums]`
Eine Liste filtern	`[x for x in nums if x > 0]`
Abbilden und filtern	`[x * 2 for x in nums if x > 0]`
Verschachtelte Schleife	`[(i, j) for i in a for j in b]`
Set Comprehension	`{x % 3 for x in nums}`
Dict Comprehension	`{k: v * 2 for k, v in d.items()}`

Häufige Built-ins & Standardbibliothek

Funktionen und Module, die du ständig benutzt.

Funktion	Was sie tut
`len(x)`	Länge eines Strings, einer Liste oder eines Dicts
`range(start, stop, step)`	Folge von Zahlen
`sum(nums)` / `max()` / `min()`	Summe, größter, kleinster Wert
`sorted(items)`	Gibt eine neue sortierte Liste zurück
`zip(a, b)`	Zwei Iterables paaren
`map(f, items)` / `filter(f, items)`	Mit einer Funktion anwenden / behalten
`import math`	Mathematische Funktionen, z. B. `math.sqrt(9)`
`import random`	Zufallswerte, z. B. `random.randint(1, 6)`

Die Python-Syntax, Datentypen und Built-ins, die du am häufigsten brauchst, auf einer Seite. Dieser Python-Spickzettel ist eine Schnellreferenz für den Python-3-Alltag - Ausgabe, Strings und f-Strings, Listen und Dictionaries, Kontrollfluss, Funktionen und Comprehensions.

Alles hier ist Standard-Python 3, das überall läuft. Kopiere, was du brauchst, oder probiere jedes Snippet live im Python-Playground aus - ein echter Interpreter in deinem Browser, nichts zu installieren.

Python-Spickzettel-FAQ

Ist dieser Python-Spickzettel kostenlos?

Ja. Dieser Python-Spickzettel ist komplett kostenlos, ohne Anmeldung. Setze ein Lesezeichen und komm wieder, wann immer du eine Syntax, eine Methode oder ein Built-in nachschlagen musst.

Was ist der Unterschied zwischen einer Liste und einem Tupel in Python?

Eine Liste ist veränderlich - du kannst ihre Elemente anhängen, entfernen und neu zuweisen - und wird mit eckigen Klammern geschrieben: [1, 2, 3]. Ein Tupel ist unveränderlich, geschrieben mit runden Klammern: (1, 2, 3), sodass es nach der Erstellung nicht mehr geändert werden kann. Verwende eine Liste für eine Sammlung, die wächst oder sich ändert, und ein Tupel für feste Wertegruppen wie Koordinaten oder eine Datenzeile.

Was ist ein f-String in Python?

Ein f-String ist ein String-Literal mit vorangestelltem f, mit dem du Ausdrücke direkt in geschweiften Klammern einbetten kannst, etwa f"Hello {name}, you have {count} messages". Python wertet jeden Ausdruck aus und fügt seinen Wert ein. Sie sind die klarste und schnellste Art, Strings in Python 3.6+ zu formatieren.

Kann ich Python online üben?

Ja. Öffne den Python-Playground, um jedes Snippet aus diesem Spickzettel in deinem Browser auszuführen - ein echter Interpreter, nichts zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver Python-Kurs Schritt für Schritt von Variablen und Schleifen zu Funktionen und Comprehensions.

Ist dieser Spickzettel gut für Anfänger?

Ja. Er ist von den Grundlagen (Ausgabe, Datentypen, Strings) bis hin zu Comprehensions und der Standardbibliothek gegliedert, sodass du die oberen Abschnitte ab dem ersten Tag nutzen und in den Rest hineinwachsen kannst.