Mastering Regular Expressions in Python

Introduction

Regular expressions are powerful tools used for pattern matching and manipulation of strings. They provide a concise and flexible way to search, extract, and replace specific patterns of text. Python, being a versatile programming language, offers a built-in module called “re” that provides support for regular expressions. In this article, we will explore the basics of regular expressions in Python and understand how to use them effectively.

Why do we use Regular Expressions?

Regular expressions are used in various scenarios where pattern matching and manipulation of text data are required. Here are a few real-life examples that highlight the significance of regular expressions:

1. Data Validation:

Regular expressions are commonly used for data validation tasks. For instance, when designing a form that collects email addresses, you can utilize a regular expression pattern to ensure that the input follows the correct email format. This helps in validating user input and preventing incorrect or malicious data from being entered into the system.

2. Text Search and Extraction:

Regular expressions are invaluable when it comes to searching and extracting specific patterns or information from a large body of text. For example, imagine you have a log file containing thousands of lines, and you need to extract all the IP addresses mentioned in the file. By utilizing regular expressions, you can define a pattern that matches IP addresses and easily extract the required information.

3. Data Cleaning and Transformation:

Regular expressions are widely used in data cleaning and transformation tasks. Consider a scenario where you have a dataset with inconsistent formatting of phone numbers. By using regular expressions, you can identify and standardize the phone numbers to a specific format, ensuring consistency and improving data quality.

4. Web Scraping:

Regular expressions play a crucial role in web scraping, which involves extracting data from websites. When scraping web pages, you often encounter HTML or text patterns that you need to parse and extract information from. Regular expressions enable you to define patterns that match the specific data you’re interested in, making web scraping more efficient and accurate.

5. String Manipulation and Replacement:

Regular expressions are helpful in performing string manipulation and replacement tasks. For instance, if you have a large text document and want to replace all occurrences of a specific word or phrase, regular expressions provide a powerful and efficient way to achieve this. You can define a pattern that matches the word or phrase, and then use the `re.sub()` function in Python to replace it with the desired text.

6. Lexical Analysis and Parsing:

Regular expressions are extensively used in lexical analysis and parsing tasks, especially in the field of programming language compilers. Regular expressions help in tokenizing the source code into meaningful elements such as keywords, identifiers, operators, and literals. This process is crucial for building syntax analyzers and compilers.

Getting Started with Regular Expressions

Before diving into the details of regular expressions, it’s important to understand the basic syntax and concepts involved.

1. Importing the re Module:

To use regular expressions in Python, we need to import the “re” module. This module provides various functions and methods to work with regular expressions.

import re

2. Basic Patterns:

Regular expressions are made up of characters and special symbols that form a pattern. For example, the pattern “cat” matches the word “cat” in a string. Regular expressions support a wide range of patterns such as letters, digits, special characters, and more.

3. Raw Strings:

When working with regular expressions, it is common to use raw strings by prefixing them with the letter ‘r’. Raw strings treat backslashes () as literal characters, which is useful when working with regular expressions that contain backslashes.

pattern = r'd+'  # Raw string

Common Functions for Regular Expressions

The “re” module in Python provides several functions and methods to work with regular expressions. Let’s explore some of the commonly used ones:

1. re.match():

The `re.match()` function checks if the pattern matches at the beginning of the string. It returns a match object if a match is found; otherwise, it returns None.

import re

pattern = r'apple'
string = "apple is a fruit"

match = re.match(pattern, string)
if match:
    print("Match found!")
else:
    print("Match not found!")

2. re.search():

The `re.search()` function scans the entire string and returns the first occurrence of the pattern. It returns a match object if a match is found; otherwise, it returns None.

import re

pattern = r'apple'
string = "banana is not an apple"

match = re.search(pattern, string)
if match:
    print("Match found!")
else:
    print("Match not found!")

3. re.findall():

The `re.findall()` function returns all non-overlapping occurrences of the pattern in the string as a list.

import re

pattern = r'apple'
string = "apple is a fruit, and apple is delicious"

matches = re.findall(pattern, string)
print(matches)  # Output: ['apple', 'apple']

4. re.sub():

The `re.sub()` function replaces all occurrences of the pattern in the string with a specified replacement string.

