Remplacements pour instruction switch en Python?

Si vous souhaitez par défaut, vous pouvez utiliser le dictionnaire get(key [par défaut]) méthode:

def f(x):
    return {
        'a': 1,
        'b': 2
    }.get(x, 9)    # 9 is default if x not found

En plus du dictionnaire des méthodes (que j'aime vraiment, d'ailleurs), vous pouvez également utiliser si-elif-d'autre pour obtenir le commutateur/cas/fonctionnalité par défaut:

if x == 'a':
    # Do the thing
elif x == 'b':
    # Do the other thing
if x in 'bc':
    # Fall-through by not using elif, but now the default case includes case 'a'!
elif x in 'xyz':
    # Do yet another thing
else:
    # Do the default

Ce n'est évidemment pas identique à switch/case - vous ne pouvez pas avoir de chute à travers aussi facilement qu'en laissant au large de la rupture, la déclaration, mais vous pouvez avoir un plus compliqué de test. Sa mise en forme est plus agréable que d'une série de imbriquée fi, même si fonctionnellement c'est ce qu'elle est plus proche.

class switch(object):
    value = None
    def __new__(class_, value):
        class_.value = value
        return True

def case(*args):
    return any((arg == switch.value for arg in args))

Utilisation:

while switch(n):
    if case(0):
        print "You typed zero."
        break
    if case(1, 4, 9):
        print "n is a perfect square."
        break
    if case(2):
        print "n is an even number."
    if case(2, 3, 5, 7):
        print "n is a prime number."
        break
    if case(6, 8):
        print "n is an even number."
        break
    print "Only single-digit numbers are allowed."
    break

Tests:

n = 2
#Result:
#n is an even number.
#n is a prime number.
n = 11
#Result:
#Only single-digit numbers are allowed.

Mon préféré est un très beau recette. Vous allez vraiment vous l'aimez. C'est le plus proche de celui que j'ai vu de changement réel de cas relevés, en particulier dans les caractéristiques.

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: # changed for v1.5, see below
            self.fall = True
            return True
        else:
            return False

Voici un exemple:

# The following example is pretty much the exact use-case of a dictionary,
# but is included for its simplicity. Note that you can include statements
# in each suite.
v = 'ten'
for case in switch(v):
    if case('one'):
        print 1
        break
    if case('two'):
        print 2
        break
    if case('ten'):
        print 10
        break
    if case('eleven'):
        print 11
        break
    if case(): # default, could also just omit condition or 'if True'
        print "something else!"
        # No need to break here, it'll stop anyway

# break is used here to look as much like the real thing as possible, but
# elif is generally just as good and more concise.

# Empty suites are considered syntax errors, so intentional fall-throughs
# should contain 'pass'
c = 'z'
for case in switch(c):
    if case('a'): pass # only necessary if the rest of the suite is empty
    if case('b'): 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!"

# As suggested by Pierre Quentel, you can even expand upon the
# functionality of the classic 'case' statement by matching multiple
# cases in a single shot. This greatly benefits operations such as the
# uppercase/lowercase example above:
import string
c = 'A'
for case in switch(c):
    if case(*string.lowercase): # note the * for unpacking as arguments
        print "c is lowercase!"
        break
    if case(*string.uppercase):
        print "c is uppercase!"
        break
    if case('!', '?', '.'): # normal argument passing style also applies
        print "c is a sentence terminator!"
        break
    if case(): # default
        print "I dunno what c was!"

Disons que vous ne voulez pas de simplement renvoyer une valeur, mais vous voulez utiliser les méthodes qui changent quelque chose sur un objet. L'utilisation de l'approche indiqué ici:

result = {
  'a': obj.increment(x),
  'b': obj.decrement(x)
}.get(value, obj.default(x))

Ce qui se passe ici est que python évalue toutes les méthodes dans le dictionnaire.
Donc, même si votre valeur est 'a', l'objet sera incrémentée et décrémenté par x.

Solution:

func, args = {
  'a' : (obj.increment, (x,)),
  'b' : (obj.decrement, (x,)),
}.get(value, (obj.default, (x,)))

result = func(*args)

De sorte que vous obtenez une liste contenant une fonction et ses arguments. De cette façon, seul le pointeur de fonction et la liste des arguments sont retournées, pas évalué. 'résultat' évalue ensuite le retour de l'appel de fonction.

expansion sur le "dict que de passer" de l'idée. si vous souhaitez utiliser une valeur par défaut pour votre switch:

def f(x):
    try:
        return {
            'a': 1,
            'b': 2,
        }[x]
    except KeyError:
        return 'default'

