工厂模式与注册机制

Python进阶编程专题 · Python中灵活的对象创建方式

专题：Python进阶编程系统学习

关键词：Python, 工厂模式, Factory, 简单工厂, 工厂方法, 抽象工厂, 注册, 插件

一、工厂模式概述

工厂模式（Factory Pattern）是面向对象设计中最常用的创建型模式之一。它的核心思想是将对象的创建过程与使用过程分离，客户端通过一个统一的接口请求对象，而不必关心对象的具体类名和构造细节。Python 作为动态语言，在实现工厂模式时具有天然的优势——函数是一等公民、类也是对象、支持运行时导入和反射，这些特性让 Python 中的工厂模式更加灵活和简洁。

在什么场景下需要引入工厂模式？当一个系统需要创建多种类型的产品对象，且这些类型可能在未来扩展时，工厂模式可以将"创建什么"的决策逻辑集中管理，避免在业务代码中散布大量的 if-elif-else 或 match-case 语句。此外，工厂模式也是实现开闭原则（Open/Closed Principle）的重要手段——对扩展开放、对修改封闭。

工厂模式的核心价值：

解耦：调用者与具体实现类解耦，只依赖抽象接口
集中管理：对象创建逻辑集中在一处，便于维护和扩展
延迟创建：可以在运行时根据配置或条件决定创建哪个类
生命周期管理：工厂可以控制对象的创建、缓存和销毁策略

Python 中的工厂模式有多种层级。从最简单的函数工厂，到使用 dict 分发的策略工厂，再到面向对象的工厂方法模式和抽象工厂模式，以及 Python 特有的注册机制。本文将逐一深入讲解，并配合完整的代码示例。

二、简单工厂模式（Simple Factory）

简单工厂是最基础的工厂形式，通常用一个函数（或类方法）根据传入的参数返回不同的对象实例。在 Python 中，由于函数是一等公民，实现简单工厂非常直观。

2.1 基于函数的简单工厂

最基本的实现是通过 if-elif 分支返回不同的类实例。这种方式适合产品种类较少且稳定的场景。

from abc import ABC, abstractmethod


class Animal(ABC):
    @abstractmethod
    def speak(self) -> str:
        pass


class Dog(Animal):
    def speak(self) -> str:
        return "汪汪！"


class Cat(Animal):
    def speak(self) -> str:
        return "喵喵～"


class Duck(Animal):
    def speak(self) -> str:
        return "嘎嘎！"


def animal_factory(animal_type: str) -> Animal:
    """简单工厂函数：根据类型创建动物对象"""
    if animal_type == "dog":
        return Dog()
    elif animal_type == "cat":
        return Cat()
    elif animal_type == "duck":
        return Duck()
    else:
        raise ValueError(f"未知的动物类型: {animal_type}")


# 使用示例
animal = animal_factory("dog")
print(animal.speak())  # 汪汪！

2.2 基于 dict 分发的简单工厂

Python 最为优雅的特性之一是 dict 可以作为 switch-case 的替代方案。将类型名称映射到类对象本身，然后统一调用，无需编写冗长的 if-elif 链条。这种方式在添加新产品时只需修改注册字典，扩展性更好。

# 使用 dict 分发重构简单工厂
_animal_registry: dict[str, type[Animal]] = {
    "dog": Dog,
    "cat": Cat,
    "duck": Duck,
}


def animal_factory_v2(animal_type: str) -> Animal:
    """基于 dict 分发的工厂，无需 if-elif"""
    cls = _animal_registry.get(animal_type)
    if cls is None:
        raise ValueError(f"未知的动物类型: {animal_type}")
    return cls()


# 使用示例
for t in ["dog", "cat", "duck"]:
    print(animal_factory_v2(t).speak())

最佳实践：dict 分发方案的优势在于新增产品类型时只需要向字典中添加新的键值对，无需修改工厂函数的内部逻辑。如果配合配置文件的自动加载，甚至可以做到零代码修改的扩展。

2.3 带参数的构造函数处理

当不同类的构造函数参数不同时，可以使用 functools.partial 或 lambda 进行适配。

from functools import partial


class AnimalV2(ABC):
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    @abstractmethod
    def speak(self) -> str:
        pass


