面向?qū)ο?a href="http://www.delux-kingway.cn/v/tag/1315/" target="_blank">編程和函數(shù)式編程（面向過程編程）都是程序設(shè)計的方法，不過稍有區(qū)別。

面向過程編程：

1.導(dǎo)入各種外部庫2.設(shè)計各種全局變量3.寫一個函數(shù)完成某個功能4.寫一個函數(shù)完成某個功能5.寫一個函數(shù)完成某個功能6.寫一個函數(shù)完成某個功能7.寫一個函數(shù)完成某個功能8.......9.寫一個main函數(shù)作為程序入口

在多函數(shù)程序中，許多重要的數(shù)據(jù)被放置在全局?jǐn)?shù)據(jù)區(qū)，這樣它們可以被所有的函數(shù)訪問。每個函數(shù)都可以具有它們自己的局部數(shù)據(jù)，將某些功能代碼封裝到函數(shù)中，日后便無需重復(fù)編寫，僅調(diào)用函數(shù)即可。從代碼的組織形式來看就是根據(jù)業(yè)務(wù)邏輯從上到下壘代碼 。

面向?qū)ο缶幊蹋?/p>

1.導(dǎo)入各種外部庫2.設(shè)計各種全局變量3.決定你要的類4.給每個類提供完整的一組操作5.明確地使用繼承來表現(xiàn)不同類之間的共同點6.根據(jù)需要，決定是否寫一個main函數(shù)作為程序入口

面向?qū)ο缶幊讨?，將函?shù)和變量進(jìn)一步封裝成類，類才是程序的基本元素，它將數(shù)據(jù)和操作緊密地連結(jié)在一起，并保護(hù)數(shù)據(jù)不會被外界的函數(shù)意外地改變。類和和類的實例（也稱對象）是面向?qū)ο蟮暮诵母拍?，是和面向過程編程、函數(shù)式編程的根本區(qū)別。

并不是非要用面向?qū)ο缶幊蹋茨愕某绦蛟趺丛O(shè)計方便，但是就目前來說，基本上都是在使用面向?qū)ο缶幊獭?/p>

類的基本用法

面向?qū)ο笫峭ㄟ^定義class類來定義，這么說面向?qū)ο缶幊叹褪侵皇褂胏lass類，在class類中有封裝，繼承的功能，并且還可以構(gòu)造要傳入的參數(shù)，方便控制。

案例一

importsysimporttimereload(sys)sys.setdefaultencoding('utf-8')classstudetn:#定義一個類名為studetndef__init__(self,idx):#定義初始化構(gòu)造，這里使用init，還有別的屬性比如reversed，iter之類的self.idx=idx#初始化變量，方便繼承defrunx(self):#定義運行函數(shù)，從上面繼承變量printself.idx#打印出idx的值，或者做一些別的處理time.sleep(1)a=studetn('a')a.runx()#這是類的調(diào)用，一定要記得類的使用方法，首先傳入?yún)?shù)，類賦值給一個變量a#然后調(diào)用這個類下面定義的函數(shù)

一些專業(yè)術(shù)語概念，既然有面向?qū)ο缶幊踢@個高大上的定義了，自然要搭配一些高大上的概念。

類(Class): 用來描述具有相同屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。其中的對象被稱作類的實例。

實例：也稱對象。通過類定義的初始化方法，賦予具體的值，成為一個”有血有肉的實體”。

實例化：創(chuàng)建類的實例的過程或操作。

實例變量：定義在實例中的變量，只作用于當(dāng)前實例。

類變量：類變量是所有實例公有的變量。類變量定義在類中，但在方法體之外。

數(shù)據(jù)成員：類變量、實例變量、方法、類方法、靜態(tài)方法和屬性等的統(tǒng)稱。

方法：類中定義的函數(shù)。

靜態(tài)方法：不需要實例化就可以由類執(zhí)行的方法

類方法：類方法是將類本身作為對象進(jìn)行操作的方法。

方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對父類的方法進(jìn)行改寫，這個過程也稱override。

封裝：將內(nèi)部實現(xiàn)包裹起來，對外透明，提供api接口進(jìn)行調(diào)用的機制

