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

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”，我构建了一个扩展Python的Python模块。它被称为ESPY“增强的Python结构”，可用于Python2.x和Python3.x。

例如，在这种情况下，switch语句可以由以下代码执行：

macro switch(arg1):
    while True:
        cont=False
        val=%arg1%
        socket case(arg2):
            if val==%arg2% or cont:
                cont=True
                socket
        socket else:
            socket
        break

可以这样使用：

a=3
switch(a):
    case(0):
        print("Zero")
    case(1):
        print("Smaller than 2"):
        break
    else:
        print ("greater than 1")

所以espy在Python中将其翻译为：

a=3
while True:
    cont=False
    if a==0 or cont:
        cont=True
        print ("Zero")
    if a==1 or cont:
        cont=True
        print ("Smaller than 2")
        break
    print ("greater than 1")
    break

如果您不担心丢失案例套件中的语法高亮显示，可以执行以下操作：

exec {
    1: """
print ('one')
""", 
    2: """
print ('two')
""", 
    3: """
print ('three')
""",
}.get(value, """
print ('None')
""")

其中value是值。在C中，这将是：

switch (value) {
    case 1:
        printf("one");
        break;
    case 2:
        printf("two");
        break;
    case 3:
        printf("three");
        break;
    default:
        printf("None");
        break;
}

我们还可以创建一个helper函数来实现这一点：

def switch(value, cases, default):
    exec cases.get(value, default)

因此，我们可以将其用于一、二和三的示例：

switch(value, {
    1: """
print ('one')
    """, 
    2: """
print ('two')
    """, 
    3: """
print ('three')
    """,
}, """
print ('None')
""")

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

首先，官方的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)()

我一直喜欢这样做

result = {
  'a': lambda x: x * 5,
  'b': lambda x: x + 7,
  'c': lambda x: x - 2
}[value](x)

从这里开始