2023年python面試題精選

問題1到底什么是Python？你可以在回答中與其他技術(shù)進(jìn)行對(duì)比（也鼓勵(lì)這樣做）。答案下面是一些關(guān)鍵點(diǎn)：Python是一種解釋型語言,Python代碼在運(yùn)營之前不需要編譯。Python是動(dòng)態(tài)類型語言，在聲明變量時(shí)，不需要說明變量的類型。Python非常適合面向?qū)ο蟮木幊蹋∣OP），由于它支持通過組合（composition）與繼承（inheritance）的方式定義類（class）。Python中沒有訪問說明符public和private，在Python語言中，函數(shù)是第一類對(duì)象（first-classobjects）。這指的是它們可以被指定給變量，函數(shù)既能返回函數(shù)類型，也可以接受函數(shù)作為輸入。類（class）也是第一類對(duì)象。Python代碼編寫快，但是運(yùn)營速度比編譯語言通常要慢。ython允許加入基于C語言編寫的擴(kuò)展，因此我們可以優(yōu)化代碼，消除瓶頸，這點(diǎn)通常是可以實(shí)現(xiàn)的。numpy就是一個(gè)很好地例子，它的運(yùn)營速度真的非?？?，由于很多算術(shù)運(yùn)算其實(shí)并不是通過Python實(shí)現(xiàn)的。Python用途非常廣泛——網(wǎng)絡(luò)應(yīng)用，自動(dòng)化，科學(xué)建模，大數(shù)據(jù)應(yīng)用，等等。它也常被用作“膠水語言”，幫助其他語言和組件改善運(yùn)營狀況。Python讓困難的事情變得容易，因此程序員可以專注于算法和數(shù)據(jù)結(jié)構(gòu)的設(shè)計(jì)，而不用解決底層的細(xì)節(jié)。問題2補(bǔ)充缺失的代碼defprint_directory_contents(sPath):"""這個(gè)函數(shù)接受文獻(xiàn)夾的名稱作為輸入?yún)?shù)，返回該文獻(xiàn)夾中文獻(xiàn)的途徑，以及其包含文獻(xiàn)夾中文獻(xiàn)的途徑。"""#補(bǔ)充代碼答案defprint_directory_contents(sPath):importosforsChildinos.listdir(sPath):sChildPath=os.path.join(sPath,sChild)ifos.path.isdir(sChildPath):print_directory_contents(sChildPath)else:printsChildPath特別要注意以下幾點(diǎn)：命名規(guī)范要統(tǒng)一。假如樣本代碼中可以看出命名規(guī)范，遵循其已有的規(guī)范。遞歸函數(shù)需要遞歸并終止。保證你明白其中的原理，否則你將面臨無休無止的調(diào)用棧（callstack）。我們使用os模塊與操作系統(tǒng)進(jìn)行交互，同時(shí)做到交互方式是可以跨平臺(tái)的。你可以把代碼寫成sChildPath=sPath+'/'+sChild，但是這個(gè)在Windows系統(tǒng)上會(huì)犯錯(cuò)。熟悉基礎(chǔ)模塊是非常有價(jià)值的，但是別想破腦袋都背下來，記住Google是你工作中的良師益友。假如你不明白代碼的預(yù)期功能，就大膽提問。堅(jiān)持KISS原則！保持簡樸，但是腦子就能懂！為什么提這個(gè)問題：說明面試者對(duì)與操作系統(tǒng)交互的基礎(chǔ)知識(shí)遞歸真是太好用啦問題3閱讀下面的代碼，寫出A0，A1至An的最終值。A0=dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))A1=range(10)A2=[iforiinA1ifiinA0]A3=[A0[s]forsinA0]A4=[iforiinA1ifiinA3]A5={i:i*iforiinA1}A6=[[i,i*i]foriinA1]答案A0={'a':1,'c':3,'b':2,'e':5,'d':4}A1=[0,1,2,3,4,5,6,7,8,9]A2=[]A3=[1,3,2,5,4]A4=[1,2,3,4,5]A5={0:0,1:1,2:4,3:9,4:16,5:25,6:36,7:49,8:64,9:81}A6=[[0,0],[1,1],[2,4],[3,9],[4,16],[5,25],[6,36],[7,49],[8,64],[9,81]]問題4Python和多線程（multi-threading）。這是個(gè)好主意碼？列舉一些讓Python代碼以并行方式運(yùn)營的方法。答案Python并不支持真正意義上的多線程。Python中提供了多線程包，但是假如你想通過多線程提高代碼的速度，使用多線程包并不是個(gè)好主意。Python中有一個(gè)被稱為GlobalInterpreterLock（GIL）的東西，它會(huì)保證任何時(shí)候你的多個(gè)線程中，只有一個(gè)被執(zhí)行。線程的執(zhí)行速度非常之快，會(huì)讓你誤認(rèn)為線程是并行執(zhí)行的，但是事實(shí)上都是輪流執(zhí)行。通過GIL這一道關(guān)卡解決，會(huì)增長執(zhí)行的開銷。這意味著，假如你想提高代碼的運(yùn)營速度，使用threading包并不是一個(gè)很好的方法。但是還是有很多理由促使我們使用threading包的。假如你想同時(shí)執(zhí)行一些任務(wù)，并且不考慮效率問題，那么使用這個(gè)包是完全沒問題的，并且也很方便。但是大部分情況下，并不是這么一回事，你會(huì)希望把多線程的部分外包給操作系統(tǒng)完畢（通過啟動(dòng)多個(gè)進(jìn)程），或者是某些調(diào)用你的Python代碼的外部程序（例如Spark或Hadoop），又或者是你的Python代碼調(diào)用的其他代碼（例如，你可以在Python中調(diào)用C函數(shù)，用于解決開銷較大的多線程工作）。問題5你如何管理不同版本的代碼？答案：版本管理！GIT,SVN問題6下面代碼會(huì)輸出什么：deff(x,l=[]):foriinrange(x):l.append(i*i)printlf(2)f(3,[3,2,1])f(3)答案：[0,1][3,2,1,0,1,4][0,1,0,1,4]呃？第一個(gè)函數(shù)調(diào)用十分明顯，for循環(huán)先后將0和1添加至了空列表l中。l是變量的名字，指向內(nèi)存中存儲(chǔ)的一個(gè)列表。第二個(gè)函數(shù)調(diào)用在一塊新的內(nèi)存中創(chuàng)建了新的列表。l這時(shí)指向了新生成的列表。之后再往新列表中添加0、1、2和4。很棒吧。第三個(gè)函數(shù)調(diào)用的結(jié)果就有些奇怪了。它使用了之前內(nèi)存地址中存儲(chǔ)的舊列表。這就是為什么它的前兩個(gè)元素是0和1了。不明白的話就試著運(yùn)營下面的代碼吧：l_mem=[]l=l_mem#thefirstcallforiinrange(2):l.append(i*i)printl#[0,1]l=[3,2,1]#thesecondcallforiinrange(3):l.append(i*i)printl#[3,2,1,0,1,4]l=l_mem#thethirdcallforiinrange(3):l.append(i*i)printl#[0,1,0,1,4]問題7monkeypatch(猴子補(bǔ)丁)

