在单个文件中，根据条件执行不同的代码片段

这是最基础的理解,你有一个 Python 脚本，需要根据某些变量（比如用户输入、配置文件内容、环境变量等）来决定运行哪一段代码。

核心思想： 使用 if/elif/else 语句、match/case 语句（Python 3.10+）或字典映射来实现。

示例 1：使用 if/elif/else

这是最经典、最通用的方法。

# user_input.py
mode = input("请输入模式 (A, B, 或 C): ").upper()
if mode == 'A':
    # 代码片段 A
    print("正在执行模式 A...")
    print("操作：读取数据，进行计算，保存结果。")
    result = "计算结果A"
elif mode == 'B':
    # 代码片段 B
    print("正在执行模式 B...")
    print("操作：连接网络，发送请求，接收响应。")
    result = "网络响应B"
elif mode == 'C':
    # 代码片段 C
    print("正在执行模式 C...")
    print("操作：清理临时文件，生成日志报告。")
    result = "日志报告C"
else:
    # 默认代码片段
    print("错误：无效的模式输入！")
    result = None
print(f"\n最终结果: {result}")

如何运行：

python user_input.py
# 然后输入 A, B, 或 C

示例 2：使用 match/case (Python 3.10+)

对于多个离散值的判断,match/case 语法更清晰、更现代。

# modern_switch.py
mode = "B"
match mode:
    case 'A':
        # 代码片段 A
        print("执行 A: 数据处理")
        result = "A done"
    case 'B':
        # 代码片段 B
        print("执行 B: 网络请求")
        result = "B done"
    case 'C':
        # 代码片段 C
        print("执行 C: 文件清理")
        result = "C done"
    case _:  # 类似于 else
        print("未知模式")
        result = None
print(f"\n结果: {result}")

示例 3：使用字典映射（函数式切换）

如果每个代码片段都比较复杂,最好封装成函数，然后用字典来映射模式名和函数，这种方式非常灵活和易于扩展。

# functional_switch.py
def process_mode_a():
    """处理模式 A 的代码片段"""
    print("执行 A: 数据处理")
    return "A done"
def process_mode_b():
    """处理模式 B 的代码片段"""
    print("执行 B: 网络请求")
    return "B done"
def process_mode_c():
    """处理模式 C 的代码片段"""
    print("执行 C: 文件清理")
    return "C done"
# 创建模式到处理函数的映射
mode_handlers = {
    'A': process_mode_a,
    'B': process_mode_b,
    'C': process_mode_c,
}
# --- 主程序 ---
mode = "B"
# 获取对应的处理函数
handler = mode_handlers.get(mode)
if handler:
    # 如果找到了对应的函数，就调用它
    result = handler()
else:
    # 如果没有找到，执行默认操作
    print("未知模式")
    result = None
print(f"\n结果: {result}")

在不同类之间切换实现（多态）

这是面向对象编程中的一个核心概念,你有一个抽象的基类（或接口），定义了一个公共方法，然后不同的子类用自己的方式来实现这个方法，代码中你操作的是基类对象，但实际运行时，会根据对象的真实类型（是哪个子类的实例）来调用对应的方法。

核心思想： 定义一个基类，多个子类重写父类的方法，通过创建不同的子类实例来“切换”行为。

示例：不同的数据格式解析器

# polymorphic_switch.py
from abc import ABC, abstractmethod
# 1. 定义一个抽象基类（协议/接口）
class DataParser(ABC):
    @abstractmethod
    def parse(self, data_string: str):
        """解析数据字符串"""
        pass
# 2. 创建不同的子类，每个实现一种解析逻辑
class JsonParser(DataParser):
    def parse(self, data_string: str):
        print("正在使用 JSON 解析器...")
        # 这里应该是实际的 JSON 解析逻辑
        # return json.loads(data_string)
        return f"已解析 JSON: {data_string}"
class XmlParser(DataParser):
    def parse(self, data_string: str):
        print("正在使用 XML 解析器...")
        # 这里应该是实际的 XML 解析逻辑
        return f"已解析 XML: {data_string}"
class CsvParser(DataParser):
    def parse(self, data_string: str):
        print("正在使用 CSV 解析器...")
        # 这里应该是实际的 CSV 解析逻辑
        return f"已解析 CSV: {data_string}"
# 3. 使用工厂函数来“切换”创建哪种解析器
def get_parser(format_type: str) -> DataParser:
    """工厂函数，根据类型返回对应的解析器实例"""
    parsers = {
        'json': JsonParser,
        'xml': XmlParser,
        'csv': CsvParser,
    }
    parser_class = parsers.get(format_type.lower())
    if parser_class:
        return parser_class()
    else:
        raise ValueError(f"不支持的格式类型: {format_type}")
# --- 主程序 ---
data_to_parse = '{"name": "Alice", "age": 30}'
# 切换到这里来改变行为
format = "json" 
# format = "xml" 
# format = "csv"
try:
    # 获取解析器（这里发生了“切换”）
    parser = get_parser(format)
    # 调用 parse 方法，Python 会自动找到正确子类的实现
    parsed_data = parser.parse(data_to_parse)
    print(f"\n最终输出: {parsed_data}")
except ValueError as e:
    print(e)

如何运行： 修改 format 变量的值（"json", "xml", "csv"），然后运行脚本，你会看到 parser.parse() 的行为完全不同，但调用代码保持不变，这就是多态的威力。

在不同文件/模块之间切换代码

如果你的代码片段非常庞大,分散在不同的文件中，你可能想动态地导入和执行它们。

核心思想： 使用 importlib 动态导入模块，或者根据配置文件路径加载代码。

示例：根据配置动态加载模块

假设你有以下文件结构：

project/
├── config.json
├── main.py
└── modules/
    ├── __init__.py
    ├── module_a.py
    └── module_b.py

modules/module_a.py

def run():
    print("模块 A 的代码正在运行！")
    return "来自模块 A 的结果"

modules/module_b.py

def run():
    print("模块 B 的代码正在运行！")
    return "来自模块 B 的结果"

config.json

{
    "active_module": "module_a"
}

main.py

import importlib
import json
import os
# 从配置文件中读取要激活的模块
with open('config.json', 'r') as f:
    config = json.load(f)
active_module_name = config['active_module']
# 动态导入模块
# 注意：你需要确保 Python 能找到 'modules' 包
# (在 project 目录下运行 python main.py)
try:
    # importlib.import_module 会像 import 语句一样工作
    module = importlib.import_module(f'modules.{active_module_name}')
    # 检查模块是否有 'run' 函数
    if hasattr(module, 'run') and callable(module.run):
        result = module.run()
        print(f"\n执行结果: {result}")
    else:
        print(f"错误: 模块 '{active_module_name}' 中没有可执行的 'run' 函数。")
except ImportError:
    print(f"错误: 无法导入模块 'modules.{active_module_name}'。")
except Exception as e:
    print(f"发生未知错误: {e}")

如何运行：

1. 在 project 目录下创建所有文件。
2. 修改 config.json 中的 "active_module" 值。
3. 在终端中进入 project 目录，然后运行 python main.py，你会看到根据配置加载并执行了不同模块的代码。

选择哪种“切换”方式，完全取决于你的具体需求和代码的复杂度，对于简单的脚本，场景一就足够了，对于构建大型、可维护的系统，场景二和场景三是更专业和强大的选择。