class DogV2(AnimalV2):
    def speak(self) -> str:
        return f"{self.name}({self.age}岁): 汪汪！"


class CatV2(AnimalV2):
    def speak(self) -> str:
        return f"{self.name}({self.age}岁): 喵喵～"


# 当构造函数参数不统一时，用 partial 固定部分参数
_advanced_registry = {
    "dog": partial(DogV2, name="默认狗", age=1),
    "cat": partial(CatV2, name="默认猫", age=1),
}


def advanced_factory(animal_type: str, **kwargs):
    creator = _advanced_registry.get(animal_type)
    if creator is None:
        raise ValueError(f"未知类型: {animal_type}")
    return creator(**kwargs)


# 使用示例
dog = advanced_factory("dog", age=3)
cat = advanced_factory("cat", name="小白", age=2)
print(dog.speak())
print(cat.speak())

三、工厂方法模式（Factory Method）

工厂方法模式是 GoF 设计模式中的经典模式。它定义一个用于创建对象的接口，但让子类决定实例化哪一个类。在 Python 中，通常用一个基类定义工厂方法接口，每个子类实现自己的创建逻辑。

适用场景：当基类无法预知需要创建哪种具体产品时，将创建逻辑推迟到子类中实现。典型的应用包括日志框架（不同日志级别创建不同处理器）、文档转换器（不同格式使用不同导出器）。

from abc import ABC, abstractmethod


# ---------- 产品层次 ----------
class Document(ABC):
    @abstractmethod
    def render(self) -> str:
        pass


class MarkdownDocument(Document):
    def render(self) -> str:
        return "渲染 Markdown 文档"


class PDFDocument(Document):
    def render(self) -> str:
        return "渲染 PDF 文档"


class HTMLDocument(Document):
    def render(self) -> str:
        return "渲染 HTML 文档"


# ---------- 工厂层次 ----------
class DocumentFactory(ABC):
    """抽象工厂，定义工厂方法接口"""

    @abstractmethod
    def create_document(self) -> Document:
        pass

    def open_and_render(self) -> str:
        """模板方法：使用工厂方法"""
        doc = self.create_document()
        # 可以在创建前后加入通用逻辑
        print("正在准备文档环境...")
        result = doc.render()
        print("文档渲染完成。")
        return result


class MarkdownFactory(DocumentFactory):
    def create_document(self) -> Document:
        return MarkdownDocument()


class PDFFactory(DocumentFactory):
    def create_document(self) -> Document:
        return PDFDocument()


class HTMLFactory(DocumentFactory):
    def create_document(self) -> Document:
        return HTMLDocument()


# 使用示例
factory = PDFFactory()
print(factory.open_and_render())  # 渲染 PDF 文档

工厂方法模式相比简单工厂的核心区别在于：简单工厂将创建逻辑集中在一个函数中，而工厂方法模式将创建逻辑分散到各个子类工厂中。这使得每个工厂子类可以拥有更复杂的创建流程，同时也更符合单一职责原则。

简单工厂 vs 工厂方法：

简单工厂：用一个函数/类处理所有产品类型的创建，适合产品较少且变化不频繁的场景
工厂方法：每个产品对应一个工厂子类，适合产品创建过程复杂或需要额外定制逻辑的场景
工厂方法天然支持开闭原则——新增产品只需添加新产品类和对应的工厂子类，无需修改现有代码

四、抽象工厂模式（Abstract Factory）

抽象工厂模式用于创建一系列相关或相互依赖的产品族。客户端通过抽象工厂接口获取整个产品族的各个产品，而不需要知道具体使用的是哪个实现类。

from abc import ABC, abstractmethod


# ---------- 抽象产品 ----------
class Button(ABC):
    @abstractmethod
    def click(self) -> str:
        pass


class Checkbox(ABC):
    @abstractmethod
    def check(self) -> str:
        pass


class ScrollBar(ABC):
    @abstractmethod
    def scroll(self) -> str:
        pass


# ---------- 具体产品族：Windows 风格 ----------
class WindowsButton(Button):
    def click(self) -> str:
        return "Windows 按钮被点击"


class WindowsCheckbox(Checkbox):
    def check(self) -> str:
        return "Windows 复选框被选中"


