Python中替代字符串传参的方案：类的使用方法咨询

一、优先推荐：使用枚举（Enum） #

对于固定的几类物品，枚举是最安全简洁的方案，能彻底避免字符串拼写错误，还自带类型检查，IDE也能提供自动补全。

示例代码：

from enum import Enum

class ItemType(Enum):
    A = "A"
    B = "B"
    C = "C"

def my_function(item_type: ItemType):
    if item_type == ItemType.A:
        print("处理类型A")
    elif item_type == ItemType.B:
        print("处理类型B")
    elif item_type == ItemType.C:
        print("处理类型C")

# 调用方式
my_function(ItemType.A)

二、使用类作为参数传递 #

当然可以用类实现，常见两种方式：

1. 直接传递类本身 #

如果不同类型的物品对应不同的类定义，可直接把类传给函数，通过判断类的身份做不同处理：

class ItemA:
    # 类型A专属的属性/方法
    pass

class ItemB:
    # 类型B专属的属性/方法
    pass

class ItemC:
    # 类型C专属的属性/方法
    pass

def my_function(item_class):
    if item_class is ItemA:
        print("处理ItemA类型")
    elif item_class is ItemB:
        print("处理ItemB类型")
    elif item_class is ItemC:
        print("处理ItemC类型")

# 调用方式
my_function(ItemA)

这里用is判断类的身份比==更准确，因为类是单例对象。

2. 传递类的实例（更符合面向对象思想） #

如果每种类型的物品有独立的处理逻辑，推荐定义抽象基类，子类实现各自的方法，函数只需接收实例并调用统一方法，无需做类型判断：

from abc import ABC, abstractmethod

class BaseItem(ABC):
    @abstractmethod
    def process(self):
        pass

class ItemA(BaseItem):
    def process(self):
        print("执行类型A的处理逻辑")

class ItemB(BaseItem):
    def process(self):
        print("执行类型B的处理逻辑")

class ItemC(BaseItem):
    def process(self):
        print("执行类型C的处理逻辑")

def my_function(item: BaseItem):
    item.process()  # 直接调用统一方法，无需判断类型

# 调用方式
my_function(ItemA())
my_function(ItemB())

这种方式遵循开闭原则，后续新增类型只需添加子类，不用修改my_function的代码，扩展性更强。

三、其他可选方案 #

• 整数常量：用1代表A、2代表B，但可读性差，不推荐。
• 字典映射：将类型标识映射到对应的处理函数，适合逻辑拆分的场景：

def process_a():
    print("处理A")

def process_b():
    print("处理B")

def process_c():
    print("处理C")

type_handlers = {
    'A': process_a,
    'B': process_b,
    'C': process_c
}

def my_function(item_type):
    handler = type_handlers.get(item_type)
    if handler:
        handler()
    else:
        print("未知类型")

但这种方案仍存在传错字符串的风险，安全性不如枚举和类。

内容的提问来源于stack exchange，提问作者LOG