Introduction
Dans ce laboratoire, vous explorerez les techniques fondamentales de manipulation des chaînes de caractères (strings) en Python. Les chaînes de caractères sont l'un des types de données les plus courants, et savoir comment les manipuler efficacement est une compétence cruciale pour tout programmeur Python. Nous couvrirons tous les aspects, depuis les définitions de base, l'utilisation de caractères spéciaux et la création de chaînes multilignes, jusqu'aux opérations plus avancées telles que l'accès aux sous-chaînes, la vérification de contenu, la modification de la casse, la recherche, la division (splitting) et le formatage de texte. À la fin de ce laboratoire, vous aurez une base solide pour gérer les données textuelles dans vos programmes Python.
Caractères d'Échappement et Chaînes Multilignes
Dans cette étape, vous apprendrez à gérer les caractères spéciaux au sein des chaînes de caractères, à créer des chaînes qui ignorent ces caractères spéciaux, et à définir des chaînes qui s'étendent sur plusieurs lignes.
Tout d'abord, explorons les caractères d'échappement (escape characters). Un caractère d'échappement est une barre oblique inverse (\) suivie d'un caractère que vous souhaitez insérer. Par exemple, \n représente un saut de ligne (newline), et \' représente une apostrophe.
Note: Si vous n'êtes pas familier avec l'utilisation de WebIDE (similaire à VS Code), veuillez vous familiariser avec celui-ci via ce laboratoire.
Ouvrez le fichier main.py depuis l'explorateur de fichiers à gauche. Ajoutez le code suivant :
## Caractères d'échappement : utilisez la barre oblique inverse pour insérer des caractères spéciaux
## \n = saut de ligne, \' = apostrophe
print("Hello there!\nHow are you?\nI\'m doing fine.")
Exécutez maintenant le script en ouvrant un terminal et en exécutant la commande ci-dessous. Vous pouvez ouvrir un nouveau terminal en cliquant sur l'icône + dans le panneau du terminal.
python3 main.py
Vous verrez la sortie avec les sauts de ligne et l'apostrophe insérés correctement.
Hello there!
How are you?
I'm doing fine.
Ensuite, examinons les chaînes brutes (raw strings). Une chaîne brute, préfixée par un r, ignore tous les caractères d'échappement et affiche toute barre oblique inverse qui apparaît dans la chaîne. Ceci est particulièrement utile pour les expressions régulières ou les chemins de fichiers.
Remplacez le contenu de main.py par le code suivant :
## Chaîne brute (préfixe r) : traite les barres obliques inverses comme des caractères littéraux
print(r"Hello there!\nHow are you?\nI\'m doing fine.")
Exécutez à nouveau le script :
python3 main.py
Remarquez comment \n et \' sont maintenant traités comme des caractères littéraux dans la sortie.
Hello there!\nHow are you?\nI\'m doing fine.
Enfin, vous pouvez créer des chaînes multi-lignes (multiline strings) en utilisant des triples guillemets (""" ou '''). C'est une manière pratique de définir des chaînes qui s'étendent sur plusieurs lignes, préservant ainsi la mise en forme.
Remplacez le contenu de main.py par cet exemple :
print(
"""Dear Alice,
Eve's cat has been arrested for catnapping,
cat burglary, and extortion.
Sincerely,
Bob"""
)
Exécutez le script :
python3 main.py
La sortie sera un message formaté et multi-lignes.
Dear Alice,
Eve's cat has been arrested for catnapping,
cat burglary, and extortion.
Sincerely,
Bob
Indexation et Découpage des Chaînes (Slicing)
Dans cette étape, vous apprendrez comment accéder aux caractères individuels et extraire des sous-chaînes en utilisant l'indexation et le découpage (slicing).
Les chaînes de caractères en Python sont des séquences, ce qui signifie que vous pouvez accéder à leurs parties en utilisant un index. L'indexation commence à 0 pour le premier caractère.
H e l l o w o r l d !
0 1 2 3 4 5 6 7 8 9 10 11
Effacez le fichier main.py et ajoutez le code suivant pour définir une chaîne :
spam = 'Hello world!'
Pour accéder au premier caractère ('H'), vous utilisez l'index 0. Pour accéder au cinquième caractère ('o'), vous utilisez l'index 4. Vous pouvez également utiliser des index négatifs pour compter à partir de la fin de la chaîne ; -1 fait référence au dernier caractère.
Ajoutez ces instructions print à main.py pour voir l'indexation en action :
spam = 'Hello world!'
## Indexation de chaîne : accès aux caractères par position (base 0)
print(spam[0]) ## Retourne le premier caractère
print(spam[4]) ## Retourne le cinquième caractère
print(spam[-1]) ## Retourne le dernier caractère
Exécutez le script :
python3 main.py
La sortie affichera les caractères individuels auxquels vous avez accédé.
H
o
!
Le découpage (slicing) vous permet d'extraire une portion d'une chaîne, appelée sous-chaîne (substring). La syntaxe est [début:fin], qui extrait les caractères à partir de l'index début jusqu'à, mais sans inclure, l'index fin.
Pratiquons le découpage. Remplacez le contenu de main.py par le code suivant. Nous allons explorer quelques façons différentes de découper la chaîne.
spam = 'Hello world!'
## Découpage de chaîne : extraction de sous-chaîne en utilisant la syntaxe [début:fin]
print(spam[0:5]) ## Retourne les caractères de l'index 0 à 4
print(spam[:5]) ## Omettre l'index de début prend la valeur 0 par défaut
print(spam[6:]) ## Omettre l'index de fin prend la valeur de fin de chaîne par défaut
print(spam[::-1]) ## Un pas (step) de -1 inverse la chaîne
Exécutez le script :
python3 main.py
Observez les différentes sous-chaînes créées par le découpage.
Hello
Hello
world!
!dlrow olleH
Appartenance et Méthodes de Cas des Chaînes
Dans cette étape, vous apprendrez comment vérifier si une sous-chaîne existe dans une chaîne et comment modifier et valider la casse (majuscules/minuscules) d'une chaîne.
Les opérateurs in et not in sont utilisés pour vérifier l'appartenance à une chaîne. Ils retournent une valeur booléenne : True ou False.
Effacez le fichier main.py et ajoutez le code suivant pour tester ces opérateurs. Notez que la comparaison est sensible à la casse (case-sensitive).
## The 'in' and 'not in' operators
print('Hello' in 'Hello World')
print('HELLO' in 'Hello World')
print('cats' not in 'cats and dogs')
Exécutez le script pour voir les résultats booléens :
python3 main.py
True
False
False
Python fournit également plusieurs méthodes pour modifier la casse d'une chaîne. Les méthodes upper(), lower() et title() retournent respectivement une nouvelle chaîne entièrement en majuscules, entièrement en minuscules, ou en casse de titre (où chaque mot commence par une majuscule).
Remplacez le contenu de main.py par ce qui suit :
greet = 'Hello world!'
print(greet.upper())
print(greet.lower())
print(greet.title())
Exécutez le script :
python3 main.py
Vous verrez les chaînes transformées.
HELLO WORLD!
hello world!
Hello World!
Pour vérifier si une chaîne est déjà dans une casse spécifique, vous pouvez utiliser les méthodes isupper() et islower(). Ces méthodes retournent True si tous les caractères ayant une casse dans la chaîne sont de la casse spécifiée et s'il y a au moins un caractère ayant une casse.
Remplacez le contenu de main.py par ces exemples :
spam = 'Hello world!'
print(spam.islower())
print('HELLO'.isupper())
## Ceci est vrai car les caractères non alphabétiques sont ignorés
print('abc12345'.islower())
## Ceci est faux car il n'y a aucun caractère ayant une casse
print('12345'.islower())
Exécutez le script pour vérifier la casse de chaque chaîne.
python3 main.py
False
True
True
False
Recherche et Division des Chaînes (Searching and Splitting)
Dans cette étape, vous apprendrez comment vérifier si une chaîne commence ou se termine par une sous-chaîne spécifique, comment joindre une liste de chaînes en une seule chaîne, et comment diviser une chaîne en une liste de sous-chaînes.
Les méthodes startswith() et endswith() sont utiles pour vérifier le début ou la fin d'une chaîne. Elles retournent True ou False.
Effacez main.py et ajoutez le code suivant :
print('Hello world!'.startswith('Hello'))
print('Hello world!'.endswith('world!'))
print('abc123'.startswith('abcdef'))
Exécutez le script pour voir les résultats :
python3 main.py
True
True
False
La méthode join() est appelée sur une chaîne séparatrice et prend un itérable (comme une liste) comme argument. Elle combine les éléments de l'itérable en une seule chaîne, le séparateur étant placé entre chaque élément.
Remplacez le contenu de main.py par ces exemples pour voir comment fonctionne join() :
## Jointure avec un séparateur virgule et espace
print(', '.join(['cats', 'rats', 'bats']))
## Jointure avec un séparateur espace
print(' '.join(['My', 'name', 'is', 'Simon']))
Exécutez le script :
python3 main.py
cats, rats, bats
My name is Simon
La méthode split() fait l'inverse de join(). Elle est appelée sur une chaîne et la divise en une liste de sous-chaînes. Par défaut, elle divise sur les espaces blancs (whitespace), mais vous pouvez fournir un délimiteur spécifique.
Remplacez le contenu de main.py par le code suivant pour pratiquer la division de chaînes :
## Division par l'espace blanc par défaut
print('My name is Simon'.split())
## Division par un délimiteur spécifique 'ABC'
print('MyABCnameABCisABCSimon'.split('ABC'))
Exécutez le script pour voir les listes résultantes :
python3 main.py
['My', 'name', 'is', 'Simon']
['My', 'name', 'is', 'Simon']
Justification et Nettoyage des Chaînes
Dans cette étape, vous apprendrez comment formater l'alignement du texte et comment supprimer les caractères indésirables, tels que les espaces blancs, du début ou de la fin d'une chaîne.
Python fournit des méthodes pour justifier le texte dans une largeur donnée : rjust() (justification à droite), ljust() (justification à gauche) et center(). Ces méthodes retournent une nouvelle chaîne complétée (padding).
Effacez le fichier main.py et ajoutez le code suivant :
print('Hello'.rjust(10))
print('Hello'.ljust(10))
print('Hello'.center(20))
Exécutez le script pour voir le texte aligné. Les guillemets simples dans la sortie aident à visualiser le remplissage (padding).
python3 main.py
Hello
Hello
Hello
Vous pouvez également fournir un deuxième argument optionnel pour spécifier un caractère de remplissage autre que l'espace. Remplacez le contenu de main.py par ceci :
print('Hello'.rjust(20, '*'))
print('Hello'.center(20, '='))
Exécutez à nouveau le script :
python3 main.py
***************Hello
=======Hello========
Pour nettoyer les chaînes, vous pouvez utiliser les méthodes strip(), rstrip() et lstrip(). Celles-ci sont utilisées pour supprimer des caractères aux extrémités d'une chaîne. Par défaut, elles suppriment les caractères d'espacement (espaces, tabulations, sauts de ligne).
Remplacez le contenu de main.py par cet exemple :
spam = ' Hello World '
print(spam.strip()) ## Supprime des deux côtés
print(spam.lstrip()) ## Supprime du côté gauche
print(spam.rstrip()) ## Supprime du côté droit
Exécutez le script pour voir les chaînes nettoyées :
python3 main.py
Hello World
Hello World
Hello World
Vous pouvez également passer un argument de chaîne à ces méthodes pour spécifier quels caractères supprimer. La méthode supprimera tous les caractères de l'argument qui se trouvent aux extrémités de la chaîne.
Remplacez le contenu de main.py une dernière fois :
spam = 'SpamSpamBaconSpamEggsSpamSpam'
## Supprime tous les caractères 'S', 'p', 'a', 'm' des extrémités
print(spam.strip('ampS'))
Exécutez le script :
python3 main.py
La sortie montre que les parties "Spam" extérieures ont été supprimées, laissant la partie centrale de la chaîne.
BaconSpamEggs
Résumé
Dans ce laboratoire, vous avez maîtrisé les techniques essentielles de manipulation de chaînes (string manipulation) en Python. Vous avez appris à utiliser les caractères d'échappement (escape characters) et à créer des chaînes multilignes pour une meilleure représentation du texte. Vous vous êtes exercé à accéder à des parties d'une chaîne en utilisant l'indexation (indexing) et le découpage (slicing). Vous avez également exploré de puissantes méthodes de chaînes pour vérifier l'appartenance (in, not in), changer la casse (upper(), lower()), valider la casse (isupper(), islower()), rechercher (startswith(), endswith()), joindre et diviser, et enfin, formater et nettoyer le texte (rjust(), strip()). Ces compétences sont fondamentales pour toute tâche impliquant le traitement de texte en Python.
