Python treats everything as an object, including classes themselves. This allows you to dynamically manipulate and modify classes, objects, functions, and their behavior at runtime. This powerful capability is known as metaprogramming. Metaprogramming allows programs to inspect, modify, or generate code during execution. Python supports metaprogramming using features like metaclasses, dynamic attribute/method creation, and the type() function.

Metaprogramming is a technique where code writes or manipulates other code. In Python, it typically involves:
- Modifying class definitions at runtime.
- Dynamically creating or altering attributes and methods.
- Customizing class creation using metaclasses.
- Using the built-in type() function to generate new classes on the fly.
It allows you to:
- Reduce boilerplate code.
- Implement Domain Specific Languages (DSLs).
- Create powerful APIs and frameworks.

A metaclass is a 'class of a class'. Just like classes define how objects behave, metaclasses define how classes behave. By default, every class in Python is created using the type metaclass:
type(MyClass) #
This means:
- Objects are instances of classes.
- Classes are instances of metaclasses.

When you define a class:
class Foo:
pass
Python internally does:
Foo = type('Foo', (), {})
Where:
- 'Foo' is the class name.
- () is the base classes tuple.
- {} is the class dictionary (methods/attributes).
So, type is the metaclass that creates Foo.

You can define your own metaclass to control how classes are created.
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)
Using the Metaclass
You attach it to a class using the metaclass keyword:
class MyClass(metaclass=Meta):
pass
print(MyClass.created_by) # Output: MetaClass

Python classes are mutable, so you can change them after they are defined.
Adding Attributes or Methods at Runtime
class Animal:
pass
Animal.legs = 4
def speak(self):
return 'Roar'
Animal.speak = speak
lion = Animal()
print(lion.legs) # 4
print(lion.speak()) # Roar
This technique is often used in frameworks (like Django or Flask) to inject behavior.

The type function can be used directly to dynamically generate classes.
Syntax:
type(class_name, bases, dict)
Example:
def greet(self):
print('Hello')
HelloClass = type('HelloClass', (object,), {'greet': greet})
obj = HelloClass()
obj.greet() # Output: Hello
This is useful when class structure depends on runtime data or configuration files.

Using setattr() to Add Dynamically
class Person:
pass
p = Person()
setattr(p, 'name', 'Alice')
print(p.name) # Output: Alice
setattr(Person, 'greet', lambda self: f'Hi, I am {self.name}')
print(p.greet()) # Hi, I am Alice
Automatically Populating Attributes
class AutoAttr:
def init(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
user = AutoAttr(name='John', age=30)
print(user.name, user.age) # Output: John 30

1. ORM (Object Relational Mappers)
   Frameworks like Django use metaclasses to define how database models map to tables:
   class User(Model):
   name = StringField()
   age = IntegerField()
   The metaclass transforms the class into a SQL table definition.
2. Validation Frameworks
   You can automatically add validation logic using metaclasses or decorators:
   class ValidateMeta(type):
   def new(cls, name, bases, dct):
   if 'validate' not in dct:
   raise TypeError('Must define validate method')
   return super().new(cls, name, bases, dct)
3. API Frameworks
   FastAPI and Flask use decorators and dynamic method binding to route requests to handler functions.
4. Plugins and Hooks
   You can dynamically register functions using metaprogramming:
   registry = {}
   def register(func):
   registry[func.name] = func
   return func
   @register
   def greet():
   return 'Hello'
   print(registry'greet') # Output: Hello