繼承：即一個派生類（derived class）繼承父類（base class）的變量和方法。

多態(tài)：根據(jù)對象類型的不同以不同的方式進(jìn)行處理。

類與實例

#-*-coding:utf-8-*-#@Time:2018/5/3000317:02#@Author:Langzi#@Blog:www.langzi.fun#@File:面向?qū)ο?.py#@Software:PyCharmimportsysimporttimeimportrequestsreload(sys)sys.setdefaultencoding('utf-8')classcc:ccc='ccc'#cc就是類名如果想要繼承別的類就classcc(threading)意思就是從threading繼承def__init__(self,a,b,c):self.a=aself.b=bself.c=c#定義構(gòu)造的過程就是實例化defrunx(self):printself.a*10printself.b*5printself.c*2defruny(self):printrequests.get('http://www.langzi.fun').headerse=cc('AAA','CCC','EEE')e.runx()e.runy()#這兩個就是調(diào)用類里面的方法printe.c#實例變量指的是實例本身擁有的變量。每個實例的變量在內(nèi)存中都不一樣。printe.ccc#類變量，在類里面找到定義的變量。

調(diào)用類的三種方法

實例方法

#-*-coding:utf-8-*-#@Time:2018/5/3000317:16#@Author:Langzi#@Blog:www.langzi.fun#@File:面向?qū)ο?.py#@Software:PyCharmimportsysimporttimeimportrequestsreload(sys)sys.setdefaultencoding('utf-8')classdd:def__init__(self,url):self.url=urldefrunx(self):printrequests.get(self.url).status_codea=dd('http://www.langzi.fun')a.runx()#這種調(diào)用方法就是實例方法

靜態(tài)方法

靜態(tài)方法由類調(diào)用，無默認(rèn)參數(shù)。將實例方法參數(shù)中的self去掉，然后在方法定義上方加上@staticmethod，就成為靜態(tài)方法。它屬于類，和實例無關(guān)。建議只使用類名.靜態(tài)方法的調(diào)用方式。（雖然也可以使用實例名.靜態(tài)方法的方式調(diào)用）

#-*-coding:utf-8-*-#@Time:2018/5/3000317:21#@Author:Langzi#@Blog:www.langzi.fun#@File:面向?qū)ο?.py#@Software:PyCharmimportsysimportrequestsreload(sys)sys.setdefaultencoding('utf-8')classff:@staticmethoddefrunx():printrequests.get('http://www.langzi.fun').status_codeff.runx()#這里就直接調(diào)用了類的變量，只在類中運行而不在實例中運行的方法

經(jīng)常有一些跟類有關(guān)系的功能但在運行時又不需要實例和類參與的情況下需要用到靜態(tài)方法. 比如更改環(huán)境變量或者修改其他類的屬性等能用到靜態(tài)方法. 這種情況可以直接用函數(shù)解決, 但這樣同樣會擴散類內(nèi)部的代碼，造成維護(hù)困難。

類方法

類方法由類調(diào)用，采用@classmethod裝飾，至少傳入一個cls（代指類本身，類似self）參數(shù)。執(zhí)行類方法時，自動將調(diào)用該方法的類賦值給cls。建議只使用類名.類方法的調(diào)用方式。（雖然也可以使用實例名.類方法的方式調(diào)用）

實際案例

如果要構(gòu)造一個類，接受一個網(wǎng)站和這個網(wǎng)站的狀態(tài)碼，然后打印出來。就像這樣：

importsysimportrequestsreload(sys)sys.setdefaultencoding('utf-8')classgg:def__init__(self,url,stat):self.url=urlself.stat=statdefouter(self):printself.urlprintself.stata=gg('langzi',200)a.outer()

這樣就是使用實例方法，雖然可以實現(xiàn)，但是有的時候傳入的參數(shù)并不是(‘langzi’,200)這樣的格式，而是(‘langzi-200’)這樣的，那該怎么做？首先要把這個拆分，但是要使用實例方法實現(xiàn)起來很麻煩，這個時候就可以使用類方法。

