Substituições para a instrução switch em Python?

Eu quero escrever uma função em Python que retorna diferentes valores fixos com base no valor de um índice de entrada.

Em outros idiomas, eu usaria uma instrução switchou case, mas o Python não parece ter uma switchinstrução. Quais são as soluções Python recomendadas nesse cenário?

Você poderia usar um dicionário:

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

Se desejar padrões, use o get(key[, default])método do dicionário :

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

Eu sempre gostei de fazer dessa maneira

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

Daqui

Além dos métodos de dicionário (que eu realmente gosto, BTW), você também pode usar if- elif- elsepara obter a funcionalidade 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

Obviamente, isso não é idêntico ao switch / case - você não pode ter uma falha tão fácil quanto deixar de fora a breakdeclaração, mas pode ter um teste mais complicado. Sua formatação é mais agradável que uma série de ifs aninhados , embora funcionalmente seja isso o que está mais próximo.

Minha receita favorita do Python para switch / case é:

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

Curto e simples para cenários simples.

Compare com mais de 11 linhas de código C:

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

Você pode até atribuir várias variáveis ​​usando tuplas:

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

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))

Uso:

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

Testes:

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

O meu favorito é uma receita muito boa . Você realmente vai gostar. É o mais próximo que eu já vi de declarações de casos de comutação reais, especialmente em recursos.

class switch(object):
    def __init__(self, value):
        self.value = value
        self.fall = False

    def __iter__(self):
        """Return the match method once, then stop"""
        yield self.match
        raise StopIteration

    def match(self, *args):
        """Indicate whether or not to enter a case suite"""
        if self.fall or not args:
            return True
        elif self.value in args: # changed for v1.5, see below
            self.fall = True
            return True
        else:
            return False

Aqui está um exemplo:

# The following example is pretty much the exact use-case of a dictionary,
# but is included for its simplicity. Note that you can include statements
# in each suite.
v = 'ten'
for case in switch(v):
    if case('one'):
        print 1
        break
    if case('two'):
        print 2
        break
    if case('ten'):
        print 10
        break
    if case('eleven'):
        print 11
        break
    if case(): # default, could also just omit condition or 'if True'
        print "something else!"
        # No need to break here, it'll stop anyway

# break is used here to look as much like the real thing as possible, but
# elif is generally just as good and more concise.

# Empty suites are considered syntax errors, so intentional fall-throughs
# should contain 'pass'
c = 'z'
for case in switch(c):
    if case('a'): pass # only necessary if the rest of the suite is empty
    if case('b'): pass
    # ...
    if case('y'): pass
    if case('z'):
        print "c is lowercase!"
        break
    if case('A'): pass
    # ...
    if case('Z'):
        print "c is uppercase!"
        break
    if case(): # default
        print "I dunno what c was!"

# As suggested by Pierre Quentel, you can even expand upon the
# functionality of the classic 'case' statement by matching multiple
# cases in a single shot. This greatly benefits operations such as the
# uppercase/lowercase example above:
import string
c = 'A'
for case in switch(c):
    if case(*string.lowercase): # note the * for unpacking as arguments
        print "c is lowercase!"
        break
    if case(*string.uppercase):
        print "c is uppercase!"
        break
    if case('!', '?', '.'): # normal argument passing style also applies
        print "c is a sentence terminator!"
        break
    if case(): # default
        print "I dunno what c was!"

class Switch:
    def __init__(self, value):
        self.value = value

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        return False # Allows a traceback to occur

    def __call__(self, *values):
        return self.value in values


from datetime import datetime

with Switch(datetime.today().weekday()) as case:
    if case(0):
        # Basic usage of switch
        print("I hate mondays so much.")
        # Note there is no break needed here
    elif case(1,2):
        # This switch also supports multiple conditions (in one line)
        print("When is the weekend going to be here?")
    elif case(3,4):
        print("The weekend is near.")
    else:
        # Default would occur here
        print("Let's go have fun!") # Didn't use case for example purposes

Há um padrão que aprendi com o código Twisted Python.

