python中的switch case不起作用;

switch case in python doesn't work; need another pattern

我需要一个关于代码的帮助，我想在python中实现switch case模式，就像一些教程所说的那样，我可以使用字典来实现这个功能，但我的问题是：

1
2
3
4
5
6
7

# type can be either create or update or ..
message = { 'create':msg(some_data),
'update':msg(other_data)
# can have more
}

return message(type)

但是它对我不起作用，因为有些数据或其他数据可能是无的(如果不是，它会引发错误)，并且msg函数需要简单(我不想在其中加入某些条件)。

这里的问题是每次执行函数msg()来填充dict与通常使用其他编程语言的switch case模式不同的是，除非匹配，否则switch case模式不会执行case中的代码。

有没有其他方法可以这样做，或者我只需要这样做，如果伊利夫…

更新：谢谢你所有的回复，但实际上更像这样

1
2
3
4

message = { 'create':"blabla %s" % msg(some_data),
'update':"blabla %s" % msg(other_data)
'delete':"blabla %s" % diff(other_data, some_data)
}

所以lambda在这里不起作用，也不调用相同的函数，所以它更像是我需要的一个真正的开关案例，也许我需要考虑其他模式。

相关讨论

听起来你把这件事复杂化了。你想要简单点？

1
2
3
4
5
6

if mytype == 'create':
return msg(some_data)
elif mytype == 'update':
return msg(other_data)
else:
return msg(default_data)

您不必仅仅因为可以使用dict和函数引用。有时，一个无聊的、明确的if/else块正是您需要的。很明显，即使是团队中最新的程序员也不会不必要地调用msg()。我也愿意打赌，这将比您正在研究的其他解决方案更快，除非案例数量增加并且msg()快得惊人。

相关讨论

1
2
3
4

message = { 'create':msg(some_data or ''),
'update':msg(other_data or '')
# can have more
}

更妙的是，为了防止执行msg只是为了完成这一指令：

1
2
3
4
5
6

message = { 'create':(msg,some_data),
'update':(msg,other_data),
# can have more
}
func,data=message[msg_type]
func(data)

现在您可以自由定义一个更合理的msg函数，它可以处理一个等于None的参数：

1
2
3

def msg(data):
if data is None: data=''
...

相关讨论

