Pattern Syntax Basics¶

Literal Characters¶

The simplest regex patterns are literal characters that match themselves exactly:

```python import re

re.search(r'cat', 'The cat sat on the mat')

¶

re.findall(r'at', 'The cat sat on the mat')

['at', 'at', 'at']¶

```

Most characters match themselves, but certain characters have special meaning in regex and must be escaped with a backslash to match literally.

Metacharacters¶

These characters have special meaning in regex:

. ^ $ * + ? { } [ ] \ | ( )

The Dot (.)¶

The dot matches any single character except a newline:

```python import re

re.findall(r'c.t', 'cat cot cut c\nt c9t')

['cat', 'cot', 'cut', 'c9t']¶

```

With re.DOTALL, the dot also matches newlines:

```python re.findall(r'c.t', 'cat c\nt', re.DOTALL)

['cat', 'c\nt']¶

```

Anchors (^ and $)¶

Anchors match positions, not characters:

```python import re

text = "hello world"

re.search(r'^hello', text) # Matches — 'hello' is at start re.search(r'^world', text) # None — 'world' is not at start re.search(r'world\(', text) # Matches — 'world' is at end re.search(r'hello\)', text) # None — 'hello' is not at end ```

With re.MULTILINE, ^ and $ match at the start/end of each line:

```python text = "first line\nsecond line\nthird line"

re.findall(r'^\w+', text) # ['first'] re.findall(r'^\w+', text, re.M) # ['first', 'second', 'third'] re.findall(r'\w+$', text, re.M) # ['line', 'line', 'line'] ```

Alternation (|)¶

The pipe acts as a logical OR:

```python import re

re.findall(r'cat|dog', 'I have a cat and a dog')

['cat', 'dog']¶

Alternation applies to the whole expression on each side¶

re.findall(r'gray|grey', 'gray and grey')

['gray', 'grey']¶

Use parentheses to limit alternation scope¶

re.findall(r'gr(a|e)y', 'gray and grey')

['a', 'e'] — returns captured groups!¶

Non-capturing group to get full match¶

re.findall(r'gr(?:a|e)y', 'gray and grey')

['gray', 'grey']¶

```

Escaping Metacharacters¶

To match a metacharacter literally, precede it with a backslash:

```python import re

Match a literal dot¶

re.findall(r'.', 'version 3.14.1')

['.', '.']¶

Match a literal dollar sign¶

re.search(r'$\d+', 'Price: $25')

¶

Match literal parentheses¶

re.search(r'\(.*?\)', 'func(arg)')

¶

```

You can also use re.escape() to escape all metacharacters in a string:

```python special = "price is $5.00 (USD)" escaped = re.escape(special) print(escaped)

price\ is\ $5.00\ \(USD\)¶

```

This is useful when building patterns from user input.

Shorthand Character Classes¶

These shortcuts match common character categories:

```python import re

text = "Agent 007 arrived at 14:30"

re.findall(r'\d+', text) # ['007', '14', '30'] re.findall(r'\w+', text) # ['Agent', '007', 'arrived', 'at', '14', '30'] re.findall(r'\s+', text) # [' ', ' ', ' ', ' '] ```

Word Boundary (\b)¶

\b matches the boundary between a word character and a non-word character (or start/end of string). It matches a position, not a character:

```python import re

text = "cat concatenate category"

re.findall(r'cat', text) # ['cat', 'cat', 'cat'] — matches inside words re.findall(r'\bcat\b', text) # ['cat'] — only the standalone word re.findall(r'\bcat', text) # ['cat', 'cat'] — words starting with 'cat' re.findall(r'cat\b', text) # ['cat', 'cat'] — words ending with 'cat' ```

Building Patterns Incrementally¶

Complex patterns are best built step by step:

```python import re

Goal: match a date like "2024-01-15"¶

Step 1: match four digits¶

r'\d{4}'

Step 2: add a hyphen and two digits¶

r'\d{4}-\d{2}'

Step 3: complete the pattern¶

r'\d{4}-\d{2}-\d{2}'

text = "Date: 2024-01-15, updated: 2024-12-31" re.findall(r'\d{4}-\d{2}-\d{2}', text)

['2024-01-15', '2024-12-31']¶

```

Summary¶

Exercises¶

Exercise 1. Write a regex pattern that matches a simple IP address format: four groups of 1-3 digits separated by dots (e.g., 192.168.1.1). Use the dot metacharacter properly (escaped). Test against "192.168.1.1", "256.1.1.1", and "10.0.0.1".

Exercise 2. Write a regex using alternation (|) that matches either "cat", "dog", or "bird" as whole words only. Test it against "I have a cat and a category" -- it should match "cat" but not the "cat" in "category".

Exercise 3. Write a regex that matches a simple Python variable name: starts with a letter or underscore, followed by zero or more letters, digits, or underscores. Test against "my_var", "_private", "2invalid", "class", and "hello_world_123".