Using Regular Expressions in Python: A Brief Guide

Regular expressions are effective tools for pattern matching and text processing. A regex, or regular expression, is a group of characters that forms a search pattern.

To determine whether a string contains a particular search pattern, use RegEx. They are supported by many programming languages, including Python, which provides a powerful and flexible regular expression engine that can handle a wide range of text-matching tasks. This article will provide a brief guide to using regular expressions in Python.

What Are Regular Expressions?

Regular Expressions (RegEx) are unique character combinations that use a search pattern to locate a string or group of strings, such as finding all email addresses in a document or validating the format of a phone number. It can distinguish between the presence and absence of a text by comparing it to a specific pattern. It may also divide a pattern into one or more sub-patterns. 

The use of regex in Python is supported via the re-module, which is provided by Python. Its main purpose is to provide a search; to do this, a regular expression and a string are required. In this case, it either returns the first match or none at all. Regular expressions are used to match patterns in text. Regular expressions are often used in text editors, command-line utilities, and programming languages.

Regular expressions consist of two types of characters:

1. Literals: These are characters that match themselves. For example, the letter "a" will match the letter "a" in a text string.
2. Metacharacters: These are special characters that have a special meaning. For example, the dot (.) metacharacter matches any single character.

Using Regular Expressions in Python

Python provides a built-in module called "re" that provides regular expression support. This module provides several functions for working with regular expressions, including searching for matches, replacing matches, and splitting a string into a list of substrings based on a pattern.

The "re" module also provides several special characters that can be used to create complex regular expressions. Here are some of the most commonly used special characters in regular expressions:

Let’s discuss some important of these metacharacters in detail:

. – Dot

Except for the newline character (\n), the dot (.) symbol only recognizes one character. For instance:

• a.b will look for any character other than a dot in the string, including acb, acbd, abbb, etc. 
• .. will determine whether the string has at least two characters.

* – Star

Star (*) symbol matches zero or more instances of the regex that comes before the star symbol. For instance:

• Because b is not followed by c, ab*c will be matched for the strings ac, abc, abbbc, dabc, etc., but not for abdc.

+ - Plus

One or more instances of the regex that comes before the + symbol are matched by the Plus (+) symbol. For instance :

• Because there is no b in ac and b is not followed by c in abdc, ab+c will match for the string abc, abbc, dabc but not for ac, abdc.

? - Question

The question mark (?) determines whether the string in the regex appears at least once or not at all. For instance:

• As there are two b’s in the string abbc, it will not be matched. However, ab?c will be matched for the strings ac, acb, and dabc. Because b is not followed by c, it will also not match for abdc.

Braces {m, n}

All repetitions from m to n, inclusive, before the regex are matched by the braces. Example- 

• The strings aaab, baaac, and gaad will be matched for regular expression a{2, 4}, but it won't be matched for strings like abc, bc because there is either just one an or none at all in both situations.

Square brackets [].

A character class made up of a group of characters that we want to match is represented by square brackets ([]). The character class [abc] will, for instance, match any single a, b, or c.

With the - symbol between the square brackets, we can also specify a range of characters. For instance:

• The sample for [0123] is [0,3].
• The sample for [abc] is [a-c].

The caret(^) sign can be used to reverse the character class as well. For instance:

• [^0-3] denotes any number other than 0 and 1 or 3.
• [^a-c]Any character that is not an a, b, or c.

\ Backslash

To ensure that the character is not given special treatment, use the backslash (/). This could be thought of as a metacharacter escape. As an illustration, the dot (.) will be treated as a special character and one of the metacharacters if you want to search for it in the string (as shown in the above table). In order to prevent it from losing its specialization, we will employ the backslash (/) before the dot (.) in this instance. The example below will help you understand.

Code:

import re

s = 'suman.singh'

# without using \

match = re.search(r'.', s)

print(match)



# using \

match = re.search(r'\.', s)

print(match)

Output:

<re.Match object; span=(0, 1), match='s'>

<re.Match object; span=(6, 7), match='.'>

| - Or Symbol 

Determines whether the pattern before or after the or symbol is present in the string. For instance:

• Any string that contains either an or b, such as acd, bcd, abcd, etc., will be matched by a|b.

Special Sequences

Special sequences provide the precise position in the search string where the match must take place rather than matching for the actual character in the string. It makes it simpler to write patterns that are used frequently.

Special Sequences List

import re


text = "Suman Raghav and Ron are friends"

pattern = "friends"

result = re.search(pattern, text)


if result:

    print("String Pattern Found")

else:

    print("String Pattern not Found")

import re


text = "Suman Raghav and Ron are friends"

pattern = "friends"

replacement = "students"

result = re.sub(pattern, replacement, text)


print(result)

import re


text = "Suman Raghav and Ron are friends"

result = re.split("\s", text)


print(result)

import re

text = "Suman has a brown coloured bag."

pattern = "BROWN"

result = re.search(pattern, text, re.IGNORECASE)


if result:

print("String Pattern Found")

else:

print("String Pattern not Found")

import re


text = "Suman Singh (sumansingh@example.com) wrote an email"

pattern = "(\w+@\w+\.\w+)"

result = re.search(pattern, text)


if result:

    print("Email address validated: " + result.group(1))

else:

    print("Email address not validated")