Using re.search() and re.findall()

One Match, Two Possible Results

A regular expression can match a larger piece of text while you keep only a smaller piece from inside it. The key tool for controlling what findall() returns is the capturing group: the part of the pattern enclosed in parentheses. Parentheses do not change the text that the pattern matches. They change which part of that match findall() returns.

Tracing a Capturing Group

import re text = "X-:42" values = re.findall(r"X-:(\d+)", text) print(values)

['42']

Matching Versus Extracting

Think of the regular expression as having two jobs. First, the whole pattern decides whether the relevant text matches. Everything outside the parentheses still participates in that decision. Second, the parentheses identify the portion to keep when findall() builds its result. Therefore, a pattern can match a long string but return only a short substring from inside it.

When several pieces of text match, findall() collects the extracted results. With one capturing group, the result is a list of strings. Without parentheses, the returned strings are the entire matching substrings instead. The matching process can therefore be the same while the returned result has different content.

Choosing search() or findall()

The capturing-group rule in this article applies specifically to what findall() returns. re.search() is described differently: it gives the first matching location and a match object. Do not assume that choosing parentheses automatically makes both functions return the same kind of result.

Working with Extracted Values

import re

text = "X-score:42 X-level:7"
items = re.findall(r"X-([a-z]+):(\d+)", text)
print(items)

for label, number_text in items:
    number = int(number_text)
    print(label, number + 1)

[('score', '42'), ('level', '7')]
score 43
level 8

The first result is a tuple because the pattern has two capturing groups. The tuple values are strings, including the value that looks like a number. Calling int() creates an integer for the later addition. Similarly, extracted decimal values need conversion to float when floating-point operations are required.

Mistakes Beginners Make

• Expecting findall() to return the whole match when a capturing group is present.

  Parentheses tell findall() to return only the enclosed portion.

  Fix: Separate the idea of matching the complete pattern from extracting the captured portion.

• Assuming captured numbers are already numeric.

  findall() returns extracted values as strings.

  Fix: Convert the value explicitly with int() or float() when the later operation requires that type.

• Treating multiple capturing groups like one capturing group.

  findall() represents multiple captured values from each match as a tuple.

  Fix: Unpack each tuple in the same order as the capturing groups appear in the pattern.

• Indexing the result without checking whether anything matched.

  There is no element to access when findall() returns no matches.

  Fix: Verify that the returned list is non-empty before accessing one of its elements.

Practice: Predict the Result

Key Takeaways

1. The complete regular expression must match, but parentheses identify the part findall() should return.
2. With one capturing group, findall() returns a list of strings.
3. With multiple capturing groups, findall() returns a list of tuples in group order.
4. Extracted values are strings, so convert them to int or float when numeric work is needed.
5. Check that findall() returned a non-empty list before accessing an element.
6. re.search() focuses on the first matching location and a match object, while re.findall() provides a collection of extracted results.