#-*-coding:utf-8-*-#@Time:2018/5/3000317:27#@Author:Langzi#@Blog:www.langzi.fun#@File:面向?qū)ο?.py#@Software:PyCharmimportsysimportrequestsreload(sys)sys.setdefaultencoding('utf-8')classgg:url=0stat=0#因為使用classmethod后會傳入新的變量，所以一開始是需要自己先定義類變量def__init__(self,url=0,stat=0):#這里按照正常的定義構(gòu)造函數(shù)self.url=urlself.stat=stat@classmethod#裝飾器，立馬執(zhí)行下面的函數(shù)defsplit(cls,info):#這個函數(shù)接受兩個參數(shù)，默認(rèn)的cls就是這個類的init函數(shù)，info就是外面?zhèn)魅脒M(jìn)來的url,stat=map(str,info.split('-'))#這里轉(zhuǎn)換成了格式化的結(jié)構(gòu)data=cls(url,stat)#然后執(zhí)行這個類第一個方法，這個類構(gòu)造函數(shù)需要傳入兩個參數(shù)，于是就傳入了兩個參數(shù)returndata#這里就直接返回了函數(shù)結(jié)果defouter(self):printself.urlprintself.statr=gg.split(('langzi-200'))r.outer()#這里是調(diào)用類方法，與調(diào)用實例方法一樣

類的特性

封裝

封裝是指將數(shù)據(jù)與具體操作的實現(xiàn)代碼放在某個對象內(nèi)部，外部無法訪問。必須要先調(diào)用類的方法才能啟動。

案例

classcc:ccc='ccc'#cc就是類名如果想要繼承別的類就classcc(threading)意思就是從threading繼承def__init__(self,a,b,c):self.a=aself.b=bself.c=cprinte.ccc#類變量，在類里面找到定義的變量。printccc#這里會報錯，這就是封裝。類中的函數(shù)同理。

繼承

當(dāng)我們定義一個class的時候，可以從某個現(xiàn)有的class繼承，新的class稱為子類（Subclass），而被繼承的class稱為基類、父類或超類（Base class、Super class）。比如，我們已經(jīng)編寫了一個名為Animal的class，有一個run()方法可以直接打印：

classAnimal(object):defrun(self):print'Animalisrunning...'

當(dāng)我們需要編寫Dog和Cat類時，就可以直接從Animal類繼承：

classDog(Animal):passclassCat(Animal):pass

繼承有什么好處？最大的好處是子類獲得了父類的全部功能。由于Animial實現(xiàn)了run()方法，因此，Dog和Cat作為它的子類，什么事也沒干，就自動擁有了run()方法：

dog=Dog()dog.run()cat=Cat()cat.run()

當(dāng)子類和父類都存在相同的run()方法時，我們說，子類的run()覆蓋了父類的run()，在代碼運行的時候，總是會調(diào)用子類的run()。這樣，我們就獲得了繼承的另一個好處：多態(tài)。

多態(tài)

要理解多態(tài)的好處，我們還需要再編寫一個函數(shù)，這個函數(shù)接受一個Animal類型的變量：

defrun_twice(animal):animal.run()animal.run()

當(dāng)我們傳入Animal的實例時，run_twice()就打印出：

run_twice(Animal())運行結(jié)果：Animalisrunning...Animalisrunning...

當(dāng)我們傳入Dog的實例時，run_twice()就打印出：

run_twice(Dog())運行結(jié)果：Dogisrunning...Dogisrunning...

當(dāng)我們傳入Cat的實例時，run_twice()就打印出：

run_twice(Cat())運行結(jié)果：Catisrunning...Catisrunning...

看上去沒啥意思，但是仔細(xì)想想，現(xiàn)在，如果我們再定義一個Tortoise類型，也從Animal派生：

classTortoise(Animal):defrun(self):print'Tortoiseisrunningslowly...'

當(dāng)我們調(diào)用run_twice()時，傳入Tortoise的實例：

run_twice(Tortoise())運行結(jié)果：Tortoiseisrunningslowly...Tortoiseisrunningslowly...

