Python Switch-Case: So funktioniert es in Python

Manchmal muss anhand des Wertes eines Objektes eine andere Aktion durchgeführt werden, wofür es in anderen Programmiersprachen wie z.B. C++ das switch Statement gibt. Hier zeige ich dir verschiedene Wege, wie du dieses Verhalten in Python simulieren kannst.

Wie funktioniert switch-case?

Im folgenden Beispiel siehst du einen switch-case-Block in C++, welcher Anhand einer Ziffer von 1-3 den Namen dieser ausgibt und wenn der Wert außerhalb liegt, den Text „Zahl muss zwischen 0 und 3 sein!“ ausgibt.

switch-case in C++

switch (n) {
    case 1:
        std::cout << "Eins";
        break;
    case 2:
        std::cout << "Zwei";
        break;
    case 3:
        std::cout << "Drei";
        break;
    default:
        std::cout << "Zahl muss zwischen 0 und 3 sein!";
}

In Python Switch-Case Verhalten mit Dictionary simulieren

Da es in Python kein switch Statement gibt, müssen wir uns anderer Strategien bedienen. Eine davon ist ein Dictionary zu verwenden, wie hier gezeigt.
Vereinfachte Switch-Case Funktionalität mit Dictionary:

switch_mit_dictionary = {
    0: 'Null',
    1: 'Eins',
    2: 'Zwei',
    3: 'Drei'
}
zahl = int(input("Geben Sie eine Zahl ein: "))
print(switch_mit_dictionary.get(zahl, 'Zahl muss zwischen 0 und 3 sein!'))

Output mit 21 und 2:

> Geben Sie eine Zahl ein: 21
> Zahl muss zwischen 0 und 3 sein!
> Geben Sie eine Zahl ein: 2
> Zwei

Mit if, elif, else ähnliches Verhalten abbilden

Auch mit den Schlagwörtern if, elif und else können wir dasselbe Ergebnis erzielen.

def switch_mit_if(zahl):
    if zahl == 0:
        return 'Null'
    elif zahl == 1:
        return 'Eins'
    elif zahl == 2:
        return 'Zwei'
    elif zahl == 3:
        return 'Drei'
    else:
        return 'Zahl muss zwischen 0 und 3 sein!'
zahl = int(input("Geben Sie eine Zahl ein: "))
print(switch_mit_if(zahl))

Eine eigene Python Switch-Case-Klasse:

Das Verhalten von Switch-Case kann mit einer eigenen Klasse noch präziser abgebildet werden. In diesem Beispiel ist eine Klasse beschrieben, die mehrere Kombinationen verwaltet.
Diese Kombinationen bestehen aus dem möglichem Wert, der Callback-Funktion und einem optionalen Parameter, der angibt ob nach diesem Callback weitere Callbacks durchlaufen werden sollen.

class Switch(object):
    def __init__(self):
        # Alle möglichen Fälle werden hier festgehalten
        self.cases = []
        # speichert, ob ein Fall eingetreten ist
        self.case_matched = False

    def add_case(self, value, callback, breaks=True):
        # Fügt Fall an das Ende der internen Liste self.cases
        self.cases.append({
            "value": value,
            "callback": callback,
            "breaks": breaks
        })
    
    def case(self, value):
        # Speichert die Zwischenergebnisse        
        results = []
        for case in self.cases:
            # überprüft ob bereits ein voriger Fall eingetroffen ist
            # oder der aktuelle Fall eintrifft
            if self.case_matched == True or value == case["value"]:
                self.case_matched = True
                # Ergebnis des Callbacks für den aktuellen Fall wird
                # gespeichert
                results.append(case["callback"]())
                # falls breaks für den aktuellen Fall auf True
                # gesetzt wurde, endet die Schleife
                if case["breaks"]:
                    break
        self.case_matched = False
        return results

switch = Switch()
case_1 = lambda : "Eins"
case_2 = lambda : "Zwei"
case_3 = lambda : "Drei"
switch.add_case(1, case_1, False)
switch.add_case(2, case_2, False)
switch.add_case(3, case_3, False)

print(switch.case(1))
print(switch.case(2))
print(switch.case(3))

> ['Eins', 'Zwei', 'Drei']
> ['Zwei', 'Drei']
> ['Drei']

Der vorherige Block hat alle Anweisungen durchgeführt. Ab dem frühesten Fall, der eingetroffen ist, wenn du nun stattdessen möchtest, dass keine weiteren Anweisungen ausgeführt werden, kannst du als dritten Parameter statt False True setzen.

switch = Switch()
switch.add_case(1, case_1, False)
switch.add_case(2, case_2, True)
switch.add_case(3, case_3, False)

print(switch.case(1))
print(switch.case(2))
print(switch.case(3))

> ['Eins', 'Zwei']
> ['Zwei']
> ['Drei']

Fazit

Python reserviert zwar weder switch noch case als Schlüsselwort. Falls du es aber brauchst, kannst du das übliche Verhalten dieses Konstruktes einfach nachbilden.

Hast du noch Fragen oder Anregungen dazu? Hat dir dieser Beitrag gefallen?
Erzähl es in den Kommentaren.