Python學習之物件導向高階程式設計

stonezhu發表於2018-06-19
Python物件程式設計

Python學習目錄

  1. 在Mac下使用Python3
  2. Python學習之資料型別
  3. Python學習之函式
  4. Python學習之高階特性
  5. Python學習之函數語言程式設計
  6. Python學習之模組
  7. Python學習之物件導向程式設計
  8. Python學習之物件導向高階程式設計
  9. Python學習之錯誤除錯和測試
  10. Python學習之IO程式設計
  11. Python學習之程式和執行緒
  12. Python學習之正則
  13. Python學習之常用模組
  14. Python學習之網路程式設計

資料封裝、繼承和多型只是物件導向程式設計中最基礎的3個概念。在Python中，物件導向還有很多高階特性，如：多重繼承、定製類、元類等概念。

_slots_

作用：限制例項的屬性。

Python允許在定義class的時候，定義一個特殊的__slots__變數，來限制該class例項能新增的屬性：

class Student(object):
    __slots__ = ('name', 'age') # 用tuple定義允許繫結的屬性名稱
    
>>> s = Student() # 建立新的例項
>>> s.name = 'Michael' # 繫結屬性'name'
>>> s.age = 25 # 繫結屬性'age'
>>> s.score = 99 # 繫結屬性'score'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
複製程式碼

由於'score'沒有被放到__slots__中，所以不能繫結score屬性，試圖繫結score將得到AttributeError的錯誤。

使用__slots__要注意，__slots__定義的屬性僅對當前類例項起作用，對繼承的子類是不起作用的：

>>> class GraduateStudent(Student):
...     pass
...
>>> g = GraduateStudent()
>>> g.score = 9999
複製程式碼

除非在子類中也定義__slots__，這樣，子類例項允許定義的屬性就是自身的__slots__加上父類的__slots__。

@property

裝飾器（decorator）可以給函式動態加上功能，對於類的方法，裝飾器一樣起作用，Python內建的@property裝飾器就是負責把一個方法變成屬性呼叫的：

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
複製程式碼

把一個getter方法變成屬性，只需要加上@property就可以了，此時，@property本身又建立了另一個裝飾器@score.setter，負責把一個setter方法變成屬性賦值，於是，我們就擁有一個可控的屬性操作：

>>> s = Student()
>>> s.score = 60 # OK，實際轉化為s.set_score(60)
>>> s.score # OK，實際轉化為s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!
複製程式碼

注意到這個神奇的@property，我們在對例項屬性操作的時候，就知道該屬性很可能不是直接暴露的，而是通過getter和setter方法來實現的。

還可以定義只讀屬性，只定義getter方法，不定義setter方法就是一個只讀屬性：

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2015 - self._birth
複製程式碼

上面的birth是可讀寫屬性，而age就是一個只讀屬性，因為age可以根據birth和當前時間計算出來。

多重繼承

在設計類的繼承關係時，通常，主線都是單一繼承下來的，例如，Ostrich繼承自Bird。但是，如果需要“混入”額外的功能，通過多重繼承就可以實現，比如，讓Ostrich除了繼承自Bird外，再同時繼承Runnable。這種設計通常稱之為MixIn。

為了更好地看出繼承關係，我們把Runnable和Flyable改為RunnableMixIn和FlyableMixIn。類似的，你還可以定義出肉食動物CarnivorousMixIn和植食動物HerbivoresMixIn，讓某個動物同時擁有好幾個MixIn：

class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
    pass
複製程式碼

MixIn的目的就是給一個類增加多個功能，這樣，在設計類的時候，我們優先考慮通過多重繼承來組合多個MixIn的功能，而不是設計多層次的複雜的繼承關係。

定製類

到類似__slots__這種形如__xxx__的變數或者函式名就要注意，這些在Python中是有特殊用途的。__slots__我們已經知道怎麼用了，__len__()方法我們也知道是為了能讓class作用於len()函式。除此之外，Python的class中還有許多這樣有特殊用途的函式，可以幫助我們定製類。

_str_

>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...     def __str__(self):
...         return 'Student object (name: %s)' % self.name
...
>>> print(Student('Michael'))
Student object (name: Michael)
複製程式碼

