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
The function has a straightforward syntax:
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.
Trueif class is subclass of a class, or any element of the tuple
Basic Use Cases of issubclass( )
Let’s look at a simple example
class Animal: pass class Dog(Animal): pass print(issubclass(Dog, Animal)) # Output: True
Dog is a subclass of
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): pass print(issubclass(Terrier, Animal)) # Output: True
Terrier being two levels down the inheritance chain,
issubclass() confirms it’s still a subclass of
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: pass class Bulldog(Dog, Pet): pass print(issubclass(Bulldog, Dog)) # Output: True print(issubclass(Bulldog, Pet)) # Output: True
issubclass( ) vs. isinstance( )
Understanding the difference between
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
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?”
subclass is indeed a subclass of
superclass, or is
superclass itself, the function will return
True. Otherwise, it returns
isinstance( ) Function
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?”
object is an instance of
classinfo, or if it is an instance of a subclass of
isinstance() will return
True. If not, it returns
- 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.
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.
Imagine a situation where you have a base class
Vehicle, and two subclasses
Boat. You also have instances of these classes,
Here’s how you would use
isinstance() in this scenario:
class Vehicle: pass class Car(Vehicle): pass class Boat(Vehicle): pass 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
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
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.