Unlock Python’s Power: A Deep Dive into Metaclasses and Dynamic Class Creation

Old‑style vs New‑style Classes

In Python, a class can be either an old‑style or a new‑style class, though the terminology is informal.

Old‑style Class

For old‑style classes, the class and its type are not identical; instances inherit from an internal instance type. In Python 2.7, obj.__class__ gives the class, while type(obj) always returns instance.

New‑style Class

New‑style classes unify class and type. For an instance obj of a new‑style class, type(obj) equals obj.__class__.

Type and Class

In Python 3, all classes are new‑style, so the type and class of an object are interchangeable. Note that in Python 2, classes default to old‑style unless declared otherwise.

Consider the following code:

Here, X is an instance of class Foo, whose type is type. All new‑style classes are instances of the metaclass type, and even type itself is an instance of type.

X is an instance of class Foo .

Foo is an instance of the metaclass type .

type is also an instance of itself.

Dynamic Class Definition

The built‑in type() function returns an object's type when called with a single argument, and for new‑style classes it matches obj.__class__. You can also call type(name, bases, dct) to create a class dynamically. name – the class name, becomes __name__. bases – a tuple of base classes, becomes __bases__. dct – a dictionary containing the class body, becomes __dict__.

Using this form, type() creates a new instance of the metaclass type, i.e., a new class.

Example 1

Creating the simplest class with empty bases and dictionary:

Example 2

Specifying a single base Foo and an attribute attr in the dictionary:

Example 3

Providing an empty base list but adding both an attribute and a method via the dictionary:

Example 4

Using a lambda for a simple function, then assigning a more complex function f to attr_val in the dictionary:

Custom Metaclasses

To customize class creation, define a metaclass that inherits from type and override its __new__ method.

The overridden __new__ calls super().__new__ to create the class, injects a custom attribute attr with value 100, and returns the new class.

Then declare a regular class using the custom metaclass via the metaclass keyword:

Instances of Foo now automatically have the attr attribute defined by the metaclass.

Metaclasses act as class factories, similar to object factories.

Are Custom Metaclasses Necessary?

Often a simple inheritance or a class decorator can achieve the same effect without the complexity of a metaclass.

Simple inheritance:

Class decorator:

Conclusion

As Tim Peters suggests, metaclasses are a powerful tool but should be used only when simpler solutions are insufficient. Understanding them deepens knowledge of Python’s class model and helps decide when a metaclass is truly appropriate.