Unlocking Python Metaclasses: When and How to Use Them

Old‑style vs New‑style Classes

In Python a class can be either old‑style or new‑style. The terminology is informal, but the distinction matters for understanding metaclasses.

Old‑style classes

For old‑style classes the class and type are not identical. An instance of an old‑style class always inherits from an internal type called instance. If obj is an old‑style instance, obj.__class__ refers to its class, while type(obj) is always instance. Example from Python 2.7:

New‑style classes

New‑style classes unify the concepts of class and type. For a new‑style instance, type(obj) is the same as obj.__class__:

Type and Class

In Python 3 all classes are new‑style, so the type and class of an object can be interchanged.

Note: In Python 2 the default was old‑style. New‑style classes were introduced in Python 2.2 and required an explicit declaration.

Remember that everything in Python is an object, including classes. Therefore a class must have a type, and the type of a class is the metaclass type.

Consider the following code:

Here X is an instance of class Foo, and Foo itself is an instance of the metaclass type. Generally, any new‑style class’s type is type.

Built‑in classes also have type as their type:

And type itself is an instance of type (yes, it’s self‑referential):

In summary:

x is an instance of class Foo.

Foo is an instance of the metaclass type.

type is also an instance of type, making it its own instance.

Dynamic Class Definition

The built‑in type() function returns the type of an object when called with a single argument. With three arguments it can create a new class dynamically. <name> – the class name, becomes __name__. <bases> – a tuple of base classes, becomes __bases__. <dct> – a namespace dictionary containing the class body, becomes __dict__.

Calling type(name, bases, dct) creates a new instance of the metaclass type, i.e., a new class. The following examples show that a class defined with type() behaves the same as one defined with the class statement.

Example 1

Creating the simplest class with no bases or attributes.

Example 2

Single base class Foo and an attribute attr placed in the namespace.

Example 3

Empty bases, two objects placed in the namespace: an attribute attr and a function attr_val that becomes a method.

Example 4

Using a lambda‑defined function and then assigning it to attr_val in the namespace.

Custom Metaclasses

Re‑examining the previous example, the expression Foo() creates an instance of class Foo. The interpreter first calls Foo 's parent __call__() method (the type metaclass), which then invokes __new__() and __init__().

If Foo defines its own __new__(), it can customise instance creation.

Because type itself cannot be altered, the usual solution is to define a metaclass that inherits from type and overrides its __new__() method.

First define the metaclass:

Then use it with the metaclass keyword:

Now Foo automatically receives the custom attribute attr. Any other class that specifies Meta as its metaclass will behave similarly.

A metaclass can be thought of as a “class factory”.

Object factory vs class factory illustrations:

Object factory :

Class factory :

Are Custom Metaclasses Really Needed?

Although metaclasses let you customise class instantiation, using them just to add a single attribute is often overkill. Simpler alternatives such as ordinary inheritance or class decorators achieve the same result.

Simple inheritance illustration:

Class decorator illustration:

Conclusion

As Tim Peters suggests, metaclasses are a powerful tool that should be used only when simpler solutions are insufficient. Understanding them, however, deepens your grasp of Python’s class model and helps you decide when a metaclass is the right choice.