blocks|key|1552048|text|下面的原始答案是在2008年写的。从那时起，Python3.10+(2021)引入了match-case语句，它为Python提供了一流的"switch“实现。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1552049|def+f(x):
++++match+x:
++++++++case+'a':
++++++++++++return+1
++++++++case+'b':
++++++++++++return+2
++++++++case+_:++++++++
++++++++++++return+0+++#+0+is+the+default+case+if+x+is+not+found|code-block|syntax|javascript|1552050|match-case语句比这个简单的示例要强大得多。|1552051|1552052|你可以使用字典：|1552053|def+f(x):
++++return+{
++++++++'a':+1,
++++++++'b':+2,
++++}[x]|1552054|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0634/^0|16|5|1C|4|16|A|0|0|0|0|5|6|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@$9|14|A|15|1|16]]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1E|8|@]|D|@]|E|$]]|$1|P|3|Q|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|R|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|S|$T|$5|U|V|W|E|$X|Y]]]]

The original answer below was written in 2008. Since then, Python 3.10 (2021) introduced the <a href="https://www.python.org/dev/peps/pep-0634/" rel="noreferrer"><code>match</code>-<code>case</code></a> statement which provides a first-class implementation of a &quot;switch&quot; for Python. For example:
<pre><code>def f(x):
 match x:
 case 'a':
 return 1
 case 'b':
 return 2
 case _: 
 return 0 # 0 is the default case if x is not found
</code></pre>
The <code>match</code>-<code>case</code> statement is considerably more powerful than this simple example.
<hr />
You could use a dictionary:
<pre><code>def f(x):
 return {
 'a': 1,
 'b': 2,
 }[x]
</code></pre>

blocks|key|1767314|text|如果您喜欢默认设置，可以使用字典get(key[,+default])方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1767315|def+f(x):
++++return+{
++++++++'a':+1,
++++++++'b':+2
++++}.get(x,+9)++++#+9+is+default+if+x+is+not+found|code-block|syntax|javascript|1767316|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/stdtypes.html#dict.get^0|G|J|G|J|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

If you like defaults, you could use the dictionary <a href="https://docs.python.org/2/library/stdtypes.html#dict.get" rel="noreferrer"><code>get(key[, default])</code></a> method:
<pre><code>def f(x):
 return {
 'a': 1,
 'b': 2
 }.get(x, 9) # 9 is default if x is not found
</code></pre>

blocks|key|1552099|text|我一直喜欢这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1552100|result+=+{
++'a':+lambda+x:+x+*+5,
++'b':+lambda+x:+x+%2B+7,
++'c':+lambda+x:+x+-+2
}[value](x)|code-block|syntax|javascript|1552101|From+here|offset|length|1552102|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.simonwillison.net/post/57956755106/switch^0|0|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

I've always liked doing it this way

<pre><code>result = {
 'a': lambda x: x * 5,
 'b': lambda x: x + 7,
 'c': lambda x: x - 2
}[value](x)
</code></pre>

<a href="http://blog.simonwillison.net/post/57956755106/switch" rel="noreferrer">From here</a>

blocks|key|1552219|text|除了字典方法(我非常喜欢，BTW)之外，您还可以使用if-elif-else来获得switch/case/default功能：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1552220|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|code-block|syntax|javascript|1552221|这当然不同于switch/case+-您不能像省略break语句那样容易出错，但您可以有一个更复杂的测试。它的格式比一系列嵌套的if更好，尽管在功能上更接近它。|1552222|entityMap^0|Q|2|T|4|Y|4|15|6|1C|4|1H|7|0|0|P|5|1S|2|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|N|$]]

In addition to the dictionary methods (which I really like, BTW), you can also use <code>if</code>-<code>elif</code>-<code>else</code> to obtain the <code>switch</code>/<code>case</code>/<code>default</code> functionality:

<pre><code>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
</code></pre>

This of course is not identical to switch/case - you cannot have fall-through as easily as leaving off the <code>break</code> statement, but you can have a more complicated test. Its formatting is nicer than a series of nested <code>if</code>s, even though functionally that's what it is closer to.

blocks|key|1552502|text|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))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1552503|用法：|unstyled|1552504|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|1552505|测试：|1552506|n+=+2
#Result:
#n+is+an+even+number.
#n+is+a+prime+number.
n+=+11
#Result:
#Only+single-digit+numbers+are+allowed.|1552507|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>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))
</code></pre>

Usage:

<pre><code>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
</code></pre>

Tests:

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

blocks|key|1767562|text|我最喜欢的是一个非常好的recipe。这是我见过的最接近实际switch+case语句的语句，尤其是在特性方面。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1767563|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|code-block|syntax|javascript|1767564|下面是一个例子：|1767565|#+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!"|1767566|一些评论表明，使用with+foo+as+case而不是for+case+in+foo的上下文管理器解决方案可能更简洁，并且对于大型切换语句，线性行为而不是二次行为可能是一种不错的做法。在这个使用for循环的答案中，部分价值是具有中断和失败的能力，如果我们愿意尝试一下我们选择的关键字，我们也可以在上下文管理器中获得它：|style|CODE|1767567|class+Switch:
++++def+__init__(self,+value):
++++++++self.value+=+value
++++++++self._entered+=+False
++++++++self._broken+=+False
++++++++self._prev+=+None

