Slicing Python : découper listes, chaînes et tuples ([:])

Le slicing en Python est une technique incontournable pour extraire, modifier ou analyser des séquences comme les listes, tuples et chaînes de caractères. Il repose sur une syntaxe simple basée sur des indices, sequence[start:stop:step], qui permet de manipuler efficacement des données sans boucles complexes.

Que ce soit pour extraire une sous-liste, inverser une chaîne de caractères ou récupérer des éléments spécifiques, le slicing est un outil puissant et intuitif. Ce guide le montre pas à pas avec des exemples clairs et des astuces pratiques, pour les développeurs débutants et intermédiaires.

Ce que vous allez apprendre

• Lire la syntaxe start:stop:step et ses valeurs par défaut
• Extraire une portion d'une liste, d'une chaîne ou d'un tuple
• Compter depuis la fin avec les indices négatifs
• Inverser une séquence avec [::-1] et sauter des éléments avec un pas
• Modifier une liste par slicing et comprendre pourquoi une chaîne reste immuable
• Copier une séquence avec [:] et connaître la limite de la copie superficielle

Syntaxe du slicing en Python

Le slicing en Python repose sur une notation simple et efficace qui permet d’extraire une portion d’une liste, d’un tuple ou d’une chaîne de caractères sans avoir besoin de boucles complexes.

L’opérateur de slicing s’écrit sous la forme :

sequence[start:stop:step]

• start : indice de départ (inclus)
• stop : indice de fin (exclu)
• step : pas de saut entre les éléments

Si un des paramètres est omis, Python utilise ses valeurs par défaut :

sequence[:stop]     # Commence à 0 et s'arrête à stop (exclu)
sequence[start:]    # Commence à start et va jusqu'à la fin
sequence[::step]    # Prend tout avec un pas spécifique
sequence[:]         # Copie complète de la séquence

Exemples simples :

1. Slicing sur une liste

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(numbers[2:5])   # [2, 3, 4]
print(numbers[:4])    # [0, 1, 2, 3]
print(numbers[5:])    # [5, 6, 7, 8, 9]
print(numbers[::2])   # [0, 2, 4, 6, 8] (un élément sur deux)

2. Slicing sur une chaîne de caractères

text = "Python slicing"

print(text[0:6])   # 'Python'
print(text[:6])    # 'Python'
print(text[7:])    # 'slicing'
print(text[::2])   # 'Pto lcig'

Comprendre les indices négatifs

Python permet d’utiliser des indices négatifs pour compter à partir de la fin de la séquence :

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(numbers[-3:])   # [7, 8, 9]
print(numbers[:-3])   # [0, 1, 2, 3, 4, 5, 6]
print(numbers[::-1])  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (inversion)

Exemple avec une chaîne de caractères :

text = "Python slicing"

print(text[-7:])   # 'slicing'
print(text[:-7])   # 'Python '
print(text[::-1])  # 'gnicils nohtyP' (inversion)

Le slicing est donc un moyen très puissant pour extraire, transformer et manipuler les séquences en Python. Voyons maintenant comment l’appliquer spécifiquement aux listes.

Slicing sur les listes

Le slicing est particulièrement utile avec les listes, car il permet d'extraire des sous-listes, d'accéder aux éléments de manière flexible et même de modifier leur contenu.

Extraire une sous-liste

La technique la plus courante consiste à récupérer une portion de la liste en utilisant la notation start:stop.

fruits = ["pomme", "banane", "cerise", "datte", "figue", "kiwi"]

print(fruits[1:4])  # ['banane', 'cerise', 'datte']
print(fruits[:3])   # ['pomme', 'banane', 'cerise']
print(fruits[3:])   # ['datte', 'figue', 'kiwi']

Dans chaque cas :

• L'élément start est inclus.
• L'élément stop est exclu.

Utiliser des indices négatifs

Python permet d'utiliser des indices négatifs pour compter depuis la fin de la liste.

print(fruits[-3:])   # ['datte', 'figue', 'kiwi']
print(fruits[:-3])   # ['pomme', 'banane', 'cerise']

