Python Language
Alternativen zum Wechseln von Anweisungen aus anderen Sprachen

Bemerkungen

Verwenden Sie das, was die Sprache bietet: das if / else-Konstrukt.

Wenn Sie ein switch / case Konstrukt verwenden möchten, ist es am einfachsten, das gute alte if / else Konstrukt zu verwenden:

def switch(value):
    if value == 1:
        return "one"
    if value == 2:
        return "two"
    if value == 42:
        return "the answer to the question about life, the universe and everything"
    raise Exception("No case found!")

Es mag überflüssig und nicht immer hübsch aussehen, aber das ist bei weitem der effizienteste Weg, und es erledigt die Aufgabe:

>>> switch(1)
one
>>> switch(2)
two
>>> switch(3)
…
Exception: No case found!
>>> switch(42)
the answer to the question about life the universe and everything

Benutze ein Diktat von Funktionen

Ein weiterer unkomplizierter Weg ist das Erstellen eines Funktionswörterbuchs:

switch = {
    1: lambda: 'one',
    2: lambda: 'two',
    42: lambda: 'the answer of life the universe and everything',
}

dann fügen Sie eine Standardfunktion hinzu:

def default_case():
    raise Exception('No case found!')

und Sie verwenden die Get-Methode des Wörterbuchs, um die Funktion mit dem Wert zu überprüfen und auszuführen. Wenn im Wörterbuch kein Wert vorhanden ist, wird default_case ausgeführt.

>>> switch.get(1, default_case)()
one
>>> switch.get(2, default_case)()
two
>>> switch.get(3, default_case)()
…
Exception: No case found!
>>> switch.get(42, default_case)()
the answer of life the universe and everything

Sie können auch etwas syntaktischen Zucker herstellen, damit der Schalter schöner aussieht:

def run_switch(value):
    return switch.get(value, default_case)()

>>> run_switch(1)
one

Verwenden Sie die Klassenprüfung

Sie können eine Klasse verwenden, um die Switch- / Case-Struktur nachzuahmen. Im Folgenden wird die Introspektion einer Klasse verwendet (mit der Funktion getattr() , die eine Zeichenfolge in eine gebundene Methode einer Instanz auflöst), um den "case" getattr() aufzulösen.

Dann wird diese Introspecting-Methode auf die __call__ Methode gesetzt, um den Operator () zu überladen.

class SwitchBase:
    def switch(self, case):
        m = getattr(self, 'case_{}'.format(case), None)
        if not m:
            return self.default
        return m

    __call__ = switch

Damit es noch schöner aussieht, subclassieren wir die SwitchBase Klasse (dies könnte jedoch in einer Klasse geschehen), und definieren den gesamten case als Methoden:

class CustomSwitcher:
    def case_1(self):
        return 'one'

    def case_2(self):
        return 'two'

    def case_42(self):
        return 'the answer of life, the universe and everything!'

    def default(self):
        raise Exception('Not a case!')

so können wir es endlich benutzen:

>>> switch = CustomSwitcher()
>>> print(switch(1))
one
>>> print(switch(2))
two
>>> print(switch(3))
…
Exception: Not a case!
>>> print(switch(42))
the answer of life, the universe and everything!

Verwenden eines Kontextmanagers

Eine andere Art, die sehr lesbar und elegant ist, aber weit weniger effizient als eine if / else-Struktur ist, besteht darin, eine Klasse wie folgt zu erstellen, die den zu vergleichenden Wert liest und speichert, um sich im Kontext als aufrufbar darzustellen gibt true zurück, wenn er mit dem gespeicherten Wert übereinstimmt:

class Switch:
    def __init__(self, value): 
        self._val = value
    def __enter__(self):
        return self
    def __exit__(self, type, value, traceback):
        return False # Allows traceback to occur
    def __call__(self, cond, *mconds): 
        return self._val in (cond,)+mconds

dann ist das Definieren der Fälle fast eine Übereinstimmung mit dem realen switch / case Konstrukt (innerhalb einer Funktion sichtbar gemacht, um die Darstellung zu erleichtern):

def run_switch(value):
    with Switch(value) as case:
        if case(1):
            return 'one'
        if case(2):
            return 'two'
        if case(3):
            return 'the answer to the question about life, the universe and everything'
        # default
        raise Exception('Not a case!')

Die Ausführung wäre also:

>>> run_switch(1)
one
>>> run_switch(2)
two
>>> run_switch(3)
…
Exception: Not a case!
>>> run_switch(42)
the answer to the question about life, the universe and everything

Nota Bene :

• Diese Lösung wird als das auf pypi verfügbare Switch- Modul angeboten .