Zastąpienia instrukcji switch w Pythonie?

Chcę napisać funkcję w języku Python, która zwraca różne stałe wartości na podstawie wartości indeksu wejściowego.

W innych językach użyłbym instrukcji switchlub case, ale wydaje się, że Python nie ma switchinstrukcji. Jakie są zalecane rozwiązania Python w tym scenariuszu?

Możesz użyć słownika:

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

Jeśli chcesz mieć wartości domyślne, możesz użyć get(key[, default])metody słownikowej :

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

Zawsze lubiłem to robić w ten sposób

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

Stąd

Oprócz metod słownikowych (które naprawdę lubię BTW) możesz także użyć if- elif- w elsecelu uzyskania funkcji 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

To oczywiście nie jest identyczne z przełącznikiem / skrzynką - nie możesz tak łatwo przejść przez to, co pomijanie breakinstrukcji, ale możesz mieć bardziej skomplikowany test. Jego formatowanie jest ładniejsze niż seria zagnieżdżonych ifs, nawet jeśli funkcjonalnie jest to do tego bliżej.

Mój ulubiony przepis Pythona na przełącznik / skrzynkę to:

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

Krótkie i proste dla prostych scenariuszy.

Porównaj z ponad 11 liniami kodu C:

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

Możesz nawet przypisać wiele zmiennych za pomocą krotek:

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

Stosowanie:

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

Testy:

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

Mój ulubiony to naprawdę fajny przepis . Naprawdę ci się spodoba. Jest to najbliższy, jaki widziałem rzeczywiste instrukcje przypadków przełączania, szczególnie w funkcjach.

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

Oto przykład:

# 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

Jest pewien wzór, którego nauczyłem się z kodu 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'

Możesz go użyć w dowolnym momencie, gdy potrzebujesz wysłać token i wykonać rozszerzony fragment kodu. W maszynie stanów masz state_metody i wysyłamy dalej self.state. Przełącznik można rozszerzyć, dziedzicząc po klasie podstawowej i definiując własne do_metody. Często nawet nie masz do_metod w klasie bazowej.

Edycja: jak dokładnie to jest używane

W przypadku SMTP otrzymasz HELOz drutu. Odpowiedni kod (z twisted/mail/smtp.py, zmodyfikowany w naszym przypadku) wygląda następująco

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

Otrzymasz ' HELO foo.bar.com '(lub możesz dostać 'QUIT'lub 'RCPT TO: foo'). Jest to symbolizowane partsjako ['HELO', 'foo.bar.com']. Rzeczywista nazwa wyszukiwania metody pochodzi z parts[0].

(Oryginalna metoda jest również wywoływana state_COMMAND, ponieważ używa tego samego wzorca do implementacji automatu stanów, tj. getattr(self, 'state_' + self.mode))

Powiedzmy, że nie chcesz po prostu zwracać wartości, ale chcesz użyć metod, które zmieniają coś na obiekcie. Przy zastosowaniu podanego tutaj podejścia byłoby:

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

To, co się tutaj dzieje, polega na tym, że Python ocenia wszystkie metody w słowniku. Więc nawet jeśli twoja wartość to „a”, obiekt zostanie zwiększony i zmniejszony o x.

Rozwiązanie:

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

result = func(*args)

Otrzymujesz więc listę zawierającą funkcję i jej argumenty. W ten sposób zwracany jest tylko wskaźnik funkcji i lista argumentów, a nie wartościowane. „wynik” następnie ocenia zwrócone wywołanie funkcji.

Po prostu wrzucę tutaj moje dwa centy. Powodem, dla którego nie ma instrukcji case / switch w Pythonie, jest to, że Python działa zgodnie z zasadą „Istnieje tylko jeden właściwy sposób na zrobienie czegoś”. Oczywiście można wymyślić różne sposoby odtwarzania funkcji przełącznika / wielkości liter, ale pythonicznym sposobem osiągnięcia tego jest konstrukcja if / elif. to znaczy

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

Po prostu czułem, że PEP 8 zasługuje na skinienie głową. Jedną z pięknych rzeczy w Pythonie jest jego prostota i elegancja. Wynika to w dużej mierze z zasad określonych w PEP 8, w tym „Istnieje tylko jeden właściwy sposób, aby coś zrobić”

rozwinięcie idei „dict as switch”. jeśli chcesz użyć domyślnej wartości dla przełącznika:

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

Jeśli masz skomplikowany blok spraw, możesz rozważyć użycie tabeli wyszukiwania słownika funkcji ...

Jeśli nie zrobiłeś tego wcześniej, dobrze jest wejść do debuggera i zobaczyć dokładnie, jak słownik wyszukuje każdą funkcję.

Uwaga: nie używać „()” wewnątrz obudowy / słownik odnośnika albo zadzwoni do każdego ze swoich funkcji jako blok słownik / sprawa jest tworzony. Pamiętaj o tym, ponieważ chcesz wywołać każdą funkcję tylko raz, używając wyszukiwania w stylu skrótu.

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