class WindowsScrollBar(ScrollBar):
    def scroll(self) -> str:
        return "Windows 滚动条在滚动"


# ---------- 具体产品族：Mac 风格 ----------
class MacButton(Button):
    def click(self) -> str:
        return "Mac 按钮被点击"


class MacCheckbox(Checkbox):
    def check(self) -> str:
        return "Mac 复选框被选中"


class MacScrollBar(ScrollBar):
    def scroll(self) -> str:
        return "Mac 滚动条在滚动"


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

    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

    @abstractmethod
    def create_scrollbar(self) -> ScrollBar:
        pass


class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

    def create_checkbox(self) -> Checkbox:
        return WindowsCheckbox()

    def create_scrollbar(self) -> ScrollBar:
        return WindowsScrollBar()


class MacFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacButton()

    def create_checkbox(self) -> Checkbox:
        return MacCheckbox()

    def create_scrollbar(self) -> ScrollBar:
        return MacScrollBar()


# ---------- 客户端 ----------
def render_ui(factory: GUIFactory):
    """客户端代码完全依赖于抽象，不关心具体产品族"""
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    scrollbar = factory.create_scrollbar()
    print(button.click())
    print(checkbox.check())
    print(scrollbar.scroll())


# 使用示例
render_ui(WindowsFactory())
render_ui(MacFactory())

抽象工厂模式在 Python GUI 框架、跨平台工具包中应用广泛。它保证了同一工厂创建的产品之间的一致性。缺点是当产品族需要扩展新产品时，所有工厂接口都需要相应修改，违反了开闭原则。Python 中可以通过在抽象工厂中提供默认实现来缓解这一问题。

五、注册机制与自动发现

Python 提供了极其强大的元编程能力，使得工厂模式的注册机制可以做到自动化和声明式。最常用的两种技术是 __init_subclass__ 钩子和 装饰器注册。

5.1 使用 __init_subclass__ 自动注册

Python 3.6 引入的 __init_subclass__ 方法允许在父类中定义一个钩子，每当有子类被定义时自动触发。这天然适合工厂注册场景。

from abc import ABC, abstractmethod


class Plugin(ABC):
    """基类：所有插件自动注册到此工厂"""
    _registry: dict[str, type["Plugin"]] = {}

    def __init_subclass__(cls, **kwargs):
        """子类被定义时自动调用，完成注册"""
        super().__init_subclass__(**kwargs)
        # 使用类名（或自定义标记）作为注册键
        plugin_name = getattr(cls, "plugin_name", cls.__name__.lower())
        cls._registry[plugin_name] = cls

    @classmethod
    def create(cls, name: str, *args, **kwargs) -> "Plugin":
        """工厂方法：根据名称创建插件实例"""
        plugin_cls = cls._registry.get(name)
        if plugin_cls is None:
            available = ", ".join(cls._registry.keys())
            raise ValueError(
                f"未知插件 '{name}'，可用插件: [{available}]"
            )
        return plugin_cls(*args, **kwargs)

    @classmethod
    def list_plugins(cls) -> list[str]:
        return list(cls._registry.keys())

    @abstractmethod
    def execute(self, data: str) -> str:
        pass


class UpperCasePlugin(Plugin):
    plugin_name = "upper"

    def execute(self, data: str) -> str:
        return data.upper()


class LowerCasePlugin(Plugin):
    plugin_name = "lower"

    def execute(self, data: str) -> str:
        return data.lower()


class ReversePlugin(Plugin):
    plugin_name = "reverse"

    def execute(self, data: str) -> str:
        return data[::-1]


# 使用示例
print("已注册插件:", Plugin.list_plugins())
# 输出: ['upper', 'lower', 'reverse']

p = Plugin.create("reverse", "Hello")
print(p.execute("Python"))  # nohtyP

优势：开发者只需编写新的子类，注册自动完成，无需手动维护任何注册表。这不仅减少了代码量，还避免了"注册遗漏"导致的运行时错误。

5.2 使用装饰器注册

装饰器提供了另一种灵活的注册方式，特别适合不能继承基类或希望更细粒度控制注册键的场景。

# ---------- 装饰器注册方案 ----------
_parser_registry: dict[str, type] = {}


