Python String Replace : Guide complet de str.replace() et au-delà

Name

Soren Atelier

Updated on 10/02/2026

Le remplacement de chaînes est l'une des opérations les plus fréquentes dans le traitement de texte. Vous devez nettoyer les entrées utilisateur, normaliser les formats de données, masquer des informations sensibles ou transformer des chaînes de modèle. La méthode str.replace() de Python gère les cas simples en une seule ligne, mais elle atteint ses limites lorsque vous avez besoin de correspondance insensible à la casse, de motifs regex ou de remplacements conditionnels. Choisir le mauvais outil signifie soit compliquer inutilement des tâches simples, soit écrire du code fragile pour les tâches complexes.

Ce guide couvre chaque approche du remplacement de chaînes en Python -- du basique str.replace() au re.sub() avec regex, au translate() au niveau des caractères et aux modèles pratiques pour le traitement de texte réel.

str.replace(old, new, count)

La méthode la plus simple et la plus courante. Remplace toutes les occurrences de old par new. Un count optionnel limite le nombre de remplacements.

text = "Hello World, Hello Python, Hello Everyone"
 
# Remplacer toutes les occurrences
print(text.replace("Hello", "Hi"))
# Hi World, Hi Python, Hi Everyone
 
# Remplacer seulement les 2 premières occurrences
print(text.replace("Hello", "Hi", 2))
# Hi World, Hi Python, Hello Everyone
 
# Supprimer une sous-chaîne (remplacer par une chaîne vide)
messy = "  extra   spaces   here  "
print(messy.replace(" ", ""))
# extraspaceshere

Comportement clé

• Retourne une nouvelle chaîne (les chaînes sont immuables en Python)
• Sensible à la casse par défaut
• Remplace toutes les occurrences sauf si count est spécifié
• Retourne la chaîne originale inchangée si old n'est pas trouvé

original = "Python is great"
new = original.replace("great", "awesome")
print(original)  # Python is great (inchangé)
print(new)       # Python is awesome

Remplacement insensible à la casse

str.replace() est toujours sensible à la casse. Pour un remplacement insensible à la casse, utilisez re.sub() avec le drapeau re.IGNORECASE.

import re
 
text = "Python is Great, python is Fun, PYTHON is Everywhere"
 
# Remplacement insensible à la casse
result = re.sub(r'python', 'Java', text, flags=re.IGNORECASE)
print(result)
# Java is Great, Java is Fun, Java is Everywhere

Remplacement regex avec re.sub()

re.sub(pattern, replacement, string, count, flags) remplace les correspondances d'un motif regex.

import re
 
# Remplacer les chiffres par '#'
text = "Call 555-1234 or 555-5678"
print(re.sub(r'\d', '#', text))
# Call ###-#### or ###-####
 
# Remplacer des numéros de téléphone complets
print(re.sub(r'\d{3}-\d{4}', '[MASQUÉ]', text))
# Call [MASQUÉ] or [MASQUÉ]
 
# Remplacer les espaces multiples par un seul espace
messy = "too    many     spaces   here"
print(re.sub(r'\s+', ' ', messy))
# too many spaces here

Utilisation des groupes de capture

import re
 
# Échanger prénom et nom de famille
names = "Smith, John\nDoe, Jane\nBrown, Bob"
swapped = re.sub(r'(\w+), (\w+)', r'\2 \1', names)
print(swapped)
# John Smith
# Jane Doe
# Bob Brown
 
# Ajouter un formatage aux dates
dates = "Meeting on 2026-02-10 and 2026-03-15"
formatted = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', dates)
print(formatted)
# Meeting on 02/10/2026 and 03/15/2026

Utilisation d'une fonction pour un remplacement dynamique

Passez une fonction au lieu d'une chaîne pour des remplacements conditionnels :

import re
 
def censor_word(match):
    word = match.group()
    return word[0] + '*' * (len(word) - 1)
 
text = "The password is secret and the code is hidden"
censored = re.sub(r'secret|hidden', censor_word, text)
print(censored)
# The password is s***** and the code is h*****

import re
 
# Convertir en casse titre uniquement pour certains mots
def smart_capitalize(match):
    word = match.group()
    minor_words = {'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to'}
    if word.lower() in minor_words:
        return word.lower()
    return word.capitalize()
 
title = "the quick BROWN fox AND the lazy DOG"
result = re.sub(r'\b\w+\b', smart_capitalize, title)
print(result)
# the Quick Brown Fox and the Lazy Dog

Remplacements multiples

Enchaîner les appels à replace()

text = "Hello World! How are you?"
result = text.replace("Hello", "Hi").replace("World", "Earth").replace("you", "they")
print(result)  # Hi Earth! How are they?

Remplacement basé sur un dictionnaire

Pour de nombreux remplacements, utilisez un dictionnaire avec re.sub() :

import re
 
def multi_replace(text, replacements):
    """Remplacer plusieurs sous-chaînes à l'aide d'un dictionnaire."""
    pattern = re.compile('|'.join(re.escape(k) for k in replacements))
    return pattern.sub(lambda m: replacements[m.group()], text)
 
