Ersetzungen für die switch-Anweisung in Python?

Ich möchte eine Funktion in Python schreiben, die verschiedene feste Werte basierend auf dem Wert eines Eingabeindex zurückgibt.

In anderen Sprachen würde ich eine switchoder case-Anweisung verwenden, aber Python scheint keine switchAnweisung zu haben . Was sind die empfohlenen Python-Lösungen in diesem Szenario?

Sie könnten ein Wörterbuch verwenden:

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

Wenn Sie Standardeinstellungen wünschen, können Sie die Wörterbuchmethode get(key[, default])verwenden:

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

Ich habe es immer so gemacht

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

Von hier

Zusätzlich zu den Wörterbuchmethoden (die mir übrigens sehr gut gefallen) können Sie auch if- elif- verwenden else, um die switch/ case/ default-Funktionalität zu erhalten:

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

Dies ist natürlich nicht identisch mit switch / case - Sie können nicht so leicht durchfallen wie das Weglassen der breakAnweisung, aber Sie können einen komplizierteren Test durchführen. Die Formatierung ist besser als bei einer Reihe verschachtelter ifs, obwohl dies funktional eher der Fall ist.

Mein Lieblingsrezept für Python für Schalter / Fall ist:

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

Kurz und einfach für einfache Szenarien.

Vergleichen Sie mit mehr als 11 Zeilen C-Code:

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

Sie können sogar mehrere Variablen mithilfe von Tupeln zuweisen:

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

Verwendungszweck:

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

Tests:

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

Mein Lieblingsrezept ist ein wirklich schönes Rezept . Du wirst es wirklich mögen. Es ist das, was ich den tatsächlichen Switch-Case-Anweisungen am nächsten gesehen habe, insbesondere in Bezug auf Funktionen.

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

Hier ist ein Beispiel:

# 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

Es gibt ein Muster, das ich aus Twisted Python-Code gelernt habe.

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'

Sie können es jederzeit verwenden, wenn Sie ein Token versenden und erweiterten Code ausführen müssen. In einer Zustandsmaschine hätten Sie state_Methoden und würden versenden self.state. Dieser Schalter kann sauber erweitert werden, indem Sie von der Basisklasse erben und Ihre eigenen do_Methoden definieren. Oft haben Sie nicht einmal do_Methoden in der Basisklasse.

Bearbeiten: wie genau wird das verwendet

Im Falle von SMTP erhalten Sie HELOvon der Leitung. Der relevante Code (von twisted/mail/smtp.py, geändert für unseren Fall) sieht folgendermaßen aus

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

Sie erhalten ' HELO foo.bar.com '(oder Sie erhalten 'QUIT'oder 'RCPT TO: foo'). Dies wird in partsas tokenisiert ['HELO', 'foo.bar.com']. Der tatsächliche Name der Methodensuche wird übernommen parts[0].

(Die ursprüngliche Methode wird auch aufgerufen state_COMMAND, da sie dasselbe Muster zum Implementieren einer Zustandsmaschine verwendet, dh getattr(self, 'state_' + self.mode))

Angenommen, Sie möchten nicht nur einen Wert zurückgeben, sondern Methoden verwenden, die etwas an einem Objekt ändern. Die Verwendung des hier angegebenen Ansatzes wäre:

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

Was hier passiert ist, dass Python alle Methoden im Wörterbuch auswertet. Selbst wenn Ihr Wert 'a' ist, wird das Objekt um x inkrementiert und dekrementiert.

Lösung:

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

result = func(*args)

Sie erhalten also eine Liste mit einer Funktion und ihren Argumenten. Auf diese Weise werden nur der Funktionszeiger und die Argumentliste zurückgegeben und nicht ausgewertet. 'result' wertet dann den zurückgegebenen Funktionsaufruf aus.

Ich werde nur meine zwei Cent hier reinwerfen. Der Grund, warum es in Python keine case / switch-Anweisung gibt, ist, dass Python dem Prinzip "Es gibt nur einen richtigen Weg, etwas zu tun" folgt. Natürlich könnten Sie verschiedene Möglichkeiten finden, um die Switch / Case-Funktionalität wiederherzustellen, aber die pythonische Methode, um dies zu erreichen, ist das if / elif-Konstrukt. dh

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

