Python 面向对象编程进阶-优快云博客

一、元类（Metaclass）与类创建控制

1. 元类原理

class Meta(type):
    def __new__(cls, name, bases, namespace):
        # 在类创建前拦截
        namespace['version'] = 1.0
        return super().__new__(cls, name, bases, namespace)

class MyClass(metaclass=Meta):
    pass

print(MyClass.version)  # 输出 1.0

2. 类注册模式

class PluginMeta(type):
    registry = {}
    
    def __new__(cls, name, bases, namespace):
        new_class = super().__new__(cls, name, bases, namespace)
        if not namespace.get('abstract'):
            cls.registry[name.lower()] = new_class
        return new_class

class PluginBase(metaclass=PluginMeta):
    abstract = True

二、描述符（Descriptor）协议

1. 数据描述符

class Validated:
    def __set_name__(self, owner, name):
        self.storage_name = name

    def __set__(self, instance, value):
        if not isinstance(value, int):
            raise TypeError("必须是整数")
        instance.__dict__[self.storage_name] = value

    def __get__(self, instance, owner):
        return instance.__dict__.get(self.storage_name, 0)

class Test:
    value = Validated()

2. 延迟计算描述符

class LazyProperty:
    def __init__(self, func):
        self.func = func
        self.cache_name = f"_lazy_{func.__name__}"

    def __get__(self, instance, owner):
        if not instance:
            return self
        if not hasattr(instance, self.cache_name):
            setattr(instance, self.cache_name, self.func(instance))
        return getattr(instance, self.cache_name)

三、上下文管理器协议

1. 基于类的实现

class DatabaseConnection:
    def __enter__(self):
        self.conn = connect_db()
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.conn.close()
        if exc_type:
            print(f"Error occurred: {exc_val}")
        return True  # 抑制异常

2. 状态保持上下文

class Transaction:
    def __init__(self):
        self.operations = []
    
    def __enter__(self):
        self._snapshot = self._take_snapshot()
        return self
    
    def __exit__(self, *args):
        if any(args):
            self._rollback(self._snapshot)
        else:
            self._commit()

四、抽象基类（ABC）高级用法

1. 协议注册

from abc import ABC, abstractmethod
from collections.abc import Iterable

class Stream(ABC):
    @abstractmethod
    def read(self):
        pass

@Stream.register
class SocketStream:
    def read(self):
        # 实现具体逻辑
        return b"data"

2. 泛型约束

from typing import Generic, TypeVar
from abc import ABC

T = TypeVar('T', bound=Stream)

class Processor(Generic[T], ABC):
    def process(self, stream: T) -> bytes:
        return stream.read()

五、混合类（Mixin）设计

1. 功能混入

class JSONSerializableMixin:
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class XMLSerializableMixin:
    def to_xml(self):
        # XML 序列化逻辑
        return "<object>data</object>"

class User(JSONSerializableMixin, XMLSerializableMixin):
    def __init__(self, name):
        self.name = name

2. 方法冲突解决

class BaseA:
    def action(self):
        print("BaseA action")

class BaseB:
    def action(self):
        print("BaseB action")

class Child(BaseA, BaseB):
    def action(self):
        super(BaseA, self).action()  # 显式指定调用链

六、性能优化技巧

1. slots 内存优化

class Point:
    __slots__ = ('x', 'y')  # 禁止动态属性，节省内存
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

2. 弱引用支持

import weakref

class Tree:
    def __init__(self):
        self.parent = None
        self._children = weakref.WeakSet()

    def add_child(self, child):
        self._children.add(child)
        child.parent = weakref.proxy(self)

七、协程与异步对象

1. 异步上下文管理器

class AsyncDatabase:
    async def __aenter__(self):
        self.conn = await connect_async()
        return self.conn

    async def __aexit__(self, *args):
        await self.conn.close()

2. 异步迭代器

class AsyncDataStream:
    def __init__(self, urls):
        self.urls = urls
    
    def __aiter__(self):
        self.index = 0
        return self
    
    async def __anext__(self):
        if self.index >= len(self.urls):
            raise StopAsyncIteration
        url = self.urls[self.index]
        self.index += 1
        return await fetch_async(url)

八、设计模式进阶实现

1. 观察者模式

class Observable:
    def __init__(self):
        self._observers = []

    def register(self, observer):
        self._observers.append(observer)

    def notify(self, *args):
        for observer in self._observers:
            observer.update(*args)

class Observer:
    def update(self, *args):
        print(f"Received update: {args}")

2. 策略模式

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"信用卡支付 {amount}")

class PaymentProcessor:
    def __init__(self, strategy: PaymentStrategy):
        self.strategy = strategy
    
    def execute_payment(self, amount):
        self.strategy.pay(amount)

九、动态类编程

1. 运行时类生成

def create_class(class_name, **methods):
    return type(class_name, (), methods)

DynamicClass = create_class('DynamicClass', 
                          hello=lambda self: print("Hello"),
                          count=0)

2. 装饰器增强类

def log_method_calls(cls):
    for name, method in cls.__dict__.items():
        if callable(method):
            setattr(cls, name, logged(method))
    return cls

def logged(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log_method_calls
class Calculator:
    def add(self, a, b):
        return a + b

十、工程化最佳实践

依赖注入模式

class DatabaseService:
    def __init__(self, connector):
        self.connector = connector

class PostgreSQLConnector:
    def connect(self):
        return "PostgreSQL connection"

service = DatabaseService(PostgreSQLConnector())

领域驱动设计（DDD）

class ValueObject:
    def __eq__(self, other):
        return self.__dict__ == other.__dict__

class Entity:
    def __init__(self, id):
        self.id = id

class DomainService:
    @staticmethod
    def transfer(source, target, amount):
        # 领域业务逻辑
        pass