Astuce : L'indice -1 représente le dernier élément, -2 l'avant-dernier, etc.

Slicing avec un pas (step)

L'argument step permet de sauter des éléments dans la liste.

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(numbers[::2])  # [0, 2, 4, 6, 8]  (un élément sur deux)
print(numbers[1::2]) # [1, 3, 5, 7, 9]  (éléments impairs)

On peut aussi utiliser un pas négatif pour parcourir la liste à l’envers.

print(numbers[::-1])  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(numbers[::-2])  # [9, 7, 5, 3, 1]  (un élément sur deux en inversé)

Modifier une liste avec le slicing

Contrairement aux chaînes de caractères qui sont immuables, on peut modifier une liste en utilisant le slicing.

letters = ["a", "b", "c", "d", "e"]

letters[1:3] = ["x", "y"]  # Remplace ['b', 'c'] par ['x', 'y']
print(letters)  # ['a', 'x', 'y', 'd', 'e']

On peut aussi supprimer plusieurs éléments en leur attribuant une liste vide.

letters[2:4] = []
print(letters)  # ['a', 'x', 'e']

Cas particulier : inverser une liste

Une astuce très utilisée consiste à inverser une liste avec [::-1].

words = ["Python", "est", "puissant"]
print(words[::-1])  # ['puissant', 'est', 'Python']

Erreurs courantes à éviter

1. Attention aux indices hors limites

   numbers = [1, 2, 3, 4]
   print(numbers[10:])  # Retourne [] au lieu d'une erreur

2. Ne pas confondre slicing et accès direct

   print(numbers[2])   # 3  (un seul élément)
   print(numbers[2:3]) # [3] (une liste contenant un seul élément)

Le slicing sur les listes offre donc une grande flexibilité. Voyons maintenant comment appliquer ces mêmes principes aux chaînes de caractères.

Slicing sur les chaînes de caractères

Les chaînes de caractères en Python sont immuables, mais on peut les manipuler facilement grâce au slicing. Cette technique permet d’extraire des morceaux de texte, de les inverser ou de récupérer certains caractères selon un motif précis.

Extraire une sous-chaîne

Comme pour les listes, on utilise la notation start:stop:step pour extraire une portion de texte.

texte = "Python slicing"

print(texte[0:6])   # 'Python'
print(texte[:6])    # 'Python' (équivalent à [0:6])
print(texte[7:])    # 'slicing' (du 7e caractère à la fin)

À noter : Le caractère à l’indice stop est exclu de la sous-chaîne.

Utiliser des indices négatifs

Les indices négatifs permettent de découper la chaîne en partant de la fin.

print(texte[-7:])   # 'slicing' (les 7 derniers caractères)
print(texte[:-7])   # 'Python ' (tout sauf les 7 derniers)

Slicing avec un pas (step)

On peut utiliser step pour extraire un caractère sur deux, par exemple.

print(texte[::2])   # 'Pto lcig' (un caractère sur deux)
print(texte[1::2])  # 'yhnsiin' (les lettres aux indices impairs)

Inverser une chaîne de caractères

Une astuce très utile est d’inverser une chaîne avec [::-1].

print(texte[::-1])  # 'gnicils nohtyP'

C’est une technique souvent utilisée pour vérifier si un mot est un palindrome :

def est_palindrome(mot):
    return mot == mot[::-1]

print(est_palindrome("radar"))  # True
print(est_palindrome("python"))  # False

Différence entre split() et slicing

Le slicing permet d’extraire une partie fixe d’une chaîne, tandis que split() découpe le texte selon un séparateur.

phrase = "Python est un langage puissant"
mots = phrase.split()  # Sépare par défaut sur les espaces
print(mots)  # ['Python', 'est', 'un', 'langage', 'puissant']

Si on veut extraire les trois premiers mots avec slicing :

print(" ".join(mots[:3]))  # 'Python est un'

Cas d’usage pratique : récupérer un mot spécifique

On peut extraire un mot précis d’une phrase sans split().

phrase = "Le slicing en Python est puissant"
print(phrase[3:10])  # 'slicing'

