import re

# Find first match anywhere
re.search(pattern, string)

# Match only at start
re.match(pattern, string)

# Return all matches
re.findall(pattern, string)

# Iterator of match objects
re.finditer(pattern, string)

# Replace matches
re.sub(pattern, repl, string)

# Precompile pattern for reuse
pattern = re.compile('pattern')

• Literal characters match themselves exactly
• Case-sensitive by default (use re.IGNORECASE for ignoring case)
• Some characters have special meaning and need escaping
• Raw strings (r'pattern') are preferred to avoid double escaping

re.search('cat', 'concatenate')  # matches 'cat'

• Dot (.) matches any character except newline by default
• Caret (^) anchors the start of string or line
• Dollar ($) anchors the end of string or line
• Pipe (|) acts as OR, low precedence; use parentheses for grouping

re.search(r'world$', 'Hello world')
re.search(r'world$', 'world\nhello', re.M)

• Always use raw strings
• Prefer explicit anchors (^, $)
• Use re.compile() for reuse
• Be mindful of flag interactions (re.M, re.S)
• Order alternations from longest to shortest

• [abc] — matches one character that is a, b, or c
• [a-z], [A-Z], [0-9] — matches characters in the specified range
• [a-zA-Z0-9_] — matches letters, digits, and underscore (similar to \w)
• [^abc] — matches any character except a, b, or c

re.findall(r'[abc]', 'cat')  # ['c', 'a']
re.findall(r'[0-9]', 'Age: 25')  # ['2', '5']
re.findall(r'[^abc]', 'abcXYZ')  # ['X', 'Y', 'Z']

• \d → digit (0–9), \D → non-digit
• \w → letters, digits, underscore ([a-zA-Z0-9_]), \W → non-word characters
• \s → whitespace (space, tab, newline), \S → non-whitespace
• Unicode vs ASCII: By default Python regex is Unicode-aware; re.ASCII restricts to ASCII-only

re.findall(r'\d', 'Room 42')  # ['4', '2']
re.findall(r'\w', 'Hi!')  # ['H', 'i']
re.findall(r'\s', 'A B\nC')  # [' ', '\n']
re.findall(r'\w', 'café', re.ASCII)  # ['c', 'a', 'f']

• Hyphen (-) at start or end → literal hyphen, in the middle → range indicator
• Escaping needed inside [ ]: ], \, ^ (if first), - (if used as range)
• . matches any character except newline
• [\s\S] matches everything, including newline (useful for multi-line matching)

re.findall(r'[-a-z]', 'abc-')  # ['a', 'b', 'c', '-']
re.findall(r'[a-z-]', 'abc-')  # ['a', 'b', 'c', '-']
re.findall(r'[\[\]\\]', '[]\\')  # ['[', ']', '\\']
re.findall(r'[\s\S]', 'A\nB')  # ['A', '\n', 'B']

• * → 0 or more occurrences (e.g., a* matches '', 'a', 'aaa')
• + → 1 or more occurrences (e.g., a+ matches 'a', 'aaa', not empty)
• ? → 0 or 1 occurrence (optional, e.g., colou?r matches 'color' or 'colour')
• {n} → exactly n times (e.g., \d{4} matches 4 digits)
• {n,} → at least n times (e.g., \d{2,} matches 2 or more digits)
• {n,m} → between n and m times (e.g., \d{2,4} matches 2 to 4 digits)

re.findall(r'a*', 'aaab')  # ['', 'aaa', '']
re.findall(r'a+', 'aaab')  # ['aaa']
re.findall(r'colou?r', 'color colour')  # ['color', 'colour']
re.findall(r'\d{4}', 'Year: 2025')  # ['2025']
re.findall(r'\d{2,}', '42 123')  # ['42', '123']
re.findall(r'\d{2,4}', '1 12 123 12345')  # ['12', '123', '1234']

• Greedy quantifiers (default) try to match as much as possible (.*)
• Lazy quantifiers (minimal match) use ? (.*?), matches as little as possible
• Common trap: greedy .* can match too much (e.g., <.*> matches entire content, use <.*?> for individual tags)

text = 'onetwo'
re.findall(r'<.*?>', text)  # ['', '', '', '']
re.findall(r'<.*>', text)  # ['onetwo']

• Possessive quantifiers match as much as possible and do NOT backtrack
• Python does NOT support possessive quantifiers natively
• Atomic groups (?>...) simulate possessive behavior: once matched, characters are not given back
• Improves performance in complex patterns

