Python Language
Alternatives à changer de déclaration à partir d'autres langues

Remarques

Utilisez ce que le langage offre: la construction if / else.

Eh bien, si vous voulez une construction switch / case , la méthode la plus simple consiste à utiliser le bon vieux if / else :

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

il peut sembler redondant, et pas toujours joli, mais c'est de loin le moyen le plus efficace, et il fait le travail:

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

Utilisez un dicton de fonctions

Un autre moyen simple consiste à créer un dictionnaire de fonctions:

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

puis vous ajoutez une fonction par défaut:

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

et vous utilisez la méthode get du dictionnaire pour obtenir la fonction donnée la valeur pour vérifier et l'exécuter. Si value n'existe pas dans le dictionnaire, default_case est exécuté.

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

vous pouvez aussi faire du sucre syntaxique pour que le commutateur soit plus joli:

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

>>> run_switch(1)
one

Utiliser l'introspection de classe

Vous pouvez utiliser une classe pour imiter la structure de commutateur / cas. Ce qui suit utilise l'introspection d'une classe (en utilisant la fonction getattr() qui résout une chaîne dans une méthode liée sur une instance) pour résoudre la partie "case".

Ensuite, cette méthode d'introspection est associée à la méthode __call__ pour surcharger l'opérateur () .

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

    __call__ = switch

Ensuite, pour le rendre plus joli, nous sous- SwitchBase classe SwitchBase (mais cela pourrait être fait dans une classe), et nous définissons ici tous les case comme des méthodes:

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

alors nous pouvons enfin l'utiliser:

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

Utiliser un gestionnaire de contexte

Une autre manière, très lisible et élégante, mais beaucoup moins efficace qu'une structure if / else, est de construire une classe comme suit, qui lira et stockera la valeur à comparer, s'exposera dans le contexte comme un appelable retournera true s'il correspond à la valeur stockée:

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

alors la définition des cas correspond presque à la construction réelle du switch / de la case (exposée dans une fonction ci-dessous, pour faciliter la démonstration):

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

Donc, l'exécution serait:

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

• Cette solution est proposée comme module de commutation disponible sur pypi .