python面試題精選

1、問題1到底什么是Python？你可以在回答中與其他技術(shù)進行對比（也鼓勵這樣做）。答案下面是一些關(guān)鍵點：· Python是一種解釋型語言,Python代碼在運行之前不需要編譯。· Python是動態(tài)類型語言，在聲明變量時，不需要說明變量的類型。· Python非常適合面向?qū)ο蟮木幊蹋∣OP），因為它支持通過組合（composition）與繼承（inheritance）的方式定義類（class）。Python中沒有訪問說明符public和private，· 在Python語言中，函數(shù)是第一類對象（first-class objects）。這指的是它們可以被指

2、定給變量，函數(shù)既能返回函數(shù)類型，也可以接受函數(shù)作為輸入。類（class）也是第一類對象。· Python代碼編寫快，但是運行速度比編譯語言通常要慢。ython允許加入基于C語言編寫的擴展，因此我們能夠優(yōu)化代碼，消除瓶頸，這點通常是可以實現(xiàn)的。numpy就是一個很好地例子，它的運行速度真的非?？?，因為很多算術(shù)運算其實并不是通過Python實現(xiàn)的。· Python用途非常廣泛網(wǎng)絡應用，自動化，科學建模，大數(shù)據(jù)應用，等等。它也常被用作“膠水語言”，幫助其他語言和組件改善運行狀況。· Python讓困難的事情變得容易，因此程序員可以專注于算法和數(shù)據(jù)結(jié)構(gòu)的設計，而不用處理底

3、層的細節(jié)。問題2補充缺失的代碼def print_directory_contents(sPath): """ 這個函數(shù)接受文件夾的名稱作為輸入?yún)?shù)， 返回該文件夾中文件的路徑， 以及其包含文件夾中文件的路徑。 """ # 補充代碼答案def print_directory_contents(sPath): import os for sChild in os.listdir(sPath): sChildPath = os.path.join(sPath,sChild) if os.path.isdir(sChildPath): pr

4、int_directory_contents(sChildPath) else: print sChildPath特別要注意以下幾點：· 命名規(guī)范要統(tǒng)一。如果樣本代碼中能夠看出命名規(guī)范，遵循其已有的規(guī)范。· 遞歸函數(shù)需要遞歸并終止。確保你明白其中的原理，否則你將面臨無休無止的調(diào)用棧（callstack）。· 我們使用os模塊與操作系統(tǒng)進行交互，同時做到交互方式是可以跨平臺的。你可以把代碼寫成sChildPath = sPath + '/' + sChild，但是這個在Windows系統(tǒng)上會出錯。· 熟悉基礎模塊是非常有價值的，但是別想破腦

