Python 元编程详解

元编程的基本概念

元编程是指编写能够操作、生成或修改代码的代码。Python 提供了丰富的元编程工具，包括装饰器、元类、动态属性等。

元编程的应用场景

框架开发（如 Django ORM）
代码生成和自动化
动态属性和方法创建
面向切面编程（AOP）
序列化和反序列化

元类（Metaclass）

什么是元类

元类是创建类的类，就像类是创建对象的模板一样，元类是创建类的模板。

python
# 基本概念
class MyClass:
    pass

# MyClass 是 type 的实例
print(type(MyClass))  # <class 'type'>

# obj 是 MyClass 的实例
obj = MyClass()
print(type(obj))  # <class '__main__.MyClass'>

自定义元类

python
class MyMeta(type):
    def __new__(cls, name, bases, namespace):
        # 在类创建时执行
        print(f"Creating class: {name}")
        # 添加类属性
        namespace['created_by'] = 'MyMeta'
        return super().__new__(cls, name, bases, namespace)

class MyClass(metaclass=MyMeta):
    pass

print(MyClass.created_by)  # MyMeta

元类的作用

python
class SingletonMeta(type):
    """单例元类"""
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(metaclass=SingletonMeta):
    def __init__(self, value):
        self.value = value

s1 = Singleton(1)
s2 = Singleton(2)

print(s1 is s2)  # True
print(s1.value)  # 2

元类的高级用法

python
class ValidateMeta(type):
    """验证元类"""
    def __new__(cls, name, bases, namespace):
        # 确保类有特定的属性
        if 'required_attr' not in namespace:
            raise TypeError(f"{name} must have 'required_attr'")
        
        # 验证方法
        for attr_name, attr_value in namespace.items():
            if callable(attr_value) and not attr_name.startswith('_'):
                if not hasattr(attr_value, '__annotations__'):
                    raise TypeError(f"Method {attr_name} must have type hints")
        
        return super().__new__(cls, name, bases, namespace)

class ValidatedClass(metaclass=ValidateMeta):
    required_attr = "value"
    
    def method(self, x: int) -> int:
        return x * 2

# class InvalidClass(metaclass=ValidateMeta):
#     pass  # TypeError: InvalidClass must have 'required_attr'

动态属性和方法

动态属性

python
class DynamicAttributes:
    def __init__(self):
        self._data = {}
    
    def __getattr__(self, name):
        """访问不存在的属性时调用"""
        if name.startswith('get_'):
            attr_name = name[4:]
            return self._data.get(attr_name)
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
    
    def __setattr__(self, name, value):
        """设置属性时调用"""
        if name.startswith('_'):
            super().__setattr__(name, value)
        else:
            self._data[name] = value
    
    def __delattr__(self, name):
        """删除属性时调用"""
        if name in self._data:
            del self._data[name]
        else:
            super().__delattr__(name)

obj = DynamicAttributes()
obj.name = "Alice"
obj.age = 25

print(obj.get_name)  # Alice
print(obj.get_age)  # 25

动态方法

python
class DynamicMethods:
    def __init__(self):
        self.methods = {}
    
    def add_method(self, name, func):
        """动态添加方法"""
        self.methods[name] = func
    
    def __getattr__(self, name):
        """动态调用方法"""
        if name in self.methods:
            return self.methods[name]
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

obj = DynamicMethods()

# 动态添加方法
obj.add_method('greet', lambda self, name: f"Hello, {name}!")
obj.add_method('calculate', lambda self, x, y: x + y)

print(obj.greet("Alice"))  # Hello, Alice!
print(obj.calculate(3, 5))  # 8

使用 types 模块创建方法

python
import types

class MyClass:
    pass

def new_method(self):
    return "This is a dynamically added method"

# 动态添加方法
MyClass.new_method = new_method

obj = MyClass()
print(obj.new_method())  # This is a dynamically added method

# 使用 types.MethodType
def another_method(self, value):
    return f"Value: {value}"

obj.another_method = types.MethodType(another_method, obj)
print(obj.another_method(42))  # Value: 42

描述符（Descriptor）

描述符协议

描述符是实现 __get__、__set__ 和 __delete__ 方法的类，用于控制属性的访问。

python
class Descriptor:
    def __init__(self, name=None):
        self.name = name
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name, f"No {self.name} set")
    
    def __set__(self, instance, value):
        instance.__dict__[self.name] = value
    
    def __delete__(self, instance):
        if self.name in instance.__dict__:
            del instance.__dict__[self.name]

class Person:
    name = Descriptor('name')
    age = Descriptor('age')

person = Person()
person.name = "Alice"
person.age = 25

print(person.name)  # Alice
print(person.age)  # 25

描述符的应用

