Using findall() and search() for Pattern Matching

A Pattern Can Ask Two Different Questions

Regular expressions are search strings containing special characters. Those characters communicate matching criteria and extraction rules to a regex system. When the same pattern is applied to text, search() answers whether and where one match can be found, while findall() is used to collect multiple matches. The choice depends on whether the task is to locate one occurrence or gather the occurrences that satisfy the pattern.

import re

text = "cat bat cat"
pattern = "cat"

one_match = re.search(pattern, text)
all_matches = re.findall(pattern, text)

In this example, both operations use the same text and pattern. The search() operation is the focused question: can the pattern locate a match? The findall() operation is the collection question: which occurrences in the text match? The regular expression itself determines what counts as a match; the operation determines how matching results are used.

Read a Pattern as a Set of Constraints

A regex pattern can constrain position, character identity, repetition, or extraction. Anchors such as ^ and $ refer to positions at the start or end of a line. A wildcard such as . represents any character. Character sets restrict a position to one character from a defined set or range. Quantifiers control how many times a preceding pattern repeats. Parentheses identify capture groups so that selected parts of a larger match can be extracted.

Control the Scan with Repetition

Quantifiers control repetition. The symbols *, +, and ? express repetition choices, while *?, +?, and ?? are their non-greedy forms. A greedy quantifier matches as many characters as possible. A non-greedy quantifier, indicated by the trailing ?, matches as few characters as possible. This difference matters when more than one span of text could satisfy the surrounding pattern.

Restrict Characters with Sets

A character set matches a single character from the set described inside square brackets. For example, [aeiou] limits a position to the listed vowels. A range such as [a-z0-9] describes lowercase letters from a through z and digits from 0 through 9. A negated set such as [^A-Za-z] describes characters outside the listed uppercase and lowercase letter ranges. The set changes which characters are eligible at each position; it does not by itself describe a whole multi-character word.

import re

text = "a7 e!"
vowels = re.findall(r"[aeiou]", text)
alphanumeric = re.findall(r"[a-z0-9]", text)
not_letters = re.findall(r"[^A-Za-z]", text)

These three patterns ask different character questions. The vowel set selects listed vowels. The range accepts a lowercase letter or a digit. The negated letter set accepts a character that is not in either letter range. The caret has a different role inside a set than it has at the beginning of a pattern: in the set example it expresses negation, while the anchor form refers to a start position.

Mark Positions with Anchors and Boundaries

Anchors match positions rather than ordinary characters. The ^ anchor restricts a match to the start of a line, and the $ anchor restricts a match to the end of a line. A word boundary is represented by \b. It identifies a boundary position associated with a word, while its negation describes a position that is not a word boundary. These tools change where a match is allowed to begin or end.

Capture the Useful Substring

Parentheses create capture groups. A pattern can therefore match a larger string while identifying particular subsets inside it for extraction. The full match represents the larger pattern, and each parenthesized part represents a captured subgroup within that match.

import re

text = "item-482"
pattern = r"item-(\d+)"
match = re.search(pattern, text)

In the pattern item-(\d+), the complete pattern describes the larger item-482 match, while the parentheses identify the digit portion as a capture group. Parentheses are therefore useful when matching context is necessary but only a subset of that context needs to be extracted.

Choose the Right Character Class

Shorthand sequences provide convenient ways to describe common matching concerns. The sequence \d represents digits, \s represents whitespace, and \b represents word boundaries. Their negations describe the corresponding opposite conditions. These classes answer different questions: whether a position contains a digit, whether it contains whitespace, or whether it is a boundary between word-related regions.

Mistakes Beginners Make

• Treating ^ and $ as ordinary characters to be found in the text.

  Anchors describe positions at the start or end of a line rather than ordinary character content.

  Fix: Use anchors when the location of the match matters, and use a character pattern when the character itself matters.

• Assuming a character set matches a complete word.

  A character set describes allowed characters for a position; it does not automatically describe a multi-character word.

  Fix: Combine the set with an appropriate repetition quantifier when repeated matching is required.

• Ignoring greediness when a repeated pattern can span different lengths.

  Greedy quantifiers match as many characters as possible.

  Fix: Use the corresponding non-greedy form with a trailing question mark when the fewest possible characters should be matched.

• Confusing the full match with a capture group.

  The complete pattern can match a larger string, while the parentheses identify only the selected subset.

  Fix: Use the full match for the complete span and the capture group for the parenthesized subset.

• Using a digit class when the requirement is a word boundary.

  The digit shorthand concerns digit characters, whereas a word boundary concerns a position.

  Fix: Select the shorthand class that describes the actual condition: \d for digits, \s for whitespace, and \b for word boundaries.

Practice the Decision

A Reliable Matching Workflow

1. State whether the task needs one located match or a collection of matches.
2. Mark positional requirements with ^, $, or a word boundary.
3. Choose a character set or shorthand class for the characters involved.
4. Add a quantifier to control repetition, then decide whether greedy or non-greedy behavior is appropriate.
5. Add parentheses around any subset that must be extracted.
6. Test the complete pattern against the intended text and check whether the selected span and captured subset are different in the expected way.

A useful mental model is to build the pattern from the outside in. First decide where a match may occur, then specify which characters may appear, then control repetition, and finally mark the subset that should be captured. After that, choose search() or findall() according to the number of matching occurrences the task requires.