一.類與類之間的依賴關係

大千世界, 萬物之間皆有規則和規律,我們的類和物件是對大千世界中的所有事物進行歸類,那事物之間存在著相對應的關係,類與類之間也同樣如此,在面向物件的世界中. 類與類中存在以下關係:

　　1. 依賴關係

　　2. 關聯關係

　　3. 組合關係

　　4. 聚合關係

　　5. 繼承關係

　　6. 實現關係

由於python是一門弱型別程式語言,並且所有的物件之間其實都是多型的關係,也就是說,所有的東西都可以當做物件來使用, 所以我們在寫程式碼的時候很容易形成以上關係.首先,我們先看第一種, 也是這些關係中緊密程度最低的一個, 依賴關係.

首先, 我們設計一個場景,還是最初的那個例子,要把大象裝冰箱,注意,在這個場景中, 其實是存在了兩種事物的, 一個是大象, 大象負責整個事件的掌控者, 還有一個是冰箱, 冰箱負責被大象操縱.

首先, 寫出兩個類, 一個是大象類, 一個是冰箱類

class Elphant:
    def __init__(self, name):
        self.name = name
    def open(self):
        '''
        開門
        :return :return:
        '''
        pass
    def close(self):
        '''
        關門
        :return :return:
        '''
        pass
class Refrigerator:
  
    def open_door(self):
        print("冰箱門被打開了")
  
    def close_door(self):
        print("冰箱門被關上了")    
 

冰箱的功能非常簡單, 只要會開門關門就行了. 但是大象就沒那麼簡單了,想想,大象開門和關門的時候是不是要先找個冰箱啊, 然後呢? 開啟冰箱門,是不是開啟剛才找到的那個冰箱門, 然後裝自己,最後呢? 關冰箱門, 注意, 關的是剛才那個冰箱吧. 也就是說, 開門和關門用的是一個冰箱,並且大象有更換冰箱的權利, 想進哪個冰箱就進哪個冰箱. 這時, 大象類和冰箱類的關係並沒有那麼的緊密,因為大象可以指定任何一個冰箱. 接下來,我們把程式碼完善一下.

class Elphant:
    def __init__(self, name):
        self.name = name
    def open(self, ref):
        print("大象要開門了. 默唸三聲. 開!")
        # 由外界傳遞進來一個冰箱, 讓冰箱開門, 這時大象不用揹著冰箱到處跑.
        # 類與類之間的關係也就不那麼的緊密了, 換句話說, 只要是有open_door()方法的物件.  都可以接收執行
        ref.open_door()
  
    def close(self, ref):
        print("大象要關門了. 默唸三聲. 關!")
        pass
    def take(self):
        print("鑽進去")
 
class Refrigerator:
    def open_door(self):
        print("冰箱門被打開了")
    def close_door(self):
        print("冰箱門被關上了")
# 造冰箱
r = Refrigerator()
# 造大象
el = Elphant("神奇的大象")
el.open(r) # 注意,此時是把一個冰箱作為引數傳遞進去了,也就是說,大象可以指定任何一個冰箱.
el.take()
el.close(r)
 

此時我們說, 大象和冰箱之間就是依賴關係,我用著你,但是你不屬於我, 這種關係是最弱的.比如,公司和僱員之間,對於正式員工, 肯定要簽訂勞動合同, 還得小心伺候著,但是如果是兼職,那無所謂,需要了你就來,不需要你就可以拜拜了. 這裡的兼職(臨時工) 就屬於依賴關係,我用你但是你不屬於我.

二.關聯關係.組合關係.聚合關係

其實這三個在程式碼上寫法是一樣的. 但是, 從含義上是不一樣的.

1. 關聯關係: 兩種事物必須是互相關聯的,但是在某些特殊情況下是可以更改和更換的

2. 聚合關係: 屬於關聯關係中的一種特例,側重點是xxx和xxx聚合成xxx. 各自有各自的宣告週期, 比如電腦,電腦裡有CPU, 硬碟, 記憶體等等,電腦掛了, CPU還是好的,還是完整的個體