5、袋都背下來，記住Google是你工作中的良師益友。· 如果你不明白代碼的預期功能，就大膽提問。· 堅持KISS原則！保持簡單，不過腦子就能懂！為什么提這個問題：· 說明面試者對與操作系統(tǒng)交互的基礎知識· 遞歸真是太好用啦問題3閱讀下面的代碼，寫出A0，A1至An的最終值。A0 = dict(zip('a','b','c','d','e'),(1,2,3,4,5)A1 = range(10)A2 = i for i in A1 if i in A0A3 = A0s for s

6、in A0A4 = i for i in A1 if i in A3A5 = i:i*i for i in A1A6 = i,i*i for i in A1答案A0 = 'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4A1 = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9A2 = A3 = 1, 3, 2, 5, 4A4 = 1, 2, 3, 4, 5A5 = 0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64,

7、 9: 81A6 = 0, 0, 1, 1, 2, 4, 3, 9, 4, 16, 5, 25, 6, 36, 7, 49, 8, 64, 9, 81問題4Python和多線程（multi-threading）。這是個好主意碼？列舉一些讓Python代碼以并行方式運行的方法。答案Python并不支持真正意義上的多線程。Python中提供了多線程包，但是如果你想通過多線程提高代碼的速度，使用多線程包并不是個好主意。Python中有一個被稱為Global Interpreter Lock（GIL）的東西，它會確保任何時候你的多個線程中，只有一個被執(zhí)行。線程的執(zhí)行速度非常之快，會讓你誤以為線程是并行

8、執(zhí)行的，但是實際上都是輪流執(zhí)行。經(jīng)過GIL這一道關(guān)卡處理，會增加執(zhí)行的開銷。這意味著，如果你想提高代碼的運行速度，使用threading包并不是一個很好的方法。不過還是有很多理由促使我們使用threading包的。如果你想同時執(zhí)行一些任務，而且不考慮效率問題，那么使用這個包是完全沒問題的，而且也很方便。但是大部分情況下，并不是這么一回事，你會希望把多線程的部分外包給操作系統(tǒng)完成（通過開啟多個進程），或者是某些調(diào)用你的Python代碼的外部程序（例如Spark或Hadoop），又或者是你的Python代碼調(diào)用的其他代碼（例如，你可以在Python中調(diào)用C函數(shù)，用于處理開銷較大的多線程工作）。問題

9、5你如何管理不同版本的代碼？答案：版本管理！GIT, SVN問題6下面代碼會輸出什么：def f(x,l=): for i in range(x): l.append(i*i) print lf(2)f(3,3,2,1)f(3)答案：0, 13, 2, 1, 0, 1, 40, 1, 0, 1, 4呃？第一個函數(shù)調(diào)用十分明顯，for循環(huán)先后將0和1添加至了空列表l中。l是變量的名字，指向內(nèi)存中存儲的一個列表。第二個函數(shù)調(diào)用在一塊新的內(nèi)存中創(chuàng)建了新的列表。l這時指向了新生成的列表。之后再往新列表中添加0、1、2和4。很棒吧。第三個函數(shù)調(diào)用的結(jié)果就有些奇怪了。它使用了之前內(nèi)存地址中存儲的舊列表。這

10、就是為什么它的前兩個元素是0和1了。不明白的話就試著運行下面的代碼吧：l_mem = l = l_mem # the first callfor i in range(2): l.append(i*i)print l # 0, 1l = 3,2,1 # the second callfor i in range(3): l.append(i*i)print l # 3, 2, 1, 0, 1, 4l = l_mem # the third callfor i in range(3): l.append(i*i)print l # 0, 1, 0, 1, 4問題7monkey patch (猴子

11、補丁)用來在運行時動態(tài)修改已有的代碼，而不需要修改原始代碼。簡單的monkey patch 實現(xiàn)：python #coding=utf-8 def originalFunc():     print 'this is original function!'      def modifiedFunc():     modifiedFunc=1     print 'this

12、 is modified function!'      def main():     originalFunc()      if _name_='_main_':     originalFunc=modifiedFunc     main()  python中所有的東西都是object，包括基本類型。查看一

13、個object的所有屬性的方法是：dir(obj)函數(shù)在python中可以像使用變量一樣對它進行賦值等操作。查看屬性的方法： print locals() print globals() 問題8這兩個參數(shù)是什么意思：*args，*kwargs？我們?yōu)槭裁匆褂盟鼈儯看鸢溉绻覀儾淮_定要往函數(shù)中傳入多少個參數(shù)，或者我們想往函數(shù)中以列表和元組的形式傳參數(shù)時，那就使要用*args；如果我們不知道要往函數(shù)中傳入多少個關(guān)鍵詞參數(shù)，或者想傳入字典的值作為關(guān)鍵詞參數(shù)時，那就要使用*kwargs。args和kwargs這兩個標識符是約定俗成的用法，你當然還可以用*bob和*bil

14、ly，但是這樣就并不太妥。下面是具體的示例：def f(*args,*kwargs): print args, kwargsl = 1,2,3t = (4,5,6)d = 'a':7,'b':8,'c':9f()f(1,2,3) # (1, 2, 3) f(1,2,3,"groovy") # (1, 2, 3, 'groovy') f(a=1,b=2,c=3) # () 'a': 1, 'c': 3, 'b': 2f(a=1,b=2,c=3,zzz="h

15、i") # () 'a': 1, 'c': 3, 'b': 2, 'zzz': 'hi'f(1,2,3,a=1,b=2,c=3) # (1, 2, 3) 'a': 1, 'c': 3, 'b': 2f(*l,*d) # (1, 2, 3) 'a': 7, 'c': 9, 'b': 8f(*t,*d) # (4, 5, 6) 'a': 7, 'c': 9, 'b':

