Python regex search vs match

Regular expressions (regex) are powerful tools for pattern matching and searching in strings. In Python, the re module offers functions such as search and match to work with regular expressions. Understanding the differences between search() and match() methods are crucial for effectively using regular expressions in Python.

The search() method

The regex search() method is a method used to search for a pattern in a string and return the first occurrence of the pattern. In this section, you will get to understand the syntax and its usage.

Syntax and usage

To efficiently use the search() method, you, first of all, have to understand its syntax. Let us look at the syntax:


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

The table below summarises the arguments:

Argument	Description
pattern	The text to search for
string	The text to search the pattern in
flags(optional)	This is for modifying the search behavior

search() method arguments

Examples

For the syntax to make sense, let us look at some examples. Here is the first one:


import re

# specify the pattern to search for
pattern = r'www.sparkbyexamples.com'  

# the input string to search within
text = 'For more great Python tutorials visit www.sparkbyexamples.com'  

# search for the pattern in the text string
match = re.search(pattern, text)  

if match:
    # if a match is found, print the matched substring
    print('Match found:', match.group())  

else:
    # if no match is found, print a message indicating no match
    print('No match found.')

In this code, we define the pattern we want to search for as 'www.sparkbyexamples.com' and the input string as 'For more great Python tutorials visit www.sparkbyexamples.com'.

The re.search() method is used to search for the pattern within the text string. If a match is found, the code prints 'Match found:' followed by the matched substring using match.group(). Otherwise, it prints 'No match found.'.

Output:


#Output
Match found: www.sparkbyexamples.com

For good measure let us look at another example:


import re

# specify the pattern to search for (matches one or more digits)
pattern = r'\d+'  

# the input string to search within
text = 'sparkbyexamples.com was found in the year 2010.'  

# search for the pattern in the text string
match = re.search(pattern, text)  

if match:
    # if a match is found, print the matched substring
    print('Match found:', match.group())  
else:
    # if no match is found, print a message indicating no match
    print('No match found.')

Here, we define the pattern we want to search for as r'\d+', which matches one or more digits. The input string is 'sparkbyexamples.com was found in the year 2010.'.

The re.search() method is used to search for the pattern within the text string.

Output:


#Output
Match found: 2010

The match() method

The regex match() method is one of the re module’s methods that are used to check if the pattern matches at the beginning of the input string and returns a match object or None.

Syntax and usage

The match() method syntax is as follows:


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

Argument	Description
pattern	This is what you what to search for in the text
string	This is the text you want to search in
flags(optional)	This helps to modify the behavior of the search

match() method arguments

Examples

To better understand the match() method syntax, let us explore some examples. Here is the first one:


import re

# specify the pattern to match
pattern = r'Spark'  

# the input string to search within
text = 'SparkByExamples is a great platform for learning programming'  

# match the pattern at the beginning of the text string
match = re.match(pattern, text)  

if match:
    # if a match is found, print the matched substring
    print('Match found:', match.group())  
else:
    # if no match is found, print a message indicating no match
    print('No match found.')

To be on the same page, let’s break this code snippet down, we first of all, define the pattern we want to match as 'Spark', and the input string as 'SparkByExamples is a great platform for learning programming'.

Then the match() method will check if a pattern matches at the beginning of a string and extract the matched substring if a match is found.

Output:


#Output
Match found: Spark

One last example of the match() method is to match a numeric pattern:


import re

# matches one or more digits
pattern = r'\d+'  

# the input string to search within
text = '2010 is the year sparkbyexamples.com was found.'

# match the pattern at the beginning of the text string
match = re.match(pattern, text)  

if match:
    # if a match is found, print the matched substring
    print('Match found:', match.group())  
else:
    # if no match is found, print a message indicating no match
    print('No match found.')

In this example, we define the pattern and the text, the pattern matches one or more digits at the start of the text. Then the match() method is called with the pattern and the text as arguments. It attempts to match the pattern at the beginning of the text string. The code checks if a match is found using an if statement. If a match is found, the code proceeds to the next step. Otherwise, it goes to the else block.

Output:


#Output
Match found: 2010

Comparing search() and match() methods

After looking at these two powerful methods that come with the re module, you might have noticed that they differ in their behavior and usage. In this section, we will look at the comparisons between these two methods.

Purpose:

search(): Finds the first occurrence of a pattern anywhere in the input string.

match(): Checks if a pattern matches at the beginning of the input string.

Matching Behavior:

search(): Searches for a pattern throughout the input string, returning the first match found.

match(): Attempts to match the pattern only at the beginning of the input string.

Positioning:

search(): Can match a pattern anywhere within the input string.

match(): Matches a pattern only at the start of the input string.

Usage:

search(): Used to find patterns anywhere within the input string.

match(): Used to validate or extract information from the beginning of the input string.

Return Value:

search(): Returns a match object if a match is found, or None if no match is found.

match(): Returns a match object if a match is found at the beginning of the string, or None if no match is found.

Scope:

search(): Searches the entire input string, not just the beginning.

match(): Matches the pattern specifically at the beginning of the input string.

Conclusion

That concludes this tutorial, we hope you have learned so much and that the knowledge gained will be used in your future Python regex projects.