3. 組合關係: 屬於關聯關係中的一種特例, 寫法上差不多,組合關係比聚合還要緊密,比如人的大腦, 心臟, 各個器官. 這些器官組合成一個人. 這時人如果掛了,其他的東西也跟著掛了.
   首先我們看關聯關係: 這個最簡單,也是最常用的一種關係. 比如,大家都有男女朋友,男人關聯著女朋友,女人關聯著男朋友. 這種關係可以是互相的, 也可以是單方面的.

#Python學習交流群：778463939

class Boy:
    def __init__(self, name, girlFriend=None):
        self.name = name
        self.girlFriend = girlFriend
 
    def have_a_dinner(self):
        if self.girlFriend:
            print("%s 和 %s⼀起去吃晚餐" % (self.name, self.girlFriend.name))
        else:
            print("單身狗. 吃什麼飯")
 
class Girl:
    def __init__(self, name):
        self.name = name
 
b = Boy("alex")
b.have_a_dinner()
 
# 突然牛B了. 找到女朋友了
g = Girl("如花")
b.girlFriend = g # 有女朋友了. 6666
b.have_a_dinner()
 
gg = Girl("李小花")
bb = Boy("wusir", gg) # 娃娃親. 出生就有女朋友. 服不服
 
bb.have_a_dinner() # 多麼幸福的一家
 
# 突然.bb失戀了. 娃娃親不跟他好了
bb.girlFriend = None
 
bb.have_a_dinner() # 又單身了

注意,此時Boy和Girl兩個類之間就是關聯關係,兩個類的物件緊密聯絡著, 其中一個沒有了,另一個就孤單的不得了, 關聯關係, 其實就是我需要你, 你也屬於我,這就是關聯關係. 像這樣的關係有很多很多,比如,學校和老師之間的關係.

• School --- 學校

• Teacher--- 老師

老師必然屬於一個學校,換句話說,每個老師肯定有一個指定的工作機構, 就是學校. 那老師的屬性中必然關聯著學校

class School:
    def __init__(self, name, address):
        self.name = name
        self.address = address
 
class Teacher:
    def __init__(self, name, school=None):
        self.name = name
        self.school = school
 
s1 = School("北京", "沙河")
s2 = School("上海", "迪士尼")
s3 = School("深圳", "南山區法院")
t1 = Teacher("白金", s1)
t2 = Teacher("黃金", s1)
t3 = Teacher("白銀", s2)
t4 = Teacher("青銅", s3)
 
# 找到青銅所在的地址
print(t4.school.address)

想想, 這樣的關係如果反過來,一個老師可以選一個學校任職, 那反過來, 一個學校有多少老師呢? 一堆吧? 這樣的關係如何來描述呢?

class School:
    def __init__(self, name, address):
        self.name = name
        self.address = address
        self.t_list = [] # 每個學校都應該有一個裝一堆老師的列表
 
    def add_teacher(self, teacher):
        self.t_list.append(teacher)
 
class Teacher:
    def __init__(self, name, school=None):
        self.name = name
        self.school = school
s1 = School("北京", "沙河")
s2 = School("上海", "迪士尼")
s3 = School("深圳", "南山區法院")
 
t1 = Teacher("白金", s1)
t2 = Teacher("黃金", s1)
t3 = Teacher("白銀", s2)
t4 = Teacher("青銅", s3)
 
s1.add_teacher(t1)
s1.add_teacher(t2)
s1.add_teacher(t3)
 

for t in s1.t_list:
    print(t.name)    

好了,這就是關聯關係,當我們在邏輯上出現了, 我需要你,你還得屬於我,這種邏輯就是關聯關係. 那注意,這種關係的緊密程度比上面的依賴關係要緊密的多,為什麼呢? 想想吧

至於組合關係和聚合關係,其實程式碼上的差別不大,都是把另一個類的物件作為這個類的屬性來傳遞和儲存, 只是在含義上會有些許的不同而已.

三.繼承關係

在面向物件的世界中存在著繼承關係,我們現實中也存在著這樣的關係, 我們說過,x是一種y, 那x就可以繼承y. 這時理解層面上的,如果上升到程式碼層面,我們可以這樣認為, 子類在不影響父類的程式執行的基礎上對父類進行的擴充和擴充套件. 這裡我們可以把父類稱為超類或者基類,子類被稱為派生類.

首先, 類名和物件預設是可以作為字典的key的

class Foo:
    def __init__(self):
        pass
    def method(self):
        pass
    # __hash__ = None
 
