还可以使用列表存储案例，并通过select调用相应的函数-

cases = ['zero()', 'one()', 'two()', 'three()']

def zero():
  print "method for 0 called..."
def one():
  print "method for 1 called..."
def two():
  print "method for 2 called..."
def three():
  print "method for 3 called..."

i = int(raw_input("Enter choice between 0-3 "))

if(i<=len(cases)):
  exec(cases[i])
else:
  print "wrong choice"

也在螺丝台上进行了解释。

我认为最好的方法是使用Python语言的习惯用法来保持代码的可测试性。如前面的回答所示，我使用字典来利用python结构和语言，并以不同的方法隔离“case”代码。下面是一个类，但您可以直接使用模块、全局变量和函数。该类具有可以隔离测试的方法。

根据您的需要，您也可以使用静态方法和属性。

class ChoiceManager:

    def __init__(self):
        self.__choice_table = \
        {
            "CHOICE1" : self.my_func1,
            "CHOICE2" : self.my_func2,
        }

    def my_func1(self, data):
        pass

    def my_func2(self, data):
        pass

    def process(self, case, data):
        return self.__choice_table[case](data)

ChoiceManager().process("CHOICE1", my_data)

也可以使用类作为“__choice_table”的键来利用此方法。通过这种方式，您可以避免信息滥用，并保持所有信息的清洁和可测试性。

假设您必须处理来自网络或MQ的大量消息或数据包。每个数据包都有自己的结构和管理代码（以通用方式）。

使用以上代码，可以执行以下操作：

class PacketManager:

    def __init__(self):
        self.__choice_table = \
        {
            ControlMessage : self.my_func1,
            DiagnosticMessage : self.my_func2,
        }

    def my_func1(self, data):
        # process the control message here
        pass

    def my_func2(self, data):
        # process the diagnostic message here
        pass

    def process(self, pkt):
        return self.__choice_table[pkt.__class__](pkt)

pkt = GetMyPacketFromNet()
PacketManager().process(pkt)


# isolated test or isolated usage example
def test_control_packet():
    p = ControlMessage()
    PacketManager().my_func1(p)

因此，复杂性不会在代码流中扩散，而是在代码结构中呈现。

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

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指示是否突破或放弃。

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

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)()

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

这里的大多数答案都很陈旧，尤其是那些被接受的答案，因此似乎值得更新。

首先，官方的Python常见问题解答涵盖了这一点，并为简单案例推荐elif链，为更大或更复杂的案例推荐dict。它还建议在某些情况下使用一组visit_方法（许多服务器框架使用的样式）：

def dispatch(self, value):
    method_name = 'visit_' + str(value)
    method = getattr(self, method_name)
    method()

FAQ还提到了PEP275，它是为了让官方一劳永逸地决定添加C风格切换语句而编写的。但PEP实际上被推迟到了Python 3，它只是作为一个单独的提案PEP3103被正式拒绝。答案当然是否定的，但如果你对原因或历史感兴趣的话，这两位政治公众人物可以获得更多信息。

有一件事多次出现（在PEP 275中可以看到，尽管它是作为实际推荐删除的），那就是如果你真的为处理4种情况而烦恼的是8行代码，而不是C或Bash中的6行代码，你总是可以这样写：

if x == 1: print('first')
elif x == 2: print('second')
elif x == 3: print('third')
else: print('did not place')

这并不是PEP 8所鼓励的，但它是可读的，并不是太单一。

自PEP 3103被拒绝以来的十多年里，C风格的案例陈述，甚至围棋中稍微更强大的版本，都被认为已经过时；每当有人提出python想法或-dev时，他们都会参考旧的决定。

然而，完全ML样式的模式匹配的想法每隔几年就会出现一次，特别是在Swift和Rust等语言采用它之后。问题是，如果没有代数数据类型，很难充分利用模式匹配。虽然圭多一直赞同这个想法，但没有人提出一个非常适合Python的方案。（你可以阅读我2014年的strawman作为一个例子。）这可能会随着3.7中的dataclass和一些零星的建议而改变，比如使用更强大的枚举来处理sum类型，或者使用不同类型的语句本地绑定的各种建议（如PEP3150，或者当前正在讨论的一组建议-ideas）。但到目前为止，它还没有。

偶尔也会有关于Perl 6样式匹配的建议，这基本上是从elif到regex到单分派类型切换的混合。

运行函数的解决方案：

result = {
    'case1':     foo1, 
    'case2':     foo2,
    'case3':     foo3,
}.get(option)(parameters_optional)

其中foo1（）、foo2（）和foo3（）是函数

示例1（带参数）：

option = number['type']
result = {
    'number':     value_of_int,  # result = value_of_int(number['value'])
    'text':       value_of_text, # result = value_of_text(number['value'])
    'binary':     value_of_bin,  # result = value_of_bin(number['value'])
}.get(option)(value['value'])

示例2（无参数）：

option = number['type']
result = {
    'number':     func_for_number, # result = func_for_number()
    'text':       func_for_text,   # result = func_for_text()
    'binary':     func_for_bin,    # result = func_for_bin()
}.get(option)()

示例4（仅限值）：

option = number['type']
result = {
    'number':    lambda: 10,       # result = 10
    'text':      lambda: 'ten',    # result = 'ten'
    'binary':    lambda: 0b101111, # result = 47
}.get(option)()