【循序漸進學Python】8.面向對象的核心——類型(下)

1 構造和初始化對象

__init__方法是Python內建眾多魔法方法(什么是魔法方法？)中最常見的一個，通過這個方法我們可以定義一個對象的初始操作。當構造函數被調用的時候的任何參數都會傳遞給__init__方法，然后該方法根據這些參數進行對象的初始化工作：

# -- coding: utf-8 --
class Employee(object):
    def __init__(self,name):
        self.name = name

e = Employee('Sunshine')

print e.name # Sunshine

 與__init__方法對應的是__del__析構方法，在對象被垃圾回收前調用,除了在進行套接字、文件IO這些非托管資源操作外，一般情況下很少會用到它。

 

1.1 正確的初始化子類型

重寫是繼承機制中一個重要的內容，對於構造方法尤其如此。大多數類型的子類既要初始化自己的部分，也要調用基類的構造方法，因為保證了對象被正確的初始化，如下所示:

# -- coding: utf-8 --
class Bird(object):
    def __init__(self):
        self.hungry = True

    def eat(self):
        if self.hungry:
            print 'Aaaah...'
            self.hungry = False
        else:
            print 'No. thanks'

class SongBird(Bird):
    def __init__(self):
        self.sound = 'Squawk!'

    def sing(self):
        print self.sound

# AttributeError: 'SongBird' object has no attribute 'hungry'
sb = SongBird()
sb.eat()

 

SongBird這個子類在調用繼承於父類Bird的eat()方法時由於其自身的構造函數沒有正確的初始化基類的成員hungry所有就會拋出AttributeError的異常。正確初始化父類成員的方法有兩個：

1.直接調用基類構造方法。這樣修改SongBird類型的定義即可:

class SongBird(Bird):
    def __init__(self):
        Bird.__init__(self) # 調用基類構造方法
        self.sound = 'Squawk!'

    def sing(self):
        print self.sound

 

2.調用super函數，可以這樣修改SongBird類型的定義:

class SongBird(Bird):
    def __init__(self):
        super(SongBird,self).__init__() # 使用super函數
        self.sound = 'Squawk!'

    def sing(self):
        print self.sound

 

一般來講，使用第一種方式：調用未綁定的基類構造方法，是為了兼容舊的代碼，如果不需要兼容舊版本的代碼還是推薦使用super函數來初始化基類的成員。從上面的示例可能覺得二者差別不大，但是為什么還要出現super函數呢，因為super函數(其他它是一個類)主要是用來解決多重繼承問題的，因為這牽涉到順序查找(MRO)、重復調用等等一系列的復雜問題。為了保證我們代碼的一致性，我們應該同時只使用一種風格來編寫代碼。

 

2. 魔法方法

在Python中內建了很多"magic"方法這些方法和其他函數有些細微的不同：

1. 從形式上來說名字都是以雙下划線(__)來開始和結束的(如:__new__)
2. 大部分的魔法方法會在特定的情況下被Python自動調用。(比如__init__方法會在對象被創建后自動調用)

 

2.1 通過魔法方法定制類型

使用Python魔法方法最大的優勢在於可以創建出自己的擁有和內置類型同樣行為的類出來。例如我們可以通過重寫下面的魔法方法，來為自己的類型定制自己的比較規則：

• __eq__(self,other) —— 定義了等於的行為(=)
• __ne__(self,other) —— 定義了不等於的行為(!=)
• __lt__(self,other) —— 定義了小於的行為(<)
• __gt__(self,other) —— 定義了大於的行為(>)
• __le__(self,other) —— 定義了小於等於的行為(<=)
• __ge__(self,other) —— 定義了大於等於的行為(>=)

例如，我們可以重寫定義類型的==等行為，只需要重寫__eq__方法即可：

# -- coding: utf-8 --
class Employee(object):
    def __init__(self,name):
        self.name = name

    def __eq__(self,other):
        return self.name == other

e = Employee('Sun')
print e == 'Sun' # True

 Python內置的魔法方法中除了這些用於比較的魔法方法之外，還有關於操作符、類型轉換以及序列相關的等等一系列的魔法方法。如果想了解更多，這里有一份很好的文檔(注意文檔中錯別字)：Python魔法方法指南

 

3. 屬性

在Python中通過訪問器定義的特性被稱為屬性(property)。有兩種定義屬性的方式，首先我們來使用property函數來創建屬性：

# --coding:utf-8--
class Employee(object):
    def __init__(self):
        self.__name = None

    # set 訪問器
    def getName(self):
        return self.__name

    # get 訪問器
    def setName(self,value):
        self.__name = value

    # 析構函數
    def delName(self):
        del self.__name

    name = property(getName,setName,delName,'set and get Name property')

c = Employee()
c.name = "Bob"
print c.name # output: Bob

 

另一種方式就是Python 2.6 新增的語法,get/set/del函數都是使用的同一個名字:

# --coding:utf-8--
class Employee(object):
    def __init__(self):
        self.__name = None

    def name(self):
        return self.__name

    def name(self,value):
        self.__name=value

    def name(self):
        del self.__name

c = Employee()
c.name = "jobs"
print c.name # jobs

 

3.1 控制屬性訪問

如果需要加強對屬性的控制，可以使用Python為我們提供一系列的魔法方法:

