6. Manipulation pratique des chaînes de caractères

Dans le chapitre 5, vous avez appris les bases de la manipulation des chaînes de caractères (strings) : comment les créer, accéder aux caractères grâce à l’indexation et au slicing, et utiliser des méthodes de base sur les chaînes. Nous allons maintenant nous appuyer sur ces bases pour explorer des opérations plus sophistiquées sur les chaînes que vous utiliserez en permanence dans de vrais programmes Python.

Ce chapitre se concentre sur des techniques pratiques de manipulation de chaînes qui résolvent des problèmes de programmation du quotidien : découper du texte et le recomposer, créer des sorties formatées d’aspect professionnel. Ces compétences sont essentielles que vous traitiez des saisies utilisateur, que vous génériez des rapports, lisiez des fichiers de données ou construisiez tout programme qui travaille avec du texte.

6.1) Découper et assembler des chaînes

L’une des tâches les plus courantes dans le traitement de texte consiste à découper une chaîne en morceaux plus petits ou à combiner plusieurs morceaux en une seule chaîne. Python fournit des méthodes puissantes pour ces deux opérations.

6.1.1) Découper des chaînes avec split()

La méthode split() découpe une chaîne en une liste (list) de chaînes plus petites selon un séparateur (aussi appelé délimiteur). C’est extrêmement utile pour traiter du texte structuré comme des données CSV, une saisie utilisateur contenant plusieurs valeurs, ou des phrases à découper en mots.

Découpage de base par espaces blancs :

Lorsque vous appelez split() sans aucun argument, la méthode découpe sur n’importe quel espace blanc (espaces, tabulations, sauts de ligne) et supprime automatiquement les chaînes vides du résultat :

python

# split_basic.py
sentence = "Python is a powerful programming language"
words = sentence.split()
print(words)  # Output: ['Python', 'is', 'a', 'powerful', 'programming', 'language']
print(len(words))  # Output: 6

Remarquez la façon dont split() gère intelligemment les espaces multiples :

python

# split_whitespace.py
messy_text = "Python    is     awesome"
words = messy_text.split()
print(words)  # Output: ['Python', 'is', 'awesome']

Même s’il y a plusieurs espaces entre les mots, split() considère n’importe quelle quantité d’espaces blancs comme un seul séparateur et produit une liste propre.

Découper selon un séparateur spécifique :

Vous pouvez préciser exactement le caractère ou la chaîne à utiliser comme séparateur en la passant en argument :

python

# split_separator.py
csv_data = "apple,banana,cherry,date"
fruits = csv_data.split(',')
print(fruits)  # Output: ['apple', 'banana', 'cherry', 'date']
 
date_string = "2024-03-15"
parts = date_string.split('-')
print(parts)  # Output: ['2024', '03', '15']
year = parts[0]
month = parts[1]
day = parts[2]
print(f"Year: {year}, Month: {month}, Day: {day}")  # Output: Year: 2024, Month: 03, Day: 15

Différence importante : Lorsque vous spécifiez un séparateur, split() le traite littéralement et créera des chaînes vides si le séparateur apparaît de façon consécutive :

python

# split_empty_strings.py
data = "apple,,cherry"
result = data.split(',')
print(result)  # Output: ['apple', '', 'cherry']
print(len(result))  # Output: 3

La chaîne vide '' au milieu représente le « rien » entre les deux virgules consécutives. Ce comportement est différent de celui du découpage sur les espaces blancs sans arguments.

Limiter le nombre de découpages :

Vous pouvez contrôler le nombre de découpages en passant un deuxième argument (maxsplit) :

python

# split_maxsplit.py
text = "one:two:three:four:five"
parts = text.split(':', 2)  # Ne découper que sur les 2 premiers deux-points
print(parts)  # Output: ['one', 'two', 'three:four:five']

Cela crée au maximum 3 parties (maxsplit + 1), car la méthode s’arrête après le nombre de découpages spécifié. Le reste de la chaîne reste intact.

Exemple pratique : traitement d’une saisie utilisateur

python

# process_input.py
user_input = input("Enter your full name: ")
# User enters: "Alice Marie Johnson"
 
