pythonswitchlambda

⑴ python程序中什麼語句也不寫，為什麼thread.active_count()等於2

同於我用過的其它編程語言，Python 沒有 switch / case 語句。為了實現它，我們可以使用字典映射：

這段代碼類似於：

Python 代碼通常比處理 case 的標准方法更為簡短，也可以說它更難理解。當我初次使用 Python 時，感覺很奇怪並且心煩意亂。而隨著時間的推移，在 switch 中使用字典的 key 來做標識符變得越來越習以為常。
函數的字典映射
在 Python 中字典映射也可以包含函數或者 lambda 表達式：

雖然 zero 和 one 中的代碼很簡單，但是很多 Python 程序使用這樣的字典映射來調度復雜的流程。
類的調度方法
如果在一個類中，不確定要使用哪種方法，可以用一個調度方法在運行的時候來確定。

很靈活，對吧？
官方說明
官方文檔的解釋說，「用if... elif... elif... else序列很容易來實現 switch / case 語句」。而且可以使用函數字典映射和類的調度方法。

⑵ 為什麼Python中沒有Switch/Case語句

不同於我用過的其它編程語言，Python 沒有 switch / case 語句。為了實現它，我們可以使用字典映射：

Python

1
2
3
4
5
6
7

def numbers_to_strings(argument):
switcher = {
0: "zero",
1: "one",
2: "two",
}
return switcher.get(argument, "nothing")

這段代碼類似於：

Python

1
2
3
4
5
6
7
8
9
10
11
12

function(argument){
switch(argument) {
case 0:
return "zero";
case 1:
return "one";
case 2:
return "two";
default:
return "nothing";
};
};

Python 代碼通常比處理 case 的標准方法更為簡短，也可以說它更難理解。當我初次使用 Python 時，感覺很奇怪並且心煩意亂。而隨著時間的推移，在 switch 中使用字典的 key 來做標識符變得越來越習以為常。
函數的字典映射
在 Python 中字典映射也可以包含函數或者 lambda 表達式：

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def zero():
return "zero"

def one():
return "one"

def numbers_to_functions_to_strings(argument):
switcher = {
0: zero,
1: one,
2: lambda: "two",
}
# Get the function from switcher dictionary
func = switcher.get(argument, lambda: "nothing")
# Execute the function
return func()

雖然 zero 和 one 中的代碼很簡單，但是很多 Python 程序使用這樣的字典映射來調度復雜的流程。
類的調度方法
如果在一個類中，不確定要使用哪種方法，可以用一個調度方法在運行的時候來確定。

Python

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

class Switcher(object):
def numbers_to_methods_to_strings(self, argument):
"""Dispatch method"""
# prefix the method_name with 'number_' because method names
# cannot begin with an integer.
method_name = 'number_' + str(argument)
# Get the method from 'self'. Default to a lambda.
method = getattr(self, method_name, lambda: "nothing")
# Call the method as we return it
return method()

def number_0(self):
return "zero"

def number_1(self):
return "one"

def number_2(self):
return "two"

很靈活，對吧？
官方說明
官方的解釋說，「用if... elif... elif... else序列很容易來實現 switch / case 語句」。而且可以使用函數字典映射和類的調度方法。
可以說官方的說明並沒有解釋什麼，只是給出了解決方案。換句話說，沒有回答為什麼。我認為其實官方真正想說的是：「Python 不需要 switch / case 語句」。
真的是這樣嗎？
是的。但是還有別的原因。我聽牛人說過，在代碼中 switch/case 語句真的很難調試。
就我個人而言，我發現當運行到大量嵌套的用作代碼分支映射的字典里，上述說法就站不住腳了。想想吧，一個超過100條語句的嵌套字典，和一個嵌套100個以上 case 的 switch/case 代碼塊一樣，都是難以調試的。
字典映射運行更快？
Python 沒有 case 語句，使用其它語言的衡量標準是沒有意義的，因為在某種語言中運行更快並不意味著在另一種語言中也一樣。讓我們繼續。
Python 實現方法的顯著優點
有時候我會遇到 Python 的實現方法比 switch/case 語句更好用的情況，例如在運行的時候，需要從映射里添加或者刪除一些潛在的選項。每當這時，多年來使用字典映射和調度方法的實踐讓我受益匪淺。現在我覺得，我再也無法回到依賴 switch/case 語句的日子了。
結束語
Python 迫使我積累了很多映射的實踐經驗，對我來說是塞翁失馬，焉知非福。沒有 switch/case 語句可用的約束，促使我想到了可能不會用來開發的方法和主意。
有意或無意中，Python 沒有 switch/case 語句已成為一種社會建構，並讓我成為一個更優秀的程序員。
綜上所述，所以我認為這種意外的社會構建解釋比官方的「用這個來代替」的說明要好得多。