import re

pattern = r'apple'
string = "apple is a fruit, and apple is delicious"

new_string = re.sub(pattern, 'orange', string)
print(new_string)  

# Output: orange is a fruit, and orange is delicious

Different Characters in Regular Expressions

Regular expressions are powerful tools for pattern matching and manipulation of strings in Python. They involve the use of special characters to define patterns and perform various operations. Here are some commonly used characters in regular expressions in Python, along with examples:

Parentheses `()`

Parentheses in regular expressions serve multiple purposes and provide useful functionalities. Here are some common use cases.

1. Grouping: Parentheses are used to group parts of a pattern together. This is helpful when you want to apply a quantifier or an operator to a specific part of the pattern.

import re

pattern = "(abc)+"
text = "abcabcabc"

match = re.search(pattern, text)
print(match.group())  # Output: "abcabcabc"

In the example above, the parentheses group the pattern “abc” together, and the plus quantifier applies to the entire group, matching one or more occurrences of “abc”.

2. Capturing Groups: Parentheses are used to create capturing groups, which allow you to extract specific parts of a matched pattern.

import re

pattern = "(d+)-(d+)-(d+)"
text = "Date: 2023-06-13"

match = re.search(pattern, text)
print(match.group())  # Output: "2023-06-13"
print(match.group(1))  # Output: "2023"
print(match.group(2))  # Output: "06"
print(match.group(3))  # Output: "13"

In this example, the pattern captures three groups of digits separated by hyphens. The captured groups can be accessed using the `group()` method, with 0 representing the entire match and higher numbers representing the specific capturing groups.

3. Non-Capturing Groups: If you want to group a part of the pattern without capturing it, you can use non-capturing groups. Non-capturing groups are denoted by `(?:)`.

import re

pattern = "(?:https?://)?(www.)?example.com"
texts = ["https://www.example.com", "http://example.com", "example.com"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group(1))  # Output: "www." or None

In this example, the non-capturing group `(?:https?://)?` is used to match an optional “http://” or “https://” part of the URL, without capturing it as a separate group.

Curly Brackets `{}`

In regular expressions, the curly brackets ({}) are used to specify the repetition or quantification of a preceding pattern. Here are the main usages of curly brackets.

1. Fixed Repetition: You can use curly brackets to specify a fixed number of repetitions of a preceding pattern.

import re