• __getattribute__(self,name)：當特性name被訪問時自動被調用（只能新式類中使用）
• __getattr__(self,name)：當特性name被訪問且對象沒有相應的特性時被自動調用
• __setattr__(self,name)：給特性name賦值時會被自動調用
• __delattr__(self,name)：當刪除特性name時被自動調用

我們知道每當屬性被賦值的時候,__setattr__()就會被調用，通過它和__dict__[]的組合，我們可以通過動態為一個類創建創建特性，如下：

# -- coding: utf-8 --
class Employee(object):
    def __init__(self,name):
        self.name = name

    # RuntimeError: maximum recursion depth exceeded
    # #每當屬性被賦值的時候,__setattr__()會被調用，這樣就造成了遞歸調用。
    # def __setattr__(self,name,value):
    #   self.name = value

    def __setattr__(self,name,value):
        self.__dict__[name] = value

e = Employee("sunshine")
print e.name
e.email = "[e-mail]"
print e.email

 

如果只能訪問特定特性的話其實也很簡單，只需要想下面 __setattr__中加個if判斷即可：

# -- coding: utf-8 --
class AccessCounter(object):
    '''一個包含計數器的控制權限的類每當值被改變時計數器會加一'''

    def __init__(self, val):
        super(AccessCounter, self).__setattr__('counter', 0)
        super(AccessCounter, self).__setattr__('value', val)

    def __setattr__(self, name, value):
        if name == 'value':
            # 通過調用基類的__setattr__方法可以防止遞歸
            super(AccessCounter, self).__setattr__('counter', self.counter + 1)
        # 如果不想讓其他屬性被訪問的話，那么可以拋出 AttributeError(name) 異常
        super(AccessCounter, self).__setattr__(name, value)

    def __delattr__(self, name):
        if name == 'value':
            super(AccessCounter, self).__setattr__('counter', self.counter + 1)
        super(AccessCounter, self).__delattr__(name)

c = AccessCounter(10)
c.value = 1
c.value = 2
c.value = 3
c.value = 4
c.value = 5
print c.counter # value特性的值改變了5次

 

4. 定義靜態方法和類成員方法

靜態方法和類成員方法分別在創建時被裝入Staficmethod類型和Classmethod類型的對象中。靜態方法定義沒有任何參數，能夠被類本身直接調用。類方法在定義時需要名為cls的參數(類似於self參數)，且能夠被類本身調用。Python 2.4 為我們提供了名為:裝飾器(decorators)的新語法，可以很簡單的創建這兩種方法:

class MyClass(object):

    @staticmethod
    def smeth():
        print 'This is a static method'

    @classmethod
    def cmeth(cls):
        print 'This is a class method of',cls

MyClass.smeth() # This is a static method
MyClass.cmeth() # This is a class method of <class '__main__.MyClass'>
my = MyClass() 
my.cmeth() # This is a class method of <class '__main__.MyClass'>
my.smeth() # This is a static method

 

5. 協議

協議(protocol)在Python中的概念和C#中的接口比較類似，協議說明了應該實現何種方法和這些方法應該做什么。比如說，如果想要自定義一個序列，那么只需要遵守序列的協議即可。

 

5.1 迭代器

迭代器必須遵循迭代器協議，需要有 __iter__ (返回它本身) 和 next。__iter__方法是迭代器規則(iterator protocol)的基礎。__iter__返回一個具有next方法的迭代器(iterator)對象，調用next方法時，迭代器會返回它的下一個值，直到沒有值可返回時才會引發一個StopIteration異常。下面的示例使用迭代器來創建斐波那契數列，如下：

class Fibs(object):
    def __init__(self):
        self.a = 0
        self.b = 1

    def next(self):
        self.a,self.b = self.b,self.a+self.b
        return self.a

    def __iter__(self):
        return self

fibs = Fibs()

# output: 1 1 2 3 5 8 13 21 34 55
for f in fibs:
    if f < 60:
        print f,
    else:
        break

 

我們可以借助內建函數iter從可迭代的對象中獲得迭代器：

it = iter([1,2,3])
print it.next() # 1
print it.next() # 2
print it.next() # 3

 

也可以將迭代器轉換為一個序列：

# -- coding: utf-8 --
class TestIterator(object):
    value = 0
    def next(self):
        self.value += 1
        if self.value >10:raise StopIteration
        return self.value

    def __iter__(self):
        return self


ti = TestIterator()

# 通過list構造方法顯示將迭代器轉換為列表
print list(ti)

 

6. 生成器

生成器是用一種普通的函數語法定義的迭代器。任何包含yield語句的函數都可以稱為生成器。當包含yield語句的函數被調用時，函數體中的代碼不會被執行，而是返回一個迭代器對象。每次請求一個值，就會執行生成器中的代碼，知道遇到一個yield或者return語句。如下:

# -- coding: utf-8 --
nested = [[1,2],[3,4],[5]]

def flatten(nested):
    for sublist in nested:
        for element in sublist:
            yield element

# <generator object flatten at 0x0000000001D90168>
print flatten(nested)

# 調用時才真正執行
for num in flatten(nested):
    print num, # 1 2 3 4 5

 

 

參考資料&進一步閱讀

Python 魔法方法指南

Python 描述符簡介

Python基礎教程(第二版)

深刻理解Python中的元類(metaclass)