16、 8f(1,2,*t) # (1, 2, 4, 5, 6) f(q="winning",*d) # () 'a': 7, 'q': 'winning', 'c': 9, 'b': 8f(1,2,*t,q="winning",*d) # (1, 2, 4, 5, 6) 'a': 7, 'q': 'winning', 'c': 9, 'b': 8def f2(arg1,arg2,*args,*kwar

17、gs): print arg1,arg2, args, kwargsf2(1,2,3) # 1 2 (3,) f2(1,2,3,"groovy") # 1 2 (3, 'groovy') f2(arg1=1,arg2=2,c=3) # 1 2 () 'c': 3f2(arg1=1,arg2=2,c=3,zzz="hi") # 1 2 () 'c': 3, 'zzz': 'hi'f2(1,2,3,a=1,b=2,c=3) # 1 2 (3,) 'a': 1, &

18、#39;c': 3, 'b': 2f2(*l,*d) # 1 2 (3,) 'a': 7, 'c': 9, 'b': 8f2(*t,*d) # 4 5 (6,) 'a': 7, 'c': 9, 'b': 8f2(1,2,*t) # 1 2 (4, 5, 6) f2(1,1,q="winning",*d) # 1 1 () 'a': 7, 'q': 'winning', 'c': 9, '

19、;b': 8f2(1,2,*t,q="winning",*d) # 1 2 (4, 5, 6) 'a': 7, 'q': 'winning', 'c': 9, 'b': 8為什么提這個問題？有時候，我們需要往函數(shù)中傳入未知個數(shù)的參數(shù)或關(guān)鍵詞參數(shù)。有時候，我們也希望把參數(shù)或關(guān)鍵詞參數(shù)儲存起來，以備以后使用。有時候，僅僅是為了節(jié)省時間。問題9下面這些是什么意思：classmethod, staticmethod, property？回答背景知識這些都是裝飾器（decora

20、tor）。裝飾器是一種特殊的函數(shù)，要么接受函數(shù)作為輸入?yún)?shù)，并返回一個函數(shù)，要么接受一個類作為輸入?yún)?shù)，并返回一個類。標記是語法糖（syntactic sugar），可以讓你以簡單易讀得方式裝飾目標對象。my_decoratordef my_func(stuff): do_thingsIs equivalent todef my_func(stuff): do_thingsmy_func = my_decorator(my_func)你可以在本網(wǎng)站上找到介紹裝飾器工作原理的教材。真正的答案classmethod, staticmethod和property這三個裝飾器的使用對象是在類

21、中定義的函數(shù)。下面的例子展示了它們的用法和行為：class MyClass(object): def _init_(self): self._some_property = "properties are nice" self._some_other_property = "VERY nice" def normal_method(*args,*kwargs): print "calling normal_method(0,1)".format(args,kwargs) classmethod def class_method(*ar

22、gs,*kwargs): print "calling class_method(0,1)".format(args,kwargs) staticmethod def static_method(*args,*kwargs): print "calling static_method(0,1)".format(args,kwargs) property def some_property(self,*args,*kwargs): print "calling some_property getter(0,1,2)".format(se

23、lf,args,kwargs) return self._some_property some_property.setter def some_property(self,*args,*kwargs): print "calling some_property setter(0,1,2)".format(self,args,kwargs) self._some_property = args0 property def some_other_property(self,*args,*kwargs): print "calling some_other_prope

24、rty getter(0,1,2)".format(self,args,kwargs) return self._some_other_propertyo = MyClass()# 未裝飾的方法還是正常的行為方式，需要當前的類實例（self）作為第一個參數(shù)。o.normal_method # <bound method MyClass.normal_method of <_main_.MyClass instance at 0x7fdd2537ea28>>o.normal_method() # normal_method(<_main_.MyClass

25、instance at 0x7fdd2537ea28>,),)o.normal_method(1,2,x=3,y=4) # normal_method(<_main_.MyClass instance at 0x7fdd2537ea28>, 1, 2),'y': 4, 'x': 3)# 類方法的第一個參數(shù)永遠是該類o.class_method# <bound method classobj.class_method of <class _main_.MyClass at 0x7fdd2536a390>>o.class_m

