How to Validate Numeric Ranges in Python

Validating that a number falls within a specific range is a fundamental requirement for data integrity. Whether you are checking user age, temperature thresholds, or financial limits, ensuring values are within bounds prevents logical errors and security vulnerabilities.

This guide explores multiple ways to validate numeric ranges in Python, from simple comparison operators to reusable decorators and custom classes.

Method 1: Using Comparison Operators (Standard)

The most Pythonic way to check if a value falls between two bounds is using chained comparison operators. This works for both integers and floats.

Syntax: min_val <= value <= max_val

def validate_age(age):
    if 18 <= age <= 65:
        return True
    return False

print(f"Age 25 valid? {validate_age(25)}")
print(f"Age 10 valid? {validate_age(10)}")

Output:

Age 25 valid? True
Age 10 valid? False

Method 2: Using range() for Integers

If you are dealing strictly with integers, you can use the in range() syntax.

Syntax: value in range(start, stop)

score = 85

if score in range(0, 101):
    print("Valid score.")
else:
    print("Invalid score.")

Output:

Valid score.

Method 3: Using Decorators for Reusable Validation

If you have many functions that require inputs to be within specific bounds, a decorator allows you to define the rule once and apply it everywhere.

def validate_range(min_val, max_val):
    def decorator(func):
        def wrapper(value):
            if not (min_val <= value <= max_val):
                raise ValueError(f"Value {value} must be between {min_val} and {max_val}")
            return func(value)
        return wrapper
    return decorator

@validate_range(0, 100)
def process_percentage(value):
    print(f"Processing {value}%...")

try:
    process_percentage(150)
except ValueError as e:
    print(f"Error: {e}")

Output:

Error: Value 150 must be between 0 and 100

Method 4: Custom Validator Class

For complex applications, a validator class offers flexibility, allowing optional bounds (e.g., only a minimum) and reusable instances.

class RangeValidator:
    def __init__(self, min_val=None, max_val=None):
        self.min_val = min_val
        self.max_val = max_val

    def validate(self, value):
        if self.min_val is not None and value < self.min_val:
            return False
        if self.max_val is not None and value > self.max_val:
            return False
        return True

price_validator = RangeValidator(min_val=0.01)

print(f"Price 10.50 valid? {price_validator.validate(10.50)}")
print(f"Price -5.00 valid? {price_validator.validate(-5.00)}")

Output:

Price 10.50 valid? True
Price -5.00 valid? False

Conclusion

To validate numeric ranges in Python:

1. Use Chained Comparison (min <= x <= max) for the most readable, standard solution.
2. Use range() only for integer checks where the exclusive upper bound logic is clear.
3. Use Decorators to enforce constraints on function arguments automatically.