Introduction
Dans ce laboratoire, vous acquerrez une expérience pratique avec les chaînes de caractères (strings) en Python, un type de données fondamental. Vous commencerez par comprendre les bases des chaînes de caractères, y compris leur création, leur immuabilité et l'accès aux caractères individuels en utilisant l'indexation positive et négative.
En vous appuyant sur ces bases, vous apprendrez à extraire des sous-chaînes à l'aide du slicing (découpage), à utiliser divers opérateurs de chaînes et des caractères d'échappement pour la manipulation et le formatage spécial, et à explorer différentes méthodes pour formater les chaînes. Enfin, vous vous pencherez sur les méthodes de chaînes courantes pour effectuer des opérations telles que la recherche, le remplacement et la modification du contenu des chaînes.
Comprendre les bases des chaînes de caractères et l'indexation
Dans cette étape, vous apprendrez les concepts fondamentaux des chaînes de caractères (strings) en Python, y compris comment les créer et accéder aux caractères individuels en utilisant l'indexation. Les chaînes de caractères sont des séquences de caractères et constituent l'un des types de données les plus courants. Vous pouvez créer des chaînes en utilisant des apostrophes ('...') ou des guillemets doubles ("...").
Une caractéristique clé des chaînes de caractères Python est qu'elles sont immuables, ce qui signifie que leur contenu ne peut pas être modifié après leur création. Toute opération qui semble modifier une chaîne en crée en réalité une nouvelle.
Explorons cela. Dans l'environnement WebIDE, ouvrez le fichier string_basics.py dans le répertoire ~/project de l'explorateur de fichiers à gauche. Ajoutez-y le code suivant :
## string_basics.py
## Les chaînes sont immuables. L'assignation d'une nouvelle chaîne à une variable
## crée un nouvel objet chaîne avec une nouvelle adresse mémoire.
a = "hello"
print(f"Value: {a}, ID: {id(a)}")
a = "hi"
print(f"Value: {a}, ID: {id(a)}")
Pour exécuter le script, ouvrez un terminal dans l'WebIDE (Terminal -> New Terminal) et exécutez la commande suivante :
python ~/project/string_basics.py
Vous verrez une sortie similaire à celle-ci, où les valeurs d'ID sont différentes, confirmant qu'un nouvel objet chaîne a été créé.
Value: hello, ID: <placeholder>
Value: hi, ID: <placeholder>
Maintenant, explorons l'indexation des chaînes. Vous pouvez accéder aux caractères individuels en utilisant leur index (position). En Python, l'indexation commence à 0 pour le premier caractère.
Modifiez le fichier string_basics.py pour inclure l'indexation positive :
## string_basics.py
a = "Hello"
## Indexation positive (depuis le début)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])
## Accéder à un index qui n'existe pas provoquera une IndexError.
## print(a[5])
Enregistrez le fichier et exécutez-le à nouveau :
python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o
Python prend également en charge l'indexation négative, qui accède aux caractères depuis la fin de la chaîne. Le dernier caractère est à l'index -1, l'avant-dernier à -2, et ainsi de suite.
Ajoutez des exemples d'indexation négative à string_basics.py :
## string_basics.py
a = "Hello"
## Indexation positive (depuis le début)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])
## Indexation négative (depuis la fin)
print("\nNegative Indexing:")
print(a[-5])
print(a[-4])
print(a[-3])
print(a[-2])
print(a[-1])
## Comme les chaînes sont immuables, vous ne pouvez pas changer un caractère.
## La ligne suivante provoquerait une TypeError: 'str' object does not support item assignment
## a[0] = "J"
Enregistrez le fichier et exécutez-le une dernière fois pour cette étape :
python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o
Negative Indexing:
H
e
l
l
o
Découper les chaînes de caractères (Slicing)
Dans cette étape, vous apprendrez comment extraire des sous-chaînes d'une chaîne de caractères en utilisant le découpage (slicing). Alors que l'indexation permet d'obtenir un seul caractère, le découpage permet d'obtenir une séquence de caractères.
La syntaxe de base pour le découpage est string[start:end]. Ceci extrait la partie de la chaîne de l'index start jusqu'à, mais sans inclure, l'index end.
Ouvrez le fichier string_slicing.py dans le répertoire ~/project. Ajoutez le code suivant pour démontrer le découpage de base :
## string_slicing.py
a = "Hello World"
## Découper de l'index 0 jusqu'à (mais sans inclure) l'index 5
print(a[0:5])
## Découper de l'index 6 jusqu'à la fin de la chaîne
print(a[6:])
## Découper depuis le début jusqu'à (mais sans inclure) l'index 5
print(a[:5])
## Utilisation des indices négatifs pour le découpage
print(a[-5:-2])
## Obtenir une copie de la chaîne entière
print(a[:])
Enregistrez le fichier et exécutez-le depuis le terminal :
python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
Le découpage peut également prendre un troisième paramètre, step (pas), avec la syntaxe string[start:end:step]. La valeur de step détermine l'intervalle entre les caractères dans la tranche (slice).
Modifiez string_slicing.py pour inclure des exemples avec un pas :
## string_slicing.py
a = "Hello World"
## ... (code précédent) ...
b = "0123456789"
## Obtenir tous les deux caractères du début à la fin
print(b[::2])
## Obtenir les caractères de l'index 1 à 7, avec un pas de 3
print(b[1:7:3])
## Un pas négatif inverse la direction. Ceci inverse la chaîne entière.
print(b[::-1])
## Inverser de l'index 7 jusqu'à (mais sans inclure) l'index 2
print(b[7:2:-1])
Enregistrez le fichier et exécutez-le à nouveau :
python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543
Le découpage est tolérant et gère automatiquement les indices qui sont hors limites, ce qui empêche les erreurs.
Ajoutez ces dernières lignes à string_slicing.py pour observer ce comportement :
## string_slicing.py
a = "Hello World"
## ... (code précédent) ...
b = "0123456789"
## ... (code précédent) ...
## Découpage avec des indices hors limites
c = "Python"
## L'indice de fin est supérieur à la longueur de la chaîne, mais cela fonctionne correctement.
print(c[2:100])
## L'indice de début est avant le début, mais cela fonctionne correctement.
print(c[-100:4])
Enregistrez et exécutez le script :
python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543
thon
Pyth
Utiliser les opérateurs de chaînes de caractères et les caractères d'échappement
Dans cette étape, vous découvrirez les opérateurs courants utilisés avec les chaînes de caractères et comment utiliser les caractères d'échappement (escape characters) pour représenter des caractères spéciaux.
Python fournit plusieurs opérateurs pour la manipulation des chaînes. Les opérateurs in et not in vérifient l'existence de sous-chaînes, + concatène les chaînes, et * répète une chaîne.
Ouvrez le fichier string_operators.py dans l'WebIDE et ajoutez le code suivant :
## string_operators.py
## L'opérateur 'in' vérifie si une sous-chaîne existe dans une chaîne
print('e' in 'Hello')
print('x' in 'Hello')
## L'opérateur 'not in' est l'opposé de 'in'
print('e' not in 'Hello')
print('x' not in 'Hello')
## La concaténation (+) joint deux chaînes
print('Hello' + ' ' + 'World')
## La répétition (*) répète une chaîne un nombre de fois donné
print('=' * 20)
print('Go! ' * 3)
Enregistrez le fichier et exécutez-le :
python ~/project/string_operators.py
True
False
False
True
Hello World
====================
Go! Go! Go!
Ensuite, examinons les caractères d'échappement. Ce sont des séquences spéciales commençant par une barre oblique inverse (\) qui représentent des caractères non imprimables ou spéciaux.
Ouvrez le fichier escape_characters.py et ajoutez le code suivant :
## escape_characters.py
## Utiliser \' ou \" pour inclure des guillemets à l'intérieur d'une chaîne
print('It\'s a beautiful day.')
print("He said, \"Python is fun!\"")
## \n crée une nouvelle ligne
print("First line\nSecond line")
## \t crée une tabulation horizontale
print("Column1\tColumn2\tColumn3")
## \\ représente une barre oblique inverse littérale
print("This is a backslash: \\")
## Une chaîne brute (*raw string*), préfixée par 'r', traite les barres obliques inverses comme des caractères littéraux.
## Ceci est très utile pour les chemins de fichiers et les expressions régulières.
print("A normal string: C:\\Users\\new_folder")
print(r"A raw string: C:\Users\new_folder")
Enregistrez le fichier et exécutez-le :
python ~/project/escape_characters.py
It's a beautiful day.
He said, "Python is fun!"
First line
Second line
Column1 Column2 Column3
This is a backslash: \
A normal string: C:\Users\new_folder
A raw string: C:\Users\new_folder
Formatage des chaînes de caractères
Dans cette étape, vous découvrirez les méthodes modernes et efficaces pour formater les chaînes de caractères en Python. Ceci est crucial pour créer une sortie dynamique et lisible en intégrant des variables et des expressions dans les chaînes.
Bien que vous puissiez utiliser l'opérateur + pour concaténer des chaînes, cela devient maladroit lorsque l'on mélange des chaînes avec des types non-chaînes comme des nombres, car vous devez les convertir manuellement en utilisant str().
Python offre de meilleures solutions. La méthode la plus courante et recommandée est l'utilisation des f-strings (littéraux de chaînes formatées).
Formatage avec les f-strings
Les f-strings, introduites dans Python 3.6, offrent une manière concise et lisible d'intégrer des expressions à l'intérieur des chaînes. Il suffit de préfixer la chaîne par f ou F et d'écrire les expressions entre accolades {}.
Ouvrez le fichier string_formatting.py et ajoutez le code suivant :
## string_formatting.py
name = "Alice"
age = 30
## Utilisation d'une f-string pour intégrer des variables
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)
## Vous pouvez également intégrer des expressions directement
print(f"In 5 years, I will be {age + 5} years old.")
Enregistrez et exécutez le script :
python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
Spécificateurs de format (Format Specifiers)
Les f-strings vous permettent également de contrôler le formatage des valeurs intégrées en utilisant des spécificateurs de format, qui suivent deux-points (:) à l'intérieur des accolades.
Ajoutez les exemples suivants à string_formatting.py :
## string_formatting.py
## ... (code précédent) ...
pi = 3.14159265
## Formater un flottant à 2 décimales
print(f"The value of pi is approximately {pi:.2f}")
## Remplir un nombre avec des zéros non significatifs jusqu'à une largeur de 8
order_id = 45
print(f"Order ID: {order_id:08}")
## Aligner le texte dans un espace donné (largeur de 10)
## < (gauche), ^ (centre), > (droite)
text = "Python"
print(f"'{text:<10}'")
print(f"'{text:^10}'")
print(f"'{text:>10}'")
## Ajouter une virgule comme séparateur de milliers
large_number = 1234567890
print(f"A large number: {large_number:,}")
Enregistrez et exécutez à nouveau le script :
python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python '
' Python '
' Python'
A large number: 1,234,567,890
La méthode str.format()
Avant les f-strings, la méthode str.format() était la manière privilégiée de formater les chaînes. Elle fonctionne en plaçant des accolades {} comme espaces réservés dans la chaîne, puis en passant les valeurs à la méthode format().
Ajoutez cet exemple à la fin de string_formatting.py :
## string_formatting.py
## ... (code précédent) ...
## Utilisation de la méthode str.format()
item = "moon"
cost = 99.95
statement = "The {} costs {:.2f} dollars.".format(item, cost)
print(statement)
Enregistrez et exécutez le fichier pour voir le résultat :
python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python '
' Python '
' Python'
A large number: 1,234,567,890
The moon costs 99.95 dollars.
Bien que str.format() soit toujours utile, les f-strings sont généralement plus lisibles et plus rapides.
Explorer les méthodes de chaînes de caractères courantes
Dans cette dernière étape, vous allez explorer quelques-unes des méthodes intégrées (built-in methods) les plus courantes et utiles pour les objets chaîne de caractères. Ces méthodes effectuent diverses opérations telles que la modification de la casse, la recherche et le remplacement de texte, et la division des chaînes en listes.
Rappelez-vous que les chaînes sont immuables (immutable), donc ces méthodes retournent toujours une nouvelle chaîne et ne modifient pas celle d'origine.
Ouvrez le fichier string_methods.py et ajoutez le code suivant pour voir ces méthodes en action :
## string_methods.py
## Méthodes de conversion de casse
s1 = "Hello, World!"
print(f"Original: '{s1}'")
print(f"Upper case: '{s1.upper()}'")
print(f"Lower case: '{s1.lower()}'")
print(f"Title case: '{s1.title()}'")
print("-" * 20)
## Recherche et remplacement
s2 = "The quick brown fox jumps over the lazy dog."
print(f"Original: '{s2}'")
## Vérifier si une chaîne commence ou se termine par une sous-chaîne
print(f"Starts with 'The': {s2.startswith('The')}")
print(f"Ends with 'dog.': {s2.endswith('dog.')}")
## Trouver l'index d'une sous-chaîne (-1 si non trouvée)
print(f"Index of 'fox': {s2.find('fox')}")
## Remplacer une sous-chaîne par une autre
s3 = s2.replace("brown", "red")
print(f"After replace: '{s3}'")
print("-" * 20)
## Suppression des espaces blancs (*Stripping whitespace*)
s4 = " some whitespace "
print(f"Original: '{s4}'")
## strip() supprime des deux extrémités, lstrip() à gauche, rstrip() à droite
print(f"Stripped: '{s4.strip()}'")
print("-" * 20)
## Division (*Splitting*) et jointure (*Joining*)
s5 = "one,two,three,four"
print(f"Original: '{s5}'")
## Diviser la chaîne en une liste de sous-chaînes basée sur un délimiteur
parts = s5.split(',')
print(f"Split list: {parts}")
## Joindre les éléments d'une liste en une seule chaîne avec un séparateur
s6 = " ".join(parts)
print(f"Joined string: '{s6}'")
Enregistrez le fichier et exécutez-le depuis le terminal :
python ~/project/string_methods.py
Votre sortie devrait ressembler à ceci :
Original: 'Hello, World!'
Upper case: 'HELLO, WORLD!'
Lower case: 'hello, world!'
Title case: 'Hello, World!'
--------------------
Original: 'The quick brown fox jumps over the lazy dog.'
Starts with 'The': True
Ends with 'dog.': True
Index of 'fox': 16
After replace: 'The quick red fox jumps over the lazy dog.'
--------------------
Original: ' some whitespace '
Stripped: 'some whitespace'
--------------------
Original: 'one,two,three,four'
Split list: ['one', 'two', 'three', 'four']
Joined string: 'one two three four'
Ce ne sont que quelques-unes des nombreuses méthodes de chaînes de caractères disponibles en Python. Elles fournissent des outils puissants pour le traitement et la manipulation des données textuelles.
Résumé
Dans ce laboratoire, vous avez appris les concepts fondamentaux du travail avec les chaînes de caractères (strings) en Python. Vous avez commencé par les bases, en comprenant comment créer des chaînes et en reconnaissant leur nature immuable. Vous vous êtes exercé à accéder aux caractères individuels avec l'indexation positive et négative, et à extraire des sous-chaînes en utilisant le découpage (slicing) avec les paramètres de début (start), de fin (end) et de pas (step).
Vous avez ensuite exploré les opérateurs de chaînes pour la concaténation (+) et la répétition (*), et appris à utiliser les caractères d'échappement (escape characters) pour inclure des caractères spéciaux dans vos chaînes. Vous avez maîtrisé les techniques modernes de formatage de chaînes, en vous concentrant sur la puissance et la lisibilité des f-strings et de leurs spécificateurs de format, tout en découvrant également la méthode str.format(). Enfin, vous vous êtes exercé à utiliser des méthodes de chaînes courantes telles que upper(), lower(), replace(), strip(), split() et join() pour effectuer des tâches essentielles de manipulation de texte.
