How-to

Tutorial: So implementiert man ein Switch-Case Statement in Python
Keine Kommentare

Switch-Case Statements sind ein mächtiges Kontrollwerkzeug in der Programmierung. In diesem Tutorial bietet Sreeram Sreenivasan eine Anleitung zur Verwendung von Switch-Case Statements in Python.

Das Switch-Case Statement ist ein mächtiges Programmierfeature, das anhand des Werts einer Variablen oder eines Ausdrucks erlaubt, den Ablauf des Programms zu kontrollieren. Man kann es dazu verwenden, in Abhängigkeit von einem Variablenwert zur Laufzeit verschiedene Codeblöcke auszuführen. Hier ist ein Beispiel eines Switch Statements in Java:

public static void switch_demo(String[] args) {
 
        int month = 8;
        String monthString;
        switch (month) {
            case 1:  monthString = "January";
                     break;
            case 2:  monthString = "February";
                     break;
            case 3:  monthString = "March";
                     break;
            case 4:  monthString = "April";
                     break;
            case 5:  monthString = "May";
                     break;
            case 6:  monthString = "June";
                     break;
            case 7:  monthString = "July";
                     break;
            case 8:  monthString = "August";
                     break;
            case 9:  monthString = "September";
                     break;
            case 10: monthString = "October";
                     break;
            case 11: monthString = "November";
                     break;
            case 12: monthString = "December";
                     break;
            default: monthString = "Invalid month";
                     break;
        }
        System.out.println(monthString);
}

Und so funktioniert das Switch-Case Statement:

  1. Der Compiler generiert eine Sprungtabelle für das Switch-Case Statement.
  2. Switch-Variable oder -Ausdruck wird einmal evaluiert.
  3. Das Switch Statement schlägt die evaluierte Variable bzw. den Ausdruck in der Sprungtabelle nach und entscheidet direkt, welcher Codeblock ausgeführt werden soll.
  4. Wenn keine Übereinstimmung gefunden wird, wird der Code unter dem Default Case ausgeführt.

Im obigen Beispiel wird in Abhängigkeit vom Variablenwert month eine entsprechende  Nachricht angezeigt. In diesem Fall, month = 8, wird August im ausgegeben.

Switch Statements

Obwohl beliebte Sprachen wie Java oder PHP Switch Statements als eingebautes Feature besitzen, ist es überraschenderweise bei Python nicht so. Daher könnte man der Versuchung erliegen, eine Serie von If-Else-Blöcken zu erstellen und eine If-Bedingung für jeden Fall des Switch Statements festzulegen.

Allerdings wird aufgrund der Sprungtabelle ein Switch Statement viel schneller sein als eine If-Else-If-Leiter. Anstatt jede Bedingung sequenziell zu evaluieren, muss in einer Sprungtabelle jede evaluierte Variable bzw. jeder evaluierte Ausdruck nur einmal nachgeschlagen werden. Dann erfolgt der direkte Sprung zum entsprechenden Codezweig, um ihn auszuführen.

Lesen Sie auch: Eine Einführung in Python – das Tutorial

Switch Statements in Python implementieren

Die Python-Art, Switch Statements zu implementieren, ist das Verwenden der mächtigen Dictionary Mappings, auch bekannt als Associative Arrays. Sie bieten einfache one-to-one Key-Value Mappings.

Der untere Code zeigt die Python-Implementierung des obigen Switch Statements. Im folgenden Beispiel erstellen wir ein Dictionary mit dem Namen switcher, um alle Switch-artigen Fälle zu speichern.

def switch_demo(argument):
    switcher = {
        1: "January",
        2: "February",
        3: "March",
        4: "April",
        5: "May",
        6: "June",
        7: "July",
        8: "August",
        9: "September",
        10: "October",
        11: "November",
        12: "December"
    }
    print switcher.get(argument, "Invalid month")

