Python - Regex Predefined Character Classes

Python Regular Expressions provide several Predefined Character Classes.

These classes are already defined with special meanings, so we do not need to manually write large Character Classes every time.

The important Predefined Character Classes are:

s
S
d
D
w
W
.
        

Simple Definition:

Predefined Character Classes are special Regular Expression symbols that represent commonly used groups of characters.

For example:

d → Any digit

w → Any word character

s → Any whitespace character
        

Pattern	Meaning
s	Space character / whitespace character
S	Any character except whitespace
d	Any digit from 0 to 9
D	Any character except a digit
w	Any word character — alphanumeric character or underscore
W	Any character except a word character
.	Any character, including special characters, except newline by default

The Predefined Character Class:

s
        

represents a whitespace character.

It can match whitespace characters such as:

• Space
• Tab
• Newline

For the document's target string:

a7b k@9z
        

there is one space character.

a 7 b   k @ 9 z
      ↑
    Space
        

Therefore, s matches that space.

Consider the target string:

Character : a 7 b   k @ 9 z
Index     : 0 1 2 3 4 5 6 7
        

At index 3, we have a space.

Since s represents whitespace:

Index 3 → Space → Match
        

Hence the output contains the match at index 3.

The matched value may look blank because the actual matched character itself is a space.

3 ...

The Predefined Character Class:

S
        

means:

Any character except a whitespace character.

It is the opposite of s.

s → Whitespace

S → Non-whitespace
        

For:

a7b k@9z
        

every character except the space at index 3 matches.

The target string contains one whitespace character at index 3.

0 → a → Match
1 → 7 → Match
2 → b → Match
3 →   → No Match
4 → k → Match
5 → @ → Match
6 → 9 → Match
7 → z → Match
        

Therefore, every character except the space is returned.

0 ... a
1 ... 7
2 ... b
4 ... k
5 ... @
6 ... 9
7 ... z

The Predefined Character Class:

d
        

represents a digit.

For basic ASCII digits, it corresponds to:

[0-9]
        

That means:

0
1
2
3
4
5
6
7
8
9
        

For the target:

a7b k@9z
        

the digits are:

7
9
        

Check the target string:

Character : a 7 b   k @ 9 z
Index     : 0 1 2 3 4 5 6 7
        

The digit characters are:

7 → index 1
9 → index 6
        

1 ... 7
6 ... 9

The Predefined Character Class:

D
        

means:

Any character except a digit.

It is the opposite of d.

d → Digit

D → Non-digit
        

Therefore, letters, spaces and special characters can match D.

The digits 7 and 9 do not match.

All remaining characters match:

a
b
space
k
@
z
        

Therefore:

0 → a
2 → b
3 → space
4 → k
5 → @
7 → z
        

0 ... a
2 ... b
3 ...
4 ... k
5 ... @
7 ... z

The Predefined Character Class:

w
        

represents a word character.

For the basic examples in this tutorial, it includes:

• Alphabet symbols
• Digits
• Underscore _

It can be remembered approximately as:

[a-zA-Z0-9_]
        

For:

a7b k@9z
        

the matching characters are:

a
7
b
k
9
z
        

The space and @ do not match.

Check every character:

Index	Character	Type	Match?
0	a	Alphabet	Yes
1	7	Digit	Yes
2	b	Alphabet	Yes
3	Space	Whitespace	No
4	k	Alphabet	Yes
5	@	Special Character	No
6	9	Digit	Yes
7	z	Alphabet	Yes

Important Note: For simple English examples, we commonly remember:

w ≈ [a-zA-Z0-9_]
        

But in Python 3, w is Unicode-aware by default.

So it can also match many Unicode letters and numbers, not only English A-Z and a-z.

For the examples in this tutorial, remembering letters + digits + underscore is sufficient.

0 ... a
1 ... 7
2 ... b
4 ... k
6 ... 9
7 ... z

The Predefined Character Class:

W
        

means:

Any character except a word character.

It is the opposite of w.

w → Word Character

W → Non-word Character
        

For the current target, the non-word characters are:

Space
@
        

The following characters are word characters:

a
7
b
k
9
z
        

Therefore, they do not match W.

The remaining characters are:

Index 3 → Space
Index 5 → @
        

Both are non-word characters and therefore match.

3 ...
5 ... @

The dot:

.
        

is a special Predefined Character Class.

By default, it matches:

Any character except a newline character.

It can match:

• Alphabet characters
• Digits
• Spaces
• Special characters

For the target:

a7b k@9z
        

all eight characters match.

The target does not contain a newline.

Therefore, every character is matched:

0 → a
1 → 7
2 → b
3 → space
4 → k
5 → @
6 → 9
7 → z
        

This demonstrates that dot is a very broad pattern.

Important Note About Dot:

Normally:

.
        

does not match a newline character.

Example:

A
B
        

If the target contains an actual newline between A and B, normal dot matching skips that newline.

Python can change this behaviour by using the re.DOTALL flag, but that advanced option is not required for understanding the basic predefined Character Class.