用來在運(yùn)營時(shí)動(dòng)態(tài)修改已有的代碼，而不需要修改原始代碼。簡樸的monkeypatch實(shí)現(xiàn)：

[python]

#coding=utf-8

deforiginalFunc():

print'thisisoriginalfunction!'

defmodifiedFunc():

modifiedFunc=1

print'thisismodifiedfunction!'

defmain():

originalFunc()

if__name__=='__main__':

originalFunc=modifiedFunc

main()

python中所有的東西都是object，涉及基本類型。查看一個(gè)object的所有屬性的方法是：dir(obj)

函數(shù)在python中可以像使用變量同樣對(duì)它進(jìn)行賦值等操作。

查看屬性的方法：

printlocals()

printglobals()

問題8這兩個(gè)參數(shù)是什么意思：*args，**kwargs？我們?yōu)槭裁匆褂盟鼈儯看鸢讣偃缥覀儾粩M定要往函數(shù)中傳入多少個(gè)參數(shù)，或者我們想往函數(shù)中以列表和元組的形式傳參數(shù)時(shí)，那就使要用*args；假如我們不知道要往函數(shù)中傳入多少個(gè)關(guān)鍵詞參數(shù)，或者想傳入字典的值作為關(guān)鍵詞參數(shù)時(shí)，那就要使用**kwargs。args和kwargs這兩個(gè)標(biāo)記符是約定俗成的用法，你當(dāng)然還可以用*bob和**billy，但是這樣就并不太妥。下面是具體的示例：deff(*args,**kwargs):printargs,kwargsl=[1,2,3]t=(4,5,6)d={'a':7,'b':8,'c':9}f()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':2}f(a=1,b=2,c=3,zzz="hi")#(){'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':2}f(*l,**d)#(1,2,3){'a':7,'c':9,'b':8}f(*t,**d)#(4,5,6){'a':7,'c':9,'b':8}f(1,2,*t)#(1,2,4,5,6){}f(q="winning",**d)#(){'a':7,'q':'winning','c':9,'b':8}f(1,2,*t,q="winning",**d)#(1,2,4,5,6){'a':7,'q':'winning','c':9,'b':8}deff2(arg1,arg2,*args,**kwargs):printarg1,arg2,args,kwargsf2(1,2,3)#12(3,){}f2(1,2,3,"groovy")#12(3,'groovy'){}f2(arg1=1,arg2=2,c=3)#12(){'c':3}f2(arg1=1,arg2=2,c=3,zzz="hi")#12(){'c':3,'zzz':'hi'}f2(1,2,3,a=1,b=2,c=3)#12(3,){'a':1,'c':3,'b':2}f2(*l,**d)#12(3,){'a':7,'c':9,'b':8}f2(*t,**d)#45(6,){'a':7,'c':9,'b':8}f2(1,2,*t)#12(4,5,6){}f2(1,1,q="winning",**d)#11(){'a':7,'q':'winning','c':9,'b':8}f2(1,2,*t,q="winning",**d)#12(4,5,6){'a':7,'q':'winning','c':9,'b':8}為什么提這個(gè)問題？有時(shí)候，我們需要往函數(shù)中傳入未知個(gè)數(shù)的參數(shù)或關(guān)鍵詞參數(shù)。有時(shí)候，我們也希望把參數(shù)或關(guān)鍵詞參數(shù)儲(chǔ)存起來，以備以后使用。有時(shí)候，僅僅是為了節(jié)省時(shí)間。問題9下面這些是什么意思：@classmethod,

@staticmethod,

@property？回答背景知識(shí)這些都是裝飾器（decorator）。裝飾器是一種特殊的函數(shù)，要么接受函數(shù)作為輸入?yún)?shù)，并返回一個(gè)函數(shù)，要么接受一個(gè)類作為輸入?yún)?shù)，并返回一個(gè)類。@標(biāo)記是語法糖（syntacticsugar），可以讓你以簡樸易讀得方式裝飾目的對(duì)象。@my_decoratordefmy_func(stuff):do_thingsIsequivalenttodefmy_func(stuff):do_thingsmy_func=my_decorator(my_func)你可以在本網(wǎng)站上找到介紹裝飾器工作原理的教材。真正的答案@classmethod,

