我倾向于使用字典的解决方案是：

def decision_time( key, *args, **kwargs):
    def action1()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action2()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action3()
        """This function is a closure - and has access to all the arguments"""
        pass

   return {1:action1, 2:action2, 3:action3}.get(key,default)()

这样做的优点是它不需要每次都对函数求值，您只需确保外部函数获得内部函数所需的所有信息。

我做了一个switch-case实现，它在外部不太使用if（它仍然在类中使用if）。

class SwitchCase(object):
    def __init__(self):
        self._cases = dict()

    def add_case(self,value, fn):
        self._cases[value] = fn

    def add_default_case(self,fn):
        self._cases['default']  = fn

    def switch_case(self,value):
        if value in self._cases.keys():
            return self._cases[value](value)
        else:
            return self._cases['default'](0)

这样使用：

from switch_case import SwitchCase
switcher = SwitchCase()
switcher.add_case(1, lambda x:x+1)
switcher.add_case(2, lambda x:x+3)
switcher.add_default_case(lambda _:[1,2,3,4,5])

print switcher.switch_case(1) #2
print switcher.switch_case(2) #5
print switcher.switch_case(123) #[1, 2, 3, 4, 5]

到目前为止，已经有很多回答说，“我们在Python中没有开关，这样做吧”。然而，我想指出，switch语句本身是一个容易被滥用的构造，在大多数情况下可以而且应该避免，因为它们促进了惰性编程。案例说明：

def ToUpper(lcChar):
    if (lcChar == 'a' or lcChar == 'A'):
        return 'A'
    elif (lcChar == 'b' or lcChar == 'B'):
        return 'B'
    ...
    elif (lcChar == 'z' or lcChar == 'Z'):
        return 'Z'
    else:
        return None        # or something

现在，您可以使用switch语句（如果Python提供了switch语句）来执行此操作，但这会浪费您的时间，因为有些方法可以很好地执行此操作。或者，你有一些不太明显的东西：

def ConvertToReason(code):
    if (code == 200):
        return 'Okay'
    elif (code == 400):
        return 'Bad Request'
    elif (code == 404):
        return 'Not Found'
    else:
        return None

然而，这种操作可以而且应该用字典来处理，因为它会更快、更复杂、更不容易出错和更紧凑。

switch语句的绝大多数“用例”将属于这两种情况之一；如果你彻底考虑了你的问题，就没有什么理由使用它。

因此，与其问“我如何在Python中切换？”，或许我们应该问“我为什么要在Python中进行切换？”因为这往往是一个更有趣的问题，而且往往会暴露出您正在构建的任何设计中的缺陷。

现在，这并不是说也不应该使用开关。状态机、词法分析器、解析器和自动机都在某种程度上使用它们，一般来说，当你从对称输入开始到非对称输出时，它们会很有用；您只需要确保不要将开关用作锤子，因为您在代码中看到了一堆钉子。

仅仅将一些键映射到一些代码并不是一个真正的问题，正如大多数人在使用字典时所展示的那样。真正的诀窍是尝试模仿整个直通和中断过程。我认为我从来没有写过一个案例陈述，其中我使用了“功能”。这里有一个直通车。

def case(list): reduce(lambda b, f: (b | f[0], {False:(lambda:None),True:f[1]}[b | f[0]]())[0], list, False)

case([
    (False, lambda:print(5)),
    (True, lambda:print(4))
])

我真的把它想象成一个单独的陈述。我希望你能原谅这种愚蠢的格式。

reduce(
    initializer=False,
    function=(lambda b, f:
        ( b | f[0]
        , { False: (lambda:None)
          , True : f[1]
          }[b | f[0]]()
        )[0]
    ),
    iterable=[
        (False, lambda:print(5)),
        (True, lambda:print(4))
    ]
)

我希望这是有效的Python代码。它应该能让你通过。当然，布尔检查可以是表达式，如果您希望它们被延迟求值，那么可以将它们全部封装在lambda中。在执行了列表中的一些项目之后，也不难让它被接受。只需创建元组（bool，bool，function），其中第二个bool指示是否突破或放弃。

我发现一种常见的交换机结构：

switch ...parameter...
case p1: v1; break;
case p2: v2; break;
default: v3;

可以用Python表示如下：

(lambda x: v1 if p1(x) else v2 if p2(x) else v3)

或以更清晰的方式格式化：

(lambda x:
     v1 if p1(x) else
     v2 if p2(x) else
     v3)

Python版本不是一个语句，而是一个表达式，其计算结果为一个值。

如果你有一个复杂的大小写块，你可以考虑使用函数字典查找表。。。

如果您以前没有这样做过，那么最好进入调试器并查看字典如何查找每个函数。

注意：不要在大小写/字典查找中使用“（）”，否则将在创建字典/大小写块时调用每个函数。记住这一点，因为您只想使用哈希样式查找调用每个函数一次。

def first_case():
    print "first"

def second_case():
    print "second"

def third_case():
    print "third"

mycase = {
'first': first_case, #do not use ()
'second': second_case, #do not use ()
'third': third_case #do not use ()
}
myfunc = mycase['first']
myfunc()