What Are Regular Expressions?

At its essence, a regular expression consists of a sequence of characters that delineates a search pattern. It's a specialized mini-language designed to specify text patterns you wish to identify within strings. Whether you need to validate user inputs, extract specific information from a document, or sift through log files, regular expressions provide a compact and adaptable solution.

Simple Pattern Matching with re.match

To kick things off, let's examine a basic example using the re.match function. Imagine you want to verify if a string begins with the word "Hello."

import re

pattern = r"Hello"

text1 = "Hello, World!"

text2 = "Hi there, Hello!"

if re.match(pattern, text1):

print(f"{text1} starts with 'Hello'.")

else:

print(f"{text1} does not start with 'Hello'.")

if re.match(pattern, text2):

print(f"{text2} starts with 'Hello'.")

else:

print(f"{text2} does not start with 'Hello'.")

In this snippet, r"Hello" represents a raw string that captures the regex pattern. The re.match function checks if the pattern matches the start of the provided text. Here, text1 meets the first condition, while text2 does not.

Extracting Patterns with re.search

Next, we will explore the re.search function to locate the first instance of a pattern within a string. For instance, if you wish to extract the first three-digit number from a given text.

text = "The price is $123.45 and the discount is $50.25."

pattern = r"d{3}"

match = re.search(pattern, text)

if match:

print(f"Found a three-digit number: {match.group()}")

else:

print("No three-digit number found.")

In this scenario, the regex pattern r"d{3}" looks for three consecutive digits. The re.search function returns a match object, and if a match exists, we display the result using match.group().

Matching Multiple Occurrences with re.findall

For cases where you need to identify all instances of a pattern in a string, the re.findall function is quite useful. Consider the task of extracting all email addresses from a provided text.

text = "Contact us at [email protected] or [email protected] for assistance."

pattern = r"b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Z|a-z]{2,}b"

email_addresses = re.findall(pattern, text)

if email_addresses:

print(f"Found email addresses: {', '.join(email_addresses)}")

else:

print("No email addresses found.")

In this example, the regex r"b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Z|a-z]{2,}b" is designed to match typical email address formats. The re.findall function returns a list of all matches discovered in the input text.

Tokenizing Text with re.split

Regular expressions can also facilitate the tokenization of text, breaking it into segments based on defined patterns. For instance, if you want to split a sentence into its constituent words.

sentence = "Regular expressions are a powerful tool for text processing."

words = re.split(r"s", sentence)

print(f"Words in the sentence: {', '.join(words)}")

Here, the regex pattern r"s" matches whitespace characters, allowing re.split to divide the sentence into a list of words.

Replacing Patterns with re.sub

If your goal is to replace occurrences of a specific pattern with another string, the re.sub function is your best option. For example, if you wish to censor a particular word in a sentence.

sentence = "Regular expressions make text processing easy."

censored_word = "expressions"

censored_sentence = re.sub(censored_word, "[CENSORED]", sentence)

print(f"Censored Sentence: {censored_sentence}")

In this case, re.sub replaces every instance of the word "expressions" with "[CENSORED]".

Case-Insensitive Matching

Python's regex capabilities also offer the flexibility of case-insensitive matching. Let's modify our earlier example to enable this feature.

pattern = r"hello"

text = "Hello, World!"

if re.match(pattern, text, re.IGNORECASE):

print(f"{text} starts with 'hello' (case-insensitive).")

else:

print(f"{text} does not start with 'hello' (case-insensitive).")

By applying the re.IGNORECASE flag, the regex becomes case-insensitive, allowing it to match regardless of letter casing.

Using Groups for Complex Patterns

Regular expressions support grouping, which can be useful for capturing specific portions of a pattern. For example, consider a scenario where you want to extract phone numbers formatted in various ways.

text = "Contact us at +1 (123) 456-7890 or 555.555.5555 for assistance."

pattern = r"(+d{1,2}s?)?((d{3})s?|d{3}[.-]?)d{3}[.-]?d{4}"

matches = re.findall(pattern, text)

formatted_numbers = ["".join(match) for match in matches]

print(f"Phone Numbers: {', '.join(formatted_numbers)}")

In this case, the regex utilizes groups to capture different components of the phone number. The re.findall function yields a list of tuples, and we can use a list comprehension to format the phone numbers for presentation.