Introduction

Regular Expressions (Regex) are essential for matching patterns within text. In Python, the re.search() function scans a string for the first match of a pattern.

This guide explains quantifiers, anchors, and wildcards using re.search(), showing output and how each pattern works step by step.

Quantifiers with re.search()

`*` – Zero or More

match = re.search('ba*', 'baaa')
print(match.group())

Output: 'baaa'

Explanation: 'b' is mandatory, followed by zero or more 'a's. The engine finds 'b' at position 0, sees 3 'a's after it, and matches all of them because '*' allows unlimited repetition.

`+` – One or More

match = re.search('ba+', 'baaa')
print(match.group())

Output: 'baaa'

Explanation: This requires at least one 'a' after 'b'. It finds 'b' at index 0, sees three 'a's, and matches greedily.

`?` – Zero or One

match = re.search('ba?', 'b')
print(match.group())

Output: 'b'

Explanation: 'a' is optional here. The string is just 'b'. The regex matches it because 'a?' allows zero occurrences.

`{n}` – Exactly n Times

match = re.search('a{3}', 'aaab')
print(match.group())

Output: 'aaa'

Explanation: 'a{3}' means match exactly 3 'a's in a row. The first 3 characters are 'aaa', so they are matched.

`{n,}` – At Least n Times

match = re.search('a{2,}', 'aaaaa')
print(match.group())

Output: 'aaaaa'

Explanation: Matches 2 or more 'a's. The engine finds 5 consecutive 'a's and matches all, since it's greedy.

`{n,m}` – Between n and m Times

match = re.search('a{2,4}', 'aaaaaa')
print(match.group())

Output: 'aaaa'

Explanation: The engine finds 6 'a's but will match only the first 4 due to the max limit of 4. Greedy match returns 'aaaa'.

`*?` – Lazy Quantifier

text = ''
match = re.search('<.*?>', text)
print(match.group())

Output: '<tag1>'

Explanation: '<.*?>' matches as little as possible between '<' and '>'. The first match is just '<tag1>', thanks to the lazy '?'.

Anchors with re.search()

`^` – Start of String

match = re.search('^Hello', 'Hello world')
print(match.group())

Output: 'Hello'

Explanation: '^Hello' asserts that 'Hello' must appear at the very beginning. It matches successfully.

`$` – End of String

match = re.search('world$', 'Hello world')
print(match.group())

Output: 'world'

Explanation: '$' checks the end of the string. The engine matches 'world' only because it's at the end.

`\\b` – Word Boundary

match = re.search(r'\\bcat\\b', 'cat catalog')
print(match.group())

Output: 'cat'

Explanation: '\\b' ensures 'cat' stands as a whole word. It skips 'catalog' because it's not bounded.

`\\B` – Non-Word Boundary

match = re.search(r'\\Bcat\\B', 'educate')
print(match.group())

Output: 'cat'

Explanation: This matches 'cat' only if it is inside another word. 'educate' contains it within, so it's valid.

`(?=...)` – Positive Lookahead

match = re.search(r'a(?=b)', 'ac ab abc')
print(match.group())

Output: 'a'

Explanation: It looks for 'a' only when followed by 'b'. Found at position of 'ab'. Only 'a' is returned.

`(?!...)` – Negative Lookahead

match = re.search(r'a(?!b)', 'ac ab')
print(match.group())

Output: 'a'

Explanation: It matches 'a' not followed by 'b'. The first 'a' in 'ac' qualifies.

Wildcards with re.search()

`.` – Any Single Character

match = re.search('a.b', 'acb')
print(match.group())

Output: 'acb'

Explanation: '.' matches any single character between 'a' and 'b'. 'c' is valid here.

`.*` – Any Characters Greedy

match = re.search('a.*b', 'axyzb')
print(match.group())

Output: 'axyzb'

Explanation: '.*' grabs everything between 'a' and the last 'b'. Greedy match.

`[abc]` – Character Set

match = re.search('[abc]', 'defa')
print(match.group())

Output: 'a'

Explanation: Matches the first character that belongs to the set [abc]. Here, it finds 'a'.

`[^abc]` – Negated Set

match = re.search('[^abc]', 'aabbcdef')
print(match.group())

Output: 'd'

Explanation: The engine skips all a/b/c and returns the first char that is not one of them: 'd'.

`[0-9]` – Digit Range

match = re.search('[0-9]', 'abc123')
print(match.group())

Output: '1'

Explanation: Finds the first digit from the range 0–9.

`\\d, \\w, \\s` – Escape Sequences

text = 'User_123 logged in.'
print(re.search(r'\\d+', text).group())
print(re.search(r'\\w+', text).group())
print(re.search(r'\\s+', text).group())

Output:

'123' — first digit sequence
'User_123' — first word character group
' ' — first whitespace (space)

Conclusion

Regex becomes powerful when you master quantifiers, anchors, and wildcards. Using re.search() lets you pinpoint patterns efficiently. With practice, regex will become a critical tool in your text processing toolkit.

Regex Quantifiers, Anchors, and Wildcards Explained with Examples