我做了一个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>=3.10

哇，Python 3.10+现在有一个match/case语法，类似于switch/case等等！

PEP 634——结构模式匹配

匹配/案例的选定特征

1-匹配值：

匹配值类似于另一种语言中的简单开关/大小写：

match something:
    case 1 | 2 | 3:
        # Match 1-3.
    case _:
        # Anything else.
        # 
        # Match will throw an error if this is omitted 
        # and it doesn't match any of the other patterns.

2-匹配结构模式：

match something:
    case str() | bytes():  
        # Match a string like object.
    case [str(), int()]:
        # Match a `str` and an `int` sequence 
        # (`list` or a `tuple` but not a `set` or an iterator). 
    case [_, _]:
        # Match a sequence of 2 variables.
        # To prevent a common mistake, sequence patterns don’t match strings.
    case {"bandwidth": 100, "latency": 300}:
        # Match this dict. Extra keys are ignored.

3-捕获变量

解析对象；将其保存为变量：

match something:
    case [name, count]
        # Match a sequence of any two objects and parse them into the two variables.
    case [x, y, *rest]:
        # Match a sequence of two or more objects, 
        # binding object #3 and on into the rest variable.
    case bytes() | str() as text:
        # Match any string like object and save it to the text variable.

捕获变量在解析数据（如JSON或HTML）时非常有用，这些数据可能以多种不同的模式之一出现。

捕获变量是一项功能。但这也意味着您只需要使用虚线常量（例如：COLOR.RED）。否则，常量将被视为捕获变量并被覆盖。

更多示例用法：

match something:
    case 0 | 1 | 2:
        # Matches 0, 1 or 2 (value).
        print("Small number")
    case [] | [_]:
        # Matches an empty or single value sequence (structure).
        # Matches lists and tuples but not sets.
        print("A short sequence")
    case str() | bytes():
        # Something of `str` or `bytes` type (data type).
        print("Something string-like")
    case _:
        # Anything not matched by the above.
        print("Something else")

Python<=3.9

我最喜欢的switch/case Python配方是：

choices = {'a': 1, 'b': 2}
result = choices.get(key, 'default')

简单场景的简短和简单。

比较11行以上的C代码：

// C Language version of a simple 'switch/case'.
switch( key ) 
{
    case 'a' :
        result = 1;
        break;
    case 'b' :
        result = 2;
        break;
    default :
        result = -1;
}

您甚至可以通过使用元组来分配多个变量：

choices = {'a': (1, 2, 3), 'b': (4, 5, 6)}
(result1, result2, result3) = choices.get(key, ('default1', 'default2', 'default3'))

我喜欢Mark Bies的回答

由于x变量必须使用两次，我将lambda函数修改为无参数。

我必须运行结果[value]（value）

In [2]: result = {
    ...:   'a': lambda x: 'A',
    ...:   'b': lambda x: 'B',
    ...:   'c': lambda x: 'C'
    ...: }
    ...: result['a']('a')
    ...: 
Out[2]: 'A'

In [3]: result = {
    ...:   'a': lambda : 'A',
    ...:   'b': lambda : 'B',
    ...:   'c': lambda : 'C',
    ...:   None: lambda : 'Nothing else matters'

    ...: }
    ...: result['a']()
    ...: 
Out[3]: 'A'

编辑：我注意到我可以在字典中使用None类型。因此，这将模拟交换机；其他情况

定义：

def switch1(value, options):
  if value in options:
    options[value]()

允许您使用相当简单的语法，并将案例绑定到映射中：

def sample1(x):
  local = 'betty'
  switch1(x, {
    'a': lambda: print("hello"),
    'b': lambda: (
      print("goodbye," + local),
      print("!")),
    })

我一直试图用一种能让我摆脱“lambda:”的方式重新定义开关，但我放弃了。调整定义：

def switch(value, *maps):
  options = {}
  for m in maps:
    options.update(m)
  if value in options:
    options[value]()
  elif None in options:
    options[None]()

允许我将多个案例映射到同一代码，并提供默认选项：

def sample(x):
  switch(x, {
    _: lambda: print("other") 
    for _ in 'cdef'
    }, {
    'a': lambda: print("hello"),
    'b': lambda: (
      print("goodbye,"),
      print("!")),
    None: lambda: print("I dunno")
    })

每个复制的案例都必须在自己的字典中；switch（）在查找值之前合并字典。它仍然比我想象的更丑，但它的基本效率是对表达式使用散列查找，而不是循环所有键。

如果您想要默认值，可以使用dictionary get（key[，default]）函数：

def f(x):
    return {
        'a': 1,
        'b': 2
    }.get(x, 9)    # 9 will be returned default if x is not found

到目前为止，已经有很多回答说，“我们在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中进行切换？”因为这往往是一个更有趣的问题，而且往往会暴露出您正在构建的任何设计中的缺陷。

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