🕷️ Crawler Inspector

## 🔹 Introduction In Python, everything is an object, even classes. But how are classes created? The answer is metaclasses. A metaclass is like a factory that builds classes. You can think of them as blueprints for classes, just like classes are blueprints for objects. ## 🏗️ What is a Metaclass? A metaclass is the class of a class. Objects are made from classes, and classes are made from metaclasses. By default, Python uses a built-in metaclass called type. **Example** ``` # A simple class class MyClass: pass print(type(MyClass)) # Output: <class 'type'> ``` 👉 This shows that MyClass was created using the metaclass type. ## ⚙️ How Do Metaclasses Work? When you create a class in Python, the following steps happen: - Python runs the class statement and collects the methods and attributes inside it into a dictionary. - The metaclass is called to create the class object itself. - After that, you can create objects from the new class. This process allows developers to control what happens when a class is defined. ## 🧑‍💻 Creating a Custom Metaclass You can create your own metaclass by inheriting from type and overriding methods like \_\_new\_\_ or \_\_init\_\_. This lets you decide what happens during class creation. **Example** ``` # Defining a custom metaclass class MyMeta(type): def __new__(cls, name, bases, dct): print(f"Creating class: {name}") return super().__new__(cls, name, bases, dct) # Using the custom metaclass class MyClass(metaclass=MyMeta): pass # Output: Creating class: MyClass ``` 👉 Here, MyMeta decides how MyClass is created. ## 🔑 Why Use Metaclasses? Metaclasses are powerful but not often needed in simple programs. They are most useful for: - **Enforcing rules:** Making sure classes follow certain patterns (for example, always having a specific method). - **Automatic modifications:** Adding or changing methods in a class automatically. - **Frameworks and libraries:** Popular frameworks like Django use metaclasses behind the scenes to provide advanced features. ## 📘 Real-World Example of Enforcing Method Names Suppose you want every class in your project to have a describe() method. You can enforce this rule with a metaclass. **Example** ``` class RequireDescribe(type): def __init__(cls, name, bases, dct): if 'describe' not in dct: raise TypeError(f"Class {name} must define a 'describe' method") super().__init__(name, bases, dct) # This will work class Animal(metaclass=RequireDescribe): def describe(self): return "This is an animal" # This will raise an error class Plant(metaclass=RequireDescribe): pass ``` 👉 The Plant class raises an error because it does not define the required describe() method. ## 📌 Metaclasses vs. Class Decorators You might ask: why not use class decorators? Class decorators can change or add things to a class, but metaclasses are more powerful. Metaclasses can affect deeper things, like inheritance rules and method resolution order (MRO), which decorators cannot. ## 🏁 Summary Metaclasses in Python are the blueprints for classes, just like classes are blueprints for objects. By default, Python uses the type metaclass, but you can create your own to enforce rules, modify behavior, or add features to classes. While they are rarely needed in everyday programming, metaclasses are very powerful and are widely used in frameworks and libraries to give developers more control over how classes behave.