02-创建型模式¶

# config.py — 模块本身就是单例
class _Config:
    def __init__(self):
        self.debug = False
        self.db_url = "sqlite:///app.db"

    def load(self, path):
        # 从文件加载配置
        ...

config = _Config()  # 全局唯一实例

# 使用：from config import config

# ⚠️ 此实现非线程安全：多线程并发调用时，两个线程可能同时通过 `is None` 检查，
# 从而创建多个实例。如需线程安全，请参考下方「方式四：线程安全的单例」
# 或直接使用模块级实例（方式一）。
class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        # 注意：__init__每次调用都会执行
        if not hasattr(self, '_initialized'):
            self._initialized = True
            self.data = {}

# 测试
a = Singleton()
b = Singleton()
assert a is b  # ✅ 同一个实例

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!"

import threading  # 线程池/多线程：并发执行任务

class ThreadSafeSingleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):  # *args接收任意位置参数；**kwargs接收任意关键字参数
        if cls._instance is None:  # 第一次检查（无锁，性能优化）
            with cls._lock:
                if cls._instance is None:  # 第二次检查（加锁后，保证安全）
                    cls._instance = super().__new__(cls)  # super()调用父类方法
        return cls._instance

from abc import ABC, abstractmethod

# 产品接口
class Notification(ABC):
    @abstractmethod
    def send(self, message: str) -> None:
        pass

# 具体产品
class EmailNotification(Notification):
    def send(self, message):
        print(f"📧 Email: {message}")

class SMSNotification(Notification):
    def send(self, message):
        print(f"📱 SMS: {message}")

class PushNotification(Notification):
    def send(self, message):
        print(f"🔔 Push: {message}")

# 工厂接口
class NotificationFactory(ABC):
    @abstractmethod
    def create_notification(self) -> Notification:
        pass

    def notify(self, message):
        """模板方法：使用工厂方法创建对象并发送通知"""
        notification = self.create_notification()
        notification.send(message)

# 具体工厂
class EmailFactory(NotificationFactory):
    def create_notification(self):
        return EmailNotification()

class SMSFactory(NotificationFactory):
    def create_notification(self):
        return SMSNotification()

# 简单工厂（变体：集中创建逻辑）
class SimpleNotificationFactory:
    @staticmethod  # @staticmethod静态方法，不需要实例
    def create(channel: str) -> Notification:
        factories = {
            "email": EmailNotification,
            "sms": SMSNotification,
            "push": PushNotification,
        }
        if channel not in factories:
            raise ValueError(f"Unknown channel: {channel}")
        return factories[channel]()

# 使用
factory = EmailFactory()
factory.notify("Your order has been shipped!")

notification = SimpleNotificationFactory.create("push")
notification.send("New message received!")

from abc import ABC, abstractmethod

# ====== 抽象产品 ======
class Button(ABC):
    @abstractmethod
    def render(self): pass

class TextBox(ABC):
    @abstractmethod
    def render(self): pass

# ====== Windows产品族 ======
class WindowsButton(Button):
    def render(self):
        return "[Windows Button]"

class WindowsTextBox(TextBox):
    def render(self):
        return "[Windows TextBox]"

# ====== macOS产品族 ======
class MacButton(Button):
    def render(self):
        return "(Mac Button)"

class MacTextBox(TextBox):
    def render(self):
        return "(Mac TextBox)"

# ====== 抽象工厂 ======
class UIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button: pass

    @abstractmethod
    def create_textbox(self) -> TextBox: pass

class WindowsFactory(UIFactory):
    def create_button(self): return WindowsButton()
    def create_textbox(self): return WindowsTextBox()

class MacFactory(UIFactory):
    def create_button(self): return MacButton()
    def create_textbox(self): return MacTextBox()

# ====== 客户端代码 ======
def create_ui(factory: UIFactory):
    """客户端只依赖抽象工厂，不关心具体产品族"""
    button = factory.create_button()
    textbox = factory.create_textbox()
    print(button.render(), textbox.render())

# 根据运行环境选择工厂
import platform
factory = WindowsFactory() if platform.system() == "Windows" else MacFactory()
create_ui(factory)

class Computer:
    """产品：电脑"""
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.storage = None
        self.gpu = None
        self.os = None

    def __str__(self):
        parts = [f"CPU: {self.cpu}", f"RAM: {self.ram}", f"Storage: {self.storage}"]
        if self.gpu:
            parts.append(f"GPU: {self.gpu}")
        if self.os:
            parts.append(f"OS: {self.os}")
        return " | ".join(parts)

