Validate an Entire Python Reference Code with re.fullmatch Instead of search

Use re.fullmatch when a Python input field must contain exactly one reference code. A successful re.search only establishes that matching text occurs somewhere in the input; it can accept a valid-looking fragment surrounded by unwanted characters. Whole-string matching closes that particular gap, but it does not establish that a reference exists or belongs to the person submitting it.

Consider a deliberately invented internal format: two uppercase ASCII letters, a hyphen, and four ASCII digits. Under this rule, AB-1234 is valid, while a sentence containing that code is not. This is a format exercise, not a real organisation’s identifier specification.

Define the field contract before writing the expression

Write down whether the field permits spaces, lowercase letters, alternate punctuation, or non-ASCII characters. For this example, none are accepted. The rule is exact and rejects leading or trailing whitespace instead of silently normalising it. That choice makes the validation result predictable and keeps the submitted value available for diagnosis.

The pattern [A-Z]{2}-[0-9]{4} implements the invented structure. Explicit [0-9] is intentional: Python’s Unicode string patterns give \d a broader meaning that includes Unicode decimal digits. Use the character set required by your actual contract rather than assuming every digit notation is equivalent.

Run a complete, non-destructive example

Save this example as a disposable Python file and run it with Python 3. It reads no files, contacts no services, and changes no configuration. The function returns a Boolean result for a candidate value, including values that are not strings.

import re

REFERENCE = re.compile(r"[A-Z]{2}-[0-9]{4}")

def valid_reference(value):
    return isinstance(value, str) and REFERENCE.fullmatch(value) is not None

cases = [
    ("AB-1234", True),
    ("prefix AB-1234", False),
    ("AB-1234 suffix", False),
    ("AB-1234\n", False),
    (" AB-1234", False),
    ("ab-1234", False),
    ("AB-12345", False),
    ("AB-١٢٣٤", False),
    ("", False),
    (None, False),
    (1234, False),
]

for value, expected in cases:
    actual = valid_reference(value)
    assert actual is expected, (value, actual, expected)
    print(repr(value), actual)

assert REFERENCE.search("prefix AB-1234 suffix") is not None
assert not valid_reference("prefix AB-1234 suffix")
print("All reference-format checks passed")

The two final assertions deliberately contrast finding a fragment with accepting a field. They can both succeed: the sentence contains a matching reference, but the entire sentence is not a reference. The newline case also ensures that a line-ending character has not slipped through unnoticed.

Understand the returned object and failed cases

The Python documentation says fullmatch returns a match object when the whole string matches and None otherwise. The function explicitly compares with None so its result is a Boolean, not a match object that callers must interpret.

The type check is a separate guard. It avoids asking the regular-expression engine to treat None or an integer as a string. Converting everything with str(value) would change the field contract and could conceal upstream data errors. If your API must distinguish missing input from malformed text, report those categories separately rather than relying on one generic message.

Do not add .strip() unless the application explicitly allows whitespace normalisation. A user interface can offer a suggested correction, but silently modifying an identifier before validation can make audit records harder to reconcile.

Keep format validation separate from business approval

A format-valid reference may still be nonexistent, expired, duplicated, or associated with a different account. After format validation, perform the application’s authorised lookup and ownership checks. Do not reveal another customer’s records merely because someone supplied a correctly shaped code.

Likewise, whole-string matching does not make arbitrary patterns efficient or safe. This example uses a small fixed-length expression. Avoid accepting user-supplied regular expressions or applying unreviewed complex patterns to enormous input. Set reasonable input-size limits at the application boundary.

For another distinct configuration-validation problem, see rejecting duplicate JSON keys before loading configuration. Validating a string field does not detect ambiguous duplicate fields in the surrounding document.

FAQ and review checklist

Is search wrong? No. It is appropriate when finding matching text inside a larger document is the intended task.

Does fullmatch remove the newline? No. The demonstrated pattern rejects the input containing it; the function does not alter the value.

Can I reuse this format for real account numbers? Only after checking the actual specification. This reference format is hypothetical.

Before release, test a valid value, extra leading and trailing text, a newline, wrong case, wrong length, non-ASCII digits, empty input, and non-string input. Keep these tests with the application so later pattern edits cannot silently broaden acceptance.

Source: Python’s regular-expression documentation, especially fullmatch, search, compiled patterns, and Unicode digit behaviour.

Safety: This tutorial is for educational purposes. Test code before using it in production. WhileNetworking is not responsible for misuse, damage, data loss, or production issues.