Ich hatte gerade das Gefühl, dass PEP 8 hier ein Nicken verdient hat. Eines der schönen Dinge an Python ist seine Einfachheit und Eleganz. Dies ist größtenteils auf die in PEP 8 festgelegten Grundsätze zurückzuführen, darunter "Es gibt nur einen richtigen Weg, etwas zu tun".

Erweiterung der Idee "Diktieren als Schalter". Wenn Sie einen Standardwert für Ihren Switch verwenden möchten:

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

Wenn Sie einen komplizierten Fallblock haben, können Sie eine Nachschlagetabelle für Funktionswörterbücher verwenden ...

Wenn Sie dies noch nicht getan haben, empfiehlt es sich, in Ihren Debugger einzusteigen und genau anzuzeigen, wie das Wörterbuch die einzelnen Funktionen nachschlägt.

HINWEIS: Verwenden Sie nicht "()" in der Fall- / Wörterbuchsuche, da sonst jede Ihrer Funktionen aufgerufen wird, wenn der Wörterbuch- / Fallblock erstellt wird. Denken Sie daran, da Sie jede Funktion nur einmal mit einer Hash-Suche aufrufen möchten.

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

Wenn Sie nach einer zusätzlichen Anweisung als "Schalter" suchen, habe ich ein Python-Modul erstellt, das Python erweitert. Es heißt ESPY als "Enhanced Structure for Python" und ist sowohl für Python 2.x als auch für Python 3.x verfügbar.

In diesem Fall könnte eine switch-Anweisung beispielsweise mit dem folgenden Code ausgeführt werden:

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

das kann so verwendet werden:

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

so espy übersetzen Sie es in Python als:

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

Ich fand, dass eine gemeinsame Schalterstruktur:

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

kann in Python wie folgt ausgedrückt werden:

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

oder klarer formatiert:

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

Anstatt eine Anweisung zu sein, ist die Python-Version ein Ausdruck, der einen Wert ergibt.

Die meisten Antworten hier sind ziemlich alt und besonders die akzeptierten, daher scheint es eine Aktualisierung wert zu sein.

Zunächst wird dies in den offiziellen Python-FAQ behandelt und die elifKette für einfache Fälle und die dictfür größere oder komplexere Fälle empfohlen . In visit_einigen Fällen wird auch eine Reihe von Methoden vorgeschlagen (ein Stil, der von vielen Server-Frameworks verwendet wird):

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

In den häufig gestellten Fragen wird auch PEP 275 erwähnt , das geschrieben wurde, um eine endgültige endgültige Entscheidung über das Hinzufügen von Switch-Anweisungen im C-Stil zu erhalten. Dieses PEP wurde jedoch tatsächlich auf Python 3 verschoben und nur als separater Vorschlag, PEP 3103, offiziell abgelehnt . Die Antwort war natürlich nein - aber die beiden PEPs haben Links zu zusätzlichen Informationen, wenn Sie an den Gründen oder der Geschichte interessiert sind.

Eine Sache, die mehrmals auftauchte (und in PEP 275 zu sehen ist, obwohl sie als tatsächliche Empfehlung herausgeschnitten wurde), ist, dass Sie wirklich die Mühe haben, 8 Codezeilen für 4 Fälle zu haben, im Vergleich zu den 6 Zeilen, die Sie in C oder Bash haben würden, können Sie immer schreiben:

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

Dies wird von PEP 8 nicht gerade unterstützt, ist aber lesbar und nicht zu unidiomatisch.

In den mehr als einem Jahrzehnt seit der Ablehnung von PEP 3103 wurde das Problem der C-artigen Fallaussagen oder sogar der etwas leistungsfähigeren Version in Go als tot angesehen. Immer wenn jemand Python-Ideen oder -dev anspricht, wird er auf die alte Entscheidung verwiesen.