class ComputerBuilder:
    """建造者：链式调用风格"""
    def __init__(self):
        self._computer = Computer()

    def cpu(self, cpu: str) -> 'ComputerBuilder':
        self._computer.cpu = cpu
        return self  # 返回self实现链式调用

    def ram(self, ram: str) -> 'ComputerBuilder':
        self._computer.ram = ram
        return self

    def storage(self, storage: str) -> 'ComputerBuilder':
        self._computer.storage = storage
        return self

    def gpu(self, gpu: str) -> 'ComputerBuilder':
        self._computer.gpu = gpu
        return self

    def os(self, os: str) -> 'ComputerBuilder':
        self._computer.os = os
        return self

    def build(self) -> Computer:
        """构建最终产品"""
        computer = self._computer
        self._computer = Computer()  # 重置，以便复用Builder
        return computer

# 使用：链式调用，清晰易读
gaming_pc = (ComputerBuilder()
    .cpu("Intel i9-13900K")
    .ram("32GB DDR5")
    .storage("2TB NVMe SSD")
    .gpu("RTX 4090")
    .os("Windows 11")
    .build())

office_pc = (ComputerBuilder()
    .cpu("Intel i5-13400")
    .ram("16GB DDR4")
    .storage("512GB SSD")
    .os("Ubuntu 22.04")
    .build())

print(gaming_pc)
print(office_pc)

from dataclasses import dataclass, field

@dataclass  # 自动生成__init__等方法
class ServerConfig:
    """Python中dataclass + 默认值常可替代Builder"""
    host: str = "localhost"
    port: int = 8080
    workers: int = 4
    debug: bool = False
    timeout: int = 30
    ssl: bool = False
    cert_path: str = ""

# 使用：命名参数即可
config = ServerConfig(host="0.0.0.0", port=443, ssl=True, cert_path="/etc/ssl/cert.pem")

import copy

class Address:
    def __init__(self, city, street):
        self.city = city
        self.street = street

class Person:
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address  # 引用类型

    def clone(self):
        """浅拷贝：内部的引用对象仍指向同一实例"""
        return copy.copy(self)

    def deep_clone(self):
        """深拷贝：完全独立的副本"""
        return copy.deepcopy(self)

# 演示区别
original = Person("Alice", 30, Address("Beijing", "Main St"))

# 浅拷贝
shallow = original.clone()
shallow.name = "Bob"              # 修改值类型 → 不影响原对象 ✅
shallow.address.city = "Shanghai" # 修改引用类型 → 影响原对象！❌
print(original.address.city)  # "Shanghai" — 被修改了！

# 深拷贝
deep = original.deep_clone()
deep.address.city = "Shenzhen"
print(original.address.city)  # "Shanghai" — 不受影响 ✅

from abc import ABC, abstractmethod  # ABC抽象基类；abstractmethod强制子类实现
import copy

class Prototype(ABC):
    @abstractmethod
    def clone(self):
        pass

class GameCharacter(Prototype):
    def __init__(self, name, level, skills, equipment):
        self.name = name
        self.level = level
        self.skills = skills      # list
        self.equipment = equipment  # dict

    def clone(self):
        return copy.deepcopy(self)

    def __str__(self):
        return f"{self.name} (Lv.{self.level}) Skills:{self.skills}"

# 原型注册表
class CharacterRegistry:
    def __init__(self):
        self._prototypes = {}

    def register(self, name, prototype):
        self._prototypes[name] = prototype

    def create(self, name, **overrides):
        prototype = self._prototypes.get(name)
        if prototype is None:
            raise ValueError(f"Unknown prototype: {name}")
        clone = prototype.clone()
        for key, value in overrides.items():
            setattr(clone, key, value)  # hasattr/getattr/setattr动态操作对象属性
        return clone

# 注册原型
registry = CharacterRegistry()
registry.register("warrior", GameCharacter(
    "Warrior", 1, ["Slash", "Block"], {"weapon": "Sword", "armor": "Shield"}
))
registry.register("mage", GameCharacter(
    "Mage", 1, ["Fireball", "Heal"], {"weapon": "Staff", "armor": "Robe"}
))

# 基于原型创建新角色
player1 = registry.create("warrior", name="Arthur", level=10)
player2 = registry.create("mage", name="Merlin", level=8)
print(player1)  # Arthur (Lv.10) Skills:['Slash', 'Block']
print(player2)  # Merlin (Lv.8) Skills:['Fireball', 'Heal']