++++def+__enter__(self):
++++++++return+self

++++def+__exit__(self,+type,+value,+traceback):
++++++++return+False+#+Allows+a+traceback+to+occur

++++def+__call__(self,+*values):
++++++++if+self._broken:
++++++++++++return+False
++++++++
++++++++if+not+self._entered:
++++++++++++if+values+and+self.value+not+in+values:
++++++++++++++++return+False
++++++++++++self._entered,+self._prev+=+True,+values
++++++++++++return+True
++++++++
++++++++if+self._prev+is+None:
++++++++++++self._prev+=+values
++++++++++++return+True
++++++++
++++++++if+self._prev+!=+values:
++++++++++++self._broken+=+True
++++++++++++return+False
++++++++
++++++++if+self._prev+==+values:
++++++++++++self._prev+=+None
++++++++++++return+False
++++
++++@property
++++def+default(self):
++++++++return+self()|1767568|1767569|#+Prints+'bar'+then+'baz'.
with+Switch(2)+as+case:
++++while+case(0):
++++++++print('foo')
++++while+case(1,+2,+3):
++++++++print('bar')
++++while+case(4,+5):
++++++++print('baz')
++++++++break
++++while+case.default:
++++++++print('default')
++++++++break|1767570|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/410692/^0|C|6|0|0|0|0|0|9|G|S|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|18|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1A|8|@$A|1B|B|1C|O|P]|$A|1D|B|1E|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1F|8|@]|9|@]|C|$G|H]]|$1|S|3|J|5|6|7|1G|8|@]|9|@]|C|$]]|$1|T|3|U|5|F|7|1H|8|@]|9|@]|C|$G|H]]|$1|V|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]]]

My favorite one is a really nice <a href="http://code.activestate.com/recipes/410692/" rel="noreferrer">recipe</a>. It's the closest one I've seen to actual switch case statements, especially in features.
<pre class="lang-py prettyprint-override"><code>class switch(object):
 def __init__(self, value):
 self.value = value
 self.fall = False

 def __iter__(self):
 &quot;&quot;&quot;Return the match method once, then stop&quot;&quot;&quot;
 yield self.match
 raise StopIteration
 
 def match(self, *args):
 &quot;&quot;&quot;Indicate whether or not to enter a case suite&quot;&quot;&quot;
 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
</code></pre>
Here's an example:
<pre class="lang-py prettyprint-override"><code># 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 &quot;something else!&quot;
 # 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 &quot;c is lowercase!&quot;
 break
 if case('A'): pass
 # ...
 if case('Z'):
 print &quot;c is uppercase!&quot;
 break
 if case(): # default
 print &quot;I dunno what c was!&quot;

# 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 &quot;c is lowercase!&quot;
 break
 if case(*string.uppercase):
 print &quot;c is uppercase!&quot;
 break
 if case('!', '?', '.'): # normal argument passing style also applies
 print &quot;c is a sentence terminator!&quot;
 break
 if case(): # default
 print &quot;I dunno what c was!&quot;
</code></pre>
Some of the comments indicated that a context manager solution using <code>with foo as case</code> rather than <code>for case in foo</code> might be cleaner, and for large switch statements the linear rather than quadratic behavior might be a nice touch. Part of the value in this answer with a for loop is the ability to have breaks and fallthrough, and if we're willing to play with our choice of keywords a little bit we can get that in a context manager too:
<pre><code>class Switch:
 def __init__(self, value):
 self.value = value
 self._entered = False
 self._broken = False
 self._prev = None

 def __enter__(self):
 return self

 def __exit__(self, type, value, traceback):
 return False # Allows a traceback to occur

 def __call__(self, *values):
 if self._broken:
 return False
 
 if not self._entered:
 if values and self.value not in values:
 return False
 self._entered, self._prev = True, values
 return True
 
 if self._prev is None:
 self._prev = values
 return True
 
 if self._prev != values:
 self._broken = True
 return False
 
 if self._prev == values:
 self._prev = None
 return False
 
 @property
 def default(self):
 return self()
</code></pre>
Here's an example:
<pre><code># Prints 'bar' then 'baz'.
with Switch(2) as case:
 while case(0):
 print('foo')
 while case(1, 2, 3):
 print('bar')
 while case(4, 5):
 print('baz')
 break
 while case.default:
 print('default')
 break
</code></pre>

blocks|key|1552857|text|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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1552858|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-py prettyprint-override"><code>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
</code></pre>

