python面向對象（進階篇）

本篇將詳細介紹Python 類的成員、成員修飾符、類的特殊成員。

類的成員：

類的成員能夠分爲三大類：字段（變量）、方法、屬性。

注：全部成員中，只有普通字段的內容保存對象中，即：根據此類建立了多少對象，在內存中就有多少個普通字段。而其餘的成員，則都是保存在類中，即：不管對象的多少，在內存中只建立一份。

1、字段

字段包括：普通字段和靜態字段，他們在定義和使用中有所區別，而最本質的區別是內存中保存的位置不一樣：

• 普通字段屬於對象
• 靜態字段屬於類

字段的定義和使用

由上述代碼能夠看出【普通字段須要經過對象來訪問】【靜態字段經過類訪問】，在使用上能夠看出普通字段和靜態字段的歸屬是不一樣的。其在內容的存儲方式相似以下圖：

由上圖看出：

• 靜態字段在內存中只保存一份
• 普通字段在每一個對象中都要保存一份

應用場景： 經過類建立對象時，若是每一個對象都具備相同的字段，那麼就使用靜態字段。

2、方法

方法包括：普通方法、靜態方法和類方法，三種方法在內存中都歸屬於類，區別在於調用方式不一樣。

• 普通方法：由對象調用；至少一個self參數；執行普通方法時，自動將調用該方法的對象賦值給self；
• 類方法：由類調用； 至少一個cls參數；執行類方法時，自動將調用該方法的類複製給cls；
• 靜態方法：由類調用；無默認參數； 

class Foo:
    def __init__(self, name):
        self.name = name

    def ord_func(self):
        """ 定義普通方法，至少有一個self參數 """
        # print self.name
        print('普通方法') 

    @classmethod
    def class_func(cls):
        """ 定義類方法，至少有一個cls參數 """
        print( '類方法')

    @staticmethod
    def static_func():
        """ 定義靜態方法 ，無默認參數"""

        print（'’靜態方法'）


# 調用普通方法
f = Foo()
f.ord_func()

# 調用類方法
Foo.class_func()

# 調用靜態方法
Foo.static_func()

方法的定義和使用

3、屬性　　

若是你已經瞭解Python類中的方法，那麼屬性就很是簡單了，由於Python中的屬性實際上是普通方法的變種。

對於屬性，有如下三個知識點：

• 屬性的基本使用
• 屬性的兩種定義方式

屬性的基本使用

屬性的定義和使用

由屬性的定義和調用要注意一下幾點：

• 定義時，在普通方法的基礎上添加 @property 裝飾器；
• 定義時，屬性僅有一個self參數
• 調用時，無需括號
             方法：foo_obj.func()
             屬性：foo_obj.prop

注意：屬性存在乎義是：訪問屬性時能夠製造出和訪問字段徹底相同的假象

        屬性由方法變種而來，若是Python中沒有屬性，方法徹底能夠代替其功能。

實例： 根據用戶輸入實現翻頁功能：

1)
data_list=[]
for i in range(1,101):
    data_list.append('movie-%s'% i)
while True:
    page=int(input('請輸入要查看的頁碼:'))
    per_page_num=10
    start=(page-1)*per_page_num
    end=page*per_page_num
    user_page=data_list[start:end]
    for item in user_page:
        print(item)
2)
class Pagenation:
    def __init__(self, data_list, page, per_page_num=10):
        self.data_list = data_list
        self.page = page
        self.per_page_num = per_page_num

    @property
    def start(self):
        return (self.page - 1) * self.per_page_num

    @property
    def end(self):
        return self.page * self.per_page_num

    def show(self):
        result = self.data_list[self.start:self.end]
        for item in result:
            print(item)

data_list = []
for i in range(1, 101):
    data_list.append('movie-%s' % i)
while True:
    page = int(input('請輸入要查看的頁碼:'))
    obj = Pagenation(data_list, page)
    obj.show()

代碼

一個靜態屬性property本質就是實現了get，set，delete三種方法，例如：

class Goods:
    def __init__(self):
        # 原價
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 實際價格 = 原價 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price

obj = Goods()
obj.price         # 獲取商品價格
obj.price = 200   # 修改商品原價
print(obj.price)
del obj.price     # 刪除商品原價

View Code

從上述可見，Python的屬性的功能是：屬性內部進行一系列的邏輯計算，最終將計算結果返回。

 類成員的修飾符

類的全部成員在上一步驟中已經作了詳細的介紹，對於每個類的成員而言都有兩種形式：

• 公有成員，在任何地方都能訪問
• 私有成員，只有在類的內部才能訪問

 私有成員和公有成員的定義不一樣：私有成員命名時，前兩個字符是下劃線。（特殊成員除外，例如：__init__、__call__、__dict__等）

 

私有成員和公有成員的訪問限制不一樣：

靜態字段

• 公有靜態字段：類能夠訪問；類內部能夠訪問；派生類中能夠訪問
• 私有靜態字段：僅類內部能夠訪問； 

