😍RegEx

Regular expressions, also known as regex or regexp, provide a powerful way to search, manipulate, and extract data from strings in Python. A regular expression is a sequence of characters that defines a search pattern. Python's built-in re module provides support for regular expressions.

Regular expressions can be used for a variety of tasks, such as searching for specific patterns in text, validating input strings, and replacing text with new values.

The re module provides several functions for working with regular expressions, including:

  • re.search(): Searches a string for a match to a specified pattern.

  • re.findall(): Returns a list containing all matches of a specified pattern in a string.

  • re.sub(): Replaces one or many occurrences of a specified pattern in a string with a replacement string.

  • re.compile(): Compiles a regular expression pattern into a regular expression object, which can be used for more efficient searching.

Regular expressions use a variety of special characters and syntax to define search patterns, such as:

  • .: Matches any character except newline.

  • *: Matches zero or more occurrences of the previous character.

  • +: Matches one or more occurrences of the previous character.

  • ?: Matches zero or one occurrence of the previous character.

  • []: Matches any character inside the square brackets.

  • () or |: Creates a group or specifies alternatives.

Regular expressions can be complex and take some time to master, but once you understand the basics, they provide a powerful tool for working with text in Python

Specify Pattern Using RegEx

To specify regular expressions, metacharacters are used. In the above example, ^ and $ are metacharacters.

MetaCharacters

Metacharacters are characters that are interpreted in a special way by a RegEx engine. Here's a list of metacharacters:

[] . ^ $ * + ? {} () \ |

In regular expressions, metacharacters are special characters that have a special meaning and are used to define search patterns. Here are some of the most commonly used metacharacters in Python regular expressions:

  1. . (dot): Matches any character except newline. For example, the pattern r'he.' matches any string that starts with "he" and is followed by any single character.

  2. * (asterisk): Matches zero or more occurrences of the previous character. For example, the pattern r'ab*' matches any string that has an "a" followed by zero or more "b" characters.

  3. + (plus): Matches one or more occurrences of the previous character. For example, the pattern r'ab+' matches any string that has an "a" followed by one or more "b" characters.

  4. ? (question mark): Matches zero or one occurrence of the previous character. For example, the pattern r'colou?r' matches both "color" and "colour".

  5. [] (square brackets): Matches any character inside the square brackets. For example, the pattern r'[aeiou]' matches any string that contains any one of the vowels "a", "e", "i", "o", or "u".

  6. () (parentheses): Creates a group that can be referenced later. For example, the pattern r'(ab)+' matches any string that has one or more occurrences of the "ab" sequence.

  7. | (pipe): Specifies alternatives. For example, the pattern r'cat|dog' matches any string that contains either "cat" or "dog".

  8. ^ (caret): Matches the beginning of a string. For example, the pattern r'^hello' matches any string that starts with "hello".

  9. $ (dollar sign): Matches the end of a string. For example, the pattern r'world$' matches any string that ends with "world".

These are just some of the most commonly used metacharacters in Python regular expressions. Regular expressions can be complex and take some time to master, but understanding the basic metacharacters is a good starting point.

Python RegEx

Python has a module named re to work with regular expressions. To use it, we need to import the module.

import re

The module defines several functions and constants to work with RegEx.

re.findall()

The re.findall() function in Python's re module returns a list containing all non-overlapping matches of a pattern in a string. The syntax for using re.findall() is:

re.findall(pattern, string, flags=0)

Here's an example that uses re.findall() to find all occurrences of a pattern in a string:

import re

text = 'The quick brown fox jumps over the lazy dog'
matches = re.findall(r'\b\w{4}\b', text)
print(matches)  # Output: ['quick', 'brown', 'jumps', 'over', 'lazy']

In this example, we import the re module and define a string text. We then use the re.findall() function to find all non-overlapping matches of the pattern r'\b\w{4}\b' in the string. The pattern matches any word that has exactly four letters. The function returns a list of all matches, which in this case are ['quick', 'brown', 'jumps', 'over', 'lazy'].

Note that the re.findall() function returns all non-overlapping matches of the pattern in the string. If you want to find all matches, including overlapping matches, you can use the re.finditer() function instead.

Also, the flags argument in the re.findall() function can be used to specify optional flags that modify the behavior of the search. For example, the re.IGNORECASE flag can be used to perform a case-insensitive search.

re.split()

The re.split() function in Python's re module is used to split a string into a list of substrings based on a specified pattern. The syntax for using re.split() is:

re.split(pattern, string, maxsplit=0, flags=0)

Here's an example that demonstrates how to use re.split() to split a string based on a pattern:

import re

text = 'The quick brown fox jumps over the lazy dog'
words = re.split(r'\s', text)
print(words)  # Output: ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']

In this example, we import the re module and define a string text. We then use the re.split() function to split the string into a list of substrings using the pattern r'\s', which matches any whitespace character. The function returns a list of words in the string, which are ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog'].