class SMTP:
    def lookupMethod(self, command):
        return getattr(self, 'do_' + command.upper(), None)
    def do_HELO(self, rest):
        return 'Howdy ' + rest
    def do_QUIT(self, rest):
        return 'Bye'

SMTP().lookupMethod('HELO')('foo.bar.com') # => 'Howdy foo.bar.com'
SMTP().lookupMethod('QUIT')('') # => 'Bye'

Você pode usá-lo sempre que precisar despachar em um token e executar trecho de código estendido. Em uma máquina de estado, você teria state_métodos e enviaria self.state. Essa opção pode ser estendida de maneira limpa, herdando da classe base e definindo seus próprios do_métodos. Muitas vezes, você nem sequer tem do_métodos na classe base.

Edit: como exatamente isso é usado

No caso de SMTP, você receberá HELOdo cabo. O código relevante (de twisted/mail/smtp.py, modificado para o nosso caso) é semelhante a este

class SMTP:
    # ...

    def do_UNKNOWN(self, rest):
        raise NotImplementedError, 'received unknown command'

    def state_COMMAND(self, line):
        line = line.strip()
        parts = line.split(None, 1)
        if parts:
            method = self.lookupMethod(parts[0]) or self.do_UNKNOWN
            if len(parts) == 2:
                return method(parts[1])
            else:
                return method('')
        else:
            raise SyntaxError, 'bad syntax'

SMTP().state_COMMAND('   HELO   foo.bar.com  ') # => Howdy foo.bar.com

Você receberá ' HELO foo.bar.com '(ou poderá receber 'QUIT'ou 'RCPT TO: foo'). Isso é tokenizado em partscomo ['HELO', 'foo.bar.com']. O nome da pesquisa de método real é obtido parts[0].

(O método original também é chamado state_COMMAND, porque usa o mesmo padrão para implementar uma máquina de estado, por exemplo getattr(self, 'state_' + self.mode))

Digamos que você não queira apenas retornar um valor, mas deseja usar métodos que alteram algo em um objeto. Usando a abordagem aqui indicada seria:

result = {
  'a': obj.increment(x),
  'b': obj.decrement(x)
}.get(value, obj.default(x))

O que acontece aqui é que o python avalia todos os métodos no dicionário. Portanto, mesmo que seu valor seja 'a', o objeto será incrementado e decrementado por x.

Solução:

func, args = {
  'a' : (obj.increment, (x,)),
  'b' : (obj.decrement, (x,)),
}.get(value, (obj.default, (x,)))

result = func(*args)

Então você obtém uma lista contendo uma função e seus argumentos. Dessa forma, somente o ponteiro da função e a lista de argumentos são retornados, não avaliados. 'result' avalia a chamada de função retornada.

Eu só vou colocar meus dois centavos aqui. A razão pela qual não existe uma declaração case / switch no Python é porque o Python segue o princípio de 'Existe apenas uma maneira correta de fazer alguma coisa'. Então, obviamente, você poderia criar várias maneiras de recriar a funcionalidade de comutação / caixa, mas a maneira Pythonic de realizar isso é a construção if / elif. ie

if something:
    return "first thing"
elif somethingelse:
    return "second thing"
elif yetanotherthing:
    return "third thing"
else:
    return "default thing"

Eu apenas senti que o PEP 8 merecia um aceno aqui. Uma das coisas bonitas do Python é sua simplicidade e elegância. Isso é amplamente derivado dos princípios estabelecidos no PEP 8, incluindo "Existe apenas uma maneira correta de fazer alguma coisa"

expandindo a idéia de "ditar como interruptor". se você deseja usar um valor padrão para seu switch:

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

Se você tiver um bloco de casos complicado, considere usar uma tabela de pesquisa de dicionário de funções ...

Se você não fez isso antes, é uma boa ideia entrar no depurador e ver exatamente como o dicionário pesquisa cada função.

NOTA: Do não usar "()" no interior da caixa / pesquisa de dicionário ou ele vai chamar cada uma de suas funções como o bloco de dicionário / case é criado. Lembre-se disso, porque você deseja chamar cada função apenas uma vez usando uma pesquisa de estilo hash.

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()