def register_parser(name: str):
    """装饰器工厂：将解析器类注册到全局注册表"""
    def decorator(cls):
        _parser_registry[name] = cls
        # 可以在类上添加元数据
        cls.parser_name = name
        return cls
    return decorator


class BaseParser(ABC):
    @abstractmethod
    def parse(self, text: str) -> dict:
        pass


@register_parser("json")
class JSONParser(BaseParser):
    def parse(self, text: str) -> dict:
        import json
        return json.loads(text)


@register_parser("yaml")
class YAMLParser(BaseParser):
    def parse(self, text: str) -> dict:
        import yaml
        return yaml.safe_load(text)


@register_parser("toml")
class TOMLParser(BaseParser):
    def parse(self, text: str) -> dict:
        import tomllib
        return tomllib.loads(text)


def create_parser(name: str) -> BaseParser:
    cls = _parser_registry.get(name)
    if cls is None:
        raise ValueError(f"未知解析器: {name}")
    return cls()


# 使用示例
parser = create_parser("json")
result = parser.parse('{"key": "value"}')
print(result)  # {'key': 'value'}

六、类名与字符串动态创建实例

在大型项目中，类名和参数往往来自配置文件、数据库或网络请求。Python 的动态特性允许我们通过字符串来创建任意类的实例，这在工厂模式中非常实用。

6.1 使用 globals() 和 locals()

当所有可能的类都在当前模块中定义时，可以直接从全局命名空间中获取类对象。

class DogTrainer:
    def train(self):
        return "训练狗"


class CatTrainer:
    def train(self):
        return "训练猫"


class HorseTrainer:
    def train(self):
        return "训练马"


def create_trainer(class_name: str, *args, **kwargs):
    """通过字符串类名动态创建实例"""
    cls = globals().get(class_name)
    if cls is None:
        raise ValueError(f"类 {class_name} 不存在")
    if not hasattr(cls, "train"):
        raise TypeError(f"{class_name} 不是合法的 Trainer 类")
    return cls(*args, **kwargs)


# 使用示例
config = {"trainer": "HorseTrainer"}
trainer = create_trainer(config["trainer"])
print(trainer.train())  # 训练马

6.2 使用 importlib 跨模块动态导入

对于分布在多个包中的类，需要使用 importlib 进行全路径导入。这是插件系统和框架开发中最常用的方式。

import importlib


def dynamic_import(full_qualname: str):
    """从完整限定名导入并实例化类
    格式: 'package.module.ClassName'
    """
    # 分割出模块路径和类名
    parts = full_qualname.rsplit(".", 1)
    if len(parts) != 2:
        raise ValueError(f"无效的限定名: {full_qualname}")

    module_path, class_name = parts

    try:
        module = importlib.import_module(module_path)
    except ImportError as e:
        raise ImportError(f"无法导入模块 '{module_path}': {e}")

    cls = getattr(module, class_name, None)
    if cls is None:
        raise AttributeError(
            f"模块 '{module_path}' 中没有 '{class_name}'"
        )

    return cls


# 使用示例：假设配置来自 YAML 文件
config = {
    "logger": {
        "class": "logging.handlers.RotatingFileHandler",
        "params": {
            "filename": "app.log",
            "maxBytes": 10485760,
            "backupCount": 5,
        }
    }
}

LoggerClass = dynamic_import(config["logger"]["class"])
logger = LoggerClass(**config["logger"]["params"])
print(f"创建了: {type(logger).__name__}")
# 创建了: RotatingFileHandler

安全警告：当类名或模块路径来自用户输入时，务必进行白名单校验。恶意的字符串可能被用来实例化不该被外部访问的类（如 subprocess.Popen），带来安全隐患。

七、工厂模式在插件系统中的应用

插件系统是工厂模式最经典的应用场景之一。结合注册机制和动态导入，可以构建一个完整的插件发现与加载框架。

import importlib
import pkgutil
from abc import ABC, abstractmethod