By default, re.split() splits the string at every occurrence of the pattern. You can use the maxsplit argument to specify the maximum number of splits to perform. For example, re.split(r'\s', text, maxsplit=2) will split the string into a maximum of 3 substrings.

The flags argument in re.split() can be used to specify optional flags that modify the behavior of the split. For example, the re.IGNORECASE flag can be used to perform a case-insensitive split.

Note that re.split() uses regular expressions to define the splitting pattern, so you can use more complex patterns to split the string based on specific criteria.

re.sub()

The re.sub() function in Python's re module is used to replace one or more occurrences of a pattern in a string with a specified replacement string. The syntax for using re.sub() is:

re.sub(pattern, repl, string, count=0, flags=0)

Here's an example that demonstrates how to use re.sub() to replace occurrences of a pattern in a string:

import re

text = 'The quick brown fox jumps over the lazy dog'
new_text = re.sub(r'fox', 'cat', text)
print(new_text)  # Output: 'The quick brown cat jumps over the lazy dog'

In this example, we import the re module and define a string text. We then use the re.sub() function to replace all occurrences of the pattern r'fox' in the string with the replacement string 'cat'. The function returns a new string new_text, which is 'The quick brown cat jumps over the lazy dog'.

You can use regular expressions in the pattern argument to replace more complex patterns. Here's an example:

import re

text = 'The quick brown fox jumps over the lazy dog'
new_text = re.sub(r'\b\w{4}\b', '****', text)
print(new_text)  # Output: 'The **** brown **** jumps over the **** ****'

In this example, we use the pattern r'\b\w{4}\b', which matches any word that has exactly four letters. We replace all matches with the replacement string '****', resulting in the new string new_text: 'The **** brown **** jumps over the **** ****'.

The count argument in re.sub() can be used to specify the maximum number of replacements to perform. By default, all occurrences of the pattern are replaced. The flags argument can be used to specify optional flags that modify the behavior of the search and replace.

Note that re.sub() returns a new string with the replacements made, and the original string is not modified.

re.search()

re.search() is a function in Python's built-in re module that is used to search for a regular expression pattern in a string. It returns a match object if the pattern is found and None otherwise.

The syntax for using re.search() is:

re.search(pattern, string, flags=0)

where pattern is the regular expression pattern to be searched for, string is the string in which to search for the pattern, and flags is an optional parameter that can be used to modify the behavior of the regular expression engine.

Here's an example of how to use re.search() to search for the word "apple" in a string:

import re

string = "I love eating apples"
pattern = r"apple"

match = re.search(pattern, string)

if match:
    print("Match found!")
else:
    print("Match not found.")

In this example, we first import the re module. We then define a string string and a regular expression pattern pattern that matches the word "apple". We then use re.search() to search for the pattern in the string. If a match is found, we print "Match found!" to the console. Otherwise, we print "Match not found."

Match object

In Python's built-in re module, when a regular expression pattern is matched with a string using any of the matching functions such as re.search(), re.match(), re.findall(), etc., a match object is returned.

A match object contains information about the match such as the start and end indices of the match in the string, the matched text, and any captured groups if the regular expression pattern includes capture groups. The match object also provides methods to access and manipulate this information.

Here's an example of how to use a match object returned by re.search() to extract the matched text and the start and end indices of the match:

import re

string = "I love eating apples"
pattern = r"apple"

match = re.search(pattern, string)

if match:
    print("Match found!")
    print("Matched text:", match.group())
    print("Start index:", match.start())
    print("End index:", match.end())
else:
    print("Match not found.")

In this example, we first define a string string and a regular expression pattern pattern that matches the word "apple". We then use re.search() to search for the pattern in the string and store the resulting match object in the variable match. If a match is found, we print "Match found!" to the console and then use the match object's group(), start(), and end() methods to extract the matched text and the start and end indices of the match. Finally, we print this information to the console.

Note that if the regular expression pattern includes capture groups, the match object's group() method can be used to extract the captured text for each group. The method takes an optional argument indicating which group to extract, with 0 indicating the entire matched text.

Using r prefix before RegEx

In Python, the r prefix before a string literal is used to create a raw string. When used with regular expressions, a raw string allows us to specify the regular expression pattern without having to escape backslashes and other special characters.

For example, if we want to search for a backslash character using a regular expression, we can specify the pattern as follows:

import re

string = "a\\b\\c"
pattern = r"\\"

match = re.search(pattern, string)

if match:
    print("Match found!")
else:
    print("Match not found.")

In this example, we define a string string that contains backslashes and a regular expression pattern pattern that matches a single backslash. We use the r prefix to create a raw string for the pattern so that we don't have to escape the backslash with another backslash.

Without the r prefix, the regular expression pattern would need to be specified as "\\\\" to match a single backslash in the string.

By using a raw string with regular expressions, we can make our code more readable and avoid errors due to escaping mistakes.

PreviousDecoratorsNextRecursion

Last updated