如何在Python中实现谓词分派并让函数按输入执行不同操作

问题 #

• 如何让函数根据输入的性质执行不同操作？
• 如何在Python中实现谓词分派（Predicate Dispatching）？

假设我们有一个名为funky_the_function的函数，需要将输入与判定条件匹配，再根据测试结果调用对应函数。以下是测试谓词的示例代码：

import string

class Predicates: 
    @classmethod
    def is_numeric_string(cls, chs:str) -> bool:
        """
        +-----------------+--------+
        |      输入       | 输出   |
        +-----------------+--------+
        | "9821"          | True   |
        | "3038739984"    | True   |
        | "0"             | True   |
        | "3.14"          | False  |
        | "orange"        | False  |
        | "kiwi 5 pear 0" | False  |
        +-----------------+--------+
        """
        return all([ch in string.digits for ch in chs])

    @classmethod
    def is_just_one_thing(cls, thing):
        """
        该函数返回布尔值（True/False）

        当`thing`满足「字符串形式等于其所有元素字符串形式的拼接」时，
        判定为“单一事物”，否则为“多个事物”

        +--------------------------+--------+   
        |          输入            | 输出   |
        |--------------------------|--------|
        | int(4)                   | True   |
        | str(4)                   | True   |
        | float(9.17)              | True   |
        | str("ABCDE")             | True   |
        | [int(1), str(2), int(3)] | False  |
        | (8, 3)                   | False  |
        | [8]                      | False  |
        | ["A", "B", "C"]          | False  |
        +--------------------------+--------+
        """
        if hasattr(thing, "__iter__") and not isinstance(thing, str):
            return str(thing) == "".join(str(elem) for elem in thing)
        else:
            return True

我们拥有多个不同版本的函数，需根据输入特性决定调用对应版本，以下是具体实现方法：

实现方案 #

1. 手动分派（简单直接） #

先定义各场景的处理函数，再在主函数中按优先级依次检查谓词，匹配成功则执行对应逻辑：

# 定义各个处理函数
def handle_numeric_string(s):
    return f"处理纯数字字符串：{s}，转换为整数：{int(s)}"

def handle_single_thing(obj):
    return f"处理单一事物：{type(obj).__name__}类型，值为{obj}"

def handle_default(obj):
    return f"处理默认情况：输入为{obj}"

def funky_the_function(input_data):
    # 按优先级检查谓词，匹配到则执行对应处理
    if isinstance(input_data, str) and Predicates.is_numeric_string(input_data):
        return handle_numeric_string(input_data)
    elif Predicates.is_just_one_thing(input_data):
        return handle_single_thing(input_data)
    else:
        return handle_default(input_data)

# 测试示例
print(funky_the_function("1234"))  # 输出：处理纯数字字符串：1234，转换为整数：1234
print(funky_the_function(3.14))    # 输出：处理单一事物：float类型，值为3.14
print(funky_the_function([1,2,3])) # 输出：处理默认情况：输入为[1, 2, 3]

2. 装饰器式分派（可扩展性强） #

通过装饰器注册谓词与对应处理函数，新增规则无需修改主函数，更适合复杂场景：

class PredicateDispatcher:
    def __init__(self):
        self.handlers = []  # 存储(谓词函数, 处理函数)，按注册顺序匹配

    def register(self, predicate):
        """装饰器：注册谓词对应的处理函数"""
        def decorator(handler):
            self.handlers.append((predicate, handler))
            return handler
        return decorator

    def dispatch(self, input_data):
        """根据输入匹配谓词，执行对应处理"""
        for predicate, handler in self.handlers:
            if predicate(input_data):
                return handler(input_data)
        # 无匹配时执行默认逻辑
        return self.default_handler(input_data)

    def default_handler(self, input_data):
        return f"处理默认情况：输入为{input_data}"

# 创建分派器实例
dispatcher = PredicateDispatcher()

# 注册处理函数
@dispatcher.register(lambda x: isinstance(x, str) and Predicates.is_numeric_string(x))
def handle_numeric_string(s):
    return f"处理纯数字字符串：{s}，转换为整数：{int(s)}"

@dispatcher.register(Predicates.is_just_one_thing)
def handle_single_thing(obj):
    return f"处理单一事物：{type(obj).__name__}类型，值为{obj}"

# 替代funky_the_function
def funky_the_function(input_data):
    return dispatcher.dispatch(input_data)

# 测试示例
print(funky_the_function("9876"))  # 输出：处理纯数字字符串：9876，转换为整数：9876
print(funky_the_function("apple")) # 输出：处理单一事物：str类型，值为apple
print(funky_the_function((1,2)))   # 输出：处理默认情况：输入为(1, 2)

关键注意点 #

• 谓词匹配的优先级由检查顺序决定：手动分派中是if-elif的代码顺序，装饰器方式是函数的注册顺序
• 字符串属于可迭代对象，但需在is_just_one_thing中单独排除，避免被误判为“多个事物”
• 装饰器式分派的扩展性更强，新增规则只需添加一个带@dispatcher.register的处理函数即可

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