Python - Regular Expressions

Regular Expressions are one of the important concepts used for pattern matching in strings.

Suppose we want to represent a group of strings that follow a particular format.

Examples:

• Mobile numbers
• Email IDs
• Identifiers
• Vehicle registration numbers

Instead of checking every possible string manually, we can define a pattern using a Regular Expression.

String Data
    │
    ▼
Regular Expression Pattern
    │
    ▼
Pattern Matching
    │
    ▼
Matched / Not Matched
        

If we want to represent a group of Strings according to a particular format or pattern, then we should go for Regular Expressions.

A Regular Expression is a declarative mechanism used to represent a group of Strings according to a particular format or pattern.

Regular Expression
        =
Pattern used to represent
a group of Strings
        

For example, if we want to represent all valid mobile numbers, we can create one Regular Expression describing the required mobile-number format.

Consider the following values:

9898989898
8989898989
7897897897
        

These strings have a common format:

• They contain digits.
• They contain a fixed number of digits.
• They can be represented using a common pattern.

A Regular Expression allows us to describe such a pattern instead of checking each value individually.

Many Strings
     │
     │
     ▼
Common Format / Pattern
     │
     ▼
Regular Expression
        

In real applications, we frequently need to check whether some text follows a required format.

For example:

• Is the entered mobile number valid?
• Is the entered email ID valid?
• Does the text contain a particular pattern?
• Does a string start or end with a particular value?
• Does a file contain mobile numbers?

Regular Expressions provide a convenient mechanism for performing these kinds of pattern-based operations.

Input String
     │
     ▼
Apply Regular Expression
     │
     ▼
Does Pattern Match?
     │
 ┌───┴───┐
 ▼       ▼
Yes      No
        

Two basic examples help us understand where Regular Expressions can be used.

Example 1 — Mobile Numbers

We can write a Regular Expression to represent all mobile numbers.

Mobile Numbers
      │
      ▼
Required Format
      │
      ▼
Regular Expression
        

Instead of writing separate validation logic for every possible mobile number, we can define a pattern that represents valid mobile numbers.

Example 2 — Mail IDs

We can write a Regular Expression to represent all mail IDs.

Mail IDs
    │
    ▼
Required Email Format
    │
    ▼
Regular Expression
        

The Regular Expression describes the required structure of the mail ID.

The basic concept can be understood using the following flow:

Requirement
    │
    ▼
Identify Format
    │
    ▼
Create Pattern
    │
    ▼
Regular Expression
    │
    ▼
Apply Pattern to Strings
    │
    ▼
Find / Validate / Extract Data
        

Therefore, Regular Expressions are not limited only to validation. They can also be used for searching and extracting required patterns from text.

The main application areas of Regular Expressions are:

1. To develop validation frameworks / validation logic
2. To develop Pattern Matching Applications
3. To develop Translators like Compilers and Interpreters
4. To develop Digital Circuits
5. To develop Communication Protocols like TCP/IP and UDP

Application	Examples / Purpose
Validation	Develop validation frameworks and validation logic
Pattern Matching	Ctrl + F in Windows, grep in UNIX
Translators	Compilers and Interpreters
Digital Circuits	Development of Digital Circuits
Communication Protocols	TCP/IP and UDP

Validation means checking whether the given data follows the required format, for example mobile number validation, email ID validation, identifier validation, and vehicle registration number validation.

Pattern matching means searching for required text or patterns inside larger text. Regular Expressions help represent and recognize patterns in source code when building compilers and interpreters.

Python provides the re module for developing Regular Expression based applications.

We can import the module using:

import re
        

The re module is Python's module for working with Regular Expressions.

Python Program
     │
     ▼
 import re
     │
     ▼
Regular Expression Operations
        

The statement import re imports Python's Regular Expression module.

The re module contains several built-in functions that make it easy to use Regular Expressions in Python applications.

After importing the module, we can perform operations such as:

• Compiling patterns
• Searching patterns
• Finding matches
• Replacing matched text
• Splitting strings based on patterns

These operations are explained in detail in the upcoming parts of the tutorial.

The general idea of working with Regular Expressions in Python is:

Start
  │
  ▼
Import re Module
  │
  ▼
Define Regular Expression Pattern
  │
  ▼
Provide Target String
  │
  ▼
Apply re Module Function
  │
  ▼
Search / Match Pattern
  │
  ▼
Process Result
        

The exact function used depends on what operation we want to perform.

Term	Meaning
Regular Expression	A pattern used to represent a group of Strings
Pattern	The format we want to search or match
Target String	The string on which the Regular Expression is applied
Match	A portion of the target string that satisfies the pattern
re	Python module used for Regular Expressions

                 Regular Expressions
                         │
                         ▼
          Represent Strings by Pattern
                         │
          ┌──────────────┼──────────────┐
          │              │              │
          ▼              ▼              ▼
      Validation      Searching      Matching
          │
          ▼
     Applications
          │
          ├── Validation Frameworks
          ├── Pattern Matching
          ├── Compilers
          ├── Interpreters
          ├── Digital Circuits
          └── Communication Protocols
                         │
                         ▼
                  Python Support
                         │
                         ▼
                    re Module
                         │
                         ▼
                    import re
        

The next important concept is compiling a Regular Expression pattern using the compile() function.