Sostituzioni per l'istruzione switch in Python?

Voglio scrivere una funzione in Python che restituisce diversi valori fissi in base al valore di un indice di input.

In altre lingue userei un'istruzione switcho case, ma Python non sembra avere switchun'istruzione. Quali sono le soluzioni Python consigliate in questo scenario?

Puoi usare un dizionario:

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

Se desideri impostazioni predefinite, puoi utilizzare il get(key[, default])metodo del dizionario :

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

Mi è sempre piaciuto farlo in questo modo

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

Da qui

Oltre ai metodi del dizionario (che mi piace molto, a proposito), puoi anche usare if- elif- elseper ottenere la funzionalità 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

Questo ovviamente non è identico a switch / case: non si può fallire facilmente come lasciare la breakdichiarazione, ma si può avere un test più complicato. La sua formattazione è migliore di una serie di ifs nidificati , anche se funzionalmente è quello che è più vicino.

La mia ricetta preferita di Python per switch / case è:

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

Breve e semplice per scenari semplici.

Confronta con 11+ righe di codice C:

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

Puoi anche assegnare più variabili usando le tuple:

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

test:

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

La mia preferita è una ricetta davvero carina . Ti piacerà davvero. È il più vicino che ho visto per le affermazioni del caso switch, in particolare per quanto riguarda le funzionalità.

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

Ecco un esempio:

# 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

C'è un modello che ho imparato dal codice di 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'

Puoi usarlo ogni volta che devi inviare un token ed eseguire un pezzo di codice esteso. In una macchina a stati avresti state_metodi e invio self.state. Questa opzione può essere estesa in modo chiaro ereditando dalla classe base e definendo i propri do_metodi. Spesso non avrai nemmeno do_metodi nella classe base.

Modifica: come viene utilizzato esattamente

In caso di SMTP riceverai HELOdal bonifico. Il codice pertinente (da twisted/mail/smtp.py, modificato per il nostro caso) è simile al seguente

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

Riceverai ' HELO foo.bar.com '(o potresti ottenere 'QUIT'o 'RCPT TO: foo'). Questo è tokenizzato in partsas ['HELO', 'foo.bar.com']. Viene preso il nome di ricerca del metodo effettivo parts[0].

(Viene anche chiamato il metodo originale state_COMMAND, perché utilizza lo stesso modello per implementare una macchina a stati, ovvero getattr(self, 'state_' + self.mode))

Diciamo che non vuoi solo restituire un valore, ma vuoi usare metodi che cambiano qualcosa su un oggetto. Utilizzando l'approccio indicato qui sarebbe:

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

Quello che succede qui è che Python valuta tutti i metodi nel dizionario. Quindi, anche se il tuo valore è 'a', l'oggetto verrà incrementato e decrementato di x.

Soluzione:

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

result = func(*args)

Quindi ottieni un elenco contenente una funzione e i suoi argomenti. In questo modo, vengono restituiti solo il puntatore a funzione e l'elenco degli argomenti, non valutati. 'risultato' quindi valuta la chiamata di funzione restituita.

Sto solo lasciando cadere i miei due centesimi qui. Il motivo per cui non esiste un'istruzione case / switch in Python è perché Python segue il principio di "C'è solo un modo giusto per fare qualcosa". Quindi, ovviamente, potresti trovare vari modi per ricreare la funzionalità switch / case, ma il modo Pythonic per realizzare questo è il costrutto if / elif. vale a dire

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

Ho appena sentito che PEP 8 meritava un cenno qui. Una delle cose belle di Python è la sua semplicità ed eleganza. Ciò è in gran parte derivato dai principi stabiliti nel PEP 8, tra cui "C'è solo un modo giusto per fare qualcosa"

espandendo l'idea "dict as switch". se si desidera utilizzare un valore predefinito per lo switch:

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

Se si dispone di un blocco maiuscolo complicato, è possibile utilizzare una tabella di ricerca del dizionario delle funzioni ...

Se non l'hai mai fatto prima, è una buona idea entrare nel tuo debugger e vedere esattamente come il dizionario cerca ogni funzione.

NOTA: non utilizzare "()" all'interno della ricerca caso / dizionario o chiamerà ciascuna delle funzioni man mano che viene creato il blocco dizionario / caso. Ricordalo perché vuoi chiamare ciascuna funzione solo una volta usando una ricerca in stile 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 stai cercando istruzioni extra, come "switch", ho creato un modulo Python che estende Python. Si chiama ESPY come "Enhanced Structure for Python" ed è disponibile per Python 2.xe Python 3.x.

