免费视频淫片aa毛片_日韩高清在线亚洲专区vr_日韩大片免费观看视频播放_亚洲欧美国产精品完整版

其實我覺得Python里面這樣的語法更容易理解面向?qū)ο蟮谋举|(zhì)， 比Java中隱式地傳this更容易理解。所謂函數(shù)，就是一段代碼，接受輸入，返回輸出。所謂方法，就是一個函數(shù)有了一個隱式傳遞的參數(shù)。所以方法就是一段代碼，是類的所有實例共享， 唯一不同的是各個實例調(diào)用的時候傳給方法的this 或者self不一樣而已。構(gòu)造方法是什么呢？其實也是一個實例方法啊，它只有在對象生成了之后才能調(diào)用，所以Python中__init__方法的參數(shù)是self啊。調(diào)用構(gòu)造方法時其實已經(jīng)為對象分配了內(nèi)存, 構(gòu)造方法只是起到初始化的作用，也就是為這段內(nèi)存里面賦點初值而已。Java中所謂的靜態(tài)變量其實也就是類的變量， 其實也就是為類也分配了內(nèi)存，里面存了這些變量，所以Python中的類對象我覺得是很合理的，也比Java要直觀。至于靜態(tài)方法，那就與對象一點關(guān)系都沒有了，本質(zhì)就是個獨立的函數(shù)，只不過寫在了類里面而已。而Python中的classmethod其實也是一種靜態(tài)方法，不過它會依賴于cls對象，這個cls就是類對象，但是只要想用這個方法，類對象必然是存在的，不像實例對象一樣需要手動的實例化，所以classmethod也可以看做是一種靜態(tài)變量。而staticmethod就是真正的靜態(tài)方法了，是獨立的函數(shù)，不依賴任何對象。Java中的實例方法是必須依賴于對象存在的, 因為要隱式的傳輸this，如果對象不存在這個this也沒法隱式了。所以在靜態(tài)方法中是沒有this指針的，也就沒法調(diào)用實例方法。而Python中的實例方法是可以通過類名來調(diào)用的。只不過因為這時候self沒辦法隱式傳遞，所以必須得顯式地傳遞。22.__call__回調(diào)函數(shù)一般來說，魔法方法都是隱式調(diào)用的__call__()放在類中定義。python中，函數(shù)是一個對象>>> f = abs #絕對值函數(shù)>>> f.__name__'abs'>>> f(-10)10由于 f 可以被調(diào)用，所以，f 被稱為可調(diào)用對象。所有的函數(shù)都是可調(diào)用對象。一個類實例也可以變成一個可調(diào)用對象，只需要實現(xiàn)一個特殊方法__call__()。我們把 Person 類變成一個可調(diào)用對象：class Person(object): def __init__(self, name, gender): self.name = name self.gender = gender def __call__(self, friend): print 'My name is %s...' % self.name print 'My friend is %s...' % friend現(xiàn)在可以對 Person 實例直接調(diào)用：>>> person = Person('Bob', 'male')>>> person('Tim')My name is Bob...My friend is Tim...單看 person('Tim') 你無法確定 p 是一個函數(shù)還是一個類實例，所以，在Python中，函數(shù)也是對象，對象和函數(shù)的區(qū)別并不顯著。23.dict的get函數(shù)get函數(shù)相比較于通過下標的方式獲取值得好處就是，即使字典中沒有想要的key，也會根據(jù)get后面的參數(shù)輸出結(jié)果，對用戶友好；而下標方式直接報錯>>> a = {'a':1,'b':2}>>> a.get('a')1>>> a.get('c',"None")'None'24.hasattr() getattr() setattr() 函數(shù)使用方法詳解hasattr(object, name)判斷一個對象里面是否有name屬性或者name方法，返回BOOL值，有name特性返回True， 否則返回False。需要注意的是name要用括號括起來>>> class test():... name="xiaohua"... def run(self):... return "HelloWord"...>>> t=test()>>> hasattr(t, "name") #判斷對象有name屬性True>>> hasattr(t, "run") #判斷對象有run方法Truegetattr(object, name[,default])獲取對象object的屬性或者方法，如果存在打印出來，如果不存在，打印出默認值，默認值可選。需要注意的是，如果是返回的對象的方法，返回的是方法的內(nèi)存地址，如果需要運行這個方法，可以在后面添加一對括號。>>> class test():... name="xiaohua"... def run(self):... return "HelloWord"...>>> t=test()>>> getattr(t, "name") #獲取name屬性，存在就打印出來。'xiaohua'>>> getattr(t, "run") #獲取run方法，存在就打印出方法的內(nèi)存地址。<bound method test.run of <__main__.test instance at 0x0269C878>>>>> getattr(t, "run"()) #獲取run方法，后面加括號可以將這個方法運行。'HelloWord'>>> getattr(t, "age") #獲取一個不存在的屬性。Traceback (most recent call last): File "<stdin>", line 1, in <module>AttributeError: test instance has no attribute 'age'>>> getattr(t, "age","18") #若屬性不存在，返回一個默認值。'18'setattr(object, name, values)給對象的屬性賦值，若屬性不存在，先創(chuàng)建再賦值。>>> class test():... name="xiaohua"... def run(self):... return "HelloWord"...>>> t=test()>>> hasattr(t, "age") #判斷屬性是否存在False>>> setattr(t, "age", "18") #為屬相賦值，并沒有返回值>>> hasattr(t, "age") #屬性存在了True一種綜合的用法是：判斷一個對象的屬性是否存在，若不存在就添加該屬性。>>> class test():... name="xiaohua"... def run(self):... return "HelloWord"...>>> t=test()>>> getattr(t, "age") #age屬性不存在Traceback (most recent call last): File "<stdin>", line 1, in <module>AttributeError: test instance has no attribute 'age'>>> getattr(t, "age", setattr(t, "age", "18")) #age屬性不存在時，設(shè)置該屬性'18'>>> getattr(t, "age") #可檢測設(shè)置成功'18'25.object，type和metaclass的關(guān)系type類是元類，用來創(chuàng)建類(對象)的，事實是調(diào)用了type的__new__創(chuàng)建的類(對象)__new__是用來創(chuàng)建實例對象的，如果沒有復(fù)寫__new__方法，事實上是調(diào)用了object的__new__metaclass關(guān)鍵字是用來定制元類的，這樣子后續(xù)我們定義的類就可以用定制的元類來創(chuàng)建。經(jīng)典的運用就是ORMtype也是繼承了object，并對object的__new__進行了復(fù)寫父類（對象）先創(chuàng)建，之后才是子類（對象）26.淺拷貝和深拷貝普通的賦值在python中是淺拷貝，及傳遞的是對象的引用；若要深拷貝，必須導(dǎo)入copy模塊copy.copy 淺拷貝 只拷貝父對象，不會拷貝對象的內(nèi)部的子對象。copy.deepcopy 深拷貝 拷貝對象及其子對象import copya = [1, 2, 3, 4, ['a', 'b']] #原始對象 b = a #賦值，傳對象的引用c = copy.copy(a) #對象拷貝，淺拷貝d = copy.deepcopy(a) #對象拷貝，深拷貝 a.append(5) #修改對象aa[4].append('c') #修改對象a中的['a', 'b']數(shù)組對象 print 'a = ', aprint 'b = ', bprint 'c = ', cprint 'd = ', d輸出結(jié)果：a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]c = [1, 2, 3, 4, ['a', 'b', 'c']]d = [1, 2, 3, 4, ['a', 'b']]深拷貝在拷貝的時候，若拷貝對象里包含引用，不僅拷貝引用，而且把引用的內(nèi)容也再復(fù)制一份。理解深的含義。27.私有屬性是可以訪問的python中定義私有屬性的方法是在變量名前加'_'或者'__'_foo:一種約定，用來指定變量私有。程序員用來指定私有變量的一種方式。但是外部仍可直接訪問__foo:這個有真正的意義：解析器用_classname__foo來代替這個名字，以區(qū)別和其他類相同的命名。但是我們可以訪問私有屬性，因為python中私有屬性是通過名字重整的機制實現(xiàn)的，改變了私有屬性名，從而報出name defined異常。In [19]: class A(): ...: def __init__(self): ...: self.__num=100 ...: In [20]: a=A()In [21]: a.__num---------------------------------------------------------------AttributeError: 'A' object has no attribute '__num'In [22]: dir(a)Out[22]: ['_A__num', '__class__',... '__weakref__']In [23]: a._A__numOut[23]: 10028.屬性攔截器__getattribute__當訪問對象的屬性時，其實先調(diào)用對象中的魔法方法__getattribute__class Itcast(object): def __init__(self,subject1): self.subject1 = subject1 self.subject2 = 'cpp' #屬性訪問時攔截器，打log def __getattribute__(self,obj): if obj == 'subject1': print('log subject1') return 'redirect python' else: #測試時注釋掉這2行，將找不到subject2 return object.__getattribute__(self,obj) def show(self): print('this is Itcast')s = Itcast("python")print(s.subject1)print(s.subject2)log subject1redirect pythoncpp29.對象中都是屬性，方法只不過是屬性的引用In [24]: class A(): ...: pass ...: In [25]: a=A()In [26]: a.f---------------------------------------------------------------AttributeError: 'A' object has no attribute 'f'In [27]: a.f()---------------------------------------------------------------AttributeError: 'A' object has no attribute 'f'所以當調(diào)用a.f()的時候也會默認執(zhí)行類中__getattribute__方法30.GIL全局解釋器鎖從名字上看能告訴我們很多東西，很顯然，這是一個加在解釋器上的全局（從解釋器的角度看）鎖（從互斥或者類似角度看）。GIL使得同一時刻只有一個線程在一個CPU上執(zhí)行字節(jié)碼，無法保證多個線程映射到多個CPU上執(zhí)行。對于任何Python程序，不管有多少的處理器，任何時候都總是只有一個線程在執(zhí)行。事實上，線程并不是完全運行完成后釋放GIL，所以線程安全也是相對的在Python多線程下，每個線程的執(zhí)行方式：1.獲取GIL2.執(zhí)行代碼直到sleep或者是python虛擬機將其掛起（虛擬機會根據(jù)執(zhí)行的字節(jié)碼行數(shù)以及時間片釋放GIL）或者遇到IO操作3.釋放GIL可見，某個線程想要執(zhí)行，必須先拿到GIL，我們可以把GIL看作是“通行證”，并且在一個python進程中，GIL只有一個。拿不到通行證的線程，就不允許進入CPU執(zhí)行解決辦法就是多進程和協(xié)程(協(xié)程也只是單CPU，單線程但是能減小切換代價提升性能)。31.當函數(shù)的參數(shù)是list引發(fā)的問題==比較的是值的大??；is是比較地址？？？32.上下文管理 __enter__,__exit__應(yīng)用場景：文件的讀寫數(shù)據(jù)庫的讀寫操作Flask的上下文管理上下文管理協(xié)議：當使用with語句時，解釋器會自動調(diào)用 __enter__,__exit__class Sample: def __enter__(self): print('enter') #進入資源 return self def __exit__(self, exc_type, exc_val, exc_tb): print('exit') #釋放資源 def do_something(self): print('do something')with Sample() as sample: sample.do_something()輸出enterdo somethingexit進入with語句，調(diào)用__enter__；退出with語句，調(diào)用__exit__事實上sample并不是sample=Sample()，而是__enter__返回的對象，即如果__enter__沒有return，sample將為None。exc_type：異常類型；exc_val：異常值；exc_tb：traceback。如果with語句中有異常發(fā)生，__exit__中會收集這些異常信息。33.__slots__Python是一門動態(tài)語言，可以在運行過程中，修改實例的屬性和增刪方法。一般，任何類的實例包含一個字典dict,Python通過這個字典可以將任意屬性綁定到實例上。有時候我們只想使用固定的屬性，而不想任意綁定屬性，這時候我們可以定義一個屬性名稱集合，只有在這個集合里的名稱才可以綁定。slots就是完成這個功能的。class test_slots(object): __slots__='x','y' def printHello(self): print 'hello!' class test(object): def printHello(self): print 'hello' print dir(test_slots) #可以看到test_slots類結(jié)構(gòu)里面包含__slots__,x,y print dir(test)#test類結(jié)構(gòu)里包含__dict__ print '**************************************' ts=test_slots() t=test() print dir(ts) #可以看到ts實例結(jié)構(gòu)里面包含__slots__,x,y，不能任意綁定屬性 print dir(t) #t實例結(jié)構(gòu)里包含__dict__,可以任意綁定屬性 print '***************************************' ts.x=11 #只能綁定__slots__名稱集合里的屬性 t.x=12 #可以任意綁定屬性 print ts.x,t.x ts.y=22 #只能綁定__slots__名稱集合里的屬性 t.y=23 #可以任意綁定屬性 print ts.y,t.y #ts.z=33 #無法綁定__slots__集合之外的屬性(AttributeError: 'test_slots' object has no attribute 'z') t.z=34 #可以任意綁定屬性 print t.z正如上面所說的，默認情況下,Python的新式類和經(jīng)典類的實例都有一個dict來存儲實例的屬性。這在一般情況下還不錯，而且非常靈活，乃至在程序中可以隨意設(shè)置新的屬性。但是，對一些在”編譯”前就知道有幾個固定屬性的小class來說，這個dict就有點浪費內(nèi)存了。當需要創(chuàng)建大量實例的時候，這個問題變得尤為突出。一種解決方法是在新式類中定義一個slots屬性。slots聲明中包含若干實例變量，并為每個實例預(yù)留恰好足夠的空間來保存每個變量；這樣Python就不會再使用dict，從而節(jié)省空間。34.__unicode__,__str____unicode__，__str__類似于java的toString方法。在java中，當打印對象的時候，其實是調(diào)用了對象的toString方法。同樣，我們可以定制對象打印輸出的格式unicode是用在python2里，而str是用在python3里#不復(fù)寫__str__方法，調(diào)用的是object的方法class A: def __init__(self,name,age): self.name=name self.age=agea=A('lu',25)print(a) #<__main__.A object at 0x101978cf8>#復(fù)寫__str__方法，調(diào)用的是object的方法class A: def __init__(self,name,age): self.name=name self.age=age def __str__(self): return self.name + ' is ' + str(self.age) + ' years old'a=A('lu',25)print(a) #lu is 25 years old35.文件緩沖36.for不可對可迭代對象進行修改在使用python的可迭代對象時有一條定律，那就是永遠都不要對迭代對象進行數(shù)據(jù)的修改。 我們可以用copy()，生成一個副本，對這個副本進行遍歷。In [10]: l = ['a','b','c','d']In [11]: for index,key in enumerate(l): ...: if key == 'c': ...: l.pop(index)In [12]: l['a', 'b', 'c'] ########推薦 for index,key in enumerate(l.copy()): ...: if key == 'c': ...: l.pop(index)37.__getitem__和 __setitem__方法來實現(xiàn)“[ ]”符號的使用class Map: def __init__(self): self.Q_key = [] self.Q_value = [] def put(self, key, value): self.Q_key.append(key) self.Q_value.append(value) def get(self, key, default=None): for index,k in enumerate(self.Q_key): if k == key: return self.Q_value[index] return default def __getitem__(self, key): return self.get(key) def __setitem__(self, key, value): self.put(key, value)m = Map()m['a']=1m['b']=2print(m['b'])38.list的倒序切片In [1]: l=[1,2,3,4,5,6]In [7]: l[-1:1:-1]Out[7]: [6, 5, 4, 3]In [8]: l[-1:0:-1]Out[8]: [6, 5, 4, 3, 2]In [9]: l[-1::-1]Out[9]: [6, 5, 4, 3, 2, 1]39.字節(jié)流與字符流40.__name__的含義#a.pyprint(__name__)運行a.py，執(zhí)行結(jié)果為__main__。但如果對于一個b.py作為模塊在a中使用，b的__name__將變成對應(yīng)b的模塊名#b.pyprint(__name__)#a.pyimport b運行a.py（如果運行b.py，結(jié)果扔是main），執(zhí)行結(jié)果為b所以為了測試模塊的相應(yīng)功能，而避免在主程序中運行，通常我們需要在執(zhí)行的代碼中這樣寫if __name__ == '__main__': do something這樣子就能很好的控制模塊的有效輸出41.為什么不能用可變對象作為函數(shù)的默認參數(shù)值先來看一道題目：>>> def func(numbers=[], num=1):... numbers.append(num)... return numbers>>> func()[1]>>> func()[1, 1]>>> func()[1, 1, 1]我們似乎發(fā)現(xiàn)了一個Bug，每次用相同的方式調(diào)用函數(shù) func() 時，返回結(jié)果竟然不一樣，而且每次返回的列表在不斷地變長。>>> id(func())4330472840>>> id(func())4330472840從上面可以看出，函數(shù)的返回值其實是同一個列表對象，因為他們的id值是一樣的，只不過是列表中的元素在變化。為什么會這樣呢？這要從函數(shù)的特性說起，在 Python 中，函數(shù)是第一類對象(function is the first class object)，換而言之，函數(shù)也是對象，跟整數(shù)、字符串一樣可以賦值給變量、當做參數(shù)傳遞、還可以作為返回值。函數(shù)也有自己的屬性，比如函數(shù)的名字、函數(shù)的默認參數(shù)列表。# 函數(shù)的名字>>> func.__name__ 'func'# 函數(shù)的默認參數(shù)列表>>> func.__defaults__ ([1, 1, 1, 1, 1], 1)def是一條可執(zhí)行語句，Python 解釋器執(zhí)行 def 語句時，就會在內(nèi)存中就創(chuàng)建了一個函數(shù)對象（此時，函數(shù)里面的代碼邏輯并不會執(zhí)行，因為還沒調(diào)用嘛），在全局命名空間，有一個函數(shù)名（變量叫 func）會指向該函數(shù)對象，記住，至始至終，不管該函數(shù)調(diào)用多少次，函數(shù)對象只有一個，就是function object，不會因為調(diào)用多次而出現(xiàn)多個函數(shù)對象。image函數(shù)對象生成之后，它的屬性：名字和默認參數(shù)列表都將初始化完成。image初始化完成時，屬性 __default__ 中的第一個默認參數(shù) numbers 指向一個空列表。當函數(shù)第一次被調(diào)用時，就是第一次執(zhí)行 func()時，開始執(zhí)行函數(shù)里面的邏輯代碼（此時函數(shù)不再需要初始化了），代碼邏輯就是往numbers中添加一個值為1的元素image第二次調(diào)用 func()，繼續(xù)往numbers中添加一個元素image第三次、四次依此類推。所以現(xiàn)在你應(yīng)該明白為什么調(diào)用同一個函數(shù)，返回值確每次都不一樣了吧。因為他們共享的是同一個列表(numbers)對象，只是每調(diào)用一次就往該列表中增加了一個元素如果我們顯示地指定 numbers 參數(shù)，結(jié)果截然不同。>>> func(numbers=[10, 11])[10, 11, 1]image因為numbers被重新賦值了，它不再指向原來初始化時的那個列表了，而是指向了我們傳遞過去的那個新列表對象，因此返回值變成了 [10, 11, 1]那么我們應(yīng)該如何避免前面那種情況發(fā)生呢？就是不要用可變對象作為參數(shù)的默認值。正確方式：>>> def func(numbers=None, num=1):... if numbers is None:... numbers = [num]... else:... numbers.append(num)... return numbers...>>> func()[1]>>> func()[1]>>> func()[1]如果調(diào)用時沒有指定參數(shù)，那么調(diào)用方法時，默認參數(shù) numbers 每次都被重新賦值了，所以，每次調(diào)用的時候numbers都將指向一個新的對象。這就是與前者的區(qū)別所在。那么，是不是說我們永遠都不應(yīng)該用可變對象來作為參數(shù)的默認值了嗎？并不是，既然Python有這樣的語法，就一定有他的應(yīng)用場景，就像 for … else 語法一樣。我們可以用可變對象來做緩存功能例如：計算一個數(shù)的階乘時可以用一個可變對象的字典當作緩存值來實現(xiàn)緩存，緩存中保存計算好的值，第二次調(diào)用的時候就無需重復(fù)計算，直接從緩存中拿。def factorial(num, cache={}): if num == 0: return 1 if num not in cache: print('xxx') cache[num] = factorial(num - 1) * num return cache[num]print(factorial(4))print("-------")print(factorial(4))輸出：---第一次調(diào)用---xxxxxxxxxxxx24---第二次調(diào)用---24第二次調(diào)用的時候，直接從 cache 中拿了值，所以，你說用可變對象作為默認值是 Python 的缺陷嗎？也并不是，對吧！你還是當作一種特性來使用。函數(shù)的基本注意點1.函數(shù)基礎(chǔ)之globals()和locals()函數(shù)名.__doc__，返回函數(shù)的解釋，對于函數(shù)定義時，可以將解釋通過字符串寫到執(zhí)行語句中。def abs（a=3） “this is new function“>>>abs.__doc__“this is new function“函數(shù)體執(zhí)行到return語句就結(jié)束，不管后面是否還有語句。當def一個函數(shù)時，其實就是創(chuàng)建了一個函數(shù)對象，并將函數(shù)對象返回給函數(shù)名。函數(shù)定義時的參數(shù)(a=2)可以通過函數(shù)對象的__defaults__查看每次對函數(shù)的調(diào)用都創(chuàng)建了一個新的本地作用域。作用域（命名空間），一個隱藏的字典(鍵為函數(shù)名，值為函數(shù)對象的地址)globals()函數(shù)返回全局變量的字典；locals()函數(shù)返回局部變量的字典（根據(jù)當前上下文來判斷，若處在全局的位置，等同于globals()，見下例）。locals()函數(shù)只有在函數(shù)執(zhí)行過程在才用意義，因為函數(shù)調(diào)用完成后，局部變量會從棧中刪除，所以再用locals()，沒有局部變量的字典>>> def test(arg): z = 1 print locals()>>> test(4){'z': 1, 'arg': 4}>>> test('doulaixuexi'){'z': 1, 'arg': 'doulaixuexi'}>>> print(locals())# 輸出與globals()一樣的結(jié)果>>> print(globals())在函數(shù)的定義中可以訪問全局變量（依據(jù)LEGB原則搜索變量），但不可以修改全局變量，除非使用global聲明變量a = 3def test(arg): z = 1 global a a = 100test(4)print(a)#100vars()函數(shù)返回在當前一個作用域（命名空間）的字典補充：Python使用叫做名字空間的東西來記錄變量的軌跡。名字空間只是一個 字典，它的鍵字就是變量名，字典的值就是那些變量的值。實際上，名字空間可以象Python的字典一樣進行訪問，一會我們就會看到。在一個Python程序中的任何一個地方，都存在幾個可用的名字空間。每個函數(shù)都有著自已的名字空間，叫做局部名字空間，它記錄了函數(shù)的變量，包括 函數(shù)的參數(shù)和局部定義的變量。每個模塊擁有它自已的名字空間，叫做全局名字空間，它記錄了模塊的變量，包括函數(shù)、類、其它導(dǎo)入的模塊、模塊級的變量和常 量。還有就是內(nèi)置名字空間，任何模塊均可訪問它，它存放著內(nèi)置的函數(shù)和異常。2.LEGB命名空間當一行代碼要使用變量x的值時，Python會到所有可用的名字空間去查找變量，按照如下順序：1. Local：局部名字空間特指當前函數(shù)或類的方法。如果函數(shù)定義了一個局部變量 x ，Python將使用這個變量，然后停止搜索。2. Enclosing：外部嵌套函數(shù)的命名空間（見閉包）3. Global：全局名字空間特指當前的模塊。如果模塊定義了一個名為 x 的變量，函數(shù)或類，Python將使用這個變量然后停止搜索。4. Builtin：內(nèi)置名字空間對每個模塊都是全局的。作為最后的嘗試，Python將假設(shè) x 是內(nèi)置函數(shù)或變量。如果Python在這些名字空間找不到x，它將放棄查找并引發(fā)一個 NameError 的異常，同時傳遞There is no variable named 'x' 這樣一條信息。像Python中的許多事情一樣，名字空間在運行時直接可以訪問。特別地，局部名字空間可以通過內(nèi)置的 locals 函數(shù)來訪問。全局（模塊級別）名字空間可以通過 globals 函數(shù)來訪問。變量名解析：LEGBPython中一切都是對象。每個對象都有一個名字，名字位于名字空間中，用名字變量引用對象。對象存在于內(nèi)存中一段空間。每個對象在內(nèi)存中都有地址。在Python里類型本身是對象，和實例對象一樣儲存在堆中，對于解釋器來說類對象和實例對象沒有根本上的別。所謂“定義一個函數(shù)”，實際上也就是生成一個函數(shù)對象。而“定義一個方法”就是生成一個函數(shù)對象，并把這個對象放在一個類的__dict__中。函數(shù)對象結(jié)構(gòu)定義：typedef struct { PyObject_HEAD PyObject *func_code; // PyCodeObject PyObject *func_globals; // 所在模塊的全局名字空間 PyObject *func_defaults; // 參數(shù)默認值列表 PyObject *func_closure; // 閉包列表 PyObject *func_doc; // __doc__ PyObject *func_name; // __name__ PyObject *func_dict; // __dict__ PyObject *func_weakreflist; // 弱引用鏈表 PyObject *func_module; // 所在 Module} PyFunctionObject;對象基本上可以看做數(shù)據(jù)（特性）以及由一系列可以存取，操作這些數(shù)據(jù)的方法所組成的集合所有的對象都屬于某一個類，稱為類的實例self指的是實例對象本身查看a是否是b的子類，可以使用issubclass（子類，超類）；查看a的基類a.__bases__匿名函數(shù)lambda 用法lambda argument1,argument2:expression using argument.功能類似于def，只是不需要再去定義一個函數(shù)名。結(jié)果返回的是一個函數(shù)對象。def add1(a,b): return a+badd1(2,3)=> 5g = lambda a,b:a+bg(2,3)=>53.閉包內(nèi)層函數(shù)引用了外層函數(shù)的變量(包括它的參數(shù)),然后返回內(nèi)層函數(shù)的情況,這就是閉包。形式上，在函數(shù)的內(nèi)部定義函數(shù)，并引用外部變量。函數(shù)對象是使用def語句定義的，函數(shù)對象的作用域與def所在的層級相同。比如下面代碼，我們在line_conf函數(shù)的隸屬范圍內(nèi)定義的函數(shù)line，就只能在line_conf的隸屬范圍內(nèi)調(diào)用。def line_conf(): def line(x): return 2*x+1 print(line(5)) # within the scopeline_conf() #結(jié)果11print(line(5)) # 錯誤，不能再外部調(diào)用內(nèi)部函數(shù)line可以在內(nèi)部函數(shù)line()的定義中引用（非修改）外部的變量def line_conf(): b = 15 def line(x): return 2*x+b #引用外部變量b，b有時又叫做環(huán)境變量 return line # return a function objectmy_line = line_conf()print(my_line(5)) #結(jié)果為25print(line_conf()(5)) #另一種引用方式，結(jié)果為25一個函數(shù)line和它的環(huán)境變量b合在一起，就構(gòu)成了一個閉包(closure)。在Python中，所謂的閉包是一個包含有環(huán)境變量取值的函數(shù)對象。環(huán)境變量取值被保存在函數(shù)對象的__closure__屬性中在python2.X中不能對外部變量賦值，而在python3中增加了nonlocal關(guān)鍵字def Fun1(): x=5 def Fun2(): x=x*x return x return Fun2()Fun1() #錯誤為什么需要閉包？def line_conf(a, b): def line(x): return ax + b return lineline1 = line_conf(1, 1)line2 = line_conf(4, 5)print(line1(5), line2(5))這個例子中，函數(shù)line與環(huán)境變量a,b構(gòu)成閉包。在創(chuàng)建閉包的時候，我們通過line_conf的參數(shù)a,b說明了這兩個環(huán)境變量的取值，這樣，我們就確定了函數(shù)的最終形式(y = x + 1和y = 4x + 5)。我們只需要變換參數(shù)a,b，就可以獲得不同的直線表達函數(shù)。由此，我們可以看到，閉包也具有提高代碼可復(fù)用性的作用。如果沒有閉包，我們需要每次創(chuàng)建直線函數(shù)的時候同時說明a,b,x。這樣，我們就需要更多的參數(shù)傳遞，也減少了代碼的可移植性。利用閉包，我們實際上創(chuàng)建了泛函。line函數(shù)定義一種廣泛意義的函數(shù)。這個函數(shù)的一些方面已經(jīng)確定(必須是直線)，但另一些方面(比如a和b參數(shù)待定)。隨后，我們根據(jù)line_conf傳遞來的參數(shù)，通過閉包的形式，將最終函數(shù)確定下來。