@staticmethod和@property這三個(gè)裝飾器的使用對(duì)象是在類中定義的函數(shù)。下面的例子展示了它們的用法和行為：classMyClass(object):def__init__(self):self._some_property="propertiesarenice"self._some_other_property="VERYnice"defnormal_method(*args,**kwargs):print"callingnormal_method({0},{1})".format(args,kwargs)@classmethoddefclass_method(*args,**kwargs):print"callingclass_method({0},{1})".format(args,kwargs)@staticmethoddefstatic_method(*args,**kwargs):print"callingstatic_method({0},{1})".format(args,kwargs)@propertydefsome_property(self,*args,**kwargs):print"callingsome_propertygetter({0},{1},{2})".format(self,args,kwargs)returnself._some_property@some_property.setterdefsome_property(self,*args,**kwargs):print"callingsome_propertysetter({0},{1},{2})".format(self,args,kwargs)self._some_property=args[0]@propertydefsome_other_property(self,*args,**kwargs):print"callingsome_other_propertygetter({0},{1},{2})".format(self,args,kwargs)returnself._some_other_propertyo=MyClass()#未裝飾的方法還是正常的行為方式，需要當(dāng)前的類實(shí)例（self）作為第一個(gè)參數(shù)。o.normal_method#<boundmethodMyClass.normal_methodof<__main__.MyClassinstanceat0x7fdd2537ea28>>o.normal_method()#normal_method((<__main__.MyClassinstanceat0x7fdd2537ea28>,),{})o.normal_method(1,2,x=3,y=4)#normal_method((<__main__.MyClassinstanceat0x7fdd2537ea28>,1,2),{'y':4,'x':3})#類方法的第一個(gè)參數(shù)永遠(yuǎn)是該類o.class_method#<boundmethodclassobj.class_methodof<class__main__.MyClassat0x7fdd2536a390>>o.class_method()#class_method((<class__main__.MyClassat0x7fdd2536a390>,),{})o.class_method(1,2,x=3,y=4)#class_method((<class__main__.MyClassat0x7fdd2536a390>,1,2),{'y':4,'x':3})#靜態(tài)方法（staticmethod）中除了你調(diào)用時(shí)傳入的參數(shù)以外，沒有其他的參數(shù)。o.static_method#<functionstatic_methodat0x7fdd25375848>o.static_method()#static_method((),{})o.static_method(1,2,x=3,y=4)#static_method((1,2),{'y':4,'x':3})#@property是實(shí)現(xiàn)getter和setter方法的一種方式。直接調(diào)用它們是錯(cuò)誤的。#“只讀”屬性可以通過只定義getter方法，不定義setter方法實(shí)現(xiàn)。o.some_property#調(diào)用some_property的getter(<__main__.MyClassinstanceat0x7fb2b70877e8>,(),{})#'propertiesarenice'#“屬性”是很好的功能o.some_property()#callingsome_propertygetter(<__main__.MyClassinstanceat0x7fb2b70877e8>,(),{})#Traceback(mostrecentcalllast):#File"<stdin>",line1,in<module>#TypeError:'str'objectisnotcallableo.some_other_property#callingsome_other_propertygetter(<__main__.MyClassinstanceat0x7fb2b70877e8>,(),{})#'VERYnice'#o.some_other_property()#callingsome_other_propertygetter(<__main__.MyClassinstanceat0x7fb2b70877e8>,(),{})#Traceback(mostrecentcalllast):#File"<stdin>",line1,in<module>#TypeError:'str'objectisnotcallableo.some_property="groovy"#callingsome_propertysetter(<__main__.MyClassobjectat0x7fb2b7077890>,('groovy',),{})o.some_property#callingsome_propertygetter(<__main__.MyClassobjectat0x7fb2b7077890>,(),{})#'groovy'o.some_other_property="verygroovy"#Traceback(mostrecentcalllast):#File"<stdin>",line1,in<module>#AttributeError:can'tsetattributeo.some_other_property#callingsome_other_propertygetter(<__main__.MyClassobjectat0x7fb2b7077890>,(),{})問題10閱讀下面的代碼，它的輸出結(jié)果是什么？classA(object):defgo(self):print"goAgo!"defstop(self):print"stopAstop!"defpause(self):raiseException("NotImplemented")classB(A):defgo(self):super(B,self).go()print"goBgo!"classC(A):defgo(self):super(C,self).go()print"goCgo!"defstop(self):super(C,self).stop()print"stopCstop!"classD(B,C):defgo(self):super(D,self).go()print"goDgo!"defstop(self):super(D,self).stop()print"stopDstop!"defpause(self):print"waitDwait!"classE(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é)果以注釋的形式表達(dá)：a.go()#goAgo!b.go()#goAgo!#goBgo!c.go()#goAgo!#goCgo!d.go()#goAgo!#goCgo!#goBgo!#goDgo!e.go()#goAgo!#goCgo!#goBgo!a.stop()#stopAstop!b.stop()#stopAstop!c.stop()#stopAstop!#stopCstop!d.stop()#stopAstop!#stopCstop!#stopDstop!e.stop()#stopAstop!a.pause()#...Exception:NotImplementedb.pause()#...Exception:NotImplementedc.pause()#...Exception:NotImplementedd.pause()#waitDwait!e.pause()#...Exception:NotImplemented問題11閱讀下面的代碼，它的輸出結(jié)果是什么？classNode(object):def__init__(self,sName):self._lChildren=[]self.sName=sNamedef__repr__(self):return"<Node'{}'>".format(self.sName)defappend(self,*args,**kwargs):self._lChildren.append(*args,**kwargs)defprint_all_1(self):printselfforoChildinself._lChildren:oChild.print_all_1()defprint_all_2(self):defgen(o):lAll=[o,]whilelAll:oNext=lAll.pop(0)lAll.extend(oNext._lChildren)yieldoNextforoNodeingen(self):printoNodeoRoot=Node("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=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é)果oRoot.print_all_1()oRoot.print_all_2()答案oRoot.print_all_1()會(huì)打印下面的結(jié)果：<Node'root'><Node'child1'><Node'child4'><Node'child7'><Node'child5'><Node'child2'><Node'child6'><Node'child10'><Node'child3'><Node'child8'><Node'child9'>oRoot.print_all_1()會(huì)打印下面的結(jié)果：<Node'root'><Node'child1'><Node'child2'><Node'child3'><Node'child4'><Node'child5'><Node'child6'><Node'child8'><Node'child9'><Node'child7'><Node'child10'>為什么提這個(gè)問題？由于對(duì)象的精髓就在于組合（composition）與對(duì)象構(gòu)造（objectconstruction）。對(duì)象需要有組合成分構(gòu)成，并且得以某種方式初始化。這里也涉及到遞歸和生成器（generator）的使用。生成器是很棒的數(shù)據(jù)類型。你可以只通過構(gòu)造一個(gè)很長的列表，然后打印列表的內(nèi)容，就可以取得與print_all_2類似的功能。生成器尚有一個(gè)好處，就是不用占據(jù)很多內(nèi)存。有一點(diǎn)還值得指出，就是print_all_1會(huì)以深度優(yōu)先（depth-first）的方式遍歷樹(tree),而print_all_2則是寬度優(yōu)先（width-first）。有時(shí)候，一種遍歷方式比另一種更合適。但這要看你的應(yīng)用的具體情況。問題12簡要描述Python的垃圾回收機(jī)制（garbagecollection）。答案這里能說的很多。你應(yīng)當(dāng)提到下面幾個(gè)重要的點(diǎn)：Python在內(nèi)存中存儲(chǔ)了每個(gè)對(duì)象的引用計(jì)數(shù)（referencecount）。假如計(jì)數(shù)值變成0，那么相應(yīng)的對(duì)象就會(huì)消失，分派給該對(duì)象的內(nèi)存就會(huì)釋放出來用作他用。偶爾也會(huì)出現(xiàn)引用循環(huán)（referencecycle）。垃圾回收器會(huì)定期尋找這個(gè)循環(huán)，并將其回收。舉個(gè)例子，假設(shè)有兩個(gè)對(duì)象o1和o2，并且符合o1.x==o2和o2.x==o1這兩個(gè)條件。假如o1和o2沒有其他代碼引用，那么它們就不應(yīng)當(dāng)繼續(xù)存在。但它們的引用計(jì)數(shù)都是1。Python中使用了某些啟發(fā)式算法（heuristics）來加速垃圾回收。例如，越晚創(chuàng)建的對(duì)象更有也許被回收。對(duì)象被創(chuàng)建之后，垃圾回收器會(huì)分派它們所屬的代（generation）。每個(gè)對(duì)象都會(huì)被分派一個(gè)代，而被分派更年輕代的對(duì)象是優(yōu)先被解決的。問題13將下面的函數(shù)按照?qǐng)?zhí)行效率高低排序。它們都接受由0至1之間的數(shù)字構(gòu)成的列表作為輸入。這個(gè)列表可以很長。一個(gè)輸入列表的示例如下：[random.random()foriinrange(100000)]。你如何證明自己的答案是對(duì)的的。deff1(lIn):l1=sorted(lIn)l2=[iforiinl1ifi<0.5]return[i*iforiinl2]deff2(lIn):l1=[iforiinlInifi<0.5]l2=sorted(l1)return[i*iforiinl2]deff3(lIn):l1=[i*iforiinlIn]l2=sorted(l1)return[iforiinl1ifi<(0.5*0.5)]答案按執(zhí)行效率從高到低排列：f2、f1和f3。要證明這個(gè)答案是對(duì)的，你應(yīng)當(dāng)知道如何分析自己代碼的性能。Python中有一個(gè)很好的程序分析包，可以滿足這個(gè)需求。importcProfilelIn=[random.random()foriinrange(100000)]cProfile.run('f1(lIn)')cProfile.run('f2(lIn)')cProfile.run('f3(lIn)')14、getattr、setattr、hasattr的功能自省（讓對(duì)象告訴我們他是什么），用于實(shí)現(xiàn)在運(yùn)營時(shí)獲取未知對(duì)象的信息。訪問對(duì)象屬性：hasattr(object,name)