Ad esempio, in questo caso, un'istruzione switch potrebbe essere eseguita dal seguente codice:

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

che può essere usato in questo modo:

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

quindi espy lo traduce in Python come:

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

Ho scoperto che una struttura switch comune:

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

può essere espresso in Python come segue:

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

o formattato in modo più chiaro:

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

Invece di essere un'istruzione, la versione di Python è un'espressione, che valuta un valore.

La maggior parte delle risposte qui sono piuttosto vecchie, e specialmente quelle accettate, quindi sembra che valga la pena aggiornarle.

Innanzitutto, le FAQ ufficiali di Python coprono questo aspetto e raccomandano la elifcatena per casi semplici e casi dictpiù grandi o più complessi. Suggerisce inoltre una serie di visit_metodi (uno stile utilizzato da molti framework di server) per alcuni casi:

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

Le FAQ menzionano anche PEP 275 , che è stato scritto per ottenere una decisione una tantum ufficiale sull'aggiunta di istruzioni switch C-style. Ma quel PEP è stato effettivamente rinviato a Python 3 ed è stato ufficialmente respinto solo come proposta separata, PEP 3103 . La risposta è stata ovviamente no, ma i due PEP hanno collegamenti a informazioni aggiuntive se siete interessati ai motivi o alla cronologia.

Una cosa che è emersa più volte (e può essere vista in PEP 275, anche se è stata ritagliata come una vera raccomandazione) è che se sei davvero infastidito dall'avere 8 righe di codice per gestire 4 casi, rispetto al 6 righe che avresti in C o Bash, puoi sempre scrivere questo:

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

Questo non è esattamente incoraggiato da PEP 8, ma è leggibile e non troppo unidiomatico.

Nel corso di oltre un decennio da quando PEP 3103 è stato respinto, il problema delle dichiarazioni di casi in stile C, o persino della versione leggermente più potente di Go, è stato considerato morto; ogni volta che qualcuno lo solleva su python-ideas o -dev, viene riferito alla vecchia decisione.

Tuttavia, l'idea di una perfetta corrispondenza del modello in stile ML nasce ogni pochi anni, soprattutto da quando sono stati adottati linguaggi come Swift e Rust. Il problema è che è difficile sfruttare al meglio la corrispondenza dei pattern senza tipi di dati algebrici. Mentre Guido è stato simpatico all'idea, nessuno ha escogitato una proposta che si adatta molto bene a Python. (Puoi leggere il mio strawman del 2014 per un esempio.) Questo potrebbe cambiare con dataclassin 3.7 e alcune sporadiche proposte per un enumtipo di somma più potente da gestire, o con varie proposte per diversi tipi di associazioni locali-dichiarazione (come PEP 3150 , o il serie di proposte attualmente in discussione in -ideas). Ma finora no.

Occasionalmente ci sono anche proposte per l'abbinamento in stile Perl 6, che è fondamentalmente un miscuglio di tutto, dal elifregex al cambio di tipo a singolo invio.

Soluzione per eseguire funzioni:

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

dove foo1 (), foo2 (), foo3 () e default () sono funzioni

Non ho trovato la risposta semplice che cercavo da nessuna parte nella ricerca di Google. Ma l'ho capito comunque. È davvero abbastanza semplice. Ha deciso di pubblicarlo e forse prevenire qualche graffio in meno sulla testa di qualcun altro. La chiave è semplicemente "in" e tuple. Ecco il comportamento dell'istruzione switch con fall-through, incluso il 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)

Fornisce:

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.

Le soluzioni che utilizzo:

Una combinazione di 2 delle soluzioni pubblicate qui, che è relativamente facile da leggere e supporta le impostazioni predefinite.

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

dove

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

cerca "lambda x: x - 2"nel dict e lo usa conx=23

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

non lo trova nel dict e utilizza l'impostazione predefinita "lambda x: x - 22"con 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

Mi è piaciuta la risposta di Mark Bies

Poiché la xvariabile deve essere utilizzata due volte, ho modificato le funzioni lambda in senza parametri.

Devo correre con 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'

Modifica: ho notato che posso usare il Nonetipo con i dizionari. Quindi questo emulerebbeswitch ; case else

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

Breve e facile da leggere, ha un valore predefinito e supporta espressioni sia in condizioni che in valori di ritorno.

Tuttavia, è meno efficiente della soluzione con un dizionario. Ad esempio, Python deve esaminare tutte le condizioni prima di restituire il valore predefinito.

puoi usare un dict spedito:

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