python
class ValidatedAttribute:
    """验证属性描述符"""
    def __init__(self, validator=None, default=None):
        self.validator = validator
        self.default = default
        self.name = None
    
    def __set_name__(self, owner, name):
        self.name = f"_{name}"
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return getattr(instance, self.name, self.default)
    
    def __set__(self, instance, value):
        if self.validator and not self.validator(value):
            raise ValueError(f"Invalid value for {self.name}: {value}")
        setattr(instance, self.name, value)

class User:
    name = ValidatedAttribute(lambda x: isinstance(x, str) and len(x) > 0)
    age = ValidatedAttribute(lambda x: isinstance(x, int) and 0 <= x <= 150)
    email = ValidatedAttribute(lambda x: '@' in x)

user = User()
user.name = "Alice"
user.age = 25
user.email = "alice@example.com"

print(user.name)  # Alice
print(user.age)  # 25

# user.age = -5  # ValueError: Invalid value for _age: -5

属性装饰器

@property 装饰器

python
class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        """获取摄氏温度"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        """设置摄氏温度"""
        if value < -273.15:
            raise ValueError("Temperature below absolute zero")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        """获取华氏温度（只读）"""
        return self._celsius * 9/5 + 32

temp = Temperature(25)
print(temp.celsius)  # 25
print(temp.fahrenheit)  # 77.0

temp.celsius = 30
print(temp.celsius)  # 30

# temp.fahrenheit = 100  # AttributeError: can't set attribute

动态属性计算

python
class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError("Radius must be positive")
        self._radius = value
    
    @property
    def diameter(self):
        return self._radius * 2
    
    @property
    def area(self):
        return 3.14159 * self._radius ** 2
    
    @property
    def circumference(self):
        return 2 * 3.14159 * self._radius

circle = Circle(5)
print(circle.diameter)  # 10
print(circle.area)  # 78.53975
print(circle.circumference)  # 31.4159

动态类创建

使用 type 创建类

python
# 动态创建类
def __init__(self, name):
    self.name = name

def greet(self):
    return f"Hello, {self.name}!"

# 使用 type 创建类
DynamicClass = type(
    'DynamicClass',
    (object,),
    {
        '__init__': __init__,
        'greet': greet,
        'class_var': 'dynamic'
    }
)

obj = DynamicClass("Alice")
print(obj.greet())  # Hello, Alice!
print(obj.class_var)  # dynamic

动态创建子类

python
def create_subclass(base_class, subclass_name, extra_methods=None):
    """动态创建子类"""
    namespace = extra_methods or {}
    return type(subclass_name, (base_class,), namespace)

class Base:
    def base_method(self):
        return "Base method"

# 动态创建子类
extra_methods = {
    'extra_method': lambda self: "Extra method"
}

SubClass = create_subclass(Base, 'SubClass', extra_methods)

obj = SubClass()
print(obj.base_method())  # Base method
print(obj.extra_method())  # Extra method

类装饰器

基本类装饰器

python
def add_class_method(cls):
    """添加类方法的装饰器"""
    @classmethod
    def class_method(cls):
        return f"Class method of {cls.__name__}"
    
    cls.class_method = class_method
    return cls

@add_class_method
class MyClass:
    pass

print(MyClass.class_method())  # Class method of MyClass

类装饰器的应用

python
def singleton(cls):
    """单例类装饰器"""
    instances = {}
    
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    
    return get_instance

@singleton
class Database:
    def __init__(self):
        self.connection = "Connected"

db1 = Database()
db2 = Database()

print(db1 is db2)  # True

参数化类装饰器

python
def add_attributes(**attrs):
    """添加类属性的装饰器"""
    def decorator(cls):
        for name, value in attrs.items():
            setattr(cls, name, value)
        return cls
    return decorator

@add_attributes(version="1.0", author="Alice")
class MyClass:
    pass

print(MyClass.version)  # 1.0
print(MyClass.author)  # Alice

实际应用场景

1. ORM 框架

python
class Field:
    """字段描述符"""
    def __init__(self, field_type, primary_key=False):
        self.field_type = field_type
        self.primary_key = primary_key
        self.name = None
    
    def __set_name__(self, owner, name):
        self.name = name
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name)
    
    def __set__(self, instance, value):
        if not isinstance(value, self.field_type):
            raise TypeError(f"Expected {self.field_type}, got {type(value)}")
        instance.__dict__[self.name] = value

class ModelMeta(type):
    """模型元类"""
    def __new__(cls, name, bases, namespace):
        # 收集字段
        fields = {}
        for key, value in namespace.items():
            if isinstance(value, Field):
                fields[key] = value
        namespace['_fields'] = fields
        return super().__new__(cls, name, bases, namespace)

class Model(metaclass=ModelMeta):
    def __init__(self, **kwargs):
        for name, value in kwargs.items():
            setattr(self, name, value)

class User(Model):
    id = Field(int, primary_key=True)
    name = Field(str)
    age = Field(int)

user = User(id=1, name="Alice", age=25)
print(user.name)  # Alice
print(user.age)  # 25

2. API 响应验证

python
class ValidatedResponse:
    """验证响应类"""
    def __init__(self, schema):
        self.schema = schema
    
    def __call__(self, cls):
        def __init__(self, data):
            self.validate(data)
            for key, value in data.items():
                setattr(self, key, value)
        
        def validate(self, data):
            for field, field_type in self.schema.items():
                if field not in data:
                    raise ValueError(f"Missing field: {field}")
                if not isinstance(data[field], field_type):
                    raise TypeError(f"Invalid type for {field}")
        
        cls.__init__ = __init__
        cls.validate = validate
        return cls

@ValidatedResponse({'name': str, 'age': int, 'email': str})
class UserResponse:
    pass

user_data = {'name': 'Alice', 'age': 25, 'email': 'alice@example.com'}
user = UserResponse(user_data)
print(user.name)  # Alice

3. 动态表单生成

python
class FormField:
    """表单字段"""
    def __init__(self, field_type, required=False, default=None):
        self.field_type = field_type
        self.required = required
        self.default = default
        self.name = None
    
    def __set_name__(self, owner, name):
        self.name = name
    
    def validate(self, value):
        if self.required and value is None:
            raise ValueError(f"{self.name} is required")
        if value is not None and not isinstance(value, self.field_type):
            raise TypeError(f"Invalid type for {self.name}")
        return True

class FormMeta(type):
    """表单元类"""
    def __new__(cls, name, bases, namespace):
        fields = {}
        for key, value in namespace.items():
            if isinstance(value, FormField):
                fields[key] = value
        namespace['_fields'] = fields
        return super().__new__(cls, name, bases, namespace)

class Form(metaclass=FormMeta):
    def __init__(self, **kwargs):
        for name, field in self._fields.items():
            value = kwargs.get(name, field.default)
            field.validate(value)
            setattr(self, name, value)
    
    def to_dict(self):
        return {name: getattr(self, name) for name in self._fields}

class UserForm(Form):
    name = FormField(str, required=True)
    age = FormField(int, default=18)
    email = FormField(str, required=True)

form = UserForm(name="Alice", email="alice@example.com")
print(form.to_dict())  # {'name': 'Alice', 'age': 18, 'email': 'alice@example.com'}

最佳实践

1. 谨慎使用元类

python
# 不好的做法 - 过度使用元类
class ComplexMeta(type):
    def __new__(cls, name, bases, namespace):
        # 复杂的元类逻辑
        pass

# 好的做法 - 使用类装饰器
def add_functionality(cls):
    # 添加功能
    return cls

@add_functionality
class SimpleClass:
    pass

2. 优先使用描述符而非 getattr

python
# 好的做法 - 使用描述符
class ValidatedField:
    def __get__(self, instance, owner):
        return instance.__dict__.get(self.name)
    
    def __set__(self, instance, value):
        instance.__dict__[self.name] = value

class MyClass:
    field = ValidatedField()

# 不好的做法 - 使用 __getattr__
class BadClass:
    def __getattr__(self, name):
        return self.__dict__.get(name)

3. 提供清晰的文档

python
class MyMeta(type):
    """自定义元类，用于添加类级别的功能
    
    这个元类会自动为所有类添加 created_at 属性
    """
    def __new__(cls, name, bases, namespace):
        namespace['created_at'] = datetime.now()
        return super().__new__(cls, name, bases, namespace)

4. 考虑性能影响

python
# 缓存属性访问
class CachedProperty:
    def __init__(self, func):
        self.func = func
        self.name = func.__name__
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        if not hasattr(instance, f'_{self.name}'):
            setattr(instance, f'_{self.name}', self.func(instance))
        return getattr(instance, f'_{self.name}')

class MyClass:
    @CachedProperty
    def expensive_computation(self):
        # 耗时计算
        return sum(range(1000000))

总结

Python 元编程的核心概念：

元类：创建类的类，控制类的创建过程
动态属性：使用 __getattr__、__setattr__ 等方法动态管理属性
动态方法：运行时添加和修改方法
描述符：控制属性的访问和修改
属性装饰器：使用 @property 创建计算属性
动态类创建：使用 type 函数动态创建类
类装饰器：修改或增强类的行为

元编程的应用场景：

框架开发（ORM、表单验证）
代码生成和自动化
动态 API 创建
序列化和反序列化
面向切面编程

元编程的注意事项：

谨慎使用，避免过度设计
提供清晰的文档和示例
考虑性能影响
优先使用简单的解决方案

掌握元编程技巧，能够编写出更灵活、更强大的 Python 代码。

Python 元编程有哪些特性和应用场景？