Regular Expressions

import re

re.search(r"\d+", "abc 123")        # first match ANYWHERE, or None
re.match(r"\d+", "abc 123")         # anchored at the START only, here None
re.fullmatch(r"\d+", "123")         # the WHOLE string must match
re.findall(r"\d+", "a1 b22")        # ['1', '22'], list of strings
re.finditer(r"\d+", "a1 b22")       # iterator of Match objects, lazy
re.sub(r"\s+", " ", text)           # replace all, returns a new string
re.subn(r"a", "X", "aaa")           # ('XXX', 3), count included
re.split(r"[,;]\s*", "a, b;c")      # ['a', 'b', 'c']
re.escape("a.b*c")                  # 'a\\.b\\*c', literal-ize user input

pat = re.compile(r"^(\w+)=(\S+)$", re.M)    # compile once, reuse in a loop
pat.findall(config)
pat.search(line)

re.findall(r"<.+>", "<a><b>")       # ['<a><b>']   greedy, one big match
re.findall(r"<.+?>", "<a><b>")      # ['<a>', '<b>']  lazy, what you wanted
re.findall(r"<[^>]+>", "<a><b>")    # ['<a>', '<b>']  faster, no backtracking

# Capturing, non-capturing, named
re.search(r"(\d{4})-(\d{2})", s)              # numbered from 1
re.search(r"(?:https?)://(\S+)", s)           # (?: ) groups without capturing
m = re.search(r"(?P<year>\d{4})-(?P<mon>\d{2})", "on 2026-09-15")
m.group("year")                                # '2026'
re.sub(r"(?P<u>\w+)@(?P<h>\w+)", r"\g<h>:\g<u>", "me@host")   # 'host:me'

# Backreference: the same text twice
re.search(r"\b(\w+) \1\b", "the the cat")      # matches 'the the'

# Optional group is None, not ''
m = re.match(r"(\d+)(?:\.(\d+))?", "5")
m.groups()                                      # ('5', None)

# Lookahead and lookbehind consume nothing
re.findall(r"\d+(?= USD)", "5 USD 9 EUR")      # ['5']   positive lookahead
re.findall(r"\d+(?! USD)", "5 USD 9 EUR")      # ['9']  negative lookahead
re.findall(r"(?<=USD )\d+", "USD 42")          # ['42']  positive lookbehind
re.findall(r"(?<!USD )\d+", "EUR 42")          # ['42']  negative lookbehind

# Password-style checks stack lookaheads at position 0
re.fullmatch(r"(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{12,}", pw)

re.findall(r"^\w+", "one\ntwo", re.M)          # ['one', 'two']
re.search(r"a.c", "a\nc", re.S)                # matches
re.search(r"(?i)hello", "HELLO")               # inline, must be at the start
re.search(r"(?i:hello) world", s)              # scoped inline group (3.6+)
re.compile(r"\d+", re.I | re.M)                # combine with |

phone = re.compile(r"""
    (\d{3})      # area code
    [-.\s]?      # optional separator
    (\d{4})      # line number
""", re.VERBOSE)
phone.search("555-1234").groups()               # ('555', '1234')

m = re.search(r"(?P<y>\d{4})-(?P<m>\d{2})", "on 2026-09-15")

m.group()        m.group(0)     # '2026-09'   the whole match
m.group(1)       m.group("y")   # '2026'
m.group(1, 2)                   # ('2026', '09')
m.groups()                      # ('2026', '09')
m.groups(default="")            # replaces None for unmatched groups
m.groupdict()                   # {'y': '2026', 'm': '09'}
m.start(), m.end(), m.span()    # 3, 10, (3, 10)
m.span(1)                       # (3, 7)  per-group offsets
m.expand(r"\g<m>/\g<y>")        # '09/2026'
m.string, m.re, m.pos, m.lastindex, m.lastgroup

# Walrus keeps the None check tight (3.8+)
if (m := re.search(r"id=(\d+)", line)) is not None:
    record_id = int(m.group(1))

def double(m: re.Match) -> str:
    return str(int(m.group()) * 2)

re.sub(r"\d+", double, "a1 b22")               # 'a2 b44'
re.sub(r"\{(\w+)\}", lambda m: env[m.group(1)], template)

python -m pip install regex

import regex

regex.search(r"(?<=\w{1,5})x", s)          # VARIABLE-width lookbehind
regex.findall(r"\p{Greek}+", s)            # Unicode property classes
regex.search(r"(?r)\d+", s)                # reverse search
regex.findall(r"(\w)(?1)", s)              # subroutine call to group 1
regex.search(r"(?e)(cat){e<=1}", "cot")    # fuzzy matching, edit distance
regex.search(r"a+", huge, timeout=1.0)     # a real timeout

LOG = re.compile(
    r'^(?P<ip>\S+) \S+ \S+ \[(?P<ts>[^\]]+)\] '
    r'"(?P<method>\S+) (?P<path>\S+) [^"]*" (?P<status>\d{3}) (?P<size>\d+|-)$'
)
m = LOG.match(line)
m.groupdict()   # {'ip': '127.0.0.1', 'ts': '10/Oct/2026:13:55:36 -0700', ...}