5. Travailler avec du texte grâce aux chaînes de caractères

Le texte est partout en programmation. De l'affichage de messages aux utilisateurs au traitement de fichiers de données, en passant par la création d'applications web, travailler avec du texte est l'une des compétences les plus fondamentales que vous développerez en tant que programmeur. En Python, nous travaillons avec du texte à l'aide des chaînes de caractères (strings) — des séquences de caractères qui peuvent représenter des mots, des phrases ou tout type de données textuelles.

Vous avez déjà rencontré les chaînes de caractères brièvement dans les chapitres précédents en utilisant print() et input(). Nous allons maintenant explorer les chaînes en profondeur, apprendre à les créer, les manipuler et utiliser les puissantes fonctionnalités intégrées de Python pour résoudre des problèmes réels de traitement de texte.

Dans ce chapitre, vous apprendrez à créer des chaînes avec des caractères spéciaux, à combiner des chaînes entre elles, à extraire des parties spécifiques de chaînes, à changer leur casse et leur formatage, à chercher du texte à l'intérieur de chaînes, et à comprendre pourquoi les chaînes se comportent différemment des nombres lorsqu'il s'agit de modification. À la fin, vous aurez une base solide pour travailler avec du texte en Python.

5.1) Littéraux de chaînes et séquences d'échappement

5.1.1) Créer des littéraux de chaînes

Un littéral de chaîne (string literal) est une valeur de chaîne écrite directement dans votre code. Vous avez déjà vu des chaînes créées avec des apostrophes (') ou des guillemets ("):

python

# string_basics.py
greeting = 'Hello, World!'
message = "Python is great!"
 
print(greeting)  # Output: Hello, World!
print(message)   # Output: Python is great!

Les apostrophes et les guillemets fonctionnent de manière identique en Python — le choix vous appartient. Cependant, disposer des deux options est utile lorsque votre chaîne contient elle‑même des caractères de guillemets :

python

# quotes_in_strings.py
# Utiliser des guillemets lorsque la chaîne contient une apostrophe
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# Utiliser des apostrophes lorsque la chaîne contient des guillemets
quote = 'She said, "Hello!"'
print(quote)  # Output: She said, "Hello!"

Si vous devez inclure le même type de guillemet que celui qui entoure votre chaîne, vous pouvez l'échapper avec une barre oblique inversée (\) :

python

# escaping_quotes.py
# Échapper une apostrophe à l'intérieur d'une chaîne délimitée par des apostrophes
sentence = 'It\'s a beautiful day!'
print(sentence)  # Output: It's a beautiful day!
 
# Échapper des guillemets à l'intérieur d'une chaîne délimitée par des guillemets
quote = "She said, \"Hello!\""
print(quote)  # Output: She said, "Hello!"

La barre oblique inversée indique à Python que le guillemet suivant fait partie du contenu de la chaîne, et non de sa fin.

5.1.2) Chaînes multilignes avec triples guillemets

