A Regular Expression or RegEx is a special sequence of characters that uses a search pattern to find a string or set of strings.
It can detect the presence or absence of a text by matching it with a particular pattern and also can split a pattern into one or more sub-patterns.
Regex Module in Python
Python has a built-in module named "re" that is used for regular expressions in Python. We can import this module by using the import statement.
Example: Importing re module in Python
Python
# importing re module
import re
How to Use RegEx in Python?
You can use RegEx in Python after importing re module.
Example:
This Python code uses regular expressions to search for the word "portal" in the given string and then prints the start and end indices of the matched word within the string.
Python
import re
s = 'GeeksforGeeks: A computer science portal for geeks'
match = re.search(r'portal', s)
print('Start Index:', match.start())
print('End Index:', match.end())
OutputStart Index: 34
End Index: 40
Note: Here r character (r’portal’) stands for raw, not regex. The raw string is slightly different from a regular string, it won’t interpret the \ character as an escape character. This is because the regular expression engine uses \ character for its own escaping purpose.
Before starting with the Python regex module let's see how to actually write regex using metacharacters or special sequences.
RegEx Functions
The re module in Python provides various functions that help search, match, and manipulate strings using regular expressions.
Below are the main functions available in the re module:
Function | Description |
---|
re.findall() | finds and returns all matching occurrences in a list |
re.compile() | Regular expressions are compiled into pattern objects |
re.split() | Split string by the occurrences of a character or a pattern. |
re.sub() | Replaces all occurrences of a character or patter with a replacement string. |
resubn | It's similar to re.sub() method but it returns a tuple: (new_string, number_of_substitutions) |
re.escape() | Escapes special character |
re.search() | Searches for first occurrence of character or pattern |
Let's see the working of these RegEx functions with definition and examples:
1. re.findall()
Returns all non-overlapping matches of a pattern in the string as a list. It scans the string from left to right.
This code uses the regular expression \d+ to find all sequences of one or more digits in the given string.
Python
import re
string = """Hello my Number is 123456789 and
my friend's number is 987654321"""
regex = '\d+'
match = re.findall(regex, string)
print(match)
Output['123456789', '987654321']
2. re.compile()
Compiles a regex into a pattern object, which can be reused for matching or substitutions.
Example 1: This pattern [a-e] matches all lowercase letters between 'a' and 'e', in the input string "Aye, said Mr. Gibenson Stark". The output should be ['e', 'a', 'd', 'b', 'e']
, which are the matching characters.
Python
import re
p = re.compile('[a-e]')
print(p.findall("Aye, said Mr. Gibenson Stark"))
Output['e', 'a', 'd', 'b', 'e', 'a']
Explanation:
- First occurrence is 'e' in "Aye" and not 'A', as it is Case Sensitive.
- Next Occurrence is 'a' in "said", then 'd' in "said", followed by 'b' and 'e' in "Gibenson", the Last 'a' matches with "Stark".
- Metacharacter backslash '\' has a very important role as it signals various sequences. If the backslash is to be used without its special meaning as metacharacter, use'\\'
Example 2: The code uses regular expressions to find and list all single digits and sequences of digits in the given input strings. It finds single digits with \d
and sequences of digits with \d+
.
Python
import re
p = re.compile('\d')
print(p.findall("I went to him at 11 A.M. on 4th July 1886"))
p = re.compile('\d+')
print(p.findall("I went to him at 11 A.M. on 4th July 1886"))
Output['1', '1', '4', '1', '8', '8', '6']
['11', '4', '1886']
Example 3: Word and non-word characters
- \w matches a single word character.
- \w+ matches a group of word characters.
- \W matches non-word characters.
Python
import re
p = re.compile('\w')
print(p.findall("He said * in some_lang."))
p = re.compile('\w+')
print(p.findall("I went to him at 11 A.M., he \
said *** in some_language."))
p = re.compile('\W')
print(p.findall("he said *** in some_language."))
Output['H', 'e', 's', 'a', 'i', 'd', 'i', 'n', 's', 'o', 'm', 'e', '_', 'l', 'a', 'n', 'g']
['I', 'went', 'to', 'him', 'at', '11', 'A', 'M', 'he', 'said', 'in', 'some_language']
[' ', ' ', '*', '*', '*', ' ', ' ', '.']
Example 4: The regular expression pattern 'ab*' to find and list all occurrences of 'ab' followed by zero or more 'b' characters. In the input string "ababbaabbb". It returns the following list of matches: ['ab', 'abb', 'abbb'].
Python
import re
p = re.compile('ab*')
print(p.findall("ababbaabbb"))
Output['ab', 'abb', 'a', 'abbb']
Explanation:
- Output 'ab', is valid because of single 'a' accompanied by single 'b'.
- Output 'abb', is valid because of single 'a' accompanied by 2 'b'.
- Output 'a', is valid because of single 'a' accompanied by 0 'b'.
- Output 'abbb', is valid because of single 'a' accompanied by 3 'b'.
3. re.split()
Splits a string wherever the pattern matches. The remaining characters are returned as list elements.
Syntax:
re.split(pattern, string, maxsplit=0, flags=0)
- pattern: Regular expression to match split points.
- string: The input string to split.
- maxsplit (optional): Limits the number of splits. Default is 0 (no limit).
- flags (optional): Apply regex flags like re.IGNORECASE.
Example 1: Splitting by non-word characters or digits
This example demonstrates how to split a string using different patterns like non-word characters (\W+), apostrophes, and digits (\d+).
Python
from re import split
print(split('\W+', 'Words, words , Words'))
print(split('\W+', "Word's words Words"))
print(split('\W+', 'On 12th Jan 2016, at 11:02 AM'))
print(split('\d+', 'On 12th Jan 2016, at 11:02 AM'))
Output['Words', 'words', 'Words']
['Word', 's', 'words', 'Words']
['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM']
['On ', 'th Jan ', ', at ', ':', ' AM']
Example 2: Using maxsplit and flags
This example shows how to limit the number of splits using maxsplit, and how flags can control case sensitivity.
Python
import re
print(re.split('\d+', 'On 12th Jan 2016, at 11:02 AM', 1))
print(re.split('[a-f]+', 'Aey, Boy oh boy, come here', flags=re.IGNORECASE))
print(re.split('[a-f]+', 'Aey, Boy oh boy, come here'))
Output['On ', 'th Jan 2016, at 11:02 AM']
['', 'y, ', 'oy oh ', 'oy, ', 'om', ' h', 'r', '']
['A', 'y, Boy oh ', 'oy, ', 'om', ' h', 'r', '']
Note: In the second and third cases of the above , [a-f]+ splits the string using any combination of lowercase letters from 'a' to 'f'. The re.IGNORECASE flag includes uppercase letters in the match.
4. re.sub()
The re.sub() function replaces all occurrences of a pattern in a string with a replacement string.
Syntax:
re.sub(pattern, repl, string, count=0, flags=0)
- pattern: The regex pattern to search for.
- repl: The string to replace matches with.
- string: The input string to process.
- count (optional): Maximum number of substitutions (default is 0, which means replace all).
- flags (optional): Regex flags like re.IGNORECASE.
Example 1: The following examples show different ways to replace the pattern 'ub' with '~*', using various flags and count values.
Python
import re
# Case-insensitive replacement of all 'ub'
print(re.sub('ub', '~*', 'Subject has Uber booked already', flags=re.IGNORECASE))
# Case-sensitive replacement of all 'ub'
print(re.sub('ub', '~*', 'Subject has Uber booked already'))
# Replace only the first 'ub', case-insensitive
print(re.sub('ub', '~*', 'Subject has Uber booked already', count=1, flags=re.IGNORECASE))
# Replace "AND" with "&", ignoring case
print(re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE))
OutputS~*ject has ~*er booked already
S~*ject has Uber booked already
S~*ject has Uber booked already
Baked Beans & Spam
5. re.subn()
re.subn() function works just like re.sub(), but instead of returning only the modified string, it returns a tuple: (new_string, number_of_substitutions)
Syntax:
re.subn(pattern, repl, string, count=0, flags=0)
Example: Substitution with count
This example shows how re.subn() gives both the replaced string and the number of times replacements were made.
Python
import re
# Case-sensitive replacement
print(re.subn('ub', '~*', 'Subject has Uber booked already'))
# Case-insensitive replacement
t = re.subn('ub', '~*', 'Subject has Uber booked already', flags=re.IGNORECASE)
print(t)
print(len(t)) # tuple length
print(t[0]) # modified string
Output('S~*ject has Uber booked already', 1)
('S~*ject has ~*er booked already', 2)
2
S~*ject has ~*er booked already
6. re.escape()
re.escape() function adds a backslash (\) before all special characters in a string. This is useful when you want to match a string literally, including any characters that have special meaning in regex (like ., *, [, ], etc.).
Syntax:
re.escape(string)
Example: Escaping special characters
This example shows how re.escape() treats spaces, brackets, dashes, and tabs as literal characters.
Python
import re
print(re.escape("This is Awesome even 1 AM"))
print(re.escape("I Asked what is this [a-9], he said \t ^WoW"))
OutputThis\ is\ Awesome\ even\ 1\ AM
I\ Asked\ what\ is\ this\ \[a\-9\]\,\ he\ said\ \ \ \^WoW
7. re.search()
The re.search() function searches for the first occurrence of a pattern in a string. It returns a match object if found, otherwise None.
Note: Use it when you want to check if a pattern exists or extract the first match.
Example: Search and extract values
This example searches for a date pattern with a month name (letters) followed by a day (digits) in a sentence.
Python
import re
regex = r"([a-zA-Z]+) (\d+)"
match = re.search(regex, "I was born on June 24")
if match:
print("Match at index %s, %s" % (match.start(), match.end()))
print("Full match:", match.group(0))
print("Month:", match.group(1))
print("Day:", match.group(2))
else:
print("The regex pattern does not match.")
OutputMatch at index 14, 21
Full match: June 24
Month: June
Day: 24
Metacharacters are special characters in regular expressions used to define search patterns. The re module in Python supports several metacharacters that help you perform powerful pattern matching.
Below is a quick reference table:
MetaCharacters | Description |
---|
\ | Used to drop the special meaning of character following it |
[] | Represent a character class |
^ | Matches the beginning |
$ | Matches the end |
. | Matches any character except newline |
| | Means OR (Matches with any of the characters separated by it. |
? | Matches zero or one occurrence |
* | Any number of occurrences (including 0 occurrences) |
+ | One or more occurrences |
{} | Indicate the number of occurrences of a preceding regex to match. |
() | Enclose a group of Regex |
Let's discuss each of these metacharacters in detail:
1. \ - Backslash
The backslash (\) makes sure that the character is not treated in a special way. This can be considered a way of escaping metacharacters.
For example, if you want to search for the dot(.) in the string then you will find that dot(.) will be treated as a special character as is one of the metacharacters (as shown in the above table). So for this case, we will use the backslash(\) just before the dot(.) so that it will lose its specialty. See the below example for a better understanding.
Example:
The first search (re.search(r'.', s)) matches any character, not just the period, while the second search (re.search(r'\.', s)) specifically looks for and matches the period character.
Python
import re
s = 'geeks.forgeeks'
# 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='g'>
<re.Match object; span=(5, 6), match='.'>
2. [] - Square Brackets
Square Brackets ([]) represent a character class consisting of a set of characters that we wish to match. For example, the character class [abc] will match any single a, b, or c.
We can also specify a range of characters using - inside the square brackets. For example,
- [0, 3] is sample as [0123]
- [a-c] is same as [abc]
We can also invert the character class using the caret(^) symbol. For example,
- [^0-3] means any character except 0, 1, 2, or 3
- [^a-c] means any character except a, b, or c
Example:
In this code, you're using regular expressions to find all the characters in the string that fall within the range of 'a' to 'm'. The re.findall() function returns a list of all such characters. In the given string, the characters that match this pattern are: 'c', 'k', 'b', 'f', 'j', 'e', 'h', 'l', 'd', 'g'.
Python
import re
string = "The quick brown fox jumps over the lazy dog"
pattern = "[a-m]"
result = re.findall(pattern, string)
print(result)
Output['h', 'e', 'i', 'c', 'k', 'b', 'f', 'j', 'm', 'e', 'h', 'e', 'l', 'a', 'd', 'g']
3. ^ - Caret
Caret (^) symbol matches the beginning of the string i.e. checks whether the string starts with the given character(s) or not. For example -
- ^g will check if the string starts with g such as geeks, globe, girl, g, etc.
- ^ge will check if the string starts with ge such as geeks, geeksforgeeks, etc.
Example:
This code uses regular expressions to check if a list of strings starts with "The". If a string begins with "The," it's marked as "Matched" otherwise, it's labeled as "Not matched".
Python
import re
regex = r'^The'
strings = ['The quick brown fox', 'The lazy dog', 'A quick brown fox']
for string in strings:
if re.match(regex, string):
print(f'Matched: {string}')
else:
print(f'Not matched: {string}')
OutputMatched: The quick brown fox
Matched: The lazy dog
Not matched: A quick brown fox
4. $ - Dollar
Dollar($) symbol matches the end of the string i.e checks whether the string ends with the given character(s) or not. For example-
- s$ will check for the string that ends with a such as geeks, ends, s, etc.
- ks$ will check for the string that ends with ks such as geeks, geeksforgeeks, ks, etc.
Example:
This code uses a regular expression to check if the string ends with "World!". If a match is found, it prints "Match found!" otherwise, it prints "Match not found".
Python
import re
string = "Hello World!"
pattern = r"World!$"
match = re.search(pattern, string)
if match:
print("Match found!")
else:
print("Match not found.")
5. . - Dot
Dot(.) symbol matches only a single character except for the newline character (\n). For example -
- a.b will check for the string that contains any character at the place of the dot such as acb, acbd, abbb, etc
- .. will check if the string contains at least 2 characters
Example:
This code uses a regular expression to search for the pattern "brown.fox" within the string. The dot (.
) in the pattern represents any character. If a match is found, it prints "Match found!" otherwise, it prints "Match not found".
Python
import re
string = "The quick brown fox jumps over the lazy dog."
pattern = r"brown.fox"
match = re.search(pattern, string)
if match:
print("Match found!")
else:
print("Match not found.")
6. | - Or
The | operator means either pattern on its left or right can match.
- a|b will match any string that contains a or b such as acd, bcd, abcd, etc.
7. ? - Question Mark
The question mark (?) indicates that the preceding element should be matched zero or one time. It allows you to specify that the element is optional, meaning it may occur once or not at all. For example,
- ab?c will be matched for the string ac, acb, dabc but will not be matched for abbc because there are two b. Similarly, it will not be matched for abdc because b is not followed by c.
8.* - Star
Star (*) symbol matches zero or more occurrences of the regex preceding the * symbol. For example -
- ab*c will be matched for the string ac, abc, abbbc, dabc, etc. but will not be matched for abdc because b is not followed by c.
9. + - Plus
Plus (+) symbol matches one or more occurrences of the regex preceding the + symbol. For example -
- ab+c will be matched for the string abc, abbc, dabc, but will not be matched for ac, abdc, because there is no b in ac and b, is not followed by c in abdc.
10. {m, n} - Braces
Braces match any repetitions preceding regex from m to n both inclusive. For example -
- a{2, 4} will be matched for the string aaab, baaaac, gaad, but will not be matched for strings like abc, bc because there is only one a or no a in both the cases.
11. (<regex>) - Group
Group symbol is used to group sub-patterns. For example -
- (a|b)cd will match for strings like acd, abcd, gacd, etc.
Special Sequences
Special sequences do not match for the actual character in the string instead it tells the specific location in the search string where the match must occur. It makes it easier to write commonly used patterns.
List of special sequences
Special Sequence | Description | Examples |
---|
\A | Matches if the string begins with the given character | \Afor | for geeks |
for the world |
\b | Matches if the word begins or ends with the given character. \b(string) will check for the beginning of the word and (string)\b will check for the ending of the word. | \bge | geeks |
get |
\B | It is the opposite of the \b i.e. the string should not start or end with the given regex. | \Bge | together |
forge |
\d | Matches any decimal digit, this is equivalent to the set class [0-9] | \d | 123 |
gee1 |
\D | Matches any non-digit character, this is equivalent to the set class [^0-9] | \D | geeks |
geek1 |
\s | Matches any whitespace character. | \s | gee ks |
a bc a |
\S | Matches any non-whitespace character | \S | a bd |
abcd |
\w | Matches any alphanumeric character, this is equivalent to the class [a-zA-Z0-9_]. | \w | 123 |
geeKs4 |
\W | Matches any non-alphanumeric character. | \W | >$ |
gee<> |
\Z | Matches if the string ends with the given regex | ab\Z | abcdab |
abababab |
Sets for character matching
A Set is a set of characters enclosed in '[]' brackets. Sets are used to match a single character in the set of characters specified between brackets. Below is the list of Sets:
Set | Description |
---|
\{n,\} | Quantifies the preceding character or group and matches at least n occurrences. |
* | Quantifies the preceding character or group and matches zero or more occurrences. |
[0123] | Matches the specified digits (0, 1, 2, or 3) |
[^arn] | matches for any character EXCEPT a, r, and n |
\d | Matches any digit (0-9). |
[0-5][0-9] | matches for any two-digit numbers from 00 and 59 |
\w | Matches any alphanumeric character (a-z, A-Z, 0-9, or _). |
[a-n] | Matches any lower case alphabet between a and n. |
\D | Matches any non-digit character. |
[arn] | matches where one of the specified characters (a, r, or n) are present |
[a-zA-Z] | matches any character between a and z, lower case OR upper case |
[0-9] | matches any digit between 0 and 9 |
Match Object
A Match object contains all the information about the search and the result and if there is no match found then None will be returned. Let's see some of the commonly used methods and attributes of the match object.
1. Getting the string and the regex
match.re attribute returns the regular expression passed and match.string attribute returns the string passed.
Example: Getting the string and the regex of the matched object
The code searches for the letter "G" at a word boundary in the string "Welcome to GeeksForGeeks" and prints the regular expression pattern (res.re) and the original string (res.string).
Python
import re
s = "Welcome to GeeksForGeeks"
res = re.search(r"\bG", s)
print(res.re)
print(res.string)
Outputre.compile('\\bG')
Welcome to GeeksForGeeks
2. Getting index of matched object
- start() method returns the starting index of the matched substring
- end() method returns the ending index of the matched substring
- span() method returns a tuple containing the starting and the ending index of the matched substring
Example: Getting index of matched object
The code searches for the substring "Gee" at a word boundary in the string "Welcome to GeeksForGeeks" and prints the start index of the match (res.start()
), the end index of the match (res.end()
), and the span of the match (res.span()
).
Python
import re
s = "Welcome to GeeksForGeeks"
res = re.search(r"\bGee", s)
print(res.start())
print(res.end())
print(res.span())
3. Getting matched substring
group() method returns the part of the string for which the patterns match. See the below example for a better understanding.
Example: Getting matched substring
The code searches for a sequence of two non-digit characters followed by a space and the letter 't' in the string "Welcome to GeeksForGeeks" and prints the matched text using res.group()
.
Python
import re
s = "Welcome to GeeksForGeeks"
res = re.search(r"\D{2} t", s)
print(res.group())
In the above example, our pattern specifies for the string that contains at least 2 characters which are followed by a space, and that space is followed by a t.
Basic RegEx Patterns
Let's understand some of the basic regular expressions. They are as follows:
1. Character Classes
Character classes allow matching any one character from a specified set. They are enclosed in square brackets [].
Python
import re
print(re.findall(r'[Gg]eeks', 'GeeksforGeeks: \
A computer science portal for geeks'))
Output['Geeks', 'Geeks', 'geeks']
2. Ranges
In RegEx, a range allows matching characters or digits within a span using - inside []. For example, [0-9] matches digits, [A-Z] matches uppercase letters.
Python
import re
print('Range',re.search(r'[a-zA-Z]', 'x'))
OutputRange <re.Match object; span=(0, 1), match='x'>
3. Negation
Negation in a character class is specified by placing a ^ at the beginning of the brackets, meaning match anything except those characters.
Syntax:
[^a-z]
Example:
Python
import re
print(re.search(r'[^a-z]', 'c'))
print(re.search(r'G[^e]', 'Geeks'))
3. Shortcuts
Shortcuts are shorthand representations for common character classes. Let's discuss some of the shortcuts provided by the regular expression engine.
- \w - matches a word character
- \d - matches digit character
- \s - matches whitespace character (space, tab, newline, etc.)
- \b - matches a zero-length character
Python
import re
print('Geeks:', re.search(r'\bGeeks\b', 'Geeks'))
print('GeeksforGeeks:', re.search(r'\bGeeks\b', 'GeeksforGeeks'))
OutputGeeks: <_sre.SRE_Match object; span=(0, 5), match='Geeks'>
GeeksforGeeks: None
4. Beginning and End of String
The ^ character chooses the beginning of a string and the $ character chooses the end of a string.
Python
import re
# Beginning of String
match = re.search(r'^Geek', 'Campus Geek of the month')
print('Beg. of String:', match)
match = re.search(r'^Geek', 'Geek of the month')
print('Beg. of String:', match)
# End of String
match = re.search(r'Geeks$', 'Compute science portal-GeeksforGeeks')
print('End of String:', match)
OutputBeg. of String: None
Beg. of String: <_sre.SRE_Match object; span=(0, 4), match='Geek'>
End of String: <_sre.SRE_Match object; span=(31, 36), match='Geeks'>
5. Any Character
The . character represents any single character outside a bracketed character class.
Python
import re
print('Any Character', re.search(r'p.th.n', 'python 3'))
OutputAny Character <_sre.SRE_Match object; span=(0, 6), match='python'>
6. Optional Characters
Regular expression engine allows you to specify optional characters using the ? character. It allows a character or character class either to present once or else not to occur. Let's consider the example of a word with an alternative spelling - color or colour.
Python
import re
print('Color',re.search(r'colou?r', 'color'))
print('Colour',re.search(r'colou?r', 'colour'))
OutputColor <_sre.SRE_Match object; span=(0, 5), match='color'>
Colour <_sre.SRE_Match object; span=(0, 6), match='colour'>
7. Repetition
Repetition enables you to repeat the same character or character class. Consider an example of a date that consists of day, month, and year. Let's use a regular expression to identify the date (mm-dd-yyyy).
Python
import re
print('Date{mm-dd-yyyy}:', re.search(r'[\d]{2}-[\d]{2}-[\d]{4}',
'18-08-2020'))
OutputDate{mm-dd-yyyy}: <_sre.SRE_Match object; span=(0, 10), match='18-08-2020'>
Here, the regular expression engine checks for two consecutive digits. Upon finding the match, it moves to the hyphen character. After then, it checks the next two consecutive digits and the process is repeated.
Let's discuss three other regular expressions under repetition.
7.1 Repetition ranges
The repetition range is useful when you have to accept one or more formats. Consider a scenario where both three digits, as well as four digits, are accepted. Let's have a look at the regular expression.
Python
import re
print('Three Digit:', re.search(r'[\d]{3,4}', '189'))
print('Four Digit:', re.search(r'[\d]{3,4}', '2145'))
OutputThree Digit: <_sre.SRE_Match object; span=(0, 3), match='189'>
Four Digit: <_sre.SRE_Match object; span=(0, 4), match='2145'>
7.2 Open-Ended Ranges
There are scenarios where there is no limit for a character repetition. In such scenarios, you can set the upper limit as infinitive. A common example is matching street addresses. Let's have a look
Python
import re
print(re.search(r'[\d]{1,}','5th Floor, A-118,\
Sector-136, Noida, Uttar Pradesh - 201305'))
Output<_sre.SRE_Match object; span=(0, 1), match='5'>
7.3 Shorthand
Shorthand characters allow you to use + character to specify one or more ({1,}) and * character to specify zero or more ({0,}.
Python
import re
print(re.search(r'[\d]+', '5th Floor, A-118,\
Sector-136, Noida, Uttar Pradesh - 201305'))
Output<_sre.SRE_Match object; span=(0, 1), match='5'>
8. Grouping
Grouping is the process of separating an expression into groups by using parentheses, and it allows you to fetch each individual matching group.
Python
import re
grp = re.search(r'([\d]{2})-([\d]{2})-([\d]{4})', '26-08-2020')
print(grp)
Output<_sre.SRE_Match object; span=(0, 10), match='26-08-2020'>
Let's see some of its functionality.
8.1 Return the entire match
The re module allows you to return the entire match using the group() method
Python
import re
grp = re.search(r'([\d]{2})-([\d]{2})-([\d]{4})','26-08-2020')
print(grp.group())
8.2 Return a tuple of matched groups
You can use groups() method to return a tuple that holds individual matched groups
Python
import re
grp = re.search(r'([\d]{2})-([\d]{2})-([\d]{4})','26-08-2020')
print(grp.groups())
Output('26', '08', '2020')
8.3 Retrieve a single group
Upon passing the index to a group method, you can retrieve just a single group.
Python
import re
grp = re.search(r'([\d]{2})-([\d]{2})-([\d]{4})','26-08-2020')
print(grp.group(3))
8.4 Name your groups
The re module allows you to name your groups. Let's look into the syntax.
Python
import re
match = re.search(r'(?P<dd>[\d]{2})-(?P<mm>[\d]{2})-(?P<yyyy>[\d]{4})',
'26-08-2020')
print(match.group('mm'))
8.5 Individual match as a dictionary
We have seen how regular expression provides a tuple of individual groups. Not only tuple, but it can also provide individual match as a dictionary in which the name of each group acts as the dictionary key.
Python
import re
match = re.search(r'(?P<dd>[\d]{2})-(?P<mm>[\d]{2})-(?P<yyyy>[\d]{4})',
'26-08-2020')
print(match.groupdict())
Output{'dd': '26', 'mm': '08', 'yyyy': '2020'}
9. Lookahead
In the case of a negated character class, it won't match if a character is not present to check against the negated character. We can overcome this case by using lookahead; it accepts or rejects a match based on the presence or absence of content.
Python
import re
print('negation:', re.search(r'n[^e]', 'Python'))
print('lookahead:', re.search(r'n(?!e)', 'Python'))
Outputnegation: None
lookahead: <_sre.SRE_Match object; span=(5, 6), match='n'>
Lookahead can also disqualify the match if it is not followed by a particular character. This process is called a positive lookahead, and can be achieved by simply replacing ! character with = character.
Python
import re
print('positive lookahead', re.search(r'n(?=e)', 'jasmine'))
Outputpositive lookahead <_sre.SRE_Match object; span=(5, 6), match='n'>
10. Substitution
The regular expression can replace the string and returns the replaced one using the re.sub method. It is useful when you want to avoid characters such as /, -, ., etc. before storing it to a database. It takes three arguments:
- the regular expression
- the replacement string
- the source string being searched
Let's have a look at the below code that replaces - character from a credit card number.
Python
import re
print(re.sub(r'([\d]{4})-([\d]{4})-([\d]{4})-([\d]{4})',r'\1\2\3\4',
'1111-2222-3333-4444'))
Related Article:
Regular Expressions in Python - Set 2
Similar Reads
Constructors in Python In Python, a constructor is a special method that is called automatically when an object is created from a class. Its main role is to initialize the object by setting up its attributes or state. The method __new__ is the constructor that creates a new instance of the class while __init__ is the init
3 min read
Destructors in Python Constructors in PythonDestructors are called when an object gets destroyed. In Python, destructors are not needed as much as in C++ because Python has a garbage collector that handles memory management automatically. The __del__() method is a known as a destructor method in Python. It is called when
7 min read
Inheritance in Python Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a class (called a child or derived class) to inherit attributes and methods from another class (called a parent or base class). In this article, we'll explore inheritance in Python.Inheritance in PythonWhy do we ne
7 min read
Encapsulation in Python In Python, encapsulation refers to the bundling of data (attributes) and methods (functions) that operate on the data into a single unit, typically a class. It also restricts direct access to some components, which helps protect the integrity of the data and ensures proper usage.Encapsulation is the
6 min read
Polymorphism in Python Polymorphism is a foundational concept in programming that allows entities like functions, methods or operators to behave differently based on the type of data they are handling. Derived from Greek, the term literally means "many forms".Python's dynamic typing and duck typing make it inherently poly
6 min read
Class method vs Static method in Python In this article, we will cover the basic difference between the class method vs Static method in Python and when to use the class method and static method in python.What is Class Method in Python? The @classmethod decorator is a built-in function decorator that is an expression that gets evaluated a
5 min read
File Handling in Python File handling refers to the process of performing operations on a file such as creating, opening, reading, writing and closing it, through a programming interface. It involves managing the data flow between the program and the file system on the storage device, ensuring that data is handled safely a
6 min read
Reading and Writing to text files in Python Python provides built-in functions for creating, writing, and reading files. Two types of files can be handled in Python, normal text files and binary files (written in binary language, 0s, and 1s). Text files: In this type of file, Each line of text is terminated with a special character called EOL
8 min read
Python Modules Python Module is a file that contains built-in functions, classes,its and variables. There are many Python modules, each with its specific work.In this article, we will cover all about Python modules, such as How to create our own simple module, Import Python modules, From statements in Python, we c
7 min read
Python Exception Handling Python Exception Handling handles errors that occur during the execution of a program. Exception handling allows to respond to the error, instead of crashing the running program. It enables you to catch and manage errors, making your code more robust and user-friendly. Let's look at an example:Handl
6 min read