Jeśli szukasz dodatkowej instrukcji, jako „switch”, zbudowałem moduł Pythona, który rozszerza Pythona. Nazywa się ESPY jako „Enhanced Structure for Python” i jest dostępny zarówno dla Python 2.x, jak i Python 3.x.

Na przykład w tym przypadku instrukcja switch może zostać wykonana za pomocą następującego kodu:

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

które mogą być użyte w ten sposób:

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

więc espy przetłumaczy to w Pythonie jako:

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

Odkryłem, że wspólna struktura przełączników:

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

można wyrazić w Pythonie w następujący sposób:

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

lub sformatowane w jaśniejszy sposób:

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

Zamiast być instrukcją, wersja Pythona jest wyrażeniem, którego wynikiem jest wartość.

Większość odpowiedzi tutaj jest dość stara, a zwłaszcza te zaakceptowane, więc warto je zaktualizować.

Po pierwsze, oficjalne FAQ Pythona obejmuje to i zaleca elifłańcuch dla prostych przypadków i dictdla większych lub bardziej złożonych przypadków. Sugeruje również zestaw visit_metod (styl używany przez wiele frameworków serwerowych) w niektórych przypadkach:

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

FAQ również wspomina PEP 275 , który został napisany, aby uzyskać oficjalną decyzję raz na zawsze o dodaniu instrukcji przełączania w stylu C. Ale ten PEP został odroczony do Pythona 3 i został oficjalnie odrzucony jako osobna propozycja, PEP 3103 . Odpowiedź brzmiała oczywiście nie - ale dwa PEP mają linki do dodatkowych informacji, jeśli interesują cię powody lub historia.

Jedną z rzeczy, które pojawiały się wiele razy (i można to zobaczyć w PEP 275, nawet jeśli zostało to wycięte jako rzeczywista rekomendacja) jest to, że jeśli naprawdę przeszkadza ci posiadanie 8 linii kodu do obsługi 4 przypadków, w porównaniu z 6 linie, które miałbyś w C lub Bash, zawsze możesz napisać to:

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

PEP 8 nie zachęca do tego, ale jest czytelny i niezbyt jednoznaczny.

Przez ponad dekadę od odrzucenia PEP 3103 kwestia instrukcji typu C lub nawet nieco bardziej rozbudowana wersja Go została uznana za martwą; ilekroć ktoś porusza to w python-pomysłach lub -dev, odnosi się do starej decyzji.

Jednak idea pełnego dopasowania wzorców w stylu ML pojawia się co kilka lat, zwłaszcza że takie języki, jak Swift i Rust ją przyjęły. Problem polega na tym, że trudno jest w dużym stopniu wykorzystać dopasowanie wzorca bez algebraicznych typów danych. Chociaż Guido był przychylny temu pomysłowi, nikt nie wpadł na propozycję, która bardzo dobrze pasuje do Pythona. (Możesz przeczytać mój strawman z 2014 r .). Może to ulec zmianie dataclassw wersji 3.7 i sporadycznych propozycjach dotyczących bardziej wydajnej enumobsługi typów sum lub różnych propozycji dla różnych rodzajów powiązań lokalnych instrukcji (takich jak PEP 3150 lub zestaw propozycji obecnie dyskutowanych na żywo). Ale jak dotąd tak nie było.

Od czasu do czasu pojawiają się również propozycje dopasowania w stylu Perla 6, które jest w zasadzie pomieszaniem wszystkiego, od elifwyrażeń regularnych po przełączanie typów pojedynczej wysyłki.

Rozwiązanie do uruchamiania funkcji:

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

gdzie foo1 (), foo2 (), foo3 () i default () są funkcjami

W wyszukiwarce Google nie znalazłem prostej odpowiedzi, której szukałem. Ale i tak to wymyśliłem. To naprawdę bardzo proste. Postanowiłem go opublikować i być może zapobiec kilku mniejszym zadrapaniom na głowie innej osoby. Klucz jest po prostu „w” i krotkami. Oto zachowanie instrukcji przełączania z funkcją awaryjną, w tym awaryjną 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)

Zapewnia:

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.

Rozwiązania, których używam:

Połączenie 2 opublikowanych tutaj rozwiązań, które jest stosunkowo łatwe do odczytania i obsługuje ustawienia domyślne.

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

gdzie

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

wyszukuje "lambda x: x - 2"w dykcie i używa gox=23

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

nie znajduje go w dykcie i używa domyślnego "lambda x: x - 22"z 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

Podobała mi się odpowiedź Marka Biesa

Ponieważ xzmienna musi być użyta dwukrotnie, zmodyfikowałem funkcje lambda do bez parametrów.

Muszę uciekać 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'

Edycja: Zauważyłem, że mogę używać Nonepisma z słownikami. To by naśladowałoswitch ; case else

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

Krótki i łatwy do odczytania, ma wartość domyślną i obsługuje wyrażenia zarówno w warunkach, jak i zwracanych wartości.