Die Idee eines vollständigen Mustervergleichs im ML-Stil entsteht jedoch alle paar Jahre, zumal Sprachen wie Swift und Rust ihn übernommen haben. Das Problem ist, dass es ohne algebraische Datentypen schwierig ist, den Mustervergleich optimal zu nutzen. Während Guido mit der Idee einverstanden war, hat niemand einen Vorschlag gemacht, der sehr gut in Python passt. (Sie können meinen Strohmann von 2014 als Beispiel lesen .) Dies könnte sich mit dataclassin 3.7 und einigen sporadischen Vorschlägen für eine leistungsfähigere enumHandhabung von Summentypen oder mit verschiedenen Vorschlägen für verschiedene Arten von aussagelokalen Bindungen (wie PEP 3150 oder die Reihe von Vorschlägen, die derzeit auf -ideas diskutiert werden). Aber bisher hat es nicht.

Gelegentlich gibt es auch Vorschläge für ein Perl 6-Matching, das im Grunde genommen eine Mischung aus allem ist, von elifRegex bis hin zu Single-Dispatch-Typ-Switching.

Lösung zum Ausführen von Funktionen:

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

Dabei sind foo1 (), foo2 (), foo3 () und default () Funktionen

Ich habe die einfache Antwort, nach der ich gesucht habe, in der Google-Suche nicht gefunden. Aber ich habe es trotzdem herausgefunden. Es ist wirklich ganz einfach. Beschlossen, es zu posten und vielleicht ein paar weniger Kratzer auf dem Kopf eines anderen zu verhindern. Der Schlüssel ist einfach "in" und Tupel. Hier ist das Verhalten der switch-Anweisung mit Fall-Through, einschließlich RANDOM-Fall-Through.

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)

Bietet:

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.

Die Lösungen, die ich benutze:

Eine Kombination aus zwei der hier veröffentlichten Lösungen, die relativ einfach zu lesen ist und Standardeinstellungen unterstützt.

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

wo

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

schaut "lambda x: x - 2"im Diktat nach und benutzt es mitx=23

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

findet es nicht im Diktat und verwendet die Standardeinstellung "lambda x: x - 22"mit 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

Ich mochte Mark Bies 'Antwort

Da die xVariable zweimal verwendet werden muss, habe ich die Lambda-Funktionen auf parameterlos geändert.

Ich muss mit rennen 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'

Bearbeiten: Mir ist aufgefallen, dass ich Nonemit Wörterbüchern schreiben kann. Das würde also nachahmenswitch ; case else

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

Kurz und einfach zu lesen, hat einen Standardwert und unterstützt Ausdrücke sowohl in Bedingungen als auch in Rückgabewerten.

Es ist jedoch weniger effizient als die Lösung mit einem Wörterbuch. Beispielsweise muss Python alle Bedingungen durchsuchen, bevor der Standardwert zurückgegeben wird.

Sie können ein versendetes Diktat verwenden:

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

Ausgabe:

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

Einfach, nicht getestet; Jede Bedingung wird unabhängig ausgewertet: Es gibt keinen Durchfall, aber alle Fälle werden ausgewertet (obwohl der einzuschaltende Ausdruck nur einmal ausgewertet wird), es sei denn, es gibt eine break-Anweisung. Zum Beispiel,

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

Drucke Was 1. Was 1 or 2. Was something. ^{(Verdammt! Warum kann ich in Inline-Codeblöcken kein nachfolgendes Leerzeichen haben?),} wenn expressionausgewertet wird 1, Was 2.wenn expressionausgewertet 2wird oder Was something.wenn expressionausgewertet wird.

Definieren:

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

ermöglicht es Ihnen, eine ziemlich einfache Syntax zu verwenden, wobei die Fälle in einer Karte gebündelt sind:

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

Ich versuchte immer wieder, den Schalter so neu zu definieren, dass ich das "Lambda:" loswerden konnte, gab aber auf. Definition optimieren:

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

Erlaubte mir, mehrere Fälle demselben Code zuzuordnen und eine Standardoption anzugeben:

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

