Comment fonctionne le slicing en Python ?

Question

Accepted Answer

Le **slicing** extrait une partie d'une séquence (liste, tuple, chaîne) en utilisant la syntaxe `sequence[start:stop:step]`. C'est une fonctionnalité puissante et concise utilisée constamment en Python.

## Slicing basique

```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
```

La règle principale : `start` est **inclusif**, `stop` est **exclusif** (`nums[1:4]` donne les indices 1, 2, 3 — pas 4).

## Les indices négatifs comptent à partir de la fin

```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
```

## Le paramètre step

```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]` pour inverser une séquence est l'un des idiomes Python les plus reconnaissables.

## Slicing de chaînes

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

## Affectation de slice (pour les listes mutables)

```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]
```

## Le slicing est sûr (pas de IndexError)

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

Contrairement à l'accès à un seul index (qui lève `IndexError`), le slicing retourne gracieusement ce qui est disponible.

## Pourquoi c'est important

Le slicing est une fonctionnalité omniprésente et distinctement pythonique pour extraire, copier et inverser des séquences proprement.

Comprendre la syntaxe `start:stop:step` (en particulier début-inclusif/fin-exclusive), les indices négatifs (comptage à partir de la fin), l'idiome d'inversion (`[::-1]`) et le fait que les slices sont sûrs (pas d'erreur si l'indice est en dehors de la plage) vous permet de manipuler les listes et les chaînes de manière concise et correcte.

Cela remplace les boucles verbales pour les opérations courantes et apparaît partout dans le code Python idiomatique.