Jest jednak mniej wydajne niż rozwiązanie ze słownikiem. Na przykład Python musi przejrzeć wszystkie warunki przed zwróceniem wartości domyślnej.

możesz użyć wysłanego słownika:

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

Wynik:

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

Prosty, nie przetestowany; każdy warunek jest oceniany niezależnie: nie występuje awaria, ale wszystkie przypadki są oceniane (chociaż wyrażenie do włączenia jest oceniane tylko raz), chyba że istnieje instrukcja break. Na przykład,

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

druki Was 1. Was 1 or 2. Was something. ^{(Cholera! Dlaczego nie mogę mieć końcowe spacje w inline bloków kodu?),} jeśli expressionocenia się 1, Was 2.jeśli expressionma wartość 2, lub Was something.jeśli expressionma wartość czegoś innego.

Definiowanie:

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

pozwala na użycie dość prostej składni, z przypadkami spakowanymi w mapę:

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

Próbowałem na nowo zdefiniować przełącznik w sposób, który pozwoliłby mi pozbyć się „lambda:”, ale poddałem się. Poprawianie definicji:

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

Pozwoliłem mi odwzorować wiele spraw na ten sam kod i podać domyślną opcję:

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

Każda replikowana sprawa musi znajdować się w swoim własnym słowniku; switch () konsoliduje słowniki przed wyszukaniem wartości. Wciąż jest brzydszy, niż bym chciał, ale ma podstawową efektywność używania haszowanego wyszukiwania wyrażenia, a nie pętli przez wszystkie klawisze.

Myślę, że najlepszym sposobem jest użycie idiomów języka Python, aby kod był testowalny . Jak pokazano w poprzednich odpowiedziach, używam słowników, aby korzystać ze struktur i języka Pythona i utrzymywać kod „case” w izolacji na różne sposoby. Poniżej znajduje się klasa, ale możesz użyć bezpośrednio modułu, globałów i funkcji. Klasa ma metody, które można przetestować w izolacji . W zależności od potrzeb możesz także grać metodami statycznymi i atrybutami.

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)

Można skorzystać z tej metody, używając również klas jako kluczy tabeli „__choice_table”. W ten sposób można uniknąć nadużyć związanych z instancją i zachować wszystko w czystości i przetestować.

Załóżmy, że musisz przetworzyć wiele wiadomości lub pakietów z sieci lub Twojego MQ. Każdy pakiet ma własną strukturę i kod zarządzania (w sposób ogólny). Z powyższym kodem można zrobić coś takiego:

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)

Tak więc złożoność nie rozkłada się w przepływie kodu, ale jest renderowana w strukturze kodu .

Rozwijanie odpowiedzi Grega Hewgilla - Możemy zamknąć słownik-rozwiązanie za pomocą dekoratora:

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

Może to być następnie użyte z @case-decoratorem

@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

Dobrą wiadomością jest to, że zostało to już zrobione w module NeoPySwitch. Po prostu zainstaluj za pomocą pip:

pip install NeoPySwitch

Rozwiązaniem, z którego zwykle korzystam i które korzysta również ze słowników, jest:

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

Ma to tę zaletę, że nie próbuje za każdym razem oceniać funkcji, a Ty musisz tylko upewnić się, że funkcja zewnętrzna otrzymuje wszystkie informacje, których potrzebują funkcje wewnętrzne.

Do tej pory pojawiło się wiele odpowiedzi, które mówiły: „nie mamy przełącznika w Pythonie, zrób to w ten sposób”. Chciałbym jednak zauważyć, że sama instrukcja switch jest konstrukcją łatwą do nadużywania, której można i należy w większości przypadków unikać, ponieważ promują leniwe programowanie. Przykładem:

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

Teraz możesz to zrobić za pomocą instrukcji switch (jeśli Python ją oferuje), ale marnowałbyś swój czas, ponieważ istnieją metody, które robią to dobrze. A może masz coś mniej oczywistego:

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

Jednak tego rodzaju operacje można i należy obsługiwać za pomocą słownika, ponieważ będzie on szybszy, mniej złożony, mniej podatny na błędy i bardziej zwarty.

Zdecydowana większość „przypadków użycia” instrukcji zamiany przypada na jeden z tych dwóch przypadków; jest tylko bardzo mały powód, aby go użyć, jeśli dokładnie przemyślałeś swój problem.

Więc zamiast pytać „jak przełączyć się w Pythonie?”, Być może powinniśmy zapytać: „dlaczego chcę przełączyć się w Pythonie?”. ponieważ jest to często bardziej interesujące pytanie i często ujawnia wady w projektowaniu wszystkiego, co budujesz.

Nie oznacza to, że przełączników nigdy nie należy używać. Maszyny stanowe, leksery, parsery i automaty używają ich do pewnego stopnia i, ogólnie rzecz biorąc, kiedy zaczynasz od symetrycznego wejścia i przechodzisz do asymetrycznego wyjścia, mogą być przydatne; musisz tylko upewnić się, że nie używasz przełącznika jako młotka, ponieważ w kodzie widzisz gwoździe.