print(hash(Foo))
print(hash(Foo()))

既然可以hash, 那就是說字典的key可以是物件或者類

dic = {}
dic[Foo] = 123
dic[Foo()] = 456
print(dic) # {<class '__main__.Foo'>: 123, <__main__.Foo object at0x103491550>: 456}

雖然顯示的有點兒詭異,但是是可以用的.

接下來,我們來繼續研究繼承上的相關內容. 在本節中主要研究一下self,記住,不管方法之間如何進行呼叫, 類與類之間是何關係, 預設的self都是訪問這個方法的物件.

#Python學習交流群：778463939

class Base:
    def __init__(self, num):
        self.num = num
 
    def func1(self):
        print(self.num)
 
class Foo(Base):
    pass
 
obj = Foo(123)
obj.func1() # 123 執行的是Base中的func1

繼續:

class Base:
    def __init__(self, num):
        self.num = num
 
    def func1(self):
        print(self.num)
 
class Foo(Base):
    def func1(self):
        print("Foo. func1", self.num)
 
obj = Foo(123)
obj.func1() # Foo. func1 123 執行的是Foo中的func1

再來:

class Base:
    def __init__(self, num):
        self.num = num
 
    def func1(self):
        print(self.num)
        self.func2()
 
    def func2(self):
        print("Base.func2")
 
class Foo(Base):
    def func2(self):
        print("Foo.func2")
 
obj = Foo(123)
obj.func1() # 123 Foo.func2 func1是Base中的 func2是子類中的

總結:self在訪問方法的順序: 永遠先找自己的,自己的找不到再找父類的.

接下來. 來難得:

class Base:
    def __init__(self, num):
        self.num = num
 
    def func1(self):
        print(self.num)
        self.func2()
 
    def func2(self):
        print(111, self.num)
 
class Foo(Base):
    def func2(self):
        print(222, self.num)
 
lst = [Base(1), Base(2), Foo(3)]
for obj in lst:
    obj.func2() # 111 1 | 111 2 | 222 3

再來,還不夠繞.

#Python學習交流群：778463939

class Base:
    def __init__(self, num):
        self.num = num
 
    def func1(self):
        print(self.num)
        self.func2()
 
    def func2(self):
        print(111, self.num)
 
class Foo(Base):
    def func2(self):
        print(222, self.num)
 
lst = [Base(1), Base(2), Foo(3)]
for obj in lst:
 obj.func1() # 拿筆來吧. 好好算

結論: self就是你訪問方法的那個物件,先找自己, 然後在找父類的

四.類中的特殊成員

什麼是特殊成員呢? __init_()就是一 個特殊的成員,說白了,帶雙下劃線的那一坨,這些方法在特殊的場景的時候會被自動的執行. 比如,

1. 類名() 會自動執行__init__()

2. 物件() 會自動執行__call__()

3. 物件[key] 會自動執行__getitem__()

4. 物件[key] = value 會自動執行__setitem__()

5. del 物件[key] 會自動執行 __delitem__()

6. 物件+物件 會自動執行 __add__()

7. with 物件 as 變數 會自動執行__enter__ 和__exit__

8. 列印物件的時候 會自動執行 __str__

9. 幹掉可雜湊 __hash__ == None 物件就不可雜湊了.

10. abs(物件) 會自動執行__abs__()

11. bool(物件)會自動執行__bool__()

12. bytes(物件)會自動執行__bytes__()

13. float(物件)會自動執行__float__()

14. int(物件)會自動執行__int__()

15. 物件.index()會自動執行__index__()

16. len(物件)會自動執行__len__()

17. next() 會自動執行__next__()

18. repr()會自動執行__repr__()

19. round(物件)會自動執行__round__()

20. copy.物件會自動執行__copy__()

建立物件的真正步驟:

首先, 在執行類名()的時候,系統會自動先執行__new__()來開闢記憶體. 此時新開闢出來的記憶體區域是空的, 緊隨其後, 系統自動呼叫__init__()來完成物件的初始化工作,按照時間軸來算.

1. 載入類

2. 開闢記憶體(__new__)

3. 初始化(__init__)

4. 使用物件幹xxxxxxxxx

類似的操作還有很多很多,我們不需要完全刻意的去把所有的特殊成員全都記住,實戰中也用不到那麼多, 用到了查就是了.