Se você está pesquisando declarações extras, como "switch", criei um módulo python que estende o Python. Chama-se ESPY como "Estrutura aprimorada para Python" e está disponível para o Python 2.xe o Python 3.x.

Por exemplo, nesse caso, uma instrução switch pode ser executada pelo seguinte código:

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

que pode ser usado assim:

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

então espy traduza-o em Python como:

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

Eu descobri que uma estrutura de switch comum:

switch ...parameter...
case p1: v1; break;
case p2: v2; break;
default: v3;

pode ser expresso em Python da seguinte maneira:

(lambda x: v1 if p1(x) else v2 if p2(x) else v3)

ou formatado de forma mais clara:

(lambda x:
     v1 if p1(x) else
     v2 if p2(x) else
     v3)

Em vez de ser uma declaração, a versão python é uma expressão que é avaliada como um valor.

A maioria das respostas aqui são bastante antigas, e especialmente as aceitas, por isso parece valer a pena atualizar.

Primeiro, o FAQ oficial do Python aborda isso e recomenda a elifcadeia para casos simples e dictpara casos maiores ou mais complexos. Também sugere um conjunto de visit_métodos (um estilo usado por muitas estruturas de servidor) para alguns casos:

def dispatch(self, value):
    method_name = 'visit_' + str(value)
    method = getattr(self, method_name)
    method()

O FAQ também menciona PEP 275 , que foi escrito para obter uma decisão oficial e definitiva sobre a adição de instruções de chave no estilo C. Mas esse PEP foi realmente adiado para o Python 3, e só foi oficialmente rejeitado como uma proposta separada, o PEP 3103 . A resposta foi, é claro, não - mas os dois PEPs têm links para informações adicionais, se você estiver interessado nos motivos ou na história.

Uma coisa que surgiu várias vezes (e pode ser vista no PEP 275, mesmo que tenha sido cortada como uma recomendação real) é que, se você realmente se incomoda ao ter 8 linhas de código para lidar com 4 casos, em comparação com os 6 linhas que você teria em C ou Bash, você sempre pode escrever isso:

if x == 1: print('first')
elif x == 2: print('second')
elif x == 3: print('third')
else: print('did not place')

Isso não é exatamente incentivado pelo PEP 8, mas é legível e não muito unidiomatic.

Durante mais de uma década desde que o PEP 3103 foi rejeitado, a questão das declarações de caso no estilo C, ou mesmo a versão um pouco mais poderosa em Go, foi considerada morta; sempre que alguém aborda ideias de python ou -dev, elas são encaminhadas para a decisão antiga.

No entanto, a idéia de uma correspondência completa de padrões no estilo ML surge a cada poucos anos, principalmente porque idiomas como Swift e Rust a adotaram. O problema é que é difícil tirar muito proveito da correspondência de padrões sem os tipos de dados algébricos. Embora Guido tenha sido solidário com a idéia, ninguém apresentou uma proposta que se encaixe muito bem no Python. (Você pode ler meu exemplo de 2014 para um exemplo.) Isso pode mudar com o dataclassitem 3.7 e com algumas propostas esporádicas para uma forma mais eficiente enumde lidar com tipos de soma, ou com várias propostas para diferentes tipos de ligações locais de declaração (como PEP 3150 ou o conjunto de propostas atualmente sendo discutidas em idéias). Mas até agora, não tem.

Ocasionalmente, também existem propostas para a correspondência no estilo Perl 6, que é basicamente uma confusão de tudo, desde elifregex até comutação de tipo de despacho único.

Solução para executar funções:

result = {
    'case1':     foo1, 
    'case2':     foo2,
    'case3':     foo3,
    'default':   default,
}.get(option)()

onde foo1 (), foo2 (), foo3 () e padrão () são funções

Não encontrei a resposta simples que estava procurando em nenhum lugar na pesquisa do Google. Mas eu descobri mesmo assim. É realmente bem simples. Decidiu publicá-lo e talvez impedir alguns arranhões a menos na cabeça de outra pessoa. A chave é simplesmente "in" e tuplas. Aqui está o comportamento da instrução switch com fall-through, incluindo fall-through RANDOM.

