5.3.1. Defining a Custom Metaclass

A metaclass is typically a subclass of type:

class Meta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class: {name}")
        dct['created_by'] = 'MetaClass'
        return super().__new__(cls, name, bases, dct)

A metaclass is a special type of class that controls how other classes are created. To define a custom metaclass, you typically subclass the built-in type. In this example, we create a metaclass named Meta. Inside the metaclass, we override the __new__ method, which is responsible for class creation. The method takes several parameters: cls (the class), name (the name of the class being created), bases (the parent classes), and dct (the class dictionary that holds its attributes and methods). In our method, we print the name of the class being created and add an attribute 'created_by' to its dictionary before returning the newly created class using super().__new__. This allows us to customize the class creation process.

Think of a metaclass like a factory that produces various types of products (classes). The factory has a blueprint (the metaclass) that specifies how to build each product. Whenever a new product is requested, the factory checks the blueprint to see if any special features or modifications are needed before handing it over. In our case, the metaclass adds a creator stamp ('created_by') to each product it produces.

You attach it to a class using the metaclass keyword:

class MyClass(metaclass=Meta):
    pass

print(MyClass.created_by)  # Output: MetaClass

Once we have defined a custom metaclass, we can use it when declaring a new class. To do this, we specify the metaclass keyword in the class definition. In the example above, MyClass uses Meta as its metaclass. When MyClass is created, the __new__ method of Meta is called, executing the customization we defined. After class creation, we can access the attribute created_by that was added by the metaclass, which in this case returns 'MetaClass'. This illustrates how the metaclass can influence the behavior and attributes of classes created with it.

Imagine you're a chef at a restaurant (the metaclass) who oversees the kitchen (class creation). When a new dish (class) is developed, you add your signature (the 'created_by' attribute) to acknowledge your input. Later, when someone orders the dish, they can see that it was prepared by you, indicating the quality and uniqueness of what they are about to enjoy.

The new method:

• Receives the class name, its base classes, and its dictionary.
• Can modify or add to the class dictionary before the class is created.

The __new__ method is a crucial part of the metaclass. It is called before the class is actually created. This means we have the opportunity to modify or add attributes to the class dictionary (dct) that defines the new class. This capability allows us to inject additional behavior or properties directly into the class definition before it becomes available to other parts of the program.

Consider a theatrical director (the metaclass) preparing a new play (class). Before the actors (attributes/methods) perform on stage (classes), the director decides to add a special scene (attribute) or change some lines (methods) to enhance the production. By doing this, the final play is better and exactly as intended.

--