Type Checking in Python

In Python, type checking refers to the process of verifying the data type of an object. This can be useful for ensuring that functions receive the correct types of arguments and for catching errors early on. In this tutorial, we will explore the different ways to perform type checking in Python.

Using isinstance()

The most common way to check the type of an object is by using the isinstance() function. This function takes two arguments: the object to be checked and the type or types to check against. Here’s an example:

my_object = "hello"
if isinstance(my_object, str):
    print("The object is a string")

In this example, isinstance(my_object, str) returns True if my_object is a string or an instance of a subclass of str.

Checking for Exact Type

If you want to check if the type of an object is exactly a certain type (not a subclass), you can use the type() function:

my_object = "hello"
if type(my_object) is str:
    print("The object is a string")

In this case, type(my_object) is str returns True only if my_object is exactly a string (not an instance of a subclass).

Type Checking in Python 2

In Python 2, there’s a distinction between strings and Unicode strings. To check for both types, you can use the basestring type:

my_object = "hello"
if isinstance(my_object, basestring):
    print("The object is a string or Unicode string")

Using Type Hints (Python 3.5+)

Type hints are a way to specify the expected types of function arguments and return values. They were introduced in Python 3.5 as part of PEP 484. Here’s an example:

def greet(name: str) -> None:
    print(f"Hello, {name}!")

greet("John")  # Okay
greet(123)     # Error (if using a type checker like mypy)

In this example, the greet function expects a string argument and returns nothing. If you pass an integer to greet, a type checker like mypy will raise an error.

Type Checking with Union Types (Python 3.10+)

As of Python 3.10, you can use the | operator to specify union types in isinstance():

my_object = "hello"
if isinstance(my_object, int | str):
    print("The object is an integer or a string")

Duck Typing vs Type Checking

Python’s philosophy emphasizes duck typing: if it looks like a duck and quacks like a duck, then it’s probably a duck. In other words, instead of checking the type of an object, you can try to use its methods and attributes directly:

def process_data(data):
    try:
        data.write("Hello!")
    except AttributeError:
        print("Error: Data is not writable")

In this example, process_data tries to write to the data object. If it succeeds, then data must be a writable object (like a file). If it fails with an AttributeError, then data doesn’t have a write() method.

Conclusion

Type checking is an essential aspect of programming in Python. By using isinstance(), type hints, and union types, you can ensure that your functions receive the correct types of arguments and catch errors early on. However, it’s also important to remember Python’s emphasis on duck typing: sometimes, it’s more efficient and flexible to try to use an object’s methods directly instead of checking its type.