name_parts = user_input.split()
if len(name_parts) >= 2:
    first_name = name_parts[0]
    last_name = name_parts[-1]  # Last element
    print(f"First name: {first_name}")  # Output: First name: Alice
    print(f"Last name: {last_name}")    # Output: Last name: Johnson
else:
    print("Please enter at least a first and last name")

6.1.2) Assembler des chaînes avec join()

La méthode join() fait l’inverse de split() : elle combine une liste (ou tout itérable) de chaînes en une seule chaîne, avec un séparateur entre chaque élément. La syntaxe peut sembler inversée au début : c’est la chaîne séparatrice qui appelle la méthode, et la liste est passée comme argument.

Assemblage de base :

python

# join_basic.py
words = ['Python', 'is', 'awesome']
sentence = ' '.join(words)
print(sentence)  # Output: Python is awesome
 
csv_line = ','.join(['apple', 'banana', 'cherry'])
print(csv_line)  # Output: apple,banana,cherry

La chaîne qui appelle join() (comme ' ' ou ',') devient le séparateur entre les éléments.

Pourquoi la syntaxe est separator.join(list) :

Cette syntaxe a du sens si vous la voyez du point de vue du séparateur : « Je veux joindre ces éléments ensemble en m’insérant entre chaque paire. » Elle permet aussi un chaînage élégant et rend le séparateur très visible dans votre code.

Assembler avec différents séparateurs :

python

# join_separators.py
items = ['eggs', 'milk', 'bread', 'butter']
 
# Séparés par des virgules
print(', '.join(items))  # Output: eggs, milk, bread, butter
 
# Séparés par des sauts de ligne (chaque élément sur sa propre ligne)
print('\n'.join(items))
# Output:
# eggs
# milk
# bread
# butter
 
# Séparés par des tirets
print('-'.join(items))  # Output: eggs-milk-bread-butter
 
# Sans séparateur (concaténation)
print(''.join(items))  # Output: eggsmilkbreadbutter

Important : join() ne fonctionne qu’avec des chaînes :

Tous les éléments de l’itérable doivent être des chaînes. Si vous essayez d’assembler des nombres ou d’autres types, vous obtiendrez une erreur :

python

# join_error.py
numbers = [1, 2, 3, 4]
# result = ','.join(numbers)  # This would cause: TypeError: sequence item 0: expected str instance, int found

Pour assembler des éléments qui ne sont pas des chaînes, convertissez-les d’abord en chaînes. Nous apprendrons une façon plus élégante de faire cela au chapitre 34, mais pour l’instant vous pouvez convertir chaque élément manuellement :

python

# join_numbers.py
numbers = [1, 2, 3, 4]
# Convert each number to a string manually
string_numbers = [str(numbers[0]), str(numbers[1]), str(numbers[2]), str(numbers[3])]
result = ','.join(string_numbers)
print(result)  # Output: 1,2,3,4

Exemple pratique : construire des chemins de fichiers

python

# build_path.py
path_parts = ['home', 'user', 'documents', 'report.txt']
# Sur les systèmes de type Unix (Linux, macOS)
unix_path = '/'.join(path_parts)
print(unix_path)  # Output: home/user/documents/report.txt
 
# Sur Windows
windows_path = '\\'.join(path_parts)
print(windows_path)  # Output: home\user\documents\report.txt

Remarque : au chapitre 26, nous verrons le module os.path qui fournit une gestion des chemins plus portable entre systèmes, mais ceci illustre le concept d’assemblage.

6.1.3) Combiner split() et join() pour le traitement de texte

Ces deux méthodes fonctionnent très bien ensemble pour transformer du texte. En les combinant, vous pouvez nettoyer une saisie désordonnée, convertir entre différents formats, ou extraire et réorganiser des données :

python

# transform_text.py
# Remplacer les espaces multiples par des espaces simples
messy = "Python    is     really    cool"
clean = ' '.join(messy.split())
print(clean)  # Output: Python is really cool
 
# Convertir un texte séparé par des virgules en texte séparé par des espaces
csv_data = "apple,banana,cherry"
space_separated = ' '.join(csv_data.split(','))
print(space_separated)  # Output: apple banana cherry
 
# Supprimer tous les espaces
text_with_spaces = "H e l l o"
no_spaces = ''.join(text_with_spaces.split())
print(no_spaces)  # Output: Hello