你會發(fā)現(xiàn)，新增一個Animal的子類，不必對run_twice()做任何修改，實際上，任何依賴Animal作為參數(shù)的函數(shù)或者方法都可以不加修改地正常運行，原因就在于多態(tài)。

多態(tài)的好處就是，當(dāng)我們需要傳入Dog、Cat、Tortoise……時，我們只需要接收Animal類型就可以了，因為Dog、Cat、Tortoise……都是Animal類型，然后，按照Animal類型進(jìn)行操作即可。由于Animal類型有run()方法，因此，傳入的任意類型，只要是Animal類或者子類，就會自動調(diào)用實際類型的run()方法，這就是多態(tài)的意思：

對于一個變量，我們只需要知道它是Animal類型，無需確切地知道它的子類型，就可以放心地調(diào)用run()方法，而具體調(diào)用的run()方法是作用在Animal、Dog、Cat還是Tortoise對象上，由運行時該對象的確切類型決定，這就是多態(tài)真正的威力：調(diào)用方只管調(diào)用，不管細(xì)節(jié)，而當(dāng)我們新增一種Animal的子類時，只要確保run()方法編寫正確，不用管原來的代碼是如何調(diào)用的。這就是著名的“開閉”原則：

對擴展開放：允許新增Animal子類；對修改封閉：不需要修改依賴Animal類型的run_twice()等函數(shù)?？偨Y(jié)：繼承可以把父類的所有功能都直接拿過來，這樣就不必重零做起，子類只需要新增自己特有的方法，也可以把父類不適合的方法覆蓋重寫；有了繼承，才能有多態(tài)。在調(diào)用類實例方法的時候，盡量把變量視作父類類型，這樣，所有子類類型都可以正常被接收；舊的方式定義Python類允許不從object類繼承，但這種編程方式已經(jīng)嚴(yán)重不推薦使用。任何時候，如果沒有合適的類可以繼承，就繼承自object類。

魔法方法

在上面有提到除了init之外還有iter,reverse的方法，這里就詳細(xì)說下除了init初始化還有哪些別的方法。

__init__:構(gòu)造函數(shù)，在生成對象時調(diào)用__del__:析構(gòu)函數(shù)，釋放對象時使用__repr__:打印，轉(zhuǎn)換__setitem__:按照索引賦值__getitem__:按照索引獲取值__len__:獲得長度__cmp__:比較運算__call__:調(diào)用__add__:加運算__sub__:減運算__mul__:乘運算__div__:除運算__mod__:求余運算__pow__:冪

具體使用

1.doc

說明性文檔和信息。Python自建，無需自定義。

classFoo:"""描述類信息，可被自動收集"""deffunc(self):pass#打印類的說明文檔print(Foo.__doc__)

2.init()

實例化方法，通過類創(chuàng)建實例時，自動觸發(fā)執(zhí)行。

classFoo:def__init__(self,name):self.name=nameself.age=18obj=Foo(jack')#自動執(zhí)行類中的__init__方法

3.module__ 和 __class

module 表示當(dāng)前操作的對象在屬于哪個模塊。class 表示當(dāng)前操作的對象屬于哪個類。這兩者也是Python內(nèi)建，無需自定義。

classFoo:passobj=Foo()print(obj.__module__)print(obj.__class__)運行結(jié)果：main

4.del()

析構(gòu)方法，當(dāng)對象在內(nèi)存中被釋放時，自動觸發(fā)此方法。

注：此方法一般無須自定義，因為Python自帶內(nèi)存分配和釋放機制，除非你需要在釋放的時候指定做一些動作。析構(gòu)函數(shù)的調(diào)用是由解釋器在進(jìn)行垃圾回收時自動觸發(fā)執(zhí)行的。

classFoo:def__del__(self):print("我被回收了！")obj=Foo()delobj

5.call()

如果為一個類編寫了該方法，那么在該類的實例后面加括號，可會調(diào)用這個方法。

注：構(gòu)造方法的執(zhí)行是由類加括號執(zhí)行的，即：對象 = 類名()，而對于call() 方法，是由對象后加括號觸發(fā)的，即：對象() 或者 類()()

classFoo:def__init__(self):passdef__call__(self,*args,**kwargs):print('__call__')obj=Foo()#執(zhí)行__init__obj()#執(zhí)行__call__

可以用Python內(nèi)建的callable()函數(shù)進(jìn)行測試，判斷一個對象是否可以被執(zhí)行。

callable(Student())

運行結(jié)果：

True

6.dict

列出類或?qū)ο笾械乃谐蓡T！非常重要和有用的一個屬性，Python自建，無需用戶自己定義。

