Wie funktioniert Slicing in Python?

Question

Accepted Answer

**Slicing** extrahiert einen Teil einer Sequenz (Liste, Tuple, String) mit der Syntax `sequence[start:stop:step]`. Es ist ein mächtiges und prägnantes Feature, das ständig in Python verwendet wird.

## Grundlegendes Slicing

```python
nums = [0, 1, 2, 3, 4, 5]

nums[1:4]     # [1, 2, 3]   — start at index 1, up to (NOT including) 4
nums[:3]      # [0, 1, 2]   — from the start (start defaults to 0)
nums[3:]      # [3, 4, 5]   — to the end (stop defaults to len)
nums[:]       # [0, 1, 2, 3, 4, 5] — a full (shallow) COPY
```

Die Hauptregel: `start` ist **einschließlich**, `stop` ist **ausschließlich** (`nums[1:4]` ergibt die Indizes 1, 2, 3 — nicht 4).

## Negative Indizes zählen vom Ende

```python
nums[-1]      # 5  — last element
nums[-2]      # 4  — second to last
nums[-3:]     # [3, 4, 5] — last three elements
nums[:-1]     # [0, 1, 2, 3, 4] — everything except the last
```

## Der step-Parameter

```python
nums[::2]     # [0, 2, 4]      — every 2nd element
nums[1::2]    # [1, 3, 5]      — every 2nd, starting at index 1
nums[::-1]    # [5, 4, 3, 2, 1, 0] — REVERSE the sequence (a famous idiom)
```

`nums[::-1]` zum Umkehren einer Sequenz ist eines der erkennbarsten Python-Idiome.

## Slicing von Strings

```python
s = "Hello"
s[1:4]        # "ell"
s[::-1]       # "olleH" — reverse a string
s[0]          # "H"
```

## Slice-Zuweisung (für veränderliche Listen)

```python
nums = [0, 1, 2, 3, 4]
nums[1:3] = [10, 20, 30]   # replace a slice (can change length)
# nums → [0, 10, 20, 30, 3, 4]
```

## Slicing ist sicher (kein IndexError)

```python
nums[10:20]   # [] — out-of-range slices return empty, don't crash (unlike nums[10])
```

Im Gegensatz zum Zugriff auf einen einzelnen Index (was `IndexError` auslöst), gibt Slicing gnädig zurück, was verfügbar ist.

## Warum es wichtig ist

Slicing ist ein allgegenwärtiges, charakteristisch pythonisches Feature zum sauberen Extrahieren, Kopieren und Umkehren von Sequenzen.

Das Verständnis der `start:stop:step`-Syntax (besonders inklusive-Start/exklusive-Stop), negativer Indizes (Zählung vom Ende), des Umkehr-Idioms (`[::-1]`) und dass Slices sicher sind (kein Absturz bei Indizes außerhalb des Bereichs), ermöglicht es dir, Listen und Strings prägnant und korrekt zu manipulieren.

Es ersetzt ausschweifende Schleifen für häufige Operationen und erscheint überall in idiomatischem Python-Code.