Skip to main content

How to Validate Object Types Dynamically in Python

Python is a dynamically typed language, meaning variable types are determined at runtime rather than compile time. While this offers great flexibility, it can lead to runtime TypeError exceptions if an object doesn't match the expected type. Validating object types dynamically is essential for writing robust code, especially when dealing with user input, API responses, or complex data processing pipelines.

This guide covers the standard methods for type checking, how to handle inheritance correctly, and how to implement reusable validation using decorators.

Understanding Dynamic Typing​

In Python, you don't declare types explicitly like int x = 10. Instead, variables are references to objects, and those objects carry type information.

  • Dynamic: The type is checked when the code is executed.
  • Strong: Python generally prevents mixing incompatible types (e.g., adding a string to an integer) without explicit conversion.

Validating types effectively prevents your application from crashing deep inside a function due to unexpected input.

The isinstance() function is the standard way to check types in Python. It returns True if the object is an instance of the specified class or any subclass thereof.

Basic Usage: uou can check against a single type or a tuple of allowed types.

def process_data(value):
    # ✅ Correct: Check if value is an integer or a float
    if isinstance(value, (int, float)):
        return value * 2
    return None

# Valid input
print(f"Number: {process_data(10)}")

# Invalid input (String)
result = process_data("10")
if result is None:
    print("Invalid input rejected.")

Output:

Number: 20
Invalid input rejected.

Why isinstance is Preferred​

It supports inheritance. If you have a custom class inheriting from a parent class, isinstance will correctly identify the relationship.

class Animal: pass
class Dog(Animal): pass

dog = Dog()

# ✅ Correct: A Dog is an Animal
print(f"Is dog an Animal? {isinstance(dog, Animal)}")

Output:

Is dog an Animal? True
tip

Always prefer isinstance() over type() unless you explicitly need to exclude subclasses.

Method 2: Using type() (Strict Checking)​

The type() function returns the exact type of an object. Comparing types directly (type(obj) is int) is stricter than isinstance(). It returns True only if the types match exactly, ignoring inheritance.

class Animal: pass
class Dog(Animal): pass

dog = Dog()

# ⛔️ Strict Check: A Dog is NOT exactly an Animal class instance
if type(dog) is Animal:
    print("Strict check passed")
else:
    print("Strict check failed (Inheritance ignored)")

Output:

Strict check failed (Inheritance ignored)
warning

Using type() for validation breaks polymorphism. For example, if you check type(x) is int, boolean values (True/False) will fail the check, whereas isinstance(True, int) returns True because bool inherits from int.

Method 3: Decorator-Based Validation​

For repetitive validation tasks, you can creating a decorator. This keeps your function logic clean by moving the type-checking boilerplate outside the function body.

def validate_types(*expected_types):
    def decorator(func):
        def wrapper(*args, **kwargs):
            # Check positional arguments against expected types
            for arg, expected_type in zip(args, expected_types):
                if not isinstance(arg, expected_type):
                    raise TypeError(f"Expected {expected_type.__name__}, got {type(arg).__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

# ✅ Apply validation: First arg must be int, second must be str
@validate_types(int, str)
def repeat_message(times, message):
    return message * times

try:
    print(repeat_message(3, "Hello "))
    
    # ⛔️ Incorrect: Passing string instead of int
    print(repeat_message("3", "Hello "))
except TypeError as e:
    print(f"Error caught: {e}")

Output:

Hello Hello Hello 
Error caught: Expected int, got str

Method 4: Validating Collections​

Sometimes you need to ensure that a list or dictionary contains elements of a specific type. isinstance only checks the container itself, not the contents.

Validating List Contents​

Use the all() function combined with isinstance.

data = [1, 2, 3, "four", 5]

def validate_int_list(numbers):
    # ⛔️ Incorrect: Only checks if 'numbers' is a list
    if not isinstance(numbers, list):
        return False
        
    # ✅ Correct: Check if ALL items inside are integers
    if not all(isinstance(x, int) for x in numbers):
        print("List contains non-integers")
        return False
        
    return True

validate_int_list(data)

Output:

List contains non-integers
note

This approach iterates over the entire list. For very large datasets, this might have performance implications.

Conclusion​

Dynamic type validation ensures your Python code behaves predictably.

  1. Use isinstance(obj, Type) for most validation needs. It handles multiple types and inheritance correctly.
  2. Use type(obj) is Type only when you need to strictly exclude subclasses.
  3. Use Decorators to abstract validation logic and keep your code DRY (Don't Repeat Yourself).
  4. Validate Collections by iterating through elements if you need strict data integrity within lists or dictionaries.

Table of Contents