l = ['Dog', 'Cat', 'Bird', 'Bigfoot',
     'Dragonfly', 'Snake', 'Bat', 'Loch Ness Monster']

for x in l:
    if x in ('Dog', 'Cat'):
        x += " has four legs"
    elif x in ('Bat', 'Bird', 'Dragonfly'):
        x += " has wings."
    elif x in ('Snake',):
        x += " has a forked tongue."
    else:
        x += " is a big mystery by default."
    print(x)

print()

for x in range(10):
    if x in (0, 1):
        x = "Values 0 and 1 caught here."
    elif x in (2,):
        x = "Value 2 caught here."
    elif x in (3, 7, 8):
        x = "Values 3, 7, 8 caught here."
    elif x in (4, 6):
        x = "Values 4 and 6 caught here"
    else:
        x = "Values 5 and 9 caught in default."
    print(x)

Fornece:

Dog has four legs
Cat has four legs
Bird has wings.
Bigfoot is a big mystery by default.
Dragonfly has wings.
Snake has a forked tongue.
Bat has wings.
Loch Ness Monster is a big mystery by default.

Values 0 and 1 caught here.
Values 0 and 1 caught here.
Value 2 caught here.
Values 3, 7, 8 caught here.
Values 4 and 6 caught here
Values 5 and 9 caught in default.
Values 4 and 6 caught here
Values 3, 7, 8 caught here.
Values 3, 7, 8 caught here.
Values 5 and 9 caught in default.

As soluções que eu uso:

Uma combinação de duas das soluções postadas aqui, que é relativamente fácil de ler e suporta padrões.

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

Onde

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

procura "lambda x: x - 2"no ditado e o usa comx=23

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

não o encontra no dict e usa o padrão "lambda x: x - 22"com x=44.

# simple case alternative

some_value = 5.0

# this while loop block simulates a case block

# case
while True:

    # case 1
    if some_value > 5:
        print ('Greater than five')
        break

    # case 2
    if some_value == 5:
        print ('Equal to five')
        break

    # else case 3
    print ( 'Must be less than 5')
    break

def f(x):
    dictionary = {'a':1, 'b':2, 'c':3}
    return dictionary.get(x,'Not Found') 
##Returns the value for the letter x;returns 'Not Found' if x isn't a key in the dictionary

Gostei da resposta de Mark Bies

Como a xvariável deve ser usada duas vezes, modifiquei as funções lambda para sem parâmetros.

Eu tenho que correr com results[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'

Editar: notei que posso usar o Nonetipo com dicionários. Então isso simulariaswitch ; case else

def f(x):
     return 1 if x == 'a' else\
            2 if x in 'bcd' else\
            0 #default

Curto e fácil de ler, possui um valor padrão e suporta expressões em condições e valores de retorno.

No entanto, é menos eficiente que a solução com um dicionário. Por exemplo, o Python precisa varrer todas as condições antes de retornar o valor padrão.

você pode usar um ditado despachado:

#!/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()

Resultado:

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

Simples, não testado; cada condição é avaliada independentemente: não há falhas, mas todos os casos são avaliados (embora a expressão para ativar seja avaliada apenas uma vez), a menos que haja uma declaração de interrupção. Por exemplo,

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. ')

impressões Was 1. Was 1 or 2. Was something. ^{(Caramba! Por que não consigo deixar espaços em branco nos blocos de código embutido?)} se expressionavalia para 1, Was 2.se expressionavalia para 2ou Was something.se expressionavalia para outra coisa.

Definindo:

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

permite que você use uma sintaxe bastante direta, com os casos agrupados em um mapa:

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

Continuei tentando redefinir a opção de uma maneira que me permitisse me livrar do "lambda:", mas desisti. Ajustando a definição:

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

Permitiu-me mapear vários casos para o mesmo código e fornecer uma opção padrão:

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")
    })

Cada caso replicado deve estar em seu próprio dicionário; switch () consolida os dicionários antes de procurar o valor. Ainda é mais feio do que eu gostaria, mas tem a eficiência básica de usar uma pesquisa de hash na expressão, em vez de um loop por todas as chaves.

