Academy — Sanjib Sikder

Pattern Matching

String methods like find(), startswith(), and replace() work on fixed, known text. But many real-world problems involve text that follows a pattern rather than an exact string.

Does this string look like an email address? Extract all numbers from this sentence. Replace every date formatted as DD/MM/YYYY with YYYY-MM-DD. Find every word that starts with a capital letter.

These questions can't be answered with simple string methods. They require regular expressions — a language for describing patterns in text.

Python's re module provides the full regular expression engine.

Your First Pattern

Python

Ctrl+Enter to run

import re

text = #22c55e">"The price is 250 rupees."
match = re.search(r#22c55e">"\d+", text)

if match:
    print(#22c55e">"Found:", match.group())
print(#22c55e">"At position:", match.start(), "-", match.end())

re.search(pattern, string) scans the string for the first location where the pattern matches.

r"\d+" is the pattern:

\d — matches any digit character (0–9)
+ — one or more of the preceding element

The r prefix marks a raw string — backslashes are passed through literally, not interpreted as escape sequences. Always use raw strings for regex patterns.

Building Patterns: The Core Syntax

Character classes

Pattern	Matches
`\d`	Any digit `0–9`
`\w`	Any word character: letters, digits, `_`
`\s`	Any whitespace: space, tab, newline
`\D`	Any non-digit
`\W`	Any non-word character
`\S`	Any non-whitespace
`.`	Any character except newline

Quantifiers

Quantifier	Meaning
`*`	Zero or more
`+`	One or more
`?`	Zero or one (optional)
`{n}`	Exactly n times
`{n,m}`	Between n and m times

Anchors

Anchor	Meaning
`^`	Start of string
`$`	End of string
`\b`	Word boundary

Python

Ctrl+Enter to run

import re

tests = [
r#22c55e">"\d{4}", # Exactly 4 digits
r#22c55e">"\w+@\w+\.\w+", # Rough email pattern
r#22c55e">"^\d+", # Starts with digits
r#22c55e">"\d+$", # Ends with digits
]

strings = [
#22c55e">"Year 2024 was eventful",
#22c55e">"user@example.com",
#22c55e">"42 is the answer",
#22c55e">"the answer is 42",
]

for pattern in tests:
for s in strings:
m = re.search(pattern, s)
if m:
print(f#22c55e">"Pattern {pattern!r:25} matched {s!r} → {m.group()!r}")

`findall` — All Matches at Once

re.search finds the first match. re.findall returns every match as a list:

Python

Ctrl+Enter to run

import re

text = #22c55e">"Call us at 98765-43210 or 011-2345-6789 for support."

numbers = re.findall(r#22c55e">"\d+", text)
print(numbers)

sentence = #22c55e">"The cat sat on the mat near the flat."
at_words = re.findall(r#22c55e">"\b\w+at\b", sentence)
print(at_words)

\b is a word boundary — it matches the position between a word character and a non-word character. \b\w+at\b matches whole words ending in "at".

Groups — Extracting Parts of a Match

Parentheses in a pattern create groups — named portions of the match you can extract independently:

Python

Ctrl+Enter to run

import re

dates = [#22c55e">"Meeting on 25/12/2024", "Deadline: 01/03/2025", "Event: 15/08/2024"]

pattern = r#22c55e">"(\d{2})/(\d{2})/(\d{4})"

for text in dates:
    m = re.search(pattern, text)
if m:
    day, month, year = m.group(1), m.group(2), m.group(3)
print(f#22c55e">"Original: {m.group(0)} → Reformatted: {year}-{month}-{day}")

m.group(0) is the entire match. m.group(1), m.group(2), m.group(3) are the captured groups in order.

Named groups make patterns more readable:

Python

Ctrl+Enter to run

import re

pattern = r#22c55e">"(?P<day>\d{2})/(?P<month>\d{2})/(?P<year>\d{4})"
text = #22c55e">"The conference runs from 10/03/2025 to 14/03/2025."

for m in re.finditer(pattern, text):
    print(f#22c55e">"Day: {m.group('day')}, Month: {m.group('month')}, Year: {m.group('year')}")

(?P<name>...) defines a named group. re.finditer is like findall but returns match objects instead of strings — giving you access to groups and positions.

`re.sub` — Find and Replace by Pattern

Python

Ctrl+Enter to run

import re

text = #22c55e">"Order placed on 25/12/2024. Delivery by 02/01/2025."

# Reformat all dates from DD/MM/YYYY to YYYY-MM-DD

result = re.sub(
r#22c55e">"(\d{2})/(\d{2})/(\d{4})",
r#22c55e">"\3-\2-\1",
text
)
print(result)

re.sub(pattern, replacement, string) replaces every match. In the replacement string, \1, \2, \3 refer to captured groups — so \3-\2-\1 puts the year first, then month, then day.

With a function as the replacement:

Python

Ctrl+Enter to run

import re

def double_number(match):
return str(int(match.group()) * 2)

text = #22c55e">"I have 3 cats and 7 books and 12 pens."
result = re.sub(r#22c55e">"\d+", double_number, text)
print(result)

When the replacement is a function, re.sub calls it with each match object and uses the return value as the replacement. Every number in the string is doubled.

Compiling Patterns

If you use the same pattern many times, compile it first with re.compile(). This parses the pattern once and reuses the result:

Python

Ctrl+Enter to run

import re

email*pattern = re.compile(r#22c55e">"[a-zA-Z0-9.*%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}")

emails = [
#22c55e">"Contact us at support@example.com or sales@company.co.in",
#22c55e">"No email here",
#22c55e">"Reach me at firstname.lastname@university.edu",
]

for text in emails:
found = email_pattern.findall(text)
if found:
print(found)

A compiled pattern object has the same methods as re itself — .search(), .findall(), .sub() — but avoids re-parsing the pattern string on every call.

`re.split` — Splitting by Pattern

Python

Ctrl+Enter to run

import re

text = #22c55e">"one, two; three four|five"

# Split on any combination of commas, semicolons, spaces, pipes

parts = re.split(r#22c55e">"[,;\s|]+", text)
print(parts)

[,;\s|]+ is a character class matching any of: comma, semicolon, whitespace, pipe — one or more in a row. re.split handles messy, inconsistent delimiters that str.split can't manage.

A Note on Complexity

Regular expressions are powerful and terse — sometimes dangerously so. A pattern that took ten minutes to write can be indecipherable six months later. Two practices help:

First, use re.VERBOSE to write readable patterns with comments:

Python

Ctrl+Enter to run

import re

email = re.compile(r#22c55e">"""
[a-zA-Z0-9._%+-]+ # username
@ # at sign
[a-zA-Z0-9.-]+ # domain name
\. # dot
[a-zA-Z]{2,} # top-level domain
""", re.VERBOSE)

print(bool(email.match(#22c55e">"user@example.com")))
print(bool(email.match(#22c55e">"not-an-email")))

Second, always test your patterns on real examples — regex errors are silent mismatches, not crashes.

What You Have Learned

Regular expressions describe text patterns precisely — enabling tasks that are impossible or extremely fragile with plain string methods.

The key ideas:

re.search — finds the first match; re.findall — returns all matches
re.finditer — returns match objects for each match (access groups and positions)
re.sub — replaces by pattern; replacement can be a string with group references or a function
re.split — splits by pattern, handling complex or inconsistent delimiters
re.compile — parses a pattern once for repeated use
Always use raw strings r"..." for patterns
Core syntax: \d, \w, \s, ., +, *, ?, {n,m}, ^, $, \b
Groups (...) extract parts of a match; named groups (?P<name>...) add clarity
re.VERBOSE lets you write and comment patterns across multiple lines

In the next lesson, you'll learn about concurrency — how Python handles multiple tasks at once, and how asyncio enables efficient asynchronous programming.

Regular Expressions

Pattern Matching

Your First Pattern

Building Patterns: The Core Syntax

Character classes

Quantifiers

Anchors

findall — All Matches at Once

Groups — Extracting Parts of a Match

re.sub — Find and Replace by Pattern

Compiling Patterns

re.split — Splitting by Pattern

A Note on Complexity

What You Have Learned

`findall` — All Matches at Once

`re.sub` — Find and Replace by Pattern

`re.split` — Splitting by Pattern