Le Slicing en Python

✂️ Le Slicing en Python

📚 Introduction

Le slicing (découpage) est une technique puissante en Python qui permet d’extraire des portions de séquences (listes, chaînes, tuples). C’est un outil essentiel pour manipuler efficacement vos données sans avoir besoin de boucles complexes.

Le slicing utilise une syntaxe simple avec des crochets [] et des indices séparés par des deux-points :. Cette fonctionnalité rend Python particulièrement élégant pour le traitement de données.

Pourquoi maîtriser le slicing ?

Efficacité : Extraction rapide de sous-séquences
Lisibilité : Code plus clair et concis
Puissance : Manipulation avancée avec indices négatifs et pas
Polyvalence : Fonctionne sur toutes les séquences Python

1️⃣ Syntaxe du slicing

La syntaxe de base

# Syntaxe du slicing en Python
# sequence[start:stop]   - De start à stop (exclu)
# sequence[:stop]        - Du début à stop (exclu)
# sequence[start:]       - De start à la fin
# sequence[::step]       - Du début à la fin avec un pas
# sequence[:]            - Copie complète de la séquence

Explication :

start : indice de début (inclus)
stop : indice de fin (exclu)
step : pas/intervalle entre les éléments

Exemples sur les listes

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

print(numbers[2:5])   # [3, 4, 5] - éléments d'index 2 à 4
print(numbers[:4])    # [0, 2, 3, 4] - du début à l'index 3
print(numbers[5:])    # [6, 7, 8, 9] - de l'index 5 à la fin
print(numbers[::2])   # [0, 3, 5, 7, 9] - un élément sur deux

Exemples sur les chaînes

texte = "Python slicing"

print(texte[0:6])   # "Python" - caractères 0 à 5
print(texte[:6])    # "Python" - du début au caractère 5
print(texte[7:])    # "slicing" - du caractère 7 à la fin
print(texte[::2])   # "Pto lcn" - un caractère sur deux

2️⃣ Comprendre les indices négatifs

Les indices négatifs comptent depuis la fin de la séquence : -1 est le dernier élément, -2 l’avant-dernier, etc.

Sur les listes

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