Eu acho que a melhor maneira é usar os idiomas da linguagem python para manter seu código testável . Como mostrado nas respostas anteriores, eu uso dicionários para tirar proveito das estruturas e da linguagem python e manter o código "case" isolado em diferentes métodos. Abaixo há uma classe, mas você pode usar diretamente um módulo, globais e funções. A classe possui métodos que podem ser testados com isolamento . Dependendo de suas necessidades, você também pode jogar com métodos e atributos estáticos.

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)

É possível aproveitar esse método usando também classes como chaves de "__choice_table". Dessa forma, você pode evitar um abuso de instância e manter tudo limpo e testável.

Supondo que você precise processar muitas mensagens ou pacotes da rede ou do seu MQ. Cada pacote tem sua própria estrutura e seu código de gerenciamento (de maneira genérica). Com o código acima, é possível fazer algo assim:

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)

Portanto, a complexidade não é espalhada no fluxo de código, mas é renderizada na estrutura do código .

Expandindo a resposta de Greg Hewgill - Podemos encapsular a solução de dicionário usando um decorador:

def case(callable):
    """switch-case decorator"""
    class case_class(object):
        def __init__(self, *args, **kwargs):
            self.args = args
            self.kwargs = kwargs

        def do_call(self):
            return callable(*self.args, **self.kwargs)

return case_class

def switch(key, cases, default=None):
    """switch-statement"""
    ret = None
    try:
        ret = case[key].do_call()
    except KeyError:
        if default:
            ret = default.do_call()
    finally:
        return ret

Isso pode ser usado com o @case-decorator

@case
def case_1(arg1):
    print 'case_1: ', arg1

@case
def case_2(arg1, arg2):
    print 'case_2'
    return arg1, arg2

@case
def default_case(arg1, arg2, arg3):
    print 'default_case: ', arg1, arg2, arg3

ret = switch(somearg, {
    1: case_1('somestring'),
    2: case_2(13, 42)
}, default_case(123, 'astring', 3.14))

print ret

A boa notícia é que isso já foi feito no módulo NeoPySwitch. Basta instalar usando o pip:

pip install NeoPySwitch

Uma solução que costumo usar e que também usa dicionários é:

def decision_time( key, *args, **kwargs):
    def action1()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action2()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action3()
        """This function is a closure - and has access to all the arguments"""
        pass

   return {1:action1, 2:action2, 3:action3}.get(key,default)()

Isso tem a vantagem de não tentar avaliar as funções todas as vezes, e você só precisa garantir que a função externa obtenha todas as informações que as funções internas precisam.

Até agora, existem muitas respostas que dizem: "não temos uma opção no Python, faça dessa maneira". No entanto, gostaria de salientar que a própria instrução switch é uma construção de fácil abuso que pode e deve ser evitada na maioria dos casos, porque promove uma programação lenta. Caso em questão:

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

Agora, você poderia fazer isso com uma instrução switch (se o Python oferecesse uma), mas estaria desperdiçando seu tempo porque existem métodos que fazem isso muito bem. Ou talvez, você tenha algo menos óbvio:

def ConvertToReason(code):
    if (code == 200):
        return 'Okay'
    elif (code == 400):
        return 'Bad Request'
    elif (code == 404):
        return 'Not Found'
    else:
        return None

No entanto, esse tipo de operação pode e deve ser tratado com um dicionário, pois será mais rápido, menos complexo, menos propenso a erros e mais compacto.

E a grande maioria dos "casos de uso" para instruções de troca se enquadra em um desses dois casos; há muito pouca razão para usar uma se você já pensou bem no seu problema.

Então, em vez de perguntar "como alterno no Python?", Talvez devêssemos perguntar: "por que quero alternar no Python?" porque essa é frequentemente a pergunta mais interessante e muitas vezes expõe falhas no design do que você estiver criando.

Agora, isso não quer dizer que os switches também nunca devam ser usados. Máquinas de estado, lexers, analisadores e autômatos os usam até certo ponto e, em geral, quando você inicia a partir de uma entrada simétrica e passa para uma saída assimétrica, eles podem ser úteis; você só precisa ter certeza de que não usa a chave como martelo, porque vê um monte de pregos no seu código.