Jeder replizierte Fall muss sich in einem eigenen Wörterbuch befinden. switch () konsolidiert die Wörterbücher, bevor der Wert nachgeschlagen wird. Es ist immer noch hässlicher als ich es gerne hätte, aber es hat die grundlegende Effizienz, eine Hash-Suche für den Ausdruck zu verwenden, anstatt eine Schleife durch alle Schlüssel.

Ich denke, der beste Weg ist, die Python-Sprachsprache zu verwenden, um Ihren Code testbar zu halten . Wie in früheren Antworten gezeigt, verwende ich Wörterbücher, um Python-Strukturen und -Sprache zu nutzen und den "Fall" -Code auf verschiedene Arten isoliert zu halten. Unten gibt es eine Klasse, aber Sie können direkt ein Modul, Globals und Funktionen verwenden. Die Klasse verfügt über Methoden, die isoliert getestet werden können . Abhängig von Ihren Anforderungen können Sie auch mit statischen Methoden und Attributen spielen.

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)

Es ist möglich, diese Methode zu nutzen, indem auch Klassen als Schlüssel von "__choice_table" verwendet werden. Auf diese Weise können Sie den Missbrauch von Instanzen vermeiden und alles sauber und testbar halten.

Angenommen, Sie müssen viele Nachrichten oder Pakete aus dem Netz oder Ihrem MQ verarbeiten. Jedes Paket hat seine eigene Struktur und seinen Verwaltungscode (generisch). Mit dem obigen Code ist es möglich, Folgendes zu tun:

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)

Die Komplexität verteilt sich also nicht auf den Codefluss, sondern wird in der Codestruktur gerendert .

Erweiterung der Antwort von Greg Hewgill - Wir können die Wörterbuchlösung mit einem Dekorateur kapseln:

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

Dies kann dann mit dem @case-decorator verwendet werden

@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

Die gute Nachricht ist, dass dies bereits im NeoPySwitch- Modul geschehen ist . Einfach mit pip installieren:

pip install NeoPySwitch

Eine Lösung, die ich tendenziell benutze und die auch Wörterbücher verwendet, ist:

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

Dies hat den Vorteil, dass nicht jedes Mal versucht wird, die Funktionen zu bewerten, und Sie müssen nur sicherstellen, dass die äußere Funktion alle Informationen erhält, die die inneren Funktionen benötigen.

Bisher gab es viele Antworten, die besagten: "Wir haben keinen Schalter in Python, machen Sie es so." Ich möchte jedoch darauf hinweisen, dass die switch-Anweisung selbst ein leicht zu missbrauchendes Konstrukt ist, das in den meisten Fällen vermieden werden kann und sollte, da sie eine verzögerte Programmierung fördert. Ein typisches Beispiel:

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

Jetzt könnten Sie dies mit einer switch-Anweisung tun (wenn Python eine anbietet), aber Sie würden Ihre Zeit verschwenden, weil es Methoden gibt, die dies gut tun. Oder vielleicht haben Sie etwas weniger Offensichtliches:

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

Diese Art von Vorgang kann und sollte jedoch mit einem Wörterbuch ausgeführt werden, da es schneller, weniger komplex, weniger fehleranfällig und kompakter ist.

Und die überwiegende Mehrheit der "Anwendungsfälle" für switch-Anweisungen fällt in einen dieser beiden Fälle. Es gibt nur einen sehr geringen Grund, einen zu verwenden, wenn Sie gründlich über Ihr Problem nachgedacht haben.

Anstatt zu fragen, wie ich in Python wechseln soll, sollten wir uns vielleicht fragen, warum ich in Python wechseln möchte. weil das oft die interessantere Frage ist und oft Fehler in der Gestaltung von allem aufdeckt, was Sie bauen.

Das heißt nicht, dass Schalter auch niemals verwendet werden sollten. Zustandsautomaten, Lexer, Parser und Automaten verwenden sie bis zu einem gewissen Grad. Wenn Sie von einer symmetrischen Eingabe ausgehen und zu einer asymmetrischen Ausgabe wechseln, können sie im Allgemeinen nützlich sein. Sie müssen nur sicherstellen, dass Sie den Schalter nicht als Hammer verwenden, da Sie in Ihrem Code ein paar Nägel sehen.