What is metaclass in Python?

In Python, a metaclass is the 'class of a class'. Just as a class defines the blueprint for creating instances of objects, a metaclass defines the blueprint for creating classes themselves. This powerful concept allows you to manipulate class creation logic.

What is a Metaclass?

Python treats everything as an object, including classes. When you define a class, it's an instance of something else. That 'something else' is its metaclass. Essentially, a metaclass is what creates class objects.

Think of it this way: a class is a factory for objects, and a metaclass is a factory for classes.

The Default Metaclass: `type`

By default, every class in Python is an instance of the built-in type metaclass. When you define a class like class MyClass: pass, Python internally calls type to construct that class object.

class MyClass:
    pass

print(type(MyClass))  # Output: <class 'type'>
print(type(int))      # Output: <class 'type'>
print(type(object))   # Output: <class 'type'>

Why Use Metaclasses?

Metaclasses are advanced tools typically used for customizing class creation. They allow you to intercept the class definition process and inject custom logic, such as:

• Automatic attribute registration or modification (e.g., adding methods, changing class-level attributes).
• API enforcement (e.g., ensuring subclasses implement specific methods or attributes).
• Logging or introspection of class creation.
• Implementing frameworks, ORMs (Object-Relational Mappers), or plugin systems.

How to Define a Custom Metaclass

To create a custom metaclass, you typically inherit from type and override methods like __new__ (which is called *before* the class object is created) or __init__ (called *after* it's created, but before it's returned). You then specify your metaclass using the metaclass keyword argument in your class definition.

class MyMeta(type):
    def __new__(mcs, name, bases, namespace):
        # Add a custom attribute to every class created by this metaclass
        namespace['custom_attribute'] = 'Hello from Metaclass!'
        # Call the super metaclass's __new__ to actually create the class
        return super().__new__(mcs, name, bases, namespace)

class MyClass(metaclass=MyMeta):
    def __init__(self, value):
        self.value = value

obj = MyClass(10)
print(obj.custom_attribute) # Output: Hello from Metaclass!
print(MyClass.custom_attribute) # Output: Hello from Metaclass!

Metaclass vs. Class Decorator

Both metaclasses and class decorators allow you to modify or wrap classes. Class decorators are generally simpler and preferred for simpler modifications, like adding a method or modifying existing attributes after the class has been fully defined.

Metaclasses are more powerful as they control the *creation* of the class object itself, allowing deeper intervention into its structure before it's even fully formed. They are suitable for more complex, architectural changes that affect how classes behave fundamentally.

Conclusion

Metaclasses are a powerful, albeit advanced, feature in Python. They provide a mechanism to hook into the class creation process, enabling highly customized and dynamic class behaviors, often seen in sophisticated frameworks.