re.findall(r'(?>\d+)', '123 456')  # simulates possessive behavior in Python

• ^ → matches the start of a string (or line with re.MULTILINE)
• $ → matches the end of a string (or line with re.MULTILINE)

re.findall(r'^Hello', 'Hello World')  # ['Hello']
re.findall(r'World$', 'Hello World')  # ['World']

# Multiline behavior
text = 'Hello\nWorld'
re.findall(r'^World', text, re.MULTILINE)  # ['World']

• \b → matches a word boundary (between \w and \W)
• \B → matches a position that is not a word boundary
• Python regex handles Unicode characters as part of \w, so accented letters are included
• Common pitfall: digits and underscore are considered \w, so \b behaves accordingly

re.findall(r'\bcat\b', 'concatenate cat')  # ['cat']
re.findall(r'\bvar1\b', 'var1_var2')  # ['var1']

• Parentheses () capture matched content
• Groups are numbered by order of opening parentheses
• Nested groups get their own numbers

match = re.match(r'(\w+) (\w+)', 'Hello World')
match.groups()  # ('Hello', 'World')

• (?:pattern) groups for structuring regex without capturing
• Improves performance and clarity when capturing is unnecessary

re.findall(r'(?:cat|dog)s?', 'cats dog')  # ['cats', 'dog']

• (?Ppattern) assigns a name to a group for readability
• Access matched groups via groupdict()
• Easier to read and maintain, avoids confusion with group numbers in complex patterns

match = re.match(r'(?P\w+) (?P\w+)', 'John Doe')
match.groupdict()  # {'first': 'John', 'last': 'Doe'}

• Backreferences refer to a previously matched group
• Enable pattern reuse in regex for repeated structures

• Numeric backreferences: \1, \2, etc., refer to captured groups by number
• Named backreferences: (?P...) to capture, (?P=name) to refer by name

re.findall(r'(\w+)\s\1', 'hello hello world')  # ['hello']
re.findall(r'(?P\w+)\s(?P=word)', 'foo foo bar')  # ['foo']

• Detect repeated words: (\w+)\s\1
• Match symmetrical patterns: (\d)(\d)\2\1 (e.g., 1221)
• Validate paired characters: (["']).*?\1 (quotes, brackets)

• Lookarounds assert context without consuming characters
• Positive lookahead: (?=pattern) — pattern must follow
• Negative lookahead: (?!pattern) — pattern must not follow
• Positive lookbehind: (?<=pattern) — pattern must precede
• Negative lookbehind: (?
• Python limitation: Lookbehind patterns must be fixed-width

re.findall(r'\w+(?=\d)', 'item1 item2')  # ['item', 'item']
re.findall(r'\w+(?!\d)', 'item1 itemX')  # ['itemX']

re.findall(r'(?<=\$)\d+', 'Price: $100')  # ['100']

• Password validation: (?=.*[A-Z])(?=.*\d).{8,} (At least 8 characters, one uppercase, one digit)
• Conditional matching: use lookarounds to match only if another pattern exists
• Excluding substrings without consuming text: useful in context-sensitive text processing

• Use re.compile(pattern, flags=0) to precompile regex for repeated use
• Benefits: Performance (parsed once), Reusability (store pattern), Readability (centralized complex patterns)

pattern = re.compile(r'\d+', re.I)
pattern.search('123abc')  # correct
pattern.findall('12, 34') # correct

# Reusable compiled pattern
digits = re.compile(r'\d+')
numbers = [digits.findall(s) for s in ['abc12', '34def']]
# [['12'], ['34']]

• .group(0) is the same as .group()
• .groups() returns all captured groups; unmatched optional groups → None
• .groupdict() requires named groups (?P...)
• .span() is often asked in string slicing problems

• Use non-greedy quantifiers when parsing structured text.
• Use lookaheads/lookbehinds for complex validations.
• Understand regex limitations—interviewers often ask this.
• Always test edge cases, e.g., optional fields, unusual input.
• Explain why your pattern works—not just the code.

• Break problem into smaller matching units
• Example: Log line → [timestamp][level][message] → build regex component by component

• Identify literals first
• Identify variable parts → use character classes / quantifiers
• Add anchors (^, $) or word boundaries
• Wrap in capturing or named groups
• Test each step incrementally

• Always build regex iteratively
• Explain thought process, not just code
• Avoid shortcuts that break readability or correctness
• Know limitations of regex; use parsing libraries when appropriate
• Include unit tests or example cases when possible