元类（Metaclass）和抽象类

1.元类（Metaclass）

元类是用于创建类的类。它定义了类的创建行为，可以控制类的属性、方法的创建和修改。

1.日志记录：在创建类时自动添加日志记录相关的方法。

class LoggingMeta(type):
    def __new__(cls, name, bases, attrs):
        def log_method_call(func):
            def wrapper(*args, **kwargs):
                print(f"Calling {func.__name__}")
                return func(*args, **kwargs)
            return wrapper

        for key, value in attrs.items():
            if callable(value):
                attrs[key] = log_method_call(value)
        return super().__new__(cls, name, bases, attrs)

class MyLoggingClass(metaclass=LoggingMeta):
    def my_method(self):
        print("Method executed")

 

 2.权限控制：确保类具有特定的权限属性或方法。

class PermissionMeta(type):
    def __new__(cls, name, bases, attrs):
        if 'required_permission' not in attrs:
            raise TypeError("Class must have 'required_permission' attribute")
        return super().__new__(cls, name, bases, attrs)

class ProtectedClass(metaclass=PermissionMeta):
    required_permission = "admin"

 

3.据库映射：自动将类属性与数据库字段关联。

class DBMappingMeta(type):
    def __new__(cls, name, bases, attrs):
        # 假设这里有映射逻辑
        attrs['table_name'] = name.lower()
        return super().__new__(cls, name, bases, attrs)

class User(metaclass=DBMappingMeta):
    pass

 

4.单例模式：确保类只能创建一个实例。

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 SingletonClass(metaclass=SingletonMeta):
    pass

 

5.缓存管理：自动处理类方法的缓存逻辑

class CacheMeta(type):
    def __new__(cls, name, bases, attrs):
        def cache_method(func):
            cache = {}
            def wrapper(*args):
                if args in cache:
                    return cache[args]
                result = func(*args)
                cache[args] = result
                return result
            return wrapper

        for key, value in attrs.items():
            if callable(value):
                attrs[key] = cache_method(value)
        return super().__new__(cls, name, bases, attrs)

class CachedClass(metaclass=CacheMeta):
    def expensive_calculation(self, n):
        print(f"Calculating for {n}")
        return n * 2

 

6.序列化：自动添加序列化和反序列化方法

class SerializationMeta(type):
    def __new__(cls, name, bases, attrs):
        def serialize_method(self):
            # 序列化逻辑
            pass
        attrs['serialize'] = serialize_method
        return super().__new__(cls, name, bases, attrs)

class SerializableClass(metaclass=SerializationMeta):
    pass

 

7.版本控制：跟踪类的版本信息

class VersioningMeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['version'] = 1
        return super().__new__(cls, name, bases, attrs)

class VersionedClass(metaclass=VersioningMeta):
    pass

 

8.动态属性添加：根据某些条件动态添加属性

class DynamicAttributeMeta(type):
    def __new__(cls, name, bases, attrs):
        if some_condition:
            attrs['dynamic_attribute'] = 'Dynamic value'
        return super().__new__(cls, name, bases, attrs)

class DynamicClass(metaclass=DynamicAttributeMeta):
    pass

 

9.验证器：自动添加属性验证逻辑

class ValidatorMeta(type):
    def __new__(cls, name, bases, attrs):
        def validate_attribute(func):
            def wrapper(self, value):
                if not validate(value):
                    raise ValueError("Invalid value")
                return func(self, value)
            return wrapper

        for key, value in attrs.items():
            if key.startswith('set_'):
                attrs[key] = validate_attribute(value)
        return super().__new__(cls, name, bases, attrs)

class ValidatedClass(metaclass=ValidatorMeta):
    def set_value(self, value):
        self._value = value

 

10.扩展功能集成：将多个扩展功能集成到类中

class ExtensionIntegrationMeta(type):
    def __new__(cls, name, bases, attrs):
        def extension_method(self):
            # 扩展功能逻辑
            pass
        attrs['extension_method'] = extension_method
        return super().__new__(cls, name, bases, attrs)

class ExtendedClass(metaclass=ExtensionIntegrationMeta):
    pass

 

抽象类

抽象类是一种不能被直接实例化的类，它通常包含一些抽象方法，这些方法在抽象类中没有具体的实现，子类必须实现这些抽象方法。

1.定义接口：为一组相关的类定义公共的接口

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

 

 2.框架设计：为框架中的组件定义基本结构

from abc import ABC, abstractmethod

class DataProcessor(ABC):
    @abstractmethod
    def load_data(self):
        pass
    @abstractmethod
    def process_data(self):
        pass
    @abstractmethod
    def save_data(self):
        pass

class CSVProcessor(DataProcessor):
    def load_data(self):
        print("Loading CSV data")
    def process_data(self):
        print("Processing CSV data")
    def save_data(self):
        print("Saving CSV data")