⑶ Python中為什麼沒有switch語法結構，有什麼代替方案嗎

switch的作用是「根據不同的鍵執行不同的流程」。
python希望你改成「根據不同的鍵，執行不同的函數」，
用一個字典代替，比如
d={1:函數1,2:函數2, 3:函數3}
然後用
d[k]();#這一句來代替switch;
函數可以帶參數，可以用lambda簡寫。
砍掉switch是為了實踐python的以唯一的一種較優方法來解決問題的理念
因為python認為switch多餘不夠優。

⑷ python如下的列表如何實現循環

printMainMenu()
input=raw_input()
ifinput=="1":
display_all_food()
elifinput=="2":
food_management()
elifinput=="3":
client_management()
elifinput=="0":
quit()
else:
print"wronginput"

⑸ Python lambda ， 使用lambda可以做到把X,Y的值交換嗎

lambda 是匿名函數，除了匿名 其他和函數是一樣的。x, y 的值 可能是可變類型，也可能是不可變類型。

#比如
defswitch(x,y):
x,y=y,x
#so....

⑹ python中的字典實現switch功能

#coding:utf-8

from__future__importdivision

result={
'+':lambdax,y:x+y,
'-':lambdax,y:x-y,
'*':lambdax,y:x*y,
'/':lambdax,y:x/y,
}
x=raw_input("輸入第一個數字：")
z=raw_input("輸入運算符：")
y=raw_input("輸入第二個數字：")
print"=",result.get(z)(int(x),int(y))

⑺ 我為什麼要學習python

首先我們來聽聽圖靈獎獲獎得主,Allan Perlis，說過的話，「如果一門語言沒有改變你的編程思維，那麼它不值得你去學習」。 如果這么說，我們大學的時候，學習了c，c++，java，C#，算是值得學習么？很多時候是不值得，我覺得我們大學的課程就是用java，c#，c++把"C程序設計"又上了一遍. 這是因為，學校的老師會C和java之類的，所以要跟著規矩開這門課，（這也就是為什麼，許多學校還在教vb，）,這也就是為什麼，你所以為的一樣就是大家都有For都有while，都有switch..都有Class...都有int 都有float,所謂的不一樣就是用C有指針，java沒有，這就是為什麼教育是失敗的，這也就是為什麼，我目前認識的幾個編程大牛，都不是計算機專業畢業的... python的優點： 簡單 我所說的簡單，是相比於象C和C++這樣的語言,你為了編程，要學習許多偏底層的東西. 在比如，你在學習一個新的編程範式，或者想要馬上做個例子看看，試驗某個API,如果你是寫java的，你不得不去寫一個main，寫一些構造，即使有IDE這樣的東西，能夠為你帶來代碼生成器，而我做得就是寫一段「腳本」，或者打開python互動式解釋器就行了。 這在寫演算法時就能夠表現出來，比如我要寫一個快速排序： 如果用C語言寫:void q_sort(int numbers[], int left, int right) { int pivot, l_hold, r_hold; l_hold = left; r_hold = right; pivot = numbers[left]; while (left < right) { while ((numbers[right] >= pivot) && (left < right)) right--; if (left != right) { numbers[left] = numbers[right]; left++; } while ((numbers[left] <= pivot) && (left < right)) left++; if (left != right) { numbers[right] = numbers[left]; right--; } } numbers[left] = pivot; pivot = left; left = l_hold; right = r_hold; if (left < pivot) q_sort(numbers, left, pivot-1); if (right > pivot) q_sort(numbers, pivot+1, right); } 為什麼這么長？因為除了表達快速排序的思想，你還要寫數組分區，swap交換，for i,j的多一少一，都可能出現錯誤.... def qsort(lis): if len(lis) == 0: return [] else: low = [] hig = [] for x in lis[1:]: if x < lis[0]: low.append(x) else: hig.append(x) low = qsort(low) hig = qsort(hig) return low+lis[:1]+hig 當然高手可以寫的更短: def qsort(L): if not L: return [] return qsort([x for x in L[1:] if x< L[0]]) + L[0:1] + qsort([x for x in L[1:] if x>=L[0]]) 因為動態語言，在使用上，比靜態語言要活，你可以自由的表達，但是如果是用java，C++這樣的靜態語言，想要表達自己的思想， 就沒有那麼容易. 學習曲線python很值得你去深入研究，因為你玩得越熟，它給你所帶來的回報越高，人們常說，java初學者和java大師寫出的代碼差不多，但是python初學者，python高手寫出來的代碼，簡直就是天壤之別。 就拿簡單的階乘函數吧. 新手可以這么寫: def factorial(x): if x == 0: return 1 else: return x * factorial(x - 1) 高手這么寫: f = lambda x: x and x * f(x - 1) or 1 FP函數式編程 python是面向對象的，也可以面向過程 但下面我們用「函數式編程」來談談它的好處 下面是一個計算器的例子，《大話設計模式》的第一章，就是使用這個例子來闡述oop和設計模式的強大， 首先一種被認為糟糕的寫法是這樣的: (以下代碼來自啄木鳥社區，如果有版權問題，請告訴我，我馬上刪除)public class Calculator { static public double Foo(char op, double x, double y) { switch(op) case '+': return x+y; break; case '-': return x-y; break; case '*': return x*y; break; case '/': return x/y; break; default: throw new Exception("?") } } 恩，不可重用，不可維護，不可擴展，不夠靈活。 那些相信「設計模式」和java的狂熱分子，要開始改這個代碼了. 先來一個介面:

⑻ Python中為什麼沒有switch語法結構，有什麼代替方案嗎

switch的作用是「根據不同的鍵執行不同的流程」。
python希望你改成「根據不同的鍵，執行不同的函數」，
用一個字典代替，比如
d={1:函數1,2:函數2, 3:函數3}

然後用
d[k]();#這一句來代替switch;
函數可以帶參數，可以用lambda簡寫。

砍掉switch是為了實踐python的以唯一的一種較優方法來解決問題的理念
因為python認為switch多餘不夠優。

⑼ Python中字典創建、遍歷、添加等實用操作技巧合集

欄位是Python是字典中唯一的鍵-值類型，是Python中非常重要的數據結構，因其用哈希的方式存儲數據，其復雜度為O(1)，速度非常快。下面列出字典的常用的用途.
一、字典中常見方法列表
代碼如下:
#方法
#描述
-------------------------------------------------------------------------------------------------
D.clear()
#移除D中的所有項
D.()
#返回D的副本
D.fromkeys(seq[,val])
#返回從seq中獲得的鍵和被設置為val的值的字典。可做類方法調用
D.get(key[,default])
#如果D[key]存在，將其返回;否則返回給定的默認值None
D.has_key(key)
#檢查D是否有給定鍵key
D.items()
#返回表示D項的(鍵，值)對列表
D.iteritems()
#從D.items()返回的(鍵，值)對中返回一個可迭代的對象
D.iterkeys()
#從D的鍵中返回一個可迭代對象
D.itervalues()
#從D的值中返回一個可迭代對象
D.keys()
#返回D鍵的列表
D.pop(key[,d])
#移除並且返回對應給定鍵key或給定的默認值D的值
D.popitem()
#從D中移除任意一項，並將其作為(鍵，值)對返回
D.setdefault(key[,default])
#如果D[key]存在則將其返回;否則返回默認值None
D.update(other)
#將other中的每一項加入到D中。
D.values()
#返回D中值的列表
二、創建字典的五種方法
方法一:
常規方法
代碼如下:
#
如果事先能拼出整個字典，則此方法比較方便
>>>
D1
=
{'name':'Bob','age':40}
方法二:
動態創建

代碼如下:
#
如果需要動態地建立字典的一個欄位，則此方法比較方便
>>>
D2
=
{}
>>>
D2['name']
=
'Bob'
>>>
D2['age']
=
40
>>>
D2
{'age':
40,
'name':
'Bob'}
方法三:
dict--關鍵字形式
代碼如下:
#
代碼比較少，但鍵必須為字元串型。常用於函數賦值
>>>
D3
=
dict(name='Bob',age=45)
>>>
D3
{'age':
45,
'name':
'Bob'}
方法四:
dict--鍵值序列
代碼如下:
#
如果需要將鍵值逐步建成序列，則此方式比較有用,常與zip函數一起使用
>>>
D4
=
dict([('name','Bob'),('age',40)])
>>>
D4
{'age':
40,
'name':
'Bob'}
或
代碼如下:
>>>
D
=
dict(zip(('name','bob'),('age',40)))
>>>
D
{'bob':
40,
'name':
'age'}
方法五:
dict--fromkeys方法#
如果鍵的值都相同的話,用這種方式比較好，並可以用fromkeys來初始化