blocks|key|1768198|text|我只想在这里发表我的观点。之所以在Python中没有case/switch语句，是因为Python遵循“只有一种正确的方式去做某件事”的原则。显然，您可以想出各种方法来重新创建switch/case功能，但实现这一点的Pythonic方法是if/elif结构。也就是说，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1768199|if+something:
++++return+"first+thing"
elif+somethingelse:
++++return+"second+thing"
elif+yetanotherthing:
++++return+"third+thing"
else:
++++return+"default+thing"|code-block|syntax|javascript|1768200|我只是觉得PEP+8应该在这里得到认可。Python最美的地方之一就是它的简单和优雅。这在很大程度上源于PEP+8中阐述的原则，包括“做某事只有一种正确的方法”。|offset|length|1768201|entityMap|0|LINK|mutability|MUTABLE|url|https://pep8.org/^0|0|0|5|5|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

I'm just going to drop my two cents in here. The reason there isn't a case/switch statement in Python is because Python follows the principle of &quot;there's only one right way to do something&quot;. So obviously you could come up with various ways of recreating switch/case functionality, but the Pythonic way of accomplishing this is the if/elif construct. I.e.,
<pre><code>if something:
 return &quot;first thing&quot;
elif somethingelse:
 return &quot;second thing&quot;
elif yetanotherthing:
 return &quot;third thing&quot;
else:
 return &quot;default thing&quot;
</code></pre>
I just felt <a href="https://pep8.org/" rel="nofollow noreferrer">PEP 8</a> deserved a nod here. One of the beautiful things about Python is its simplicity and elegance. That is largely derived from principles laid out in PEP 8, including &quot;There's only one right way to do something.&quot;

blocks|key|1767262|text|扩展了"dict+as+switch“的概念。如果要对交换机使用默认值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1767263|def+f(x):
++++try:
++++++++return+{
++++++++++++'a':+1,
++++++++++++'b':+2,
++++++++}[x]
++++except+KeyError:
++++++++return+'default'|code-block|syntax|javascript|1767264|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Expanding on the &quot;dict as switch&quot; idea. If you want to use a default value for your switch:
<pre><code>def f(x):
 try:
 return {
 'a': 1,
 'b': 2,
 }[x]
 except KeyError:
 return 'default'
</code></pre>

blocks|key|1552473|text|如果你正在搜索额外的语句，比如"switch"，我构建了一个扩展Python的Python模块。它被称为“ESPY的增强结构”，它在Python2.x和Python3.x上都可用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1552474|例如，在这种情况下，可以通过以下代码执行switch语句：|1552475|macro+switch(arg1):
++++while+True:
++++++++cont=False
++++++++val=%25arg1%25
++++++++socket+case(arg2):
++++++++++++if+val==%25arg2%25+or+cont:
++++++++++++++++cont=True
++++++++++++++++socket
++++++++socket+else:
++++++++++++socket
++++++++break|code-block|syntax|javascript|1552476|可以像这样使用：|1552477|a=3
switch(a):
++++case(0):
++++++++print("Zero")
++++case(1):
++++++++print("Smaller+than+2"):
++++++++break
++++else:
++++++++print+("greater+than+1")|1552478|因此，espy在Python中将其翻译为：|1552479|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|1552480|entityMap|0|LINK|mutability|MUTABLE|url|https://web.archive.org/web/20111103124355/http://elp.chronocv.fr/articles.php?lng=en&pg=19^0|1H|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

If you're searching extra-statement, as &quot;switch&quot;, I built a Python module that extends Python. It's called <a href="https://web.archive.org/web/20111103124355/http://elp.chronocv.fr/articles.php?lng=en&amp;pg=19" rel="nofollow noreferrer">ESPY</a> as &quot;Enhanced Structure for Python&quot; and it's available for both Python 2.x and Python 3.x.
For example, in this case, a switch statement could be performed by the following code:
<pre><code>macro switch(arg1):
 while True:
 cont=False
 val=%arg1%
 socket case(arg2):
 if val==%arg2% or cont:
 cont=True
 socket
 socket else:
 socket
 break
</code></pre>
That can be used like this:
<pre><code>a=3
switch(a):
 case(0):
 print(&quot;Zero&quot;)
 case(1):
 print(&quot;Smaller than 2&quot;):
 break
 else:
 print (&quot;greater than 1&quot;)
</code></pre>
So espy translate it in Python as:
<pre><code>a=3
while True:
 cont=False
 if a==0 or cont:
 cont=True
 print (&quot;Zero&quot;)
 if a==1 or cont:
 cont=True
 print (&quot;Smaller than 2&quot;)
 break
 print (&quot;greater than 1&quot;)
 break
</code></pre>

