史上最全Python面向對象編程

面向對象編程和函數式編程(面向過程編程)都是程序設計的方法，不過稍有區別。

面向過程編程：

1. 導入各類外部庫

2. 設計各類全局變量

3. 寫一個函數完成某個功能

4. 寫一個函數完成某個功能

5. 寫一個函數完成某個功能

6. 寫一個函數完成某個功能

7. 寫一個函數完成某個功能

8. ......

9. 寫一個main函數做爲程序入口

在多函數程序中，許多重要的數據被放置在全局數據區，這樣它們能夠被全部的函數訪問。每一個函數均可以具備它們本身的局部數據，將某些功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可。從代碼的組織形式來看就是根據業務邏輯從上到下壘代碼 。

面向對象編程：

1. 導入各類外部庫

2. 設計各類全局變量

3. 決定你要的類

4. 給每一個類提供完整的一組操做

5. 明確地使用繼承來表現不一樣類之間的共同點

6. 根據須要，決定是否寫一個main函數做爲程序入口

面向對象編程中，將函數和變量進一步封裝成類，類纔是程序的基本元素，它將數據和操做緊密地連結在一塊兒，並保護數據不會被外界的函數意外地改變。類和和類的實例(也稱對象)是面向對象的核心概念，是和麪向過程編程、函數式編程的根本區別。

並非非要用面向對象編程，要看你的程序怎麼設計方便，可是就目前來講，基本上都是在使用面向對象編程。

類的基本用法

面向對象是經過定義class類來定義，這麼說面向對象編程就是隻使用class類，在class類中有封裝，繼承的功能，而且還能夠構造要傳入的參數，方便控制。

案例一

1. import sys 
2. import time 
3. reload(sys) 
4. sys.setdefaultencoding('utf-8') 
5.  
6. class studetn: 
7.     # 定義一個類名爲studetn 
8.     def __init__(self,idx): 
9.     # 定義初始化構造，這裏使用init，還有別的屬性好比reversed，iter之類的 
10.         self.idx=idx 
11.         # 初始化變量，方便繼承 
12.     def runx(self): 
13.     # 定義運行函數，從上面繼承變量 
14.         print self.idx 
15.         # 打印出idx的值，或者作一些別的處理 
16.         time.sleep(1) 
17. a=studetn('a') 
18. a.runx() 
19. # 這是類的調用，必定要記得類的使用方法，首先傳入參數，類賦值給一個變量a 
20. # 而後調用這個類下面定義的函數 

一些專業術語概念，既然有面向對象編程這個高大上的定義了，天然要搭配一些高大上的概念。

1. 類(Class): 用來描述具備相同屬性和方法的對象的集合。它定義了該集合中每一個對象所共有的屬性和方法。其中的對象被稱做類的實例。
2. 實例：也稱對象。經過類定義的初始化方法，賦予具體的值，成爲一個」有血有肉的實體」。
3. 實例化：建立類的實例的過程或操做。
4. 實例變量：定義在實例中的變量，只做用於當前實例。
5. 類變量：類變量是全部實例公有的變量。類變量定義在類中，但在方法體以外。
6. 數據成員：類變量、實例變量、方法、類方法、靜態方法和屬性等的統稱。
7. 方法：類中定義的函數。
8. 靜態方法：不須要實例化就能夠由類執行的方法
9. 類方法：類方法是將類自己做爲對象進行操做的方法。
10. 方法重寫：若是從父類繼承的方法不能知足子類的需求，能夠對父類的方法進行改寫，這個過程也稱override。
11. 封裝：將內部實現包裹起來，對外透明，提供api接口進行調用的機制
12. 繼承：即一個派生類(derived class)繼承父類(base class)的變量和方法。
13. 多態：根據對象類型的不一樣以不一樣的方式進行處理。

類與實例