6.1.4) Autres méthodes de découpage

Python fournit d’autres méthodes de découpage pour des cas d’usage spécifiques :

rsplit() – Découper à partir de la droite :

python

# rsplit_example.py
path = "folder/subfolder/file.txt"
 
# Découpage normal avec maxsplit
parts = path.split('/', 1)
print(parts)  # Output: ['folder', 'subfolder/file.txt']
 
# rsplit découpe depuis la droite
parts = path.rsplit('/', 1)
print(parts)  # Output: ['folder/subfolder', 'file.txt']

C’est utile lorsque vous voulez séparer la dernière partie d’une chaîne de tout ce qui la précède.

splitlines() – Découper sur les sauts de ligne :

python

# splitlines_example.py
multiline = "Line 1\nLine 2\nLine 3"
lines = multiline.splitlines()
print(lines)  # Output: ['Line 1', 'Line 2', 'Line 3']
 
# Fonctionne avec différents styles de fin de ligne
mixed_lines = "Line 1\nLine 2\r\nLine 3\rLine 4"
all_lines = mixed_lines.splitlines()
print(all_lines)  # Output: ['Line 1', 'Line 2', 'Line 3', 'Line 4']

La méthode splitlines() reconnaît toutes les conventions standard de saut de ligne (\n, \r\n, \r) et découpe en conséquence, ce qui la rend plus robuste que split('\n') pour traiter du texte provenant de différentes sources.

6.2) Formater des chaînes avec les f-strings

Créer une sortie formatée est l’une des tâches les plus courantes en programmation. Vous devez combiner du texte avec des valeurs de variables, aligner des colonnes, formater des nombres et produire une sortie lisible pour les utilisateurs. Les f-strings (littéraux de chaîne formatés) de Python offrent la façon la plus moderne, lisible et puissante de faire cela.

6.2.1) Syntaxe de base des f-strings

Une f-string est un littéral de chaîne précédé de f ou F qui peut contenir des expressions entre accolades {}. Python évalue ces expressions et convertit leurs résultats en chaînes :

python

# fstring_basic.py
name = "Alice"
age = 30
greeting = f"Hello, {name}! You are {age} years old."
print(greeting)  # Output: Hello, Alice! You are 30 years old.

Les expressions entre {} peuvent être n’importe quelle expression Python valide :

python

# fstring_expressions.py
x = 10
y = 20
result = f"The sum of {x} and {y} is {x + y}"
print(result)  # Output: The sum of 10 and 20 is 30
 
price = 19.99
quantity = 3
total = f"Total cost: ${price * quantity}"
print(total)  # Output: Total cost: $59.97

6.2.2) Pourquoi les f-strings sont meilleures que les anciennes approches

Avant les f-strings (introduites dans Python 3.6), les programmeurs utilisaient la concaténation de chaînes ou la méthode format(). Comparons :

Concaténation de chaînes (ancienne approche sujette aux erreurs) :

python

# concatenation_example.py
name = "Bob"
age = 25
# Nécessite de convertir les nombres en chaînes et beaucoup d’opérateurs +
message = "Hello, " + name + "! You are " + str(age) + " years old."
print(message)  # Output: Hello, Bob! You are 25 years old.

Cette approche est verbeuse, sujette aux erreurs (oublier str() provoque des erreurs) et difficile à lire lorsqu’il y a beaucoup de variables.

f-strings (approche moderne et claire) :

python

# fstring_clean.py
name = "Bob"
age = 25
message = f"Hello, {name}! You are {age} years old."
print(message)  # Output: Hello, Bob! You are 25 years old.

Les f-strings convertissent automatiquement les valeurs en chaînes, sont plus lisibles, et sont en fait plus rapides que les autres approches.

6.2.3) Expressions et appels de méthodes dans les f-strings

Vous pouvez inclure des expressions complexes, des appels de méthodes et même des appels de fonctions dans des f-strings :

python

# fstring_methods.py
name = "alice"
print(f"Capitalized: {name.capitalize()}")  # Output: Capitalized: Alice
print(f"Uppercase: {name.upper()}")  # Output: Uppercase: ALICE
print(f"Length: {len(name)}")  # Output: Length: 5
 
