前言

表驱动法是一种编辑模式（ Scheme ）——从表里面查找信息而不使用逻辑语句（if 和 case）。事实上，凡是能通过逻辑语句来选择的事物，都可以通过查表来选择。

对简单的情况而言，使用逻辑语句更为容易和直白。但随着逻辑链的越来越复杂，查表法也就愈发显得更具吸引力。

Python 的switch case

由于 Python 中没有switch case关键词，所以对于每一种情况的逻辑语句只能用if,elif,else来实现，显得很不 Pythonic.

def handle_case(case):
    if case == 1:
        print('case 1')
    elif case == 2:
        print('case 2')
    else:
        print('default case')

而受到PEP-443: Single-dispatch generic functions的启发，很容易就能实现如下装饰器：

from functools import update_wrapper
from types import MappingProxyType
from typing import Hashable, Callable, Union


def specificdispatch(key: Union[int, str] = 0) -> Callable:
    """specific-dispatch generic function decorator.

    Transforms a function into a generic function, which can have different
    behaviours depending upon the value of its key of arguments or key of keyword arguments.
    The decorated function acts as the default implementation, and additional
    implementations can be registered using the register() attribute of the
    generic function.
    """

    def decorate(func: Callable) -> Callable:
        registry = {}

        def dispatch(key: Hashable) -> Callable:
            """
            Runs the dispatch algorithm to return the best available implementation
            for the given *key* registered on *generic_func*.
            """
            try:
                impl = registry[key]
            except KeyError:
                impl = registry[object]
            return impl

        def register(key: Hashable, func: Callable=None) -> Callable:
            """
            Registers a new implementation for the given *key* on a *generic_func*.
            """
            if func is None:
                return lambda f: register(key, f)

            registry[key] = func
            return func

        def wrapper_index(*args, **kw):
            return dispatch(args[key])(*args, **kw)

        def wrapper_keyword(*args, **kw):
            return dispatch(kw[key])(*args, **kw)

        registry[object] = func
        if isinstance(key, int):
            wrapper = wrapper_index
        elif isinstance(key, str):
            wrapper = wrapper_keyword
        else:
            raise KeyError('The key must be int or str')
        wrapper.register = register
        wrapper.dispatch = dispatch
        wrapper.registry = MappingProxyType(registry)
        update_wrapper(wrapper, func)

        return wrapper

    return decorate

而之前的代码就能很优美的重构成这样：

@specificdispatch(key=0)
def handle_case(case):
    print('default case')

@handle_case.register(1)
def _(case):
    print('case 1')

@handle_case.register(2)
def _(case):
    print('case 2')

handle_case(1) # case 1
handle_case(0) # default case

而对于这样的架构，即易于扩展也利于维护。

更多实例

class Test:
    @specificdispatch(key=1)
    def test_dispatch(self, message, *args, **kw):
        print(f'default: {message} args:{args} kw:{kw}')

    @test_dispatch.register('test')
    def _(self, message, *args, **kw):
        print(f'test: {message} args:{args} kw:{kw}')

test = Test()
# default: default args:(1,) kw:{'test': True}
test.test_dispatch('default', 1, test=True)
# test: test args:(1,) kw:{'test': True}
test.test_dispatch('test', 1, test=True)

@specificdispatch(key='case')
def handle_case(case):
    print('default case')

@handle_case.register(1)
def _(case):
    print('case 1')

@handle_case.register(2)
def _(case):
    print('case 2')

handle_case(case=1)  # case 1
handle_case(case=0)  # default case

monkeylyf

2018-10-14 10:21:04 +08:00

@GreatTony
1. 我可能没理解正确：对应的 case 具体处理函数不管在任何情况下都要编写，我不是很理解为什么存在多余不多余的情况
2. 函数加入 dict，从你的设计来看，确实是只需要加一个装饰器即可。如果按照我的想法封装在 dict 里面，我个人不同意这是一个多余的步骤，比如就在 dict 初始化时一步完成：func_mapping = { "case1": handle_case_1_func, "case": handle_case_2_func, ...}

追加两点：
1. 除非是把所有 case handling 函数强行封装在某个单独文件或者某个 class 里面，按照你的设计，这些函数理论上可以随意分布，即虽然你给的例子，三个函数是连续定义的，但是实际操作中可以被任何别的语块割裂。另外你的 register 是偏隐性，和 dict 的 explictly 定义，后者可读性更强。
2. 抛开维护和扩展而言，设计此类特性，更偏向于需求方的要求。decrator 在某些 use case 下是很优雅，但是不代表因为优雅就会去使用

Python Switch Case 最佳实践

前言

Python 的switch case

更多实例