Python 设计模式全解析#

def get_serializer(fmt: str):
    """根据格式返回对应的序列化工具"""
    if fmt == "json":
        return lambda data: f"JSON: {str(data).replace(' ', '')}"
    if fmt == "xml":
        return lambda data: f"<xml>{data}</xml>"
    # 默认返回字符串转义版？不，直接原生str更灵活
    return str

# 业务调用方的代码
if __name__ == "__main__":
    user = {"name": "Alice", "age": 28}
    # 只传格式参数，完全不知道内部用了lambda还是str
    json_serializer = get_serializer("json")
    print(json_serializer(user))

# 定义两个「产品族」的成员类
class DarkComponent:
    get_bg = lambda self: "#000000"
    get_text = lambda self: "#FFFFFF"

class LightComponent:
    get_bg = lambda self: "#FFFFFF"
    get_text = lambda self: "#000000"

# 抽象工厂（统一返回家族成员的入口）
def get_theme_factory(mode: str):
    if mode == "dark":
        return DarkComponent
    if mode == "light":
        return LightComponent
    raise ValueError(f"不支持的主题模式: {mode}")

# 业务调用方
if __name__ == "__main__":
    # 选一个模式，拿到整个家族的工厂
    theme_factory = get_theme_factory("dark")
    # 直接取家族里的所有关联组件，绝对不会出现「暗黑背景配亮瞎眼的黑字」
    print(f"背景色: {theme_factory.get_bg()}, 文字色: {theme_factory.get_text()}")

class LargeFileLoader:
    def __init__(self, file_path: str):
        self.file_path = file_path
        # 提前占位，不真的加载
        self._content = None

    @property
    def content(self):
        """第一次访问content属性时才加载文件"""
        if self._content is None:
            print(f"⏳ 首次加载大文件: {self.file_path}...")
            # 真实场景用open，这里模拟
            self._content = ["行1", "行2", "行3", "行..."] * 10000
        return self._content

# 业务调用方
if __name__ == "__main__":
    loader = LargeFileLoader("超大日志.txt")
    # 此时还没加载！！
    print("对象初始化完成，文件未加载")
    # 第一次print才会触发加载
    print(f"文件内容前2行: {loader.content[:2]}")
    # 第二次直接用缓存，不会再加载
    print(f"文件总行数（复用缓存）: {len(loader.content)}")

class SingletonMeta(type):
    """元类：控制类的创建过程"""
    _instances = {}

    def __call__(cls, *args, **kwargs):
        """当调用类（比如AppConfig()）时触发"""
        if cls not in cls._instances:
            # 先占个位置？或者直接加锁？这里是简化版单线程
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

# 实际的单例类
class AppConfig(metaclass=SingletonMeta):
    def __init__(self):
        # 这里的初始化只会在第一次调用时执行！！
        print("🔧 首次加载配置...")
        self.db_host = "localhost"
        self.db_port = 3306

# 测试单例
if __name__ == "__main__":
    config1 = AppConfig()
    config2 = AppConfig()
    # 两个变量指向同一个对象
    print(f"config1 == config2? {config1 == config2}")
    print(f"config1的地址: {id(config1)}, config2的地址: {id(config2)}")

# 定义两个装饰器
def bold(func):
    """给返回值加<b>标签"""
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return f"<b>{result}</b>"
    return wrapper

def italic(func):
    """给返回值加<i>标签"""
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return f"<i>{result}</i>"
    return wrapper

# 业务函数，用@语法糖叠加装饰器（注意顺序：从下往上生效）
@bold
@italic
def say_hello(name: str):
    return f"Hello, {name}!"

# 测试
if __name__ == "__main__":
    print(say_hello("Bob"))  # 输出: <b><i>Hello, Bob!</i></b>

# 1. 原生用法（Python内置容器全支持，比如list/dict/set/str）
if __name__ == "__main__":
    print("--- 原生list迭代器 ---")
    my_list = [10, 20, 30]
    # iter()拿到迭代器对象
    it = iter(my_list)
    # next()逐个取元素，取完会抛StopIteration异常
    print(next(it))  # 10
    print(next(it))  # 20
    print(next(it))  # 30
    # print(next(it))  # 这里会报错

# 2. 自定义简单迭代器（实现__iter__和__next__）
class EvenNumberIterator:
    """生成0到max_num的所有偶数的迭代器"""
    def __init__(self, max_num: int):
        self.max_num = max_num
        self.current = 0

    def __iter__(self):
        """必须返回自己，因为迭代器本身也是可迭代对象"""
        return self

    def __next__(self):
        """返回下一个偶数，超过max_num就抛异常"""
        if self.current > self.max_num:
            raise StopIteration
        result = self.current
        self.current += 2
        return result

# 测试自定义迭代器
if __name__ == "__main__":
    print("\n--- 自定义偶数迭代器 ---")
    even_it = EvenNumberIterator(10)
    # 可以直接用for循环（Python的for本质上就是调用iter()和next()）
    for num in even_it:
        print(num)