谢谢你的回答，但这很令人困惑，它就像一个不可读的代码一样在找我。
@未知，如果代码看起来不可读，您需要学会更好地阅读。这是最干净的代码，可以很好地使用函数是第一类对象的事实。
@aaronmcsmound，抱歉，但在一家公司，程序员的水平不同，并不是所有的程序员都能读这样的代码，在我的公司里，我们有一条规则说："做最简单的事情，这样开发人员之后就可以知道你在做什么了"，所以如果这看起来对你来说是可读的，我会说"很好"，但在安装2次之后，我相信你会问自己为什么在我就是这么说的：恕我直言
"不知道。"对不起的。我可能会被器官收割机绑架，在写完后的X个月里，我在服药的时候读到这段代码。如果你公司里有人看不懂，那我就很生气，因为他们为了生活而写代码，而我却没有。这真是微不足道的事情。
@阿隆姆斯朗克。：)我理解你的意思，但我想说的不是代码是不可理解的，确定它是(对于优秀的开发人员)，但为什么会是这样，有人会来，他会认为代码可以简化只是一个听写，然后是booomm，这在我老时候就发生了：)所以现在我不把代码这样，如果我这样做了，我会在上面写上很多评论，比如为什么是这样的，基本上我想我们一直都不会问自己代码是做什么的，但是为什么是这样的，不是吗？？)
如果你打算用最小的分母来写代码，那么你总是会遇到这个问题，即使代码是可读的，而且是Python式的。
@未知：在某种程度上，您确实需要假定使用编程语言的基本知识水平。如果代码使用了语言中一个深奥的部分，您可以添加一个注释，但是代码并不是所有的代码都不可读，而且我也不是所有的python人。
@未知：可以这样使用字典是Python的基础知识。语言没有switch语句，因为您可以使用if/elifs或此构造。我想说，如果你在python工作，并且不能理解或记住函数是一流的对象，并且听写功能非常通用，那么你的公司需要在员工培训和面试方面投入更多。
@阿德里亚诺：让我问一下：是你决定不在python中使用switch案例吗？我打赌不是，所以你怎么能说python不需要，你只是接受事实还是……？还有一件事告诉你，我公司的员工不好，不是我，你只是以我所有的尊重来解释我写的东西，最后一件事是我认为这是关于分享知识和帮助，但我错了，因为这是关于人们试图用侮辱和观点来击败别人，我认为你应该学会改变别说，谦虚是一种财富。
@不知道：如果我能给你留下我的印象：首先，"switch"只是一系列"if"语句的快捷方式。支持"if"的语言不需要支持"switch"来提供相同的功能。无论是否包含特定的快捷方式，都是语言设计师的选择，而Python设计师显然不认为这是必要的。如果你想要进一步的细节，另一个问题或一些研究应该提供它。
回复：知识水平，你说，"对不起，但是在一家公司，程序员的水平是不同的，不是所有的程序员都能读到这样的代码，"很明显，这意味着你的一些公司程序员不会理解答案中的代码。考虑到这是一个基本的语言特性，并且期望使用特定语言的程序员不知道核心语言特性是不合理的(对双重否定表示抱歉)，建议您公司的程序员编写经过培训的Python，以便他们能够阅读它是完全合理的。如果这不是你的意思，那又是什么？
@不详，对不起。它不是"语言没有switch语句，因为它有if else和这个构造"，而是"语言没有switch语句，它有if else和这个构造"。我不是想侮辱你，但我知道你可能会对我的陈述感到侮辱。阅读@atk对我的看法的评论。
@ATK：我不同意，也不是所有像你说的那样的语言设计师都会用这种语言添加switch case语句，因为：让我们从if else语句开始，它做什么？它是"每次"测试，如果条件是正确的，可以决定是否执行代码，另一方面switch case语句得到一个var，并且通过了解它的价值，它就知道该去哪里(你可以把它当作老go to)；参见这个en.wikipedia.org/wiki/switch_声明
@未知：您不同意语言设计器必须选择是否包含switch语句？或者您不同意使用if/else可以实现相同的功能？或者，您是否认为开关本质上是goto的一种形式，而if/else不是(或者类似地，如果jmp指令和另一个指令不是，则实现一个形式)？
@ATK：这个"switch"只是一系列"if"语句的快捷方式，我不同意，这个"支持if"的语言不需要支持"switch"来提供相同的功能，"我不同意"，这是语言设计者的选择是否包括特定的快捷方式。我同意，除了"特定shoRTCHATE"。关于"你不同意用if/else可以实现相同的功能"，当然我们可以，但我在这里谈论的是优化，特别是在许多要测试的条件下，以及可读性(if elif elif…)
@ATK：维基百科的链接解释了交换盒和我认为的其他交换盒之间的区别，如果不清楚，这里还有一个：eventhix.com/realtimemantra/basics/&hellip；玩得开心：)
@未知：if/else没有的交换机有哪些功能可用？如果语言设计者不决定要在语言中加入什么，那么谁会决定呢？编译器可以使用if/else无法执行的开关执行什么优化？我同意在某些情况下，switch比if/else更可读，但这是您第一次在switch与if/else的讨论中提到可读性。让我们来讨论那些没有意义的东西：)
@阿特克：好吧，让我们乞求"如果语言设计师不决定用哪种语言，谁来做？"我不是你这里所说的设计师，但是python有一个叫做pep和bdfl的东西，请查看python.org/dev/peps/pep-0001，对于另一个问题，我刚刚发现了这个：python.org/dev/peps/pep-0275，但是它被拒绝了两次，hehehehe:)
@未知：语言设计者将是个人或团体，决定什么FET进入语言，什么不进入语言。就像每一个计算机项目。如果语言设计者不决定语言中的内容，那么谁来决定呢？

在我学习python之前的5年里，我被灌输了开关发明游戏：没有lambda或字典的可读开关结构。哦，好吧。阅读下面的另一种方法。

在这里。有一个switch语句。(有@martineau的一些不错的清洁服务)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

with switch(foo):

@case(1)
def _():
print"1"