Pour les chaînes qui s'étendent sur plusieurs lignes, Python fournit les triples guillemets — soit trois apostrophes ('''), soit trois guillemets (""") :

python

# multiline_strings.py
poem = """Roses are red,
Violets are blue,
Python is awesome,
And so are you!"""
 
print(poem)
# Output:
# Roses are red,
# Violets are blue,
# Python is awesome,
# And so are you!

Les chaînes entre triples guillemets conservent tous les sauts de ligne et les espacements exactement tels que vous les tapez. Elles sont particulièrement utiles pour de longs blocs de texte, les chaînes de documentation (que nous verrons au chapitre 19), ou lorsque vous devez inclure à la fois des apostrophes et des guillemets sans les échapper :

python

# triple_quotes_convenience.py
dialogue = '''The teacher said, "Don't forget: it's important to practice!"'''
print(dialogue)  # Output: The teacher said, "Don't forget: it's important to practice!"

5.1.3) Séquences d'échappement courantes

Au‑delà de l'échappement des guillemets, la barre oblique inversée introduit des séquences d'échappement — des combinaisons spéciales de deux caractères qui représentent des caractères difficiles ou impossibles à taper directement :

python

# escape_sequences.py
# Newline: passe à la ligne suivante
print("First line\nSecond line")
# Output:
# First line
# Second line
 
# Tab: insère un espacement horizontal
print("Name:\tJohn\nAge:\t25")
# Output:
# Name:	John
# Age:	25
 
# Backslash: pour inclure une barre oblique inversée littérale
path = "C:\\Users\\Documents"
print(path)  # Output: C:\Users\Documents

Voici les séquences d'échappement les plus couramment utilisées :

Séquence d'échappement	Signification	Exemple de sortie
`\n`	Saut de ligne	Deux lignes
`\t`	Tabulation (espacement horizontal)	Texte indenté
`\\`	Barre oblique inversée	caractère `\`
`\'`	Apostrophe	caractère `'`
`\"`	Guillemets	caractère `"`

Comprendre les séquences d'échappement est crucial lorsque vous travaillez avec des chemins de fichiers (en particulier sous Windows, qui utilise les barres obliques inversées), des sorties formatées, ou tout texte nécessitant un formatage spécial.

5.1.4) Chaînes brutes pour les barres obliques inversées littérales

Parfois, vous voulez que les barres obliques inversées soient traitées littéralement, sans déclencher de séquences d'échappement. C'est courant lorsque vous travaillez avec des chemins de fichiers ou des expressions régulières (que nous aborderons brièvement au chapitre 39). Python fournit les chaînes brutes (raw strings) en préfixant la chaîne avec r :

python

# raw_strings.py
# Chaîne normale : les barres obliques inversées déclenchent des séquences d'échappement
regular = "C:\new\test"
print(regular)  # Output: C:
                #         ew   est
                # (\n devient un saut de ligne, \t devient une tabulation)
 
# Chaîne brute : les barres obliques inversées sont littérales
raw = r"C:\new\test"
print(raw)  # Output: C:\new\test

Dans une chaîne brute, \n est littéralement les deux caractères barre oblique inversée et n, pas un saut de ligne. Les chaînes brutes sont particulièrement utiles pour les chemins de fichiers Windows :

python

# windows_paths.py
# Sans chaîne brute, vous devez échapper chaque barre oblique inversée
path1 = "C:\\Users\\John\\Documents\\file.txt"
 
# Avec une chaîne brute, les barres obliques inversées fonctionnent naturellement
path2 = r"C:\Users\John\Documents\file.txt"
 
print(path1)  # Output: C:\Users\John\Documents\file.txt
print(path2)  # Output: C:\Users\John\Documents\file.txt

Les deux approches produisent le même résultat, mais les chaînes brutes sont plus lisibles lorsque vous avez beaucoup de barres obliques inversées.

5.2) Concaténation et répétition de chaînes

5.2.1) Concaténer des chaînes avec +

Vous pouvez combiner des chaînes en utilisant l'opérateur +, ce que l'on appelle la concaténation :

python

# string_concatenation.py
first_name = "John"
last_name = "Smith"
 
# Combiner des chaînes avec +
full_name = first_name + " " + last_name
print(full_name)  # Output: John Smith
 
# Construire des chaînes plus longues
greeting = "Hello, " + full_name + "!"
print(greeting)  # Output: Hello, John Smith!

La concaténation crée une nouvelle chaîne en plaçant les chaînes bout à bout. Notez que Python n'ajoute pas automatiquement d'espaces — vous devez les inclure explicitement :

python

# concatenation_spacing.py
word1 = "Hello"
word2 = "World"
 
# Sans espace
no_space = word1 + word2
print(no_space)  # Output: HelloWorld
 
# Avec espace
with_space = word1 + " " + word2
print(with_space)  # Output: Hello World

Vous pouvez concaténer autant de chaînes que vous le souhaitez dans une seule expression :

python

# multiple_concatenation.py
address = "123" + " " + "Main" + " " + "Street"
print(address)  # Output: 123 Main Street

Limite importante : vous ne pouvez concaténer des chaînes qu'avec d'autres chaînes. Essayer de concaténer une chaîne avec un nombre provoquera une erreur :

python

# concatenation_error.py
age = 25
# Ceci provoquera une erreur :
# message = "I am " + age + " years old"  # TypeError!
 
# Vous devez d'abord convertir le nombre en chaîne
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Nous explorerons plus en détail la conversion chaîne/nombre dans la section 5.6.

5.2.2) Répéter des chaînes avec *

Python fournit un moyen pratique de répéter une chaîne plusieurs fois à l'aide de l'opérateur * :

python

# string_repetition.py
separator = "-" * 20
print(separator)  # Output: --------------------
 
# Créer des motifs
pattern = "abc" * 3
print(pattern)  # Output: abcabcabc
 
# Utile pour formater la sortie
print("=" * 30)
print("Important Message")
print("=" * 30)
# Output:
# ==============================
# Important Message
# ==============================

L'opérateur de répétition fonctionne avec n'importe quel entier positif :

python

# repetition_examples.py
# Répéter zéro fois donne une chaîne vide
nothing = "Hello" * 0
print(nothing)      # Output: (empty string)
print(len(nothing)) # Output: 0
 
# Répéter une fois donne la chaîne d'origine
once = "Hello" * 1
print(once)  # Output: Hello
 
# Répétitions plus grandes
many = "Go! " * 5
print(many)  # Output: Go! Go! Go! Go! Go!

La répétition de chaînes est particulièrement utile pour créer des séparateurs visuels, du remplissage (padding), ou générer des données de test :

python

# practical_repetition.py
# Créer une simple boîte de texte
width = 40
border = "=" * width
title = "Welcome"
padding = " " * ((width - len(title)) // 2)
 
print(border)
print(padding + title)
print(border)
# Output:
# ========================================
#                 Welcome
# ========================================

5.2.3) Combiner concaténation et répétition

Vous pouvez combiner les deux opérateurs dans la même expression, en respectant les règles de priorité des opérateurs de Python (la multiplication avant l'addition, comme pour les nombres) :

python

# combined_operations.py
# La répétition se produit d'abord, puis la concaténation
result = "=" * 10 + " Title " + "=" * 10
print(result)  # Output: ========== Title ==========
 
# Utiliser des parenthèses pour contrôler l'ordre
repeated_phrase = ("Hello " + "World ") * 3
print(repeated_phrase)  # Output: Hello World Hello World Hello World

Ces opérations constituent la base de la manipulation de chaînes, vous permettant de construire des chaînes complexes à partir d'éléments simples.

5.3) Indexation et tranchage (slicing) des chaînes

Les chaînes en Python sont des séquences de caractères, ce qui signifie que chaque caractère possède une position spécifique. Vous pouvez accéder à des caractères individuels ou extraire des portions de chaîne en utilisant l'indexation et le tranchage (slicing).

5.3.1) Comprendre les indices de chaîne

Chaque caractère dans une chaîne possède une position numérique appelée indice (index). Python utilise l'indexation basée sur zéro (zero‑based indexing), ce qui signifie que le premier caractère est à l'indice 0, le deuxième à l'indice 1, et ainsi de suite :

python

# string_indexing.py
text = "Python"
 
# Accéder aux caractères individuels par indice
print(text[0])  # Output: P (first character)
print(text[1])  # Output: y (second character)
print(text[5])  # Output: n (sixth character)

Voici une représentation visuelle de la façon dont les indices correspondent aux caractères :

String:  P  y  t  h  o  n
Index:   0  1  2  3  4  5

Python prend également en charge les indices négatifs, qui comptent à partir de la fin de la chaîne. L'indice -1 fait référence au dernier caractère, -2 à l'avant‑dernier, et ainsi de suite :

python

# negative_indexing.py
text = "Python"
 
print(text[-1])  # Output: n (last character)
print(text[-2])  # Output: o (second-to-last)
print(text[-6])  # Output: P (first character)

Les indices négatifs sont particulièrement utiles lorsque vous souhaitez accéder à des caractères proches de la fin d'une chaîne sans connaître sa longueur exacte :

String:    P  y  t  h  o  n
Positive:  0  1  2  3  4  5
Negative: -6 -5 -4 -3 -2 -1

Important : essayer d'accéder à un indice qui n'existe pas provoquera une IndexError :

python

# index_error.py
text = "Python"
 
# Ceci fonctionne
print(text[5])  # Output: n
 
# Ceci provoque une erreur car l'indice 6 n'existe pas
# print(text[6])  # IndexError: string index out of range

5.3.2) Découper des chaînes avec des tranches (slicing) pour extraire des sous‑chaînes

Alors que l'indexation vous donne un seul caractère, le tranchage (slicing) vous permet d'extraire une portion de chaîne (appelée sous‑chaîne, substring). La syntaxe de base est :

string[start:stop]

Cela extrait les caractères de l'indice start jusqu'à (mais sans inclure) l'indice stop :

python

# basic_slicing.py
text = "Python Programming"
 
# Extraire les caractères de l'indice 0 jusqu'à (mais sans inclure) 6
print(text[0:6])  # Output: Python
 
# Extraire les caractères de l'indice 7 jusqu'à 18
print(text[7:18])  # Output: Programming
 
# Extraire une portion au milieu
print(text[7:11])  # Output: Prog

L'élément clé à retenir est que l'indice stop n'est pas inclus dans le résultat. Pensez aux indices comme pointant entre les caractères :

 P  y  t  h  o  n
 0  1  2  3  4  5  6

Ainsi, text[0:6] signifie « commencer à la position 0 et s'arrêter avant la position 6 », ce qui vous donne les caractères aux positions 0, 1, 2, 3, 4 et 5.

5.3.3) Omettre les indices de début ou de fin

Vous pouvez omettre l'indice start pour découper depuis le début, ou omettre l'indice stop pour découper jusqu'à la fin :

python

# omitting_indices.py
text = "Python Programming"
 
# Du début jusqu'à l'indice 6
print(text[:6])  # Output: Python
 
# De l'indice 7 jusqu'à la fin
print(text[7:])  # Output: Programming
 
# La chaîne entière (du début à la fin)
print(text[:])  # Output: Python Programming

Ces raccourcis sont très courants dans le code Python car ils rendent les intentions claires et évitent de coder en dur des longueurs.

5.3.4) Utiliser des indices négatifs dans les tranches

Les indices négatifs fonctionnent également dans les tranches, vous permettant de compter à partir de la fin :

python

# negative_slice_indices.py
text = "Python Programming"
 
# Les 11 derniers caractères
print(text[-11:])  # Output: Programming
 
# Tout sauf les 11 derniers caractères
print(text[:-11])  # Output: Python
 
# Les 7 derniers caractères
print(text[-7:])  # Output: ramming
 
# De l'indice 7 jusqu'au troisième caractère en partant de la fin
print(text[7:-3])  # Output: Programm (s'arrête avant 'ing')

Les indices négatifs sont particulièrement utiles lorsque vous souhaitez exclure un certain nombre de caractères à partir de la fin :

python

# removing_suffix.py
filename = "document.txt"
 
# Récupérer tout sauf les 4 derniers caractères (.txt)
name_without_extension = filename[:-4]
print(name_without_extension)  # Output: document

5.3.5) Tranchage avec une valeur de pas (step)

Les tranches peuvent inclure une troisième valeur appelée pas (step), qui détermine combien de caractères sont sautés :

string[start:stop:step]

python

# slicing_with_step.py
text = "Python Programming"
 
# Un caractère sur deux dans la chaîne entière
print(text[::2])  # Output: Pto rgamn
 
# Un caractère sur deux de l'indice 0 à 6
print(text[0:6:2])  # Output: Pto
 
# Un caractère sur trois
print(text[::3])  # Output: Ph oai

Une astuce particulièrement utile consiste à utiliser un pas de -1 pour inverser une chaîne :

python

# reversing_strings.py
text = "Python"
 
# Inverser la chaîne entière
reversed_text = text[::-1]
print(reversed_text)  # Output: nohtyP
 
# Exemple pratique : vérifier un palindrome
word = "radar"
if word == word[::-1]:
    print(f"{word} is a palindrome!")  # Output: radar is a palindrome!

5.3.6) Le tranchage ne provoque jamais d'erreur

Contrairement à l'indexation, le tranchage est très tolérant. Si vous spécifiez des indices hors limites, Python les ajuste simplement pour qu'ils rentrent dans la plage :

python

# safe_slicing.py
text = "Python"
 
# Tout ceci fonctionne sans erreur
print(text[0:100])   # Output: Python (s'arrête à la fin)
print(text[10:20])   # Output: (empty string - start is beyond end)
print(text[-100:3])  # Output: Pyt (start ajusté à 0)

Ce comportement rend le tranchage sûr à utiliser même lorsque vous n'êtes pas sûr de la longueur exacte de la chaîne.

5.3.7) Exemples pratiques de tranchage

Voici quelques motifs courants que vous utiliserez fréquemment :

python

# practical_slicing.py
text = "Hello, World!"
 
# Les 5 premiers caractères
print(text[:5])  # Output: Hello
 
# Les 6 derniers caractères
print(text[-6:])  # Output: World!
 
# Tout sauf le premier et le dernier caractère
print(text[1:-1])  # Output: ello, World
 
# Un caractère sur deux
print(text[::2])  # Output: Hlo ol!
 
# Inverser la chaîne
print(text[::-1])  # Output: !dlroW ,olleH

Comprendre l'indexation et le tranchage est fondamental pour le traitement de texte en Python. Ces techniques apparaîtront à de nombreuses reprises tout au long de votre parcours de programmation.

5.4) Méthodes de chaînes courantes pour la casse et les espaces

Les chaînes Python disposent de nombreuses méthodes intégrées — des fonctions attachées aux objets chaîne qui effectuent des opérations sur eux. Dans cette section, nous allons explorer les méthodes permettant de changer la casse et de gérer les espaces, qui sont essentielles pour nettoyer et mettre en forme le texte.

5.4.1) Comprendre les méthodes de chaînes

Une méthode (method) est appelée en utilisant la notation pointée : string.method_name(). Les méthodes sont des fonctions qui appartiennent à un type d'objet spécifique. Pour les chaînes, Python fournit des dizaines de méthodes utiles :

python

# method_basics.py
text = "hello"
 
# Appeler une méthode sur une chaîne
result = text.upper()
print(result)  # Output: HELLO
 
# La chaîne d'origine est inchangée (nous verrons pourquoi en section 5.8)
print(text)  # Output: hello

Les méthodes peuvent être chaînées, car chaque méthode renvoie une nouvelle chaîne :

python

# method_chaining.py
text = "  hello world  "
 
# Chaîner plusieurs méthodes
result = text.strip().upper().replace("WORLD", "PYTHON")
print(result)  # Output: HELLO PYTHON

5.4.2) Méthodes de conversion de casse

Python fournit plusieurs méthodes pour changer la casse des chaînes :

python

# case_methods.py
text = "Python Programming"
 
# Convertir en majuscules
print(text.upper())  # Output: PYTHON PROGRAMMING
 
# Convertir en minuscules
print(text.lower())  # Output: python programming
 
# Mettre la première lettre en majuscule, et le reste en minuscules
print(text.capitalize())  # Output: Python programming
 
# Title case : première lettre de chaque mot en majuscule
print(text.title())  # Output: Python Programming

Ces méthodes sont particulièrement utiles pour normaliser la saisie utilisateur :

python

# case_normalization.py
# Simulation de saisie utilisateur
user_input = "YES"
 
# Comparaison insensible à la casse
if user_input.lower() == "yes":
    print("User confirmed!")  # Output: User confirmed!
 
# Autre approche en utilisant upper()
command = "start"
if command.upper() == "START":
    print("Starting process...")  # Output: Starting process...

La méthode title() met en majuscule la première lettre de chaque mot, ce qui est utile pour formater des noms et des titres :

python

# title_case.py
name = "john smith"
print(name.title())  # Output: John Smith
 
book = "the great gatsby"
print(book.title())  # Output: The Great Gatsby

Cependant, sachez que title() a des limites avec les apostrophes et certains cas particuliers :

python

# title_limitations.py
text = "it's a beautiful day"
print(text.title())  # Output: It'S A Beautiful Day (note the capital S)
 
# Pour un title case plus sophistiqué, vous aurez peut-être besoin d'une logique personnalisée

La méthode capitalize() ne met en majuscule que le tout premier caractère de la chaîne entière :

python

# capitalize_examples.py
sentence = "python is great"
print(sentence.capitalize())  # Output: Python is great
 
# Remarque : seule la première lettre est en majuscule
multi_word = "hello world"
print(multi_word.capitalize())  # Output: Hello world (not Hello World)

5.4.3) Méthodes de vérification de casse

Python fournit également des méthodes pour vérifier la casse des chaînes :

python

# case_checking.py
text1 = "HELLO"
text2 = "hello"
text3 = "Hello World"
 
# Vérifier si tous les caractères sont en majuscule
print(text1.isupper())  # Output: True
print(text2.isupper())  # Output: False
 
# Vérifier si tous les caractères sont en minuscule
print(text1.islower())  # Output: False
print(text2.islower())  # Output: True
 
# Vérifier si la chaîne est en title case
print(text3.istitle())  # Output: True
print(text2.istitle())  # Output: False

Ces méthodes de vérification renvoient True ou False (valeurs booléennes que nous avons vues au chapitre 3), ce qui les rend parfaites pour les conditions :

python

# case_checking_conditions.py
password = "SECRET123"
 
if password.isupper():
    print("Password is all uppercase")  # Output: Password is all uppercase

5.4.4) Méthodes de suppression des espaces

Les espaces blancs (whitespace) incluent les espaces, les tabulations (\t) et les sauts de ligne (\n). Python fournit des méthodes pour supprimer les espaces aux extrémités des chaînes :

python

# whitespace_removal.py
text = "   Hello, World!   "
 
# Supprimer les espaces aux deux extrémités
print(text.strip())  # Output: Hello, World!
 
# Supprimer les espaces à gauche (début)
print(text.lstrip())  # Output: Hello, World!   
 
# Supprimer les espaces à droite (fin)
print(text.rstrip())  # Output:    Hello, World!

La méthode strip() est extrêmement utile pour nettoyer la saisie utilisateur :

python

# cleaning_input.py
# Simulation de saisie utilisateur avec des espaces supplémentaires
user_name = "  John Smith  "
 
# Nettoyer la saisie
clean_name = user_name.strip()
print(f"Welcome, {clean_name}!")  # Output: Welcome, John Smith!

Ces méthodes suppriment également les tabulations et les sauts de ligne :

python

# strip_all_whitespace.py
text = "\n\t  Hello  \t\n"
print(repr(text))  # Output: '\n\t  Hello  \t\n'
 
cleaned = text.strip()
print(repr(cleaned))  # Output: 'Hello'

Notez que strip(), lstrip() et rstrip() ne suppriment les espaces qu'aux extrémités, pas au milieu :

python

# strip_edges_only.py
text = "  Hello   World  "
print(text.strip())  # Output: Hello   World (spaces in middle remain)

5.4.5) Supprimer des caractères spécifiques

Les méthodes de type strip peuvent aussi supprimer des caractères spécifiques (pas seulement des espaces) aux extrémités :

python

# Remove multiple different characters
text = "...Hello!!!"
cleaned = text.strip(".!")
print(cleaned)  # Output: Hello

Lorsque vous passez une chaîne à strip(), elle supprime toute combinaison de ces caractères aux extrémités :

python

# strip_character_set.py
text = "xxxyyyHelloyyyxxx"
 
# Supprimer tous les x ou y aux deux extrémités
result = text.strip("xy")
print(result)  # Output: Hello

5.4.6) Exemples pratiques combinant casse et méthodes sur les espaces

Voici des scénarios réels où ces méthodes sont inestimables :

python

# practical_text_cleaning.py
# Nettoyer et normaliser la saisie utilisateur
user_email = "  JohnSmith@EXAMPLE.com  "
clean_email = user_email.strip().lower()
print(clean_email)  # Output: johnsmith@example.com
 
# Formater correctement des noms
raw_name = "  john smith  "
formatted_name = raw_name.strip().title()
print(formatted_name)  # Output: John Smith
 
# Traiter des commandes (insensibles à la casse)
command = "  START  "
if command.strip().upper() == "START":
    print("Command recognized!")  # Output: Command recognized!

Ces méthodes constituent la base du nettoyage et de la normalisation de texte, que vous utiliserez constamment pour traiter la saisie utilisateur, lire des fichiers ou préparer des données pour l'analyse.

5.5) Recherche et remplacement dans les chaînes

Trouver et modifier du texte dans des chaînes est une tâche courante en programmation. Python fournit des méthodes puissantes pour rechercher des sous‑chaînes et remplacer du texte.

5.5.1) Trouver des sous‑chaînes avec find() et index()

La méthode find() recherche une sous‑chaîne et renvoie l'indice où elle apparaît en premier :

python

# find_method.py
text = "Python is great. Python is powerful."
 
# Trouver la première occurrence de "Python"
position = text.find("Python")
print(position)  # Output: 0 (found at the beginning)
 
# Trouver "great"
position = text.find("great")
print(position)  # Output: 10
 
# Trouver quelque chose qui n'existe pas
position = text.find("Java")
print(position)  # Output: -1 (not found)

La méthode find() renvoie -1 si la sous‑chaîne n'est pas trouvée, ce qui la rend sûre à utiliser sans provoquer d'erreur :

python

# safe_searching.py
text = "Hello, World!"
 
# Vérifier si une sous-chaîne existe
if text.find("World") != -1:
    print("Found 'World'!")  # Output: Found 'World'!
 
if text.find("Python") == -1:
    print("'Python' not found")  # Output: 'Python' not found

Vous pouvez également rechercher une sous‑chaîne à partir d'une position spécifique :

python

# find_with_start.py
text = "Python is great. Python is powerful."
 
# Trouver la première occurrence
first = text.find("Python")
print(first)  # Output: 0
 
# Trouver l'occurrence suivante après la première
second = text.find("Python", first + 1)
print(second)  # Output: 17

La méthode index() fonctionne de manière similaire à find(), mais lève une erreur si la sous‑chaîne n'est pas trouvée :

python

# index_method.py
text = "Hello, World!"
 
# Ceci fonctionne
position = text.index("World")
print(position)  # Output: 7
 
# Ceci provoquerait une ValueError :
# position = text.index("Python")  # ValueError: substring not found

Quand utiliser laquelle :

Utilisez find() lorsque vous voulez vérifier si quelque chose existe (renvoie -1 si non trouvé)
Utilisez index() lorsque vous vous attendez à ce que la sous‑chaîne soit présente (lève une erreur si non trouvée)

python

# choosing_find_vs_index.py
text = "Python Programming"
 
# Utiliser find() pour un test sûr
if text.find("Java") != -1:
    print("Found Java")
else:
    print("Java not found")  # Output: Java not found
 
# Utiliser index() lorsque vous êtes sûr que cela existe
position = text.index("Python")  # Nous savons que Python est présent
print(f"Found at position {position}")  # Output: Found at position 0

5.5.2) Recherche depuis la fin avec rfind() et rindex()

Les méthodes rfind() et rindex() recherchent à partir de la droite (fin) de la chaîne :

python

# rfind_method.py
text = "Python is great. Python is powerful."
 
# Trouver la dernière occurrence de "Python"
last_position = text.rfind("Python")
print(last_position)  # Output: 17
 
# Comparer avec find() qui donne la première occurrence
first_position = text.find("Python")
print(first_position)  # Output: 0

C'est utile lorsque vous voulez la dernière occurrence de quelque chose :

python

# last_occurrence.py
filename = "document.backup.txt"
 
# Trouver le dernier point (pour obtenir l'extension du fichier)
last_dot = filename.rfind(".")
if last_dot != -1:
    extension = filename[last_dot:]
    print(extension)  # Output: .txt

5.5.3) Compter les occurrences avec count()

La méthode count() vous indique combien de fois une sous‑chaîne apparaît :

python

# count_method.py
text = "Python is great. Python is powerful. Python is fun."
 
# Compter le nombre de fois que "Python" apparaît
count = text.count("Python")
print(count)  # Output: 3
 
# Compter un caractère
letter_count = text.count("o")
print(f"Letter 'o' appears {letter_count} times")  # Output: Letter 'o' appears 4 times

Vous pouvez également compter dans une plage spécifique :

python

# count_in_range.py
text = "abcabcabc"
 
# Compter "abc" dans la chaîne entière
total = text.count("abc")
print(total)  # Output: 3
 
# Compter "abc" seulement dans les 6 premiers caractères
partial = text.count("abc", 0, 6)
print(partial)  # Output: 2

5.5.4) Remplacer du texte avec replace()

La méthode replace() crée une nouvelle chaîne dans laquelle toutes les occurrences d'une sous‑chaîne sont remplacées :

python

# replace_method.py
text = "I love Java. Java is great."
 
# Remplacer toutes les occurrences de "Java" par "Python"
new_text = text.replace("Java", "Python")
print(new_text)  # Output: I love Python. Python is great.
 
# La chaîne d'origine est inchangée
print(text)  # Output: I love Java. Java is great.

Vous pouvez limiter le nombre de remplacements avec un troisième argument :

python

# limited_replace.py
text = "one one one one"
 
# Remplacer seulement les 2 premières occurrences
result = text.replace("one", "two", 2)
print(result)  # Output: two two one one

La méthode replace() est sensible à la casse :

python

# case_sensitive_replace.py
text = "Python is great. python is powerful."
 
# Ceci remplace uniquement "Python" (P majuscule)
result = text.replace("Python", "Java")
print(result)  # Output: Java is great. python is powerful.

Pour un remplacement insensible à la casse, vous devez le gérer manuellement :

python

# case_insensitive_approach.py
text = "Python is great. python is powerful."
 
# Convertir en minuscules, remplacer, mais cela perd la casse d'origine
result = text.lower().replace("python", "java")
print(result)  # Output: java is great. java is powerful.

5.5.5) Exemples pratiques de recherche et remplacement

Voici des scénarios réels où ces méthodes sont particulièrement utiles :

python

# practical_search_replace.py
# Nettoyer des données : supprimer des caractères indésirables
phone = "123-456-7890"
clean_phone = phone.replace("-", "")
print(clean_phone)  # Output: 1234567890
 
# Censurer des mots
message = "This is a bad word and another bad word."
censored = message.replace("bad", "***")
print(censored)  # Output: This is a *** word and another *** word.
 
# Extraire l'extension de fichier
filename = "document.txt"
dot_position = filename.rfind(".")
if dot_position != -1:
    extension = filename[dot_position + 1:]
    print(f"File type: {extension}")  # Output: File type: txt
 
# Compter les occurrences d'un mot (approche simple)
text = "Python is fun. I love Python. Python rocks!"
word = "Python"
occurrences = text.count(word)
print(f"'{word}' appears {occurrences} times")  # Output: 'Python' appears 3 times

Ces méthodes de recherche et de remplacement sont des outils fondamentaux pour le traitement de texte, le nettoyage de données et la manipulation de chaînes dans les programmes Python.

5.6) Conversion entre chaînes et nombres

L'une des tâches les plus courantes en programmation est la conversion entre représentations textuelles et numériques. Lorsque vous lisez la saisie utilisateur avec input(), vous obtenez une chaîne — même si l'utilisateur tape un nombre. De même, lorsque vous souhaitez afficher des nombres dans du texte, vous devez les convertir en chaînes.

5.6.1) Convertir des chaînes en nombres

Nous avons déjà vu les fonctions int() et float() au chapitre 3, mais explorons‑les plus en détail :

python

# string_to_number.py
# Convertir une chaîne en entier
age_text = "25"
age = int(age_text)
print(age)        # Output: 25
print(type(age))  # Output: <class 'int'>
 
# Convertir une chaîne en flottant
price_text = "19.99"
price = float(price_text)
print(price)        # Output: 19.99
print(type(price))  # Output: <class 'float'>

Ces conversions sont essentielles pour traiter la saisie utilisateur :

python

# user_input_conversion.py
# Simulation de saisie utilisateur (en vrai, vous utiliseriez input())
user_age = "30"
user_height = "5.9"
 
# Convertir en nombres pour pouvoir faire des calculs
age = int(user_age)
height = float(user_height)
 
# Nous pouvons maintenant effectuer des calculs
print(f"In 10 years, you'll be {age + 10}")  # Output: In 10 years, you'll be 40
print(f"Your height in meters: {height * 0.3048:.2f}")  # Output: Your height in meters: 1.80

Important : la chaîne doit représenter un nombre valide, sinon vous aurez une erreur :

python

# conversion_errors.py
# Ceci fonctionne
print(int("123"))      # Output: 123
print(float("3.14"))   # Output: 3.14
 
# Ceci provoque une ValueError :
# print(int("hello"))     # ValueError: invalid literal for int()
# print(int("12.5"))      # ValueError: invalid literal for int() with base 10
# print(float("12.5.3"))  # ValueError: could not convert string to float

Nous apprendrons à gérer ces erreurs proprement au chapitre 28. Pour l'instant, sachez que la conversion peut échouer si la chaîne ne représente pas un nombre valide.

5.6.2) Gestion des espaces dans les chaînes numériques

Les fonctions de conversion de Python gèrent automatiquement les espaces au début et à la fin :

python

# whitespace_handling.py
# Tout ceci fonctionne malgré les espaces
print(int("  42  "))      # Output: 42
print(float("  3.14  "))  # Output: 3.14
 
# Combiner strip() avec la conversion pour plus de sécurité
user_input = "  100  "
number = int(user_input.strip())
print(number)  # Output: 100

C'est utile pour traiter la saisie utilisateur, qui contient souvent des espaces supplémentaires.

5.6.3) Convertir des nombres en chaînes

La fonction str() convertit n'importe quelle valeur en sa représentation sous forme de chaîne :

python

# number_to_string.py
age = 25
height = 5.9
 
# Convertir des nombres en chaînes
age_text = str(age)
height_text = str(height)
 
print(type(age_text))     # Output: <class 'str'>
print(type(height_text))  # Output: <class 'str'>
 
# Nous pouvons maintenant les concaténer avec d'autres chaînes
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

C'est nécessaire chaque fois que vous voulez combiner des nombres avec des chaînes :

python

# concatenation_with_numbers.py
score = 95
total = 100
 
# Il faut convertir les nombres en chaînes pour la concaténation
result = "Score: " + str(score) + "/" + str(total)
print(result)  # Output: Score: 95/100
 
# Alternative : utiliser les f-strings (détaillées au chapitre 6)
result = f"Score: {score}/{total}"
print(result)  # Output: Score: 95/100

5.6.4) Conversion entre entier et flottant

Vous pouvez également convertir entre les types entier et flottant :

python

# int_float_conversion.py
# Float vers int (tronque la partie décimale)
price = 19.99
price_int = int(price)
print(price_int)  # Output: 19 (decimal part removed, not rounded)
 
# Int vers float
age = 25
age_float = float(age)
print(age_float)  # Output: 25.0

Important : convertir un flottant en entier tronque (coupe) la partie décimale — cela n'arrondit pas :

python

# truncation_not_rounding.py
print(int(3.9))   # Output: 3 (not 4!)
print(int(3.1))   # Output: 3
print(int(-3.9))  # Output: -3 (truncates toward zero)
 
# Pour arrondir, utilisez d'abord la fonction round() (vue au chapitre 4)
print(int(round(3.9)))  # Output: 4

5.6.5) Exemples pratiques de conversion

Voici des scénarios réels où la conversion de type est essentielle :

python

# practical_conversions.py
# Lecture et traitement de la saisie utilisateur
# (Simulation de input() - en vrai, vous utiliseriez input())
user_input = "42"
 
# Convertir en nombre pour faire des calculs
number = int(user_input)
doubled = number * 2
print(f"Double of {number} is {doubled}")  # Output: Double of 42 is 84
 
# Construire une sortie formatée
name = "John"
age = 30
height = 5.9
 
# Méthode 1 : convertir les nombres en chaînes
info = name + " is " + str(age) + " years old and " + str(height) + " feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# Méthode 2 : utiliser les f-strings (plus lisible - détaillé au chapitre 6)
info = f"{name} is {age} years old and {height} feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# Traitement de données provenant de fichiers (aperçu)
data_line = "100,200,300"  # Simulation d'une ligne provenant d'un fichier CSV
numbers = data_line.split(",")  # Découper en liste de chaînes
total = int(numbers[0]) + int(numbers[1]) + int(numbers[2])
print(f"Total: {total}")  # Output: Total: 600

5.6.6) Pièges courants de conversion

Soyez attentif à ces erreurs fréquentes :

python

# conversion_pitfalls.py
# Piège 1 : essayer de convertir des chaînes non numériques
# text = "hello"
# number = int(text)  # ValueError!
 
# Piège 2 : oublier de convertir avant l'arithmétique
age_text = "25"
# next_year = age_text + 1  # TypeError: can only concatenate str to str
 
# Approche correcte :
age = int(age_text)
next_year = age + 1
print(next_year)  # Output: 26
 
# Piège 3 : perdre de la précision avec int()
price = 19.99
price_int = int(price)  # Devient 19, pas 20 !
print(price_int)  # Output: 19
 
# Piège 4 : essayer de convertir des chaînes avec des virgules ou des symboles monétaires
# price_text = "$1,234.56"
# price = float(price_text)  # ValueError!
 
# Vous devez d'abord nettoyer la chaîne :
price_text = "$1,234.56"
clean_price = price_text.replace("$", "").replace(",", "")
price = float(clean_price)
print(price)  # Output: 1234.56

Comprendre la conversion de types est crucial pour créer des programmes qui interagissent avec les utilisateurs et traitent des données réelles. Vous utiliserez ces conversions constamment tout au long de votre parcours en Python.

5.7) Vérifier des sous‑chaînes avec in et not in

Python fournit des moyens simples et lisibles de vérifier si une chaîne en contient une autre à l'aide des opérateurs in et not in. Ils sont extrêmement utiles pour la validation, le filtrage et la prise de décision dans vos programmes.

5.7.1) Utiliser in pour vérifier des sous‑chaînes

L'opérateur in renvoie True si une chaîne est trouvée dans une autre, et False sinon :

python

# in_operator.py
text = "Python is a powerful programming language"
 
# Vérifier si une sous-chaîne existe
print("Python" in text)      # Output: True
print("powerful" in text)    # Output: True
print("Java" in text)        # Output: False

C'est bien plus lisible que d'utiliser find() ou index() :

python

# in_vs_find.py
text = "Hello, World!"
 
# Utiliser in (clair et lisible)
if "World" in text:
    print("Found World!")  # Output: Found World!
 
# Utiliser find (moins lisible)
if text.find("World") != -1:
    print("Found World!")  # Output: Found World!

L'opérateur in est sensible à la casse :

python

# case_sensitivity.py
text = "Python Programming"
 
print("python" in text)   # Output: False (lowercase 'p')
print("Python" in text)   # Output: True (uppercase 'P')
 
# Pour une vérification insensible à la casse, convertissez d'abord en minuscules
print("python" in text.lower())  # Output: True

5.7.2) Utiliser not in pour vérifier l'absence

L'opérateur not in vérifie qu'une sous‑chaîne n'est PAS présente :

python

# not_in_operator.py
text = "Python is great"
 
print("Java" not in text)     # Output: True (Java est absent)
print("Python" not in text)   # Output: False (Python est présent)

C'est particulièrement utile pour la validation :

python

# validation_examples.py
# Vérifier l'absence de caractères invalides dans un nom d'utilisateur
username = "john_smith"
 
if " " not in username:
    print("Username is valid (no spaces)")  # Output: Username is valid (no spaces)

5.7.3) Méthodes supplémentaires de vérification de chaînes

Python fournit plusieurs autres méthodes utiles pour vérifier des propriétés de chaînes :

python

# string_checking_methods.py
text = "Python"
 
# Vérifier si la chaîne commence par une sous-chaîne
print(text.startswith("Py"))   # Output: True
print(text.startswith("Ja"))   # Output: False
 
# Vérifier si la chaîne se termine par une sous-chaîne
print(text.endswith("on"))     # Output: True
print(text.endswith("ing"))    # Output: False
 
# Ces méthodes sont plus précises que l'utilisation de in
filename = "report.txt"
print(filename.endswith(".txt"))  # Output: True
print(".txt" in filename)         # Output: True (but less precise)
 
# startswith/endswith peuvent vérifier plusieurs options
filename = "document.pdf"
print(filename.endswith((".pdf", ".doc", ".txt")))  # Output: True

Ces méthodes de vérification sont des outils essentiels pour la validation de saisie, le filtrage de données et la logique conditionnelle dans vos programmes. Elles rendent votre code plus lisible et plus facile à maintenir que des recherches de chaînes manuelles.

5.8) Les chaînes sont immuables : ce que cela signifie en pratique

L'une des caractéristiques les plus importantes des chaînes Python est qu'elles sont immutables — une fois créées, elles ne peuvent pas être modifiées. Cela peut sembler être une limitation au début, mais comprendre l'immuabilité est crucial pour écrire du code Python correct et éviter des bogues subtils.

5.8.1) Ce que signifie l'immuabilité

Lorsque nous disons que les chaînes sont immuables, nous voulons dire que vous ne pouvez pas modifier les caractères d'une chaîne existante. Toute opération qui semble « modifier » une chaîne crée en réalité une nouvelle chaîne :

python

# immutability_basics.py
text = "Hello"
 
# Cela semble modifier la chaîne, mais ce n'est pas le cas
text = text + " World"
print(text)  # Output: Hello World
 
# Ce qui s'est réellement passé :
# 1. Python a créé une nouvelle chaîne "Hello World"
# 2. La variable 'text' fait maintenant référence à cette nouvelle chaîne
# 3. La chaîne "Hello" d'origine existe toujours (jusqu'à ce qu'elle soit collectée par le garbage collector)

Vous ne pouvez pas changer des caractères individuels dans une chaîne :

python

# cannot_modify_characters.py
text = "Hello"
 
# Ceci provoque une erreur :
# text[0] = "J"  # TypeError: 'str' object does not support item assignment
 
# Vous devez créer une nouvelle chaîne à la place
text = "J" + text[1:]
print(text)  # Output: Jello

Ceci est fondamentalement différent de la façon dont fonctionnent les listes (que nous verrons au chapitre 13). Les listes sont mutables — vous pouvez changer leurs éléments :

python

# lists_are_mutable.py
# Aperçu des listes (détaillé au chapitre 13)
numbers = [1, 2, 3]
numbers[0] = 10  # Ceci fonctionne pour les listes
print(numbers)   # Output: [10, 2, 3]
 
# Mais les chaînes ne le permettent pas :
text = "Hello"
# text[0] = "J"  # TypeError avec les chaînes !

5.8.2) Pourquoi les méthodes de chaînes renvoient de nouvelles chaînes

Toutes les méthodes de chaînes qui semblent modifier une chaîne renvoient en réalité une nouvelle chaîne, en laissant l'originale inchangée :

python

# methods_return_new_strings.py
original = "hello world"
 
# Ces méthodes renvoient de nouvelles chaînes
uppercase = original.upper()
capitalized = original.capitalize()
replaced = original.replace("world", "Python")
 
# La chaîne originale est inchangée
print(original)      # Output: hello world
print(uppercase)     # Output: HELLO WORLD
print(capitalized)   # Output: Hello world
print(replaced)      # Output: hello Python

C'est pourquoi vous devez affecter le résultat à une variable (ou réutiliser la même variable) pour conserver les modifications :

python

# keeping_changes.py
text = "  hello  "
 
# Mauvais : le résultat est perdu
text.strip()
print(text)  # Output:   hello   (still has spaces!)
 
# Correct : affecter le résultat
text = text.strip()
print(text)  # Output: hello (spaces removed)

C'est une erreur courante pour les débutants :

python

# common_mistake.py
message = "python programming"
 
# Erreur : appeler la méthode sans utiliser le résultat
message.upper()
message.replace("python", "Python")
print(message)  # Output: python programming (unchanged!)
 
# Correct : affecter les résultats
message = message.upper()
message = message.replace("PYTHON", "Python")
print(message)  # Output: Python PROGRAMMING

5.8.3) Conséquences de l'immuabilité

Comprendre l'immuabilité vous aide à écrire un meilleur code :

1. Les chaînes sont sûres à partager :

python

# safe_sharing.py
original = "Hello"
copy = original  # Les deux variables pointent vers la même chaîne
 
# Comme les chaînes sont immuables, c'est sans danger
copy = copy + " World"
 
print(original)  # Output: Hello (inchangée)
print(copy)      # Output: Hello World (nouvelle chaîne)

2. Les opérations sur les chaînes créent de nouveaux objets :

python

# new_objects.py
text = "Python"
 
# Chaque opération crée un nouvel objet chaîne
result1 = text.upper()
result2 = text.lower()
result3 = text.replace("P", "J")
 
# Ce sont tous des objets différents
print(id(text))     # Une adresse mémoire
print(id(result1))  # Adresse mémoire différente
print(id(result2))  # Adresse mémoire différente
print(id(result3))  # Adresse mémoire différente

3. Construire des chaînes dans des boucles peut être inefficace :

python

# inefficient_string_building.py
# Ceci crée de nombreux objets chaîne temporaires
result = ""
for i in range(5):
    result = result + str(i)  # Crée une nouvelle chaîne à chaque fois
print(result)  # Output: 01234
 
# Approche plus efficace (pour de nombreuses concaténations) :
# Utiliser une liste et join (nous verrons cela au chapitre 6)
parts = []
for i in range(5):
    parts.append(str(i))
result = "".join(parts)
print(result)  # Output: 01234

5.8.4) Immuabilité et arguments de fonction

Lorsque vous passez une chaîne à une fonction, vous n'avez pas à craindre qu'elle soit modifiée accidentellement :

python

# safe_function_arguments.py
def process_text(text):
    # Toute opération crée de nouvelles chaînes
    text = text.upper()
    text = text.replace("A", "X")
    return text
 
original = "banana"
result = process_text(original)
 
print(original)  # Output: banana (inchangée)
print(result)    # Output: BXNXNX (version modifiée)

C'est différent des types mutables (comme les listes, que nous verrons au chapitre 13), où les modifications à l'intérieur des fonctions affectent l'objet original.

5.8.5) Visualiser l'immuabilité

Voici une représentation visuelle de ce qui se passe lorsque vous « modifiez » une chaîne :

Comprendre que les chaînes sont immuables vous aide à :

Éviter les erreurs où vous oubliez de récupérer le résultat des méthodes
Comprendre pourquoi les opérations sur les chaînes créent de nouveaux objets
Écrire un code plus efficace lorsque vous construisez de grandes chaînes
Partager les chaînes en toute sécurité entre différentes parties de votre programme

Cette immuabilité est une caractéristique fondamentale qui distingue les chaînes des types mutables comme les listes, que nous explorerons en détail dans la partie IV de ce livre.

Résumé du chapitre :

Dans ce chapitre, vous avez appris les bases du travail avec le texte en Python à l'aide des chaînes de caractères. Vous comprenez maintenant comment :

Créer des littéraux de chaînes à l'aide de guillemets et de séquences d'échappement
Combiner des chaînes avec la concaténation et la répétition
Accéder à des caractères individuels et extraire des sous‑chaînes grâce à l'indexation et au tranchage
Transformer des chaînes à l'aide de méthodes de conversion de casse et de suppression d'espaces
Rechercher et remplacer du texte à l'intérieur de chaînes
Convertir entre chaînes et nombres pour traiter les entrées et formater les sorties
Vérifier des sous‑chaînes à l'aide des opérateurs in et not in
Reconnaître que les chaînes sont immuables et comprendre ce que cela implique pour votre code

Ces compétences de manipulation de chaînes constituent la base du traitement de texte en Python. Vous utiliserez ces techniques constamment pour créer des interfaces utilisateur, traiter des fichiers de données, valider des entrées et formater des sorties.

Dans le chapitre suivant, nous nous appuierons sur ces bases en explorant des techniques de gestion de chaînes plus avancées, notamment la séparation et la jointure de chaînes, le formatage puissant avec les f‑strings et la méthode format(), ainsi que la compréhension de l'encodage du texte pour travailler avec des caractères internationaux.