Introduction

A lookahead is a regex assertion that checks whether a pattern is (or is not) followed by another pattern — without including that other pattern in the match. This "zero-width" behaviour makes lookaheads incredibly powerful for validating context, enforcing rules (like password requirements), and matching text based on its surroundings rather than just its own characters.

Real-World Analogy

Prerequisites

The Key Idea: Zero-Width

Normal tokens consume characters — they move the match position forward. Lookarounds are zero-width: they test a condition at the current position but do not advance or include anything in the result.

The Four Lookaround Assertions

Syntax Reference

Positive Lookahead (?=...)

Match a number only if it is followed by "USD".

import re

text = "100USD 200EUR 300USD"
# \d+ that is followed by "USD" — but "USD" is NOT captured
matches = re.findall(r"\d+(?=USD)", text)
print(matches)   # ['100', '300']

Negative Lookahead (?!...)

Match a number only if it is NOT followed by "USD".

import re

text = "100USD 200EUR 300USD"
matches = re.findall(r"\d+(?!USD)", text)
print(matches)   # ['200'] and partial digits — see note below

import re

# Safer: whole numbers not followed by USD
text = "100USD 200EUR 300USD"
matches = re.findall(r"\b\d+\b(?!USD)", text)
print(matches)   # ['200']

Lookbehind (?<=...) and (?<!...)

Match text based on what comes before it.

import re

text = "$100 and €200 and $300"

# Positive lookbehind: numbers preceded by "$"
dollars = re.findall(r"(?<=\$)\d+", text)
print(dollars)   # ['100', '300']

# Negative lookbehind: numbers NOT preceded by "$"
non_dollars = re.findall(r"(?<!\$)\b\d+", text)
print(non_dollars)   # ['200']

Classic Use Case: Password Validation

Multiple lookaheads stacked at the start check several independent rules at once.

import re

# Rules: at least 8 chars, one digit, one uppercase, one lowercase
pattern = r"^(?=.*\d)(?=.*[A-Z])(?=.*[a-z]).{8,}$"

def is_strong(pw):
    return bool(re.match(pattern, pw))

print(is_strong("Abc12345"))   # True
print(is_strong("abc12345"))   # False (no uppercase)
print(is_strong("Abcdefg"))    # False (no digit, too short)

Practical: Thousands Separators

Lookahead can insert commas into large numbers.

import re

number = "1234567"
# Insert a comma at every position followed by groups of 3 digits
formatted = re.sub(r"\d(?=(\d{3})+$)", r"\g<0>,", number)
print(formatted)   # 1,234,567

Zero-Width Formally

If a normal token consumes a substring of length \(L > 0\), a lookaround consumes \(L = 0\). So after evaluating a lookaround at position \(p\), the match position stays fixed:

\[ p_{\text{after}} = p_{\text{before}} \quad\text{(width } = 0\text{)} \]

This is exactly why you can stack several lookaheads at the same spot — none of them move the cursor.

Best Practices

Common Mistakes

Interview Questions

Quick Revision