blocks|key|1767850|text|我发现了一个常见的开关结构：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1767851|switch+...parameter...
case+p1:+v1;+break;
case+p2:+v2;+break;
default:+v3;|code-block|syntax|javascript|1767852|可以用Python表达如下：|1767853|(lambda+x:+v1+if+p1(x)+else+v2+if+p2(x)+else+v3)|1767854|或者以更清晰的方式格式化：|1767855|(lambda+x:
+++++v1+if+p1(x)+else
+++++v2+if+p2(x)+else
+++++v3)|1767856|Python版本不是一个语句，而是一个表达式，它的计算结果是一个值。|1767857|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I found that a common switch structure:
<pre><code>switch ...parameter...
case p1: v1; break;
case p2: v2; break;
default: v3;
</code></pre>
can be expressed in Python as follows:
<pre><code>(lambda x: v1 if p1(x) else v2 if p2(x) else v3)
</code></pre>
or formatted in a clearer way:
<pre><code>(lambda x:
 v1 if p1(x) else
 v2 if p2(x) else
 v3)
</code></pre>
Instead of being a statement, the Python version is an expression, which evaluates to a value.

blocks|key|1552396|text|我使用的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1552397|这里发布的两个解决方案的组合，相对容易阅读，并支持默认值。|1552398|result+=+{
++'a':+lambda+x:+x+*+5,
++'b':+lambda+x:+x+%2B+7,
++'c':+lambda+x:+x+-+2
}.get(whatToUse,+lambda+x:+x+-+22)(value)|code-block|syntax|javascript|1552399|哪里|1552400|.get('c',+lambda+x:+x+-+22)(23)|1552401|在字典中查找"lambda+x:+x+-+2"并将其与x=23一起使用|offset|length|style|CODE|1552402|.get('xxx',+lambda+x:+x+-+22)(44)|1552403|在字典中找不到它，并使用x=44的默认"lambda+x:+x+-+22"。|1552404|entityMap^0|0|0|0|0|0|6|H|R|4|0|0|C|4|J|I|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@$O|14|P|15|Q|R]|$O|16|P|17|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|19|8|@$O|1A|P|1B|Q|R]|$O|1C|P|1D|Q|R]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

The solutions I use: 

A combination of 2 of the solutions posted here, which is relatively easy to read and supports defaults.

<pre><code>result = {
 'a': lambda x: x * 5,
 'b': lambda x: x + 7,
 'c': lambda x: x - 2
}.get(whatToUse, lambda x: x - 22)(value)
</code></pre>

where

<pre><code>.get('c', lambda x: x - 22)(23)
</code></pre>

looks up <code>"lambda x: x - 2"</code> in the dict and uses it with <code>x=23</code> 

<pre><code>.get('xxx', lambda x: x - 22)(44)
</code></pre>

doesn't find it in the dict and uses the default <code>"lambda x: x - 22"</code> with <code>x=44</code>.

blocks|key|1552809|text|我在谷歌搜索中找不到我想要的简单答案。但我还是想通了。这真的很简单。我决定把它贴出来，也许还能防止别人头上的抓痕。关键字是简单的"in“和元组。以下是具有落差的switch语句行为，包括随机落差。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1552810|l+=+['Dog',+'Cat',+'Bird',+'Bigfoot',
+++++'Dragonfly',+'Snake',+'Bat',+'Loch+Ness+Monster']

for+x+in+l:
++++if+x+in+('Dog',+'Cat'):
++++++++x+%2B=+"+has+four+legs"
++++elif+x+in+('Bat',+'Bird',+'Dragonfly'):
++++++++x+%2B=+"+has+wings."
++++elif+x+in+('Snake',):
++++++++x+%2B=+"+has+a+forked+tongue."
++++else:
++++++++x+%2B=+"+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)|code-block|syntax|javascript|1552811|提供：|1552812|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.|1552813|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I didn't find the simple answer I was looking for anywhere on Google search. But I figured it out anyway. It's really quite simple. Decided to post it, and maybe prevent a few less scratches on someone else's head. The key is simply "in" and tuples. Here is the switch statement behavior with fall-through, including RANDOM fall-through.

<pre><code>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)
</code></pre>

Provides:

<pre><code>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.
</code></pre>

blocks|key|1553559|text|您可以使用分派的dict：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553560|#!/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()|code-block|syntax|javascript|1553561|输出：|1553562|This+is+case+1
This+is+case+3
This+is+case+2
This+is+case+1|1553563|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can use a dispatched dict:
<pre><code>#!/usr/bin/env python


def case1():
 print(&quot;This is case 1&quot;)

def case2():
 print(&quot;This is case 2&quot;)

def case3():
 print(&quot;This is case 3&quot;)


token_dict = {
 &quot;case1&quot; : case1,
 &quot;case2&quot; : case2,
 &quot;case3&quot; : case3,
}


def main():
 cases = (&quot;case1&quot;, &quot;case3&quot;, &quot;case2&quot;, &quot;case1&quot;)
 for case in cases:
 token_dict[case]()


if __name__ == '__main__':
 main()
</code></pre>
Output:
<pre class="lang-none prettyprint-override"><code>This is case 1
This is case 3
This is case 2
This is case 1
</code></pre>

blocks|key|1552862|text|#+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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1552863|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code># simple case alternative

some_value = 5.0

# this while loop block simulates a case block

# case
while True:

 # case 1
 if some_value &gt; 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
