Modifier les chaînes de caractères

Les chaînes Python sont des séquences de caractères entourées de guillemets. Bien que les chaînes soient immuables — vous ne pouvez pas les modifier en place — Python vous offre un riche ensemble d'opérateurs et de méthodes qui retournent de nouvelles chaînes modifiées. Ce chapitre couvre les techniques les plus importantes : la concaténation, la répétition, la conversion de casse, le découpage, le remplacement de sous-chaînes, la suppression d'espaces, le fractionnement et la jonction, et bien plus encore.

Concept clé : les chaînes sont immuables

Avant de plonger dans le vif du sujet, il est important de comprendre que chaque méthode de « modification » retourne une nouvelle chaîne. La chaîne originale n'est jamais modifiée.

greeting = "hello"
upper_greeting = greeting.upper()

print(greeting)        # hello  (unchanged)
print(upper_greeting)  # HELLO  (new string)

Cela signifie que vous devez assigner le résultat à une variable (ou l'utiliser directement) pour conserver la modification.

Concaténation de chaînes

La concaténation combine deux ou plusieurs chaînes en une seule à l'aide de l'opérateur +. Vous pouvez enchaîner autant de chaînes que vous le souhaitez.

Concaténer des chaînes en Python

Concaténer avec des variables et des littéraux

Vous pouvez mélanger des variables de type string avec des littéraux de chaîne :

first_name = "Ada"
last_name  = "Lovelace"
full_name  = first_name + " " + last_name
print(full_name)  # Ada Lovelace

Pour de plus grandes quantités de texte, préférez les chaînes formatées ou les f-strings qui sont plus lisibles que de longues chaînes de +.

Répétition de chaînes

L'opérateur * répète une chaîne un nombre donné de fois. Cela est utile pour générer des séparateurs, du remplissage ou des motifs simples.

Répéter une chaîne en Python

Changement de casse

Python fournit plusieurs méthodes pour modifier la capitalisation d'une chaîne.

Convertir une chaîne en majuscules ou en minuscules en Python

Les méthodes de casse sont souvent utilisées pour comparer des saisies utilisateur quelle que soit la façon dont elles ont été tapées :

answer = input("Type yes or no: ")
if answer.lower() == "yes":
    print("You said yes!")

Découpage de chaînes

Le découpage extrait une partie d'une chaîne à l'aide de la syntaxe [start:stop:step]. Le résultat est une nouvelle chaîne contenant les caractères de l'index start jusqu'à — mais sans inclure — l'index stop.

 H  e  l  l  o  ,     W  o  r  l  d  !
 0  1  2  3  4  5  6  7  8  9 10 11 12
-13-12-11-10-9 -8 -7 -6 -5 -4 -3 -2 -1

Découper des chaînes en Python

Quand utiliser les indices négatifs

Les indices négatifs comptent à partir de la fin de la chaîne. L'index -1 correspond au dernier caractère, -2 à l'avant-dernier, et ainsi de suite. C'est pratique quand vous voulez la fin d'une chaîne sans connaître sa longueur :

filename = "report_2024.csv"
extension = filename[-3:]
print(extension)  # csv

Pour une exploration approfondie, consultez le chapitre Découpage de chaînes.

Remplacement de sous-chaînes

La méthode replace(old, new) retourne une copie de la chaîne où chaque occurrence de old est remplacée par new. Passez un troisième argument count pour limiter le nombre de remplacements effectués.

Remplacer une partie d'une chaîne en Python

text = "I like cats. Cats are great. Cats!"
print(text.replace("Cats", "Dogs"))         # replaces all occurrences
print(text.replace("Cats", "Dogs", 1))      # replaces first occurrence only

I like cats. Dogs are great. Dogs!
I like cats. Dogs are great. Cats!

Notez que replace() est sensible à la casse : "cats" et "Cats" sont traités comme des sous-chaînes différentes.

Suppression des espaces blancs

Les caractères d'espacement (espaces, tabulations, sauts de ligne) au début ou à la fin d'une chaîne doivent souvent être supprimés, notamment lors du traitement de saisies utilisateur ou de la lecture de fichiers.

raw = "   hello world   "
print(repr(raw.strip()))   # 'hello world'
print(repr(raw.lstrip()))  # 'hello world   '
print(repr(raw.rstrip()))  # '   hello world'

Vous pouvez également supprimer des caractères spécifiques en les passant comme argument :

path = "///usr/local/bin///"
print(path.strip("/"))  # usr/local/bin

Fractionnement de chaînes

La méthode split(sep) divise une chaîne sur un séparateur et retourne une liste de sous-chaînes. Sans argument, elle divise sur tout espace blanc et supprime les chaînes vides.

sentence = "Python is easy to learn"
words = sentence.split()
print(words)  # ['Python', 'is', 'easy', 'to', 'learn']

csv_row = "Alice,30,Engineer"
fields = csv_row.split(",")
print(fields)  # ['Alice', '30', 'Engineer']

Passez un second argument maxsplit pour limiter le nombre de divisions :

data = "one:two:three:four"
print(data.split(":", 2))  # ['one', 'two', 'three:four']

Jonction de chaînes

join() est l'inverse de split(). Elle combine une liste de chaînes en une seule, en plaçant un séparateur entre chaque élément. Le séparateur est la chaîne sur laquelle vous appelez join().

words = ["Python", "is", "fun"]
sentence = " ".join(words)
print(sentence)  # Python is fun

path_parts = ["usr", "local", "bin"]
path = "/".join(path_parts)
print(path)  # usr/local/bin

L'utilisation de join() est bien plus efficace que la concaténation de chaînes dans une boucle, car chaque + crée un nouvel objet string. join() n'alloue la chaîne finale qu'une seule fois.

Recherche dans les chaînes

Plusieurs méthodes vous aident à trouver du texte à l'intérieur d'une chaîne.

find() et index()

find(sub) retourne l'index de la première occurrence de sub, ou -1 si non trouvé. index(sub) fait la même chose mais lève une ValueError au lieu de retourner -1.

text = "the quick brown fox"
print(text.find("quick"))   # 4
print(text.find("slow"))    # -1

print(text.index("brown"))  # 10

startswith() et endswith()

Ces méthodes retournent True ou False et constituent une alternative plus propre au découpage lorsque vous devez vérifier le début ou la fin d'une chaîne.

url = "https://www.w3docs.com"
print(url.startswith("https"))   # True
print(url.endswith(".com"))      # True
print(url.startswith("http://")) # False

Vous pouvez passer un tuple de préfixes/suffixes pour vérifier plusieurs options à la fois :

filename = "photo.jpg"
print(filename.endswith((".jpg", ".jpeg", ".png")))  # True

count()

count(sub) retourne le nombre de fois que sub apparaît dans la chaîne (sans chevauchement).

text = "banana"
print(text.count("a"))   # 3
print(text.count("an"))  # 2

Vérification des propriétés d'une chaîne

Python dispose d'une famille de méthodes is* qui retournent True ou False selon le contenu d'une chaîne.

print("hello".isalpha())    # True  – all alphabetic
print("hello123".isalnum()) # True  – all alphanumeric
print("12345".isdigit())    # True  – all digits
print("  ".isspace())       # True  – all whitespace
print("Hello World".istitle()) # True – title-case

Ces méthodes sont particulièrement utiles pour la validation des saisies.

Exemple pratique : nettoyer une saisie utilisateur

La modification de chaînes dans la pratique combine souvent plusieurs techniques :

raw_input = "  Ada Lovelace  "

# Clean and normalise
name = raw_input.strip()          # remove surrounding spaces
name = name.title()               # ensure proper capitalisation

parts = name.split()              # split into first / last
first, last = parts[0], parts[1]

print(f"First: {first}, Last: {last}")  # First: Ada, Last: Lovelace

Référence rapide

Pour la liste complète des méthodes de chaînes intégrées, consultez Méthodes de chaînes. Pour en savoir plus sur les séquences d'échappement comme \n et \t, consultez Caractères d'échappement. Pour une recherche et une manipulation de texte puissantes à l'aide de motifs, consultez Regex Python.

Pratique