Im obigen Beispiel wird ein Argument gegen das Dictionary Mapping switcher geprüft, wenn man es an die switch_demo-Funktion übergibt. Wird ein Match gefunden, wird der assoziierte Wert ausgegeben. Ansonsten erfolgt die Ausgabe eines Default Strings (“Invalid Month”).

Dictionary Mapping für Funktionen

Jetzt wird es spannend. Die Werte des Python Dictionary können jeglichem Datentypus angehören. Man muss sich daher nicht auf Konstanten beschränken (Integer, Strings), sondern man kann auch Funktionsnamen und Lambdas als Werte verwenden.

Zum Beispiel kann man das obige Switch Statement auch implementieren, indem man ein Dictionary mit Funktionsnamen als Werte erstellt. In diesem Fall ist switcher ein Dictionary aus Funktionsnamen, und nicht aus Strings.

def one():
    return "January"
 
def two():
    return "February"
 
def three():
    return "March"
 
def four():
    return "April"
 
def five():
    return "May"
 
def six():
    return "June"
 
def seven():
    return "July"
 
def eight():
    return "August"
 
def nine():
    return "September"
 
def ten():
    return "October"
 
def eleven():
    return "November"
 
def twelve():
    return "December"
 
 
def numbers_to_months(argument):
    switcher = {
        1: one,
        2: two,
        3: three,
        4: four,
        5: five,
        6: six,
        7: seven,
        8: eight,
        9: nine,
        10: ten,
        11: eleven,
        12: twelve
    }
    # Get the function from switcher dictionary
    func = switcher.get(argument, lambda: "Invalid month")
    # Execute the function
    print func()

Obwohl die obigen Funktionen recht simpel sind und nur Strings ausgeben, kann man diesen Ansatz verwenden, um umfangreiche Codeblöcke innerhalb jeder Funktion auszuführen.

Wenn man Methoden auf Objekten aufruft, kann man sogar eine Dispatch-Methode verwenden, um dynamisch zu definieren, welche Funktion während der Laufzeit aufgerufen werden soll.

class Switcher(object):
    def numbers_to_months(self, argument):
        """Dispatch method"""
        method_name = 'month_' + str(argument)
        # Get the method from 'self'. Default to a lambda.
        method = getattr(self, method_name, lambda: "Invalid month")
        # Call the method as we return it
        return method()
 
    def month_1(self):
        return "January"
 
    def month_2(self):
        return "February"
 
    def month_3(self):
        return "March"
 
...

Auf dem weitergegebenen Argument basierend wird die eingebaute getattr()-Funktion Objektmethoden mit dem spezifischen Namen aufrufen.

Vorteil der Python-Herangehensweise

Da Python-Dictionaries während der Laufzeit verändert werden können (Hinzufügen, Entfernen oder Aktualisieren von Key-Value-Paaren), kann das Switch Statement einfach und schnell geändert werden. Hier ist ein Beispiel dafür:

def zero():
    return "zero"
 
def one():
    return "one"
 
def two():
    return "two"
 
switcher = {
        0: zero,
        1: one,
        2: two
    }
 
 
def numbers_to_strings(argument):
    # Get the function from switcher dictionary
    func = switcher.get(argument, "nothing")
    # Execute the function
    return func()
 
Input: numbers_to_strings(1)
Output: One
 
Input: switcher[1]=two #changing the switch case
Input: numbers_to_strings(1)
Output: Two

Switch-Case ist ein sehr hilfreiches Programmierkonstrukt, das nicht nur bessere Performance als If-Else-Statements liefert, sondern auch einen besser verwaltbaren Code ermöglicht. Wenn ihr euch durch das Fehlen von Switch Statements in Python eingeschränkt gefühlt habt, dann wird euch das obige Tutorial hoffentlich bei der Implementierung behilflich sein können.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Hinterlasse einen Kommentar

Hinterlasse den ersten Kommentar!

avatar
400
  Subscribe  
Benachrichtige mich zu:
X
- Gib Deinen Standort ein -
- or -