Comment implémenter l'instruction switch/case en Python

Ce que cet article vous apporte concerne la méthode d'implémentation des instructions switch/case en Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Il n'y a pas d'instruction Switch/Case en Python Beaucoup de gens pensent que cette instruction n'est pas assez élégante et flexible. Il sera plus simple et plus efficace d'utiliser un dictionnaire pour gérer les problèmes de correspondance multi-conditions en Python. Pour ceux qui ont une certaine expérience avec Python, les joueurs doivent admettre que c'est effectivement le cas.

Mais aujourd'hui, nous allons voir comment jouer à Switch/Case si nous devons utiliser Python.

Contraintes de syntaxe

Définissons d'abord comment Switch/Case doit être exprimé Pour plus de simplicité, nous pouvons le faire ressembler à ceci.

def cn():
    print('cn')

def us():
    print('us')

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

Implémentation de classe 1

Grâce aux contraintes ci-dessus, nous pouvons implémenter switch en tant que classe. Les paramètres entrants sont traités dans le constructeur, puis les méthodes case et default sont implémentées respectivement. . C'est ça.

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

Dans le constructeur, nous nous souvenons de case_path et de l'état d'exécution _invoked Dans case(), si les key et switch_to actuels correspondent et que la fonction n'a pas été exécutée, alors mettez à jour. _invoked et exécutez la méthode correspondante. Vérifiez default() dans _invoked S'il n'a jamais été exécuté, alors appelez la fonction de la branche default.

Ça a l’air bien, essayons-le.

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

Jetons un coup d'œil à quelques cas étranges.

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

Avez-vous remarqué que l'implémentation ci-dessus ne gérera pas les cas répétés ? Bien sûr, vous pouvez renforcer la méthode case, de préférence en lançant une exception. Cela se fait généralement dans d'autres langages de programmation.

La deuxième question est la suivante : vous voulez obtenir la valeur de retour du cas. L'écrire comme ci-dessus est sans espoir car il est jeté. Nous pouvons envisager d'ajouter une variable de résultat à la classe switch pour enregistrer les résultats de l'exécution.

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

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

Une fois l'appel terminé, vous pouvez obtenir le résultat via result.

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

Implémentation de la classe deux

J'ai probablement cherché sur Internet, vous pouvez également vous référer à Brian Beck pour implémenter Swich/Case à travers les classes.

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

Ce type d'implémentation est relativement compliqué, et il n'est pas très confortable à utiliser. Il nécessite à la fois for et if (ce n'est pas aussi agréable que direct if/else). Bien sûr, il y a aussi des avantages, c'est-à-dire que des cas avec les mêmes résultats peuvent être rassemblés et que plus de choses peuvent être écrites dans le cas, pas seulement un nom de méthode.

Écrit à la fin

Enfin, nous revenons à la méthode recommandée par Python pour traiter le problème switch/case. Généralement, nous pouvons utiliser des dictionnaires pour traiter ce problème multi-branches, à titre d'exemple.

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

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

Est-il clair en un coup d'oeil, facile à lire et facile à entretenir ? La clé est unique dans le dictionnaire et la valeur peut être n'importe quel type de données, soit une classe, soit une méthode, elle est donc suffisamment flexible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!