class PluginBase(ABC):
    """插件基类：支持自动发现和按需加载"""

    _plugin_registry: dict[str, type["PluginBase"]] = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        name = getattr(cls, "plugin_id", cls.__name__.lower())
        cls._plugin_registry[name] = cls

    @classmethod
    def discover_plugins(cls, package_name: str):
        """从指定包中自动发现并加载所有插件模块"""
        try:
            package = importlib.import_module(package_name)
        except ImportError:
            print(f"包 {package_name} 不存在，跳过发现")
            return []

        discovered = []
        for importer, modname, ispkg in pkgutil.iter_modules(
            package.__path__, package.__name__ + "."
        ):
            if not ispkg:
                importlib.import_module(modname)
                discovered.append(modname)

        print(f"发现并加载了 {len(discovered)} 个插件模块")
        return discovered

    @classmethod
    def get_plugin(cls, name: str) -> type["PluginBase"]:
        return cls._plugin_registry.get(name)

    @classmethod
    def create_plugin(cls, name: str, *args, **kwargs):
        entry = cls._plugin_registry.get(name)
        if entry is None:
            raise KeyError(f"插件 '{name}' 未注册")
        return entry(*args, **kwargs)

    @abstractmethod
    def run(self, context: dict) -> dict:
        pass

上述设计允许第三方开发者只需创建继承 PluginBase 的类，并放置在约定的包目录下，框架即可自动发现并加载所有插件。Flask、Pytest、Sphinx 等知名框架的设计思路与此类似。

# ---------- 插件目录 plugins/notify.py ----------
import smtplib
from plugins.base import PluginBase


class EmailNotifier(PluginBase):
    plugin_id = "email"

    def __init__(self, smtp_host: str, smtp_port: int):
        self.host = smtp_host
        self.port = smtp_port

    def run(self, context: dict) -> dict:
        print(f"通过 {self.host}:{self.port} 发送邮件通知")
        return {"status": "sent", "channel": "email"}


# ---------- 插件加载入口 ----------
def initialize_plugins():
    PluginBase.discover_plugins("plugins")
    notifier = PluginBase.create_plugin(
        "email", smtp_host="smtp.example.com", smtp_port=587
    )
    result = notifier.run({"message": "Hello"})
    print(result)

八、工厂与依赖注入对比

依赖注入（Dependency Injection，DI）和工厂模式都致力于解耦对象的创建和使用，但它们的关注点和实现方式有本质区别。

工厂模式的特点

创建逻辑集中，客户端主动调用工厂获取对象
适用于产品层次结构明确、类型可枚举的场景
在编译/编写时就知道所有可能的产品类型
对 Python 来说实现极轻量，无需框架支持

依赖注入的特点

对象由 DI 容器创建并注入，客户端被动接收
适用于组件关系复杂、需要动态装配的场景
通过配置（文件/注解）声明依赖关系
通常需要框架支持（如 FastAPI、Dependency Injector）

下面用代码直观展示两者的差异：

# ---------- 工厂模式实现 ----------
class DatabaseConnection:
    def query(self, sql: str):
        return f"执行: {sql}"


class DatabaseFactory:
    @staticmethod
    def create_connection(db_type: str) -> DatabaseConnection:
        # 工厂负责决定创建哪种连接
        return DatabaseConnection()


class UserRepository:
    def __init__(self):
        # 主动调用工厂获取依赖
        self.db = DatabaseFactory.create_connection("postgres")

    def get_user(self, uid: int):
        return self.db.query(f"SELECT * FROM users WHERE id={uid}")


# ---------- 依赖注入实现 ----------
class UserService:
    def __init__(self, db: DatabaseConnection):
        # 依赖由外部注入，类本身不负责创建
        self.db = db

    def get_user(self, uid: int):
        return self.db.query(f"SELECT * FROM users WHERE id={uid}")


# DI 容器负责装配
db = DatabaseConnection()
service = UserService(db)
print(service.get_user(1))

实践建议：中小型项目用工厂模式就足够了，它简单直观，不需要额外依赖。大型项目或微服务架构中，DI 容器能更好地管理复杂的对象图和生命周期。在 Python 生态中，很多项目会混合使用两者——用工厂管理产品族的创建，用 DI 管理组件之间的装配关系。

九、Python特有的工厂模式简化方案

Python 的动态特性为我们提供了许多传统静态语言无法实现的简便方案。这些方案不需要显式的工厂类或函数，却能达到同样的效果。

