Python - Metaprogramming with Metaclasses

In Python, Metaprogramming refers to the practice of writing code that has knowledge of itself and can be manipulated. The metaclasses are a powerful tool for metaprogramming in Python, allowing you to customize how classes are created and behave. Using metaclasses, you can create more flexible and efficient programs through dynamic code generation and reflection.

Metaprogramming in Python involves techniques such as decorators and metaclasses. In this tutorial, you will learn about metaprogramming with metaclasses by exploring dynamic code generation and reflection.

Defining Metaclasses

Metaprogramming with metaclasses in Python offer advanced features of enabling advanced capabilities to your program. One such feature is the __prepare__() method, which allows customization of the namespace where a class body will be executed.

This method is called before any class body code is executed, providing a way to initialize the class namespace with additional attributes or methods. The __prepare__() method should be implemented as a classmethod.

Example

Here is an example of creating metaclass with advanced features using the __prepare__() method.

 
class MyMetaClass(type):
   @classmethod
   def __prepare__(cls, name, bases, **kwargs):
      print(f'Preparing namespace for {name}')

      # Customize the namespace preparation here
      custom_namespace = super().__prepare__(name, bases, **kwargs)
      custom_namespace['CONSTANT_VALUE'] = 100  

      return custom_namespace

# Define a class using the custom metaclass
class MyClass(metaclass=MyMetaClass):
   def __init__(self, value):
      self.value = value
    
   def display(self):
       print(f"Value: {self.value}, Constant: {self.__class__.CONSTANT_VALUE}")

# Instantiate the class
obj = MyClass(42)
obj.display()

Output

While executing above code, you will get the following results −

Preparing namespace for MyClass
Value: 42, Constant: 100

Dynamic Code Generation with Metaclasses

Metaprogramming with metaclasses enables the creation or modification of code during runtime.

Example

This example demonstrates how metaclasses in Python metaprogramming can be used for dynamic code generation.

class MyMeta(type):
   def __new__(cls, name, bases, attrs):
      print(f"Defining class: {name}") 
        
      # Dynamic attribute to the class
      attrs['dynamic_attribute'] = 'Added dynamically'
        
      # Dynamic method to the class
      def dynamic_method(self):
         return f"This is a dynamically added method for {name}"
        
      attrs['dynamic_method'] = dynamic_method
        
      return super().__new__(cls, name, bases, attrs)

# Define a class using the metaclass
class MyClass(metaclass=MyMeta):
   pass

obj = MyClass()
print(obj.dynamic_attribute)       
print(obj.dynamic_method())

Output

On executing above code, you will get the following results −

Defining class: MyClass
Added dynamically
This is a dynamically added method for MyClass

Reflection and Metaprogramming

Metaprogramming with metaclasses often involves reflection, allowing for introspection and modification of class attributes and methods at runtime.

Example

In this example, the MyMeta metaclass inspects and prints the attributes of the MyClass during its creation, demonstrating how metaclasses can introspect and modify class definitions dynamically.

class MyMeta(type):
   def __new__(cls, name, bases, dct):
      # Inspect class attributes and print them
      print(f"Class attributes for {name}: {dct}")
      return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
   data = "example"

Output

On executing above code, you will get the following results −

Class attributes for MyClass: {'__module__': '__main__', '__qualname__': 'MyClass', 'data': 'example'}