# Arithmétique et comparaisons
x = 10
print(f"Is {x} even? {x % 2 == 0}")  # Output: Is 10 even? True
 
# Indexation et slicing
text = "Python"
print(f"First letter: {text[0]}")  # Output: First letter: P
print(f"First three: {text[:3]}")  # Output: First three: Pyt

6.2.4) Formater les nombres avec les f-strings

Les f-strings prennent en charge des spécificateurs de format (format specifiers) qui contrôlent la façon dont les valeurs sont affichées. La syntaxe est {expression:format_spec} :

Contrôler le nombre de décimales pour les flottants :

python

# fstring_decimals.py
pi = 3.14159265359
 
print(f"Default: {pi}")  # Output: Default: 3.14159265359
print(f"2 decimals: {pi:.2f}")  # Output: 2 decimals: 3.14
print(f"4 decimals: {pi:.4f}")  # Output: 4 decimals: 3.1416
print(f"No decimals: {pi:.0f}")  # Output: No decimals: 3

Le spécificateur de format .2f signifie « formater comme un flottant avec 2 décimales ». Le f signifie « notation à virgule fixe » (fixed-point notation).

Formatage avec séparateurs de milliers :

python

# fstring_thousands.py
large_number = 1234567890
 
print(f"No separator: {large_number}")  # Output: No separator: 1234567890
print(f"With commas: {large_number:,}")  # Output: With commas: 1,234,567,890
print(f"With underscores: {large_number:_}")  # Output: With underscores: 1_234_567_890
 
# Combiner avec des décimales
price = 1234567.89
print(f"Price: ${price:,.2f}")  # Output: Price: $1,234,567.89

Formatage en pourcentage :

python

# fstring_percentage.py
ratio = 0.847
print(f"Ratio: {ratio}")  # Output: Ratio: 0.847
print(f"Percentage: {ratio:.1%}")  # Output: Percentage: 84.7%
print(f"Percentage: {ratio:.2%}")  # Output: Percentage: 84.70%

Le spécificateur % multiplie la valeur par 100 et ajoute le symbole de pourcentage.

6.2.5) Exemples pratiques avec les f-strings

Créer des rapports formatés :

python

# report_example.py
product = "Laptop"
price = 899.99
quantity = 5
tax_rate = 0.08
 
subtotal = price * quantity
tax = subtotal * tax_rate
total = subtotal + tax
 
print(f"Product: {product}")  # Output: Product: Laptop
print(f"Price: ${price:.2f}")  # Output: Price: $899.99
print(f"Quantity: {quantity}")  # Output: Quantity: 5
print(f"Subtotal: ${subtotal:.2f}")  # Output: Subtotal: $4499.95
print(f"Tax (8%): ${tax:.2f}")  # Output: Tax (8%): $360.00
print(f"Total: ${total:.2f}")  # Output: Total: $4859.95

Créer des messages conviviaux pour les utilisateurs :

python

# user_messages.py
username = "Alice"
login_count = 42
last_login = "2024-03-15"
 
welcome = f"Welcome back, {username}!"
stats = f"You've logged in {login_count} times. Last login: {last_login}"
 
print(welcome)  # Output: Welcome back, Alice!
print(stats)  # Output: You've logged in 42 times. Last login: 2024-03-15

6.2.6) Débogage (debugging) avec les f-strings

Python 3.8 a introduit le spécificateur = pour le débogage, qui affiche à la fois l’expression et sa valeur :

python

# fstring_debug.py
x = 10
y = 20
z = x + y
 
print(f"{x=}")  # Output: x=10
print(f"{y=}")  # Output: y=20
print(f"{z=}")  # Output: z=30
print(f"{x + y=}")  # Output: x + y=30

C’est extrêmement utile pour vérifier rapidement les valeurs de variables pendant le développement sans avoir à taper deux fois le nom de la variable.

6.2.7) Échapper les accolades dans les f-strings

Si vous avez besoin d’accolades littérales dans une f-string, doublez-les :

python

# fstring_escape.py
value = 42
# Les accolades simples sont des emplacements d’expression
print(f"Value: {value}")  # Output: Value: 42
 
# Les doubles accolades produisent des accolades littérales
print(f"Use {{value}} as a placeholder")  # Output: Use {value} as a placeholder
print(f"The value is {value}, shown as {{value}}")  # Output: The value is 42, shown as {value}

