Python issubclass() Function

Spread the love

The issubclass() function is a built-in utility in Python that determines whether a particular class is a derived class of another class. It takes two arguments: the class to be tested, and the class, or tuple of classes, it may inherit from. The function returns True if the first class is a subclass of the second, and False otherwise.


The function has a straightforward syntax:

issubclass(class, classinfo)


issubclass() takes two parameters:

  • class: This is the class you want to check.
  • classinfo: This can be a class, type, or a tuple of classes and types.

Return Value:

issubclass() returns:

  • True if class is subclass of a class, or any element of the tuple
  • False otherwise

Basic Use Cases of issubclass( )

Let’s look at a simple example

class Animal:

class Dog(Animal):

print(issubclass(Dog, Animal))  # Output: True

Here, issubclass() returns True because Dog is a subclass of Animal.

Checking Subclass Relationships in Complex Hierarchies

In more complex class hierarchies, issubclass() can be used to verify if a class inherits from any class up the hierarchy chain:

class Terrier(Dog):

print(issubclass(Terrier, Animal))  # Output: True

Despite Terrier being two levels down the inheritance chain, issubclass() confirms it’s still a subclass of Animal.

issubclass( ) with Multiple Inheritance

Python supports multiple inheritance, where a class can inherit from more than one parent class. issubclass() gracefully handles this scenario:

class Pet:

class Bulldog(Dog, Pet):

print(issubclass(Bulldog, Dog))  # Output: True
print(issubclass(Bulldog, Pet))  # Output: True

issubclass( ) vs. isinstance( )

Understanding the difference between issubclass() and isinstance() is crucial for Python developers, especially when working with object-oriented programming (OOP). Both functions are introspective, meaning they provide a way for you to check the properties of objects and classes at runtime, but they serve different purposes.

issubclass( ) Function

The issubclass() function checks class inheritance. It determines if a particular class is a derived class (subclass) of another class. It answers the question: “Is this class a kind of that class?”

issubclass(subclass, superclass)

If subclass is indeed a subclass of superclass, or is superclass itself, the function will return True. Otherwise, it returns False.

isinstance( ) Function

The isinstance() function checks if an object is an instance of a class or a tuple of classes. It’s about instance-to-class comparison rather than class-to-class. It answers the question: “Is this object an instance of that class or one of those classes?”

isinstance(object, classinfo)

If object is an instance of classinfo, or if it is an instance of a subclass of classinfo, isinstance() will return True. If not, it returns False.

Key Differences

  • Type of Check: issubclass() is for checking the class hierarchy for subclass relationships. isinstance(), on the other hand, checks if an object is an instance of a class or an instance of a subclass of that class.
  • Arguments: issubclass() takes classes as both its arguments, while isinstance() takes an object as its first argument and a class or classes as the second.
  • Use Cases: Use issubclass() when you are interested in class inheritance and class relationships. Use isinstance() when you need to ensure an object is of a particular type at runtime, which is useful when you’re implementing functions that expect certain kinds of objects.

Practical Example

Imagine a situation where you have a base class Vehicle, and two subclasses Car and Boat. You also have instances of these classes, my_car and my_boat.

Here’s how you would use issubclass() and isinstance() in this scenario:

class Vehicle:

class Car(Vehicle):

class Boat(Vehicle):

my_car = Car()
my_boat = Boat()

# issubclass() checks
print(issubclass(Car, Vehicle))  # True, Car is a subclass of Vehicle
print(issubclass(Boat, Car))     # False, Boat is not a subclass of Car

# isinstance() checks
print(isinstance(my_car, Vehicle))  # True, my_car is an instance of a subclass of Vehicle
print(isinstance(my_boat, Car))     # False, my_boat is not an instance of Car

Philosophical Consideration

Python’s dynamic and duck-typing nature often prefers behavior checks (what an object can do) over explicit type checks. While isinstance() is commonly used and generally accepted, using issubclass() is rarer and can sometimes be a sign of a design that’s overly rigid or not taking full advantage of polymorphism.

Caveats and Considerations

A key thing to remember is that every class is considered a subclass of itself.

print(issubclass(Dog, Dog))  # Output: True

So, issubclass() will return True if the two arguments are the same class.


issubclass() is a powerful function for inspecting class inheritance relationships. It’s an essential part of Python’s dynamic type system, enabling developers to write flexible and introspective code. Understanding when and how to use issubclass(), along with its nuances, can significantly contribute to writing clear and effective object-oriented Python code.

Leave a Reply