Python Switch Case 最佳實(shí)踐

sorra 發(fā)布于2019-07-31 11:12 / 1183人閱讀

摘要：事實(shí)上，凡是能通過(guò)邏輯語(yǔ)句來(lái)選擇的事物，都可以通過(guò)查表來(lái)選擇。對(duì)簡(jiǎn)單的情況而言，使用邏輯語(yǔ)句更為容易和直白。但隨著邏輯鏈的越來(lái)越復(fù)雜，查表法也就愈發(fā)顯得更具吸引力。

優(yōu)美勝于丑陋
import this

博客地址：Specific-Dispatch

前言

表驅(qū)動(dòng)法是一種編輯模式（Scheme）——從表里面查找信息而不使用邏輯語(yǔ)句（if 和 case）。事實(shí)上，凡是能通過(guò)邏輯語(yǔ)句來(lái)選擇的事物，都可以通過(guò)查表來(lái)選擇。

對(duì)簡(jiǎn)單的情況而言，使用邏輯語(yǔ)句更為容易和直白。但隨著邏輯鏈的越來(lái)越復(fù)雜，查表法也就愈發(fā)顯得更具吸引力。

Python的switch case

由于Python中沒有switch case關(guān)鍵詞，所以對(duì)于每一種情況的邏輯語(yǔ)句只能用if,elif,else來(lái)實(shí)現(xiàn)，顯得很不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的啟發(fā)，很容易就能實(shí)現(xiàn)如下裝飾器：

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

而之前的代碼就能很優(yōu)美的重構(gòu)成這樣：

@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

而對(duì)于這樣的架構(gòu)，即易于擴(kuò)展也利于維護(hù)。

更多實(shí)例

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