Maitriser le slicing en Python

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. Grâce à une syntaxe simple basée sur des indices (start:stop:step), il 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. Je vais vous montrer comment l’utiliser efficacement avec des exemples clairs et des astuces pratiques.

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

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

Conclusion

Le slicing en Python est une technique essentielle pour manipuler efficacement les listes, chaînes de caractères et tuples. Grâce à une syntaxe simple (start:stop:step), il permet d’extraire, modifier ou analyser des données sans boucles complexes.

Que ce soit pour extraire des éléments spécifiques, inverser une séquence ou créer des sous-ensembles, le slicing offre une solution rapide et optimisée. Avec un bon usage des indices négatifs, des pas et des copies, on peut éviter les erreurs courantes et améliorer la performance de son code.

En combinant slicing, compréhension de liste et gestion de mémoire, vous maîtriserez pleinement cette technique et pourrez l’appliquer à des cas concrets en data science, traitement de texte et algorithmes avancés.