- À propos du slicing des chaînes de caractères en Python
- Comprendre la syntaxe chaine[debut:fin]
- Extraire une sous-chaîne à partir du début
- Extraire une sous-chaîne jusqu'à la fin
- Utiliser les indices négatifs dans un slicing
- Utiliser un pas avec la syntaxe chaine[debut:fin:pas]
- Extraire un caractère sur plusieurs
- Inverser une chaîne avec le slicing
- Copier une chaîne avec le slicing
- Comprendre les indices hors limites
- Combiner slicing et len()
- Exemples pratiques d'utilisation du slicing
- À retenir !
1. À propos du slicing des chaînes de caractères en Python
En Python, une chaîne de caractères est une séquence ordonnée de caractères. Chaque caractère possède un indice et il est possible d'utiliser ces indices pour sélectionner une partie de la chaîne. Cette opération est appelée slicing, que l'on peut traduire par découpage ou extraction d'une tranche.
Le slicing permet d'obtenir une sous-chaîne sans modifier la chaîne d'origine. Il est notamment possible de sélectionner plusieurs caractères consécutifs, les premiers ou les derniers caractères, un caractère sur plusieurs ou encore d'inverser une chaîne.
Dans cet exemple simple, le slicing permet d'extraire les six premiers caractères de la chaîne.
1 2 3 | texte = "Python facile" resultat = texte[0:6] print(resultat) |
Sortie :
1 | Python |
Le résultat obtenu est une nouvelle chaîne contenant uniquement les caractères sélectionnés.
2. Comprendre la syntaxe chaine[debut:fin]
La forme la plus courante du slicing Python utilise deux indices séparés par deux-points. Le premier indique où commence l'extraction et le second indique où elle doit s'arrêter.
La syntaxe générale est chaine[debut:fin]. Le caractère correspondant à l'indice debut est inclus, tandis que celui correspondant à l'indice fin est exclu.
Dans la chaîne "Python", les indices positifs vont de 0 à 5. Le slicing [1:4] sélectionne donc les caractères d'indices 1, 2 et 3.
1 2 | texte = "Python" print(texte[1:4]) |
Sortie :
1 | yth |
Le caractère d'indice 4, qui est "o", n'est pas inclus dans le résultat.
3. Extraire une sous-chaîne à partir du début
Lorsque l'indice de début est omis, Python commence automatiquement le slicing au début de la chaîne. La notation [:fin] est donc équivalente à [0:fin].
Dans l'exemple suivant, nous extrayons les six premiers caractères.
1 2 | texte = "Python facile" print(texte[:6]) |
Sortie :
1 | Python |
Les deux écritures [0:6] et [:6] donnent exactement le même résultat.
1 2 3 | texte = "Programmation" print(texte[0:7]) print(texte[:7]) |
Sortie :
1 2 | Program Program |
La notation [:n] est particulièrement pratique lorsque nous souhaitons récupérer les n premiers caractères d'une chaîne.
1 2 3 | mot = "Informatique" n = 4 print(mot[:n]) |
Sortie :
1 | Info |
4. Extraire une sous-chaîne jusqu'à la fin
Lorsque l'indice de fin est omis, Python poursuit automatiquement l'extraction jusqu'à la fin de la chaîne. La syntaxe devient alors chaine[debut:].
Dans l'exemple suivant, l'extraction commence à l'indice 7 et se poursuit jusqu'au dernier caractère.
1 2 | texte = "Python facile" print(texte[7:]) |
Sortie :
1 | facile |
Cette notation est utile lorsqu'on connaît le début de la partie à récupérer, mais que l'on ne souhaite pas calculer l'indice du dernier caractère.
Nous pouvons par exemple supprimer les cinq premiers caractères d'une chaîne en conservant tout ce qui suit.
1 2 3 | texte = "2026-Python" resultat = texte[5:] print(resultat) |
Sortie :
1 | Python |
Le slicing ne modifie pas la chaîne originale. Il produit une chaîne correspondant aux caractères sélectionnés.
5. Utiliser les indices négatifs dans un slicing
Le slicing accepte également les indices négatifs. L'indice -1 correspond au dernier caractère, -2 à l'avant-dernier, et ainsi de suite.
La notation [-3:] permet par exemple de récupérer les trois derniers caractères d'une chaîne.
1 2 | texte = "Python" print(texte[-3:]) |
Sortie :
1 | hon |
De la même manière, la notation [:-3] permet de conserver toute la chaîne sauf les trois derniers caractères.
1 2 | texte = "Python" print(texte[:-3]) |
Sortie :
1 | Pyt |
Il est également possible d'utiliser deux indices négatifs pour sélectionner une zone située vers la fin de la chaîne. Dans "Programmation", l'indice -7 correspond au premier "m" et l'indice -3 au caractère "i". Comme la borne de fin est exclue, "i" n'est pas sélectionné.
1 2 | texte = "Programmation" print(texte[-7:-3]) |
Sortie :
1 | mmat |
Les indices négatifs sont donc particulièrement pratiques lorsqu'une extraction doit être effectuée relativement à la fin de la chaîne.
6. Utiliser un pas avec la syntaxe chaine[debut:fin:pas]
Le slicing possède une forme plus complète permettant d'ajouter un troisième paramètre appelé pas. Celui-ci indique l'écart entre deux caractères sélectionnés. La syntaxe générale est chaine[debut:fin:pas].
Avec un pas égal à 2, Python sélectionne un caractère sur deux dans l'intervalle considéré.
1 2 | texte = "Python" print(texte[0:6:2]) |
Sortie :
1 | Pto |
Les caractères sélectionnés sont ceux d'indices 0, 2 et 4.
Lorsque le début et la fin sont omis, le pas peut être appliqué à toute la chaîne.
1 2 | texte = "0123456789" print(texte[::2]) |
Sortie :
1 | 02468 |
Le pas ne peut pas être égal à zéro. Un slicing avec un pas égal à zéro provoque une exception ValueError.
7. Extraire un caractère sur plusieurs
Le paramètre pas permet de sélectionner facilement un caractère sur deux, un caractère sur trois ou selon tout autre intervalle non nul.
Dans cet exemple, [::3] sélectionne un caractère tous les trois caractères à partir du début.
1 2 | texte = "ABCDEFGHIJKL" print(texte[::3]) |
Sortie :
1 | ADGJ |
Nous pouvons également choisir un point de départ différent. Ici, l'extraction commence à l'indice 1 puis avance avec un pas de 2.
1 2 | texte = "0123456789" print(texte[1::2]) |
Sortie :
1 | 13579 |
Cette technique peut servir à séparer les caractères placés aux indices pairs et impairs.
1 2 3 4 5 | texte = "Python" indices_pairs = texte[::2] indices_impairs = texte[1::2] print("Indices pairs :", indices_pairs) print("Indices impairs :", indices_impairs) |
Sortie :
1 2 | Indices pairs : Pto Indices impairs : yhn |
8. Inverser une chaîne avec le slicing
Le pas peut également être négatif. Dans ce cas, le parcours s'effectue de droite à gauche. La notation [::-1] constitue une méthode très connue pour inverser une chaîne en Python.
L'exemple suivant inverse complètement le mot "Python".
1 2 3 | texte = "Python" inverse = texte[::-1] print(inverse) |
Sortie :
1 | nohtyP |
Cette technique peut notamment être utilisée pour vérifier simplement si une chaîne est un palindrome, c'est-à-dire si elle se lit de la même manière dans les deux sens.
1 2 3 4 5 | mot = "radar" if mot == mot[::-1]: print("Le mot est un palindrome.") else: print("Le mot n'est pas un palindrome.") |
Sortie :
1 | Le mot est un palindrome. |
Un pas négatif peut aussi être utilisé avec des bornes pour parcourir seulement une partie de la chaîne en sens inverse.
1 2 | texte = "0123456789" print(texte[7:2:-1]) |
Sortie :
1 | 76543 |
9. Copier une chaîne avec le slicing
Lorsque les indices de début et de fin sont tous les deux omis, la notation [:] sélectionne toute la chaîne.
L'exemple suivant récupère l'intégralité du contenu de la chaîne.
1 2 3 | texte = "Python facile" copie = texte[:] print(copie) |
Sortie :
1 | Python facile |
La notation [:] est souvent présentée comme une copie par slicing. Dans le cas des chaînes, il faut surtout retenir que les objets str sont immuables : on ne peut pas modifier directement leurs caractères.
Le slicing peut être combiné avec d'autres chaînes pour construire une nouvelle valeur.
1 2 3 4 | texte = "Python" nouveau = texte[:3] + "HON" print("Original :", texte) print("Nouveau :", nouveau) |
Sortie :
1 2 | Original : Python Nouveau : PytHON |
La chaîne originale reste inchangée.
10. Comprendre les indices hors limites
Lorsqu'on accède directement à un caractère avec un indice inexistant, Python provoque une exception IndexError. Le slicing possède cependant un comportement différent : les bornes qui dépassent la longueur de la chaîne sont ajustées automatiquement.
Dans l'exemple suivant, l'indice de fin 100 dépasse largement la longueur de la chaîne, mais aucune erreur n'est générée.
1 2 | texte = "Python" print(texte[0:100]) |
Sortie :
1 | Python |
Si l'indice de départ se trouve après la fin de la chaîne avec un pas positif, le résultat est une chaîne vide.
1 2 3 4 | texte = "Python" resultat = texte[20:30] print("Résultat :", resultat) print("Longueur :", len(resultat)) |
Sortie :
1 2 | Résultat : Longueur : 0 |
Cette tolérance aux bornes dépassant les limites rend le slicing particulièrement pratique pour certaines opérations d'extraction.
11. Combiner slicing et len()
La fonction len() peut être associée au slicing lorsque les bornes doivent être calculées à partir de la longueur de la chaîne.
Le programme suivant utilise len() pour récupérer la partie de la chaîne qui commence à son indice central.
1 2 3 4 | texte = "Programmation" milieu = len(texte) // 2 print("Longueur :", len(texte)) print("À partir du milieu :", texte[milieu:]) |
Sortie :
1 2 | Longueur : 13 À partir du milieu : mmation |
Comme "Programmation" contient 13 caractères, l'opérateur // donne 6. Le slicing commence donc à l'indice 6. Pour une chaîne de longueur impaire, il est préférable de parler ici de la partie commençant à l'indice central plutôt que de deux moitiés strictement égales.
Pour une chaîne de longueur paire, nous pouvons en revanche obtenir deux parties de même longueur.
1 2 3 4 5 6 | texte = "Python2026" milieu = len(texte) // 2 premiere_partie = texte[:milieu] deuxieme_partie = texte[milieu:] print("Première partie :", premiere_partie) print("Deuxième partie :", deuxieme_partie) |
Sortie :
1 2 | Première partie : Pytho Deuxième partie : n2026 |
Dans de nombreux cas, les indices négatifs permettent d'obtenir une écriture plus courte. Pour récupérer les quatre derniers caractères, [-4:] est plus simple qu'un calcul explicite utilisant len().
1 2 | texte = "document.pdf" print(texte[-4:]) |
Sortie :
1 | .pdf |
12. Exemples pratiques d'utilisation du slicing
Extraire une partie d'un code
Lorsqu'une chaîne possède une structure fixe, le slicing permet d'en extraire rapidement différentes parties. Dans cet exemple, les quatre premiers caractères représentent une année.
1 2 3 4 5 | code = "2026-PYTHON" annee = code[:4] langage = code[5:] print("Année :", annee) print("Langage :", langage) |
Sortie :
1 2 | Année : 2026 Langage : PYTHON |
Masquer une partie d'un numéro
Le slicing permet de conserver uniquement certains caractères d'une donnée avant de construire une nouvelle chaîne. Ici, seuls les quatre derniers chiffres sont conservés.
1 2 3 | numero = "1234567890123456" masque = "************" + numero[-4:] print(masque) |
Sortie :
1 | ************3456 |
Extraire le nom d'un fichier sans son extension
Lorsque l'extension possède une longueur connue, un indice négatif permet de retirer cette partie de la chaîne. Pour une extension de quatre caractères telle que ".txt", [:-4] conserve tout ce qui la précède.
1 2 3 4 5 | fichier = "cours_python.txt" nom = fichier[:-4] extension = fichier[-4:] print("Nom :", nom) print("Extension :", extension) |
Sortie :
1 2 | Nom : cours_python Extension : .txt |
Extraire les premiers et les derniers caractères
Le slicing permet également de récupérer rapidement une partie située au début et une autre située à la fin d'une chaîne.
1 2 3 4 5 | texte = "Programmation" debut = texte[:4] fin = texte[-4:] print("Début :", debut) print("Fin :", fin) |
Sortie :
1 2 | Début : Prog Fin : tion |
13. À retenir !
Le slicing en Python est une technique fondamentale permettant d'extraire facilement une sous-chaîne à partir d'une chaîne de caractères.
- La syntaxe chaine[debut:fin] extrait les caractères depuis l'indice debut inclus jusqu'à l'indice fin exclu.
- La syntaxe chaine[:fin] extrait les caractères depuis le début.
- La syntaxe chaine[debut:] extrait les caractères depuis l'indice debut jusqu'à la fin.
- Les indices négatifs permettent de compter les positions à partir de la fin de la chaîne.
- La syntaxe complète est chaine[debut:fin:pas].
- Un pas égal à 2 permet de sélectionner un caractère sur deux.
- Un pas négatif permet de parcourir les caractères dans le sens inverse.
- La notation chaine[::-1] permet d'inverser une chaîne.
- La notation chaine[:] sélectionne toute la chaîne.
- Les bornes d'un slicing peuvent dépasser la longueur de la chaîne sans provoquer d'IndexError.
- Le slicing ne modifie pas le contenu de la chaîne originale.
Le programme suivant résume les principales formes de slicing à connaître pour manipuler efficacement les chaînes de caractères.
1 2 3 4 5 6 7 | texte = "Python facile" print("Chaîne complète :", texte[:]) print("Six premiers caractères :", texte[:6]) print("À partir de l'indice 7 :", texte[7:]) print("Trois derniers caractères :", texte[-3:]) print("Un caractère sur deux :", texte[::2]) print("Chaîne inversée :", texte[::-1]) |
Sortie :
1 2 3 4 5 6 | Chaîne complète : Python facile Six premiers caractères : Python À partir de l'indice 7 : facile Trois derniers caractères : ile Un caractère sur deux : Pto aie Chaîne inversée : elicaf nohtyP |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
