Python Regex Tutorial: A Complete Guide to Regular Expressions in Python (2026)
Written by Guest
By Mihir Das | Updated March 2026 | Python · Regex · Text Processing · Data Cleaning
Primary Keyword: Python regex tutorial Secondary Keywords: regular expressions in Python, Python re module, regex patterns Python, Python string matching, regex cheat sheet, regex examples Python, how to use regex in Python
Introduction: Why Python Regex Skills Are Essential in 2026
If you've ever needed to validate an email address, extract data from a log file, or clean messy text in Python, you've already run into a problem that Python regular expressions were built to solve. After years of writing Python professionally, regex is one of those skills I wish I had learned properly from the start.
A regular expression (regex) is a sequence of characters that defines a search pattern. Python's built-in re module lets you use that pattern to find, match, replace, or split strings with surgical precision, in just a few lines of code.
In this complete Python regex tutorial, I'll walk you through everything from your first re.search() call to advanced techniques like lookaheads, named groups, and compiled patterns. Every section includes working code examples you can run immediately.
What you'll learn in this guide:
- How to use every core function in Python's
remodule - How to build regex patterns step by step
- Greedy vs. lazy matching and why it matters
- Real-world examples including email validation, log parsing, and URL extraction
- The most common regex mistakes and exactly how to fix them
- Performance tips for production-grade code
Whether you're a beginner writing your first pattern or an experienced developer looking to sharpen your skills, this guide has something for you.
Table of Contents
1. Getting Started: Python's re Module
Python's re module is the standard library for working with regular expressions. It comes built into Python, which means you don't need to install anything.
import re
That single import gives you access to every regex tool covered in this guide. The re module works with Python 3.x and is available in all modern Python versions, including 3.10, 3.11, 3.12, and beyond.
When Should You Use Python Regex?
Python regex is the right tool when you need to:
- Match patterns rather than exact strings (e.g., any email address, any 5-digit zip code)
- Extract structured data from unstructured text (e.g., dates, prices, phone numbers)
- Validate input formats like emails, URLs, and passwords
- Search and replace with pattern-based rules rather than fixed strings
- Split strings on complex delimiters
For simple string operations (exact substring checks, fixed splits), Python's built-in string methods like str.find(), str.split(), and str.replace() are faster and easier to read. Use regex when the pattern is dynamic or complex.
2. Your First Python Regular Expression
Let's write the simplest possible Python regex: checking whether a word exists in a string.
import re
text = "I love Python programming."
match = re.search(r"Python", text)
if match:
print("Found:", match.group())
else:
print("Not found.")
Output:
Found: Python
Understanding Raw Strings in Python Regex
Notice the r prefix before the pattern string. That's a Python raw string, and it's critical for writing regex correctly. Without it, Python interprets backslashes as escape sequences before the regex engine ever sees them.
For example, "\d" in a regular string becomes just "d" (because \d is not a recognized escape, Python may drop the backslash). But r"\d" passes the literal characters \d to the regex engine, which correctly interprets it as "any digit."
Rule: Always use raw strings (r"...") for Python regex patterns.
3. Core Python Regex Functions Explained
The re module provides eight key functions. I'll explain each one clearly, including the difference between re.match() and re.search(), which is one of the most common points of confusion for Python developers learning regex.
re.search() -- Find a Pattern Anywhere in a String
re.search() scans the entire string and returns the first location where the pattern matches. Returns None if no match is found.
result = re.search(r"\d+", "I have 42 apples and 7 oranges")
print(result.group()) # Output: 42
Use this when: You want to find a pattern anywhere in the string.
re.match() -- Match Only at the Start of a String
re.match() only checks for a match at the very beginning of the string. This is the function most beginners misuse.
result = re.match(r"\d+", "42 is the answer")
print(result.group()) # Output: 42
result = re.match(r"\d+", "The answer is 42")
print(result) # Output: None (no match at the start)
Use this when: You're checking that a string starts with a specific pattern.
re.fullmatch() -- Match the Entire String
re.fullmatch() requires the entire string to match the pattern. I use this constantly for input validation.
result = re.fullmatch(r"\d{5}", "12345")
print(result.group()) # Output: 12345
result = re.fullmatch(r"\d{5}", "1234567")
print(result) # Output: None (too many digits)
Use this when: Validating that an input conforms exactly to a required format.
re.findall() -- Return All Matches as a List
re.findall() returns a list of all non-overlapping matches in the string. This is the function I use most often in data extraction work.
text = "I have 3 cats, 2 dogs, and 10 fish."
numbers = re.findall(r"\d+", text)
print(numbers) # Output: ['3', '2', '10']
Important: When your pattern contains capturing groups, findall() returns the group contents rather than the full match. I cover this in detail in the Common Mistakes section.
re.finditer() -- Return Matches as an Iterator
re.finditer() works like findall() but returns an iterator of match objects instead of a list. For large texts, this is significantly more memory-efficient.
text = "cat bat sat"
for match in re.finditer(r"\w+at", text):
print(match.group(), "at position", match.start())
Output:
cat at position 0
bat at position 4
sat at position 8
Use this when: Iterating over many matches in a large string and you don't need them all in memory at once.
re.sub() -- Search and Replace with Regex
re.sub() replaces every match with a replacement string. It's far more powerful than str.replace() because the search pattern can be a regex.
text = "Hello, my phone is 123-456-7890."
result = re.sub(r"\d", "*", text)
print(result) # Output: Hello, my phone is ***-***-****.
You can also pass a function as the replacement, which receives each match object and returns the replacement string:
text = "hello world"
result = re.sub(r"\b\w", lambda m: m.group().upper(), text)
print(result) # Output: Hello World
re.split() -- Split a String by a Regex Pattern
re.split() splits the string wherever the pattern matches. This is more flexible than str.split(), which only handles fixed delimiters.
text = "one1two2three3four"
parts = re.split(r"\d", text)
print(parts) # Output: ['one', 'two', 'three', 'four']
re.compile() -- Pre-compile a Pattern for Reuse
re.compile() compiles a regex pattern into a reusable pattern object. See Section 10 for a full breakdown. Use it whenever you're applying the same pattern multiple times.
4. Python Regex Syntax: Patterns and Character Classes
This section covers the building blocks of Python regex patterns. Understanding these thoroughly is what separates developers who Google regex from those who write it fluently.
Literal Characters
The simplest Python regex pattern is a literal character or string. The pattern cat matches the exact substring "cat" anywhere in the text.
re.search(r"cat", "I have a cat") # Match
re.search(r"cat", "I have a dog") # No match
The Dot . -- Wildcard for Any Single Character
The dot . matches any single character except a newline (\n). It's one of the most-used regex metacharacters.
re.findall(r"c.t", "cat cut cot c4t c t")
# Output: ['cat', 'cut', 'cot', 'c4t', 'c t']
To match a literal dot, escape it with a backslash: r"\.".
Character Classes [ ] -- Match One of Several Characters
Square brackets define a character class, matching any one character from the set.
re.findall(r"[aeiou]", "Hello World")
# Output: ['e', 'o', 'o']
Ranges inside character classes let you specify spans of characters concisely:
[a-z]-- any lowercase letter[A-Z]-- any uppercase letter[0-9]-- any digit[a-zA-Z0-9]-- any alphanumeric character
re.findall(r"[A-Z][a-z]+", "Hello World from Python")
# Output: ['Hello', 'World', 'Python']
Negated character classes use ^ at the start of the brackets to match anything except the listed characters:
re.findall(r"[^aeiou\s]", "hello")
# Output: ['h', 'l', 'l'] (consonants only)
Python Regex Shorthand Character Classes
Python's re module provides shorthand classes that I rely on in nearly every regex I write:
| Shorthand | Meaning | Equivalent |
|---|---|---|
\d | Any digit | [0-9] |
\D | Any non-digit | [^0-9] |
\w | Word character (letter, digit, or underscore) | [a-zA-Z0-9_] |
\W | Non-word character | [^a-zA-Z0-9_] |
\s | Any whitespace character | [ \t\n\r\f\v] |
\S | Any non-whitespace character | [^ \t\n\r\f\v] |
\b | Word boundary (position between word and non-word character) | -- |
\B | Non-word boundary | -- |
re.findall(r"\d+", "Phone: 123-456-7890")
# Output: ['123', '456', '7890']
re.findall(r"\w+", "Hello, World!")
# Output: ['Hello', 'World']
Regex Anchors -- Matching Positions, Not Characters
Anchors are zero-width assertions. They don't consume characters; they match positions within the string.
| Anchor | Matches |
|---|---|
^ | Start of string (or each line with re.MULTILINE) |
$ | End of string (or each line with re.MULTILINE) |
\b | Word boundary |
\A | Absolute start of string (unaffected by re.MULTILINE) |
\Z | Absolute end of string (unaffected by re.MULTILINE) |
re.search(r"^\d+", "42 is the answer") # Matches: '42'
re.search(r"^\d+", "The answer is 42") # No match
re.findall(r"\bcat\b", "cat concatenate catch")
# Output: ['cat'] -- only the standalone word, not 'catch' or 'concatenate'
Anchors are especially useful when validating input, where you need to ensure a pattern covers the entire string from start to finish.
5. Regex Quantifiers: Controlling Repetition in Python
Quantifiers tell the regex engine how many times to match a character, group, or character class. They're the key to writing patterns that handle variable-length input.
Python Regex Quantifier Reference
| Quantifier | Meaning | Example |
|---|---|---|
* | 0 or more times | \d* matches "", "1", "123" |
+ | 1 or more times | \d+ matches "1", "123" but not "" |
? | 0 or 1 time (makes it optional) | colou?r matches "color" and "colour" |
{n} | Exactly n times | \d{4} matches "2024" only |
{n,} | At least n times | \d{2,} matches "12", "123", "1234" |
{n,m} | Between n and m times | \d{2,4} matches "12", "123", "1234" |
re.findall(r"go+al", "goal gooal goooal gal")
# Output: ['goal', 'gooal', 'goooal'] -- 'gal' excluded, needs at least one 'o'
re.findall(r"colou?r", "color colour")
# Output: ['color', 'colour'] -- the 'u' is optional
re.findall(r"\d{3}-\d{4}", "Call 555-1234 or 800-5678")
# Output: ['555-1234', '800-5678']
Greedy vs. Lazy Matching in Python Regex
This is one of the most important concepts in Python regex, and it's responsible for a huge number of bugs I've seen in real code.
By default, all quantifiers are greedy. A greedy quantifier matches as much text as possible.
text = "<b>bold</b> and <i>italic</i>"
re.findall(r"<.+>", text)
# Output: ['<b>bold</b> and <i>italic</i>'] -- grabbed everything!
The .+ matched all the way from the first < to the last > in the string. That's almost certainly not what you wanted.
Adding ? after any quantifier makes it lazy (also called "non-greedy"). A lazy quantifier matches as little as possible.
re.findall(r"<.+?>", text)
# Output: ['<b>', '</b>', '<i>', '</i>'] -- correct!
Rule of thumb: When matching content between opening and closing delimiters, use lazy quantifiers (*?, +?, ??, {n,m}?) unless you have a specific reason to use greedy ones.
6. Groups and Capturing in Python Regex
Groups are one of the most powerful features of Python regex. Parentheses ( ) serve two purposes: grouping parts of a pattern so you can apply quantifiers to them, and capturing the matched text so you can extract it.
Basic Capturing Groups
text = "2024-03-15"
match = re.search(r"(\d{4})-(\d{2})-(\d{2})", text)
if match:
print("Full match:", match.group(0)) # 2024-03-15
print("Year:", match.group(1)) # 2024
print("Month:", match.group(2)) # 03
print("Day:", match.group(3)) # 15
Groups are numbered left to right, starting at 1. group(0) always returns the full match.
Named Capturing Groups in Python Regex
Named groups ((?P<name>...)) are the version I always reach for in production code. They make patterns self-documenting and eliminate fragile numeric references.
text = "2024-03-15"
match = re.search(
r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})",
text
)
if match:
print(match.group("year")) # 2024
print(match.group("month")) # 03
print(match.group("day")) # 15
print(match.groupdict()) # {'year': '2024', 'month': '03', 'day': '15'}
Non-Capturing Groups (?:...)
When you need to group a part of your pattern for a quantifier or alternation, but you don't need to extract the matched text, use non-capturing groups. They're slightly more efficient and keep your group numbering clean.
re.findall(r"(?:cat|dog)s?", "I love cats and dogs and one cat")
# Output: ['cats', 'dogs', 'cat']
Backreferences: Matching Repeated Patterns
A backreference lets you refer to a previously captured group within the same pattern. Use \1 to reference group 1, \2 for group 2, and so on.
# Detect repeated words in text
text = "the the quick brown fox jumps over the the lazy dog"
re.findall(r"\b(\w+)\s+\1\b", text)
# Output: ['the', 'the']
This is the pattern I use to detect copy-editing errors like "the the" in documents.
7. Alternation with the Pipe Operator
The pipe | in Python regex works like a logical OR. It matches either the expression on its left or the one on its right.
re.findall(r"cat|dog|bird", "I have a cat and a dog but no bird.")
# Output: ['cat', 'dog', 'bird']
Important: The regex engine tries alternatives left to right and stops at the first match. Order matters when alternatives overlap.
Use groups to control the scope of alternation. Without them, | applies to the entire expression on each side.
# With capturing group -- returns only the group content
re.findall(r"gr(e|a)y", "grey and gray are both valid")
# Output: ['e', 'a']
# With non-capturing group -- returns the full match
re.findall(r"gr(?:e|a)y", "grey and gray are both valid")
# Output: ['grey', 'gray']
The non-capturing group version is what you almost always want when using alternation.
8. Lookahead and Lookbehind Assertions
Lookaheads and lookbehinds are zero-width assertions. They let you match a pattern only if it's followed or preceded by another pattern, without including that surrounding context in the match itself.
I find these invaluable for extracting values that appear in specific contexts, like prices after a currency symbol or values before a unit of measurement.
Positive Lookahead (?=...)
Matches the current position only if it's followed by the specified pattern.
# Extract numbers only when followed by 'px'
re.findall(r"\d+(?=px)", "font-size: 16px, margin: 10em, padding: 8px")
# Output: ['16', '8'] -- '10' excluded because it's followed by 'em'
Negative Lookahead (?!...)
Matches the current position only if it is NOT followed by the specified pattern.
# Extract numbers that are NOT followed by 'px'
re.findall(r"\d+(?!px)\b", "16px 10em 8px 200")
# Output: ['10', '200']
Positive Lookbehind (?<=...)
Matches the current position only if it's preceded by the specified pattern.
# Extract dollar amounts (numbers preceded by '$')
re.findall(r"(?<=\$)\d+", "Price: $100 and $250 or €300")
# Output: ['100', '250'] -- '300' excluded, preceded by '€'
Negative Lookbehind (?<!...)
Matches the current position only if it is NOT preceded by the specified pattern.
re.findall(r"(?<!\$)\d+", "Price: $100 and 250 free")
# Output: ['250'] -- '100' excluded because it follows '$'
Python Regex Limitation: Lookbehind assertions must have a fixed width in Python. You cannot use
*,+, or?inside a lookbehind. For variable-width lookbehinds, you'll need a workaround such asre.split()or adjusting your pattern logic.
9. Python Regex Flags and Modifiers
Flags change the behavior of the regex engine. You pass them as the third argument to most re functions, or combine multiple flags using |.
re.IGNORECASE / re.I -- Case-Insensitive Matching
re.findall(r"python", "Python PYTHON python", re.IGNORECASE)
# Output: ['Python', 'PYTHON', 'python']
re.MULTILINE / re.M -- Multi-Line Mode
By default, ^ and $ match the start and end of the entire string. With re.MULTILINE, they match the start and end of each line.
text = "first line\nsecond line\nthird line"
re.findall(r"^\w+", text, re.MULTILINE)
# Output: ['first', 'second', 'third']
re.DOTALL / re.S -- Dot Matches Newlines
By default, . does not match \n. The re.DOTALL flag removes this restriction.
text = "Hello\nWorld"
re.search(r"Hello.World", text) # No match
re.search(r"Hello.World", text, re.DOTALL) # Match
re.VERBOSE / re.X -- Readable Multi-Line Patterns
This is the flag that changed how I write complex regex in Python. re.VERBOSE lets you spread a pattern across multiple lines with comments, making it far easier to maintain.
phone_pattern = re.compile(r"""
\(? # Optional opening parenthesis
(\d{3}) # Area code -- 3 digits
\)? # Optional closing parenthesis
[\s\-]? # Optional space or hyphen separator
(\d{3}) # Exchange code -- 3 digits
[\s\-]? # Optional separator
(\d{4}) # Subscriber number -- 4 digits
""", re.VERBOSE)
match = phone_pattern.search("Call me at (123) 456-7890")
print(match.groups()) # ('123', '456', '7890')
Without re.VERBOSE, that same pattern would be r"\(?(\d{3})\)?[\s\-]?(\d{3})[\s\-]?(\d{4})" -- readable only to whoever wrote it.
Combining Multiple Flags
re.findall(r"^python", text, re.IGNORECASE | re.MULTILINE)
10. Compiling Regex Patterns with re.compile()
When you use the same regex pattern more than once in your code, always compile it first with re.compile(). This parses the pattern once and stores the result as a pattern object, so Python doesn't re-parse it on every call.
email_pattern = re.compile(
r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
)
emails = [
"user@example.com",
"not-an-email",
"another.user@domain.org"
]
for item in emails:
if email_pattern.fullmatch(item):
print(f"{item} -- valid")
else:
print(f"{item} -- invalid")
A compiled pattern object exposes the same functions as the re module: .search(), .match(), .fullmatch(), .findall(), .finditer(), .sub(), and .split().
Performance benefit: In loops or functions that run frequently, using re.compile() can meaningfully reduce CPU time. The gain is small for a handful of calls, but significant when processing thousands of strings.
11. Python Regex Examples: Real-World Use Cases
Here are the Python regex patterns I reach for most often in real projects, with full working code.
Python Regex for Email Validation
import re
def is_valid_email(email: str) -> bool:
pattern = re.compile(
r"^[a-zA-Z0-9._%+-]+" # Local part
r"@" # @ symbol
r"[a-zA-Z0-9.-]+" # Domain name
r"\.[a-zA-Z]{2,}$" # Top-level domain (at least 2 chars)
)
return bool(pattern.fullmatch(email))
# Test cases
print(is_valid_email("user@example.com")) # True
print(is_valid_email("first.last@domain.co")) # True
print(is_valid_email("bad@")) # False
print(is_valid_email("no-at-sign.com")) # False
Python Regex for URL Extraction
text = """
Visit https://www.python.org for official docs.
Also check http://realpython.com and https://docs.python.org/3/
"""
url_pattern = re.compile(r"https?://[^\s]+")
urls = url_pattern.findall(text)
for url in urls:
print(url)
Output:
https://www.python.org
http://realpython.com
https://docs.python.org/3/
Python Regex for Log File Parsing
Log file parsing is one of the tasks where Python regex delivers the most value. Here's a pattern for structured log lines with date, time, level, and message:
log = """
2024-03-15 10:23:45 ERROR Connection timeout
2024-03-15 10:24:01 INFO Request received
2024-03-15 10:24:03 WARNING High memory usage
"""
log_pattern = re.compile(
r"(?P<date>\d{4}-\d{2}-\d{2})\s+"
r"(?P<time>\d{2}:\d{2}:\d{2})\s+"
r"(?P<level>\w+)\s+"
r"(?P<message>.+)"
)
for match in log_pattern.finditer(log.strip()):
d = match.groupdict()
print(f"[{d['level']}] {d['date']} {d['time']}: {d['message']}")
Output:
[ERROR] 2024-03-15 10:23:45: Connection timeout
[INFO] 2024-03-15 10:24:01: Request received
[WARNING] 2024-03-15 10:24:03: High memory usage
Python Regex for HTML Tag Removal and Text Cleaning
def clean_html_text(text: str) -> str:
# Remove all HTML tags
text = re.sub(r"<[^>]+>", "", text)
# Collapse multiple whitespace characters into a single space
text = re.sub(r"\s+", " ", text)
return text.strip()
raw = "<p> Hello <b>World</b>! This is a test. </p>"
print(clean_html_text(raw))
# Output: Hello World! This is a test.
Python Regex for Config File Parsing
config_text = """
host=localhost
port=5432
database=myapp
user=admin
"""
key_value_pattern = re.compile(r"^(?P<key>\w+)=(?P<value>.+)$", re.MULTILINE)
config = {
m.group("key"): m.group("value")
for m in key_value_pattern.finditer(config_text)
}
print(config)
# Output: {'host': 'localhost', 'port': '5432', 'database': 'myapp', 'user': 'admin'}
Python Regex Password Strength Validator
def check_password_strength(password: str) -> bool:
rules = {
"At least 8 characters": len(password) >= 8,
"Contains uppercase letter": bool(re.search(r"[A-Z]", password)),
"Contains lowercase letter": bool(re.search(r"[a-z]", password)),
"Contains digit": bool(re.search(r"\d", password)),
"Contains special character": bool(
re.search(r"[!@#$%^&*(),.?\":{}|<>]", password)
),
}
for rule, passed in rules.items():
print(f"{'✓' if passed else '✗'} {rule}")
return all(rules.values())
check_password_strength("MyP@ssw0rd!")
12. Common Python Regex Mistakes (and How to Fix Them)
These are the errors I see most often when reviewing Python code that uses regular expressions.
Mistake 1: Not Using Raw Strings
Problem: Without the r prefix, backslashes in your pattern are interpreted by Python before the regex engine sees them.
# Wrong -- \d may not work as expected
re.findall("\d+", "Price: 42")
# Correct -- always use raw strings
re.findall(r"\d+", "Price: 42")
Fix: Add r before every regex pattern string. Make it a reflex.
Mistake 2: Using re.match() Instead of re.search()
Problem: re.match() only checks the beginning of the string. Developers often use it expecting it to search the whole string.
# This returns None -- there's no digit at the very start
result = re.match(r"\d+", "The answer is 42")
print(result) # None
# This works as expected
result = re.search(r"\d+", "The answer is 42")
print(result.group()) # 42
Fix: Use re.search() to find a pattern anywhere in the string. Reserve re.match() for patterns that must appear at the start.
Mistake 3: Greedy Matching Capturing Too Much
Problem: Greedy quantifiers match as much text as possible, often capturing more than intended.
text = "<title>Home Page</title>"
# Wrong -- greedy matches too much
re.search(r"<.+>", text).group()
# Output: '<title>Home Page</title>'
# Correct -- lazy matches as little as needed
re.search(r"<.+?>", text).group()
# Output: '<title>'
Fix: Add ? after quantifiers to make them lazy: +?, *?, {n,m}?.
Mistake 4: Forgetting to Escape Special Characters
Problem: Characters like ., +, *, ?, (, ), [, ], {, }, ^, $, |, and \ are regex metacharacters. If you want to match them literally, you must escape them.
# Wrong -- the dot matches any character
re.search(r"3.14", "3X14") # Matches! (dot = any char)
# Correct -- escape the dot
re.search(r"3\.14", "3X14") # No match
re.search(r"3\.14", "3.14") # Match
When you need to match an arbitrary user-supplied string, use re.escape() to automatically escape all metacharacters:
user_input = "price.per+unit"
safe_pattern = re.escape(user_input)
print(safe_pattern) # price\.per\+unit
Mistake 5: Misunderstanding findall() with Capturing Groups
Problem: When your pattern contains capturing groups, re.findall() returns the contents of those groups, not the full match.
# No groups -- returns full matches
re.findall(r"\d+-\d+", "10-20 and 30-40")
# Output: ['10-20', '30-40'] -- correct
# With groups -- returns group contents only
re.findall(r"(\d+)-(\d+)", "10-20 and 30-40")
# Output: [('10', '20'), ('30', '40')] -- tuples of group values!
Fix: If you need the full match and also want groups, use re.finditer() and call .group(0) on each match object.
Mistake 6: Catastrophic Backtracking
Problem: Patterns with nested quantifiers like (a+)+ can cause the regex engine to perform exponential amounts of work on certain non-matching inputs, making your program hang.
import re, time
# Dangerous pattern
pattern = re.compile(r"(a+)+b")
start = time.time()
pattern.search("a" * 30) # This could take seconds or minutes
print(time.time() - start)
Fix: Avoid nested quantifiers. Rewrite the pattern to be more specific. For example, (a+)+b can almost always be simplified to a+b.
13. Python Regex Performance Tips
For scripts that run regex operations in tight loops or on large datasets, performance matters. Here's what I've learned from profiling real Python applications.
1. Compile patterns you reuse. Calling re.compile() once at module level and reusing the pattern object avoids parsing overhead on every call.
# At module level -- parsed once
EMAIL_PATTERN = re.compile(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}")
# In your function -- reused
def extract_emails(text):
return EMAIL_PATTERN.findall(text)
2. Use specific patterns over broad ones. \d{4}-\d{2}-\d{2} is faster than \S+ when matching dates, because the engine can rule out non-matches quickly.
3. Anchor patterns whenever possible. If you know a match must start at the beginning of the string, use ^. This prevents the engine from scanning the entire string.
4. Know when NOT to use regex. For simple, fixed-string operations, Python's built-in string methods outperform regex and are easier to read. "error" in line is faster than re.search(r"error", line).
5. Profile before optimizing. Don't assume regex is your bottleneck. Use cProfile or timeit to measure before spending time on optimization.
6. Consider the regex third-party library. The regex package (installable via pip install regex) is a drop-in replacement for re with better performance on complex patterns and additional features like variable-width lookbehinds.
14. Python Regex Cheat Sheet (Quick Reference)
Bookmark this section for fast lookups while writing Python regex patterns.
Anchors
| Pattern | Meaning |
|---|---|
^ | Start of string (or line with re.M) |
$ | End of string (or line with re.M) |
\b | Word boundary |
\A | Absolute start of string |
\Z | Absolute end of string |
Character Classes
| Pattern | Meaning |
|---|---|
\d | Any digit [0-9] |
\D | Any non-digit |
\w | Word character [a-zA-Z0-9_] |
\W | Non-word character |
\s | Whitespace |
\S | Non-whitespace |
. | Any character except newline |
Quantifiers
| Pattern | Meaning |
|---|---|
* | 0 or more (greedy) |
+ | 1 or more (greedy) |
? | 0 or 1 (greedy) |
*? | 0 or more (lazy) |
+? | 1 or more (lazy) |
{n} | Exactly n times |
{n,m} | Between n and m times |
{n,m}? | Between n and m times (lazy) |
Groups
| Pattern | Meaning |
|---|---|
(...) | Capturing group |
(?:...) | Non-capturing group |
(?P<name>...) | Named capturing group |
\1, \2 | Backreference to group 1, 2 |
(?P=name) | Backreference to named group |
Lookarounds
| Pattern | Meaning |
|---|---|
(?=...) | Positive lookahead |
(?!...) | Negative lookahead |
(?<=...) | Positive lookbehind (fixed width) |
(?<!...) | Negative lookbehind (fixed width) |
Flags
| Flag | Shorthand | Meaning |
|---|---|---|
re.IGNORECASE | re.I | Case-insensitive matching |
re.MULTILINE | re.M | ^ and $ match each line |
re.DOTALL | re.S | Dot matches newlines |
re.VERBOSE | re.X | Allow whitespace and comments in pattern |
Key re Functions
| Function | Returns | Use Case |
|---|---|---|
re.search(p, s) | First match object or None | Find pattern anywhere in string |
re.match(p, s) | Match object or None | Match at start of string |
re.fullmatch(p, s) | Match object or None | Entire string must match |
re.findall(p, s) | List of strings | All matches as a list |
re.finditer(p, s) | Iterator of match objects | All matches, memory-efficient |
re.sub(p, r, s) | New string | Search and replace |
re.split(p, s) | List of strings | Split by pattern |
re.compile(p) | Pattern object | Pre-compile for reuse |
re.escape(s) | Escaped string | Safely escape user input |
15. Frequently Asked Questions (FAQ)
What is a regular expression in Python?
A regular expression (regex) in Python is a sequence of characters that defines a search pattern. Python's re module uses these patterns to find, match, replace, or split strings. For example, r"\d+" is a regex pattern that matches one or more digits.
What is the difference between re.match() and re.search() in Python?
re.match() only looks for a match at the beginning of the string. re.search() scans the entire string for the first match. If you're not sure which to use, re.search() is almost always the right choice.
How do I match a literal dot or other special character in Python regex?
Escape it with a backslash: r"\." matches a literal dot, r"\+" matches a literal plus sign. For user-supplied strings, use re.escape(user_input) to escape all metacharacters automatically.
What does the r prefix mean in Python regex strings?
The r prefix creates a raw string, which tells Python not to process backslash escape sequences. This is essential for regex patterns because \d, \w, \s, etc. must reach the regex engine with their backslashes intact.
How do I do a case-insensitive regex search in Python?
Pass re.IGNORECASE (or re.I) as the third argument: re.search(r"python", text, re.IGNORECASE).
What is greedy vs. lazy matching in Python regex?
By default, quantifiers like + and * are greedy: they match as much text as possible. Adding ? after a quantifier makes it lazy: it matches as little as possible. Use +? instead of + when you want the shortest possible match.
When should I use re.compile() in Python?
Use re.compile() whenever you use the same regex pattern more than once. It pre-parses the pattern, saving processing time on repeated calls. In performance-sensitive code, always compile at module level rather than inside functions.
Is Python regex slow?
Python regex can be slow if patterns are poorly written (see catastrophic backtracking in Section 12). For most tasks, performance is excellent. If regex is a bottleneck, consider the third-party regex library, which is faster on complex patterns and adds features Python's re module lacks.
What are the best tools for writing and testing Python regex?
regex101.com is the tool I use most. It provides real-time pattern explanation, match highlighting, and a Python-specific mode. pythex.org is another solid option. For IDE support, VS Code has excellent regex highlighting and testing extensions.
Conclusion: Mastering Python Regex Takes Practice
Python regular expressions are a skill with a steep-looking entry point but a very fast payoff. The patterns that seem cryptic at first start to read like plain English once you've written a few dozen of them.
My practical advice: don't try to memorize everything at once. Start with re.search(), re.findall(), and basic character classes. Solve one real problem with regex every week. Validate an input, parse a file format, clean a dataset. Each problem you solve builds intuition that no tutorial can fully replace.
A few tools that made the biggest difference in my own learning were regex101.com for real-time feedback, re.VERBOSE for writing readable patterns, and the habit of always compiling patterns I reuse with re.compile().
Regular expressions are not always the right tool. For simple fixed-string operations, Python's built-in string methods are faster and clearer. But when the pattern is complex, the structure is variable, or you're processing text at scale, regex is often the most concise and powerful solution available.
Bookmark this guide, keep the cheat sheet handy, and start building your pattern library today.
Found this Python regex guide helpful? Share it with a fellow developer who's learning regular expressions.
Tags
Similar Articles
No similar articles found.