Python re.sub() Function: Performing String Replacement with Regular Expressions (With Examples)

Introduction

Regular expressions are powerful tools used in text processing for pattern matching and manipulation. The re.sub() function in Python’s re module allows you to perform string replacement using regular expressions. This tutorial will provide a comprehensive overview of how to use the re.sub() function effectively, along with practical examples to illustrate its usage.

Table of Contents

1. Basic Syntax of re.sub()
2. Flags for Modifying Matching Behavior
3. Using Groups in Replacement
4. Examples
   • Example 1: Simple String Replacement
   • Example 2: Advanced Replacement with Groups
5. Conclusion

1. Basic Syntax of re.sub()

The basic syntax of the re.sub() function is as follows:

re.sub(pattern, replacement, string, count=0, flags=0)

• pattern: The regular expression pattern you want to search for in the string.
• replacement: The string to replace the matched occurrences of pattern.
• string: The input string in which you want to perform replacements.
• count: The maximum number of replacements to perform. If omitted or set to 0, all occurrences will be replaced.
• flags: Optional flags to modify the matching behavior (case-insensitive, multiline, etc.).

The re.sub() function returns a new string with the replacements made according to the provided pattern and replacement.

2. Flags for Modifying Matching Behavior

Before we delve into examples, let’s briefly discuss the flags that can be used with the re.sub() function to modify its matching behavior:

• re.IGNORECASE (re.I): Perform case-insensitive matching.
• re.MULTILINE (re.M): Allow the ^ and $ anchors to match the start and end of each line.
• re.DOTALL (re.S): Make the . character match any character, including newline.
• re.UNICODE (re.U): Enable Unicode matching.
• re.VERBOSE (re.X): Allow the use of whitespace and comments within the pattern for better readability.

Flags can be combined using the bitwise OR (|) operator. For example, re.IGNORECASE | re.MULTILINE enables both case-insensitive and multiline matching.

3. Using Groups in Replacement

Groups in regular expressions are enclosed in parentheses and allow you to capture specific parts of the matched text. You can refer to these captured groups in the replacement string using backreferences. The syntax for using backreferences is \n, where n is the index of the captured group.

For instance, if you have a pattern with groups (pattern1)(pattern2), you can reference these groups in the replacement string as \1 and \2, respectively.

4. Examples

In this section, we’ll explore two examples to demonstrate the usage of the re.sub() function.

Example 1: Simple String Replacement

Suppose you have a text with profanity and you want to censor the offensive words. Let’s say we want to replace instances of “bad” and “ugly” with asterisks. Here’s how you can achieve this using the re.sub() function:

import re

text = "This is a bad example and contains ugly language."
censored_text = re.sub(r'bad|ugly', '***', text)

print(censored_text)

In this example, we use the regular expression pattern bad|ugly to match either “bad” or “ugly”. The replacement string '***' is used to replace each occurrence of the matched pattern.

Example 2: Advanced Replacement with Groups

Consider a scenario where you have a list of dates in the format “YYYY-MM-DD” and you want to reformat them to “DD-MM-YYYY”. Here’s how you can achieve this using groups and backreferences:

import re

dates = [
    "2023-08-01",
    "2022-05-15",
    "2021-12-25"
]

def reformat_date(match):
    year, month, day = match.groups()
    return f"{day}-{month}-{year}"

formatted_dates = [re.sub(r'(\d{4})-(\d{2})-(\d{2})', reformat_date, date) for date in dates]

for date in formatted_dates:
    print(date)

In this example, the pattern (\d{4})-(\d{2})-(\d{2}) captures the year, month, and day using three groups. The reformat_date() function uses these groups to rearrange the date components in the desired format. The re.sub() function calls this function for each match and replaces the matched date with the reformatted version.

5. Conclusion

The re.sub() function is a versatile tool for performing string replacements using regular expressions. With its ability to handle complex patterns, groups, and backreferences, you can achieve a wide range of text manipulation tasks. By understanding the basic syntax, flags, and group usage, you can harness the power of regular expressions to efficiently process and transform text data. Remember to practice and experiment with different patterns to become more proficient in using re.sub() for various text processing needs.