Produzione:

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

Semplice, non testato; ogni condizione viene valutata in modo indipendente: non esiste un fall-through, ma vengono valutati tutti i casi (sebbene l'espressione da attivare venga valutata solo una volta), a meno che non vi sia un'istruzione break. Per esempio,

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

stampe Was 1. Was 1 or 2. Was something. ^{(Dannazione! Perché non posso avere spazi vuoti finali in blocchi di codice inline?)} se expressionvaluta 1, Was 2.se expressionvaluta 2o Was something.se expressionvaluta qualcos'altro.

Definizione:

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

ti permette di usare una sintassi abbastanza semplice, con i casi raggruppati in una mappa:

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

Continuavo a cercare di ridefinire l'interruttore in un modo che mi permettesse di liberarmi del "lambda:", ma mi sono arreso. Modifica della definizione:

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

Mi ha permesso di mappare più casi sullo stesso codice e di fornire un'opzione predefinita:

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

Ogni caso replicato deve essere nel proprio dizionario; switch () consolida i dizionari prima di cercare il valore. È ancora più brutto di quanto mi piacerebbe, ma ha l'efficienza di base dell'uso di una ricerca con hash sull'espressione, piuttosto che un ciclo attraverso tutte le chiavi.

Penso che il modo migliore sia usare gli idiomi del linguaggio python per mantenere testabile il tuo codice . Come mostrato nelle risposte precedenti, utilizzo i dizionari per sfruttare le strutture e il linguaggio di Python e mantenere il codice "case" isolato in diversi metodi. Di seguito è presente una classe, ma è possibile utilizzare direttamente un modulo, globi e funzioni. La classe ha metodi che possono essere testati con isolamento . A seconda delle tue esigenze, puoi giocare anche con metodi e attributi statici.

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)

È possibile sfruttare questo metodo usando anche le classi come chiavi di "__choice_table". In questo modo puoi evitare l'abuso di isinstance e mantenere tutto pulito e testabile.

Supponendo che tu debba elaborare molti messaggi o pacchetti dalla rete o dal tuo MQ. Ogni pacchetto ha la sua struttura e il suo codice di gestione (in modo generico). Con il codice sopra è possibile fare qualcosa del genere:

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)

Quindi la complessità non si diffonde nel flusso del codice ma viene resa nella struttura del codice .

Espandendo la risposta di Greg Hewgill - Possiamo incapsulare la soluzione del dizionario usando un decoratore:

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

Questo può quindi essere usato con il @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

La buona notizia è che questo è già stato fatto nel modulo NeoPySwitch . Installa semplicemente usando pip:

pip install NeoPySwitch

Una soluzione che tendo a utilizzare che utilizza anche dizionari è:

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

Questo ha il vantaggio di non provare a valutare le funzioni ogni volta e devi solo assicurarti che la funzione esterna ottenga tutte le informazioni di cui le funzioni interne hanno bisogno.

Finora ci sono state molte risposte che hanno detto: "Non abbiamo un interruttore in Python, fallo in questo modo". Tuttavia, vorrei sottolineare che la stessa istruzione switch è un costrutto facilmente abusato che può e dovrebbe essere evitato nella maggior parte dei casi perché promuove la programmazione pigra. Caso in questione:

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

Ora, si potrebbe fare questo con un interruttore-statement (se Python offerto uno), ma si sarebbe sprecare il vostro tempo, perché ci sono metodi che fanno questo bene. O forse, hai qualcosa di meno ovvio:

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

Tuttavia, questo tipo di operazione può e deve essere gestita con un dizionario perché sarà più veloce, meno complesso, meno soggetto a errori e più compatto.

E la stragrande maggioranza dei "casi d'uso" per le istruzioni switch rientrerà in uno di questi due casi; ci sono pochissime ragioni per usarne uno se hai riflettuto a fondo sul tuo problema.

Quindi, piuttosto che chiedere "come faccio a cambiare in Python?", Forse dovremmo chiedere "perché voglio passare a Python?" perché questa è spesso la domanda più interessante e spesso esporrà difetti nella progettazione di qualsiasi cosa tu stia costruendo.

Ora, ciò non vuol dire che nemmeno gli switch dovrebbero essere usati. Le macchine a stati, i lexer, i parser e gli automi li usano tutti in una certa misura e, in generale, quando si parte da un input simmetrico e si passa a un output asimmetrico, possono essere utili; devi solo assicurarti di non usare l'interruttore come un martello perché vedi un mucchio di chiodi nel tuo codice.