@case(2)
def _():
print"2"

@case(3)
def _():
print"3"

@case(5)
@case(6)
def _():
print '5 and 6'

@case.default
def _():
print 'default'

我将免费加入(适度的)黑客堆栈、滥用的装饰器和可疑的上下文管理器。它很难看，但功能正常(而且不是很好)。基本上，它所做的就是用一个丑陋的包装器包装字典逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import inspect

class switch(object):
def __init__(self, var):
self.cases = {}
self.var = var

def __enter__(self):
def case(value):
def decorator(f):
if value not in self.cases:
self.cases[value] = f
return f
return decorator

def default(f):
self.default = f
return f
case.default = default

f_locals = inspect.currentframe().f_back.f_locals
self.f_locals = f_locals.copy()
f_locals['case'] = case

def __exit__(self, *args, **kwargs):
new_locals = inspect.currentframe().f_back.f_locals
new_items = [key for key in new_locals if key not in self.f_locals]
for key in new_items:
del new_locals[key] # clean up
new_locals.update(self.f_locals) # this reverts all variables to their
try: # previous values
self.cases[self.var]()
except KeyError:
try:
getattr(self, 'default')()
except AttributeError:
pass

注意，黑客堆栈实际上并不必要。我们只是使用它来创建一个作用域，这样switch语句中出现的定义就不会泄漏到封闭作用域中，也不会将case泄漏到命名空间中。如果您不介意泄漏(例如循环泄漏)，那么您可以从__enter__中移除堆栈黑客并返回case修饰器，使用WITH语句上的as子句在封闭范围内接收它。

相关讨论

亲爱的上帝。我给你加1是因为你精神错乱。
+1.对with和装饰工的创造性滥用——但我怀疑这一行动是否会给他/她造成他/她认为func,data=message[msg_type]过于复杂的后果。
fwiw，如果你把self.f_locals = copy.copy(f_locals)移到__enter()的一条线上，你就不需要__exit__()的del new_locals['case']。
很容易修复错误。嵌套的decorator(f)函数在结尾处需要一个return f，因此@case(X)装饰器的链接起作用，否则设置foo = 5会导致示例中的TypeError: 'NoneType' object is not callable错误。不过，这是一个非常聪明的解决方案。
@马蒂诺，谢谢你的安排。最后一个错误只是由于同时编辑两个版本而导致的复制错误。我很尴尬，但是我错过了第一个。哦，好吧，我写这篇文章的时候应该睡觉，所以我会让它解释清楚的。重点不是说OP喜欢它，而是说OP看到了一个复杂的问题解决方案，把简单的问题放在透视图上。
没什么大不了的。我发现第一个原因仅仅是因为我密切关注你如此贬低的"堆栈黑客"的每一步。真正让我感兴趣的是它如何能够通过上下文处理程序协议将"case"注入调用方的本地命名空间，然后将其移除。似乎有点值得理解。
另一个需要考虑的小简化：如果self.f_locals = copy.copy(f_locals)改为self.f_locals = f_locals.copy()，靠近顶部的import copy也会消失。
@马蒂诺。好眼力。我总是忘记听写的复制方法。我应该开始假装那个模块被否决了，然后开始想出一个不用它做任何事情的方法。
@马蒂诺。我把它修好了，还修好了我看到的两个but。1)如果调用"default"失败，并且大小写不匹配，则会因属性错误而放大。2)如果case是switch'语句之外的变量，那么它就会消失。都是固定的。谢谢你的建议，让我再看一遍。
但是等等，还有更多！您可以通过在__init__()中添加self.default = lambda: None来创建默认的default()。这将允许您删除刚才在getattr(self, 'default')()调用周围添加的try/except。无论如何，后者可以改为更简单的self.default()。也许@unknown有点过于复杂…；-)
@martineau，把它改为self.default()是不好的，因为这样，Python将把它当作绑定方法调用来处理，并将其传递给一个实例。这将要求用户编写默认方法来接受self，哪种方法会破坏它。我可以将它存储在一个列表中，然后以这种方式拉出，但也可以使用getattr。
不知道，我明白你说的，但是它似乎很适合我，正如我所描述的那样，无论有没有一个@case.default函数在那里。实际上，我可能发现了一个严重的(不相关的)限制——除非在那里定义了类，否则不能在函数体中使用它——我正在研究……
@马蒂尼奥，你说得对，我对此有误解。我要保持原样，以免为了那样的小变化而撞到它。
@马蒂诺，关于限制你也是对的。退出两个帧可以修复它，但在全局代码中会破坏它。对于递归函数，需要三个f_backs。我怀疑我只是在使用globals，在这种情况下，我们也可以删除inspect。
我怀疑摆脱inspect是一件好事，特别是如果一路上它可以在更多或所有的地方工作。相比之下，lambda和self.default()的修改是微不足道的。