1. # -*- coding: utf-8 -*- 
2. # @Time    : 2018/5/3 0003 17:02 
3. # @Author  : Langzi 
4. # @Blog    : www.langzi.fun 
5. # @File    : 面向對象2.py 
6. # @Software: PyCharm 
7. import sys 
8. import time 
9. import requests 
10. reload(sys) 
11. sys.setdefaultencoding('utf-8') 
12.  
13. class cc: 
14.     ccc = 'ccc' 
15.     # cc就是類名 若是想要繼承別的類 就class cc(threading) 意思就是從threading繼承 
16.     def __init__(self,a,b,c): 
17.         self.a=a 
18.         self.b=b 
19.         self.c=c 
20.         # 定義構造的過程就是實例化 
21.     def runx(self): 
22.         print self.a*10 
23.         print self.b*5 
24.         print self.c*2 
25.     def runy(self): 
26.         print requests.get('http://www.langzi.fun').headers 
27. e = cc('AAA','CCC','EEE') 
28. e.runx() 
29. e.runy() 
30. # 這兩個就是調用類裏面的方法 
31. print e.c 
32. #實例變量指的是實例自己擁有的變量。每一個實例的變量在內存中都不同。 
33. print e.ccc 
34. #類變量，在類裏面找到定義的變量。 
35. 調用類的三種方法 

調用類的三種方法

實例方法

1. # -*- coding: utf-8 -*- 
2. # @Time    : 2018/5/3 0003 17:16 
3. # @Author  : Langzi 
4. # @Blog    : www.langzi.fun 
5. # @File    : 面向對象3.py 
6. # @Software: PyCharm 
7. import sys 
8. import time 
9. import requests 
10. reload(sys) 
11. sys.setdefaultencoding('utf-8') 
12.  
13. class dd: 
14.     def __init__(self,url): 
15.         self.url=url 
16.     def runx(self): 
17.         print requests.get(self.url).status_code 
18.  
19. a = dd('http://www.langzi.fun') 
20. a.runx() 
21. # 這種調用方法就是實例方法 

靜態方法

靜態方法由類調用，無默認參數。將實例方法參數中的self去掉，而後在方法定義上方加上@staticmethod，就成爲靜態方法。它屬於類，和實例無關。建議只使用類名.靜態方法的調用方式。(雖然也可使用實例名.靜態方法的方式調用)

1. # -*- coding: utf-8 -*- 
2. # @Time    : 2018/5/3 0003 17:21 
3. # @Author  : Langzi 
4. # @Blog    : www.langzi.fun 
5. # @File    : 面向對象4.py 
6. # @Software: PyCharm 
7. import sys 
8. import requests 
9. reload(sys) 
10. sys.setdefaultencoding('utf-8') 
11. class ff: 
12.     @staticmethod 
13.     def runx(): 
14.         print requests.get('http://www.langzi.fun').status_code 
15. ff.runx() 
16. #這裏就直接調用了類的變量，只在類中運行而不在實例中運行的方法 

常常有一些跟類有關係的功能但在運行時又不須要實例和類參與的狀況下須要用到靜態方法. 好比更改環境變量或者修改其餘類的屬性等能用到靜態方法. 這種狀況能夠直接用函數解決, 但這樣一樣會擴散類內部的代碼，形成維護困難。

類方法

類方法由類調用，採用@classmethod裝飾，至少傳入一個cls(代指類自己，相似self)參數。執行類方法時，自動將調用該方法的類賦值給cls。建議只使用類名.類方法的調用方式。(雖然也可使用實例名.類方法的方式調用)

實際案例

若是要構造一個類，接受一個網站和這個網站的狀態碼，而後打印出來。就像這樣：

1. import sys 
2. import requests 
3. reload(sys) 
4. sys.setdefaultencoding('utf-8') 
5. class gg: 
6.     def __init__(self,url,stat): 
7.         self.url=url 
8.         self.stat=stat 
9.     def outer(self): 
10.         print self.url 
11.         print self.stat 
12. a = gg('langzi',200) 
13. a.outer() 

這樣就是使用實例方法，雖然能夠實現，可是有的時候傳入的參數並非(‘langzi’,200)這樣的格式，而是(‘langzi-200’)這樣的，那該怎麼作?首先要把這個拆分，可是要使用實例方法實現起來很麻煩，這個時候就可使用類方法。

