# Python-Spickzettel: Syntax, Befehle und eingebaute Funktionen in Tabellen

URL: https://skillaria.top/de/guides/python/python-spickzettel

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`, `def` führt zu einem `SyntaxError`.
- **Addition von Zeichenkette und Zahl**: `"Alter: " + 25` ist ein Fehler, schreiben Sie `f"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 mit `int()` oder `float()` 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.

## FAQ

**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.


---
Source: Skillaria.Top (https://skillaria.top)