這樣列印出來的例項，不但好看，而且容易看出例項內部重要的資料。但是直接敲變數不用print，列印出來的例項還是不好看：

>>> s = Student('Michael')
>>> s
<__main__.Student object at 0x109afb310>
複製程式碼

這是因為直接顯示變數呼叫的不是__str__()，而是__repr__()，兩者的區別是__str__()返回使用者看到的字串，而__repr__()返回程式開發者看到的字串，也就是說，__repr__()是為除錯服務的。

解決辦法是再定義一個__repr__()。但是通常__str__()和__repr__()程式碼都是一樣的，所以，有個偷懶的寫法：

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__
複製程式碼

_iter_

如果一個類想被用於for ... in迴圈，類似list或tuple那樣，就必須實現一個__iter__()方法，該方法返回一個迭代物件，然後，Python的for迴圈就會不斷呼叫該迭代物件的__next__()方法拿到迴圈的下一個值，直到遇到StopIteration錯誤時退出迴圈。

我們以斐波那契數列為例，寫一個Fib類，可以作用於for迴圈：

class Fib(object):
   def __init__(self):
       self.a, self.b = 0, 1 # 初始化兩個計數器a，b

   def __iter__(self):
       return self # 例項本身就是迭代物件，故返回自己

   def __next__(self):
       self.a, self.b = self.b, self.a + self.b # 計算下一個值
       if self.a > 100000: # 退出迴圈的條件
           raise StopIteration()
       return self.a # 返回下一個值
複製程式碼

現在，試試把Fib例項作用於for迴圈：

>>> for n in Fib():
...     print(n)
...
1
1
2
3
5
...
46368
75025
複製程式碼

_getitem_

像list那樣按照下標取出元素，需要實現__getitem__()方法：

class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a
複製程式碼

現在，就可以按下標訪問數列的任意一項了：

>>> f = Fib()
>>> f[0]
1
>>> f[1]
1
>>> f[2]
2
>>> f[3]
3
>>> f[10]
89
>>> f[100]
573147844013817084101
複製程式碼

但是list有個神奇的切片方法：

>>> list(range(100))[5:10]
[5, 6, 7, 8, 9]
複製程式碼

對於Fib卻報錯。原因是__getitem__()傳入的引數可能是一個int，也可能是一個切片物件slice，所以要做判斷：

class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice): # n是切片
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L 
複製程式碼

_getattr_

Python有一個機制，那就是寫一個__getattr__()方法，動態返回一個屬性：

class Student(object):

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

    def __getattr__(self, attr):
        if attr=='score':
            return 99
複製程式碼

當呼叫不存在的屬性時，比如score，Python直譯器會試圖呼叫__getattr__(self, 'score')來嘗試獲得屬性，這樣，我們就有機會返回score的值：

>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99
複製程式碼

返回函式也是完全可以的：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
複製程式碼

只是呼叫方式要變為：

>>> s.age()
25
複製程式碼

注意，只有在沒有找到屬性的情況下，才呼叫__getattr__，已有的屬性，比如name，不會在__getattr__中查詢。

此外，注意到任意呼叫如s.abc都會返回None，這是因為我們定義的__getattr__預設返回就是None。要讓class只響應特定的幾個屬性，我們就要按照約定，丟擲AttributeError的錯誤：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)
複製程式碼

_call_

一個物件例項可以有自己的屬性和方法，當我們呼叫例項方法時，我們用instance.method()來呼叫。

同樣的，任何類，只需要定義一個__call__()方法，就可以直接對例項進行呼叫。請看示例：

class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)
        
>>> s = Student('Michael')
>>> s() # self引數不要傳入
My name is Michael.
複製程式碼

__call__()還可以定義引數。對例項進行直接呼叫就好比對一個函式進行呼叫一樣，所以你完全可以把物件看成函式，把函式看成物件，因為這兩者之間本來就沒啥根本的區別。

如果你把物件看成函式，那麼函式本身其實也可以在執行期動態建立出來，因為類的例項都是執行期建立出來的，這麼一來，我們就模糊了物件和函式的界限。

