Regex Cheat Sheet

Regular expressions are a universal pattern-matching syntax built into every major programming language, text editor, and command-line tool. This reference sheet is designed to be scanned, not read — keep it open next to your editor.

Character Classes & Metacharacters

A character class matches exactly one character from a defined set. Metacharacters are symbols with special meaning inside a pattern.

import re

re.findall(r'\d+', 'Order 42, item 7')
## => ['42', '7']

re.findall(r'\w+', 'hello_world 123')
## => ['hello_world', '123']

re.findall(r'[aeiou]+', 'beautiful')
## => ['eau', 'i', 'u']

re.findall(r'[^a-zA-Z0-9]+', 'hello, world! 42')
## => [', ', '! ']

Anchors & Boundaries

Anchors assert a position in the string — they consume no characters.

text = "apple\nbanana\napricot"

re.findall(r'^a\w+', text, re.MULTILINE)
## => ['apple', 'apricot']

re.findall(r'\bcat\b', 'the cat in scatter')
## => ['cat']  — 'cat' inside 'scatter' is not matched

re.findall(r'\Aapple', text, re.MULTILINE)
## => ['apple']  — only the absolute start of the string

bool(re.fullmatch(r'\d{5}', '90210'))   ## => True
bool(re.fullmatch(r'\d{5}', 'ABC'))     ## => False

Quantifiers: Greedy and Lazy

Quantifiers control how many times the preceding element repeats. Greedy quantifiers consume as much input as possible; lazy (non-greedy) quantifiers consume as little as possible.

text = '<b>bold</b> and <i>italic</i>'

re.findall(r'<.+>', text)
## => ['<b>bold</b> and <i>italic</i>']   — greedy, one giant match

re.findall(r'<.+?>', text)
## => ['<b>', '</b>', '<i>', '</i>']   — lazy, each tag separately

re.findall(r'\b\d{2,4}\b', 'a 5 b 12 c 1234 d 99999')
## => ['12', '1234']

re.findall(r'https?://\S+', 'Visit http://a.com or https://b.com')
## => ['http://a.com', 'https://b.com']

Groups, Capturing & Backreferences

Groups let you apply quantifiers to multi-character sequences, capture submatches, and refer back to earlier matches in the same pattern or in a replacement string.

pattern = r'(?P<protocol>https?)://(?P<domain>[^/]+)(?P<path>/[^\s]*)?'
m = re.match(pattern, 'https://devnook.dev/guides/')
m.group('protocol')  ## 'https'
m.group('domain')    ## 'devnook.dev'
m.group('path')      ## '/guides/'

re.findall(r'\b(\w+)\s+\1\b', 'the the quick brown fox fox')
## => ['the', 'fox']   — repeated words

re.findall(r'colo(?:u|)r', 'colour and color')
## => ['colour', 'color']   — alternation in non-capturing group

re.sub(r'(\w+)\s+(\w+)', r'\2 \1', 'John Smith')
## => 'Smith John'   — swap groups in replacement

Lookaheads & Lookbehinds

Lookarounds are zero-width assertions — they check what surrounds the current position without consuming any characters.

re.findall(r'\d+(?=px)', '12px 5em 100px 3rem')
## => ['12', '100']   — digits followed by 'px', 'px' not captured

re.findall(r'new(?!line)', 'newline and new feature')
## => ['new']   — 'new' not followed by 'line'

re.findall(r'(?<=name=)\w+', 'id=42 name=alice role=admin')
## => ['alice']

re.findall(r'(?<!no )error', 'no error here; another error exists')
## => ['error']   — only the second occurrence

re.findall(r'(?<=\$)\d+(?=\s*USD)', '$100 USD and $50 EUR')
## => ['100']   — combined lookahead + lookbehind

Regex Flags

Flags (also called modifiers) alter how the engine interprets the entire pattern. Combine multiple flags with | in Python, or use inline (?imsx) syntax to embed them inside the pattern itself.

re.findall(r'(?i)hello', 'Hello HELLO hello')
## => ['Hello', 'HELLO', 'hello']   — inline case-insensitive flag

text = "Error: disk full\nerror: timeout\nWARN: retrying"
re.findall(r'^error:.+$', text, re.IGNORECASE | re.MULTILINE)
## => ['Error: disk full', 'error: timeout']