</code></pre>

blocks|key|1768560|text|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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1768561|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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
</code></pre>

blocks|key|1768066|text|在阅读了被接受的答案后，我感到非常困惑，但这一切都清楚了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1768067|def+numbers_to_strings(argument):
++++switcher+=+{
++++++++0:+"zero",
++++++++1:+"one",
++++++++2:+"two",
++++}
++++return+switcher.get(argument,+"nothing")|code-block|syntax|javascript|1768068|此代码类似于：|1768069|function(argument){
++++switch(argument)+{
++++++++case+0:
++++++++++++return+"zero";
++++++++case+1:
++++++++++++return+"one";
++++++++case+2:
++++++++++++return+"two";
++++++++default:
++++++++++++return+"nothing";
++++}
}|1768070|有关字典映射到函数的更多信息，请查看Source。|offset|length|1768071|entityMap|0|LINK|mutability|MUTABLE|url|https://www.pydanny.com/why-doesnt-python-have-switch-case.html^0|0|0|0|0|I|6|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I was quite confused after reading the accepted answer, but this cleared it all up:
<pre><code>def numbers_to_strings(argument):
 switcher = {
 0: &quot;zero&quot;,
 1: &quot;one&quot;,
 2: &quot;two&quot;,
 }
 return switcher.get(argument, &quot;nothing&quot;)
</code></pre>
This code is analogous to:
<pre><code>function(argument){
 switch(argument) {
 case 0:
 return &quot;zero&quot;;
 case 1:
 return &quot;one&quot;;
 case 2:
 return &quot;two&quot;;
 default:
 return &quot;nothing&quot;;
 }
}
</code></pre>
Check the <a href="https://www.pydanny.com/why-doesnt-python-have-switch-case.html" rel="nofollow noreferrer">Source</a> for more about dictionary mapping to functions.

blocks|key|1552652|text|def+f(x):
+++++return+1+if+x+==+'a'+else\
++++++++++++2+if+x+in+'bcd'+else\
++++++++++++0+#default|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1552653|简短且易于阅读，具有默认值，并支持在条件和返回值中的表达式。|unstyled|1552654|然而，它的效率低于使用字典的解决方案。例如，在返回默认值之前，Python必须扫描所有条件。|1552655|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>def f(x):
 return 1 if x == 'a' else\
 2 if x in 'bcd' else\
 0 #default
</code></pre>

Short and easy to read, has a default value and supports expressions in both conditions and return values.

However, it is less efficient than the solution with a dictionary. For example, Python has to scan through all the conditions before returning the default value.

blocks|key|1768542|text|我倾向于使用的一个也使用字典的解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1768543|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)()|code-block|syntax|javascript|1768544|这样做的好处是，它不会每次都对函数求值，您只需确保外部函数获得内部函数所需的所有信息。|1768545|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A solution I tend to use which also makes use of dictionaries is:
<pre><code>def decision_time( key, *args, **kwargs):
 def action1()
 &quot;&quot;&quot;This function is a closure - and has access to all the arguments&quot;&quot;&quot;
 pass
 def action2()
 &quot;&quot;&quot;This function is a closure - and has access to all the arguments&quot;&quot;&quot;
 pass
 def action3()
 &quot;&quot;&quot;This function is a closure - and has access to all the arguments&quot;&quot;&quot;
 pass

 return {1:action1, 2:action2, 3:action3}.get(key,default)()
</code></pre>
This has the advantage that it doesn't try to evaluate the functions every time, and you just have to ensure that the outer function gets all the information that the inner functions need.

blocks|key|1767771|text|定义：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1767772|def+switch1(value,+options):
++if+value+in+options:
++++options[value]()|code-block|syntax|javascript|1767773|允许您使用相当简单的语法，将案例捆绑到一个映射中：|1767774|def+sample1(x):
++local+=+'betty'
++switch1(x,+{
++++'a':+lambda:+print("hello"),
++++'b':+lambda:+(
++++++print("goodbye,"+%2B+local),
++++++print("!")),
++++})|1767775|我一直试图以一种让我摆脱"lambda:“的方式重新定义switch，但最终放弃了。调整定义：|1767776|def+switch(value,+*maps):
++options+=+{}
++for+m+in+maps:
++++options.update(m)
++if+value+in+options:
++++options[value]()
++elif+None+in+options:
++++options[None]()|1767777|允许我将多个案例映射到相同的代码，并提供一个默认选项：|1767778|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")
++++})|1767779|每个复制的案例都必须在其自己的字典中；switch()在查找值之前合并字典。它仍然比我希望的要难看，但它具有对表达式使用散列查找的基本效率，而不是遍历所有键。|1767780|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Defining:

<pre><code>def switch1(value, options):
 if value in options:
 options[value]()
</code></pre>

allows you to use a fairly straightforward syntax, with the cases bundled into a map:

<pre><code>def sample1(x):
 local = 'betty'
 switch1(x, {
 'a': lambda: print("hello"),
 'b': lambda: (
 print("goodbye," + local),
 print("!")),
 })