text = "The cat sat on the mat with another cat"
replacements = {
    'cat': 'dog',
    'mat': 'rug',
    'sat': 'stood',
}
 
print(multi_replace(text, replacements))
# The dog stood on the rug with another dog

Remplacement au niveau des caractères avec translate()

Pour remplacer des caractères individuels, str.translate() avec str.maketrans() est l'option la plus rapide :

# Remplacer des caractères : a->@, e->3, o->0
table = str.maketrans('aeo', '@30')
text = "Hello World"
print(text.translate(table))
# H3ll0 W0rld
 
# Supprimer des caractères spécifiques
remove_vowels = str.maketrans('', '', 'aeiouAEIOU')
print("Hello World".translate(remove_vowels))
# Hll Wrld
 
# Remplacer ET supprimer en un seul appel
table = str.maketrans({'a': '@', 'e': '3', ' ': None})
print("apple pie".translate(table))
# @ppl3pi3

Comparaison des méthodes

Exemples pratiques

Nettoyer et normaliser du texte

import re
 
def clean_text(text):
    """Normaliser le texte pour le traitement."""
    text = text.strip()
    text = re.sub(r'\s+', ' ', text)           # Réduire les espaces blancs
    text = re.sub(r'[^\w\s.,!?-]', '', text)   # Supprimer les caractères spéciaux
    text = text.lower()
    return text
 
raw = "  Hello!!!   This is    MESSY @#$ text...  "
print(clean_text(raw))
# hello!!! this is messy text...

Remplacement de chaînes de modèle

template = "Dear {name}, your order #{order_id} ships on {date}."
 
data = {
    'name': 'Alice',
    'order_id': '12345',
    'date': 'Feb 15, 2026',
}
 
# Utiliser str.format_map (meilleur que le remplacement manuel)
result = template.format_map(data)
print(result)
# Dear Alice, your order #12345 ships on Feb 15, 2026.

Masquer des données sensibles

import re
 
def redact_pii(text):
    """Masquer les e-mails, numéros de téléphone et SSN."""
    text = re.sub(r'\b[\w.]+@[\w.]+\.\w+\b', '[EMAIL]', text)
    text = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[TÉLÉPHONE]', text)
    text = re.sub(r'\b\d{3}-\d{2}-\d{4}\b', '[SSN]', text)
    return text
 
msg = "Contact john@example.com or call 555-123-4567. SSN: 123-45-6789"
print(redact_pii(msg))
# Contact [EMAIL] or call [TÉLÉPHONE]. SSN: [SSN]

Traitement de données textuelles dans Jupyter

Le nettoyage et la transformation de texte est un travail itératif -- vous testez des motifs sur des données d'exemple, ajustez les regex et vérifiez les résultats. RunCell (opens in a new tab) est un agent IA pour Jupyter qui peut vous aider à construire et déboguer des pipelines de traitement de texte de manière interactive, en testant des motifs de remplacement sur vos données réelles en temps réel.

FAQ

Comment remplacer une sous-chaîne en Python ?

Utilisez str.replace(old, new) pour les remplacements simples : "hello world".replace("world", "python") retourne "hello python". Cela remplace toutes les occurrences. Ajoutez un troisième argument pour limiter les remplacements : text.replace("a", "b", 2) ne remplace que les 2 premières correspondances.

Comment faire un remplacement insensible à la casse en Python ?

Utilisez re.sub() avec le drapeau re.IGNORECASE : re.sub(r'python', 'Java', text, flags=re.IGNORECASE). La méthode intégrée str.replace() ne prend pas en charge la correspondance insensible à la casse.

Comment remplacer plusieurs chaînes différentes en même temps ?

Construisez un motif regex à partir d'un dictionnaire de remplacements : créez un motif compilé correspondant à toutes les clés, puis utilisez un lambda pour rechercher le remplacement de chaque correspondance. Alternativement, enchaînez les appels à .replace() pour un petit nombre de remplacements littéraux.

Quelle est la différence entre str.replace() et re.sub() ?

str.replace() fait uniquement de la correspondance littérale de chaînes -- c'est plus rapide et plus simple. re.sub() utilise des expressions régulières, prenant en charge la correspondance de motifs, les groupes de capture, les références arrière et les remplacements basés sur des fonctions. Utilisez str.replace() pour les échanges littéraux simples et re.sub() quand vous avez besoin de flexibilité de motifs.

Comment supprimer des caractères d'une chaîne en Python ?

Trois approches : str.replace(char, "") supprime toutes les occurrences d'une sous-chaîne spécifique. str.translate(str.maketrans("", "", chars)) supprime efficacement tous les caractères spécifiés. re.sub(r"[pattern]", "", text) supprime les caractères correspondant à un motif regex.

Conclusion

Python offre plusieurs outils pour le remplacement de chaînes, chacun adapté à différents niveaux de complexité. Utilisez str.replace() pour les échanges littéraux simples, re.sub() pour la correspondance de motifs et les règles complexes, et str.translate() pour le mappage rapide au niveau des caractères. Pour plusieurs remplacements simultanés, une approche re.sub() pilotée par dictionnaire maintient votre code propre et maintenable.