Python 3.10（2021）引入了match-case语句，该语句提供了Pythons“switch”的一流实现。例如：

def f(x):
    match x:
        case 'a':
            return 1
        case 'b':
            return 2
        case _:
            return 0   # 0 is the default case if x is not found

match-case语句比这个简单的示例强大得多。

以下原始答案写于2008年，当时还未提供匹配案例：

你可以用字典：

def f(x):
    return {
        'a': 1,
        'b': 2,
    }[x]

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

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

Python 3.10（2021）引入了match-case语句，该语句提供了Pythons“switch”的一流实现。例如：

def f(x):
    match x:
        case 'a':
            return 1
        case 'b':
            return 2
        case _:
            return 0   # 0 is the default case if x is not found

match-case语句比这个简单的示例强大得多。

以下原始答案写于2008年，当时还未提供匹配案例：

你可以用字典：

def f(x):
    return {
        'a': 1,
        'b': 2,
    }[x]

扩展“dict as switch”思想。如果要为交换机使用默认值：

def f(x):
    try:
        return {
            'a': 1,
            'b': 2,
        }[x]
    except KeyError:
        return 'default'

如果你有一个复杂的大小写块，你可以考虑使用函数字典查找表。。。

如果您以前没有这样做过，那么最好进入调试器并查看字典如何查找每个函数。

注意：不要在大小写/字典查找中使用“（）”，否则将在创建字典/大小写块时调用每个函数。记住这一点，因为您只想使用哈希样式查找调用每个函数一次。

def first_case():
    print "first"

def second_case():
    print "second"

def third_case():
    print "third"

mycase = {
'first': first_case, #do not use ()
'second': second_case, #do not use ()
'third': third_case #do not use ()
}
myfunc = mycase['first']
myfunc()

作为Mark Biek答案的一个小变化，对于像这样的不常见情况，用户有一堆函数调用要延迟，而参数要打包（而且不值得构建一堆不符合逻辑的函数），而不是这样：

d = {
    "a1": lambda: a(1),
    "a2": lambda: a(2),
    "b": lambda: b("foo"),
    "c": lambda: c(),
    "z": lambda: z("bar", 25),
    }
return d[string]()

…您可以这样做：

d = {
    "a1": (a, 1),
    "a2": (a, 2),
    "b": (b, "foo"),
    "c": (c,)
    "z": (z, "bar", 25),
    }
func, *args = d[string]
return func(*args)

这当然更短，但它是否更可读是一个悬而未决的问题…

我认为从lambda转换为partial可能更容易理解（虽然不是更简单）：

d = {
    "a1": partial(a, 1),
    "a2": partial(a, 2),
    "b": partial(b, "foo"),
    "c": c,
    "z": partial(z, "bar", 25),
    }
return d[string]()

…它的优点是可以很好地处理关键字参数：

d = {
    "a1": partial(a, 1),
    "a2": partial(a, 2),
    "b": partial(b, "foo"),
    "c": c,
    "k": partial(k, key=int),
    "z": partial(z, "bar", 25),
    }
return d[string]()