classProvince:country='China'def__init__(self,name,count):self.name=nameself.count=countdeffunc(self,*args,**kwargs):print（'func'）#獲取類的成員print(Province.__dict__)#獲取對象obj1的成員obj1=Province('HeBei',10000)print(obj1.__dict__)#獲取對象obj2的成員obj2=Province('HeNan',3888)print(obj2.__dict__)

7.str()

如果一個類中定義了str()方法，那么在打印對象時，默認(rèn)輸出該方法的返回值。這也是一個非常重要的方法，需要用戶自己定義。

下面的類，沒有定義str()方法，打印結(jié)果是：

classFoo:passobj=Foo()print(obj)定義了__str__()方法后，打印結(jié)果是：'jack'。classFoo:def__str__(self):return'jack'obj=Foo()print(obj)

8、getitem__()、_setitem_()、__delitem()

取值、賦值、刪除這“三劍客”的套路，在Python中，我們已經(jīng)見過很多次了，比如前面的@property裝飾器。

Python中，標(biāo)識符后面加圓括號，通常代表執(zhí)行或調(diào)用方法的意思。而在標(biāo)識符后面加中括號[]，通常代表取值的意思。Python設(shè)計了getitem()、setitem()、delitem()這三個特殊成員，用于執(zhí)行與中括號有關(guān)的動作。它們分別表示取值、賦值、刪除數(shù)據(jù)。

也就是如下的操作：

a=標(biāo)識符[]：執(zhí)行__getitem__方法標(biāo)識符[]=a：執(zhí)行__setitem__方法del標(biāo)識符[]：執(zhí)行__delitem__方法

如果有一個類同時定義了這三個魔法方法，那么這個類的實例的行為看起來就像一個字典一樣，如下例所示：

classFoo:def__getitem__(self,key):print('__getitem__',key)def__setitem__(self,key,value):print('__setitem__',key,value)def__delitem__(self,key):print('__delitem__',key)obj=Foo()result=obj['k1']#自動觸發(fā)執(zhí)行__getitem__obj['k2']='jack'#自動觸發(fā)執(zhí)行__setitem__delobj['k1']#自動觸發(fā)執(zhí)行__delitem__

9.iter()

這是迭代器方法！列表、字典、元組之所以可以進(jìn)行for循環(huán)，是因為其內(nèi)部定義了 iter()這個方法。如果用戶想讓自定義的類的對象可以被迭代，那么就需要在類中定義這個方法，并且讓該方法的返回值是一個可迭代的對象。當(dāng)在代碼中利用for循環(huán)遍歷對象時，就會調(diào)用類的這個iter()方法。

普通的類：

classFoo:passobj=Foo()foriinobj:print(i)#報錯：TypeError:'Foo'objectisnotiterable
#原因是Foo對象不可迭代添加一個__iter__()，但什么都不返回：classFoo:def__iter__(self):passobj=Foo()foriinobj:print(i)#報錯：TypeError:iter()returnednon-iteratoroftype'NoneType'#原因是__iter__方法沒有返回一個可迭代的對象

返回一個個迭代對象：

classFoo:def__init__(self,sq):self.sq=sqdef__iter__(self):returniter(self.sq)obj=Foo([11,22,33,44])foriinobj:print(i)

最好的方法是使用生成器：

classFoo:def__init__(self):passdef__iter__(self):yield1yield2yield3obj=Foo()foriinobj:print(i)

10、len()

在Python中，如果你調(diào)用內(nèi)置的len()函數(shù)試圖獲取一個對象的長度，在后臺，其實是去調(diào)用該對象的len()方法，所以，下面的代碼是等價的：

len('ABC')3'ABC'.__len__()3

