Python Regular Expressions

Learning Objectives

By the end of this lesson, you will understand how regular expressions work and how to use Python's re module for practical text-processing tasks.

What Is a Regular Expression?

A regular expression, commonly called regex or regexp, is a pattern used to search and manipulate text.

Instead of looking for one exact string, you can describe a pattern that many strings can match.

For example, suppose you want to find every number in a piece of text.

text = "Order 125 contains 3 products and costs $450"

A regular expression can identify the numbers without knowing their exact values beforehand.

\d+

125
3
450

Why Regular Expressions Matter

Regular expressions are particularly useful when working with large amounts of text.

Regex is especially valuable in data cleaning, automation, web scraping, log analysis, and text processing.

Python's re Module

Python provides regular expression functionality through the built-in re module.

import re

You do not need to install a separate package to use the standard regular expression features.

Some of the most important functions are:

• re.search()
• re.match()
• re.fullmatch()
• re.findall()
• re.finditer()
• re.split()
• re.sub()

Searching with re.search()

re.search() scans the string and returns the first location where the pattern matches.

import re


text = "Python is powerful"


result = re.search("Python", text)


if result:
    print("Found!")
else:
    print("Not found")

Found!

If no match exists, re.search() returns None.

result = re.search("Java", text)

print(result)

None

re.match()

re.match() checks whether the pattern matches at the beginning of the string.

import re


text = "Python programming"


result = re.match("Python", text)


if result:
    print("Matched at the beginning")

But:

result = re.match("programming", text)

print(result)

None

re.fullmatch()

re.fullmatch() requires the entire string to match the pattern.

import re


result = re.fullmatch(r"\d+", "12345")


if result:
    print("Valid number")

Valid number

But:

result = re.fullmatch(r"\d+", "12345abc")

print(result)

None

This makes fullmatch() useful when you want strict validation.

Basic Regular Expression Patterns

Regular expressions use special symbols to describe patterns.

import re


text = "Room 25"


print(re.findall(r"\d", text))
print(re.findall(r"\d+", text))
print(re.findall(r"\w+", text))

['2', '5']
['25']
['Room', '25']

Character Classes

Character classes let you define which characters can appear at a particular position.

Square brackets

[abc]

This matches one character that is either a, b, or c.

Ranges

[a-z]
[A-Z]
[0-9]

These represent lowercase letters, uppercase letters, and digits respectively.

Negated character class

[^0-9]

The caret inside the brackets means "anything except" the listed characters.

Quantifiers

Quantifiers specify how many times a pattern should occur.

import re


text = "Python 123"


print(re.findall(r"\d+", text))

['123']

The + combines consecutive digits into one match.

Anchors

Anchors describe positions in a string rather than actual characters.

import re


text = "Python"


print(bool(re.search(r"^Python", text)))
print(bool(re.search(r"Python$", text)))

True
True

Capturing Groups

Parentheses create groups that allow you to capture specific parts of a match.

import re


text = "Name: Ali, Age: 25"


pattern = r"Name: (\w+), Age: (\d+)"

result = re.search(pattern, text)


if result:

    print(result.group(1))
    print(result.group(2))

Ali
25

You can also access the complete match using:

result.group(0)

Groups are extremely useful when extracting structured information from text.

re.findall()

re.findall() returns all non-overlapping matches as a list.

import re


text = "Python 101, Java 202, SQL 303"


numbers = re.findall(r"\d+", text)

print(numbers)

['101', '202', '303']

This is one of the most commonly used regex functions for extracting information.

re.finditer()

re.finditer() returns match objects one at a time.

import re


text = "Order 125 costs 450"


for match in re.finditer(r"\d+", text):

    print(match.group())
    print(match.start())
    print(match.end())

125
6
9
450
16
19

This is useful when you need additional information about each match, such as its position.

re.split()

re.split() splits a string wherever the regular expression matches.

import re


text = "apple,banana;orange|mango"


items = re.split(r"[,;|]", text)

print(items)

['apple', 'banana', 'orange', 'mango']

This is particularly useful when input data uses inconsistent separators.

