In my years of developing enterprise software, I have often seen developers get confused when they realize type() does more than just identify an object.
It took me a few deep-dive sessions into Python’s internals to realize that type is actually the “class of all classes”, the ultimate metaclass.
In this tutorial, I will show you how to use type() to create classes dynamically and how it functions as a metaclass in your Python projects.
What is a Metaclass in Python?
Before we jump into the code, let’s understand the hierarchy. In Python, everything is an object, including classes themselves.
If a class is a blueprint for an object, then a metaclass is the blueprint for a class. It defines how a class behaves.
Whenever I create a class using the class keyword, Python uses a metaclass to build it. By default, that metaclass is type.
Use type() to Check Object Types
Most of us start using type() for a very simple purpose: to see what we are working with.
I often use this during debugging sessions when I am receiving data from a US-based API, like a financial ticker or a weather service.
# Checking data types from a simulated US stock market feed
stock_symbol = "AAPL"
price = 150.25
print(type(stock_symbol)) # Output: <class 'str'>
print(type(price)) # Output: <class 'float'>In the example above, type() tells us the class that created these objects. This is the “single argument” version of the function.
How type() Works with Three Arguments
The real magic happens when you pass three arguments to type(). This is how you create a class dynamically without using the class keyword.
When I am building flexible frameworks that need to generate classes on the fly based on user input, this is the method I rely on.
The syntax is: type(name, bases, dict).
- Name: A string defining the class name.
- Bases: A tuple containing the parent classes (inheritance).
- Dict: A dictionary containing the class attributes and methods.
Method 1: Create a Simple Dynamic Class
Let’s say I need to create a class to represent different US Federal Agencies dynamically.
Instead of hardcoding every agency, I can use the three-argument version of type().
# Dynamically creating a class for a US Government Agency
Agency = type('Agency', (), {'location': 'Washington D.C.', 'country': 'USA'})
# Creating an instance of our dynamic class
fbi = Agency()
print(fbi.location)
print(fbi.__class__)You can refer to the screenshot below to see the output.
In this case, I didn’t write the class Agency:. Python did it for me behind the scenes using the type metaclass.
Method 2: Dynamic Class with Inheritance
In many of my projects involving US logistics data, I need to create subclasses that inherit from a base “Vehicle” class.
We can pass the base class into the bases tuple of the type() function to achieve inheritance.
# Base class
class LogisticsVehicle:
def __init__(self):
self.region = "North America"
# Dynamic subclass
Truck = type('Truck', (LogisticsVehicle,), {'capacity_lbs': 26000})
my_truck = Truck()
print(my_truck.region) # Inherited attribute
print(my_truck.capacity_lbs) # Class-specific attributeYou can refer to the screenshot below to see the output.
This approach is incredibly useful when you are building plugins or modules where you don’t know the class structure until runtime.
Method 3: Add Methods Dynamically
A class isn’t very useful without methods. I often find myself needing to attach functions to classes created via type().
To do this, you define a regular function and then map it to a key in the dictionary argument.
# Function to calculate sales tax for a US state
def calculate_tax(self, price):
return price * self.tax_rate
# Creating a class for New York Retail
NYRetail = type('NYRetail', (), {
'tax_rate': 0.08875,
'get_tax': calculate_tax
})
store = NYRetail()
print(f"Tax on $100 in NY: ${store.get_tax(100)}")You can refer to the screenshot below to see the output.
I used self as the first argument in the function, just like a standard class method. When I assigned it to the dictionary, it became an instance method.
Create a Custom Metaclass
Sometimes, the default behavior of the type isn’t enough. I might want to automatically modify every class created in a project.
For instance, I once worked on a project where all class names had to be strictly in uppercase to follow a specific US corporate coding standard.
To do this, you create a class that inherits from type.
# A custom metaclass that forces all attributes to be uppercase
class USStandardMeta(type):
def __new__(mcs, name, bases, class_dict):
# Create a new dict with uppercase keys
uppercase_dict = {}
for key, value in class_dict.items():
if not key.startswith('__'):
uppercase_dict[key.upper()] = value
else:
uppercase_dict[key] = value
return super().__new__(mcs, name, bases, uppercase_dict)
# Applying the metaclass
class StateData(metaclass=USStandardMeta):
population = 331000000
currency = "USD"
# Accessing attributes
print(StateData.POPULATION) # Note how it is now uppercaseBy using metaclass=USStandardMeta, we told Python not to use the default type to build StateData, but to use our custom logic instead.
Why Should You Use Metaclasses?
I don’t recommend using metaclasses for every project. They can make the code harder to read if overused.
However, they are perfect for building APIs, Object-Relational Mappers (ORMs), or validation frameworks.
For example, many popular Python libraries used in the US tech industry, like Django or SQLAlchemy, use metaclasses extensively.
They allow these frameworks to turn simple class definitions into complex database schemas automatically.
Common Issues with type() and Metaclasses
When I first started experimenting with dynamic classes, I made the mistake of forgetting that the base argument must be a tuple.
If you are only inheriting from one class, you must include a trailing comma (e.g., (BaseClass,)).
Another thing to watch out for is readability. If a colleague looks at your code, they might find type() calls more confusing than standard class definitions.
I always suggest adding clear comments whenever you use dynamic class generation in a production environment.
Real-World Example: US Employee Management System
Let’s look at a full example where we use type() to generate employee roles for a US-based corporation.
# Base functionality for all employees
class Employee:
def __init__(self, name):
self.name = name
# A function to describe the role
def show_details(self):
print(f"Employee: {self.name}")
print(f"Department: {self.dept}")
print(f"Location: {self.office}")
# Data for dynamic class creation
roles = [
{"name": "Developer", "dept": "Engineering", "office": "San Francisco"},
{"name": "Manager", "dept": "Operations", "office": "New York"},
{"name": "Analyst", "dept": "Finance", "office": "Chicago"}
]
# Dictionary to store our new classes
class_registry = {}
for role in roles:
class_name = role["name"]
# Create the class dynamically
new_class = type(class_name, (Employee,), {
"dept": role["dept"],
"office": role["office"],
"display": show_details
})
class_registry[class_name] = new_class
# Testing the dynamic classes
dev_instance = class_registry["Developer"]("John Smith")
dev_instance.display()
mgr_instance = class_registry["Manager"]("Sarah Jones")
mgr_instance.display()This script creates three distinct classes without ever typing the word class for them individually.
I find this pattern very useful when reading configuration files or database tables that define different business entities.
Compare type() and Instance Checks
In professional Python development, I often see people use type(obj) == int to check types.
I prefer using isinstance(obj, int) because it supports inheritance, which is a core part of the Python ecosystem.
However, when I need to check the exact class and exclude subclasses, type() is the correct tool for the job.
It is all about choosing the right tool for the specific logic you are trying to implement in your software.
Understanding how type() works as a metaclass has certainly made me a more versatile developer.
It gives you a deeper look into how Python operates under the hood, allowing you to write more powerful and flexible code.
Whether you are building a small tool for data analysis or a large-scale application for a US enterprise, mastering type() is a valuable skill.
You may also like to read other tutorials on OOPS:
- How to Use @dataclass in Python
- Python Dataclass vs. Normal Class
- Default Values and Type Hints in Python Dataclasses
- How to Build a Simple OOP Project in Python
I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.
