開發十年，就只剩下這套架構體系了！ >>>   

面向物件程式設計和函數語言程式設計(面向過程程式設計)都是程式設計的方法，不過稍有區別。

面向過程程式設計：

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) 

8、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) 

10、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__時的描述