6.3) Formatage avec format() et spécificateurs de format

Même si les f-strings sont l’approche moderne recommandée, la méthode format() est encore largement utilisée et offre certaines possibilités qu’il est utile de comprendre. C’est aussi la base sur laquelle les f-strings sont construites, donc comprendre format() vous aide à mieux comprendre les f-strings.

6.3.1) Syntaxe de base de format()

La méthode format() utilise des accolades {} comme emplacements (placeholders) dans une chaîne, et les valeurs à insérer sont passées en arguments :

python

# format_basic.py
template = "Hello, {}! You are {} years old."
message = template.format("Alice", 30)
print(message)  # Output: Hello, Alice! You are 30 years old.
 
# Utilisation multiple de format()
greeting = "Hello, {}!".format("Bob")
print(greeting)  # Output: Hello, Bob!

6.3.2) Arguments positionnels et nommés

Vous pouvez contrôler quel argument va où en utilisant des numéros de position ou des noms :

Arguments positionnels :

python

# format_positional.py
# Ordre par défaut (0, 1, 2, ...)
template = "{} + {} = {}"
result = template.format(5, 3, 8)
print(result)  # Output: 5 + 3 = 8
 
# Positions explicites
template = "{0} + {1} = {2}"
result = template.format(5, 3, 8)
print(result)  # Output: 5 + 3 = 8
 
# Réorganisation et réutilisation
template = "{2} = {0} + {1}"
result = template.format(5, 3, 8)
print(result)  # Output: 8 = 5 + 3
 
# Réutiliser la même valeur
template = "{0} times {0} equals {1}"
result = template.format(7, 49)
print(result)  # Output: 7 times 7 equals 49

Arguments nommés :

python

# format_keyword.py
template = "Hello, {name}! You are {age} years old."
message = template.format(name="Alice", age=30)
print(message)  # Output: Hello, Alice! You are 30 years old.
 
# Peut être combiné avec des positionnels (les positionnels doivent venir en premier)
template = "{0}, your score is {score} out of {1}"
result = template.format("Alice", 100, score=95)
print(result)  # Output: Alice, your score is 95 out of 100

6.3.3) Spécificateurs de format avec format()

Les spécificateurs de format fonctionnent de la même manière dans format() que dans les f-strings, en utilisant le séparateur : :

python

# format_specifiers.py
pi = 3.14159265359
 
print("{:.2f}".format(pi))  # Output: 3.14
print("{:.4f}".format(pi))  # Output: 3.1416
 
# Avec des noms
print("{value:.2f}".format(value=pi))  # Output: 3.14
 
# Valeurs multiples avec des formats différents
template = "{name}'s score is {score:.1f}%"
result = template.format(name="Bob", score=87.654)
print(result)  # Output: Bob's score is 87.7%

6.3.4) Quand utiliser format() plutôt que les f-strings

Les f-strings sont généralement préférées, mais format() est utile dans certaines situations spécifiques :

1. Chaînes modèles (templates) définies séparément des données :

python

# format_templates.py
# Modèle défini une fois, utilisé plusieurs fois avec des données différentes
email_template = "Dear {name},\n\nYour order #{order_id} has shipped.\n\nThank you!"
 
# Utiliser le modèle avec différents clients
message1 = email_template.format(name="Alice", order_id=12345)
message2 = email_template.format(name="Bob", order_id=12346)
 
print(message1)
# Output:
# Dear Alice,
#
# Your order #12345 has shipped.
#
# Thank you!
 
print(message2)
# Output:
# Dear Bob,
#
# Your order #12346 has shipped.
#
# Thank you!

2. Lorsque le modèle vient de sources externes :

python

# format_external.py
# Le modèle peut venir d’un fichier de configuration ou d’une base de données
# (Nous verrons comment lire des fichiers au chapitre 24)
user_template = input("Enter message template: ")
# User enters: "Hello, {name}! Welcome to {place}."
 
message = user_template.format(name="Charlie", place="Python")
print(message)  # Output: Hello, Charlie! Welcome to Python.

Avec les f-strings, le modèle doit se trouver dans votre code car les expressions sont évaluées immédiatement. Avec format(), le modèle peut être une chaîne ordinaire provenant de n’importe où.

