When writing Python functions, ensuring that the parameters are of the correct type is crucial for robust and error-free code. In this post, we’ll explore how to enforce type checks in a function to ensure it raises an error if the parameter is not of the expected type.

The Problem

Consider a simple function that takes a string argument and prints a welcome message:

def print_name(name):
    print("You are welcome:", name)

This function works perfectly if we pass a string:

print_name("John")
You are welcome: John

However, if we mistakenly pass a non-string argument, like an integer, the function will still execute without raising an error, which might lead to unintended behavior:

print_name(8)
You are welcome: 8

While Python is dynamically typed, in some cases, you might want to enforce type checks to ensure that the function is used correctly. Let’s modify the function to raise an error if the parameter is not a string.

Adding Type Checks

To add a type check, we can use the isinstance() function to verify the type of the argument. If the argument is not of the expected type, we can raise a TypeError. Here’s how you can do it:

def print_name(name):
    if not isinstance(name, str):
        raise TypeError("Argument must be a string")
    print("You are welcome:", name)

With this modification, the function will raise an error if the argument is not a string:

print_name("John")  # This will work as expected
You are welcome: John

print_name(8)  # This will raise a TypeError
TypeError: Argument must be a string

Benefits of Type Checking

1. Error Prevention: Ensures that functions are used correctly, preventing unintended behavior.
2. Improved Debugging: Makes it easier to identify and fix errors related to incorrect argument types.
3. Self-Documenting Code: Type checks serve as documentation for expected parameter types, making the code more readable and maintainable.

Conclusion

By adding type checks to your functions, you can make your code more robust and easier to debug. This practice is especially useful in larger codebases where functions might be called with unexpected arguments. Remember that while Python is dynamically typed, enforcing type safety can help you catch errors early and ensure your code behaves as expected.