Python的list、dict、str等內(nèi)置數(shù)據(jù)類型都實現(xiàn)了該方法，但是你自定義的類要實現(xiàn)len方法需要好好設(shè)計。

11.repr()

這個方法的作用和str()很像，兩者的區(qū)別是str()返回用戶看到的字符串，而repr()返回程序開發(fā)者看到的字符串，也就是說，repr()是為調(diào)試服務(wù)的。通常兩者代碼一樣。

classFoo:def__init__(self,name):self.name=namedef__str__(self):return"thisis%s"%self.name__repr__=__str__

12.add__: 加運算_sub_: 減運算_mul_: 乘運算_div_: 除運算_mod_: 求余運算 __pow: 冪運算

這些都是算術(shù)運算方法，需要你自己為類設(shè)計具體運算代碼。有些Python內(nèi)置數(shù)據(jù)類型，比如int就帶有這些方法。Python支持運算符的重載，也就是重寫。

classVector:def__init__(self,a,b):self.a=aself.b=bdef__str__(self):return'Vector(%d,%d)'%(self.a,self.b)def__add__(self,other):returnVector(self.a+other.a,self.b+other.b)v1=Vector(2,10)v2=Vector(5,-2)print(v1+v2)

13.author作者信息

__author__="Jack"defshow():print(__author__)show()

14.slots

Python作為一種動態(tài)語言，可以在類定義完成和實例化后，給類或者對象繼續(xù)添加隨意個數(shù)或者任意類型的變量或方法，這是動態(tài)語言的特性。例如：

defprint_doc(self):print("haha")classFoo:passobj1=Foo()obj2=Foo()#動態(tài)添加實例變量obj1.name="jack"obj2.age=18#動態(tài)的給類添加實例方法Foo.show=print_docobj1.show()obj2.show()

但是！如果我想限制實例可以添加的變量怎么辦？可以使slots限制實例的變量，比如，只允許Foo的實例添加name和age屬性。

defprint_doc(self):print("haha")classFoo:__slots__=("name","age")passobj1=Foo()obj2=Foo()#動態(tài)添加實例變量obj1.name="jack"obj2.age=18obj1.sex="male"#這一句會彈出錯誤#但是無法限制給類添加方法Foo.show=print_docobj1.show()obj2.show()由于'sex'不在__slots__的列表中，所以不能綁定sex屬性，試圖綁定sex將得到AttributeError的錯誤。Traceback(mostrecentcalllast):File"F:/Python/pycharm/201705/1.py",line14,inobj1.sex="male"AttributeError:'Foo'objecthasnoattribute'sex'

需要提醒的是，slots定義的屬性僅對當(dāng)前類的實例起作用，對繼承了它的子類是不起作用的。想想也是這個道理，如果你繼承一個父類，卻莫名其妙發(fā)現(xiàn)有些變量無法定義，那不是大問題么？如果非要子類也被限制，除非在子類中也定義slots，這樣，子類實例允許定義的屬性就是自身的slots加上父類的slots。

成員保護(hù)與訪問機制

有些對象你不想外部訪問，即使是通過調(diào)用類對象也無法訪問，那就請認(rèn)真學(xué)完本章節(jié)。

私有成員

classobj:def__init__(self,name):self.name=namedefpri(self):printself.name__age=18#加上雙下劃線的就是私有變量，只能在類的內(nèi)部訪問，外部無法訪問a=obj('zhao')a.pri()

運行結(jié)果：

zhao

如果要在類中調(diào)用這個私有成員，可以這么用

classobj:def__init__(self,name):self.name=namedefprin(self):printself.name__age=18#加上雙下劃線的就是私有變量，只能在類的內(nèi)部訪問，外部無法訪問@classmethod#如果要在類中調(diào)用，首先調(diào)用類方法defpri(cls):printcls.__age#然后在使用a=obj('zhao')a.prin()obj.pri()#通過這樣直接調(diào)用類中的私有變量

運行結(jié)果：

zhao18

使用get-set-del方法操作私有成員