判斷一個(gè)對(duì)象里面是否有name屬性或者name方法，返回BOOL值，有name特性返回True，否則返回False。

需要注意的是name要用括號(hào)括起來getattr(object,name[,default])

獲取對(duì)象object的屬性或者方法，假如存在打印出來，假如不存在，打印出默認(rèn)值，默認(rèn)值可選。需要注意的是，假如是返回的對(duì)象的方法，返回的是方法的內(nèi)存地址，假如需要運(yùn)營這個(gè)方法，可以在后面添加一對(duì)括號(hào)。setattr(object,name,values)

給對(duì)象的屬性賦值，若屬性不存在，先創(chuàng)建再賦值。15、@staticmethod和@classmethodpython有3個(gè)方法，即靜態(tài)方法(staticmethod),類方法(classmethod)和實(shí)例方法。deffoo(x):print"executingfoo(%s)"%(x)classA(object):deffoo(self,x):print"executingfoo(%s,%s)"%(self,x)@classmethoddefclass_foo(cls,x):print"executingclass_foo(%s,%s)"%(cls,x)@staticmethoddefstatic_foo(x):print"executingstatic_foo(%s)"%xa=A()

這個(gè)self和cls是對(duì)類或者實(shí)例的綁定,對(duì)于一般的函數(shù)來說我們可以這么調(diào)用foo(x),這個(gè)函數(shù)就是最常用的,它的工作跟任何東西(類,實(shí)例)無關(guān).對(duì)于實(shí)例方法,我們知道在類里每次定義方法的時(shí)候都需要綁定這個(gè)實(shí)例,就是foo(self,x),為什么要這么做呢?由于實(shí)例方法的調(diào)用離不開實(shí)例,我們需要把實(shí)例自己傳給函數(shù),調(diào)用的時(shí)候是這樣的a.foo(x)(其實(shí)是foo(a,x)).類方法同樣,只但是它傳遞的是類而不是實(shí)例,A.class_foo(x).注意這里的self和cls可以替換別的參數(shù),但是python的約定是這倆,還是不要改的好.對(duì)于靜態(tài)方法其實(shí)和普通的方法同樣,不需要對(duì)誰進(jìn)行綁定,唯一的區(qū)別是調(diào)用的時(shí)候需要使用a.static_foo(x)或者A.static_foo(x)來調(diào)用.16、python中的sys模塊有什么作用？如何獲得變量（函數(shù)？）所占內(nèi)存空間？sys是system的縮寫,用來獲取操作系統(tǒng)和編譯器的一些配置,設(shè)立及操作。如判斷文獻(xiàn)和文獻(xiàn)夾是否存在,創(chuàng)建文獻(xiàn)文獻(xiàn)夾,獲取系統(tǒng)版本之類的操作。importsysv=1printsys.getsizeof(v)printsys.getsizeof(int())s='abc'printsys.getsizeof(s)28245217、python中的duckingtype當(dāng)看到一只鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那么這只鳥就可以被稱為鴨子?！眕ython在運(yùn)營時(shí)并不關(guān)心對(duì)象是什么類型，到底是不是鴨子，只關(guān)心行為。比如在python中，有很多file-like的東西，比如StringIO,GzipFile,socket。它們有很多相同的方法，我們把它們當(dāng)作文獻(xiàn)使用。又比如list.extend()方法中,我們并不關(guān)心它的參數(shù)是不是list,只要它是可迭代的,所以它的參數(shù)可以是list/tuple/dict/字符串/生成器等.鴨子類型在動(dòng)態(tài)語言中經(jīng)常使用，非常靈活，使得python不想java那樣專門去弄一大堆的設(shè)計(jì)模式。下面例子用ducktyping來實(shí)現(xiàn)多態(tài)。#coding=utf-8

