Skip to main content

How to Replace Multiple Characters in Python Strings

Replacing multiple characters or substrings within a string is a common requirement in text processing and data cleaning.

This guide explores several effective methods for achieving this in Python, including chaining str.replace(), using loops with lists or dictionaries, leveraging regular expressions with re.sub(), and using the str.translate() method.

Chaining str.replace() Calls (Simple Cases)​

For replacing a small, fixed number of characters, chaining replace() calls is often the simplest and most readable approach:

string = 'tutorial!reference@com'
new_string = string.replace('!', '-').replace('@', '_')
print(new_string)  # Output: tutorial-reference_com
  • Each .replace(old, new) call returns a new string with the specified replacement made.
  • Strings are immutable, so the original string remains unchanged.

Using a Loop with a List of Replacements​

If you have a dynamic or longer list of replacements, use a for loop with a list of tuples (character_to_replace, replacement_character):

string = 'tutorial!reference@com'
replacements = [('!', '-'), ('@', '_')]

for char, replacement in replacements:
    string = string.replace(char, replacement) # Reassign string in each iteration

print(string)  # Output: tutorial-reference_com
  • This approach iterates through the replacements list, applying each replacement sequentially.

Using a Loop with a Dictionary of Replacements​

Similarly, you can use a dictionary to store replacements, where keys are characters to replace and values are the replacements:

string = 'tutorial!reference@com'
replacements_dict = {
    '!': '-',
    '@': '_'
}

for key, value in replacements_dict.items():
    string = string.replace(key, value) # Reassign string in each iteration

print(string)  # Output: tutorial-reference_com
  • This offers a slightly more structured way to manage replacements compared to a list of tuples.

Using Regular Expressions (re.sub())​

Regular expressions provide a powerful and concise way to replace multiple characters based on a pattern:

import re

string = 'tutorial!reference@com#12 34'
# Replace !, @, #, or whitespace with _
new_string = re.sub(r'[!@#\s]', '_', string)
print(new_string)  # Output: tutorial_reference_com_12_34
  • re.sub(pattern, replacement, string) replaces all occurrences matching the pattern.
  • r'[!@#\s]': The pattern uses a character set [...] to match any single character within it (!, @, #, or whitespace \s).
  • This is very efficient for replacing multiple characters belonging to a certain category (e.g., all punctuation, all whitespace).

Using str.translate()​

The str.translate() method offers an efficient way to perform multiple single-character replacements using a translation table created by str.maketrans():

string = 'tutorial!reference@com'
replacements_dict = {'!': '-', '@': '_'}
translation_table = str.maketrans(replacements_dict)
new_string = string.translate(translation_table)

print(new_string)  # Output: tutorial-reference_com
  • str.maketrans(replacements_dict) creates the translation mapping.
  • string.translate(translation_table) applies the mapping to the string.
note

str.maketrans() with a dictionary argument only works for replacing single characters with other single characters (or None to delete). For replacing substrings or using longer replacements, other methods are necessary.

Choosing the Right Method​

  • Simple, Few Replacements: Chaining str.replace() is often the clearest.
  • Dynamic/Many Replacements: Using a loop with a list or dictionary is more scalable.
  • Pattern-Based Replacements: re.sub() is the most powerful and efficient for replacing characters based on patterns (e.g., all digits, all punctuation).
  • Single-Character Replacements: str.translate() can be very efficient for multiple single-character substitutions.

Table of Contents