26、ethod()# class_method(<class _main_.MyClass at 0x7fdd2536a390>,),)o.class_method(1,2,x=3,y=4)# class_method(<class _main_.MyClass at 0x7fdd2536a390>, 1, 2),'y': 4, 'x': 3)# 靜態(tài)方法（static method）中除了你調(diào)用時傳入的參數(shù)以外，沒有其他的參數(shù)。o.static_method# <function static_method at 0x7fdd2537

27、5848>o.static_method()# static_method(),)o.static_method(1,2,x=3,y=4)# static_method(1, 2),'y': 4, 'x': 3)# property是實現(xiàn)getter和setter方法的一種方式。直接調(diào)用它們是錯誤的。# “只讀”屬性可以通過只定義getter方法，不定義setter方法實現(xiàn)。o.some_property# 調(diào)用some_property的getter(<_main_.MyClass instance at 0x7fb2b70877e8>,()

28、,)# 'properties are nice'# “屬性”是很好的功能o.some_property()# calling some_property getter(<_main_.MyClass instance at 0x7fb2b70877e8>,(),)# Traceback (most recent call last):# File "<stdin>", line 1, in <module># TypeError: 'str' object is not callableo.some_ot

29、her_property# calling some_other_property getter(<_main_.MyClass instance at 0x7fb2b70877e8>,(),)# 'VERY nice'# o.some_other_property()# calling some_other_property getter(<_main_.MyClass instance at 0x7fb2b70877e8>,(),)# Traceback (most recent call last):# File "<stdin&g

30、t;", line 1, in <module># TypeError: 'str' object is not callableo.some_property = "groovy"# calling some_property setter(<_main_.MyClass object at 0x7fb2b7077890>,('groovy',),)o.some_property# calling some_property getter(<_main_.MyClass object at 0x7fb

31、2b7077890>,(),)# 'groovy'o.some_other_property = "very groovy"# Traceback (most recent call last):# File "<stdin>", line 1, in <module># AttributeError: can't set attributeo.some_other_property# calling some_other_property getter(<_main_.MyClass obje

32、ct at 0x7fb2b7077890>,(),)問題10閱讀下面的代碼，它的輸出結(jié)果是什么？class A(object): def go(self): print "go A go!" def stop(self): print "stop A stop!" def pause(self): raise Exception("Not Implemented")class B(A): def go(self): super(B, self).go() print "go B go!"class C(A):

33、 def go(self): super(C, self).go() print "go C go!" def stop(self): super(C, self).stop() print "stop C stop!"class D(B,C): def go(self): super(D, self).go() print "go D go!" def stop(self): super(D, self).stop() print "stop D stop!" def pause(self): print &qu

34、ot;wait D wait!"class E(B,C): passa = A()b = B()c = C()d = D()e = E()# 說明下列代碼的輸出結(jié)果a.go()b.go()c.go()d.go()e.go()a.stop()b.stop()c.stop()d.stop()e.stop()a.pause()b.pause()c.pause()d.pause()e.pause()答案輸出結(jié)果以注釋的形式表示：a.go()# go A go!b.go()# go A go!# go B go!c.go()# go A go!# go C go!d.go()# go A go

35、!# go C go!# go B go!# go D go!e.go()# go A go!# go C go!# go B go!a.stop()# stop A stop!b.stop()# stop A stop!c.stop()# stop A stop!# stop C stop!d.stop()# stop A stop!# stop C stop!# stop D stop!e.stop()# stop A stop!a.pause()# . Exception: Not Implementedb.pause()# . Exception: Not Implementedc.p

36、ause()# . Exception: Not Implementedd.pause()# wait D wait!e.pause()# .Exception: Not Implemented問題11閱讀下面的代碼，它的輸出結(jié)果是什么？class Node(object): def _init_(self,sName): self._lChildren = self.sName = sName def _repr_(self): return "<Node ''>".format(self.sName) def append(self,*arg

37、s,*kwargs): self._lChildren.append(*args,*kwargs) def print_all_1(self): print self for oChild in self._lChildren: oChild.print_all_1() def print_all_2(self): def gen(o): lAll = o, while lAll: oNext = lAll.pop(0) lAll.extend(oNext._lChildren) yield oNext for oNode in gen(self): print oNodeoRoot = No