print(numbers[-3:])    # [7, 8, 9] - les 3 derniers éléments
print(numbers[:-3])    # [0, 1, 2, 3, 4, 5, 6] - tous sauf les 3 derniers
print(numbers[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] - liste inversée

Sur les chaînes

texte = "Python slicing"

print(texte[-7:])    # "slicing" - 7 derniers caractères
print(texte[:-7])    # "Python " - tous sauf les 7 derniers
print(texte[::-1])   # "gnicils nohtyP" - chaîne inversée

Astuce : [::-1] est le moyen le plus élégant d’inverser une séquence en Python !

3️⃣ Slicing sur les listes

Extraction de portions

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

print(fruits[1:4])   # ['mangue', 'banane', 'datte'] - index 1 à 3
print(fruits[:3])    # ['pomme', 'mangue', 'banane'] - 3 premiers
print(fruits[3:])    # ['datte', 'kiwi', 'figue'] - à partir de l'index 3
print(fruits[-3:])   # ['datte', 'kiwi', 'figue'] - 3 derniers
print(fruits[:-3])   # ['pomme', 'mangue', 'banane'] - tous sauf 3 derniers

4️⃣ Slicing avec un pas (step)

Le pas permet de sauter des éléments lors de l’extraction.

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

print(numbers[::2])   # [0, 2, 4, 6, 8] - tous les éléments pairs (index)
print(numbers[1::2])  # [1, 3, 5, 7, 9] - tous les éléments impairs (index)

Explication :

[::2] : commence à 0, prend un élément sur deux
[1::2] : commence à 1, prend un élément sur deux

5️⃣ Modifier une liste avec le slicing

Le slicing permet de modifier directement une portion de liste.

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

# Remplacer des éléments
letters[1:3] = ["x", "y"]
print(letters)  # ['a', 'x', 'y', 'd', 'e']

# Supprimer des éléments
letters[2:4] = []
print(letters)  # ['a', 'x', 'e']

Note : Cette fonctionnalité ne marche que sur les listes (mutables), pas sur les chaînes ou tuples (immuables).

6️⃣ Cas particulier : inverser une liste

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

Explication : Le pas négatif -1 parcourt la liste en sens inverse.

7️⃣ Slicing sur les chaînes de caractères

Les chaînes sont immuables, donc le slicing crée toujours de nouvelles chaînes.

texte = "Python est génial"

# Extraction
print(texte[0:6])    # "Python"
print(texte[7:10])   # "est"
print(texte[-6:])    # "génial"

# Inversion
print(texte[::-1])   # "laínég tse nohtyP"

Différence entre split() et slicing

phrase = "Python est génial"

# split() : découpe sur un séparateur
mots = phrase.split()
print(mots)  # ['Python', 'est', 'génial']

# slicing : découpe par position
premier_mot = phrase[0:6]
print(premier_mot)  # "Python"

8️⃣ Slicing sur les tuples

Les tuples fonctionnent exactement comme les listes, mais sont immuables.

couleurs = ("rouge", "vert", "bleu", "jaune", "orange")

# Extraction
print(couleurs[1:4])   # ('vert', 'bleu', 'jaune')
print(couleurs[-2:])   # ('jaune', 'orange')
print(couleurs[::2])   # ('rouge', 'bleu', 'orange')

# Inversion
print(couleurs[::-1])  # ('orange', 'jaune', 'bleu', 'vert', 'rouge')

Important : On ne peut PAS modifier un tuple avec le slicing (contrairement aux listes).

9️⃣ Slicing et copies en mémoire

Copie superficielle

original = [1, 2, 3, 4, 5]

# Crée une COPIE de la liste
copie = original[:]
copie[0] = 999

print(original)  # [1, 2, 3, 4, 5] - inchangé
print(copie)     # [999, 2, 3, 4, 5] - modifié

Explication : [:] crée une nouvelle liste en mémoire, pas juste une référence.

📋 Évaluation des connaissances

À quoi sert cette évaluation ?

Cette évaluation rapide (3 minutes) va vous permettre de vérifier votre compréhension du sujet traité dans ce guide.

Instructions :

🕒 Temps limité : 3 minutes
🎯 Seuil de réussite : 80%
💡 Les réponses seront expliquées à la fin

À vous de jouer ! 🚀

📝 Exercices pratiques

Exercice 1 : Extraction de sous-listes

Énoncé : Créez une liste de nombres de 0 à 9. Extrayez et affichez :

Les 5 premiers nombres
Les 5 derniers nombres
Les nombres de l’index 3 à 7
Un nombre sur trois

Exemple d’exécution :

nombres = list(range(10))
# Votre code ici

Voir la solution

nombres = list(range(10))
print(f"Liste complète : {nombres}")

# 5 premiers
premiers = nombres[:5]
print(f"5 premiers : {premiers}")

# 5 derniers
derniers = nombres[-5:]
print(f"5 derniers : {derniers}")

# Index 3 à 7
milieu = nombres[3:8]
print(f"Index 3 à 7 : {milieu}")

# Un sur trois
un_sur_trois = nombres[::3]
print(f"Un sur trois : {un_sur_trois}")

Résultat attendu :

Liste complète : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5 premiers : [0, 1, 2, 3, 4]
5 derniers : [5, 6, 7, 8, 9]
Index 3 à 7 : [3, 4, 5, 6, 7]
Un sur trois : [0, 3, 6, 9]

Exercice 2 : Manipulation de chaînes

Énoncé : Avec la chaîne “Programmation Python”, extrayez :

Le mot “Programmation”
Le mot “Python”
Les 5 premiers caractères
La chaîne inversée

Exemple d’exécution :

texte = "Programmation Python"
# Votre code ici

Voir la solution

texte = "Programmation Python"

# Mot "Programmation"
mot1 = texte[:13]
print(f"Mot 1 : {mot1}")

# Mot "Python"
mot2 = texte[14:]
print(f"Mot 2 : {mot2}")

# 5 premiers caractères
debut = texte[:5]
print(f"5 premiers : {debut}")

# Chaîne inversée
inverse = texte[::-1]
print(f"Inversé : {inverse}")

Résultat attendu :

Mot 1 : Programmation
Mot 2 : Python
5 premiers : Progr
Inversé : nohtyP noitammargorP

Exercice 3 : Modification de liste

Énoncé : Créez une liste notes = [12, 15, 8, 18, 14, 9, 16]. Utilisez le slicing pour :

Remplacer les notes d’index 2 à 4 par [10, 11, 12]
Supprimer les deux dernières notes
Afficher la liste finale

Exemple d’exécution :

notes = [12, 15, 8, 18, 14, 9, 16]
# Votre code ici

Voir la solution

notes = [12, 15, 8, 18, 14, 9, 16]
print(f"Liste initiale : {notes}")

# Remplacer index 2 à 4
notes[2:5] = [10, 11, 12]
print(f"Après remplacement : {notes}")

# Supprimer les 2 dernières
notes[-2:] = []
print(f"Après suppression : {notes}")

Résultat attendu :

Liste initiale : [12, 15, 8, 18, 14, 9, 16]
Après remplacement : [12, 15, 10, 11, 12, 9, 16]
Après suppression : [12, 15, 10, 11, 12]

Exercice 4 : Pairs et impairs

Énoncé : Créez une liste de nombres de 1 à 20. Utilisez le slicing pour extraire :

Tous les nombres pairs (indices pairs)
Tous les nombres impairs (indices impairs)
Inversez chaque liste

Exemple d’exécution :

nombres = list(range(1, 21))
# Votre code ici

Voir la solution

nombres = list(range(1, 21))
print(f"Liste complète : {nombres}")

# Nombres aux indices pairs (0, 2, 4...)
pairs = nombres[::2]
print(f"Indices pairs : {pairs}")

# Nombres aux indices impairs (1, 3, 5...)
impairs = nombres[1::2]
print(f"Indices impairs : {impairs}")

# Inversés
pairs_inverse = pairs[::-1]
impairs_inverse = impairs[::-1]

print(f"Pairs inversés : {pairs_inverse}")
print(f"Impairs inversés : {impairs_inverse}")

Résultat attendu :

Liste complète : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
Indices pairs : [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
Indices impairs : [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
Pairs inversés : [19, 17, 15, 13, 11, 9, 7, 5, 3, 1]
Impairs inversés : [20, 18, 16, 14, 12, 10, 8, 6, 4, 2]

Exercice 5 : Palindrome avec slicing

Énoncé : Créez une fonction est_palindrome(texte) qui vérifie si un mot est un palindrome en utilisant le slicing. Testez avec “radar”, “python” et “kayak”.

Exemple d’exécution :

def est_palindrome(texte):
    # Votre code ici
    pass

Voir la solution

def est_palindrome(texte):
    """Vérifie si un mot est un palindrome"""
    texte_minuscule = texte.lower()
    return texte_minuscule == texte_minuscule[::-1]

# Tests
mots = ["radar", "python", "kayak", "niveau", "code"]

print("🔍 Vérification des palindromes :")
print("-" * 40)

for mot in mots:
    resultat = "✅ Palindrome" if est_palindrome(mot) else "❌ Pas palindrome"
    print(f"{mot:<10} : {resultat}")

Résultat attendu :

🔍 Vérification des palindromes :
----------------------------------------
radar      : ✅ Palindrome
python     : ❌ Pas palindrome
kayak      : ✅ Palindrome
niveau     : ✅ Palindrome
code       : ❌ Pas palindrome

🎯 Conclusion

Le slicing est une technique essentielle en Python qui permet de manipuler efficacement les séquences. En maîtrisant la syntaxe [start:stop:step] et les indices négatifs, vous pouvez extraire, modifier et inverser des données en une seule ligne de code. C’est un outil puissant qui rend votre code plus pythonique et performant.

Bon codage ! 🐍✨

📢 Partagez cet article

LinkedIn Twitter Facebook WhatsApp

À propos de l'auteur

Riyad ODJOUADEExpert en cybersécurité & infrastructure

Je partage des guides techniques pratiques sur la cybersécurité, l'administration système et le développement web. Tous les contenus sont basés sur des expérimentations réelles.

LinkedIn GitHub Email