¿Reemplazos para la declaración de cambio en Python?
https://stackoverflow.com/questions/60208
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Quiero escribir una función en Python que devuelva diferentes valores fijos según el valor de un índice de entrada.
En otros idiomas usaría un switch o case declaración, pero Python no parece tener una switch declaración.¿Cuáles son las soluciones Python recomendadas en este escenario?
Solución
Podrías usar un diccionario:
def f(x):
return {
'a': 1,
'b': 2,
}[x]
Otros consejos
Si desea valores predeterminados, puede usar el diccionario. get(key[, default]) método:
def f(x):
return {
'a': 1,
'b': 2
}.get(x, 9) # 9 is default if x not found
Siempre me ha gustado hacerlo de esta manera.
result = {
'a': lambda x: x * 5,
'b': lambda x: x + 7,
'c': lambda x: x - 2
}[value](x)
Además de los métodos de diccionario (que realmente me gustan, por cierto), también puedes usar if-elif-else para obtener la funcionalidad switch/case/default:
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
Por supuesto, esto no es idéntico al interruptor/caja: no se puede fallar tan fácilmente como dejar de romper;declaración, pero puede tener una prueba más complicada.Su formato es mejor que una serie de if anidados, aunque funcionalmente es a lo que se acerca más.
Mi receta Python favorita para switch/case es:
choices = {'a': 1, 'b': 2}
result = choices.get(key, 'default')
Corto y simple para escenarios simples.
Compare con más de 11 líneas de código C:
// C Language version of a simple 'switch/case'.
switch( key )
{
case 'a' :
result = 1;
break;
case 'b' :
result = 2;
break;
default :
result = -1;
}
Incluso puedes asignar múltiples variables usando tuplas:
choices = {'a': (1, 2, 3), 'b': (4, 5, 6)}
(result1, result2, result3) = choices.get(key, ('default1', 'default2', 'default3'))
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))
Uso:
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
Pruebas:
n = 2
#Result:
#n is an even number.
#n is a prime number.
n = 11
#Result:
#Only single-digit numbers are allowed.
Hay un patrón que aprendí del código Twisted Python.
class SMTP:
def lookupMethod(self, command):
return getattr(self, 'do_' + command.upper(), None)
def do_HELO(self, rest):
return 'Howdy ' + rest
def do_QUIT(self, rest):
return 'Bye'
SMTP().lookupMethod('HELO')('foo.bar.com') # => 'Howdy foo.bar.com'
SMTP().lookupMethod('QUIT')('') # => 'Bye'
Puede usarlo en cualquier momento que necesite enviar un token y ejecutar un fragmento de código extendido.En una máquina de estados tendrías state_ métodos y envío en self.state.Este modificador se puede ampliar limpiamente heredándolo de la clase base y definiendo el suyo propio. do_ métodos.Muchas veces ni siquiera tendrás do_ métodos en la clase base.
Editar:¿Cómo se usa exactamente?
En caso de SMTP recibirás HELO del cable.El código relevante (de twisted/mail/smtp.py, modificado para nuestro caso) se ve así
class SMTP:
# ...
def do_UNKNOWN(self, rest):
raise NotImplementedError, 'received unknown command'
def state_COMMAND(self, line):
line = line.strip()
parts = line.split(None, 1)
if parts:
method = self.lookupMethod(parts[0]) or self.do_UNKNOWN
if len(parts) == 2:
return method(parts[1])
else:
return method('')
else:
raise SyntaxError, 'bad syntax'
SMTP().state_COMMAND(' HELO foo.bar.com ') # => Howdy foo.bar.com
Recibirás ' HELO foo.bar.com ' (o podrías conseguir 'QUIT' o 'RCPT TO: foo').Esto se tokeniza en parts como ['HELO', 'foo.bar.com'].El nombre de búsqueda del método real se toma de parts[0].
(El método original también se llama state_COMMAND, porque usa el mismo patrón para implementar una máquina de estados, es decir getattr(self, 'state_' + self.mode))
Mi favorito es realmente bonito. receta.Realmente te gustará.Es lo más cercano que he visto a declaraciones de casos de cambio reales, especialmente en características.
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
He aquí un ejemplo:
# 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!"
class Switch:
def __init__(self, value):
self.value = value
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
return False # Allows a traceback to occur
def __call__(self, *values):
return self.value in values
from datetime import datetime
with Switch(datetime.today().weekday()) as case:
if case(0):
# Basic usage of switch
print("I hate mondays so much.")
# Note there is no break needed here
elif case(1,2):
# This switch also supports multiple conditions (in one line)
print("When is the weekend going to be here?")
elif case(3,4):
print("The weekend is near.")
else:
# Default would occur here
print("Let's go have fun!") # Didn't use case for example purposes
Digamos que no desea simplemente devolver un valor, sino que desea utilizar métodos que cambien algo en un objeto.Usar el enfoque indicado aquí sería:
result = {
'a': obj.increment(x),
'b': obj.decrement(x)
}.get(value, obj.default(x))
Lo que sucede aquí es que Python evalúa todos los métodos del diccionario.Entonces, incluso si su valor es 'a', el objeto se incrementará y disminuido en x.
Solución:
func, args = {
'a' : (obj.increment, (x,)),
'b' : (obj.decrement, (x,)),
}.get(value, (obj.default, (x,)))
result = func(*args)
Entonces obtienes una lista que contiene una función y sus argumentos.De esta manera, solo se devuelven el puntero de función y la lista de argumentos, no evaluado.'resultado' luego evalúa la llamada a la función devuelta.
Voy a dejar mi granito de arena aquí.La razón por la que no hay una declaración case/switch en Python es porque Python sigue el principio de "Sólo hay una manera correcta de hacer algo".Entonces, obviamente, se podrían idear varias formas de recrear la funcionalidad switch/case, pero la forma Pythonic de lograr esto es la construcción if/elif.es decir
if something:
return "first thing"
elif somethingelse:
return "second thing"
elif yetanotherthing:
return "third thing"
else:
return "default thing"
Simplemente sentí que PEP 8 merecía un reconocimiento aquí.Una de las cosas hermosas de Python es su simplicidad y elegancia.Esto se deriva en gran medida de los principios establecidos en PEP 8, incluido "Sólo hay una manera correcta de hacer algo".
ampliando la idea de "dictar como interruptor".si desea utilizar un valor predeterminado para su interruptor:
def f(x):
try:
return {
'a': 1,
'b': 2,
}[x]
except KeyError:
return 'default'
Si tiene un bloque de casos complicado, puede considerar usar una tabla de búsqueda de diccionario de funciones...
Si no ha hecho esto antes, es una buena idea ingresar a su depurador y ver exactamente cómo el diccionario busca cada función.
NOTA:Hacer no use "()" dentro de la búsqueda de casos/diccionario o llamará a cada una de sus funciones a medida que se crea el bloque de diccionario/caso.Recuerde esto porque solo desea llamar a cada función una vez mediante una búsqueda de estilo hash.
def first_case():
print "first"
def second_case():
print "second"
def third_case():
print "third"
mycase = {
'first': first_case, #do not use ()
'second': second_case, #do not use ()
'third': third_case #do not use ()
}
myfunc = mycase['first']
myfunc()
Si está buscando una declaración adicional, como "cambiar", construí un módulo de Python que extiende Python.Se llama DIVISAR como "Estructura mejorada para Python" y está disponible tanto para Python 2.x como para Python 3.x.
Por ejemplo, en este caso, una declaración de cambio podría realizarse con el siguiente código:
macro switch(arg1):
while True:
cont=False
val=%arg1%
socket case(arg2):
if val==%arg2% or cont:
cont=True
socket
socket else:
socket
break
que se puede utilizar así:
a=3
switch(a):
case(0):
print("Zero")
case(1):
print("Smaller than 2"):
break
else:
print ("greater than 1")
así que espía traducirlo en Python como:
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
No encontré la respuesta simple que estaba buscando en ninguna parte de la búsqueda de Google.Pero lo descubrí de todos modos.Es realmente bastante simple.Decidí publicarlo y tal vez evitar algunos rasguños menos en la cabeza de otra persona.La clave es simplemente "en" y tuplas.A continuación se muestra el comportamiento de la declaración de cambio con falla, incluida la falla ALEATORIA.
l = ['Dog', 'Cat', 'Bird', 'Bigfoot',
'Dragonfly', 'Snake', 'Bat', 'Loch Ness Monster']
for x in l:
if x in ('Dog', 'Cat'):
x += " has four legs"
elif x in ('Bat', 'Bird', 'Dragonfly'):
x += " has wings."
elif x in ('Snake',):
x += " has a forked tongue."
else:
x += " is a big mystery by default."
print(x)
print()
for x in range(10):
if x in (0, 1):
x = "Values 0 and 1 caught here."
elif x in (2,):
x = "Value 2 caught here."
elif x in (3, 7, 8):
x = "Values 3, 7, 8 caught here."
elif x in (4, 6):
x = "Values 4 and 6 caught here"
else:
x = "Values 5 and 9 caught in default."
print(x)
Proporciona:
Dog has four legs
Cat has four legs
Bird has wings.
Bigfoot is a big mystery by default.
Dragonfly has wings.
Snake has a forked tongue.
Bat has wings.
Loch Ness Monster is a big mystery by default.
Values 0 and 1 caught here.
Values 0 and 1 caught here.
Value 2 caught here.
Values 3, 7, 8 caught here.
Values 4 and 6 caught here
Values 5 and 9 caught in default.
Values 4 and 6 caught here
Values 3, 7, 8 caught here.
Values 3, 7, 8 caught here.
Values 5 and 9 caught in default.
Encontré que una estructura de interruptor común:
switch ...parameter...
case p1: v1; break;
case p2: v2; break;
default: v3;
se puede expresar en Python de la siguiente manera:
(lambda x: v1 if p1(x) else v2 if p2(x) else v3)
o formateado de una manera más clara:
(lambda x:
v1 if p1(x) else
v2 if p2(x) else
v3)
En lugar de ser una declaración, la versión de Python es una expresión que se evalúa como un valor.
Las soluciones que uso:
Una combinación de 2 de las soluciones publicadas aquí, que es relativamente fácil de leer y admite valores predeterminados.
result = {
'a': lambda x: x * 5,
'b': lambda x: x + 7,
'c': lambda x: x - 2
}.get(whatToUse, lambda x: x - 22)(value)
dónde
.get('c', lambda x: x - 22)(23)
mira hacia arriba "lambda x: x - 2" en el dict y lo usa con x=23
.get('xxx', lambda x: x - 22)(44)
no lo encuentra en el dict y usa el predeterminado "lambda x: x - 22" con x=44.
# simple case alternative
some_value = 5.0
# this while loop block simulates a case block
# case
while True:
# case 1
if some_value > 5:
print ('Greater than five')
break
# case 2
if some_value == 5:
print ('Equal to five')
break
# else case 3
print ( 'Must be less than 5')
break
La mayoría de las respuestas aquí son bastante antiguas, y especialmente las aceptadas, por lo que parece que vale la pena actualizarlas.
Primero, el funcionario Preguntas frecuentes sobre Python cubre esto y recomienda el elif cadena para casos simples y la dict para casos más grandes o más complejos.También sugiere un conjunto de visit_ métodos (un estilo utilizado por muchos marcos de servidores) para algunos casos:
def dispatch(self, value):
method_name = 'visit_' + str(value)
method = getattr(self, method_name)
method()
Las preguntas frecuentes también mencionan PEP 275, que fue escrito para obtener una decisión oficial de una vez por todas sobre la adición de declaraciones de cambio estilo C.Pero ese PEP en realidad se aplazó a Python 3 y solo se rechazó oficialmente como una propuesta separada. PEP 3103.La respuesta fue, por supuesto, no, pero los dos PEP tienen enlaces a información adicional si está interesado en los motivos o la historia.
Una cosa que surgió varias veces (y se puede ver en PEP 275, aunque fue eliminada como una recomendación real) es que si realmente te molesta tener 8 líneas de código para manejar 4 casos, vs.las 6 líneas que tendrías en C o Bash, siempre puedes escribir esto:
if x == 1: print('first')
elif x == 2: print('second')
elif x == 3: print('third')
else: print('did not place')
PEP 8 no fomenta exactamente esto, pero es legible y no demasiado poco idiomático.
Durante más de una década desde que se rechazó PEP 3103, la cuestión de las declaraciones de casos estilo C, o incluso la versión ligeramente más poderosa en Go, se ha considerado muerta;Cada vez que alguien menciona python-ideas o -dev, se le remite a la decisión anterior.
Sin embargo, la idea de una coincidencia completa de patrones al estilo ML surge cada pocos años, especialmente desde que lenguajes como Swift y Rust la han adoptado.El problema es que es difícil sacarle mucho provecho a la coincidencia de patrones sin tipos de datos algebraicos.Si bien Guido ha simpatizado con la idea, a nadie se le ha ocurrido una propuesta que encaje muy bien en Python.(Puedes leer mi hombre de paja de 2014 por ejemplo.) Esto podría cambiar con dataclass en 3.7 y algunas propuestas esporádicas para una versión más potente. enum para manejar tipos de suma, o con varias propuestas para diferentes tipos de enlaces de declaración local (como PEP 3150, o el conjunto de propuestas que se están discutiendo actualmente sobre -ideas).Pero hasta ahora no es así.
Ocasionalmente también hay propuestas para la combinación de estilos de Perl 6, que es básicamente una mezcolanza de todo, desde elif a expresiones regulares a cambio de tipo de despacho único.
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
me gustó La respuesta de Mark Bies
desde el x La variable debe usarse dos veces, modifiqué las funciones lambda a sin parámetros.
tengo que correr con results[value](value)
In [2]: result = {
...: 'a': lambda x: 'A',
...: 'b': lambda x: 'B',
...: 'c': lambda x: 'C'
...: }
...: result['a']('a')
...:
Out[2]: 'A'
In [3]: result = {
...: 'a': lambda : 'A',
...: 'b': lambda : 'B',
...: 'c': lambda : 'C',
...: None: lambda : 'Nothing else matters'
...: }
...: result['a']()
...:
Out[3]: 'A'
Editar: Me di cuenta de que puedo usar None escriba con diccionarios.Entonces esto emularía switch ; case else
Solución para ejecutar funciones:
result = {
'case1': foo1,
'case2': foo2,
'case3': foo3,
'default': default,
}.get(option)()
donde foo1(), foo2(), foo3() y default() son funciones
def f(x):
return 1 if x == 'a' else\
2 if x in 'bcd' else\
0 #default
Corto y fácil de leer, tiene un valor predeterminado y admite expresiones tanto en condiciones como en valores de retorno.
Sin embargo, es menos eficaz que la solución con un diccionario.Por ejemplo, Python tiene que analizar todas las condiciones antes de devolver el valor predeterminado.
Creo que la mejor manera es use los modismos del lenguaje Python para mantener su código comprobable.Como se mostró en respuestas anteriores, uso diccionarios para aprovechar las estructuras y el lenguaje de Python y mantener el código "caso" aislado en diferentes métodos.Debajo hay una clase, pero puedes usar directamente un módulo, globales y funciones.La clase tiene métodos que se puede probar con aislamiento.Dependiendo de tus necesidades, también puedes jugar con métodos y atributos estáticos.
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)
Es posible aprovecha este método usando también clases como claves de "__choice_table".De esta manera podrás evitar abuso de instancia y manténgalo todo limpio y comprobable.
Supongamos que tiene que procesar muchos mensajes o paquetes de la red o de su MQ.Cada paquete tiene su propia estructura y su código de gestión (de forma genérica).Con el código anterior es posible hacer algo como esto:
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)
Entonces La complejidad no se distribuye en el flujo del código, sino que se representa en la estructura del código..
Ampliando La respuesta de Greg Hewgill - Podemos encapsular la solución del diccionario usando un decorador:
def case(callable):
"""switch-case decorator"""
class case_class(object):
def __init__(self, *args, **kwargs):
self.args = args
self.kwargs = kwargs
def do_call(self):
return callable(*self.args, **self.kwargs)
return case_class
def switch(key, cases, default=None):
"""switch-statement"""
ret = None
try:
ret = case[key].do_call()
except KeyError:
if default:
ret = default.do_call()
finally:
return ret
Esto luego se puede utilizar con el @case-decorador
@case
def case_1(arg1):
print 'case_1: ', arg1
@case
def case_2(arg1, arg2):
print 'case_2'
return arg1, arg2
@case
def default_case(arg1, arg2, arg3):
print 'default_case: ', arg1, arg2, arg3
ret = switch(somearg, {
1: case_1('somestring'),
2: case_2(13, 42)
}, default_case(123, 'astring', 3.14))
print ret
La buena noticia es que esto ya se ha hecho en NeoPySwitch-módulo.Simplemente instale usando pip:
pip install NeoPySwitch
Una solución que suelo utilizar y que también utiliza diccionarios es:
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)()
Esto tiene la ventaja de que no intenta evaluar las funciones cada vez, y sólo hay que asegurarse de que la función externa obtenga toda la información que las funciones internas necesitan.
puedes usar un dict enviado:
#!/usr/bin/env python
def case1():
print("This is case 1")
def case2():
print("This is case 2")
def case3():
print("This is case 3")
token_dict = {
"case1" : case1,
"case2" : case2,
"case3" : case3,
}
def main():
cases = ("case1", "case3", "case2", "case1")
for case in cases:
token_dict[case]()
if __name__ == '__main__':
main()
Producción:
This is case 1
This is case 3
This is case 2
This is case 1
Sencillo, no probado;cada condición se evalúa de forma independiente:no hay fallas, pero se evalúan todos los casos (aunque la expresión para activar solo se evalúa una vez), a menos que haya una declaración de interrupción.Por ejemplo,
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. ')
huellas dactilares Was 1. Was 1 or 2. Was something. (¡Maldita sea!¿Por qué no puedo tener espacios en blanco al final de los bloques de código en línea?) si expression evalúa a 1, Was 2. si expression evalúa a 2, o Was something. si expression evalúa a otra cosa.
Definiendo:
def switch1(value, options):
if value in options:
options[value]()
le permite utilizar una sintaxis bastante sencilla, con los casos agrupados en un mapa:
def sample1(x):
local = 'betty'
switch1(x, {
'a': lambda: print("hello"),
'b': lambda: (
print("goodbye," + local),
print("!")),
})
Seguí intentando redefinir switch de una manera que me permitiera deshacerme del "lambda:", pero me di por vencido.Modificando la definición:
def switch(value, *maps):
options = {}
for m in maps:
options.update(m)
if value in options:
options[value]()
elif None in options:
options[None]()
Me permitió asignar varios casos al mismo código y proporcionar una opción predeterminada:
def sample(x):
switch(x, {
_: lambda: print("other")
for _ in 'cdef'
}, {
'a': lambda: print("hello"),
'b': lambda: (
print("goodbye,"),
print("!")),
None: lambda: print("I dunno")
})
Cada caso replicado tiene que estar en su propio diccionario;switch() consolida los diccionarios antes de buscar el valor.Sigue siendo más feo de lo que me gustaría, pero tiene la eficiencia básica de usar una búsqueda hash en la expresión, en lugar de un bucle a través de todas las claves.
Si no le preocupa perder el resaltado de sintaxis dentro de los conjuntos de casos, puede hacer lo siguiente:
exec {
1: """
print ('one')
""",
2: """
print ('two')
""",
3: """
print ('three')
""",
}.get(value, """
print ('None')
""")
Dónde value es el valor.En C, esto sería:
switch (value) {
case 1:
printf("one");
break;
case 2:
printf("two");
break;
case 3:
printf("three");
break;
default:
printf("None");
break;
}
También podemos crear una función auxiliar para hacer esto:
def switch(value, cases, default):
exec cases.get(value, default)
Entonces podemos usarlo así para el ejemplo con uno, dos y tres:
switch(value, {
1: """
print ('one')
""",
2: """
print ('two')
""",
3: """
print ('three')
""",
}, """
print ('None')
""")