9.1 可调用对象（Callable）作为工厂

任何实现了 __call__ 方法的类实例都可以像函数一样被调用。这使得我们可以创建带状态的工厂对象。

import random


class RandomShapeFactory:
    """可调用工厂：每次调用随机返回一种形状"""

    def __init__(self):
        self.shapes = [Circle, Square, Triangle]
        self.counter = 0

    def __call__(self, *args, **kwargs):
        shape_cls = random.choice(self.shapes)
        self.counter += 1
        print(f"第 {self.counter} 次创建，选择了 {shape_cls.__name__}")
        return shape_cls(*args, **kwargs)


# 可调用对象可以像函数一样使用
shape_factory = RandomShapeFactory()
shape1 = shape_factory()
shape2 = shape_factory()

9.2 类对象本身作为工厂

在 Python 中，类本身就是可调用对象（调用类 = 创建实例）。这意味着只要客户端能接受任何实现了某个接口的类，这个类本身就可以作为它的工厂。这在追求极简的场景下非常有用。

class FormatProcessor:
    def process(self, content: str) -> str:
        return content.strip()


class LoggingProcessor:
    """既是实现类，也是自己的工厂"""

    def __init__(self, log_file: str = "app.log"):
        self.log_file = log_file

    def process(self, content: str) -> str:
        return content.upper()


# 类对象本身可以直接作为工厂使用
processors = {
    "format": FormatProcessor,         # 类对象
    "log": lambda: LoggingProcessor("out.log"),  # 或 Lambda
}

# 直接调用类 = 创建实例
proc = processors["format"]()
print(proc.process("  Hello  "))

9.3 使用 functools.partial 绑定参数

partial 可以将一个类的构造函数的部分参数固定下来，形成一个新的可调用对象，相当于预配置的工厂。

from functools import partial
from urllib.request import Request


# 预配置的 HTTP 请求工厂
get_json = partial(
    Request,
    method="GET",
    headers={"Accept": "application/json"},
    data=None,
)

# 使用时只需提供 URL
req1 = get_json("https://api.example.com/users")
req2 = get_json("https://api.example.com/posts")

print(req2.method)    # GET
print(req2.full_url)  # https://api.example.com/posts

总结：Python 特有的工厂简化方案充分利用了"函数/类是一等公民"的语言特性。可调用对象适合带状态的工厂；类对象直接作为工厂最为精简；partial 适合预绑定公共参数的场景。三者都没有显式的工厂类，但都完美实现了工厂模式的核心目标——将创建逻辑抽象出来。

十、核心要点总结

简单工厂用一个函数 + dict 分发即可实现，是 Python 中最常见、最实用的工厂形式，适合 80% 的场景
工厂方法模式将创建逻辑推迟到子类，适用于每个产品需要独立且复杂的创建流程
抽象工厂模式用于创建一组相关的产品族，保证产品间的一致性
__init_subclass__ 和装饰器注册让 Python 的工厂模式具有自动发现能力，是插件系统的基石
importlib 动态导入结合字符串配置，可以实现完全运行时的灵活实例化
Python 特有方案（可调用对象、类对象本身、partial）可以用极简代码实现工厂效果，无需设计模式框架
工厂 vs DI：工厂模式是创建型模式，DI 是架构模式。两者互补而非互斥，混合使用效果最佳
选择原则：从最简单的方案开始——先用 dict + 函数工厂，有明确扩展需求时再升级到面向对象的工厂模式或注册机制

十一、进一步思考

工厂模式看似简单，但其背后体现了软件设计中一个深刻的哲理：变化的隔离。无论技术栈如何演变，将"创建什么"和"如何使用"分离的思想始终是构建可维护系统的核心原则。

在实际项目中，建议从最轻量的方案开始。Python 的 dict + 函数工厂足以应对绝大多数场景。只有当代码结构确实需要更复杂的层次时，才引入工厂方法或抽象工厂。过度设计是工厂模式最常见的误用——为每个类配备一个工厂子类，只会让代码变得臃肿而收益有限。

最后，工厂模式与 Python 的注册机制、反射、元编程能力结合后，其威力远超传统的 GoF 设计模式范畴。理解并善用这些动态特性，是 Python 进阶编程的重要里程碑。