Si on ne connaît pas les indices exacts, split() peut être plus flexible.

print(phrase.split()[1])  # 'slicing'

Erreurs courantes à éviter

1. Confondre slicing et accès direct

   texte = "Python"
   print(texte[2])   # 't' (un seul caractère)
   print(texte[2:3]) # 't' (sous-chaîne de longueur 1)

2. Essayer de modifier une chaîne

   texte = "Python"
   texte[0] = "J"  # Erreur : TypeError (les chaînes sont immuables)

Si on veut modifier une chaîne, on doit la reconstruire.

texte_modifie = "J" + texte[1:]
print(texte_modifie)  # 'Jython'

Le slicing sur les chaînes de caractères est donc un outil puissant pour manipuler du texte. Passons maintenant au slicing sur les tuples.

Slicing sur les tuples

Les tuples sont des séquences immuables, similaires aux listes, mais non modifiables après leur création. Le slicing fonctionne exactement comme pour les listes, sauf qu’on ne peut pas modifier le contenu du tuple.

Extraire une sous-partie d’un tuple

On utilise la notation start:stop:step pour obtenir une portion d’un tuple.

jours = ("lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche")

print(jours[1:4])  # ('mardi', 'mercredi', 'jeudi')
print(jours[:3])   # ('lundi', 'mardi', 'mercredi')
print(jours[4:])   # ('vendredi', 'samedi', 'dimanche')

Utiliser des indices négatifs

Comme pour les listes et les chaînes, on peut compter à rebours depuis la fin du tuple.

print(jours[-3:])   # ('vendredi', 'samedi', 'dimanche')
print(jours[:-3])   # ('lundi', 'mardi', 'mercredi', 'jeudi')

Slicing avec un pas (step)

On peut utiliser l’option step pour récupérer un élément sur deux.

print(jours[::2])  # ('lundi', 'mercredi', 'vendredi', 'dimanche')
print(jours[::-1])  # ('dimanche', 'samedi', 'vendredi', 'jeudi', 'mercredi', 'mardi', 'lundi')  (inversion)

Différence avec les listes : immuabilité des tuples

Contrairement aux listes, on ne peut pas modifier un tuple après sa création.

jours[0] = "dimanche"  # TypeError : un tuple ne peut pas être modifié

Si on veut modifier un tuple, il faut le transformer en liste, effectuer les modifications, puis recréer un tuple.

jours_liste = list(jours)  # Conversion en liste
jours_liste[0] = "dimanche"
jours_modifie = tuple(jours_liste)  # Conversion en tuple
print(jours_modifie)
# ('dimanche', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche')

Utilisation du slicing sur les tuples en pratique

1. Extraire des données d’un tuple

Si on stocke des coordonnées GPS dans un tuple (latitude, longitude), on peut facilement extraire chaque valeur.

coordonnees = (48.8566, 2.3522)  # Paris

latitude = coordonnees[:1]   # (48.8566,)
longitude = coordonnees[1:]  # (2.3522,)

2. Obtenir les éléments d’un tuple par plage d’index

Si on a des données triées, on peut obtenir facilement une plage spécifique.

scores = (10, 12, 14, 16, 18, 20)
print(scores[2:5])  # (14, 16, 18)

3. Vérifier si un élément est présent avec slicing

def contient_element(tuple_data, element):
    return element in tuple_data[:]

print(contient_element(jours, "mardi"))  # True
print(contient_element(jours, "férié"))  # False

Les tuples sont donc bien compatibles avec le slicing, mais il faut garder en tête qu’ils sont immuables. Passons maintenant aux cas avancés et astuces de performance.

Slicing et copies en mémoire

Le slicing sert aussi à copier une séquence, mais cette copie a une limite qu'il faut connaître pour éviter des bugs difficiles à traquer. Voici la différence entre une copie superficielle obtenue avec [:] et une copie profonde.

Copie superficielle (shallow copy)

Le slicing d’une liste crée une nouvelle liste avec des références aux mêmes objets.

original = [1, 2, [3, 4]]
copie = original[:]