38、de("root")oChild1 = Node("child1")oChild2 = Node("child2")oChild3 = Node("child3")oChild4 = Node("child4")oChild5 = Node("child5")oChild6 = Node("child6")oChild7 = Node("child7")oChild8 = Node("child8")oChild9

39、= Node("child9")oChild10 = Node("child10")oRoot.append(oChild1)oRoot.append(oChild2)oRoot.append(oChild3)oChild1.append(oChild4)oChild1.append(oChild5)oChild2.append(oChild6)oChild4.append(oChild7)oChild3.append(oChild8)oChild3.append(oChild9)oChild6.append(oChild10)# 說明下面代碼的輸出結(jié)果

40、oRoot.print_all_1()oRoot.print_all_2()答案oRoot.print_all_1()會打印下面的結(jié)果：<Node 'root'><Node 'child1'><Node 'child4'><Node 'child7'><Node 'child5'><Node 'child2'><Node 'child6'><Node 'child10'>&

41、lt;Node 'child3'><Node 'child8'><Node 'child9'>oRoot.print_all_1()會打印下面的結(jié)果：<Node 'root'><Node 'child1'><Node 'child2'><Node 'child3'><Node 'child4'><Node 'child5'><Node '

42、child6'><Node 'child8'><Node 'child9'><Node 'child7'><Node 'child10'>為什么提這個問題？因為對象的精髓就在于組合（composition）與對象構(gòu)造（object construction）。對象需要有組合成分構(gòu)成，而且得以某種方式初始化。這里也涉及到遞歸和生成器（generator）的使用。生成器是很棒的數(shù)據(jù)類型。你可以只通過構(gòu)造一個很長的列表，然后打印列表的內(nèi)容，就可以取得與print_all_2類

43、似的功能。生成器還有一個好處，就是不用占據(jù)很多內(nèi)存。有一點還值得指出，就是print_all_1會以深度優(yōu)先（depth-first）的方式遍歷樹(tree),而print_all_2則是寬度優(yōu)先（width-first）。有時候，一種遍歷方式比另一種更合適。但這要看你的應用的具體情況。問題12簡要描述Python的垃圾回收機制（garbage collection）。答案這里能說的很多。你應該提到下面幾個主要的點：· Python在內(nèi)存中存儲了每個對象的引用計數(shù)（reference count）。如果計數(shù)值變成0，那么相應的對象就會消失，分配給該對象的內(nèi)存就會釋放出來用作他用。&#

44、183; 偶爾也會出現(xiàn)引用循環(huán)（reference cycle）。垃圾回收器會定時尋找這個循環(huán)，并將其回收。舉個例子，假設有兩個對象o1和o2，而且符合o1.x = o2和o2.x = o1這兩個條件。如果o1和o2沒有其他代碼引用，那么它們就不應該繼續(xù)存在。但它們的引用計數(shù)都是1。· Python中使用了某些啟發(fā)式算法（heuristics）來加速垃圾回收。例如，越晚創(chuàng)建的對象更有可能被回收。對象被創(chuàng)建之后，垃圾回收器會分配它們所屬的代（generation）。每個對象都會被分配一個代，而被分配更年輕代的對象是優(yōu)先被處理的。問題13將下面的函數(shù)按照執(zhí)行效率高低排序。它們都接受由0至

45、1之間的數(shù)字構(gòu)成的列表作為輸入。這個列表可以很長。一個輸入列表的示例如下：random.random() for i in range(100000)。你如何證明自己的答案是正確的。def f1(lIn): l1 = sorted(lIn) l2 = i for i in l1 if i<0.5 return i*i for i in l2def f2(lIn): l1 = i for i in lIn if i<0.5 l2 = sorted(l1) return i*i for i in l2def f3(lIn): l1 = i*i for i in lIn l2 = sor

46、ted(l1) return i for i in l1 if i<(0.5*0.5)答案按執(zhí)行效率從高到低排列：f2、f1和f3。要證明這個答案是對的，你應該知道如何分析自己代碼的性能。Python中有一個很好的程序分析包，可以滿足這個需求。import cProfilelIn = random.random() for i in range(100000)cProfile.run('f1(lIn)')cProfile.run('f2(lIn)')cProfile.run('f3(lIn)')14、getattr、setattr、hasa

