Python type() Function

Spread the love

The type() function in Python is a built-in function that has two distinct purposes. When given a single object as an argument, it returns the type of the specified object. When given three arguments, it dynamically creates a new class.

Understanding the type( ) Function

When applied to a single object, type() returns the type object of that object, which is essentially its class. For example, calling type(123) returns <class 'int'>, indicating that 123 is an integer.

Here’s the basic syntax for the first use case:

  • object – the object whose type you want to determine.

For the second use case, where type() is used to create a new class dynamically, the syntax is:

type(class_name, bases, attrs)
  • class_name – a string defining the class name and becomes the __name__ attribute of the class.
  • bases – a tuple that itemizes the base class or classes from which the new class inherits.
  • attrs – a dictionary containing attributes and methods of the class.

Using type( ) to Determine an Object’s Type

The type() function is often used in debugging and development, where you need to know the type of an object at runtime. It’s also used to ensure type compatibility in functions that may operate on different types of objects.


print(type(123))           # Output: <class 'int'>
print(type('abc'))         # Output: <class 'str'>
print(type([1, 2, 3]))     # Output: <class 'list'>

Here, type() is used to determine that 123 is an integer, 'abc' is a string, and [1, 2, 3] is a list.

Using type( ) for Type Comparison

You can compare the output of type() with a type object to check if an object is of a certain type:

obj = 10
if type(obj) is int:
    print('Object is an integer.')

However, it’s generally recommended to use isinstance() for such checks as it supports inheritance (an instance of a derived class is an instance of a base class too), unlike type().

Using type( ) to Dynamically Create Classes

The type() function can also create classes on the fly. This is less commonly used but is a powerful feature of Python’s dynamic nature.


# Define class attributes and methods separately
attrs = {
    'attr1': 100,
    'method1': lambda self: print("Method 1")

# Create a new class dynamically
MyDynamicClass = type('MyDynamicClass', (object,), attrs)

# Create an instance of this new class
instance = MyDynamicClass()
print(instance.attr1)       # Output: 100
instance.method1()          # Output: Method 1

In the above code, type() is used to create a new class called MyDynamicClass with one attribute and one method.

Why Use type( ) to Create Classes?

Dynamic class creation can be useful in metaprogramming where classes need to be generated based on user input or runtime data. This can lead to more generic and flexible code. It’s also foundational in understanding how Python’s metaclasses work, as metaclasses are themselves classes of classes, and type() is actually the default metaclass in Python.


The type() function is a versatile tool in Python, serving both introspective and constructive purposes. For introspection, type() allows developers to query the type of an object at runtime, aiding in debugging, validation, and ensuring correct operation. For construction, type() can be used to dynamically create classes, providing a level of metaprogramming that can add significant flexibility to a Python program.

type() encapsulates the dynamic essence of Python, showing that Python is not just an object-oriented language but also a reflective one, where programs can introspect and modify their own structure and behavior. Whether used for simple type checking or complex dynamic class generation, type() is an integral part of Python’s powerful programming toolkit.

Leave a Reply