So implementieren Sie die Switch/Case-Anweisung in Python

In diesem Artikel geht es um die Methode zur Implementierung von Switch/Case-Anweisungen in Python. Ich hoffe, dass er für Freunde hilfreich ist.

Es gibt keine Switch/Case-Anweisung in Python. Viele Leute denken, dass diese Anweisung nicht elegant und flexibel genug ist. Es ist einfacher und effizienter, ein Wörterbuch zu verwenden, um Probleme mit der Zuordnung mehrerer Bedingungen in Python zu lösen. Für diejenigen, die etwas Erfahrung mit Python haben, müssen Spieler zugeben, dass dies tatsächlich der Fall ist.

Aber heute werfen wir einen Blick darauf, wie man Switch/Case spielt, wenn wir Python verwenden müssen.

Syntaxeinschränkungen

Definieren wir zunächst, wie Switch/Case ausgedrückt werden soll. Der Einfachheit halber können wir es so gestalten.

def cn():
    print('cn')

def us():
    print('us')

switch(lang).case('cn',cn)
            .case('us',us)
               .default(us)

Klassenimplementierung eins

Durch die oben genannten Einschränkungen können wir den Schalter als Klasse implementieren. Die eingehenden Parameter werden im Konstruktor verarbeitet und dann werden die Fall- und Standardmethoden implementiert.

class switch(object):
    def __init__(self, case_path):
        self.switch_to = case_path
        self._invoked = False

    def case(self, key, method):
        if self.switch_to == key and not self._invoked:
            self._invoked = True
            method()

        return self

    def default(self, method):
        if not self._invoked:
            self._invoked = True
            method()

Im Konstruktor merken wir uns case_path und den Ausführungsstatus _invoked, wenn in case() die aktuellen key und switch_to übereinstimmen und die Funktion nicht ausgeführt wurde, dann aktualisieren wir _invoked und führen Sie die entsprechende Methode aus. Aktivieren Sie default() in _invoked. Wenn es noch nie ausgeführt wurde, rufen Sie die Funktion des Zweigs default auf.

Sieht gut aus, probieren wir es aus.

switch('cn').case('cn',cn).case('us',us).default(fail)
>>> cn
switch('us').case('cn',cn).case('us',us).default(fail)
>>> cn
switch('jp').case('cn',cn).case('us',us).default(fail)
>>> fail
switch('cn').case('cn',cn).case('us',us)
>>> cn

Werfen wir einen Blick auf ein paar seltsame Fälle.

# duplicate case
switch('us').case('us',cn).case('us',us).default(fail)
>>> cn

def cn() return 'cn'
def us() return 'us'

# return value
result = switch('cn').case('cn',cn).case('us',us)
result
>>> <python_switch_case.switch object at 0x11034fb70>

Ist Ihnen aufgefallen, dass die obige Implementierung keine wiederholten Fälle verarbeiten kann? Natürlich können Sie die Fallmethode verstärken, vorzugsweise durch Auslösen einer Ausnahme. Dies geschieht normalerweise in anderen Programmiersprachen.

Die zweite Frage ist, ob Sie den Rückgabewert aus dem Fall erhalten möchten. Es ist aussichtslos, ihn wie oben beschrieben zu schreiben, weil er weggeworfen wird. Wir können erwägen, der Switch-Klasse eine Ergebnisvariable hinzuzufügen, um die Ausführungsergebnisse zu speichern.

class switch(object):
    def __init__(self, case_path):
        ...
        self.result = None

    def case(self, key, method):
        ...
        self.result = method()
    ...

Nachdem der Anruf abgeschlossen ist, können Sie das Ergebnis über result erhalten.

_ = switch('cn').case('cn',cn).case('us',us)
_.result
>>> cn

Klassenimplementierung 2

Ich habe wahrscheinlich im Internet gesucht. Sie können sich auch an Brian Beck wenden, um Swich/Case über Klassen zu implementieren.

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:
            self.fall = True
            return True
        else:
            return False


c = 'z'
for case in switch(c):
    if case('a'): pass  # only necessary if the rest of the suite is empty
    if case('c'): 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!")

Diese Art der Implementierung ist relativ kompliziert und nicht sehr komfortabel zu verwenden. Sie erfordert sowohl for als auch if (sie ist nicht so glücklich wie direktes if/else). Natürlich gibt es auch Vorteile, das heißt, Fälle mit den gleichen Ergebnissen können zusammengestellt werden und es können mehr Dinge in den Fall geschrieben werden, nicht nur ein Methodenname.

Am Ende geschrieben

Abschließend kehren wir zu der von Python empfohlenen Methode zurück, um das Schalter-/Fallproblem zu lösen. Im Allgemeinen können wir dieses Problem mit mehreren Zweigen mithilfe eines Wörterbuchs lösen. als Beispiel.

MAPPING = {
    'cn': cn,
    'us': us
}

lang = 'cn'
result = MAPPING.get(lang, default=us)

Ist es auf einen Blick klar, leicht zu lesen und leicht zu pflegen? Der Schlüssel ist im Wörterbuch eindeutig und der Wert kann ein beliebiger Datentyp sein, entweder eine Klasse oder eine Methode, sodass er flexibel genug ist.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Switch/Case-Anweisung in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!