python_繼承

繼承

class Root(object):
    def __init__(self):
        print 'this is Root'
class B(Root):
    def __init__(self):
        print 'enter B'
        super(B, self).__init__()
        print 'leave B'

1、super 並不是一個函數，是一個類名，形如 super(B, self) 事實上調用了 super 類的初始化函數，產生了一個 super 對象

2、在super機制裏可以保證公共父類僅被執行一次，至於執行的順序，是按照mro進行的（E.__mro__）

3、Python的多繼承類是通過mro的方式來保證各個父類的函數被逐一調用，而且保證每個父類函數
       只調用一次（如果每個類都使用super）

4、super(B, self).func的調用並不是用於調用當前類的父類的func函數（mro中下一個類的func）

5、mro中記錄了一個類的所有基類的類類型序列。（如： F E B C D A object）

抽象基類

from abc import ABCMeta, abstractmethod        #導包

#抽象類
class Headers(object):
    __metaclass__ = ABCMeta            #表示抽象類

    def __init__(self):
        self.headers = ''

    @abstractmethod                    #定義抽象函數
    def _getBaiduHeaders(self):pass

    def __str__(self):
        return str(self.headers)

    def __repr__(self):
        return repr(self.headers)

#實現類
class BaiduHeaders(Headers):
    def __init__(self, url, username, password):
        self.url = url
        self.headers = self._getBaiduHeaders(username, password)

    def _getBaiduHeaders(self, username, password):
        client = GLOBAL_SUDS_CLIENT.Client(self.url)
        headers = client.factory.create('ns0:AuthHeader')
        headers.username = username
        headers.password = password
        headers.token = _baidu_headers['token']
        return headers

多重繼承

經典類：

#! /usr/bin/python
# -*- coding:utf-8 -*-

class P1():
    def foo(self):
        print 'p1-foo'

class P2():
    def foo(self):
        print 'p2-foo'
    def bar(self):
        print 'p2-bar'

class C1(P1,P2):
    pass

class C2(P1,P2):
    def bar(self):
        print 'C2-bar'

class D(C1,C2):
    pass


if __name__ =='__main__':
    d=D()
    d.foo()
    d.bar()

執行的結果：

p1-foo
p2-bar

從上面經典類的輸出結果來看，

實例d調用foo()時，搜索順序是 D => C1 => P1，

實例d調用bar()時，搜索順序是 D => C1 => P1 => P2

總結：經典類的搜索方式是按照“從左至右，深度優先”的方式去查找屬性。d先查找自身是否有foo方法，沒有則查找最近的父類C1裏是否有該方法，如果沒有則繼續向上查找，直到在P1中找到該方法，查找結束。

（換句話說：子類只會調用第一個被繼承的類的__init__）

新式類：

#! /usr/bin/python
# -*- coding:utf-8 -*-

class P1(object):
    def foo(self):
        print 'p1-foo'
        
class P2(object):
    def foo(self):
        print 'p2-foo'
    def bar(self):
        print 'p2-bar'
        
class C1(P1,P2):
    pass
    
class C2(P1,P2):
    def bar(self):
        print 'C2-bar'
        
class D(C1,C2):
    pass 
    

if __name__ =='__main__':
    print D.__mro__   #只有新式類有__mro__屬性，告訴查找順序是怎樣的
    d=D()
    d.foo()
    d.bar()

執行的結果：

(<class '__main__.D'>, <class '__main__.C1'>, <class '__main__.C2'>, <class '__main__.P1'>, <class '__main__.P2'>, <type 'object'>)

p1-foo
C2-bar

從上面新式類的輸出結果來看，

實例d調用foo()時，搜索順序是 D => C1 => C2 => P1

實例d調用bar()時，搜索順序是 D => C1 => C2

總結：新式類的搜索方式是採用“廣度優先”的方式去查找屬性。

Mix-in

貌似是一種方法，父類取消之間的依賴關係，化爲平級關係，子類繼承所有父類，順序自己排