copie[0] = 99
copie[2][0] = 999

print(original)  # [1, 2, [999, 4]]
print(copie)     # [99, 2, [999, 4]]

Explication : Les éléments simples (entiers, chaînes) sont copiés indépendamment, mais les objets mutables (listes, dictionnaires, objets) conservent leurs références.

Copie profonde (deep copy)

Si on veut copier complètement une structure imbriquée sans effet de bord, il faut utiliser copy.deepcopy().

import copy

original = [1, 2, [3, 4]]
copie_profonde = copy.deepcopy(original)

copie_profonde[2][0] = 999

print(original)         # [1, 2, [3, 4]]
print(copie_profonde)   # [1, 2, [999, 4]]

À retenir

• Syntaxe sequence[start:stop:step] : start inclus, stop exclu, step optionnel.
• Valeurs par défaut : [:n] part de 0, [n:] va jusqu'à la fin, [:] copie toute la séquence.
• Indices négatifs : -1 est le dernier élément ; [-3:] prend les trois derniers.
• Inverser une séquence se fait avec [::-1], sans fonction supplémentaire.
• Modifier par slicing ne marche que sur les listes ; les chaînes et tuples sont immuables.
• [:] crée une copie superficielle : les objets imbriqués restent partagés, utilisez copy.deepcopy() pour une copie profonde.
• Un index hors limites ne lève pas d'erreur en slicing (numbers[10:] renvoie []), contrairement à l'accès direct.

FAQ : questions fréquentes

Les réponses courtes ci-dessous couvrent les questions les plus recherchées sur le slicing Python. Chaque exemple est autonome et testé sur Python 3.12.

Qu'est-ce que le slicing en Python ?

Le slicing extrait une portion d'une séquence (liste, chaîne, tuple) avec la syntaxe sequence[start:stop:step] : start est inclus, stop est exclu, step est le pas. Par exemple ma_liste[1:4] renvoie les éléments d'index 1, 2 et 3 dans une nouvelle séquence.

Comment inverser une liste ou une chaîne en Python ?

Utilisez un pas négatif avec [::-1] : ma_liste[::-1] renvoie la liste dans l'ordre inverse, et 'texte'[::-1] inverse la chaîne. C'est la méthode la plus concise, sans fonction ni boucle, et elle fonctionne sur toute séquence.

Que signifie [:] en Python ?

sequence[:] découpe la séquence du début à la fin, ce qui en renvoie une copie complète. Sur une liste, cela crée une nouvelle liste indépendante (copie superficielle) : modifier la copie ne touche pas l'originale, sauf pour les objets imbriqués qui restent partagés.

Comment utiliser les indices négatifs dans un slicing ?

Un index négatif compte depuis la fin : -1 est le dernier élément, -2 l'avant-dernier. Ainsi ma_liste[-3:] renvoie les trois derniers éléments et ma_liste[:-3] tout sauf les trois derniers. Les indices négatifs se combinent avec start, stop et step.

Quelle différence entre le slicing et l'accès direct par index ?

L'accès direct ma_liste[2] renvoie un seul élément. Le slicing ma_liste[2:3] renvoie une nouvelle séquence contenant cet élément. Un index hors limites lève une IndexError en accès direct, alors qu'un slicing hors limites renvoie simplement une séquence vide sans erreur.

Peut-on modifier une liste avec le slicing en Python ?

Oui pour les listes, qui sont mutables : ma_liste[1:3] = ['x', 'y'] remplace la portion, et ma_liste[1:3] = [] la supprime. En revanche, les chaînes et les tuples sont immuables : toute tentative de modification par slicing lève une TypeError.

Prochaines étapes

Listes Python Créer, indexer et manipuler les collections ordonnées que vous découpez avec le slicing.

Tuples Python Comprendre les séquences immuables et pourquoi le slicing y renvoie un nouveau tuple.

Traitement de texte Aller plus loin que le slicing pour manipuler et nettoyer des chaînes de caractères.

Dictionnaires Python Passer des séquences indexées aux structures clé-valeur pour vos données.

×

📖 Voir la documentation →