</code></pre>

I kept trying to redefine switch in a way that would let me get rid of the "lambda:", but gave up. Tweaking the definition:

<pre><code>def switch(value, *maps):
 options = {}
 for m in maps:
 options.update(m)
 if value in options:
 options[value]()
 elif None in options:
 options[None]()
</code></pre>

Allowed me to map multiple cases to the same code, and to supply a default option:

<pre><code>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")
 })
</code></pre>

Each replicated case has to be in its own dictionary; switch() consolidates the dictionaries before looking up the value. It's still uglier than I'd like, but it has the basic efficiency of using a hashed lookup on the expression, rather than a loop through all the keys.

blocks|key|1767986|text|在Greg+Hewgill's+answer上扩展-我们可以使用装饰器封装字典解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1767987|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|code-block|syntax|javascript|1767988|然后可以将其与@case-decorator一起使用|style|CODE|1767989|@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|1767990|好消息是，在NeoPySwitch-module中已经做到了这一点。只需使用pip进行安装：|1767991|pip+install+NeoPySwitch|1767992|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/60211/3106539|1|https://pypi.python.org/pypi/NeoPySwitch/0.2.0^0|1|L|0|0|0|7|5|0|0|6|B|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@$A|18|B|19|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|Q|3|R|5|F|7|1F|8|@]|9|@]|C|$G|H]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

Expanding on <a href="https://stackoverflow.com/a/60211/3106539">Greg Hewgill's answer</a> - We can encapsulate the dictionary-solution using a decorator:

<pre><code>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
</code></pre>

This can then be used with the <code>@case</code>-decorator

<pre><code>@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
</code></pre>

The good news are that this has already been done in <a href="https://pypi.python.org/pypi/NeoPySwitch/0.2.0" rel="nofollow noreferrer">NeoPySwitch</a>-module. Simply install using pip:

<pre><code>pip install NeoPySwitch
</code></pre>

blocks|key|1767934|text|如果您不担心丢失case套件中的语法突出显示，您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1767935|exec+{
++++1:+"""
print+('one')
""",+
++++2:+"""
print+('two')
""",+
++++3:+"""
print+('three')
""",
}.get(value,+"""
print+('None')
""")|code-block|syntax|javascript|1767936|其中value是值。在C中，这将是：|offset|length|style|CODE|1767937|switch+(value)+{
++++case+1:
++++++++printf("one");
++++++++break;
++++case+2:
++++++++printf("two");
++++++++break;
++++case+3:
++++++++printf("three");
++++++++break;
++++default:
++++++++printf("None");
++++++++break;
}|1767938|我们也可以创建一个helper函数来做这件事：|1767939|def+switch(value,+cases,+default):
++++exec+cases.get(value,+default)|1767940|因此，我们可以像这样将其用于具有1、2和3的示例：|1767941|switch(value,+{
++++1:+"""
print+('one')
++++""",+
++++2:+"""
print+('two')
++++""",+
++++3:+"""
print+('three')
++++""",
},+"""
print+('None')
""")|1767942|entityMap^0|0|0|2|5|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

If you don't worry losing syntax highlight inside the case suites, you can do the following:

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

Where <code>value</code> is the value. In C, this would be:

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

We can also create a helper function to do this:

<pre><code>def switch(value, cases, default):
 exec cases.get(value, default)
</code></pre>

So we can use it like this for the example with one, two and three:

<pre><code>switch(value, {
 1: """
print ('one')
 """, 
 2: """
print ('two')
 """, 
 3: """
print ('three')
 """,
}, """
print ('None')
""")
</code></pre>

blocks|key|1767696|text|正如大多数人使用dict所展示的那样，只是将一些键映射到一些代码并不是一个真正的问题。真正的诀窍是试图模仿整个跌破和破解的过程。我想我从来没有写过一个案例陈述，我使用过这个“特性”。这是drop+through的一次尝试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1767697|def+case(list):+reduce(lambda+b,+f:+(b+%7C+f[0],+{False:(lambda:None),True:f[1]}[b+%7C+f[0]]())[0],+list,+False)

case([
++++(False,+lambda:print(5)),
++++(True,+lambda:print(4))
])|code-block|syntax|javascript|1767698|我真的把它想象成一句话。我希望你能原谅这种愚蠢的格式。|1767699|reduce(
++++initializer=False,
++++function=(lambda+b,+f:
++++++++(+b+%7C+f[0]
++++++++,+{+False:+(lambda:None)
++++++++++,+True+:+f[1]
++++++++++}[b+%7C+f[0]]()
++++++++)[0]
++++),
++++iterable=[
++++++++(False,+lambda:print(5)),
++++++++(True,+lambda:print(4))
++++]
)|1767700|我希望这是有效的Python代码。它应该会让你中途放弃。当然，布尔检查可以是表达式，如果您希望延迟计算它们，可以将它们都包装在一个lambda中。在执行列表中的一些项之后，让它接受也不难。只需创建元组(+bool，bool，function)，其中第二个bool表示是否中断或丢弃。|1767701|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Just mapping some a key to some code is not really an issue as most people have shown using the dict. The real trick is trying to emulate the whole drop through and break thing. I don't think I've ever written a case statement where I used that &quot;feature&quot;. Here's a go at drop through.
<pre><code>def case(list): reduce(lambda b, f: (b | f[0], {False:(lambda:None),True:f[1]}[b | f[0]]())[0], list, False)