那麼，怎麼判斷一個變數是物件還是函式呢？其實，更多的時候，我們需要判斷一個物件是否能被呼叫，能被呼叫的物件就是一個Callable物件，比如函式和我們上面定義的帶有__call__()的類例項：

>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False
複製程式碼

列舉類

「列舉類」Enum是為列舉型別定義一個class型別，然後，每個常量都是class的一個唯一例項。

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
複製程式碼

這樣我們就獲得了Month型別的列舉類，可以直接使用Month.Jan來引用一個常量，或者列舉它的所有成員：

for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)
複製程式碼

value屬性則是自動賦給成員的int常量，預設從1開始計數。

如果需要更精確地控制列舉型別，可以從Enum派生出自定義類：

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被設定為0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
複製程式碼

@unique裝飾器可以幫助我們檢查保證沒有重複值。

訪問這些列舉型別可以有若干種方法：

>>> day1 = Weekday.Mon
>>> print(day1)
Weekday.Mon
>>> print(Weekday.Tue)
Weekday.Tue
>>> print(Weekday['Tue'])
Weekday.Tue
>>> print(Weekday.Tue.value)
2
>>> print(day1 == Weekday.Mon)
True
>>> print(day1 == Weekday.Tue)
False
>>> print(Weekday(1))
Weekday.Mon
>>> print(day1 == Weekday(1))
True
>>> Weekday(7)
Traceback (most recent call last):
  ...
ValueError: 7 is not a valid Weekday
>>> for name, member in Weekday.__members__.items():
...     print(name, '=>', member)
...
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat
複製程式碼

可見，既可以用成員名稱引用列舉常量，又可以直接根據value的值獲得列舉常量。

元類

type()

動態語言和靜態語言最大的不同，就是函式和類的定義，不是編譯時定義的，而是執行時動態建立的。

比方說我們要定義一個Hello的class，就寫一個hello.py模組：

class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)
複製程式碼

當Python直譯器載入hello模組時，就會依次執行該模組的所有語句，執行結果就是動態建立出一個Hello的class物件，測試如下：

>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class 'hello.Hello'>
複製程式碼

type()函式可以檢視一個型別或變數的型別，Hello是一個class，它的型別就是type，而h是一個例項，它的型別就是class Hello。

我們說class的定義是執行時動態建立的，而建立class的方法就是使用type()函式。

type()函式既可以返回一個物件的型別，又可以建立出新的型別，比如，我們可以通過type()函式建立出Hello類，而無需通過class Hello(object)...的定義：

>>> def fn(self, name='world'): # 先定義函式
...     print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 建立Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class '__main__.Hello'>
複製程式碼

要建立一個class物件，type()函式依次傳入3個引數：

  1. class的名稱；
  2. 繼承的父類集合，注意Python支援多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；
  3. class的方法名稱與函式繫結，這裡我們把函式fn繫結到方法名hello上。

通過type()函式建立的類和直接寫class是完全一樣的，因為Python直譯器遇到class定義時，僅僅是掃描一下class定義的語法，然後呼叫type()函式建立出class。

正常情況下，我們都用class Xxx...來定義類，但是，type()函式也允許我們動態建立出類來，也就是說，動態語言本身支援執行期動態建立類，這和靜態語言有非常大的不同，要在靜態語言執行期建立類，必須構造原始碼字串再呼叫編譯器，或者藉助一些工具生成位元組碼實現，本質上都是動態編譯，會非常複雜。

metaclass

除了使用type()動態建立類以外，要控制類的建立行為，還可以使用metaclass。

metaclass，直譯為元類，簡單的解釋就是：

當我們定義了類以後，就可以根據這個類建立出例項，所以：先定義類，然後建立例項。

但是如果我們想建立出類呢？那就必須根據metaclass建立出類，所以：先定義metaclass，然後建立類。

連線起來就是：先定義metaclass，就可以建立類，最後建立例項。

所以，metaclass允許你建立類或者修改類。換句話說，你可以把類看成是metaclass建立出來的“例項”。

下一篇：Python學習之錯誤除錯和測試

相關文章