class

Duck:

def

quack(self):

print

"Quaaaaaack!"

class

Bird:

def

quack(self):

print

"bird

imitate

duck."

class

Doge:

def

quack(self):

print

"doge

imitate

duck."

def

in_the_forest(duck):

duck.quack()

duck

=

Duck()

bird

=

Bird()

doge

=

Doge()

for

x

in

[duck,

bird,

doge]:

in_the_forest(x)

再舉個(gè)例子，我們來hack輸出流。import

sys

sys.stdout

=

open('D:\stdout.log',

'a')

#只要是file-like,不管是什么類型

print

'foo'

sys.stdout

=

sys.__stdout__

#恢復(fù)

print

'bar'

這樣就把輸出流給寫入到文獻(xiàn)中去了。18、python中的淺拷貝與深拷貝1.

copy.copy

淺拷貝只拷貝父對(duì)象及父對(duì)象內(nèi)的不可變對(duì)象，不會(huì)拷貝父對(duì)象的內(nèi)部的可變子對(duì)象。(比深拷貝更加節(jié)省內(nèi)存)

2.

copy.deepcopy

深拷貝

拷貝對(duì)象及其子對(duì)象可變類型：

列表，字典

不可變類型：數(shù)字，字符串，元組淺拷貝是指拷貝的只是原對(duì)象元素的引用，換句話說，淺拷貝產(chǎn)生的對(duì)象自身是新的，但是它的內(nèi)容不是新的，只是對(duì)原對(duì)象的一個(gè)引用19、python中的特殊函數(shù)：高階函數(shù)：一個(gè)函數(shù)可以接受另一個(gè)函數(shù)作為參數(shù)；def

add(x,y,f):

return

f(x)+f(y)add(-5,9,abs)

內(nèi)置高階函數(shù)map():map函數(shù)有兩個(gè)參數(shù)，一個(gè)是函數(shù)，另一個(gè)是列表，返回值為對(duì)傳入的列表每一個(gè)元素執(zhí)行傳入的函數(shù)操作得到的列表；def

format_name(s):

return

s.title();

print

map(format_name,

['adam',

'LISA',

'barT'])

內(nèi)置高階函數(shù)reduce():reduce函數(shù)也有兩個(gè)參數(shù)，一個(gè)是函數(shù)，另一個(gè)是列表，返回值為對(duì)list的每一個(gè)元素反復(fù)調(diào)用函數(shù)f，得到最終結(jié)果，以下函數(shù)為連乘；def

prod(x,

y):

return

x*y;

print

reduce(prod,

[2,

4,

5,

7,

12])

內(nèi)置高階函數(shù)filter():filter函數(shù)接受函數(shù)參數(shù)f和列表參數(shù)list，f對(duì)list元素進(jìn)行判斷，返回lst的元素中調(diào)用f函數(shù)結(jié)果為true的元素組成的列表（將不滿足f函數(shù)條件的元素過濾掉）；import

math

def

is_sqr(x):

return

int(math.sqrt(x))*int(math.sqrt(x))==x

print

filter(is_sqr,

range(1,

101))自定義排序函數(shù)sorted():sorted函數(shù)接受一個(gè)列表lst和一個(gè)函數(shù)參數(shù)f，f為自定義的比較lst元素大小的函數(shù)，返回值為lst中元素按f函數(shù)排列的列表；def

cmp_ignore_case(s1,

s2):

return

cmp(s1.lower(),s2.lower())

print

sorted(['bob',

'about',

'Zoo',

'Credit'],

cmp_ignore_case)

返回函數(shù)：def

calc_prod(lst):

def

prod(x,y):

return

x*y;

def

g():

return

reduce(prod,lst)

return

g;

f

=

calc_prod([1,

2,

3,

4])

print

f()

閉包：內(nèi)層函數(shù)使用外層函數(shù)的參數(shù)，然后返回內(nèi)層函數(shù)；def

count():

fs

=

[]

for

i

in

range(1,

4):

def

f(j):

def

g():

return

j*j;

return

g

fs.append(f(i))

return

fs

f1,

f2,

f3

=

count()

print

f1(),

f2(),

f3()

匿名函數(shù)：傳入函數(shù)參數(shù)不需要顯式定義函數(shù)，可以用lambdax:statement

x為參數(shù)，statement為對(duì)參數(shù)執(zhí)行的語句；[python]\o"viewplain"viewplain\o"copy"copydef

is_not_empty(s):

return

s

and

len(s.strip())

>

0

print

filter(lambda

s:s

and

len(s.strip())>0,

['test',

None,

'',

'str',

'

',

'END'])

裝飾器：給函數(shù)添加新功能，并簡化該函數(shù)調(diào)用；無參數(shù)裝飾器示例：[python]\o"viewplain"viewplain\o"copy"copydef

log(f):

def

fn(*args,

**kw):

#*args，**kw保證對(duì)任意個(gè)數(shù)參數(shù)都能正常調(diào)用

print

'call

'

+

f.__name__

+

'()...'

return

f(*args,

**kw)

return

fn

@log

#調(diào)用日記裝飾器

def

factorial(n):

return

reduce(lambda

x,y:

x*y,

range(1,

n+1))

