简单，未经测试；每个条件都是独立计算的：没有贯穿，但所有情况都会计算（尽管要打开的表达式只计算一次），除非有break语句。例如

for case in [expression]:
    if case == 1:
        print(end='Was 1. ')

    if case == 2:
        print(end='Was 2. ')
        break

    if case in (1, 2):
        print(end='Was 1 or 2. ')

    print(end='Was something. ')

指纹是1。是1或2。是什么。（该死！为什么在内联代码块中不能有尾随空格？）若表达式的计算结果为1，则为2。如果表达式的计算结果为2或Was某物。if表达式的计算结果为其他值。

您可以使用分派的dict：

#!/usr/bin/env python


def case1():
    print("This is case 1")

def case2():
    print("This is case 2")

def case3():
    print("This is case 3")


token_dict = {
    "case1" : case1,
    "case2" : case2,
    "case3" : case3,
}


def main():
    cases = ("case1", "case3", "case2", "case1")
    for case in cases:
        token_dict[case]()


if __name__ == '__main__':
    main()

输出：

This is case 1
This is case 3
This is case 2
This is case 1

除了字典方法（我很喜欢，BTW），您还可以使用if elif else来获得switch/case/default功能：

if x == 'a':
    # Do the thing
elif x == 'b':
    # Do the other thing
if x in 'bc':
    # Fall-through by not using elif, but now the default case includes case 'a'!
elif x in 'xyz':
    # Do yet another thing
else:
    # Do the default

当然，这与switch/case不同——你不可能像放弃break语句那样轻易地通过，但你可以进行更复杂的测试。它的格式比一系列嵌套的if更好，尽管在功能上更接近。

我认为最好的方法是使用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)

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

我使用的解决方案：

这里发布的两个解决方案的组合，相对容易阅读，并支持默认值。

result = {
  'a': lambda x: x * 5,
  'b': lambda x: x + 7,
  'c': lambda x: x - 2
}.get(whatToUse, lambda x: x - 22)(value)

哪里

.get('c', lambda x: x - 22)(23)

在dict中查找“lambda x:x-2”，并在x=23时使用它

.get('xxx', lambda x: x - 22)(44)

在dict中找不到它，使用默认的“lambda x:x-22”，x=44。

class switch(object):
    value = None
    def __new__(class_, value):
        class_.value = value
        return True

def case(*args):
    return any((arg == switch.value for arg in args))

用法：

while switch(n):
    if case(0):
        print "You typed zero."
        break
    if case(1, 4, 9):
        print "n is a perfect square."
        break
    if case(2):
        print "n is an even number."
    if case(2, 3, 5, 7):
        print "n is a prime number."
        break
    if case(6, 8):
        print "n is an even number."
        break
    print "Only single-digit numbers are allowed."
    break

测验：

n = 2
#Result:
#n is an even number.
#n is a prime number.
n = 11
#Result:
#Only single-digit numbers are allowed.