pattern = "a{3}"
texts = ["aaa", "aa", "aaaa"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `a{3}` matches the letter “a” exactly three times. It will match the first and last texts (“aaa” and “aaaa”), but not the second text (“aa”).

2. Range of Repetition: Curly brackets can also define a range of repetition for a preceding pattern.

import re

pattern = "a{2,4}"
texts = ["aaa", "aa", "aaaa"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `a{2,4}` matches the letter “a” repeated between 2 and 4 times (inclusive). It will match the first and third texts (“aaa” and “aaaa”), but not the second text (“aa”).

3. Minimum Repetition: Curly brackets can specify the minimum number of repetitions for a preceding pattern.

import re

pattern = "a{2,}"
texts = ["aaa", "aa", "aaaa"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `a{2,}` matches the letter “a” repeated at least two times. It will match the first and third texts (“aaa” and “aaaa”), but not the second text (“aa”).

4. Exact Repetition: You can also use curly brackets to specify an exact number of repetitions of a preceding pattern.

import re

pattern = "a{3}"
texts = ["aaa", "aa", "aaaa"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `a{3}` matches the letter “a” exactly three times. It will match the first text (“aaa”), but not the second or third texts (“aa” and “aaaa”).

Escape Character (/)

In regular expressions, the backslash (/) is used as an escape character to indicate that the character immediately following it should be treated as a literal character rather than a special character with its regular expression meaning. Here are some common use cases for the escape character:

1. Escaping Special Characters: The escape character is used to escape special characters so that they are treated as literal characters.

import re

pattern = "apple."
text = "I love apples."

match = re.search(pattern, text)
print(match.group())  # Output: "apple."

In this example, the dot (.) is a special character in regular expressions, but by preceding it with a backslash, it is treated as a literal dot character.

2. Escaping Metacharacters: The escape character is used to escape metacharacters that have special meanings in regular expressions. For example, escaping the plus sign (+) removes its special meaning of “one or more occurrences”.

import re

pattern = "1+1=2"
text = "The equation 1+1=2 is true."

match = re.search(pattern, text)
print(match.group())  # Output: "1+1=2"

In this example, the plus sign is escaped to match the literal plus sign in the text.

3. Escaping Digit Shorthands: The escape character is used to escape digit shorthands such as d, which matches any digit.

import re

pattern = "d+"
text = "The number is 12345."

match = re.search(pattern, text)
print(match.group())  # Output: "12345"

In this example, the backslash is used to escape the “d” shorthand, treating it as a literal “d” character to match digits.

4. Escaping Anchors: The escape character is used to escape anchor characters like `^` and `$`, which have special meanings in regular expressions.

import re

pattern = "$10"
text = "The price is $10."

match = re.search(pattern, text)
print(match.group())  # Output: "$10"

In this example, the dollar sign is escaped to match the literal dollar sign in the text.

5. Escaping Whitespace Characters: The escape character is used to escape whitespace characters such as space, tab, and newline. 

import re

pattern = "HellosWorld"
text = "HellotWorld"

match = re.search(pattern, text)
print(match.group())  # Output: "HellotWorld"

In this example, the backslash is used to escape the “s” shorthand for whitespace, matching the literal tab character in the text.

Pipe Character (|)

In regular expressions, the pipe character (|) is used as the alternation operator. It allows you to specify multiple options and matches any of the given options. Here are some common use cases.

1. Matching Multiple Options: The pipe character is used to match any of the specified options.

import re

pattern = "apple|banana"
texts = ["I love apples", 
"I love bananas", "I love oranges"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern will match either “apple” or “banana”. If any of the options match, it returns the first successful match.

2. Matching Multiple Words: The pipe character can be used to match multiple words by enclosing the options in parentheses.

import re

pattern = "(apple|banana) juice"
texts = ["I like apple juice", 
"I like banana juice", "I like orange juice"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern will match either “apple juice” or “banana juice” when it appears in the text.

3. Case-Insensitive Matching: The pipe character can be used to perform case-insensitive matching by combining options with different letter cases.

import re

pattern = "apple|banana"
texts = ["I love apples", 
"I love BANANA", "I love Oranges"]

for text in texts:
    match = re.search(pattern, text, re.IGNORECASE)
    if match:
        print(match.group())

By using the `re.IGNORECASE` flag, the pattern will match “apple” or “banana” regardless of the letter case.

4. Alternation within Capturing Groups: The pipe character can be used within capturing groups to create subpatterns with multiple options.

import re

pattern = "(apple|banana) (juice|smoothie)"
texts = ["I like apple juice", 
"I love banana smoothie", "I like orange juice"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group(1))
        print(match.group(2))

In this example, the pattern matches “apple” or “banana” followed by “juice” or “smoothie”. The capturing groups `(apple|banana)` and `(juice|smoothie)` allow you to extract the specific options separately.

Question Mark (?)

The question mark (?) is used as a quantifier and it indicates that the preceding element is optional. Here are some common use cases for the question mark in regular expressions in Python:

1. Zero or One Occurrence: The question mark matches zero or one occurrence of the preceding element.

import re

pattern = "colou?r"
texts = ["color", "colour", "favourite colour"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern will match either “color” or “colour”. The question mark makes the “u” character optional.

2. Non-Greedy Matching: The question mark can be used to perform non-greedy or minimal matching.

import re

pattern = "<.*?>"
text = "<h1>Hello</h1><p>Paragraph</p>"

matches = re.findall(pattern, text)
print(matches)

In this example, the pattern `<.*?>` matches the smallest possible string between angle brackets. Without the question mark, it would match the largest possible string between the first and last angle brackets.

3. Lazy Quantifiers: The question mark can be used with other quantifiers to make them lazy rather than greedy.

import re

pattern = "a.+?b"
text = "aababb"

matches = re.findall(pattern, text)
print(matches)

In this example, the pattern `a.+?b` matches the smallest possible substring that starts with “a” and ends with “b”. Without the question mark, it would match the largest possible substring.

4. Escaping the Question Mark: If you want to match a literal question mark, you need to escape it with a backslash.

import re

pattern = "What?"
text = "What?"

match = re.search(pattern, text)
if match:
    print(match.group())

In this example, the pattern `What?` matches the literal string “What?” by escaping the question mark.

Star Character (*)

The star (*) is a quantifier that matches zero or more occurrences of the preceding element. Here are some common use cases.

1. Zero or More Occurrences: The star matches zero or more occurrences of the preceding element.

import re

pattern = "go*d"
texts = ["gd", "god", "good", "goooood"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern will match “gd”, “god”, “good”, and “goooood”. The star allows for any number of “o” characters (including zero) between “g” and “d”.

2. Lazy Quantifiers: The star can be used with other quantifiers to make them lazy rather than greedy.

import re

pattern = "<.*?>"
text = "<h>>Hello</h1><p>Paragraph</p>"

matches = re.findall(pattern, text)
print(matches)

In this example, the pattern `<.*?>` matches the smallest possible string between angle brackets. Without the question mark, it would match the largest possible string between the first and last angle brackets.

3. Pattern Repeating: The star can be used to repeat a pattern multiple times.

import re

pattern = "ab*c"
texts = ["ac", "abc", "abbc", "abbbbc"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern will match “ac”, “abc”, “abbc”, and “abbbbc”. The star allows for any number of “b” characters (including zero) between “a” and “c”.

4. Escaping the Star: If you want to match a literal star character, you need to escape it with a backslash.

import re

pattern = "Hello*"
text = "Hello*"

match = re.search(pattern, text)
if match:
    print(match.group())

In this example, the pattern `Hello*` matches the literal string “Hello*” by escaping the star.

Plus Character (+)

The plus symbol (+) is a quantifier that matches one or more occurrences of the preceding element. Here are some common use cases.

1. One or More Occurrences: The plus matches one or more occurrences of the preceding element.

import re

pattern = "go+d"
texts = ["gd", "god", "good", "goooood"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern will match “god”, “good”, and “goooood”. The plus requires at least one “o” character between “g” and “d”.

2. Pattern Repeating: The plus can be used to repeat a pattern multiple times.

import re

pattern = "ab+c"
texts = ["ac", "abc", "abbc", "abbbbc"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern will match “abc”, “abbc”, and “abbbbc”. The plus requires at least one “b” character between “a” and “c”.

3. Escaping the Plus: If you want to match a literal plus character, you need to escape it with a backslash.

import re

pattern = "Hello+"
text = "Hello+"

match = re.search(pattern, text)
if match:
    print(match.group())

In this example, the pattern `Hello+` matches the literal string “Hello+” by escaping the plus.

The Caret (^) and Dollar ($) Character

The caret (^) and dollar sign ($) have special meanings when used as anchors. Here are the various usages of the caret and dollar characters in regular expressions in Python:

1. Caret as an Anchor: Outside of square brackets, the caret is used as an anchor to match the beginning of a line or string.

import re

pattern = "^Hello"
texts = ["Hello, World!", "Hi there, Hello", "Saying Hello"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `^Hello` matches the word “Hello” only if it appears at the beginning of a line or string. It will match the first and third texts but not the second one.

2. Caret Inside Square Brackets: Inside square brackets ([]), the caret is used to indicate a negated character class. It matches any character except those listed within the brackets.

import re

pattern = "[^aeiou]"
texts = ["apple", "banana", "orange", "grape"]

for text in texts:
    matches = re.findall(pattern, text)
    if matches:
        print("".join(matches))

In this example, the pattern `[^aeiou]` matches any character that is not a vowel (a, e, i, o, or u). The `findall` function returns a list of all matches found in each text. By using the `join` method, we can concatenate the matched characters and print the result.

3. Dollar Sign ($) Anchor: The dollar sign is used as an anchor to match the end of a line or string.

import re

pattern = "World$"
texts = ["Hello, World!", "Hi there, World", "Hello, Big World"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `World$` matches the word “World” only if it appears at the end of a line or string. It will match the first and second texts but not the third one.

4. Combining Caret and Dollar Sign: By combining the caret and dollar sign anchors, you can match an entire line or string.

import re

pattern = "^Hello, World!$"
texts = ["Hello, World!", "Hello, Big World!", "Hi there, World!"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `^Hello`, `World!$` matches the exact line or string “Hello, World!” and nothing else. It will match the first text but not the second and third texts.

Wildcard Character (.)

The wildcard character, often represented as a period (.), is used to match any single character except for a newline character. Here’s an example of how the wildcard character is used in regular expressions:

import re

pattern = "a.b"
texts = ["acb", "aAb", "axb", "anb"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `a.b` matches a string that starts with “a”, followed by any character, and ends with “b”. The `search` function finds the first occurrence of the pattern in each text and prints the result.

The output of the above code will be:

acb
aAb
axb

As you can see, the pattern matches “acb”, “aAb”, and “axb” because the wildcard character matches any character except for a newline character. It allows for a flexible and general pattern-matching approach where the specific character in a certain position is not known or does not matter.

It’s important to note that if you want the wildcard character to also match newline characters, you can use the `re.DOTALL` flag when compiling the regular expression pattern.

import re

pattern = "a.b"
texts = ["acb", "aAb", "axb", "anb"]

for text in texts:
    match = re.search(pattern, text, flags=re.DOTALL)
    if match:
        print(match.group())

By including the `re.DOTALL` flag, the pattern will match “anb” as well.

Dot-Star (.*)

The dot-star (.*), also known as a wildcard pattern, is used to match any sequence of characters (including an empty sequence) except for a newline character. Here’s an example of how the dot-star is used in regular expressions in Python:

import re

pattern = "a.*b"
texts = ["acb", "a123b", "axb", "anb", "ab"]

for text in texts:
    match = re.search(pattern, text)
    if match:
        print(match.group())

In this example, the pattern `a.*b` matches a string that starts with “a”, followed by zero or more occurrences of any character (except for a newline), and ends with “b”. The `search` function finds the first occurrence of the pattern in each text and prints the result.

The output of the above code will be:

acb
a123b
axb
ab

As you can see, the pattern matches “acb”, “a123b”, “axb”, and “ab”. The dot-star allows for flexibility in matching various sequences of characters between “a” and “b”, including no characters at all (as seen in the “ab” case).

It’s important to note that the dot-star is greedy by default, meaning it will match as many characters as possible. If you want it to be non-greedy and match as few characters as possible, you can append a question mark (?) after the dot-star.

import re

pattern = "a.*?b"
text = "a123b456b789b"

matches = re.findall(pattern, text)
print(matches)

In this example, the pattern `a.*?b` matches the smallest possible substring that starts with “a” and ends with “b”. The `findall` function returns a list of all matches found in the text.

The output of the above code will be:

['a123b', 'a456b', 'a789b']

As you can see, the non-greedy dot-star matches each individual substring between “a” and “b” rather than the longest possible substring.

Matching New Lines with Dot-Star (.*)

By default, the dot (.) character in regular expressions does not match newline characters. However, you can modify this behavior using the `re.DOTALL` or `re.S` flag in Python. Here’s an example of how to match newlines with the dot-star:

import re

text = "Hello,nWorld!"

# Match newlines with dot-star and re.DOTALL flag
pattern = "Hello.*World"
match = re.search(pattern, text, re.DOTALL)
print(match.group())

Output:

Hello,
World

In this example, the `re.DOTALL` flag is passed as the third argument to the `re.search()` function. This flag enables the dot (.) to match any character, including newline characters. The pattern `Hello.*World` matches the substring “Hello,” followed by any characters (including newline), and ending with “World”. The `search()` function returns the first occurrence of the pattern that satisfies the match.

Alternatively, you can use the `re.S` flag instead of `re.DOTALL`, as they are equivalent:

import re

text = "Hello,nWorld!"

# Match newlines with dot-star and re.S flag
pattern = "Hello.*World"
match = re.search(pattern, text, re.S)
print(match.group())

The `re.DOTALL` or `re.S` flag allows the dot (.) to match newline characters, enabling you to include newlines in the matched portions of the string when using the dot-star (.*).

Greedy and Non-Greedy Matching

In regular expressions, greedy and non-greedy (also known as lazy or reluctant) matching refer to the behavior of quantifiers when they encounter multiple matches.

By default, quantifiers are greedy, meaning they match as much as possible while still allowing the overall pattern to match. On the other hand, non-greedy matching matches as little as possible while still allowing the pattern to match.

Here’s an example to illustrate the difference between greedy and non-greedy matching in Python:

import re

text = "Hello, <b>world</b>! Welcome to <b>Python</b>."

# Greedy matching with *
greedy_pattern = "<b>.*</b>"
greedy_match = re.search(greedy_pattern, text)
print(greedy_match.group())

# Non-greedy matching with *?
non_greedy_pattern = "<b>.*?</b>"
non_greedy_match = re.search(non_greedy_pattern, text)
print(non_greedy_match.group())

Output:

<b>world</b>! Welcome to <b>Python</b>
<b>world</b>

In this example, the text contains two occurrences of `<b>` and `</b>`, and we are trying to match the content between these tags.

import re

text = "apple banana cherry"
pattern = "[abc]"  # Matches 'a', 'b', or 'c'

matches = re.findall(pattern, text)
print(matches)  # Output: ['a', 'b']

import re

text = "The quick brown fox jumps over the lazy dog"
pattern = "[a-z]"  # Matches any lowercase letter

matches = re.findall(pattern, text)
print(matches)  

import re

text = "The quick brown fox jumps over the lazy dog"
pattern = "[a-zA-Z0-9]"  # Matches any alphanumeric character

matches = re.findall(pattern, text)
print(matches)

pattern = r"d{3}-d{3}-d{4}"

import re

# Regular expression to match a valid email address
local_part = r"[a-zA-Z0-9._%+-]+"
domain_part = r"[a-zA-Z0-9.-]+.[a-zA-Z]{2,}"
pattern = rf"{local_part}@{domain_part}"

text = "Contact us at info@example.com"
match = re.search(pattern, text)
if match:
    print(match.group())

# Matches YYYY-MM-DD format"
pattern = r"(?P<year>d{4})-(?P<month>d{2})-(?P<day>d{2})

pattern = r"""
    ^                           # Start of string
    [a-zA-Z0-9._%+-]+           # Local part
    @                           # @ symbol
    [a-zA-Z0-9.-]+.[a-zA-Z]{2,}  # Domain part
    $                           # End of string
"""

pattern = r"""
    d{3}       # Matches three digits
    -           # Hyphen
    d{3}       # Matches three digits
    -           # Hyphen
    d{4}       # Matches four digits
"""
compiled_pattern = re.compile(pattern, re.VERBOSE)

import re

text = "Hello, World!"

# Case-insensitive matching
pattern = r"hello"
match = re.search(pattern, text, re.IGNORECASE)
if match:
    print("Match found!")

Match found!

import re

text = "Hello, World!"

# Case-insensitive matching with compiled pattern
pattern = re.compile(r"hello", re.IGNORECASE)
match = pattern.search(text)
if match:
    print("Match found!")

import re

def validate_email(email):
    pattern = r'^[w.-]+@[w.-]+.[a-zA-Z]{2,}$'
    return re.match(pattern, email) is not None

email1 = "example@example.com"
email2 = "invalid_email"

print(validate_email(email1))  # Output: True
print(validate_email(email2))  # Output: False

import re

def extract_phone_numbers(text):
    pattern = re.compile(r'''(
    (b(?:+?d{1,3}[-.]))?         # Country Code
    (d{3}|(d{3}))?              # Area Code(Optional)
    (s|-|.)                       # Separator
    (d{3})                         # First Three Digits
    (s|-|.)                       # Separator
    (d{4})                         # Last Four Digits
    (s*(ext|x|ext.)s*(d{2,5}))?  # Extension
    )''', re.VERBOSE)

    results = []
    extracted_data = re.findall(pattern, text)
    for group in extracted_data:
        results.append(group[0])

    return results

text = "Contact us at +1-123-456-7890 or (987) 654-3210"

phone_numbers = extract_phone_numbers(text)
print(phone_numbers)

['1-123-456-7890', '(987) 654-3210']