一.類與類之間的依賴關系
大千世界, 萬物之間皆有規則和規律,我們的類和物件是對大千世界中的所有事物進行歸類,那事物之間存在著相對應的關系,類與類之間也同樣如此,在面向物件的世界中. 類與類中存在以下關系:
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)
此時我們說, 大象和冰箱之間就是依賴關系,我用著你,但是你不屬于我, 這種關系是最弱的.比如,公司和雇員之間,對于正式員工, 肯定要簽訂勞動合同, 還得小心伺候著,但是如果是兼職,那無所謂,需要了你就來,不需要你就可以拜拜了. 這里的兼職(臨時工) 就屬于依賴關系,我用你但是你不屬于我.
二.關聯關系.組合關系.聚合關系
其實這三個在代碼上寫法是一樣的. 但是, 從含義上是不一樣的.
-
關聯關系: 兩種事物必須是互相關聯的,但是在某些特殊情況下是可以更改和更換的
-
聚合關系: 屬于關聯關系中的一種特例,側重點是xxx和xxx聚合成xxx. 各自有各自的宣告周期, 比如電腦,電腦里有CPU, 硬碟, 記憶體等等,電腦掛了, CPU還是好的,還是完整的個體
-
組合關系: 屬于關聯關系中的一種特例, 寫法上差不多,組合關系比聚合還要緊密,比如人的大腦, 心臟, 各個器官. 這些器官組合成一個人. 這時人如果掛了,其他的東西也跟著掛了.
首先我們看關聯關系: 這個最簡單,也是最常用的一種關系. 比如,大家都有男女朋友,男人關聯著女朋友,女人關聯著男朋友. 這種關系可以是互相的, 也可以是單方面的.
#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_()就是一 個特殊的成員,說白了,帶雙下劃線的那一坨,這些方法在特殊的場景的時候會被自動的執行. 比如,
-
類名() 會自動執行
__init__() -
物件() 會自動執行
__call__() -
物件[key] 會自動執行
__getitem__() -
物件[key] = value 會自動執行
__setitem__() -
del 物件[key] 會自動執行
__delitem__() -
物件+物件 會自動執行
__add__() -
with 物件 as 變數 會自動執行
__enter__和__exit__ -
列印物件的時候 會自動執行
__str__ -
干掉可哈希
__hash__ == None物件就不可哈希了. -
abs(物件) 會自動執行
__abs__() -
bool(物件)會自動執行
__bool__() -
bytes(物件)會自動執行
__bytes__() -
float(物件)會自動執行
__float__() -
int(物件)會自動執行
__int__() -
物件.index()會自動執行
__index__() -
len(物件)會自動執行
__len__() -
next() 會自動執行
__next__() -
repr()會自動執行
__repr__() -
round(物件)會自動執行
__round__() -
copy.物件會自動執行
__copy__()
創建物件的真正步驟:
首先, 在執行類名()的時候,系統會自動先執行__new__()來開辟記憶體. 此時新開辟出來的記憶體區域是空的, 緊隨其后, 系統自動呼叫__init__()來完成物件的初始化作業,按照時間軸來算.
-
加載類
-
開辟記憶體(
__new__) -
初始化(
__init__) -
使用物件干xxxxxxxxx
類似的操作還有很多很多,我們不需要完全刻意的去把所有的特殊成員全都記住,實戰中也用不到那么多, 用到了查就是了.
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/197468.html
標籤：Python
上一篇：python獲得命令列輸入的引數
下一篇：Verification of WISHBONE I2C Master Core(IRUN+Simvision)