Python type() Function Explained

Python has a lot of built-in functions. The type() function is used to get the type of an object.

Python type() function syntax is:

type(object)

type(name, bases, dict)

When a single argument is passed to the type() function, it returns the type of the object. Its value is the same as the object.__class__ instance variable.

When three arguments are passed, it returns a new type object. It’s used to create a class dynamically on the fly.

• “name” string becomes the class name. It’s the same as the __name__ attribute of a class.
• “bases” tuple specifies the base classes. It’s the same as the __bases__ attribute of the class.
• “dict” dictionary helps create the class body. It’s the same as the __dict__ attribute of the class.

Let’s look into some examples of using the type() function.

1. Finding the type of a Python object

x = 10
print(type(x))

s = 'abc'
print(type(s))

from collections import OrderedDict

od = OrderedDict()
print(type(od))

class Data:
    pass

d = Data()
print(type(d))

Output:

<class 'int'>
<class 'str'>
<class 'collections.OrderedDict'>
<class '__main__.Data'>

Notice that the type() function returns the type of the object with the module name. Since our Python script doesn’t have a module, its module becomes __main__.

2. Extracting Details from Python Classes

Let’s say we have the following classes. We’ll pull metadata about the classes using the class, bases, dict, and doc properties.

class Data:
    """Data Class"""
    d_id = 10

class SubData(Data):
    """SubData Class"""
    sd_id = 20

Let’s print some of the properties of these classes.

print(Data.__class__)
print(Data.__bases__)
print(Data.__dict__)
print(Data.__doc__)

print(SubData.__class__)
print(SubData.__bases__)
print(SubData.__dict__)
print(SubData.__doc__)

Output:

<class 'type'>
(<class 'object'>,)
{'__module__': '__main__', '__doc__': 'Data Class', 'd_id': 10, '__dict__': <attribute '__dict__' of 'Data' objects>, '__weakref__': <attribute '__weakref__' of 'Data' objects>}
Data Class

<class 'type'>
(<class '__main__.Data'>,)
{'__module__': '__main__', '__doc__': 'SubData Class', 'sd_id': 20}
SubData Class

We can create similar classes using the type() function.

Data1 = type('Data1', (object,), {'__doc__': 'Data1 Class', 'd_id': 10})
SubData1 = type('SubData1', (Data1,), {'__doc__': 'SubData1 Class', 'sd_id': 20})

print(Data1.__class__)
print(Data1.__bases__)
print(Data1.__dict__)
print(Data1.__doc__)

print(SubData1.__class__)
print(SubData1.__bases__)
print(SubData1.__dict__)
print(SubData1.__doc__)

Output:

