Python(面向對象編程——2 繼承、派生、組合、抽象類)
繼承與派生
‘‘‘ 繼承:屬於 組合:包含 一、 在OOP程序設計中,當我們定義一個class的時候,可以從某個現有的class繼承,新的class稱為子類(Subclass),而被繼承的class稱為基類、父類或超類(Base class、Super class)。 繼承有什麽好處?最大的好處是子類獲得了父類的全部功能。 繼承:是基於抽象的結果,通過編程語言去實現它,肯定是先經歷抽象這個過程,才能通過繼承的方式去表達出抽象的結構。 二、 組合指的是,在一個類中以另外一個類的對象作為數據屬性,稱為類的組合 三、 接口的特征: * 1)是一組功能的集合,而不是一個功能 * 2)接口的功能用於交互,所有的功能都是public,即別的對象可操作 * 3)接口只定義函數,但不涉及函數實現 * 4)這些功能是相關的,都是某個類相關的功能。 接口提取了一群類共同的函數,可以把接口當做一個函數的集合。然後讓子類去實現接口中的函數。 這麽做的意義在於歸一化,什麽叫歸一化,就是只要是基於同一個接口實現的類,那麽所有的這些類產生的對象在使用時,從用法上來說都一樣。 歸一化,讓使用者無需關心對象的類是什麽,只需要的知道這些對象都具備某些功能就可以了,這極大地降低了使用者的使用難度。 四、 抽象類是一個特殊的類,它的特殊之處在於只能被繼承,不能被實例化 如果說類是從一堆對象中抽取相同的內容而來的,那麽抽象類就是從一堆類中抽取相同的內容而來的,內容包括數據屬性和函數屬性。‘‘‘ class Animal: #人屬於動物 def __init__(self,name,age): self.name=name self.age=age print(‘Animal.----init----‘) print(self.__dict__) def walk(self): print(self.name,‘wlaking‘) class Date_b: #人有生日 def __init__(self,year,mon,day): self.year=year self.mon=mon self.day=day def p_birth(self): print(‘出生於%s年,%s月,%s日‘ %(self.year,self.mon,self.day)) class People(Animal): #繼承 def __init__(self,name,age,sex,hobbies,*args) : #這裏也可以把 年月日列出來傳,那樣寫的時候pycharm也有提示,會比較好,這裏偷懶了Animal.__init__(self,name,age) self.sex=sex self.hobbies=hobbies self.birth=Date_b(*args) #組合 print(‘People--init--‘) # print(self.__dict__) def walk(self): #道理上來說,這裏可以不用類的原名字,可以任意命名,如何解決————抽象類(起到接口作用)(必須定義某幾個函數的功能) Animal.walk(self) print(‘兩腳獸walking:名字:%s,年齡:%s,性別:%s,愛好:%s‘ %(self.name,self.age,self.sex,self.hobbies)) #派生其實就是子類 print(‘年月:<%s><%s><%s>‘ %(self.birth.year,self.birth.mon,self.birth.day)) #直接繼承的內容,和組合上的內容,調用方式不大一樣 class Student(People): pass alex=People(‘alex‘,10,‘mail‘,‘anyway‘,‘1666‘,‘06‘,‘66‘) alex.walk() print(‘-----------------------------‘) alex.birth.p_birth() #-----------------抽象類---------------------- import abc class File_personal(metaclass=abc.ABCMeta): @abc.abstractmethod def read(self): pass class Txt(File_personal): def read(self): print(‘reading‘) def lll(self): print(‘lalala‘) a=Txt() a.read() a.lll()
‘‘‘ 另一種組合 ‘‘‘ class Animal: #人屬於動物 def __init__(self,name,age): self.name=name self.age=age def walk(self): print(self.name,‘wlaking‘) class Date_b: #人有生日 def __init__(self,year,mon,day): self.year=year self.mon=mon self.day=day def p_birth(self): print(‘出生於%s年,%s月,%s日‘ %(self.year,self.mon,self.day)) class People(Animal): #繼承 def __init__(self,name,age,sex,hobbies) : Animal.__init__(self,name,age) self.sex=sex self.hobbies=hobbies def walk(self): #道理上來說,這裏可以不用類的原名字,可以任意命名,如何解決————抽象類(起到接口作用)(必須定義某幾個函數的功能) Animal.walk(self) print(‘兩腳獸walking:名字:%s,年齡:%s,性別:%s,愛好:%s‘ %(self.name,self.age,self.sex,self.hobbies)) #派生 class Student(People): pass alex=People(‘alex‘,10,‘mail‘,‘anyway‘) alex.walk() alex.birth=Date_b(‘1666‘,‘06‘,‘66‘) #之後再定制屬性 alex.birth.p_birth()
1 什麽是繼承
繼承是一種創建新類的方式,在python中,新建的類可以繼承一個或多個父類,父類又可稱為基類或超類,新建的類稱為派生類或子類
python中類的繼承分為:單繼承和多繼承
class ParentClass1: #定義父類 pass class ParentClass2: #定義父類 pass class SubClass1(ParentClass1): #單繼承,基類是ParentClass1,派生類是SubClass pass class SubClass2(ParentClass1,ParentClass2): #python支持多繼承,用逗號分隔開多個繼承的類 pass
查看繼承
>>> SubClass1.__bases__ #__base__只查看從左到右繼承的第一個子類,__bases__則是查看所有繼承的父類 (<class ‘__main__.ParentClass1‘>,) >>> SubClass2.__bases__ (<class ‘__main__.ParentClass1‘>, <class ‘__main__.ParentClass2‘>)
提示:如果沒有指定基類,python的類會默認繼承object類,object是所有python類的基類,它提供了一些常見方法(如__str__)的實現。
>>> ParentClass1.__bases__ (<class ‘object‘>,) >>> ParentClass2.__bases__ (<class ‘object‘>,)
2 繼承與抽象(先抽象再繼承)
抽象即抽取類似或者說比較像的部分。
抽象分成兩個層次:
1.將奧巴馬和梅西這倆對象比較像的部分抽取成類;
2.將人,豬,狗這三個類比較像的部分抽取成父類。
抽象最主要的作用是劃分類別(可以隔離關註點,降低復雜度)
繼承:是基於抽象的結果,通過編程語言去實現它,肯定是先經歷抽象這個過程,才能通過繼承的方式去表達出抽象的結構。
抽象只是分析和設計的過程中,一個動作或者說一種技巧,通過抽象可以得到類
3 繼承與重用性
在開發程序的過程中,如果我們定義了一個類A,然後又想新建立另外一個類B,但是類B的大部分內容與類A的相同時
我們不可能從頭開始寫一個類B,這就用到了類的繼承的概念。
通過繼承的方式新建類B,讓B繼承A,B會‘遺傳’A的所有屬性(數據屬性和函數屬性),實現代碼重用
class Hero: def __init__(self,nickname,aggressivity,life_value): self.nickname=nickname self.aggressivity=aggressivity self.life_value=life_value def move_forward(self): print(‘%s move forward‘ %self.nickname) def move_backward(self): print(‘%s move backward‘ %self.nickname) def move_left(self): print(‘%s move forward‘ %self.nickname) def move_right(self): print(‘%s move forward‘ %self.nickname) def attack(self,enemy): enemy.life_value-=self.aggressivity class Garen(Hero): pass class Riven(Hero): pass g1=Garen(‘草叢倫‘,100,300) r1=Riven(‘銳雯雯‘,57,200) print(g1.life_value) r1.attack(g1) print(g1.life_value) ‘‘‘ 運行結果 300 243 ‘‘‘
提示:用已經有的類建立一個新的類,這樣就重用了已經有的軟件中的一部分設置大部分,大大生了編程工作量,這就是常說的軟件重用,不僅可以重用自己的類,也可以繼承別人的,比如標準庫,來定制新的數據類型,這樣就是大大縮短了軟件開發周期,對大型軟件開發來說,意義重大.
註意:像g1.life_value之類的屬性引用,會先從實例中找life_value然後去類中找,然後再去父類中找...直到最頂級的父類。
當然子類也可以添加自己新的屬性或者在自己這裏重新定義這些屬性(不會影響到父類),需要註意的是,一旦重新定義了自己的屬性且與父類重名,那麽調用新增的屬性時,就以自己為準了。
class Riven(Hero): camp=‘Noxus‘ def attack(self,enemy): #在自己這裏定義新的attack,不再使用父類的attack,且不會影響父類 print(‘from riven‘) def fly(self): #在自己這裏定義新的 print(‘%s is flying‘ %self.nickname)
在子類中,新建的重名的函數屬性,在編輯函數內功能的時候,有可能需要重用父類中重名的那個函數功能,應該是用調用普通函數的方式,即:類名.func(),此時就與調用普通函數無異了,因此即便是self參數也要為其傳值
class Riven(Hero): camp=‘Noxus‘ def __init__(self,nickname,aggressivity,life_value,skin): Hero.__init__(self,nickname,aggressivity,life_value) #調用父類功能 self.skin=skin #新屬性 def attack(self,enemy): #在自己這裏定義新的attack,不再使用父類的attack,且不會影響父類 Hero.attack(self,enemy) #調用功能 print(‘from riven‘) def fly(self): #在自己這裏定義新的 print(‘%s is flying‘ %self.nickname) r1=Riven(‘銳雯雯‘,57,200,‘比基尼‘) r1.fly() print(r1.skin) ‘‘‘ 運行結果 銳雯雯 is flying 比基尼 ‘‘‘
4 組合與重用性
軟件重用的重要方式除了繼承之外還有另外一種方式,即:組合
組合指的是,在一個類中以另外一個類的對象作為數據屬性,稱為類的組合
其實早在3.5小節中我們就體會了組合的用法,比如一個英雄有一個裝備
>>> class Equip: #武器裝備類 ... def fire(self): ... print(‘release Fire skill‘) ... >>> class Riven: #英雄Riven的類,一個英雄需要有裝備,因而需要組合Equip類 ... camp=‘Noxus‘ ... def __init__(self,nickname): ... self.nickname=nickname ... self.equip=Equip() #用Equip類產生一個裝備,賦值給實例的equip屬性 ... >>> r1=Riven(‘銳雯雯‘) >>> r1.equip.fire() #可以使用組合的類產生的對象所持有的方法 release Fire skill
組合與繼承都是有效地利用已有類的資源的重要方式。但是二者的概念和使用場景皆不同,
1.繼承的方式
通過繼承建立了派生類與基類之間的關系,它是一種‘是‘的關系,比如白馬是馬,人是動物。
當類之間有很多相同的功能,提取這些共同的功能做成基類,用繼承比較好,比如教授是老師
>>> class Teacher: ... def __init__(self,name,gender): ... self.name=name ... self.gender=gender ... def teach(self): ... print(‘teaching‘) ... >>> >>> class Professor(Teacher): ... pass ... >>> p1=Professor(‘egon‘,‘male‘) >>> p1.teach() teaching
2.組合的方式
用組合的方式建立了類與組合的類之間的關系,它是一種‘有’的關系,比如教授有生日,教授教python課程
class BirthDate: def __init__(self,year,month,day): self.year=year self.month=month self.day=day class Couse: def __init__(self,name,price,period): self.name=name self.price=price self.period=period class Teacher: def __init__(self,name,gender): self.name=name self.gender=gender def teach(self): print(‘teaching‘) class Professor(Teacher): def __init__(self,name,gender,birth,course): Teacher.__init__(self,name,gender) self.birth=birth self.course=course p1=Professor(‘egon‘,‘male‘, BirthDate(‘1995‘,‘1‘,‘27‘), Couse(‘python‘,‘28000‘,‘4 months‘)) print(p1.birth.year,p1.birth.month,p1.birth.day) print(p1.course.name,p1.course.price,p1.course.period) ‘‘‘ 運行結果: 1995 1 27 python 28000 4 months ‘‘‘
當類之間有顯著不同,並且較小的類是較大的類所需要的組件時,用組合比較好
5 接口與歸一化設計
1.什麽是接口
繼承有兩種用途:
一:繼承基類的方法,並且做出自己的改變或者擴展(代碼重用)
二:聲明某個子類兼容於某基類,定義一個接口類Interface,接口類中定義了一些接口名(就是函數名)且並未實現接口的功能,子類繼承接口類,並且實現接口中的功能
class Interface:#定義接口Interface類來模仿接口的概念,python中壓根就沒有interface關鍵字來定義一個接口。 def read(self): #定接口函數read pass def write(self): #定義接口函數write pass class Txt(Interface): #文本,具體實現read和write def read(self): print(‘文本數據的讀取方法‘) def write(self): print(‘文本數據的讀取方法‘) class Sata(Interface): #磁盤,具體實現read和write def read(self): print(‘硬盤數據的讀取方法‘) def write(self): print(‘硬盤數據的讀取方法‘) class Process(Interface): def read(self): print(‘進程數據的讀取方法‘) def write(self): print(‘進程數據的讀取方法‘)
實踐中,繼承的第一種含義意義並不很大,甚至常常是有害的。因為它使得子類與基類出現強耦合。
繼承的第二種含義非常重要。它又叫“接口繼承”。
接口繼承實質上是要求“做出一個良好的抽象,這個抽象規定了一個兼容接口,使得外部調用者無需關心具體細節,可一視同仁的處理實現了特定接口的所有對象”——這在程序設計上,叫做歸一化。
歸一化使得高層的外部使用者可以不加區分的處理所有接口兼容的對象集合——就好象linux的泛文件概念一樣,所有東西都可以當文件處理,不必關心它是內存、磁盤、網絡還是屏幕(當然,對底層設計者,當然也可以區分出“字符設備”和“塊設備”,然後做出針對性的設計:細致到什麽程度,視需求而定)。
在python中根本就沒有一個叫做interface的關鍵字,上面的代碼只是看起來像接口,其實並沒有起到接口的作用,子類完全可以不用去實現接口 ,如果非要去模仿接口的概念,可以借助第三方模塊:
http://pypi.python.org/pypi/zope.interface
twisted的twisted\internet\interface.py裏使用zope.interface
文檔https://zopeinterface.readthedocs.io/en/latest/
設計模式:https://github.com/faif/python-patterns
2. 為何要用接口
接口提取了一群類共同的函數,可以把接口當做一個函數的集合。
然後讓子類去實現接口中的函數。
這麽做的意義在於歸一化,什麽叫歸一化,就是只要是基於同一個接口實現的類,那麽所有的這些類產生的對象在使用時,從用法上來說都一樣。
歸一化,讓使用者無需關心對象的類是什麽,只需要的知道這些對象都具備某些功能就可以了,這極大地降低了使用者的使用難度。
比如:我們定義一個動物接口,接口裏定義了有跑、吃、呼吸等接口函數,這樣老鼠的類去實現了該接口,松鼠的類也去實現了該接口,由二者分別產生一只老鼠和一只松鼠送到你面前,即便是你分別不到底哪只是什麽鼠你肯定知道他倆都會跑,都會吃,都能呼吸。
再比如:我們有一個汽車接口,裏面定義了汽車所有的功能,然後由本田汽車的類,奧迪汽車的類,大眾汽車的類,他們都實現了汽車接口,這樣就好辦了,大家只需要學會了怎麽開汽車,那麽無論是本田,還是奧迪,還是大眾我們都會開了,開的時候根本無需關心我開的是哪一類車,操作手法(函數調用)都一樣
6 抽象類
1 什麽是抽象類
與java一樣,python也有抽象類的概念但是同樣需要借助模塊實現,抽象類是一個特殊的類,它的特殊之處在於只能被繼承,不能被實例化
2 為什麽要有抽象類
如果說類是從一堆對象中抽取相同的內容而來的,那麽抽象類就是從一堆類中抽取相同的內容而來的,內容包括數據屬性和函數屬性。
比如我們有香蕉的類,有蘋果的類,有桃子的類,從這些類抽取相同的內容就是水果這個抽象的類,你吃水果時,要麽是吃一個具體的香蕉,要麽是吃一個具體的桃子。。。。。。你永遠無法吃到一個叫做水果的東西。
從設計角度去看,如果類是從現實對象抽象而來的,那麽抽象類就是基於類抽象而來的。
從實現角度來看,抽象類與普通類的不同之處在於:抽象類中只能有抽象方法(沒有實現功能),該類不能被實例化,只能被繼承,且子類必須實現抽象方法。這一點與接口有點類似,但其實是不同的,即將揭曉答案
3. 在python中實現抽象類
#_*_coding:utf-8_*_ __author__ = ‘Linhaifeng‘ #一切皆文件 import abc #利用abc模塊實現抽象類 class All_file(metaclass=abc.ABCMeta): all_type=‘file‘ @abc.abstractmethod #定義抽象方法,無需實現功能 def read(self): ‘子類必須定義讀功能‘ pass @abc.abstractmethod #定義抽象方法,無需實現功能 def write(self): ‘子類必須定義寫功能‘ pass # class Txt(All_file): # pass # # t1=Txt() #報錯,子類沒有定義抽象方法 class Txt(All_file): #子類繼承抽象類,但是必須定義read和write方法 def read(self): print(‘文本數據的讀取方法‘) def write(self): print(‘文本數據的讀取方法‘) class Sata(All_file): #子類繼承抽象類,但是必須定義read和write方法 def read(self): print(‘硬盤數據的讀取方法‘) def write(self): print(‘硬盤數據的讀取方法‘) class Process(All_file): #子類繼承抽象類,但是必須定義read和write方法 def read(self): print(‘進程數據的讀取方法‘) def write(self): print(‘進程數據的讀取方法‘) wenbenwenjian=Txt() yingpanwenjian=Sata() jinchengwenjian=Process() #這樣大家都是被歸一化了,也就是一切皆文件的思想 wenbenwenjian.read() yingpanwenjian.write() jinchengwenjian.read() print(wenbenwenjian.all_type) print(yingpanwenjian.all_type) print(jinchengwenjian.all_type)
4. 抽象類與接口
抽象類的本質還是類,指的是一組類的相似性,包括數據屬性(如all_type)和函數屬性(如read、write),而接口只強調函數屬性的相似性。
抽象類是一個介於類和接口直接的一個概念,同時具備類和接口的部分特性,可以用來實現歸一化設計
Python(面向對象編程——2 繼承、派生、組合、抽象類)