Regular expressions (with Examples) for Python

A regular expression is a pattern you write to find things in a string. It is one line of code for something that takes a loop to do by hand.

In Python they live in the re module. The tricky part is not the syntax, it is writing a pattern that matches what you meant and not more than that.

Use them to check whether a string has the shape you expect, an email address or a phone number, and to pull parts out of it.

When working with strings in Python, we often need to test if a string contains a particular substring. Consider this example:

 
>>> s = "Are you afraid of ghosts?"
>>> "ghosts" in s
True

The inverse, testing if a string does not contain a substring, is just as straightforward:

>>> "coffee" not in s
True

But what if you want to match patterns, such as phone numbers, email addresses, or URLs? That’s where regular expressions come into play.

Core Methods in the re Module

The re module in Python is dedicated to working with regular expressions. Here are some of its central functions:

• match(): Determines if the regex pattern matches at the beginning of the string.
• search(): Scours the string and returns a location if there’s a match anywhere in it.
• findall(): Finds all the substrings matching the regex and returns them as a list.
• finditer(): Like findall(), but returns the matches as an iterator.

Let’s explore these methods with examples.

Using re.match

The match() method checks if the provided pattern matches at the beginning of the string. Here’s a simple example:

>>> import re
>>> txt = "Carl is a cat, he is smart, clever, and more.."
>>> m = re.match(r"(\w+)\s", txt)
>>> if m:
...     print(m.group(0))
... else:
...     print('No match found')

The first parameter is the regex pattern, and the second is the string you’re checking. If the pattern matches, the function returns a match object; otherwise, it returns None.

Here’s another example demonstrating how the start of a string is matched using a different pattern:

>>> txt = "The number 123456 is my phone number"
>>> result = re.match(r'^The number \d+\s*',txt)
>>> print(result.group(0))

Employing re.search

The search() function is similar to match(), but it looks throughout the entire string for a match:

>>> txt = "Sombrero in Spain for fun"
>>> obj = re.search('Spain',txt)
>>> print(obj.group(0))

The difference between match() and search() is primarily their scope of search within the string.

The group method

The group() function allows you to fetch specific portions of the matched string:

>>> import re
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> print(m.group(0), m.group(1), m.group(2))

The groups() function, on the other hand, returns a tuple of all the subgroups.

>>> m.groups()

Harnessing re.findall

If you want to retrieve all matches of a pattern within a string, findall() is the go-to method:

>>> txt = "Carl is a cool cat from a good family and has a happy mood"
>>> matches = re.findall(r'\w*oo\w*',txt)
>>> print(matches)

Using re.finditer

The finditer() method is similar to findall(), but instead of returning a list, it yields match objects:

>>> txt = "Blue blue sky"
>>> pattern = "blue sky"
>>> for match in re.finditer(pattern,txt):
...     s = match.start()
...     e = match.end()
...     print(f'String match {pattern} at {s}:{e}')

Regular Expression Syntax Guide

Regular expressions have their own unique syntax. Here’s a concise guide to some of the fundamental regex symbols:

Understanding and mastering regular expressions can significantly enhance your text processing skills, especially in data extraction, validation, and transformation tasks.

The fastest way to learn this is to write it yourself. The PyChallenge exercises run in your browser, no install needed.