date_re = re.compile(r"""
    (?P<year>\d{4})            (?# 4-digit year)
    -
    (?P<month>0[1-9]|1[0-2])  (?# month 01-12)
    -
    (?P<day>0[1-9]|[12]\d|3[01])  (?# day 01-31)
""", re.VERBOSE)

date_re.match('2026-06-09').groupdict()
## => {'year': '2026', 'month': '06', 'day': '09'}

'Hello HELLO hello'.match(/hello/gi);
// => ['Hello', 'HELLO', 'hello']

const { groups: { year, month, day } } =
  '2026-06-09'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
// year='2026', month='06', day='09'

const sticky = /\d+/y;
sticky.lastIndex = 7;
sticky.exec('Order: 42');
// => ['42']  — matched exactly at index 7

Common Regex Patterns

Production-ready patterns for frequent validation and extraction tasks. Paste them into the Java Regex Tester — Free Online Tool to verify matches before shipping.

import re

email_re = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
email_re.match('user@example.com')  ## => Match object
email_re.match('not-an-email')      ## => None

css = "color: #fff; background: #1a2b3c; border: 1px solid #aabbcc;"
re.findall(r'#(?:[0-9a-fA-F]{3}){1,2}\b', css)
## => ['#fff', '#1a2b3c', '#aabbcc']

changelog = "Released v1.2.3; fixed bug from v1.2.1; target is v2.0.0"
re.findall(r'\bv?\d+\.\d+\.\d+\b', changelog)
## => ['v1.2.3', 'v1.2.1', 'v2.0.0']

Regex in Python: re Module Reference

The Python re module is the standard library’s full regex API. Always use raw strings (r'…') for patterns to avoid double-escaping backslashes.

import re

text = "2026-06-09: Released version 2.1.4"

for m in re.finditer(r'\d+', text):
    print(f"'{m.group()}' at {m.span()}")
## '2026' at (0, 4)
## '06' at (5, 7)  ... etc.

def bump(m):
    return str(int(m.group()) + 1)

re.sub(r'\b\d+\b', bump, 'a=1 b=2 c=3')
## => 'a=2 b=3 c=4'

re.split(r'[,;\s]+', 'one, two;three  four')
## => ['one', 'two', 'three', 'four']

slug_re = re.compile(r'^[a-z0-9]+(?:-[a-z0-9]+)*$')
[s for s in ['hello-world', 'Bad Slug', 'ok-123'] if slug_re.match(s)]
## => ['hello-world', 'ok-123']

For more Python string operations that complement regex, see Python String Methods Cheat Sheet: split, join, replace & More.

Regex in JavaScript

JavaScript regex uses literal syntax /pattern/flags or new RegExp('pattern', 'flags'). The MDN Regular Expressions guide covers every detail of the spec.

// Named groups (ES2018+) with destructuring
const dateRe = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const { groups: { year, month, day } } = '2026-06-09'.match(dateRe);
// year='2026', month='06', day='09'

// replaceAll with a transform function (requires /g)
const result = 'a=1, b=2, c=3'.replace(/(\w+)=(\d+)/g, (_, k, v) => `${k}=${+v * 10}`);
// => 'a=10, b=20, c=30'

// matchAll: iterate all matches and extract groups
const str = 'cat bat hat mat';
const matches = [...str.matchAll(/(?<word>[cbhm]at)/g)];
matches.map(m => m.groups.word);
// => ['cat', 'bat', 'hat', 'mat']

// test() for fast boolean validation
const emailRe = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
emailRe.test('user@example.com');  // true
emailRe.test('not-an-email');      // false

For a deeper look at JavaScript’s native regex capabilities, see What is Regex Pattern Checking in JavaScript?. If you use regex in shell scripts or with CLI tools like grep, sed, and awk, the Linux Commands Cheat Sheet has the flags and syntax for POSIX and extended regex modes.

Escaping Special Characters

These characters carry special meaning in regex syntax and must be escaped with a backslash when you want to match them literally.

import re

re.escape('3.14 * x^2')
## => '3\\.14\\ \\*\\ x\\^2'

pattern = re.compile(re.escape('3.14 * x^2'))
pattern.search("result: 3.14 * x^2 + 1")
## => Match object — safe to use with user-supplied text

def is_valid_regex(s):
    try:
        re.compile(s)
        return True
    except re.error:
        return False

is_valid_regex(r'\d+')       ## => True
is_valid_regex(r'[unclosed') ## => False