re.sub()

re.sub() replaces text matching a pattern.

import re


text = "Python is amazing"


cleaned = re.sub(r"amazing", "powerful", text)

print(cleaned)

Python is powerful

You can use regex patterns to perform more advanced replacements.

import re


text = "Phone: 0300-1234567"


masked = re.sub(r"\d", "*", text)

print(masked)

Phone: ****-*******

Regex Flags

Flags modify how Python interprets a regular expression.

re.IGNORECASE

import re


text = "Python PYTHON python"


matches = re.findall(
    r"python",
    text,
    re.IGNORECASE
)

print(matches)

['Python', 'PYTHON', 'python']

re.MULTILINE

re.MULTILINE changes how ^ and $ behave when working with multiple lines.

re.DOTALL

re.DOTALL allows the dot . to match newline characters as well.

Escaping Special Characters

Some characters have special meanings in regular expressions.

If you want to match the literal character, you may need to escape it.

For example, a period normally means "any character".

.

To match an actual period:

\.

Other commonly escaped characters include:

\+
\*
\?
\(
\)
\[
\]
\{ 
\}

Raw Strings

Regex patterns often contain backslashes, so Python programmers commonly use raw strings.

pattern = r"\d+"

instead of:

pattern = "\\d+"

The r prefix tells Python to treat the string as a raw string, making regex patterns easier to read and write.

Real-World Regex Examples

Extracting Email Addresses

import re


text = """
Contact ali@example.com
or sara@example.org
"""


emails = re.findall(
    r"[\w.-]+@[\w.-]+\.\w+",
    text
)

print(emails)

['ali@example.com', 'sara@example.org']

Extracting Phone Numbers

import re


text = "Call 0300-1234567 or 0312-7654321"


phones = re.findall(
    r"\d{4}-\d{7}",
    text
)

print(phones)

['0300-1234567', '0312-7654321']

Extracting Prices

import re


text = "Laptop $1200, Phone $800, Mouse $25"


prices = re.findall(
    r"\$\d+",
    text
)

print(prices)

['$1200', '$800', '$25']

Finding Dates

import re


text = "Meeting dates: 12-08-2026 and 25-09-2026"


dates = re.findall(
    r"\d{2}-\d{2}-\d{4}",
    text
)

print(dates)

['12-08-2026', '25-09-2026']

Common Regex Mistakes

Mistake 1 — Confusing search() and match()

search() can find a match anywhere, while match() starts from the beginning.

Mistake 2 — Forgetting raw strings

Backslashes can become confusing when ordinary Python strings are used for complex regex patterns.

Mistake 3 — Using overly broad patterns

A pattern such as .* can match far more than intended.

Mistake 4 — Assuming regex is always the best solution

Simple string methods such as startswith(), endswith(), split(), and replace() may be clearer for simple tasks.

Practice Exercises

Mini Challenge — Smart Contact Extractor

Build a small text-analysis program that extracts useful contact information from a business description.

import re


text = """
Contact our sales team:

Email: sales@example.com
Support: support@example.com

Phone: 0300-1234567
Alternative: 0312-7654321

Website: https://www.example.com
"""


emails = re.findall(
    r"[\w.-]+@[\w.-]+\.\w+",
    text
)

phones = re.findall(
    r"\d{4}-\d{7}",
    text
)

urls = re.findall(
    r"https?://[^\s]+",
    text
)


print("Emails:", emails)
print("Phones:", phones)
print("URLs:", urls)

Emails: ['sales@example.com', 'support@example.com']

Phones: ['0300-1234567', '0312-7654321']

URLs: ['https://www.example.com']

This challenge combines regex searching, extraction, replacement, functions, and structured data into a practical text-processing application.

Knowledge Check

Test your understanding of Python regular expressions.

Lesson Summary

Regular expressions provide a powerful way to search, extract, validate, split, and replace structured text.

You now have a powerful tool for text processing and data extraction. In the next lesson, we move into Type Hints, where you will learn how to make Python code clearer, easier to maintain, and easier for development tools to understand.