5 Best Ways to Check if a String Follows a Pattern in Python

Rate this post

πŸ’‘ Problem Formulation: You’re given a string and a pattern. The task is to determine if the sequence of characters in the string follows the specific order defined by the pattern. For instance, given the string "subsequence" and the pattern "sue", the desire is to ascertain whether the string contains the characters ‘s’, ‘u’, ‘e’ in the same order as they appear in the pattern, that is, the output should be True.

Method 1: Iterative Check

This method involves iterating over every character in the string and checking if it matches the current character of the pattern. It is straightforward, allowing you to maintain a pointer for the pattern and move it forward each time you find a matching character.

Here’s an example:

def follows_pattern(string, pattern):
    it = iter(string)
    return all(char in it for char in pattern)

print(follows_pattern("subsequence", "sue"))

Output: True

This code snippet defines a function follows_pattern() that takes a string and a pattern. It uses iter() to create an iterator over the string and all() to ensure all characters of the pattern are found in order. If the pattern is fully matched, it returns True.

Method 2: Regular Expressions

Python’s re library can be used to check if the string contains the pattern in the specified order through regular expressions. This method is powerful as it can handle complex patterns and conditions.

Here’s an example:

import re

def follows_pattern_regex(string, pattern):
    regex_pattern = '.*' + '.*'.join(pattern) + '.*'
    return bool(re.match(regex_pattern, string))

print(follows_pattern_regex("subsequence", "sue"))

Output: True

Here, the function follows_pattern_regex() constructs a regular expression that allows any characters to exist between the characters of the pattern. The re.match() function checks if the pattern occurs in the correct order within the string.

Method 3: Using Find Function

We can leverage the built-in find() function for strings to determine the index of each pattern character and ensure each subsequent character in the pattern follows the previous one in the string.

Here’s an example:

def follows_pattern_find(string, pattern):
    index = -1
    for char in pattern:
        index = string.find(char, index + 1)
        if index == -1:
            return False
    return True

print(follows_pattern_find("subsequence", "sue"))

Output: True

The follows_pattern_find() function iterates through the pattern characters and uses string.find() to check if each character follows the previous one. It returns False if a character is not found.

Method 4: Using List Comprehension

With list comprehension, we can achieve this by creating a list of positions for each pattern character in the string and ensuring the positions are in ascending order.

Here’s an example:

def follows_pattern_list_comprehension(string, pattern):
    positions = [string.index(char) for char in pattern if char in string]
    return positions == sorted(positions)

print(follows_pattern_list_comprehension("subsequence", "sue"))

Output: True

This code utilizes list comprehension to find and store the index of each character in the pattern within the string. If the list of positions is equal to the same list sorted, it confirms the pattern order is maintained.

Bonus One-Liner Method 5: Using Filter and Lambda

This method uses the filter() function with a lambda expression to sequentially find pattern characters in the string, ensuring they follow the specified order.

Here’s an example:

def follows_pattern_one_liner(string, pattern):
    return list(filter(lambda x: x in pattern, string)) == list(pattern)

print(follows_pattern_one_liner("subsequence", "sue"))

Output: True

This one-liner uses filter() to extract characters from the string that are in the pattern and compares the resulting list with the list of pattern characters to verify the order.


Each method provided offers a different approach to solving the problem:

  • Method 1: Iterative Check. Straightforward and efficient for simple patterns. Weakness includes difficulty in handling very complex pattern checks.
  • Method 2: Regular Expressions. Powerful for complex patterns and conditions. Can be slower and less readable than other methods for simple patterns.
  • Method 3: Using Find Function. Readable and uses built-in string methods, efficient for small to medium-sized strings. May be slower for very large strings.
  • Method 4: List Comprehension. Offers a more Pythonic way with good readability. However, it might run into issues if the string contains repeated characters.
  • Method 5: Using Filter and Lambda. A concise one-liner that’s elegant but can be less readable to those unfamiliar with the filter or lambda functions.