print

factorial(10)

call

factorial()...

3628800

帶參數(shù)裝飾器示例：[python]\o"viewplain"viewplain\o"copy"copydef

log(prefix):

def

log_decorator(f):

def

wrapper(*args,

**kw):

print

'[%s]

%s()...'

%

(prefix,

f.__name__)

return

f(*args,

**kw)

return

wrapper

return

log_decorator

@log('DEBUG')#DEBUG為給裝飾器傳入的參數(shù)

def

test():

pass

print

test()

執(zhí)行結(jié)果

[DEBUG]

test()...

None

運(yùn)用functool.wraps作用在返回的新函數(shù)上，使得調(diào)用裝飾器以后不改變?cè)瘮?shù)的信息[python]\o"viewplain"viewplain\o"copy"copyimport

time,

functools

def

performance(unit):

def

perf_decorator(f):

@functools.wraps(f)

def

wrapper(*args,

**kw):

t1

=

time.time()

r

=

f(*args,

**kw)

t2

=

time.time()

t

=

(t2

-

t1)

*

1000

if

unit=='ms'

else

(t2

-

t1)

print

'call

%s()

in

%f

%s'

%

(f.__name__,

t,

unit)

return

r

return

wrapper

return

perf_decorator

@performance('ms')

def

factorial(n):

return

reduce(lambda

x,y:

x*y,

range(1,

n+1))

print

factorial.__name__

偏函數(shù)：functools.partial(f,f的默認(rèn)參數(shù))

減少需要提供應(yīng)f的參數(shù)[python]\o"viewplain"viewplain\o"copy"copyimport

functools

int2

=

functools.partial(int,

base=2)

int2('1000000')

64

python裝飾器作用：為已存在的函數(shù)添加功能：參考：python兩個(gè)list求交集，并集，差集在python中，數(shù)組可以用list來表達(dá)。假如有兩個(gè)數(shù)組，分別規(guī)定交集，并集與差集，怎么實(shí)現(xiàn)比較方便呢？

當(dāng)然最容易想到的是對(duì)兩個(gè)數(shù)組做循環(huán)，即寫兩個(gè)for循環(huán)來實(shí)現(xiàn)。這種寫法大部分同學(xué)應(yīng)當(dāng)都會(huì)，并且也沒有太多的技術(shù)含量，本博主就不解釋了。這里給大家使用更為裝bility的一些方法。老規(guī)矩，talkischeap,showmethecode#!/usr/bin/envpython#coding:utf-8'''Createdon2023年6月9日@author:lei.wang'''defdiff(listA,listB):#求交集的兩種方式retA=[iforiinlistAifiinlistB]retB=list(set(listA).intersection(set(listB)))print"retAis:",retAprint"retBis:",retB#求并集retC=list(set(listA).union(set(listB)))print"retC1is:",retC#求差集，在B中但不在A中retD=list(set(listB).difference(set(listA)))print"retDis:",retDretE=[iforiinlistBifinotinlistA]print"retEis:",retEdefmain():listA=[1,2,3,4,5]listB=[3,4,5,6,7]diff(listA,listB)if__name__=='__main__':main()讓coderun起來retAis:[3,4,5]retBis:[3,4,5]retC1is:[1,2,3,4,5,6,7]retDis:[6,7]retEis:[6,7]python類變量和實(shí)例變量classPerson:name=[]p1=Person()p2=Person().append(1)#[1]#[1]printP#[1]classTest(object):num_of_instance=0def__init__(self,name):=nameTest.num_of_instance+=1if__name__=='__main__':printTest.num_of_instancet1=Test('jack')printTest.num_of_instancet2=Test('lucy'),t1.num_of_,t2.num_of_instanceclassPerson:

name="aaa"

p1=Person()p2=Person()="bbb"

#

#aaaprintP

#aaa類變量就是供類使用的變量,實(shí)例變量就是供實(shí)例使用的.這里="bbb"是實(shí)例調(diào)用了類變量,這其實(shí)和上面第一個(gè)問題同樣,就是函數(shù)傳參的問題,一開始是指向的類變量name="aaa",但是在實(shí)例的作用域里把類變量的引用改變了,就變成了一個(gè)實(shí)例變量,不再引用Person的類變量name了.可以看看下面的例子:123456789classPerson:

name=[]

p1=Person()p2=Person().append(1)

#[1]

#[1]printP

#[1]python推導(dǎo)式列表推導(dǎo)式(list)提供一種方便的列表創(chuàng)建方法，返回一個(gè)列表。格式：用中括號(hào)括起來，中間用for語句，后面跟if語句用作判讀，滿足條件的傳到for語句前面用作構(gòu)建先的列表.li=[i*2foriinrange(10)ifi%2==0]print(li)[0,4,8,12,16]

字典推導(dǎo)式(dic)格式：d={key:valuefor(key,value)initerable}mca={"a":1,"b":2,"c":3,"d":4}dicts={v:kfork,vinmca.items()}Python中單下劃線和雙下劃線_foo:在一個(gè)模塊中以單下劃線開頭的變量和函數(shù)被默認(rèn)當(dāng)作內(nèi)部函數(shù)，假如使用froma_moduleimport*導(dǎo)入時(shí)，這部分變量和函數(shù)不會(huì)被導(dǎo)入。但是值得注意的是，假如使用importa_module這樣導(dǎo)入模塊，仍然可以用a_module._some_var這樣的形式訪問到這樣的對(duì)象。一種約定,用來指定變量私有.程序員用來指定私有變量的一種方式.__foo:這個(gè)有真正的意義:解析器用_classname__foo來代替這個(gè)名字,以區(qū)別和其他類相同的命名.雙下劃線開頭的命名形式在Python的類成員中使用表達(dá)名字改編(NameMangling)，即假如有一Test類里有一成員__x，那么dir(Test)時(shí)會(huì)看到_Test__x而非__x。這是為了避免該成員的名稱與子類中的名稱沖突。但要注意這規(guī)定該名稱末尾沒有下劃線.__foo__:一種約定,Python內(nèi)部的名字,用來區(qū)別其他用戶自定義的命名,以防沖突.雙下劃線開頭雙下劃線結(jié)尾的是一些Python的“魔術(shù)”對(duì)象，如類成員的__init__、__del__、__add__、__getitem__等，以及全局的__file__、__name__等。Python官方推薦永遠(yuǎn)不要將這樣的命名方式應(yīng)用于自己的變量或函數(shù)，而是按照文檔說明來使用。classMyClass():def__init__(self):self.__superprivate="Hello"self._semiprivate=",world!"mc=MyClass()printmc.__superprivateTraceback(mostrecentcalllast):File"<stdin>",line1,in<module>AttributeError:myClassinstancehasnoattribute'__superprivate'printmc._semiprivate,world!printmc.__dict__{'_MyClass__superprivate':'Hello','_semiprivate':',world!'}Python的is和==python中的對(duì)象包含三要素：id、type、value其中id用來唯一標(biāo)記一個(gè)對(duì)象。is是對(duì)比地址==是對(duì)比值read，readline和readlines

