我认为最好的方法是使用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 numbers_to_strings(argument):
    switcher = {
        0: "zero",
        1: "one",
        2: "two",
    }
    return switcher.get(argument, "nothing")

该代码类似于：

function(argument){
    switch(argument) {
        case 0:
            return "zero";
        case 1:
            return "one";
        case 2:
            return "two";
        default:
            return "nothing";
    }
}

有关字典映射到函数的详细信息，请查看源代码。

到目前为止，已经有很多回答说，“我们在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 f(x):
     return 1 if x == 'a' else\
            2 if x in 'bcd' else\
            0 #default

简短易读，具有默认值，支持条件和返回值中的表达式。

然而，它的效率不如字典解决方案。例如，Python必须在返回默认值之前扫描所有条件。

当我需要一个简单的switchcase来调用一堆方法而不仅仅是打印一些文本时，下面的方法适用于我的情况。在玩了lambda和globals之后，我觉得这是迄今为止最简单的选择。也许它也会帮助某人：

def start():
    print("Start")

def stop():
    print("Stop")

def print_help():
    print("Help")

def choose_action(arg):
    return {
        "start": start,
        "stop": stop,
        "help": print_help,
    }.get(arg, print_help)

argument = sys.argv[1].strip()
choose_action(argument)()  # calling a method from the given string