Type Checking

9.1 The type() Function

Python has a bunch of built-in functions for checking the types and classes of objects. These functions are super handy for writing flexible and safe code that can handle different data types.

I'll tell you about the most popular ones: type(), isinstance(), issubclass(), and also some functions for type annotation like getattr() and hasattr().

The type() Function

The type() function returns the type of an object. You've worked with it before, right?

x = 10
print(type(x))  # Output: <class 'int'>

But here's something you might not know: you can use it to create new classes!

Creating a New Class

If you pass it three arguments, it'll create a new type (class).

The signature for this operation is:

type(name, bases, dict)

where:

• name — the name of the class being created (a string).
• bases — a tuple of base classes (parents) from which the new class inherits.
• dict — a dictionary containing attributes and methods for the new class.

Creating a Simple Class:

MyClass = type('MyClass', (), {'say_hello': lambda self: print("Hello!")})

# Create an instance of the class
instance = MyClass()
instance.say_hello()  # Output: Hello!

You can even make something more complex:

MyClass = type('MyClass', (), {
    'attribute': 42,
    '__init__': lambda self, value: setattr(self, 'value', value),
    'display_value': lambda self: print(self.value)
})

# Create an instance of the class
instance = MyClass(10)
print(instance.attribute)  # Output: 42
instance.display_value()  # Output: 10

So now you can not only determine the type of an object but also create a class, spawn some objects, and then determine their types.

9.2 The isinstance() Function

The isinstance() Function is a built-in function in Python used to check if an object belongs to a particular class or a tuple of classes. It returns True if the object is an instance of the specified class or any of the classes in the tuple, and False otherwise.

The signature and parameters:

isinstance(object, classinfo)

where:

• object — the object whose class membership you want to check.
• classinfo — a class, type, or a tuple of classes and types against which the object will be checked.

Usage examples:

Checking membership of a single class

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

y = "Hello"
print(isinstance(y, str))  # Output: True

Checking membership of multiple classes — at least one of them:

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

y = "Hello"
print(isinstance(y, (int, str)))  # Output: True

z = 3.14
print(isinstance(z, (int, str)))  # Output: False

Checking membership of custom classes

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

print(isinstance(dog, Dog))  # Output: True
print(isinstance(dog, Animal))  # Output: True

Unlike direct type comparison using type(), isinstance() correctly handles inheritance, checking for membership of an object in any class in the hierarchy.

9.3 The issubclass() Function

The issubclass() Function is a built-in function in Python used to check whether a specified class is a subclass of another class or any class in a tuple. It returns True if the first argument is indeed a subclass of the second, and False otherwise.

The signature and parameters:

issubclass(class, classinfo)

where:

• class — the class whose membership to a class or classes needs to be checked.
• classinfo — a class, type, or a tuple of classes and types against which the first argument will be checked.

Usage examples:

Checking membership of a single class

class Animal:
    pass

class Dog(Animal):
    pass

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

Checking membership of multiple classes — at least one:

class Animal:
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

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

Examples with custom classes

Inheritance from built-in classes

class MyInt(int):
    pass

print(issubclass(MyInt, int))  # Output: True
print(issubclass(int, MyInt))  # Output: False

Inheritance hierarchy

class A:
    pass

class B(A):
    pass

class C(B):
    pass

print(issubclass(C, A))  # Output: True
print(issubclass(C, B))  # Output: True
print(issubclass(B, A))  # Output: True
print(issubclass(A, C))  # Output: False

Benefits of using issubclass()

Checking class hierarchy: issubclass() allows checking class hierarchy, which is useful for ensuring correct inheritance and code structure.

Flexibility: The function supports checking against both a single class or a tuple of classes, making it flexible for use in various scenarios.

Handy for metaprogramming: issubclass() is often used in metaprogramming and when writing code that deals with dynamic types and classes. But we'll talk about that much later :)