<class 'type'>
(<class 'object'>,)
{'__doc__': 'Data1 Class', 'd_id': 10, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Data1' objects>, '__weakref__': <attribute '__weakref__' of 'Data1' objects>}
Data1 Class

<class 'type'>
(<class '__main__.Data1'>,)
{'__doc__': 'SubData1 Class', 'sd_id': 20, '__module__': '__main__'}
SubData1 Class

Note that we can create functions in the dynamic class using the type() function.

Python is a dynamically-typed language. So, if we want to know the type of the arguments, we can use the type() function. If you want to make sure that your function works only on the specific types of objects, use the isinstance() function.

Let’s say we want to create a function to calculate something on two integers. We can implement it in the following way.

def calculate(x, y, op='sum'):
    if not(isinstance(x, int) and isinstance(y, int)):
        print(f'Invalid Types of Arguments - x:{type(x)}, y:{type(y)}')
        raise TypeError('Incompatible types of arguments, must be integers')

    if op == 'difference':
        _return_ x - y
    if op == 'multiply':
        return x * y
    # default is sum
    return x + y

The isinstance() function is used to validate the input argument type. The type() function is used to print the type of the parameters when validation fails.

While type() can tell you the exact type of an object, it’s not always the best tool for type checking in conditional logic, especially when inheritance is involved.

• type(obj) == SomeClass checks if obj is exactly an instance of SomeClass. It will return False if obj is an instance of a subclass of SomeClass.

• isinstance(obj, SomeClass), on the other hand, checks if obj is an instance of SomeClass or an instance of any subclass of SomeClass. This is generally more flexible and aligns with polymorphism.

Here are some best practices for type() vs isinstance():

• For Type Validation in Functions/Methods: Prefer isinstance() when you want to accept an object of a specific type or any of its subtypes. This makes your functions more flexible and robust.

• For Exact Type Identification: Use type() when you need to know the exact class of an object and want to differentiate between base and derived classes, or among unrelated classes. This is less common in typical application logic but can be useful in frameworks or highly specific scenarios.

• For Debugging and Logging: type() is excellent for printing out the type of an object to understand its nature during debugging or for logging purposes.

1. What does the type() function do in Python?

The type() function in Python serves two primary purposes:

• To get an object’s type: When called with a single argument (e.g., type(my_variable)), it returns the type or class of that specific object. For example, type(10) returns <class 'int'>.
• To create a class dynamically: When called with three arguments (e.g., type('MyNewClass', (object,), {'attribute': 100})), it allows you to create new classes (types) at runtime. This is a more advanced feature used in metaprogramming.

2. How do I check the type of a variable in Python?

You can get the exact type of a variable using type(variable). For example, type(x) == int checks if x is exactly an integer. You can also use the isinstance(variable, TypeName) function to check if a variable is an instance of a particular class or any of its subclasses. For example, isinstance(x, int) will return True if x is an integer or an instance of a class derived from int. This is generally preferred for type checking in conditional logic because it correctly handles inheritance.

3. Can I use type() to create a class dynamically?

Yes, you can use the type() function with three arguments, type(name, bases, dict), to create a new class dynamically. Here, name is a string for the class name, bases is a tuple of parent classes from which the new class will inherit, and dict is a dictionary containing the attributes and methods for the new class. This is a powerful feature often used by frameworks, ORMs (Object-Relational Mappers), or in situations where class structures need to be defined programmatically.

4. What is the difference between type() and isinstance()?

The key difference between type() and isinstance() lies in how they handle inheritance. The type(obj) == SomeClass checks if obj is exactly an instance of SomeClass. It does not consider inheritance. If obj is an instance of a subclass of SomeClass, this comparison will be False. On the other hand, isinstance(obj, SomeClass) checks if obj is an instance of SomeClass or an instance of any subclass of SomeClass. It correctly handles inheritance and is generally the preferred way to check an object’s type for conditional logic.

For example:

class Animal: pass
class Dog(Animal): pass

my_dog = Dog()

print(type(my_dog) == Animal)    # False
print(isinstance(my_dog, Animal)) # True

Here, my_dog is an instance of the Dog class, which inherits from the Animal class. The check type(my_dog) == Animal returns False because type() looks for the object’s exact originating class, which is Dog, not Animal.

In contrast, isinstance(my_dog, Animal) returns True because isinstance() considers the entire inheritance hierarchy; since Dog is a subclass of Animal (a Dog “is an” Animal), my_dog is recognized as an instance of the Animal family. Thus, type() is for strict, exact class identification, while isinstance() is for checking if an object conforms to a type or any of its subtypes, respecting the “is-a” relationship of inheritance.

5. Can type() be used with custom classes?

type() works perfectly with custom classes.

If you have an instance of a custom class (e.g., my_obj = MyCustomClass()), calling type(my_obj) will return the class MyCustomClass itself (e.g., <class '__main__.MyCustomClass'>).

You can also use type(name, bases, dict) to dynamically create new custom classes, specify their base classes (which can also be other custom classes), and define their attributes and methods.

Python’s type() function is an important tool for understanding the precise nature of objects and for advanced scenarios involving the dynamic construction of classes. While its ability to reveal an object’s exact class is invaluable for debugging and introspection, and its three-argument form unlocks potent metaprogramming capabilities, developers should predominantly rely on isinstance() for type checking in application logic to ensure robust handling of inheritance and create more flexible, polymorphic code.

For more Python-related topics, check out our following articles:

• Python Data Types
• How To Define Functions in Python 3
• Python staticmethod Explained: When and How to Use Static Methods

• type() documentation