0 ... a
1 ... 7
2 ... b
3 ...
4 ... k
5 ... @
6 ... 9
7 ... z

The following is the complete demo program used for every Predefined Character Class in this section.

No output captured.

We can use the same program and change only the Regular Expression.

Start with:

matcher = re.finditer("\s", "a7b k@9z")
        

Then test:

s
S
d
D
w
W
.
        

The target string remains:

a7b k@9z
        

This makes it easy to compare the behaviour of all Predefined Character Classes.

The output for every pattern is:

Pattern: s

3 ...
        

---

Pattern: S

0 ... a
1 ... 7
2 ... b
4 ... k
5 ... @
6 ... 9
7 ... z
        

---

Pattern: d

1 ... 7
6 ... 9
        

---

Pattern: D

0 ... a
2 ... b
3 ...
4 ... k
5 ... @
7 ... z
        

---

Pattern: w

0 ... a
1 ... 7
2 ... b
4 ... k
6 ... 9
7 ... z
        

---

Pattern: W

3 ...
5 ... @
        

---

Pattern: .

0 ... a
1 ... 7
2 ... b
3 ...
4 ... k
5 ... @
6 ... 9
7 ... z
        

The target string used in this section is:

a7b k@9z
        

Index	Character	Type
0	a	Alphabet / Word / Non-space / Non-digit
1	7	Digit / Word / Non-space
2	b	Alphabet / Word / Non-space / Non-digit
3	Space	Whitespace / Non-word / Non-digit
4	k	Alphabet / Word / Non-space / Non-digit
5	@	Special / Non-word / Non-space / Non-digit
6	9	Digit / Word / Non-space
7	z	Alphabet / Word / Non-space / Non-digit

Several Predefined Character Classes occur in opposite pairs.

Pattern	Meaning	Opposite	Opposite Meaning
s	Whitespace	S	Non-whitespace
d	Digit	D	Non-digit
w	Word character	W	Non-word character

A useful memory rule is:

Lowercase → Matches that category
Uppercase → Opposite of that category

s ↔ S
d ↔ D
w ↔ W
        

Character Class	Related Predefined Class	Meaning in Basic Examples
[0-9]	d	Digit
[^0-9]	D	Non-digit
[a-zA-Z0-9_]	w	Word character
[^a-zA-Z0-9_]	W	Non-word character

Note: Python's default Unicode behaviour means d and w can match more Unicode characters than the simple ASCII ranges shown above. The ranges are useful for understanding the introductory examples.

Pattern	Meaning	Matches in a7b k@9z
s	Whitespace	Space
S	Except whitespace	a, 7, b, k, @, 9, z
d	Digit	7, 9
D	Except digit	a, b, Space, k, @, z
w	Word character	a, 7, b, k, 9, z
W	Except word character	Space, @
.	Any character except newline by default	Every character in this target

Consider:

import re

matcher = re.finditer("\d", "a7b k@9z")

for match in matcher:
    print(match.start(), "...", match.group())
        

Step 1:

import re
        

imports the Regular Expression module.

Step 2:

re.finditer("\d", "a7b k@9z")
        

searches the target for characters matching d.

Step 3:

Python checks the target from left to right.

a → No
7 → Yes
b → No
space → No
k → No
@ → No
9 → Yes
z → No
        

Step 4:

For every successful match, finditer() provides a Match Object.

Step 5:

match.start()
        

returns the starting index.

Step 6:

match.group()
        

returns the actual matched character.

Therefore:

1 ... 7
6 ... 9
        

Program Starts
      │
      ▼
Import re
      │
      ▼
Select Predefined
Character Class
      │
      │
      ├── s
      ├── S
      ├── d
      ├── D
      ├── w
      ├── W
      └── .
      │
      ▼
Target String
"a7b k@9z"
      │
      ▼
re.finditer()
      │
      ▼
Start from Index 0
      │
      ▼
Check Current Character
Against Pattern
      │
   ┌──┴───┐
   │      │
 Match   No Match
   │      │
   ▼      ▼
Create   Continue
Match    Searching
Object
   │
   ▼
match.start()
match.group()
   │
   ▼
Print Result
   │
   ▼
Move to Next Character
   │
   ▼
Repeat Until
End of String
   │
   ▼
Program Ends
        

Execution Example with d:

Pattern = d
Target  = a7b k@9z

             Start
               │
               ▼
Index 0 → a → No Match
               │
               ▼
Index 1 → 7 → Match
               │
               ▼
          Print 1 ... 7
               │
               ▼
Index 2 → b → No Match
               │
               ▼
Index 3 → Space → No Match
               │
               ▼
Index 4 → k → No Match
               │
               ▼
Index 5 → @ → No Match
               │
               ▼
Index 6 → 9 → Match
               │
               ▼
          Print 6 ... 9
               │
               ▼
Index 7 → z → No Match
               │
               ▼
              End
        

s → Space / Whitespace

S → Except Space / Whitespace


d → Digit

D → Except Digit


w → Word Character

W → Except Word Character


.  → Any Character Except Newline by Default
        

Remember the three important opposite pairs:

s ↔ S

d ↔ D

w ↔ W