代碼如下:
>>>
D5
=
dict.fromkeys(['A','B'],0)
>>>
D5
{'A':
0,
'B':
0}
如果鍵的值沒提供的話，默認為None
代碼如下:
>>>
D3
=
dict.fromkeys(['A','B'])
>>>
D3
{'A':
None,
'B':
None}
三、字典中鍵值遍歷方法

代碼如下:
>>>
D
=
{'x':1,
'y':2,
'z':3}
#
方法一
>>>
for
key
in
D:
print
key,
'=>',
D[key]
y
=>
2
x
=>
1
z
=>
3
>>>
for
key,
value
in
D.items():
#
方法二
print
key,
'=>',
value
y
=>
2
x
=>
1
z
=>
3
>>>
for
key
in
D.iterkeys():
#
方法三
print
key,
'=>',
D[key]
y
=>
2
x
=>
1
z
=>
3
>>>
for
value
in
D.values():
#
方法四
print
value
2
1
3
>>>
for
key,
value
in
D.iteritems():
#
方法五
print
key,
'=>',
value
y
=>
2
x
=>
1
z
=>
3
Note:用D.iteritems(),
D.iterkeys()的方法要比沒有iter的快的多。
四、字典的常用用途之一代替switch
在C/C++/Java語言中，有個很方便的函數switch，比如:
代碼如下:
public
class
test
{
public
static
void
main(String[]
args)
{
String
s
=
"C";
switch
(s){
case
"A":
System.out.println("A");
break;
case
"B":
System.out.println("B");
break;
case
"C":
System.out.println("C");
break;
default:
System.out.println("D");
}
}
}
在Python中要實現同樣的功能，
方法一，就是用if,
else語句來實現，比如:

代碼如下:
from
__future__
import
division
def
add(x,
y):
return
x
+
y
def
sub(x,
y):
return
x
-
y
def
mul(x,
y):
return
x
*
y
def
div(x,
y):
return
x
/
y
def
operator(x,
y,
sep='+'):
if
sep
==
'+':
print
add(x,
y)
elif
sep
==
'-':
print
sub(x,
y)
elif
sep
==
'*':
print
mul(x,
y)
elif
sep
==
'/':
print
div(x,
y)
else:
print
'Something
Wrong'
print
__name__
if
__name__
==
'__main__':
x
=
int(raw_input("Enter
the
1st
number:
"))
y
=
int(raw_input("Enter
the
2nd
number:
"))
s
=
raw_input("Enter
operation
here(+
-
*
/):
")
operator(x,
y,
s)
方法二，用字典來巧妙實現同樣的switch的功能，比如:

代碼如下:
#coding=gbk
from
__future__
import
division
x
=
int(raw_input("Enter
the
1st
number:
"))
y
=
int(raw_input("Enter
the
2nd
number:
"))
def
operator(o):
dict_oper
=
{
'+':
lambda
x,
y:
x
+
y,
'-':
lambda
x,
y:
x
-
y,
'*':
lambda
x,
y:
x
*
y,
'/':
lambda
x,
y:
x
/
y}
return
dict_oper.get(o)(x,
y)
if
__name__
==
'__main__':
o
=
raw_input("Enter
operation
here(+
-
*
/):
")
print
operator(o)

⑽ 各位有沒有經歷過Python和Ruby的選擇

1. ruby的case可以匹配很多東西：范圍/數組，對象，正則表達，python沒有case/switch而使用if/else比較死板點
2. python的縮進很漂亮，雖然有時會造成些許麻煩。ruby的end蠻難看的，所以大家都被逼當one liner（玩笑）
3. 感覺上ruby比python更OO,當然這也可能是因為python不提倡用那些改變對象內部構造的『伎倆』造成的錯覺
4. python有list comprehension, ruby沒有:(
5. python有真正的keyword argument, ruby用hash模擬，當然實際用起來沒什麼差別
6. python的self很討厭，ruby沒有那種繁瑣的東西
7. reflection，ruby內置了很多方法，比如object.methods，而python把這些信息存在特殊的字典里。差不多
8. ruby的block功能很強，python的lambda只能返回單一值
9. ruby的open class已經聲明遠播，可以玩出2.days.ago這樣的花樣，python好像沒法直接修改內置類也反對這么做。
10. python需要用@classmethod修飾聲明類方法，ruby是內建
11. ruby有單子方法，也就對對象單獨定製，python不知道有沒有類似概念