Si vous êtes à la recherche extra-déclaration, comme "switch", j'ai construit un module python qui s'étend Python. Il est appelé ESPY que "le renforcement de la Structure pour Python" et il est disponible pour Python 2.x et Python 3.x.

Par exemple, dans ce cas, une instruction de commutation peut être effectuée par le code suivant:

macro switch(arg1):
    while True:
        cont=False
        val=%arg1%
        socket case(arg2):
            if val==%arg2% or cont:
                cont=True
                socket
        socket else:
            socket
        break

qui peut être utilisée comme ceci:

a=3
switch(a):
    case(0):
        print("Zero")
    case(1):
        print("Smaller than 2"):
        break
    else:
        print ("greater than 1")

donc espy traduire en Python comme:

a=3
while True:
    cont=False
    if a==0 or cont:
        cont=True
        print ("Zero")
    if a==1 or cont:
        cont=True
        print ("Smaller than 2")
        break
    print ("greater than 1")
    break

J'ai trouvé qu'une commune de l'interrupteur de la structure:

switch ...parameter...
case p1: v1; break;
case p2: v2; break;
default: v3;

peut être exprimé en Python comme suit:

(lambda x: v1 if p1(x) else v2 if p2(x) else v3)

ou la mise en forme d'une façon plus claire:

(lambda x:
     v1 if p1(x) else
     v2 if p2(x) else
     v3)

Au lieu d'être une déclaration, la version de python est une expression qui renvoie une valeur.

La plupart des réponses sont assez vieux, et en particulier les acceptée, si elle semble en vaut la mise à jour.

Tout d'abord, l'officiel Python FAQ couvre ce, et recommande la elif de la chaîne pour les cas simples et les dict pour les plus grands ou plus complexes. Elle propose également un ensemble de visit_ méthodes (un style utilisé par de nombreux serveur cadres) pour certains cas:

def dispatch(self, value):
    method_name = 'visit_' + str(value)
    method = getattr(self, method_name)
    method()

La FAQ mentionne également PEP 275, qui a été écrite pour obtenir un officiel-fois-pour-toutes les décisions sur l'ajout de style C instructions de commutation. Mais que PEP a effectivement été reportée à Python 3, et il ne fut officiellement rejeté une proposition distincte, PEP 3103. La réponse est, bien sûr, pas—mais les deux PEPs ont des liens vers des informations supplémentaires si vous êtes intéressé par les raisons ou l'histoire.

---

Une chose qui m'est venue à plusieurs reprises (et peut être vu dans la PPE 275, même si elle a été découpé comme une véritable recommandation), c'est que si vous êtes vraiment gêné par 8 lignes de code pour gérer les 4 cas, contre 6 lignes, vous auriez en C ou en Bash, vous pouvez toujours écrire ceci:

if x == 1: print('first')
elif x == 2: print('second')
elif x == 3: print('third')
else: print('did not place')

Ce n'est pas exactement encouragé par PEP 8, mais c'est lisible et pas trop unidiomatic.

---

Sur plus d'une décennie depuis que PEP 3103 a été rejetée, la question du style C le cas de déclarations, ou même un peu plus puissant version en Aller, a été considéré comme mort; chaque fois que quelqu'un met sur python-des idées ou -dev, qu'ils sont visés à l'ancienne décision.

Cependant, l'idée de la pleine ML de style pattern matching se pose toutes les quelques années, surtout depuis que les langues comme Swift et la Rouille ont adopté. Le problème est qu'il est difficile d'obtenir beaucoup de l'utilisation de la correspondance de motif sans des types de données algébriques. Alors que Guido a été sympathique à l'idée, personne n'est venu avec une proposition qui s'inscrit dans Python très bien. (Vous pouvez lire mon 2014 strawman pour un exemple.) Cela pourrait changer avec dataclass en 3.7 et sporadique des propositions pour un plus puissant enum pour gérer les types sommes, ou avec des propositions différentes pour les différents types de déclaration locale de liaisons (comme PEP 3150, ou l'ensemble des propositions actuellement en cours de discussion sur des idées). Mais jusqu'à présent, il n'a pas.

Il y a aussi parfois des propositions pour Perl 6-style correspondant, qui est en fait un méli-mélo de tout, de elif de regex de répartition unique type de commutation.

def f(x):
    dictionary = {'a':1, 'b':2, 'c':3}
    return dictionary.get(x,'Not Found') 
##Returns the value for the letter x;returns 'Not Found' if x isn't a key in the dictionary

Solution pour exécuter des fonctions:

result = {
    'case1':     foo1, 
    'case2':     foo2,
    'case3':     foo3,
    'default':   default,
}.get(option)()

où foo1(), foo2(), foo3() et par défaut() sont des fonctions

Je pense que la meilleure façon est de utiliser le langage python idiomes de garder votre code testable. Comme l'a montré dans les réponses précédentes, j'utilise les dictionnaires pour prendre avantage de python structures et de la langue et de garder le "cas" code isolés dans différentes méthodes. Ci-dessous il y a une classe, mais vous pouvez l'utiliser directement un module, variables globales et fonctions. La classe possède des méthodes qui peut être testé avec l'isolement.
Dependending à vos besoins, vous pouvez jouer avec des méthodes statiques et les attributs de trop.

class ChoiceManager:

    def __init__(self):
        self.__choice_table = \
        {
            "CHOICE1" : self.my_func1,
            "CHOICE2" : self.my_func2,
        }

    def my_func1(self, data):
        pass

    def my_func2(self, data):
        pass

    def process(self, case, data):
        return self.__choice_table[case](data)

ChoiceManager().process("CHOICE1", my_data)

Il est possible de prendre avantage de cette méthode aide aussi classes que les clés de "__choix_table". De cette façon, vous pouvez éviter isinstance abus et de garder tout propre et vérifiables.

En supposant que vous avez à traiter un grand nombre de messages ou de paquets sur le net ou votre MQ. Chaque paquet possède sa propre structure et son code de gestion (de manière générique).
Avec le code ci-dessus, il est possible de faire quelque chose comme ceci:

class PacketManager:

    def __init__(self):
        self.__choice_table = \
        {
            ControlMessage : self.my_func1,
            DiagnosticMessage : self.my_func2,
        }

    def my_func1(self, data):
        # process the control message here
        pass

    def my_func2(self, data):
        # process the diagnostic message here
        pass

    def process(self, pkt):
        return self.__choice_table[pkt.__class__](pkt)

pkt = GetMyPacketFromNet()
PacketManager().process(pkt)


# isolated test or isolated usage example
def test_control_packet():
    p = ControlMessage()
    PacketManager().my_func1(p)

Donc complexité ne se propage pas dans le flux de code, mais il est rendu dans la structure de code.

Une solution, j'ai tendance à utiliser qui permet également l'utilisation de dictionnaires est :

def decision_time( key, *args, **kwargs):
    def action1()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action2()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action3()
        """This function is a closure - and has access to all the arguments"""
        pass

   return {1:action1, 2:action2, 3:action3}.get(key,default)()

Ceci a l'avantage qu'il ne tente pas d'évaluer les fonctions de tous les temps, et vous avez juste à vous assurer que la fonction externe reçoit toutes les informations à l'intérieur des fonctions de besoin.

Simple, pas testé; chaque condition est évaluée de façon indépendante: il n'y a pas de chute, mais tous les cas sont évalués (bien que l'expression de l'interrupteur n'est évaluée qu'une seule fois), sauf s'il existe une instruction break. Par exemple,

for case in [expression]:
    if case == 1:
        print(end='Was 1. ')

    if case == 2:
        print(end='Was 2. ')
        break

    if case in (1, 2):
        print(end='Was 1 or 2. ')

    print(end='Was something. ')

