Python isinstance: Deep Dive!

The Python isinstance in Python is a built-in function that checks whether an object is an instance of a particular class or a tuple of classes. This function is extremely useful when you need to verify the type of an object, which can help you make your code more dynamic and robust by ensuring that variables or inputs are of the expected type.

By the end of this guide, you will have a thorough understanding of how to use isinstance() in Python and how to apply it effectively in your projects.

What Is the isinstance() Function?

The isinstance() function in Python checks whether an object (variable) is an instance or subclass of a class, or a tuple of classes. This function returns True if the object is an instance of the specified class or any of its subclasses. If not, it returns False.

Syntax:

isinstance(object, classinfo)

• object: The object whose type you want to check.
• classinfo: The class, type, or a tuple of classes and types to check against.

Return Value:

• True: If the object is an instance of the given class or any class in the classinfo tuple.
• False: If the object is not an instance of the specified class or tuple of classes.

How to Use isinstance() in Python

The isinstance() function is straightforward to use. You pass the object you want to check as the first argument, and the class (or tuple of classes) to check against as the second argument.

Example 1: Basic Usage of isinstance()

x = 5
result = isinstance(x, int)
print(result)  # Output: True

In this example, the variable x is an integer, so isinstance(x, int) returns True.

Example 2: Checking Against Multiple Classes

You can also check whether an object is an instance of multiple types by passing a tuple of classes to isinstance().

x = 5.5
result = isinstance(x, (int, float))
print(result)  # Output: True

Here, x is a float, and since we’re checking against both int and float types, isinstance(x, (int, float)) returns True.

Difference Between isinstance() and type()

Both isinstance() and type() are used to check the type of an object in Python, but they behave differently:

• isinstance(): Returns True if the object is an instance of the specified class or a subclass of it.
• type(): Returns the exact type of the object, but does not consider inheritance.

Example: isinstance() vs. type()

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

print(isinstance(dog, Animal))  # Output: True (Dog is a subclass of Animal)
print(type(dog) == Animal)      # Output: False (dog is of type Dog, not Animal)

In this example, isinstance(dog, Animal) returns True because Dog is a subclass of Animal. However, type(dog) == Animal returns False because the exact type of dog is Dog, not Animal.

Common Use Cases for isinstance() in Python

1. Type Checking for Function Arguments

When writing functions, it’s often important to ensure that the arguments passed are of the correct type. Using isinstance() allows you to perform dynamic type checking.

Example: Type Checking in Functions

def process_data(data):
    if not isinstance(data, list):
        raise TypeError("Expected a list, but got {}".format(type(data).__name__))
    # Process the list data
    print("Processing data...")

process_data([1, 2, 3])  # Works fine
process_data(123)  # Raises TypeError: Expected a list, but got int

In this example, isinstance() checks whether the data argument is a list. If it’s not, a TypeError is raised.

2. Checking for Multiple Types

Sometimes, a function or operation can accept more than one type of input. In such cases, you can use isinstance() to check for multiple types by passing a tuple of allowed classes.

Example: Accepting Multiple Input Types

def add_numbers(a, b):
    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
        return a + b
    else:
        raise TypeError("Both arguments must be int or float.")

print(add_numbers(3, 4))        # Output: 7
print(add_numbers(3.5, 4.5))    # Output: 8.0
print(add_numbers("3", 4))      # Raises TypeError

In this example, isinstance() is used to ensure that both a and b are either integers or floats.

3. Working with Subclasses

isinstance() is particularly useful when working with class inheritance, as it can check not only the exact type of an object but also whether an object is an instance of a subclass.

Example: Checking Subclasses

class Animal:
    pass

class Dog(Animal):
    pass

def check_animal(animal):
    if isinstance(animal, Animal):
        print("This is an Animal.")
    else:
        print("This is not an Animal.")

dog = Dog()
check_animal(dog)  # Output: This is an Animal.

In this example, isinstance() allows us to check if dog is an instance of Animal, even though it is a Dog object.

Best Practices for Using isinstance()

1. Use isinstance() for Type Checking Instead of type()

Whenever you need to check if an object is of a certain type, especially when working with class hierarchies, always prefer isinstance() over type(). This is because isinstance() supports subclass checking, while type() does not.

2. Use isinstance() for Multiple Types with a Tuple

If your function or method can accept arguments of different types, use a tuple with isinstance() to check for multiple allowed types. This makes your code cleaner and easier to maintain.

Example:

# Accepting both int and float types
if isinstance(variable, (int, float)):
    print("The variable is a number.")

3. Avoid Overusing isinstance()

While isinstance() is useful for ensuring type safety, overusing it can lead to less flexible code. In many cases, Python’s duck typing philosophy (where the type of the object is inferred by its behavior) can reduce the need for strict type checking.

Common Pitfalls When Using isinstance()

1. Confusing isinstance() with type()

A common mistake is assuming that isinstance() behaves exactly like type(). Remember that isinstance() checks for subclasses, while type() checks for the exact type. If you want to ensure that an object is exactly of a specific type (not a subclass), use type().

2. Forgetting to Use a Tuple for Multiple Types

If you want to check against multiple types, remember to pass them as a tuple. If you use a list or other iterable, Python will raise a TypeError.

Incorrect:

isinstance(x, [int, float])  # Raises TypeError

Correct:

isinstance(x, (int, float))  # Works fine

3. Over-Reliance on isinstance() for Type Checking

In Python, type checking should generally be avoided unless absolutely necessary. Python encourages a dynamic and flexible programming style where the type of an object is often inferred from how it behaves. Overusing isinstance() can sometimes lead to overly restrictive and less Pythonic code.

Summary of Key Concepts