1. # -*- coding: utf-8 -*- 
2. # @Time    : 2018/5/3 0003 17:27 
3. # @Author  : Langzi 
4. # @Blog    : www.langzi.fun 
5. # @File    : 面向對象5.py 
6. # @Software: PyCharm 
7. import sys 
8. import requests 
9. reload(sys) 
10. sys.setdefaultencoding('utf-8') 
11. class gg: 
12.     url = 0 
13.     stat = 0 
14.     # 由於使用classmethod後會傳入新的變量，因此一開始是須要本身先定義類變量 
15.     def __init__(self,url=0,stat=0): 
16.     # 這裏按照正常的定義構造函數 
17.         self.url=url 
18.         self.stat=stat 
19.     @classmethod 
20.     # 裝飾器，立馬執行下面的函數 
21.     def split(cls,info): 
22.         # 這個函數接受兩個參數，默認的cls就是這個類的init函數，info就是外面傳入進來的 
23.         url,stat=map(str,info.split('-')) 
24.         # 這裏轉換成了格式化的結構 
25.         data = cls(url,stat) 
26.         # 而後執行這個類第一個方法，這個類構造函數須要傳入兩個參數，因而就傳入了兩個參數 
27.         return data 
28.         # 這裏就直接返回了函數結果 
29.     def outer(self): 
30.         print self.url 
31.         print self.stat 
32.  
33. r = gg.split(('langzi-200')) 
34. r.outer() 
35. # 這裏是調用類方法，與調用實例方法同樣 

類的特性

封裝

封裝是指將數據與具體操做的實現代碼放在某個對象內部，外部沒法訪問。必需要先調用類的方法才能啓動。

案例

1. class cc: 
2.     ccc = 'ccc' 
3.     # cc就是類名 若是想要繼承別的類 就class cc(threading) 意思就是從threading繼承 
4.     def __init__(self,a,b,c): 
5.         self.a=a 
6.         self.b=b 
7.         self.c=c 
8. print e.ccc 
9. #類變量，在類裏面找到定義的變量。 
10. print ccc 
11. # 這裏會報錯，這就是封裝。類中的函數同理。 

繼承

當咱們定義一個class的時候，能夠從某個現有的class繼承，新的class稱爲子類(Subclass)，而被繼承的class稱爲基類、父類或超類(Base class、Super class)。

好比，咱們已經編寫了一個名爲Animal的class，有一個run()方法能夠直接打印：

1. class Animal(object): 
2.     def run(self): 
3.         print 'Animal is running...' 

當咱們須要編寫Dog和Cat類時，就能夠直接從Animal類繼承：

1. class Dog(Animal): 
2.     pass 
3. class Cat(Animal): 
4.     pass 

繼承有什麼好處?最大的好處是子類得到了父類的所有功能。因爲Animial實現了run()方法，所以，Dog和Cat做爲它的子類，什麼事也沒幹，就自動擁有了run()方法：

1. dog = Dog() 
2. dog.run() 
3. cat = Cat() 
4. cat.run() 

當子類和父類都存在相同的run()方法時，咱們說，子類的run()覆蓋了父類的run()，在代碼運行的時候，老是會調用子類的run()。這樣，咱們就得到了繼承的另外一個好處：多態。

多態

要理解多態的好處，咱們還須要再編寫一個函數，這個函數接受一個Animal類型的變量：

1. def run_twice(animal): 
2.     animal.run() 
3.     animal.run() 

當咱們傳入Animal的實例時，run_twice()就打印出：

1. run_twice(Animal()) 
2. 運行結果： 
3. Animal is running... 
4. Animal is running... 

當咱們傳入Dog的實例時，run_twice()就打印出：

1. run_twice(Dog()) 
2. 運行結果： 
3. Dog is running... 
4. Dog is running... 

當咱們傳入Cat的實例時，run_twice()就打印出：

1. run_twice(Cat()) 
2. 運行結果： 
3. Cat is running... 
4. Cat is running... 

看上去沒啥意思，可是仔細想一想，如今，若是咱們再定義一個Tortoise類型，也從Animal派生：

1. class Tortoise(Animal): 
2.     def run(self): 
3.         print 'Tortoise is running slowly...' 

當咱們調用run_twice()時，傳入Tortoise的實例：

1. run_twice(Tortoise()) 
2. 運行結果： 
3. Tortoise is running slowly... 
4. Tortoise is running slowly... 

你會發現，新增一個Animal的子類，沒必要對run_twice()作任何修改，實際上，任何依賴Animal做爲參數的函數或者方法均可以不加修改地正常運行，緣由就在於多態。

多態的好處就是，當咱們須要傳入Dog、Cat、Tortoise……時，咱們只須要接收Animal類型就能夠了，由於Dog、Cat、Tortoise……都是Animal類型，而後，按照Animal類型進行操做便可。因爲Animal類型有run()方法，所以，傳入的任意類型，只要是Animal類或者子類，就會自動調用實際類型的run()方法，這就是多態的意思：