case([
 (False, lambda:print(5)),
 (True, lambda:print(4))
])
</code></pre>
I was really imagining it as a single statement. I hope you'll pardon the silly formatting.
<pre><code>reduce(
 initializer=False,
 function=(lambda b, f:
 ( b | f[0]
 , { False: (lambda:None)
 , True : f[1]
 }[b | f[0]]()
 )[0]
 ),
 iterable=[
 (False, lambda:print(5)),
 (True, lambda:print(4))
 ]
)
</code></pre>
I hope that's valid Python code. It should give you drop through. Of course the Boolean checks could be expressions and if you wanted them to be evaluated lazily you could wrap them all in a lambda. It wouldn't be to hard to make it accept after executing some of the items in the list either. Just make the tuple (bool, bool, function) where the second bool indicates whether or not to break or drop through.

blocks|key|1552169|text|如果您真的只是返回一个预定的固定值，那么您可以创建一个字典，将所有可能的输入索引及其相应值作为键。而且，你可能并不真的想要一个函数来做这件事--除非你以某种方式计算返回值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1552170|哦，如果你想做一些类似switch的事情，请参见here。|offset|length|1552171|entityMap|0|LINK|mutability|MUTABLE|url|https://web.archive.org/web/20120216013404/http://www.mustap.com/pythonzone_post_224_python-switch-statement?^0|0|O|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

If you are really just returning a predetermined, fixed value, you could create a dictionary with all possible input indexes as the keys, along with their corresponding values. Also, you might not really want a function to do this - unless you're computing the return value somehow.

Oh, and if you feel like doing something switch-like, see <a href="https://web.archive.org/web/20120216013404/http://www.mustap.com/pythonzone_post_224_python-switch-statement?" rel="nofollow noreferrer">here</a>.

blocks|key|1553390|text|虽然已经有了足够的答案，但我想指出一个更简单、更强大的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553391|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))|code-block|syntax|javascript|1553392|输出：|1553393|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|1553394|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Although there are already enough answers, I want to point a simpler and more powerful solution:
<pre><code>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] &lt;= x &lt; 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))
</code></pre>
Output:
<pre class="lang-none prettyprint-override"><code>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
</code></pre>

blocks|key|1768453|text|与this+answer+by+abarnert类似，这里有一个专门针对这样的用例的解决方案:为开关中的每个“case”调用一个函数，同时避免使用lambda或partial以实现超级简洁，同时仍然能够处理关键字参数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1768454|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|code-block|syntax|javascript|1768455|示例用法：|1768456|def+add(a,+b):
++++return+a+%2B+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)|1768457|请注意，这是链接调用，即switch(3)(...)(...)(...)。不要把逗号放在中间。将所有内容放在一个表达式中也很重要，这就是为什么我在主调用两边使用了额外的圆括号来隐式行接续。|1768458|如果您打开一个未处理的值，例如switch(5)(1,+...)(2,+...)(3,+...)，上面的示例将引发错误。您可以提供默认值，例如switch(5,+default=-1)...返回-1。|1768459|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/50686874/2482744^0|21|6|28|7|1|N|0|0|0|0|0|C|O|0|F|X|1Z|O|2P|2|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

Similar to <a href="https://stackoverflow.com/a/50686874/2482744">this answer by abarnert</a>, here is a solution specifically for the use case of calling a single function for each 'case' in the switch, while avoiding the <code>lambda</code> or <code>partial</code> for ultra-conciseness while still being able to handle keyword arguments:

<pre><code>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
</code></pre>

Example usage:

<pre><code>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)
</code></pre>

Note that this is chaining calls, i.e. <code>switch(3)(...)(...)(...)</code>. Don't put commas in between. It's also important to put it all in one expression, which is why I've used extra parentheses around the main call for implicit line continuation.

The above example will raise an error if you switch on a value that is not handled, e.g. <code>switch(5)(1, ...)(2, ...)(3, ...)</code>. You can provide a default value instead, e.g. <code>switch(5, default=-1)...</code> returns <code>-1</code>.

blocks|key|1553305|text|当我需要一个简单的切换用例来调用一组方法，而不仅仅是打印一些文本时，下面的方法适用于我的情况。在使用了lambda和globals之后，它给了我到目前为止最简单的选择。也许它也会帮助一些人：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553306|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|code-block|syntax|javascript|1553307|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The following works for my situation when I need a simple switch-case to call a bunch of methods and not to just print some text. After playing with lambda and globals it hit me as the simplest option for me so far. Maybe it will help someone also:

<pre><code>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
</code></pre>

blocks|key|1768343|text|还有另一种选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1768344|def+fnc_MonthSwitch(int_Month):+####+Define+a+function+take+in+the+month+variable+
++++str_Return+="Not+Found"+++++####+Set+Default+Value+
++++if+int_Month==1:+++++++str_Return+=+"Jan"+++
++++if+int_Month==2:+++++++str_Return+=+"Feb"+++
++++if+int_Month==3:+++++++str_Return+=+"Mar"+++
++++return+str_Return;++++++++++####+Return+the+month+found++
print+("Month+Test+3:++"+%2B+fnc_MonthSwitch(+3)+)
print+("Month+Test+14:+"+%2B+fnc_MonthSwitch(14)+)|code-block|syntax|javascript|1768345|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

And another option: 

<pre><code>def fnc_MonthSwitch(int_Month): #### Define a function take in the month variable 
 str_Return ="Not Found" #### Set Default Value 
 if int_Month==1: str_Return = "Jan" 
 if int_Month==2: str_Return = "Feb" 
 if int_Month==3: str_Return = "Mar" 
 return str_Return; #### Return the month found 
print ("Month Test 3: " + fnc_MonthSwitch( 3) )
print ("Month Test 14: " + fnc_MonthSwitch(14) )
</code></pre>

blocks|key|1553156|text|switch语句只是if/elif/else的语法糖。任何控制语句所做的都是根据特定的条件委托作业-决策路径。为了将其封装到模块中并能够基于其唯一id调用作业，可以使用继承和Python中任何方法都是虚拟的这一事实，以提供派生类特定的作业实现，作为特定的"case“处理程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553157|#!/usr/bin/python

import+sys

class+Case(object):
++++"""
++++++++Base+class+which+specifies+the+interface+for+the+"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+overridden
++++++++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+which+delegates+the+jobs
++++++++based+on+the+given+job+id
++++"""
++++def+__init__(self,+cases):
++++++++self.cases+=+cases+#+dictionary:+time+complexity+for+the+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)|code-block|syntax|javascript|1553158|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A switch statement is just syntactic sugar for if/elif/else.
What any control statement is doing is delegating the job based on certain condition is being fulfilled - decision path. For wrapping that into a module and being able to call a job based on its unique id, one can use inheritance and the fact that any method in Python is virtual, to provide the derived class specific job implementation, as a specific &quot;case&quot; handler:
<pre><code>#!/usr/bin/python

import sys

class Case(object):
 &quot;&quot;&quot;
 Base class which specifies the interface for the &quot;case&quot; handler.
 The all required arbitrary arguments inside &quot;execute&quot; method will be
 provided through the derived class
 specific constructor

 @note in Python, all class methods are virtual
 &quot;&quot;&quot;
 def __init__(self, id):
 self.id = id

 def pair(self):
 &quot;&quot;&quot;
 Pairs the given id of the &quot;case&quot; with
 the instance on which &quot;execute&quot; will be called
 &quot;&quot;&quot;
 return (self.id, self)

 def execute(self): # Base class virtual method that needs to be overridden
 pass

class Case1(Case):
 def __init__(self, id, msg):
 self.id = id
 self.msg = msg
 def execute(self): # Override the base class method
 print(&quot;&lt;Case1&gt; id={}, message: \&quot;{}\&quot;&quot;.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(&quot;&lt;Case2&gt; id={}, n={}.&quot;.format(str(self.id), str(self.n)))
 print(&quot;\n&quot;.join(map(str, range(self.n))))


class Switch(object):
 &quot;&quot;&quot;
 The class which delegates the jobs
 based on the given job id
 &quot;&quot;&quot;
 def __init__(self, cases):
 self.cases = cases # dictionary: time complexity for the access operation is 1
 def resolve(self, id):

 try:
 cases[id].execute()
 except KeyError as e:
 print(&quot;Given id: {} is wrong!&quot;.format(str(id)))



if __name__ == '__main__':

 # Cases
 cases=dict([Case1(0, &quot;switch&quot;).pair(), Case2(1, 5).pair()])

 switch = Switch(cases)

 # id will be dynamically specified
 switch.resolve(0)
 switch.resolve(1)
 switch.resolve(2)
</code></pre>

I want to write a function in Python that returns different fixed values based on the value of an input index. 

In other languages I would use a <code>switch</code> or <code>case</code> statement, but Python does not appear to have a <code>switch</code> statement. What are the recommended Python solutions in this scenario?

Replacements for switch statement in Python?

Python

我想用Python编写一个函数，根据输入索引值返回不同的固定值。在其他语言中，我会使用switch或case语句，但是Python语言似乎没有switch语句。在此场景中，推荐的Python解决方案是什么？

问Python中switch语句的替换？
EN

回答 29

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中switch语句的替换？EN

回答 29

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中switch语句的替换？
EN