imprime Was 1. Was 1 or 2. Was something. ^{(nom d'une pipe! Pourquoi ne puis-je pas avoir de fuite des espaces dans des blocs de code en ligne?)} si expression évalue à 1, Was 2. si expression évalue à 2, ou Was something. si expression évalue à quelque chose d'autre.

Si vous n'avez pas à vous inquiéter de perdre la surbrillance de la syntaxe à l'intérieur du boîtier suites, vous pouvez effectuer les opérations suivantes:

exec {
    1: """
print ('one')
""", 
    2: """
print ('two')
""", 
    3: """
print ('three')
""",
}.get(value, """
print ('None')
""")

Où value est la valeur. En C, ce serait:

switch (value) {
    case 1:
        printf("one");
        break;
    case 2:
        printf("two");
        break;
    case 3:
        printf("three");
        break;
    default:
        printf("None");
        break;
}

Nous pouvons également créer une fonction d'aide pour ce faire:

def switch(value, cases, default):
    exec cases.get(value, default)

On peut donc l'utiliser comme ça pour l'exemple avec un, deux et trois:

switch(value, {
    1: """
print ('one')
    """, 
    2: """
print ('two')
    """, 
    3: """
print ('three')
    """,
}, """
print ('None')
""")

Il y a eu beaucoup de réponses jusqu'à présent qui ont dit, "nous n'avons pas d'interrupteur en Python, le faire de cette façon". Cependant, je tiens à souligner que l'instruction switch lui-même est un facile d'abuser de construire, qui peut et doit être évité dans la plupart des cas, car ils favorisent la programmation différée. Affaire au point:

def ToUpper(lcChar):
    if (lcChar == 'a' or lcChar == 'A'):
        return 'A'
    elif (lcChar == 'b' or lcChar == 'B'):
        return 'B'
    ...
    elif (lcChar == 'z' or lcChar == 'Z'):
        return 'Z'
    else:
        return None        # or something

Maintenant, vous pourrait le faire avec un interrupteur d'instruction (si Python offert) mais vous ferais perdre votre temps, car il y a des méthodes qui font cela très bien. Ou peut-être, vous avez quelque chose de moins évident:

def ConvertToReason(code):
    if (code == 200):
        return 'Okay'
    elif (code == 400):
        return 'Bad Request'
    elif (code == 404):
        return 'Not Found'
    else:
        return None

Cependant, ce genre d'opération peut et doit être manipulé avec un dictionnaire, parce que ça sera plus rapide, moins complexe, moins sujet à erreur et plus compact.

Et la grande majorité des "cas d'utilisation" pour les instructions switch va tomber dans un de ces deux cas; il n'y a que très peu de raison de l'utiliser si vous avez pensé à votre problème de fond.

Donc, plutôt que de demander "comment puis-je passer en Python?", peut-être devrions-nous demander, "pourquoi dois-je passer en Python?" parce que c'est souvent la question la plus intéressante et souvent exposer les défauts dans la conception de ce que vous êtes en train de construire.

Maintenant, cela ne veut pas dire que les interrupteurs ne doivent jamais être utilisés. Les machines d'état, lexers, les analyseurs et des automates de tous les utiliser à un certain degré, et, en général, lorsque vous démarrez à partir d'une entrée symétrique et aller à une sortie asymétrique ils peuvent être utiles; il vous suffit de vous assurer que vous n'utilisez pas l'interrupteur, comme un marteau parce que vous voyez un tas de clous dans votre code.

J'ai fait un Commutateur Cas de mise en œuvre qui ne fait pas l'utiliser tout à fait fi de l'extérieur(il utilise encore une si dans la classe).

class SwitchCase(object):
    def __init__(self):
        self._cases = dict()

    def add_case(self,value, fn):
        self._cases[value] = fn

    def add_default_case(self,fn):
        self._cases['default']  = fn

    def switch_case(self,value):
        if value in self._cases.keys():
            return self._cases[value](value)
        else:
            return self._cases['default'](0)

L'utiliser comme ceci:-

from switch_case import SwitchCase
switcher = SwitchCase()
switcher.add_case(1, lambda x:x+1)
switcher.add_case(2, lambda x:x+3)
switcher.add_default_case(lambda _:[1,2,3,4,5])

print switcher.switch_case(1) #2
print switcher.switch_case(2) #5
print switcher.switch_case(123) #[1, 2, 3, 4, 5]

Bien qu'il existe déjà suffisamment de réponses, je tiens à souligner un plus simple et plus puissante solution:

class Switch:
def __init__(self, switches):
self.switches = switches
self.between = len(switches[0]) == 3
def __call__(self, x):
for line in self.switches:
if self.between:
if line[0] <= x < line[1]:
return line[2]
else:
if line[0] == x:
return line[1]
return None
if __name__ == '__main__':
between_table = [
(1, 4, 'between 1 and 4'),
(4, 8, 'between 4 and 8')
]
switch_between = Switch(between_table)
print('Switch Between:')
for i in range(0, 10):
if switch_between(i):
print('{} is {}'.format(i, switch_between(i)))
else:
print('No match for {}'.format(i))
equals_table = [
(1, 'One'),
(2, 'Two'),
(4, 'Four'),
(5, 'Five'),
(7, 'Seven'),
(8, 'Eight')
]
print('Switch Equals:')
switch_equals = Switch(equals_table)
for i in range(0, 10):
if switch_equals(i):
print('{} is {}'.format(i, switch_equals(i)))
else:
print('No match for {}'.format(i))

De sortie:

Switch Between:
No match for 0
1 is between 1 and 4
2 is between 1 and 4
3 is between 1 and 4
4 is between 4 and 8
5 is between 4 and 8
6 is between 4 and 8
7 is between 4 and 8
No match for 8
No match for 9
Switch Equals:
No match for 0
1 is One
2 is Two
No match for 3
4 is Four
5 is Five
No match for 6
7 is Seven
8 is Eight
No match for 9

Similaire à cette réponse par abarnert, voici une solution spécifiquement pour le cas d'utilisation de l'appel d'une fonction unique pour chaque " cas " dans le commutateur, tout en évitant les lambda ou partial pour les ultra-concision tout en étant capable de gérer les arguments mots-clefs:

class switch(object):
NO_DEFAULT = object()
def __init__(self, value, default=NO_DEFAULT):
self._value = value
self._result = default
def __call__(self, option, func, *args, **kwargs):
if self._value == option:
self._result = func(*args, **kwargs)
return self
def pick(self):
if self._result is switch.NO_DEFAULT:
raise ValueError(self._value)
return self._result

Exemple d'utilisation:

def add(a, b):
return a + b
def double(x):
return 2 * x
def foo(**kwargs):
return kwargs
result = (
switch(3)
(1, add, 7, 9)
(2, double, 5)
(3, foo, bar=0, spam=8)
(4, lambda: double(1 / 0))  # if evaluating arguments is not safe
).pick()
print(result)

Noter que c'est le chaînage des appels, c'est à dire switch(3)(...)(...)(...). Ne mettez pas de virgule entre les deux. Il est également important de mettre tout ça dans une expression, c'est pourquoi j'ai utilisé supplémentaire des parenthèses autour de la principale appel implicite de continuation de ligne.

L'exemple ci-dessus va déclencher une erreur si vous passez sur une valeur qui n'est pas traitée, par exemple switch(5)(1, ...)(2, ...)(3, ...). Vous pouvez fournir une valeur par défaut au lieu de cela, par exemple, switch(5, default=-1)... retourne -1.

Les ouvrages suivants pour ma situation quand j'ai besoin d'un interrupteur simple-cas d'appel d'un ensemble de méthodes et de ne pas seulement l'impression du texte. Après avoir joué avec les lambda et globals il m'a frappé comme l'option la plus simple pour moi pour l'instant. Peut-être que cela aidera quelqu'un aussi:

def start():
print("Start")
def stop():
print("Stop")
def print_help():
print("Help")
def choose_action(arg):
return {
"start": start,
"stop": stop,
"help": print_help,
}.get(arg, print_help)
argument = sys.argv[1].strip()
choose_action(argument)()  # calling a method from the given string

Facile à retenir:

while True:
try:
x = int(input("Enter a numerical input: "))
except:
print("Invalid input - please enter a Integer!");
if x==1:
print("good");
elif x==2:
print("bad");
elif x==3:
break
else:
print ("terrible");

Instruction Switch est juste sucre syntaxique pour if/elif/else.
Ce que tout contrôle est en train de faire est de déléguer le travail basé sur certaine condition est remplie - la décision de chemin.Pour l'emballage que dans le module et être capable d'appeler un travail basé sur un id unique, on peut utilise sur l'héritage et le fait que n'importe quelle méthode de python est virtuel, de fournir à la classe dérivée de travail spécifique de mise en œuvre, en tant que cas particuliers" gestionnaire

#!/usr/bin/python
import sys
class Case(object):
"""
Base class wich specifies the interface for "case" handler.
The all required arbitrary arguments inside "execute" method will be
provided through the derived class
specific constructor
@note in python, all class methods are virtual
"""
def __init__(self, id):
self.id = id
def pair(self):
"""
Pairs the given id of the "case" with
the instance on which "execute" will be called
"""
return (self.id, self)
def execute(self):#base class virtual method that needs to be overrided
pass
class Case1(Case):
def __init__(self, id, msg):
self.id = id
self.msg = msg
def execute(self):#override the base class method
print("<Case1> id={}, message: \"{}\"".format(str(self.id), self.msg))
class Case2(Case):
def __init__(self, id, n):
self.id = id
self.n = n
def execute(self):#override the base class method
print("<Case2> id={}, n={}.".format(str(self.id), str(self.n)))
print("\n".join(map(str, range(self.n))))
class Switch(object):
"""
The class wich delegates the jobs
based on the given job id
"""
def __init__(self, cases):
self.cases = cases#dictionary: time complexitiy for access operation is 1
def resolve(self, id):
try:
cases[id].execute()
except KeyError as e:
print("Given id: {} is wrong!".format(str(id)))
if __name__ == '__main__':
# Cases
cases=dict([Case1(0, "switch").pair(), Case2(1, 5).pair()])
switch = Switch(cases)
# id will be dynamically specified
switch.resolve(0)
switch.resolve(1)
switch.resolve(2)