Python re.escape() Function

last modified April 20, 2025

Introduction to re.escape

The re.escape function is a utility in Python’s re module that escapes special regex metacharacters in strings. It ensures characters are treated as literals in regular expressions.

This function is particularly useful when you need to match strings that may contain regex metacharacters. It automatically escapes all special characters with backslashes.

The escaped string can then be safely used in regular expression patterns without unexpected behavior from metacharacters like *, +, or ?.

Basic Syntax

The syntax for re.escape is simple:

re.escape(pattern)

The function takes a string as input and returns a new string with all regex metacharacters escaped. The original string remains unchanged.

Basic String Escaping

Let’s start with a simple example of escaping a string with special chars.

basic_escape.py

#!/usr/bin/python

import re

text = “file*.txt” escaped = re.escape(text)

print(f"Original: {text}") print(f"Escaped: {escaped}")

This example shows how re.escape converts the asterisk into a literal character by adding a backslash before it.

escaped = re.escape(text)

The function processes the input string and returns a new string with all special regex characters properly escaped.

print(f"Escaped: {escaped}")

The output shows the asterisk is now escaped, making it a literal character in regex patterns.

Escaping Multiple Special Characters

re.escape handles multiple special characters at once.

multiple_chars.py

#!/usr/bin/python

import re

text = “price? $10.50+ (50% off!)” escaped = re.escape(text)

print(f"Original: {text}") print(f"Escaped: {escaped}")

This demonstrates escaping several special characters including ?, $, ., +, (, %, and ).

Using Escaped Strings in Patterns

Escaped strings can be used to create safe regex patterns.

pattern_usage.py

#!/usr/bin/python

import re

user_input = “file[1].txt” pattern = re.compile(re.escape(user_input))

text = “The files are file1.txt, file[1].txt, and file2.txt” match = pattern.search(text)

if match: print(f"Found exact match: {match.group()}")

This shows how to safely use user input in regex patterns by escaping it first. The square brackets are treated as literals, not character classes.

Escaping for Search and Replace

Escaped strings are useful in search and replace operations.

search_replace.py

#!/usr/bin/python

import re

search_term = “C++” replacement = “Python” text = “I love C++ programming”

escaped_search = re.escape(search_term) result = re.sub(escaped_search, replacement, text)

print(f"Original: {text}") print(f"Modified: {result}")

This example safely replaces “C++” with “Python” by first escaping the plus signs in the search term.

Escaping Dynamic Patterns

re.escape is essential when building patterns dynamically.

dynamic_patterns.py

#!/usr/bin/python

import re

def find_exact_match(text, search_term): pattern = re.compile(f"^{re.escape(search_term)}$") return bool(pattern.match(text))

print(find_exact_match(“file.txt”, “file.txt”)) # True print(find_exact_match(“file.txt”, “file*.txt”)) # False

This function checks for exact matches by escaping the search term and wrapping it in start/end anchors. The asterisk is treated literally.

Escaping for Filename Patterns

Filename patterns often contain special characters that need escaping.

filenames.py

#!/usr/bin/python

import re

filenames = [“report.pdf”, “data*.csv”, “notes?.txt”, “backup.zip”] search_pattern = “data*.csv”

escaped_pattern = re.escape(search_pattern) matching_files = [f for f in filenames if re.fullmatch(escaped_pattern, f)]

print(“Matching files:”, matching_files)

This finds filenames matching an exact pattern, treating the asterisk as a literal character rather than a wildcard.

Escaping Special Characters in Paths

File paths often contain characters that need escaping in regex.

path_escaping.py

#!/usr/bin/python

import re

path = “C:\Users\John\Documents\file[1].txt” escaped_path = re.escape(path)

print(f"Original path: {path}") print(f"Escaped path: {escaped_path}")

This demonstrates escaping Windows paths containing backslashes and square brackets. Each special character is properly escaped.

Best Practices

When using re.escape, follow these best practices:

• Always escape user input before using it in regex patterns

• Remember that escaping makes special characters literal

• Combine with raw strings for complex patterns

• Use for dynamic pattern construction

• Consider performance for very large strings

Performance Considerations

re.escape adds some overhead as it scans the entire string. For most use cases, this overhead is negligible.

For extremely large strings or performance-critical code, consider alternatives like pre-escaping known patterns or using string methods when possible.

Source

Python re.escape documentation

This tutorial covered the essential aspects of Python’s re.escape function. Proper use of escaping makes regex patterns safer and more predictable.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.