對於一個變量，咱們只須要知道它是Animal類型，無需確切地知道它的子類型，就能夠放心地調用run()方法，而具體調用的run()方法是做用在Animal、Dog、Cat仍是Tortoise對象上，由運行時該對象的確切類型決定，這就是多態真正的威力：調用方只管調用，無論細節，而當咱們新增一種Animal的子類時，只要確保run()方法編寫正確，不用管原來的代碼是如何調用的。這就是著名的「開閉」原則：

對擴展開放：容許新增Animal子類;

對修改封閉：不須要修改依賴Animal類型的run_twice()等函數。

總結：繼承能夠把父類的全部功能都直接拿過來，這樣就沒必要重零作起，子類只須要新增本身特有的方法，也能夠把父類不適合的方法覆蓋重寫;

有了繼承，纔能有多態。在調用類實例方法的時候，儘可能把變量視做父類類型，這樣，全部子類類型均可以正常被接收;

舊的方式定義Python類容許不從object類繼承，但這種編程方式已經嚴重不推薦使用。任什麼時候候，若是沒有合適的類能夠繼承，就繼承自object類。

魔法方法

在上面有提到除了init以外還有iter,reverse的方法，這裏就詳細說下除了init初始化還有哪些別的方法。

1. __init__ :      構造函數，在生成對象時調用 
2. __del__ :       析構函數，釋放對象時使用 
3. __repr__ :      打印，轉換 
4. __setitem__ :   按照索引賦值 
5. __getitem__:    按照索引獲取值 
6. __len__:        得到長度 
7. __cmp__:        比較運算 
8. __call__:       調用 
9. __add__:        加運算 
10. __sub__:        減運算 
11. __mul__:        乘運算 
12. __div__:        除運算 
13. __mod__:        求餘運算 
14. __pow__:        冪 

具體使用

1. doc

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

1. class Foo: 
2.     """ 描述類信息，可被自動收集 """ 
3.     def func(self): 
4.         pass 
5. # 打印類的說明文檔  
6. print(Foo.__doc__) 

2. init()

實例化方法，經過類建立實例時，自動觸發執行。