6.3.5) Accéder aux attributs d’objets et aux clés de dictionnaires

La méthode format() peut accéder directement aux attributs et aux clés de dictionnaires :

python

# format_access.py
# Accès à un dictionnaire
person = {"name": "Alice", "age": 30, "city": "Boston"}
message = "Name: {0[name]}, Age: {0[age]}, City: {0[city]}".format(person)
print(message)  # Output: Name: Alice, Age: 30, City: Boston
 
# Avec un argument nommé
message = "{p[name]} is {p[age]} years old".format(p=person)
print(message)  # Output: Alice is 30 years old

Remarque : nous verrons les attributs d’objets au chapitre 30, mais ceci montre que format() peut accéder à des structures de données imbriquées.

6.4) Aligner et arrondir les nombres dans la sortie formatée

Une sortie d’aspect professionnel nécessite souvent un alignement soigné et un formatage des nombres. Les f-strings et format() fournissent tous deux des outils puissants pour créer des tableaux, rapports et affichages bien formatés.

6.4.1) Alignement du texte

Vous pouvez contrôler la largeur et l’alignement des valeurs à l’aide de spécificateurs de format :

python

# alignment_basic.py
# Syntaxe : {value:width}
# Par défaut, les chaînes sont alignées à gauche, les nombres à droite
 
name = "Alice"
print(f"|{name}|")      # Output: |Alice|
print(f"|{name:10}|")   # Output: |Alice     |  (aligné à gauche, largeur 10)
print(f"|{name:>10}|")  # Output: |     Alice|  (aligné à droite)
print(f"|{name:^10}|")  # Output: |  Alice   |  (centré)

Les spécificateurs d’alignement sont :

< : alignement à gauche (par défaut pour les chaînes)
> : alignement à droite (par défaut pour les nombres)
^ : alignement centré

Alignement avec les nombres :

python

# alignment_numbers.py
value = 42
print(f"|{value}|")      # Output: |42|
print(f"|{value:5}|")    # Output: |   42|  (aligné à droite par défaut)
print(f"|{value:<5}|")   # Output: |42   |  (aligné à gauche)
print(f"|{value:^5}|")   # Output: | 42  |  (centré)

6.4.2) Caractères de remplissage personnalisés

Vous pouvez spécifier un caractère pour remplir l’espace vide :

python

# alignment_fill.py
name = "Bob"
print(f"|{name:*<10}|")  # Output: |Bob*******|
print(f"|{name:*>10}|")  # Output: |*******Bob|
print(f"|{name:*^10}|")  # Output: |***Bob****|
 
# Utile pour créer des séparateurs visuels
print(f"{name:=^20}")    # Output: ========Bob=========

La syntaxe est {value:fill_char align width}.

6.4.3) Combiner alignement et formatage des nombres

Vous pouvez combiner largeur, alignement et formatage des nombres :

python

# alignment_combined.py
price = 19.99
quantity = 5
total = price * quantity
 
# Alignement à droite avec largeur 10, 2 décimales
print(f"Price:    ${price:>10.2f}")     # Output: Price:    $     19.99
print(f"Quantity: {quantity:>10}")      # Output: Quantity:          5
print(f"Total:    ${total:>10.2f}")     # Output: Total:    $     99.95
 
# Avec un caractère de remplissage pour l’effet visuel
print(f"Total:    ${total:>10.2f}".replace(' ', '.'))  # Output: Total:....$.....99.95

Dans ce chapitre, vous avez appris des techniques essentielles de manipulation de chaînes que vous utiliserez dans pratiquement tous vos programmes Python : découper et assembler des chaînes pour le traitement de texte, créer des sorties formatées avec les f-strings et les spécificateurs de format, aligner et formater les nombres pour des affichages professionnels.

Ces compétences constituent la base du travail avec des données textuelles en Python. Vous pouvez désormais traiter des saisies utilisateur, créer des rapports formatés, gérer des données issues de fichiers (que nous aborderons au chapitre 24). À mesure que vous continuez à apprendre Python, vous utiliserez en permanence ces techniques de manipulation de chaînes, donc entraînez-vous jusqu’à ce qu’elles deviennent une seconde nature.