• isinstance() is a built-in Python function used to check if an object is an instance or subclass of a specific class or tuple of classes.
• Syntax: isinstance(object, classinfo)
• Return Value: Returns True if the object is an instance or subclass of the specified class, and False otherwise.
• Use cases: Validating function arguments, checking for multiple types, and working with inheritance.
• Difference from type(): isinstance() checks for subclass relationships, while type() checks for the exact type.
• Best practices: Use isinstance() for type checking, especially when dealing with inheritance or multiple types, but avoid overusing it to maintain flexible and Pythonic code.

Exercises

1. Basic Type Checking: Write a Python function that takes an input and checks if it is a string. If it is, the function should return the length of the string; otherwise, it should return an error message.
2. Multiple Type Checking: Create a Python function that accepts either a list, tuple, or set and returns the length of the collection. If the input is of another type, raise a TypeError.
3. Inheritance Type Checking: Define two classes: Shape and Circle (which is a subclass of Shape). Write a function that accepts an object and checks if it is an instance of Shape or its subclasses, printing a message accordingly.

Check out our FREE Learn Python Programming Masterclass to hone your skills or learn from scratch.

The course covers everything from first principles to Graphical User Interfaces and Machine Learning

You can refer to the official Python documentation on isinstance here.

FAQ

Q1: Can I use isinstance() to check for multiple types that are not related (e.g., checking for string and list types together)?

A1: Yes, you can check for multiple unrelated types using isinstance() by passing a tuple of types. Python will return True if the object matches any of the types in the tuple.

Example:

x = "Hello"
result = isinstance(x, (str, list))
print(result)  # Output: True (since 'x' is a string)

In this example, the check passes because x is a string, which is one of the types in the tuple.

Q2: What is the difference between isinstance() and issubclass()?

A2:

• isinstance() checks if an object is an instance of a class or its subclass.
• issubclass() checks if one class is a subclass of another class. You use issubclass() when you want to confirm the relationship between two classes rather than checking the type of an object.

Example:

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

print(isinstance(dog, Animal))  # Output: True (dog is an instance of Dog, which is a subclass of Animal)
print(issubclass(Dog, Animal))  # Output: True (Dog is a subclass of Animal)

Q3: Can I use isinstance() to check for custom data types?

A3: Yes, you can use isinstance() to check if an object is an instance of a custom class that you define. This is especially useful when working with user-defined types in object-oriented programming.

Example:

class Car:
    pass

my_car = Car()
print(isinstance(my_car, Car))  # Output: True

In this case, isinstance() correctly identifies my_car as an instance of the Car class.

Q4: How do I check if a variable is not of a certain type using isinstance()?

A4: To check if a variable is not of a certain type, you can use the not keyword with isinstance().

Example:

x = 5.5
if not isinstance(x, int):
    print("x is not an integer.")  # Output: x is not an integer.

This code checks whether x is not an integer, and since x is a float, the condition is True.

Q5: Can I use isinstance() with a list of types instead of a tuple?

A5: No, isinstance() requires a tuple when checking for multiple types. If you try to pass a list, Python will raise a TypeError. You should always use a tuple to list multiple types.

Incorrect:

x = 10
# isinstance(x, [int, float])  # This will raise a TypeError

Correct:

x = 10
print(isinstance(x, (int, float)))  # Output: True

Q6: How does isinstance() work with abstract base classes (ABCs)?

A6: isinstance() works with abstract base classes (ABCs) to check whether an object implements a specific interface. Abstract base classes in Python define a common interface for a group of classes. For example, the collections.abc module defines ABCs like Iterable, Sequence, and Mapping.

Example:

from collections.abc import Iterable

x = [1, 2, 3]
print(isinstance(x, Iterable))  # Output: True (because lists are iterable)

In this case, isinstance() checks if the list x implements the Iterable interface, and returns True.

Q7: Can I use isinstance() to check if an object is a None type?

A7: Yes, you can use isinstance() to check if an object is of NoneType, which is the type of the None object in Python. This is not common, but it’s possible.

Example:

x = None
print(isinstance(x, type(None)))  # Output: True

Here, isinstance(x, type(None)) checks if x is None and returns True.

Q8: What is the performance impact of using isinstance() in a loop?

A8: The performance impact of using isinstance() is generally minimal since it’s a built-in function written in highly optimized C code. However, if you’re using isinstance() in tight loops where performance is critical (e.g., for thousands or millions of iterations), it could add some overhead. In most cases, though, the impact is negligible unless you’re checking complex types or calling it excessively in a performance-sensitive application.

Q9: Can I check for the instance of a Union type (as used in type hints)?

A9: No, Python’s isinstance() function does not support checking directly for Union types, which are used in type hints. If you need to check for multiple types, you should use a tuple in isinstance().

Example:

from typing import Union

# This won't work:
# isinstance(x, Union[int, float])  # Raises a TypeError

# Correct approach:
x = 5.5
print(isinstance(x, (int, float)))  # Output: True

In this example, Union[int, float] is used for type hints but is not applicable in isinstance(). You should use a tuple of types instead.

Q10: Can isinstance() check for types like int or float in NumPy arrays?

A10: Yes, you can use isinstance() to check for types like int or float in NumPy arrays, but be cautious, as NumPy uses its own data types (numpy.int32, numpy.float64, etc.). For NumPy-specific types, it’s often better to use numpy.issubdtype().

Example:

import numpy as np

arr = np.array([1, 2, 3], dtype=np.int32)
print(isinstance(arr[0], int))  # Output: True
print(isinstance(arr[0], np.int32))  # Output: True

In this example, both checks return True because the NumPy integer type (np.int32) is compatible with Python’s built-in int.