Python Language - Regular Expressions (re module)

Regular Expressions in Python (re module)

Regular expressions, often referred to as regex or regexp, are a powerful tool for pattern matching and text manipulation. In Python, the re module provides support for working with regular expressions. In this guide, we’ll explore the basics of regular expressions in Python and how to use the re module effectively.

What are Regular Expressions?

A regular expression is a sequence of characters that defines a search pattern. These patterns can be used to search, match, and manipulate strings. Regular expressions are commonly used in tasks like data validation, text parsing, and searching and replacing text.

Using the re Module

Python’s re module provides functions for working with regular expressions. To use it, you first need to import the module:


import re

Matching Patterns

You can use the re.match() function to check if a string starts with a specific pattern:


pattern = r'^Hello'
text = 'Hello, World!'
match = re.match(pattern, text)
if match:
    print('Match found')

The r before the pattern string denotes a raw string, which is often used with regular expressions to avoid unintended escapes.

Searching for Patterns

The re.search() function searches for a pattern anywhere in the string:


pattern = r'World'
text = 'Hello, World!'
match = re.search(pattern, text)
if match:
    print('Match found')

Pattern Compilation

Compiling a regular expression pattern can improve performance, especially when you need to use the same pattern multiple times. You can use the re.compile() function:


pattern = re.compile(r'Python')
text = 'Python is a powerful language. Python rocks!'
match = pattern.search(text)
if match:
    print('Match found')

Pattern Matching

The re.findall() function returns all non-overlapping matches in a string as a list:


pattern = r'\d+'  # Matches one or more digits
text = 'There are 42 apples and 123 oranges.'
matches = re.findall(pattern, text)
print(matches)

Replacing Text

You can use the re.sub() function to replace text based on a pattern:


pattern = r'apple'
replacement = 'banana'
text = 'I have an apple.'
new_text = re.sub(pattern, replacement, text)
print(new_text)

Common Regular Expression Patterns

Here are some common patterns used in regular expressions:

1. Matching Digits:


pattern = r'\d+'  # Matches one or more digits

2. Matching Words:


pattern = r'\b\w+\b'  # Matches whole words

3. Matching Email Addresses:


pattern = r'\b[\w.-]+@[\w.-]+\.\w+\b'  # Matches email addresses

4. Matching URLs:


pattern = r'https?://\S+'  # Matches URLs

Using Regular Expressions for Validation

Regular expressions are commonly used for input validation. For example, you can use them to validate email addresses, phone numbers, or URLs. Here’s a simple email validation example:


import re

def is_valid_email(email):
    pattern = r'\b[\w.-]+@[\w.-]+\.\w+\b'
    return bool(re.match(pattern, email))

Conclusion

Regular expressions are a versatile tool for working with text data in Python. They allow you to search, match, and manipulate strings based on complex patterns. By using the re module and understanding regular expression syntax, you can perform a wide range of text processing tasks efficiently.

Python Language – Regular Expressions (re module)