Python re.fullmatch() Method Explained

The re.fullmatch() method checks if the entire string matches the regular expression pattern. It returns a match object if the whole string matches, or None if it doesn’t.

Syntax

python

re.fullmatch(pattern, string, flags=0)

import re

# Target string
string = "The Euro STOXX 600 index, which tracks all stock markets across Europe including the FTSE, fell by 11.48% – the worst day since it launched in 1998. The panic selling prompted by the coronavirus has wiped £2.7tn off the value of STOXX 600 shares since its all-time peak on 19 February."

# Source: https://www.theguardian.com/

# Check if the entire string has exactly 285 characters
result = re.fullmatch(r".{285}", string)

print(f"String length: {len(string)} characters")
print(f"re.fullmatch result: {result}")

if result:
    print("✓ The string has exactly 285 characters")
else:
    print("✗ The string does NOT have exactly 285 characters")

# Display the actual matched portion (if any)
if result:
    print(f"\nMatched text: '{result.group()}'")

Output:

text

String length: 285 characters
re.fullmatch result: <re.Match object; span=(0, 285), match='The Euro STOXX 600 index, which tracks all stock >

✓ The string has exactly 285 characters

Matched text: 'The Euro STOXX 600 index, which tracks all stock markets across Europe including the FTSE, fell by 11.48% – the worst day since it launched in 1998. The panic selling prompted by the coronavirus has wiped £2.7tn off the value of STOXX 600 shares since its all-time peak on 19 February.'

In the code re.fullmatch(r".{285}", string), the dot (.) is a special regex character that matches any character except a newline (unless the re.DOTALL flag is used).

What r".{285}" means:

• . – Matches any single character (except newline by default)
• {285} – Specifies exactly 285 occurrences of the preceding element
• So .{285} means “exactly 285 of any characters”

Python re.fullmatch() Method Explained

The re.fullmatch() method checks if the entire string matches the regular expression pattern. It returns a match object if the whole string matches, or None if it doesn’t.

Syntax

python

re.fullmatch(pattern, string, flags=0)

Example 1: Validating Email Format

python

import re

# Validate email format
emails = ["user@example.com", "invalid-email", "name@domain.co.uk", "short@a.b"]

for email in emails:
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    match = re.fullmatch(pattern, email)
    
    if match:
        print(f"✓ Valid email: {email}")
    else:
        print(f"✗ Invalid email: {email}")

Let me break down this email validation regex pattern piece by piece:

Pattern: r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
1. ^ - Start of string anchor
Ensures the pattern matches from the very beginning

2. [a-zA-Z0-9._%+-]+ - Local part (before @)
[a-zA-Z0-9._%+-] - Character class matching:

Letters: a-z, A-Z

Digits: 0-9

Special characters: ., _, %, +, -

+ - One or more of these characters

3. @ - Literal @ symbol
Must contain exactly one @ symbol

4. [a-zA-Z0-9.-]+ - Domain name (after @)
[a-zA-Z0-9.-] - Character class matching:

Letters: a-z, A-Z

Digits: 0-9

Special characters: ., -

+ - One or more of these characters

5. \. - Literal dot (escaped)
The dot before TLD (must be escaped with \ because . is a regex metacharacter)

6. [a-zA-Z]{2,} - Top Level Domain (TLD)
[a-zA-Z] - Only letters allowed in TLD

{2,} - Two or more characters (e.g., .com, .org, .io)

7. $ - End of string anchor
Ensures the pattern matches to the very end

What this pattern validates:
text
username@domain.tld
Examples that match:
user@example.com

first.last@company.co.uk

name123@sub.domain.org

user_name+filter@domain.io

Examples that DON'T match:
user@com (TLD too short)

user@.com (domain part empty)

@domain.com (local part missing)

user@domain. (TLD missing)

user@domain.c (TLD too short)

user@-domain.com (hyphen at start of domain)

Visual Breakdown:
text
^[a-zA-Z0-9._%+-]+ @ [a-zA-Z0-9.-]+ \. [a-zA-Z]{2,} $
 │                  │ │               │ │             │
 │                  │ │               │ │             └── End of string
 │                  │ │               │ └── TLD (2+ letters)
 │                  │ │               └── Literal dot
 │                  │ └── Domain name (hostname)
 │                  └── Literal @ symbol
 └── Local part (username)
This is a commonly used email validation pattern that covers most standard email formats while being relatively strict about the structure.

Output:

text

✓ Valid email: user@example.com
✗ Invalid email: invalid-email
✓ Valid email: name@domain.co.uk
✗ Invalid email: short@a.b

Example 2: Password Validation

python

import re

# Validate password: 8+ chars, at least one uppercase, one lowercase, one digit, one special char
passwords = ["StrongP@ss1", "weak", "NoSpecialChar123", "Valid#Pass99"]

for pwd in passwords:
    pattern = r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$'
    match = re.fullmatch(pattern, pwd)
    
    if match:
        print(f"✓ Strong password: {pwd}")
    else:
        print(f"✗ Weak password: {pwd}")

Output:

text

✓ Strong password: StrongP@ss1
✗ Weak password: weak
✗ Weak password: NoSpecialChar123
✓ Strong password: Valid#Pass99

Example 3: Date Format Validation

python

import re

# Validate dates in YYYY-MM-DD format
dates = [
    "2023-12-25",
    "2023-02-30",  # Invalid date (February 30th)
    "23-12-25",    # Wrong format
    "2023-13-01",  # Invalid month
    "2023-12-25 extra"  # Extra characters
]

for date in dates:
    pattern = r'^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$'
    match = re.fullmatch(pattern, date)
    
    if match:
        print(f"✓ Valid date format: {date}")
    else:
        print(f"✗ Invalid date format: {date}")

Output:

text

✓ Valid date format: 2023-12-25
✓ Valid date format: 2023-02-30  # Note: Pattern validates format, not actual date validity
✗ Invalid date format: 23-12-25
✗ Invalid date format: 2023-13-01
✗ Invalid date format: 2023-12-25 extra

Key Differences from Other Methods

• re.fullmatch(): Entire string must match pattern
• re.match(): Pattern must match from the beginning of string
• re.search(): Pattern can match anywhere in the string

python

import re

text = "abc123def"
pattern = r'\d+'

print("fullmatch:", re.fullmatch(pattern, text))  # None (entire string isn't digits)
print("match:", re.match(pattern, text))         # None (doesn't start with digits)
print("search:", re.search(pattern, text))       # Match object (finds '123')

The re.fullmatch() method is particularly useful for validation tasks where you need to ensure the entire input conforms to a specific pattern.