read讀取整個(gè)文獻(xiàn)。readline讀取下一行，使用生成器方法。readlines讀取整個(gè)文獻(xiàn)到一個(gè)迭代器以供我們遍歷。f=open('poem.txt','r')a=f.read()print(a)f=open('poem.txt','r')result=list()forlineinf:line=f.readline()print(line)result.append(line)print(result)f.close()f=open('poem.txt','r')#以讀方式打開文獻(xiàn)result=list()forlineinf.readlines():#依次讀取每行l(wèi)ine=line.strip()#去掉每行頭尾空白ifnotlen(line)orline.startswith('#'):#判斷是否是空行或注釋行continue#是的話，跳過不解決result.append(line)#保存result.sort()#排序結(jié)果printresult字符串格式化:%和.format對(duì)于%最煩人的是它無法同時(shí)傳遞一個(gè)變量和元組.name=(1,2,3)print("hithere%s"%name)#報(bào)錯(cuò)print("hithere%s"%(name,))#提供一個(gè)單元素的數(shù)組而不是一個(gè)參數(shù)

format通過{}和.來代替%通過位置：print("{0},{1}".format('lujf',123))通過關(guān)鍵字參數(shù)print("{name},{age}".format(name='lujf',age=23))

通過對(duì)象屬性classPerson:def__init__(self,name,age):,self.age=name,agedef__str__(self):return'Thisguyis{},is{self.age}old'.format(self=self)