47、ttr的功能自?。ㄗ寣ο蟾嬖V我們他是什么），用于實現(xiàn)在運行時獲取未知對象的信息。訪問對象屬性：hasattr(object, name)判斷一個對象里面是否有name屬性或者name方法，返回BOOL值，有name特性返回True， 否則返回False。需要注意的是name要用括號括起來getattr(object, name,default)獲取對象object的屬性或者方法，如果存在打印出來，如果不存在，打印出默認值，默認值可選。需要注意的是，如果是返回的對象的方法，返回的是方法的內(nèi)存地址，如果需要運行這個方法，可以在后面添加一對括號。setattr(object, name, value

48、s)給對象的屬性賦值，若屬性不存在，先創(chuàng)建再賦值。15、staticmethod和classmethodpython有3個方法，即靜態(tài)方法(staticmethod),類方法(classmethod)和實例方法。def foo(x): print "executing foo(%s)"%(x)class A(object): def foo(self,x): print "executing foo(%s,%s)"%(self,x) classmethod def class_foo(cls,x): print "executing class

49、_foo(%s,%s)"%(cls,x) staticmethod def static_foo(x): print "executing static_foo(%s)"%xa=A() 這個self和cls是對類或者實例的綁定,對于一般的函數(shù)來說我們可以這么調(diào)用foo(x),這個函數(shù)就是最常用的,它的工作跟任何東西(類,實例)無關(guān).對于實例方法,我們知道在類里每次定義方法的時候都需要綁定這個實例,就是foo(self, x),為什么要這么做呢?因為實例方法的調(diào)用離不開實例,我們需要把實例自己傳給函數(shù),調(diào)用的時候是這樣的a.foo(x)(其實是foo(a,

50、 x).類方法一樣,只不過它傳遞的是類而不是實例,A.class_foo(x).注意這里的self和cls可以替換別的參數(shù),但是python的約定是這倆,還是不要改的好.對于靜態(tài)方法其實和普通的方法一樣,不需要對誰進行綁定,唯一的區(qū)別是調(diào)用的時候需要使用a.static_foo(x)或者A.static_foo(x)來調(diào)用.16、python中的sys模塊有什么作用？如何獲得變量（函數(shù)？）所占內(nèi)存空間？sys是system的縮寫,用來獲取操作系統(tǒng)和編譯器的一些配置,設置及操作。 如判斷文件和文件夾是否存在,創(chuàng)建文件文件夾,獲取系統(tǒng)版本之類的操作。import sysv = 1print sys

