Skip to main content

How to Check if Any List Element Matches a Regex in Python

This guide explains how to efficiently determine if any element within a Python list matches a given regular expression. We'll cover using re.search() (to match anywhere in the string) and re.match() (to match only at the beginning), along with generator expressions and the any() function for concise and readable code.

The most Pythonic and efficient way to check if any element in a list matches a regex is to combine re.search() with the any() function and a generator expression:

import re

prog = re.compile(r'[a-z]+')  # Compile the regex for efficiency
my_list = ['!', '?', '???abc???']

if any((match := prog.search(item)) for item in my_list):
    print('At least one list item matches regex')
    print(match.group(0))  # Output: abc
else:
    print('No list items match regex')
  • re.compile(r'[a-z]+'): This compiles the regular expression [a-z]+ into a regex object. Compiling the regex once outside the loop is more efficient if you're going to use the same regex multiple times. [a-z]+ matches one or more lowercase letters.
  • prog.search(item): re.search() searches for the pattern anywhere within the string item. It returns a match object if found, and None otherwise.
  • (match := prog.search(item)) for item in my_list: This is a generator expression. It iterates over the list, and for each item, it tries to find a match. The assignment expression (:=, the "walrus operator") assigns the result of prog.search(item) to the variable match and yields that value. This lets us use the match object later, if one is found.
  • any(...): The any() function returns True if any of the values yielded by the generator expression are truthy. A match object is truthy; None is falsy. So, any() returns True if at least one string in the list has a match.
  • match.group(0): Returns the matched substring.

Understanding re.search() vs. re.match()​

It's crucial to understand the difference between re.search() and re.match():

  • re.search(pattern, string): Searches for the pattern anywhere within the string.
  • re.match(pattern, string): Checks if the pattern matches at the beginning of the string.
import re

print(re.search(r'abc', '123abc456'))  # Output: <re.Match object; span=(3, 6), match='abc'> (Match found)
print(re.match(r'abc', '123abc456'))   # Output: None (No match at the *beginning*)
  • Use re.search() if the pattern could appear anywhere in the string.
  • Use re.match() if the pattern must appear on the start of the string.

Using re.match() with any()​

If you specifically want to check if any element in the list starts with the pattern, use re.match():

import re

prog = re.compile(r'[a-z]+')
my_list = ['!', '?', 'abc???']

if any((match := prog.match(item)) for item in my_list):
    print('At least one list item starts with the regex')
    print(match.group(0))  # Output: abc
else:
    print('No list items start with the regex')

Using re.compile() for Efficiency​

When you use the same regular expression multiple times (as we do within the loop), it's more efficient to compile it into a regular expression object once using re.compile(). This avoids recompiling the regex on each iteration. That's why we used:

prog = re.compile(r'[a-z]+')

at the beginning of the examples. Then, we use prog.search() or prog.match() instead of re.search() or re.match().

Table of Contents