1. class Foo: 
2.     def __init__(self, name): 
3.         self.name = name 
4.         self.age = 18 
5. obj = Foo(jack') # 自動執行類中的 __init__ 方法 

3. module__ 和 __class

module 表示當前操做的對象在屬於哪一個模塊。

class 表示當前操做的對象屬於哪一個類。

這二者也是Python內建，無需自定義。

1. class Foo: 
2.     pass 
3. obj = Foo() 
4. print(obj.__module__) 
5. print(obj.__class__) 

運行結果：

1. main 

4. del()

析構方法，當對象在內存中被釋放時，自動觸發此方法。

注：此方法通常無須自定義，由於Python自帶內存分配和釋放機制，除非你須要在釋放的時候指定作一些動做。析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的。

1. class Foo: 
2.     def __del__(self): 
3.         print("我被回收了！") 
4.  
5. obj = Foo() 
6. del obj 

5. call()

若是爲一個類編寫了該方法，那麼在該類的實例後面加括號，可會調用這個方法。

注：構造方法的執行是由類加括號執行的，即：對象 = 類名()，而對於call() 方法，是由對象後加括號觸發的，即：對象() 或者 類()()

1. class Foo: 
2.     def __init__(self): 
3.         pass 
4.     def __call__(self, *args, **kwargs): 
5.         print('__call__') 
6. obj = Foo()     # 執行 __init__ 
7. obj()       # 執行 __call__ 

能夠用Python內建的callable()函數進行測試，判斷一個對象是否能夠被執行。

1. callable(Student()) 

運行結果：

1. True 

6. dict

列出類或對象中的全部成員!很是重要和有用的一個屬性，Python自建，無需用戶本身定義。

1. class Province: 
2.     country = 'China' 
3.     def __init__(self, name, count): 
4.         self.name = name 
5.         self.count = count 
6.     def func(self, *args, **kwargs): 
7.         print（'func'） 
8. # 獲取類的成員 
9. print(Province.__dict__) 
10. # 獲取 對象obj1 的成員  
11. obj1 = Province('HeBei',10000) 
12. print(obj1.__dict__) 
13. # 獲取 對象obj2 的成員  
14. obj2 = Province('HeNan', 3888) 
15. print(obj2.__dict__) 

7. str()

若是一個類中定義了str()方法，那麼在打印對象時，默認輸出該方法的返回值。這也是一個很是重要的方法，須要用戶本身定義。

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

1. class Foo: 
2.     pass 
3. obj = Foo() 
4. print(obj) 
5. 定義了__str__()方法後，打印結果是：'jack'。 
6. class Foo: 
7.     def __str__(self): 
8.         return 'jack' 
9. obj = Foo() 
10. print(obj) 

八、getitem__()、_setitem_()、__delitem()

取值、賦值、刪除這「三劍客」的套路，在Python中，咱們已經見過不少次了，好比前面的@property裝飾器。

Python中，標識符後面加圓括號，一般表明執行或調用方法的意思。而在標識符後面加中括號[]，一般表明取值的意思。Python設計了getitem()、setitem()、delitem()這三個特殊成員，用於執行與中括號有關的動做。它們分別表示取值、賦值、刪除數據。

也就是以下的操做：

1. a = 標識符[]　： 執行__getitem__方法 
2. 標識符[] = a  ： 執行__setitem__方法 
3. del 標識符[]　： 執行__delitem__方法 

若是有一個類同時定義了這三個魔法方法，那麼這個類的實例的行爲看起來就像一個字典同樣，以下例所示：

1. class Foo: 
2.     def __getitem__(self, key): 
3.         print('__getitem__',key) 
4.     def __setitem__(self, key, value): 
5.         print('__setitem__',key,value) 
6.     def __delitem__(self, key): 
7.         print('__delitem__',key) 
8. obj = Foo() 
9. result = obj['k1']      # 自動觸發執行 __getitem__ 
10. obj['k2'] = 'jack'      # 自動觸發執行 __setitem__ 
11. del obj['k1']             # 自動觸發執行 __delitem__ 

9. iter()

這是迭代器方法!列表、字典、元組之因此能夠進行for循環，是由於其內部定義了 iter()這個方法。若是用戶想讓自定義的類的對象能夠被迭代，那麼就須要在類中定義這個方法，而且讓該方法的返回值是一個可迭代的對象。當在代碼中利用for循環遍歷對象時，就會調用類的這個iter()方法。

普通的類：

1. class Foo: 
2.     pass 
3. obj = Foo() 
4. for i in obj: 
5.     print(i) 
6. # 報錯：TypeError: 'Foo' object is not iterable<br># 緣由是Foo對象不可迭代 
7. 添加一個__iter__()，但什麼都不返回： 
8. class Foo: 
9.     def __iter__(self): 
10.         pass 
11. obj = Foo() 
12. for i in obj: 
13.     print(i) 
14. # 報錯：TypeError: iter() returned non-iterator of type 'NoneType' 
15. #緣由是 __iter__方法沒有返回一個可迭代的對象 

返回一個個迭代對象：

1. class Foo: 
2.     def __init__(self, sq): 
3.         self.sq = sq 
4.     def __iter__(self): 
5.         return iter(self.sq) 
6. obj = Foo([11,22,33,44]) 
7. for i in obj: 
8.     print(i) 

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

1. class Foo: 
2.     def __init__(self): 
3.         pass 
4.     def __iter__(self): 
5.         yield 1 
6.         yield 2 
7.         yield 3 
8. obj = Foo() 
9. for i in obj: 
10.     print(i) 

十、len()

在Python中，若是你調用內置的len()函數試圖獲取一個對象的長度，在後臺，實際上是去調用該對象的len()方法，因此，下面的代碼是等價的：

1. len('ABC') 
2. 3 
3. 'ABC'.__len__() 
4. 3 

Python的list、dict、str等內置數據類型都實現了該方法，可是你自定義的類要實現len方法須要好好設計。

11. repr()

這個方法的做用和str()很像，二者的區別是str()返回用戶看到的字符串，而repr()返回程序開發者看到的字符串，也就是說，repr()是爲調試服務的。一般二者代碼同樣。

1. class Foo: 
2.     def __init__(self, name): 
3.         self.name = name 
4.     def __str__(self): 
5.         return "this is %s" % self.name 
6.     __repr__ = __str__ 

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

這些都是算術運算方法，須要你本身爲類設計具體運算代碼。有些Python內置數據類型，好比int就帶有這些方法。Python支持運算符的重載，也就是重寫。

1. class Vector: 
2.    def __init__(self, a, b): 
3.       self.a = a 
4.       self.b = b 
5.    def __str__(self): 
6.       return 'Vector (%d, %d)' % (self.a, self.b) 
7.    def __add__(self,other): 
8.       return Vector(self.a + other.a, self.b + other.b) 
9. v1 = Vector(2,10) 
10. v2 = Vector(5,-2) 
11. print (v1 + v2) 

13. author做者信息

1. __author__ = "Jack" 
2. def show(): 
3.     print(__author__) 
4. show() 

14. slots

Python做爲一種動態語言，能夠在類定義完成和實例化後，給類或者對象繼續添加隨意個數或者任意類型的變量或方法，這是動態語言的特性。例如：

1. def print_doc(self): 
2.     print("haha") 
3.  
4. class Foo: 
5.     pass 
6.  
7. obj1 = Foo() 
8. obj2 = Foo() 
9. # 動態添加實例變量 
10. obj1.name = "jack" 
11. obj2.age = 18 
12. # 動態的給類添加實例方法 
13. Foo.show = print_doc 
14. obj1.show() 
15. obj2.show() 

可是!若是我想限制實例能夠添加的變量怎麼辦?可使slots限制實例的變量，好比，只容許Foo的實例添加name和age屬性。

 

1. def print_doc(self): 
2.     print("haha") 
3. class Foo: 
4.     __slots__ = ("name", "age") 
5.     pass 
6. obj1 = Foo() 
7. obj2 = Foo() 
8. # 動態添加實例變量 
9. obj1.name = "jack" 
10. obj2.age = 18 
11. obj1.sex = "male"       # 這一句會彈出錯誤 
12. # 可是沒法限制給類添加方法 
13. Foo.show = print_doc 
14. obj1.show() 
15. obj2.show() 
16. 因爲'sex'不在__slots__的列表中，因此不能綁定sex屬性，試圖綁定sex將獲得AttributeError的錯誤。 
17. Traceback (most recent call last): 
18.   File "F:/Python/pycharm/201705/1.py", line 14, in <module> 
19.     obj1.sex = "male" 
20. AttributeError: 'Foo' object has no attribute 'sex' 

須要提醒的是，slots定義的屬性僅對當前類的實例起做用，對繼承了它的子類是不起做用的。想一想也是這個道理，若是你繼承一個父類，卻莫名其妙發現有些變量沒法定義，那不是大問題麼?若是非要子類也被限制，除非在子類中也定義slots，這樣，子類實例容許定義的屬性就是自身的slots加上父類的slots。

成員保護與訪問機制

有些對象你不想外部訪問，即便是經過調用類對象也沒法訪問，那就請認真學完本章節。

私有成員

1. class obj: 
2.     def __init__(self,name): 
3.         self.name=name 
4.     def pri(self): 
5.         print self.name 
6.     __age = 18 
7.     # 加上雙下劃線的就是私有變量，只能在類的內部訪問，外部沒法訪問 
8. a = obj('zhao') 
9. a.pri() 

運行結果：

1. zhao 

若是要在類中調用這個私有成員，能夠這麼用

1. class obj: 
2.     def __init__(self,name): 
3.         self.name=name 
4.     def prin(self): 
5.         print self.name 
6.     __age = 18 
7.     # 加上雙下劃線的就是私有變量，只能在類的內部訪問，外部沒法訪問 
8.     @classmethod 
9.     # 若是要在類中調用，首先調用類方法 
10.     def pri(cls): 
11.         print cls.__age 
12.         # 而後在使用 
13. a = obj('zhao') 
14. a.prin() 
15. obj.pri() 
16. # 經過這樣直接調用類中的私有變量 

運行結果：

1. zhao
2. 18 

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

1. class obj: 
2.     def __init__(self,name): 
3.         self.name=name 
4.     def prin(self): 
5.         print self.name 
6.     __age = 18 
7.     # 加上雙下劃線的就是私有變量，只能在類的內部訪問，外部沒法訪問 
8.     @classmethod 
9.     # 若是要在類中調用，首先調用類方法 
10.     def pri(cls): 
11.         print cls.__age 
12.         # 而後在使用 
13.     @classmethod 
14.     def set_age(cls,value): 
15.         cls.__age = value 
16.         return cls.__age 
17.         # 這個用法就是改變__age的值 
18.     @classmethod 
19.     def get_age(cls): 
20.         return cls.__age 
21.         # 這個用法就是直接返回__age的值 
22.     @classmethod 
23.     def del_age(cls): 
24.         del cls.__age 
25.         # 這個用法就是直接刪除__age的值 
26.  
27. print obj.get_age() 
28. # 這裏是直接調用出__age的值  返回值18 
29. print obj.set_age(20) 
30. # 這裏是直接改變__age的值  返回值20 
31. obj.del_age() 
32. # 這裏是直接刪除__age的值 

思考： 既然是私有變量，不讓外部訪問，爲什麼有要在後面調用又改變呢?由於能夠對私有變量進行額外的檢測，處理，加工等等。好比判斷value的值，使用isinstance而後作if-else判斷。

使用私有變量能夠對內部變量進行保護，外部沒法改變，可是能夠對它進行檢測處理。

這裏引伸一下私有成員的保護機制，使用__age對私有變量其實就是—>obj._obj__age的樣子進行保護，說白了你直接使用obj._obj__age就能夠直接調用內部私有變量age了。

Propety裝飾器

把類的方法假裝成屬性調用的方式，就是把類裏面的一個函數，變成一個屬性同樣的東西~

一開始調用類的方法要使用圓括號，如今變成了屬性進行讀取設置存儲。

舉個例子來講明：

經常使用的調用方法

1. class obj: 
2.     def __init__(self,name,age): 
3.         self.__name=name 
4.         self.__age=age 
5.         # 講這些設置成私有變量 
6.     def get_age(self): 
7.         return self.__age 
8.     def set_age(self,value): 
9.         if isinstance(value,int): 
10.             self.__age=value 
11.         else: 
12.             raise ValueError('非整數類型') 
13.     def del_age(self): 
14.         print 'delete over' 
15. a = obj('langzi',18) 
16. print a.get_age() 
17. a.set_age(20) 
18. print a.get_age() 

使用裝飾器

1. class obj: 
2.     def __init__(self,name,age): 
3.         self.__name=name 
4.         self.__age=age 
5.         # 把這些設置成私有變量 
6.     @property 
7.     def age(self): 
8.         return self.__age 
9.     @age.setter 
10.     def age(self,value): 
11.         if isinstance(value,int): 
12.             self.__age=value 
13.         else: 
14.             raise ValueError('非整數類型') 
15.     @age.deleter 
16.     def age(self): 
17.         print 'delete over' 
18. a = obj('langzi',18) 
19. # 使用這些裝飾器，可使用類與對象的方法直接調用 
20. print a.age 
21. # 這裏就是直接調用返回age的值 
22. a.age=20 
23. # 這裏就是直接使用setter把值轉換 
24. print a.age 
25. del a.age 
26. # 刪除age 

固然這種調用方法有些麻煩，每次都是一個一個去實例類與對象，有個更加簡單直觀的方法。

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

除了使用裝飾器的方式將一個方法假裝成屬性外，Python內置的builtins模塊中的property()函數，爲咱們提供了第二種設置類屬性的手段。

1. class People: 
2.  
3.     def __init__(self, name, age): 
4.         self.__name = name 
5.         self.__age = age 
6.  
7.     def get_age(self): 
8.         return self.__age 
9.  
10.     def set_age(self, age): 
11.         if isinstance(age, int): 
12.             self.__age = age 
13.         else: 
14.             raise ValueError 
15.  
16.     def del_age(self): 
17.         print("刪除年齡數據！") 
18.  
19.     # 核心在這句 
20.     age = property(get_age, set_age, del_age, "年齡")     
21.  
22.  
23. obj = People("jack", 18) 
24. print(obj.age) 
25. obj.age = 19 
26. print("obj.age:  ", obj.age) 
27. del obj.ag 

經過語句age = property(get_age, set_age, del_age, 「年齡」)將一個方法假裝成爲屬性。其效果和裝飾器的方法是同樣的。

property()函數的參數：

1. 第一個參數是方法名，調用 實例.屬性 時自動執行的方法 
2. 第二個參數是方法名，調用 實例.屬性 ＝ XXX時自動執行的方法 
3. 第三個參數是方法名，調用 del 實例.屬性 時自動執行的方法 
4. 第四個參數是字符串，調用 實例.屬性.__doc__時的描述信息。