这里有一点不同(虽然有点类似于@torbeweed)，而且可以说更"面向对象"。您可以使用Python类(包含字典)来代替显式使用字典来处理各种情况。

这种方法提供了一个看似自然的C/C++ EDCOX1，12个语句到Python代码的翻译。与后者一样，它推迟了处理每种情况的代码的执行，并允许提供默认的代码。

与案例对应的每个switch类方法的代码可以由多行代码组成，而不是此处显示的单个return 行代码，并且都只编译一次。但是，有一个区别或限制是，一个方法中的处理不会也不能自动"尽管"进入下一个方法的代码中(这在示例中不是问题，但很好)。

1
2
3
4
5
6
7
8
9
10

class switch:
def create(self): return"blabla %s" % msg(some_data)
def update(self): return"blabla %s" % msg(other_data)
def delete(self): return"blabla %s" % diff(other_data, some_data)
def _default(self): return"unknown type_"
def __call__(self, type_): return getattr(self, type_, self._default)()

switch = switch() # only needed once

return switch(type_)

可以将计算隐藏在lambda中：

1
2
3
4

message = { 'create': lambda: msg(some_data),
'update': lambda: msg(other_data),
}
return message[type]()

只要所有的名称都定义好了(这样你就不会得到一个NameError，你也可以这样构造它：

1
2
3
4
5

message = { 'create': (msg, some_data),
'update': (other_func, other_data),
}
func, arg = message[type]
return func(arg)

相关讨论

创建新的类并将数据/参数包装在对象中，这样就可以让函数决定它需要哪些参数，而不是通过传递参数来绑定数据…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class MyObj(object):
def __init__(self, data, other_data):
self.data = data
self.other_data = other_data

def switch(self, method_type):
return {
"create": self.msg,
"update": self.msg,
"delete": self.delete_func,
}[method_type]()

def msg(self):
#process self.data
return"Hello, World !!"

def delete_func(self):
#process other data self.other_data or anything else....
return True

if"__main__" == __name__:
m1 = MyObj(1,2)
print m1.switch('create')
print m1.switch('delete')

您可以使用lambda延迟执行匹配：

1
2
3
4
5

return {
'create': lambda: msg(some_data),
'update': lambda: msg(other_data),
# ...
}[type]()

如果所有的情况都只是用不同的参数调用msg，您可以将其简化为：

1
2
3
4
5

return msg({
'create': some_data,
'update': other_data,
# ...
}[type])

由于在每种情况下要执行的代码都来自安全的源代码，因此可以将每个代码段存储在字典中的单独字符串表达式中，并沿着这些行执行一些操作：

1
2
3
4
5
6

message = { 'create': '"blabla %s" % msg(some_data)',
'update': '"blabla %s" % msg(other_data)',
'delete': '"blabla %s" % diff(other_data, some_data)'
}

return eval(message[type_])

最后一行的表达式也可以是eval(message.get(type_, '"unknown type_"'))，以提供默认值。无论哪种方式，为了保持事物的可读性，丑陋的细节都可以隐藏起来：

1
2
3

switch = lambda type_: eval(message.get(type_, '"unknown type_"'))

return switch(type_)

甚至可以更快地预编译代码片段：

1
2
3
4

from compiler import compile # deprecated since version 2.6: Removed in Python 3

for k in message:
message[k] = compile(message[k], 'message case', 'eval')

啊，没关系，这就解释了。我在想伊利夫http://bytebaker.com/2008/11/03/switch-case-statement-in-python/

相关讨论