通過下標(biāo)p=['lujf',23]print('{0[0]},{0[1]}'.format(p)

迭代器和生成器迭代器：迭代器是訪問集合元素的一種方式。迭代器對(duì)象從集合的第一個(gè)元素開始訪問，知道所有的元素被訪問完結(jié)束。迭代器只能往前不會(huì)后退。

對(duì)于原生支持隨機(jī)訪問的數(shù)據(jù)結(jié)構(gòu)（如tuple、list），迭代器和經(jīng)典for循環(huán)的索引訪問相比并無優(yōu)勢(shì)，反而丟失了索引值（可以使用內(nèi)建函數(shù)enumerate()找回這個(gè)索引值）。但對(duì)于無法隨機(jī)訪問的數(shù)據(jù)結(jié)構(gòu)（比如set）而言，迭代器是唯一的訪問元素的方式。迭代器的一大優(yōu)點(diǎn)是不規(guī)定事先準(zhǔn)備好整個(gè)迭代過程中所有的元素。迭代器僅僅在迭代到某個(gè)元素時(shí)才計(jì)算該元素，而在這之前或之后，元素可以不存在或者被銷毀。這個(gè)特點(diǎn)使得它特別適合用于遍歷一些巨大的或是無限的集合，比如幾個(gè)G的文獻(xiàn)，或是斐波那契數(shù)列等等迭代器更大的功勞是提供了一個(gè)統(tǒng)一的訪問集合的接口，只要定義了__iter__()方法對(duì)象，就可以使用迭代器訪問。迭代器有兩個(gè)基本的方法next方法：返回迭代器的下一個(gè)元素__iter__方法：返回迭代器對(duì)象自身classFab(object):def__init__(self,max):self.max=maxself.n,self.a,self.b=0,0,1def__iter__(self):returnselfdefnext(self):ifself.n<self.max:r=self.bself.a,self.b=self.b,self.a+self.bself.n=self.n+1returnrraiseStopIteration()#python解決迭代器越界是拋出StopIteration異常

使用迭代器：使用內(nèi)建的工廠函數(shù)iter(iterable)可以獲取迭代器對(duì)象：>>>lst=range(5)>>>it=iter(lst)>>>it<listiteratorobjectat0x01A63110>使用next()方法可以訪問下一個(gè)元素：>>>it.next()0>>>it.next()1>>>it.next()2

事實(shí)上，由于迭代器如此普遍，python專門為for關(guān)鍵字做了迭代器的語法糖。在for循環(huán)中，Python將自動(dòng)調(diào)用工廠函數(shù)iter()獲得迭代器，自動(dòng)調(diào)用next()獲取元素，還完畢了檢查StopIteration異常的工作。生成器：帶有yield的函數(shù)在Python中被稱之為generator（生成器）。deffab(max):n,a,b=0,0,1whilen<max:yieldba,b=b,a+bn=n+1

簡樸地講，yield的作用就是把一個(gè)函數(shù)變成一個(gè)generator，帶有yield的函數(shù)不再是一個(gè)普通函數(shù)，Python解釋器會(huì)將其視為一個(gè)generator，調(diào)用fab(5)不會(huì)執(zhí)行fab函數(shù)，而是返回一個(gè)

iterable對(duì)象！在for循環(huán)執(zhí)行時(shí)，每次循環(huán)都會(huì)執(zhí)行fab函數(shù)內(nèi)部的代碼，執(zhí)行到

yieldb時(shí)，fab函數(shù)就返回一個(gè)迭代值，下次迭代時(shí)，代碼從yieldb的下一條語句繼續(xù)執(zhí)行，而函數(shù)的本地變量看起來和上次中斷執(zhí)行前是完全同樣的，于是函數(shù)繼續(xù)執(zhí)行，直到再次碰到y(tǒng)ield?？雌饋砭头路鹨粋€(gè)函數(shù)在正常執(zhí)行的過程中被yield中斷了數(shù)次，每次中斷都會(huì)通過yield返回當(dāng)前的迭代值。return的作用在一個(gè)生成器中，假如沒有return，則默認(rèn)執(zhí)行到函數(shù)完畢；假如碰到return,假如在執(zhí)行過程中return，則直接拋出StopIteration終止迭代。Python重載（python自然就不需要函數(shù)重載）引自知乎:函數(shù)重載重要是為了解決兩個(gè)問題。可變參數(shù)類型。可變參數(shù)個(gè)數(shù)。此外，一個(gè)基本的設(shè)計(jì)原則是，僅僅當(dāng)兩個(gè)函數(shù)除了參數(shù)類型和參數(shù)個(gè)數(shù)不同以外，其功能是完全相同的，此時(shí)才使用函數(shù)重載，假如兩個(gè)函數(shù)的功能其實(shí)不同，那么不應(yīng)當(dāng)使用重載，而應(yīng)當(dāng)使用一個(gè)名字不同的函數(shù)。好吧，那么對(duì)于情況1，函數(shù)功能相同，但是參數(shù)類型不同，python如何解決？答案是主線不需要解決，由于python可以接受任何類型的參數(shù)，假如函數(shù)的功能相同，那么不同的參數(shù)類型在python中很也許是相同的代碼，沒有必要做成兩個(gè)不同函數(shù)。那么對(duì)于情況2，函數(shù)功能相同，但參數(shù)個(gè)數(shù)不同，python如何解決？大家知道，答案就是缺省參數(shù)。對(duì)那些缺少的參數(shù)設(shè)定為缺省參數(shù)即可解決問題。由于你假設(shè)函數(shù)功能相同，那么那些缺少的參數(shù)終歸是需要用的。好了，鑒于情況1跟情況2都有了解決方案，python自然就不需要函數(shù)重載了。__new__和__init__的區(qū)別lassBook(object):def__new__(cls,title):print'__new__'returnsuper(Book,cls).__new__(cls)def__init__(self,title):print'__init__'super(Book,self).__init__(self)self.title=titleb=Book('TheDjangoBook')print(b.title)官方文檔：__init__是當(dāng)實(shí)例對(duì)象創(chuàng)建完畢后被調(diào)用的，然后設(shè)立對(duì)象屬性的一些初始值。__new__是在實(shí)例創(chuàng)建之前被調(diào)用的，由于它的任務(wù)就是創(chuàng)建實(shí)例然后返回該實(shí)例，是個(gè)靜態(tài)方法也就是，__new__在__init__之前被調(diào)用，__new__的返回值（實(shí)例）將傳遞給__init__方法的第一個(gè)參數(shù)，然后__init__給這個(gè)實(shí)例設(shè)立一些參數(shù)。GIL線程全局鎖線程全局鎖(GlobalInterpreterLock),即Python為了保證線程安全而采用的獨(dú)立線程運(yùn)營的限制,說白了就是一個(gè)核只能在同一時(shí)間運(yùn)營一個(gè)線程.協(xié)程簡樸點(diǎn)說協(xié)程是進(jìn)程和線程的升級(jí)版,進(jìn)程和線程都面臨著內(nèi)核態(tài)和用戶態(tài)的切換問題而花費(fèi)許多切換時(shí)間,而協(xié)程就是用戶自己控制切換的時(shí)機(jī),不再需要陷入系統(tǒng)的內(nèi)核態(tài).lambda函數(shù)簡樸來說，編程中提到的lambda表達(dá)式，通常是在需要一個(gè)函數(shù)，但是又不想費(fèi)心去命名一個(gè)函數(shù)的場合下使用，也就是指匿名函數(shù)。map(lambdax:x*x,[yforyinrange(10)])defsq(x):returnx*xmap(sq,[yforyinrange(10)])map()函數(shù)接受兩個(gè)參數(shù)，一個(gè)是函數(shù)，一個(gè)是序列，map將傳入的函數(shù)依次作用到序列的每個(gè)元素，并把結(jié)果作為新的list返回。函數(shù)閉包：閉包(closure)是函數(shù)式編程的重要的語法結(jié)構(gòu)。閉包也是一種組織代碼的結(jié)構(gòu)，它同樣提高了代碼的可反復(fù)使用性。當(dāng)一個(gè)內(nèi)嵌函數(shù)引用其外部作作用域的變量,我們就會(huì)得到一個(gè)閉包.總結(jié)一下,創(chuàng)建一個(gè)閉包必須滿足以下幾點(diǎn):必須有一個(gè)內(nèi)嵌函數(shù)內(nèi)嵌函數(shù)必須引用外部函數(shù)中的變量外部函數(shù)的返回值必須是內(nèi)嵌函數(shù)感覺閉包還是有難度的,幾句話是說不明白的,還是查查相關(guān)資料.重點(diǎn)是函數(shù)運(yùn)營后并不會(huì)被撤消,就像16題的instance字典同樣,當(dāng)函數(shù)運(yùn)營完后,instance并不被銷毀,而是繼續(xù)留在內(nèi)存空間里.這個(gè)功能類似類里的類變量,只但是遷移到了函數(shù)上.閉包就像個(gè)空心球同樣,你知道外面和里面,但你不知道中間是什么樣.defmake_adder(addend1):

print(addend1)

defadder(addend):

returnaddend1+addend

returnadder

P1=make_adder(5)

P2=make_adder(4)

print(P1(10))super的原理重新實(shí)現(xiàn)str.strip()defrightStrip(tempStr,splitStr):endindex=tempStr.rfind(splitStr)whileendindex!=-1andendindex==len(tempStr)-1:tempStr=tempStr[:endindex]endindex=tempStr.rfind(splitStr)returntempStrdefleftStrip(tempStr,splitStr):startindex=tempStr.find(splitStr)whilestartindex==0:tempStr=tempStr[startindex+1:]startindex=tempStr.find(splitStr)