公有靜態字段

私有靜態字段

方法、屬性的訪問於上述方式類似，即：私有成員只能在類內部使用 

普通字段

• 公有普通字段：對象能夠訪問；類內部能夠訪問；派生類中能夠訪問
• 私有普通字段：僅類內部能夠訪問；

ps：若是想要強制訪問私有字段，能夠經過 【對象._類名__私有字段明 】訪問（如：obj._C__foo），不建議強制訪問私有成員。 

class C:    
    def __init__(self):
        self.foo = "公有字段"

    def func(self):
        print self.foo 　#　類內部訪問

class D(C):    
    def show(self):
        print self.foo　＃　派生類中訪問

obj = C()

obj.foo     # 經過對象訪問
obj.func()  # 類內部訪問

obj_son = D();
obj_son.show()  # 派生類中訪問

公有字段

class C:    
    def __init__(self):
        self.__foo = "私有字段"

    def func(self):
        print self.foo 　#　類內部訪問

class D(C):    
    def show(self):
        print self.foo　＃　派生類中訪問

obj = C()

obj.__foo     # 經過對象訪問    ==> 錯誤
obj.func()  # 類內部訪問        ==> 正確

obj_son = D();
obj_son.show()  # 派生類中訪問  ==> 錯誤

私有字段

方法、屬性的訪問於上述方式類似，即：私有成員只能在類內部使用

ps：非要訪問私有屬性的話，能夠經過 對象._類__屬性名

 類的特殊成員：

 上文介紹了Python的類成員以及成員修飾符，從而瞭解到類中有字段、方法和屬性三大類成員，而且成員名前若是有兩個下劃線，則表示該成員是私有成員，私有成員只能由類內部調用。不管人或事物每每都有不按套路出牌的狀況，Python的類成員也是如此，存在着一些具備特殊含義的成員，詳情以下：

1. __doc__

　　表示類的描述信息

class Foo:
    """ 描述類信息，這是用於看片的神奇 """
    
    def func(self):
        pass
    
print(Foo.__doc__)
輸出：描述類信息，這是用於看片的神奇 

View Code

2. __module__ 和  __class__ 

　　__module__ 表示當前操做的對象在那個模塊

　　__class__     表示當前操做的對象的類是什麼

class C:

    def __init__(self):
        self.name = 'messi'

View Code

from lib.aa import C

obj = C()
print obj.__module__  # 輸出 lib.aa，即：輸出模塊
print obj.__class__      # 輸出 lib.aa.C，即：輸出類

View Code

3. __init__

　　構造方法，經過類建立對象時，自動觸發執行。

class Foo:
    def __init__(self, name):
        self.name = name
        self.age = 31

obj = Foo('messi') # 自動執行類中的 __init__ 方法

View Code

4. __del__

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

注：此方法通常無須定義，由於Python是一門高級語言，程序員在使用時無需關心內存的分配和釋放，由於此工做都是交給Python解釋器來執行，因此，析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的。

class Foo:

    def __del__(self):
        pass

View Code

5. __call__

　　對象後面加括號，觸發執行。

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

class Foo:
    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print '__call__'

obj = Foo() # 執行 __init__
obj()       # 執行 __call__

View Code

6. __dict__

　　類或對象中的全部成員

上文中咱們知道：類的普通字段屬於對象；類中的靜態字段和方法等屬於類，即：

class Province:
    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print 'func'

# 獲取類的成員，即：靜態字段、方法、
print Province.__dict__
# 輸出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei',10000)
print obj1.__dict__
# 獲取 對象obj1 的成員
# 輸出：{'count': 10000, 'name': 'HeBei'}

View Code

7. __str__

　　若是一個類中定義了__str__方法，那麼在打印 對象 時，默認輸出該方法的返回值。

class Foo:

    def __str__(self):
        return 'messi'

obj = Foo()
print(obj)
# 輸出：messi

View Code

八、__getitem__、__setitem__、__delitem__

用於索引操做，如字典。以上分別表示獲取、設置、刪除數據

class Foo(object):
    def __getitem__(self, key):
        print( key)

    def __setitem__(self, key, value):
        print(key, value)

    def __delitem__(self, key):
        print(key)

obj = Foo()

result = obj['k1']  # 自動觸發執行 __getitem__
obj['k2'] = 'messi'  # 自動觸發執行 __setitem__
del obj['k1']  # 自動觸發執行 __delitem__

k1
k2 messi
k1

View Code

10. __iter__ 

用於迭代器，之因此列表、字典、元組能夠進行for循環，是由於類型內部定義了 __iter__ 

class Foo(object):
    def __init__(self, sq):
        self.sq = sq

    def __iter__(self):
        return iter(self.sq)

obj = Foo([11,22,33,44])

for i in obj:
    print i

View Code

11. __new__ 

建立一個空對象 (其實這纔是構造方法,而init是對數據進行初始化)

class Foo:
    def __new__(cls, *args, **kwargs):
        return(cls)

obj=Foo()
print(obj)

View Code