classobj:def__init__(self,name):self.name=namedefprin(self):printself.name__age=18#加上雙下劃線的就是私有變量，只能在類的內(nèi)部訪問，外部無法訪問@classmethod#如果要在類中調(diào)用，首先調(diào)用類方法defpri(cls):printcls.__age#然后在使用@classmethoddefset_age(cls,value):cls.__age=valuereturncls.__age#這個用法就是改變__age的值@classmethoddefget_age(cls):returncls.__age#這個用法就是直接返回__age的值@classmethoddefdel_age(cls):delcls.__age#這個用法就是直接刪除__age的值printobj.get_age()#這里是直接調(diào)用出__age的值返回值18printobj.set_age(20)#這里是直接改變__age的值返回值20obj.del_age()#這里是直接刪除__age的值

思考： 既然是私有變量，不讓外部訪問，為何有要在后面調(diào)用又改變呢？因為可以對私有變量進(jìn)行額外的檢測，處理，加工等等。比如判斷value的值，使用isinstance然后做if-else判斷。

使用私有變量可以對內(nèi)部變量進(jìn)行保護(hù)，外部無法改變，但是可以對它進(jìn)行檢測處理。

這里引申一下私有成員的保護(hù)機制，使用__age對私有變量其實就是—>obj._obj__age的樣子進(jìn)行保護(hù)，說白了你直接使用obj._obj__age就可以直接調(diào)用內(nèi)部私有變量age了。

Propety裝飾器

把類的方法偽裝成屬性調(diào)用的方式，就是把類里面的一個函數(shù)，變成一個屬性一樣的東西~一開始調(diào)用類的方法要使用圓括號，現(xiàn)在變成了屬性進(jìn)行讀取設(shè)置存儲。舉個例子來說明：

常用的調(diào)用方法

classobj:def__init__(self,name,age):self.__name=nameself.__age=age#講這些設(shè)置成私有變量defget_age(self):returnself.__agedefset_age(self,value):ifisinstance(value,int):self.__age=valueelse:raiseValueError('非整數(shù)類型')defdel_age(self):print'deleteover'a=obj('langzi',18)printa.get_age()a.set_age(20)printa.get_age()

使用裝飾器

classobj:def__init__(self,name,age):self.__name=nameself.__age=age#把這些設(shè)置成私有變量@propertydefage(self):[email protected](self,value):ifisinstance(value,int):self.__age=valueelse:raiseValueError('非整數(shù)類型')@age.deleterdefage(self):print'deleteover'a=obj('langzi',18)#使用這些裝飾器，可以使用類與對象的方法直接調(diào)用printa.age#這里就是直接調(diào)用返回age的值a.age=20#這里就是直接使用setter把值轉(zhuǎn)換printa.agedela.age#刪除age

當(dāng)然這種調(diào)用方法有些麻煩，每次都是一個一個去實例類與對象，有個更加簡單直觀的方法。

更加減半的使用property()函數(shù)

除了使用裝飾器的方式將一個方法偽裝成屬性外，Python內(nèi)置的builtins模塊中的property()函數(shù)，為我們提供了第二種設(shè)置類屬性的手段。

classPeople:def__init__(self,name,age):self.__name=nameself.__age=agedefget_age(self):returnself.__agedefset_age(self,age):ifisinstance(age,int):self.__age=ageelse:raiseValueErrordefdel_age(self):print("刪除年齡數(shù)據(jù)！")#核心在這句age=property(get_age,set_age,del_age,"年齡")obj=People("jack",18)print(obj.age)obj.age=19print("obj.age:",obj.age)delobj.ag

通過語句age = property(get_age, set_age, del_age, “年齡”)將一個方法偽裝成為屬性。其效果和裝飾器的方法是一樣的。

property()函數(shù)的參數(shù)：

第一個參數(shù)是方法名，調(diào)用實例.屬性時自動執(zhí)行的方法第二個參數(shù)是方法名，調(diào)用實例.屬性＝XXX時自動執(zhí)行的方法第三個參數(shù)是方法名，調(diào)用del實例.屬性時自動執(zhí)行的方法第四個參數(shù)是字符串，調(diào)用實例.屬性.__doc__時的描述信息。