51、.getsizeof(v)print sys.getsizeof(int()s = 'abc'print sys.getsizeof(s)28245217、python中的ducking type當看到一只鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那么這只鳥就可以被稱為鴨子?！眕ython在運行時并不關(guān)心對象是什么類型，到底是不是鴨子，只關(guān)心行為。比如在python中，有很多file-like的東西，比如StringIO,GzipFile,socket。它們有很多相同的方法，我們把它們當作文件使用。又比如list.extend()方法中,我們并不關(guān)心它的參數(shù)是不是list

52、,只要它是可迭代的,所以它的參數(shù)可以是list/tuple/dict/字符串/生成器等.鴨子類型在動態(tài)語言中經(jīng)常使用，非常靈活，使得python不想java那樣專門去弄一大堆的設計模式。下面例子用duck typing來實現(xiàn)多態(tài)。#coding=utf-8  class Duck:     def quack(self):          print "Quaaaaaack!"

53、;  class Bird:      def quack(self):          print "bird imitate duck."  class Doge:      def quack(self):   

54、       print "doge imitate duck."  def in_the_forest(duck):      duck.quack()    duck = Duck()  bird = Bird()  doge = Doge()&

55、#160; for x in duck, bird, doge:      in_the_forest(x)  再舉個例子，我們來hack輸出流。import sys  sys.stdout = open('D:stdout.log', 'a') #只要是file-like,不管是什么類型  print 'foo

56、9;  sys.stdout = sys._stdout_ #恢復  print 'bar'  這樣就把輸出流給寫入到文件中去了。18、python中的淺拷貝與深拷貝1. copy.copy 淺拷貝只拷貝父對象及父對象內(nèi)的不可變對象，不會拷貝父對象的內(nèi)部的可變子對象。(比深拷貝更加節(jié)省內(nèi)存)2. copy.deepcopy 深拷貝 拷貝對象及其子對象可變類型： 列表，字典不可變類型：數(shù)字，字符串，元組淺拷貝是指拷貝的只是

57、原對象元素的引用，換句話說，淺拷貝產(chǎn)生的對象本身是新的，但是它的內(nèi)容不是新的，只是對原對象的一個引用19、python中的特殊函數(shù)： 高階函數(shù)：一個函數(shù)可以接收另一個函數(shù)作為參數(shù)；def add(x,y,f):  return f(x)+f(y) add(-5,9,abs)    內(nèi)置高階函數(shù)map():map函數(shù)有兩個參數(shù)，一個是函數(shù)，另一個是列表，返回值為對傳入的列表每一個元素執(zhí)行傳入的函數(shù)操作得到的列表； def format_name(s):    

58、0; return s.title();  print map(format_name, 'adam', 'LISA', 'barT')  內(nèi)置高階函數(shù)reduce():reduce函數(shù)也有兩個參數(shù)，一個是函數(shù)，另一個是列表，返回值為對list的每一個元素反復調(diào)用函數(shù)f，得到最終結(jié)果，以下函數(shù)為連乘；def prod(x, y):      return x*

59、y;  print reduce(prod, 2, 4, 5, 7, 12)  內(nèi)置高階函數(shù)filter():filter函數(shù)接受函數(shù)參數(shù)f和列表參數(shù)list，f對list元素進行判斷，返回lst的元素中調(diào)用f函數(shù)結(jié)果為true的元素組成的列表（將不滿足f函數(shù)條件的元素過濾掉）；import math  def is_sqr(x):      return int(math.sqrt(x

60、)*int(math.sqrt(x)=x  print filter(is_sqr, range(1, 101)自定義排序函數(shù)sorted():sorted函數(shù)接受一個列表lst和一個函數(shù)參數(shù)f，f為自定義的比較lst元素大小的函數(shù)，返回值為lst中元素按f函數(shù)排列的列表；def cmp_ignore_case(s1, s2):      return cmp(s1.lower(),s2.lower()    pri

61、nt sorted('bob', 'about', 'Zoo', 'Credit', cmp_ignore_case)  返回函數(shù)：def calc_prod(lst):      def prod(x,y):          return x*y;  

62、    def g():          return reduce(prod,lst)      return g;    f = calc_prod(1, 2, 3, 4)  print f()  閉包：內(nèi)層函數(shù)使用外層函數(shù)

63、的參數(shù)，然后返回內(nèi)層函數(shù)；def count():      fs =       for i in range(1, 4):          def f(j):           &#

64、160;  def g():                return j*j;              return g          fs

65、.append(f(i)      return fs    f1, f2, f3 = count()  print f1(), f2(), f3()  匿名函數(shù)：傳入函數(shù)參數(shù)不需要顯式定義函數(shù)，可以用lambda x:statement     x為參數(shù)，statement為對參數(shù)執(zhí)行的語句；python view plain copydef i

66、s_not_empty(s):      return s and len(s.strip() > 0    print filter(lambda s:s and len(s.strip()>0, 'test', None, '', 'str', '  ',&#

67、160;'END')         裝飾器：給函數(shù)添加新功能，并簡化該函數(shù)調(diào)用；無參數(shù)裝飾器示例：python view plain copydef log(f):      def fn(*args, *kw): #*args，*kw保證對任意個數(shù)參數(shù)都能正常調(diào)用          print 'ca

68、ll ' + f._name_ + '().'          return f(*args, *kw)      return fn   log   #調(diào)用日志裝飾器  def factorial(n):   &

69、#160;  return reduce(lambda x,y: x*y, range(1, n+1)  print factorial(10)    call factorial().  3628800  帶參數(shù)裝飾器示例：python view plain copydef log(prefix):      def log_

70、decorator(f):          def wrapper(*args, *kw):              print '%s %s().' % (prefix, f._name_)              return f(*args, *kw)