二 面向对象三大特性
?
?
?
一 繼承與派生
一、繼承定義
二、繼承與抽象的關(guān)系
三、繼承與重用性
四、派生
五、組合與重用性
六、接口與歸一化設(shè)計(jì)
七、抽象類
八、繼承實(shí)現(xiàn)的原理
九、子類中調(diào)用父類的方法
二 多態(tài)與多態(tài)性
一、多態(tài)
二、多態(tài)性
三 封裝
一、封裝定義
二、特性(property)
三、封裝與擴(kuò)展性
?
一 繼承與派生
一、繼承定義
什么是繼承
繼承是一種創(chuàng)建新類的方式，新建的類可以繼承一個(gè)或多個(gè)父類（python支持多繼承），父類又可稱為基類或超類，新建的類稱為派生類或子類。
子類會(huì)“”遺傳”父類的屬性，從而解決代碼重用問題（比如練習(xí)7中Garen與Riven類有很多冗余的代碼）
python中類的繼承分為：單繼承和多繼承
?
1 class ParentClass1: #定義父類 2 pass 3 4 class ParentClass2: #定義父類 5 pass 6 7 class SubClass1(ParentClass1): #單繼承，基類是ParentClass1，派生類是SubClass 8 pass 9 10 class SubClass2(ParentClass1,ParentClass2): #python支持多繼承，用逗號(hào)分隔開多個(gè)繼承的類 11 pass查看繼承
1 >>> SubClass1.__bases__ #__base__只查看從左到右繼承的第一個(gè)子類，__bases__則是查看所有繼承的父類 2 (<class '__main__.ParentClass1'>,) 3 >>> SubClass2.__bases__ 4 (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)經(jīng)典類與新式類
1.只有在python2中才分新式類和經(jīng)典類，python3中統(tǒng)一都是新式類 2.在python2中，沒有顯式的繼承object類的類，以及該類的子類，都是經(jīng)典類 3.在python2中，顯式地聲明繼承object的類，以及該類的子類，都是新式類 3.在python3中，無論是否繼承object，都默認(rèn)繼承object，即python3中所有類均為新式類 #關(guān)于新式類與經(jīng)典類的區(qū)別，我們稍后討論提示：如果沒有指定基類，python的類會(huì)默認(rèn)繼承object類，object是所有python類的基類，它提供了一些常見方法（如__str__）的實(shí)現(xiàn)。
1 >>> ParentClass1.__bases__ 2 (<class 'object'>,) 3 >>> ParentClass2.__bases__ 4 (<class 'object'>,)?
二、繼承與抽象的關(guān)系
繼承描述的是子類與父類之間的關(guān)系，是一種什么是什么的關(guān)系。要找出這種關(guān)系，必須先抽象再繼承
抽象即抽取類似或者說比較像的部分。
繼承：是基于抽象的結(jié)果，通過編程語言去實(shí)現(xiàn)它，肯定是先經(jīng)歷抽象這個(gè)過程，才能通過繼承的方式去表達(dá)出抽象的結(jié)構(gòu)。
?
抽象只是分析和設(shè)計(jì)的過程中，一個(gè)動(dòng)作或者說一種技巧，通過抽象可以得到類
?
三、繼承與重用性
在開發(fā)程序的過程中，如果我們定義了一個(gè)類A，然后又想新建立另外一個(gè)類B，但是類B的大部分內(nèi)容與類A的相同時(shí)
我們不可能從頭開始寫一個(gè)類B，這就用到了類的繼承的概念。
通過繼承的方式新建類B，讓B繼承A，B會(huì)‘遺傳’A的所有屬性(數(shù)據(jù)屬性和函數(shù)屬性)，實(shí)現(xiàn)代碼重用
1 class Hero: 2 def __init__(self,nickname,aggressivity,life_value): 3 self.nickname=nickname 4 self.aggressivity=aggressivity 5 self.life_value=life_value 6 7 def move_forward(self): 8 print('%s move forward' %self.nickname) 9 10 def move_backward(self): 11 print('%s move backward' %self.nickname) 12 13 def move_left(self): 14 print('%s move forward' %self.nickname) 15 16 def move_right(self): 17 print('%s move forward' %self.nickname) 18 19 def attack(self,enemy): 20 enemy.life_value-=self.aggressivity 21 class Garen(Hero): 22 pass 23 24 class Riven(Hero): 25 pass 26 27 g1=Garen('草叢倫',100,300) 28 r1=Riven('銳雯雯',57,200) 29 30 print(g1.life_value) 31 r1.attack(g1) 32 print(g1.life_value) 33 34 ''' 35 運(yùn)行結(jié)果 36 '''提示：用已經(jīng)有的類建立一個(gè)新的類，這樣就重用了已經(jīng)有的軟件中的一部分設(shè)置大部分，大大生了編程工作量，這就是常說的軟件重用，不僅可以重用自己的類，也可以繼承別人的，比如標(biāo)準(zhǔn)庫，來定制新的數(shù)據(jù)類型，這樣就是大大縮短了軟件開發(fā)周期，對(duì)大型軟件開發(fā)來說，意義重大.
注意：像g1.life_value之類的屬性引用，會(huì)先從實(shí)例中找life_value然后去類中找，然后再去父類中找...直到最頂級(jí)的父類。
1 class Foo: 2 def f1(self): 3 print('Foo.f1') 4 5 def f2(self): 6 print('Foo.f2') 7 self.f1() 8 9 class Bar(Foo): 10 def f1(self): 11 print('Foo.f1') 12 13 14 b=Bar() 15 b.f2()?
四、派生
當(dāng)然子類也可以添加自己新的屬性或者在自己這里重新定義這些屬性（不會(huì)影響到父類），需要注意的是，一旦重新定義了自己的屬性且與父類重名，那么調(diào)用新增的屬性時(shí)，就以自己為準(zhǔn)了。
1 class Riven(Hero): 2 camp='Noxus' 3 def attack(self,enemy): #在自己這里定義新的attack,不再使用父類的attack,且不會(huì)影響父類 4 print('from riven') 5 def fly(self): #在自己這里定義新的 6 print('%s is flying' %self.nickname)在子類中，新建的重名的函數(shù)屬性，在編輯函數(shù)內(nèi)功能的時(shí)候，有可能需要重用父類中重名的那個(gè)函數(shù)功能，應(yīng)該是用調(diào)用普通函數(shù)的方式，即：類名.func()，此時(shí)就與調(diào)用普通函數(shù)無異了，因此即便是self參數(shù)也要為其傳值
class Riven(Hero):camp='Noxus'def __init__(self,nickname,aggressivity,life_value,skin):Hero.__init__(self,nickname,aggressivity,life_value) #調(diào)用父類功能self.skin=skin #新屬性def attack(self,enemy): #在自己這里定義新的attack,不再使用父類的attack,且不會(huì)影響父類Hero.attack(self,enemy) #調(diào)用功能print('from riven')def fly(self): #在自己這里定義新的print('%s is flying' %self.nickname)r1=Riven('銳雯雯',57,200,'大衣') r1.fly() print(r1.skin)''' 運(yùn)行結(jié)果 銳雯雯 is flying 大衣'''?
五、組合與重用性
軟件重用的重要方式除了繼承之外還有另外一種方式，即：組合
組合指的是，在一個(gè)類中以另外一個(gè)類的對(duì)象作為數(shù)據(jù)屬性，稱為類的組合
組合與繼承都是有效地利用已有類的資源的重要方式。但是二者的概念和使用場(chǎng)景皆不同，
1.繼承的方式
通過繼承建立了派生類與基類之間的關(guān)系，它是一種'是'的關(guān)系，比如白馬是馬，人是動(dòng)物。
當(dāng)類之間有很多相同的功能，提取這些共同的功能做成基類，用繼承比較好，比如老師是人，學(xué)生是人
2.組合的方式
用組合的方式建立了類與組合的類之間的關(guān)系，它是一種‘有’的關(guān)系,比如教授有生日，教授教python和linux課程，教授有學(xué)生s1、s2、s3...
1 class People: 2 def __init__(self,name,age,sex): 3 self.name=name 4 self.age=age 5 self.sex=sex 6 7 class Course: 8 def __init__(self,name,period,price): 9 self.name=name 10 self.period=period 11 self.price=price 12 def tell_info(self): 13 print('<%s %s %s>' %(self.name,self.period,self.price)) 14 15 class Teacher(People): 16 def __init__(self,name,age,sex,job_title): 17 People.__init__(self,name,age,sex) 18 self.job_title=job_title 19 self.course=[] 20 self.students=[] 21 22 23 class Student(People): 24 def __init__(self,name,age,sex): 25 People.__init__(self,name,age,sex) 26 self.course=[] 27 28 29 lucy=Teacher('lucy',56,'male','python講師') 30 s1=Student('anna',18,'female') 31 32 python=Course('python','3mons',3000.0) 33 linux=Course('python','3mons',3000.0) 34 35 #為老師egon和學(xué)生s1添加課程 36 lucy.course.append(python) 37 lucy.course.append(linux) 38 s1.course.append(python) 39 40 #為老師lucy添加學(xué)生s1 41 lucy.students.append(s1) 42 43 44 #使用 45 for obj in lucy.course: 46 obj.tell_info() 例子：繼承與組合當(dāng)類之間有顯著不同，并且較小的類是較大的類所需要的組件時(shí)，用組合比較好
?
六、接口與歸一化設(shè)計(jì)
1.什么是接口
?
1 =================第一部分：Java 語言中的接口很好的展現(xiàn)了接口的含義: IAnimal.java 2 /* 3 * Java的Interface接口的特征: 4 * 1)是一組功能的集合,而不是一個(gè)功能 5 * 2)接口的功能用于交互,所有的功能都是public,即別的對(duì)象可操作 6 * 3)接口只定義函數(shù),但不涉及函數(shù)實(shí)現(xiàn) 7 * 4)這些功能是相關(guān)的,都是動(dòng)物相關(guān)的功能,但光合作用就不適宜放到IAnimal里面了 */ 8 9 package com.oo.demo; 10 public interface IAnimal { 11 public void eat(); 12 public void run(); 13 public void sleep(); 14 public void speak(); 15 } 16 17 =================第二部分：Pig.java：豬”的類設(shè)計(jì),實(shí)現(xiàn)了IAnnimal接口 18 package com.oo.demo; 19 public class Pig implements IAnimal{ //如下每個(gè)函數(shù)都需要詳細(xì)實(shí)現(xiàn) 20 public void eat(){ 21 System.out.println("Pig like to eat grass"); 22 } 23 24 public void run(){ 25 System.out.println("Pig run: front legs, back legs"); 26 } 27 28 public void sleep(){ 29 System.out.println("Pig sleep 16 hours every day"); 30 } 31 32 public void speak(){ 33 System.out.println("Pig can not speak"); } 34 } 35 36 =================第三部分：Person2.java 37 /* 38 *實(shí)現(xiàn)了IAnimal的“人”,有幾點(diǎn)說明一下: 39 * 1)同樣都實(shí)現(xiàn)了IAnimal的接口,但“人”和“豬”的實(shí)現(xiàn)不一樣,為了避免太多代碼導(dǎo)致影響閱讀,這里的代碼簡化成一行,但輸出的內(nèi)容不一樣,實(shí)際項(xiàng)目中同一接口的同一功能點(diǎn),不同的類實(shí)現(xiàn)完全不一樣 40 * 2)這里同樣是“人”這個(gè)類,但和前面介紹類時(shí)給的類“Person”完全不一樣,這是因?yàn)橥瑯拥倪壿嫺拍?在不同的應(yīng)用場(chǎng)景下,具備的屬性和功能是完全不一樣的 */ 41 42 package com.oo.demo; 43 public class Person2 implements IAnimal { 44 public void eat(){ 45 System.out.println("Person like to eat meat"); 46 } 47 48 public void run(){ 49 System.out.println("Person run: left leg, right leg"); 50 } 51 52 public void sleep(){ 53 System.out.println("Person sleep 8 hours every dat"); 54 } 55 56 public void speak(){ 57 System.out.println("Hellow world, I am a person"); 58 } 59 } 60 61 =================第四部分：Tester03.java 62 package com.oo.demo; 63 64 public class Tester03 { 65 public static void main(String[] args) { 66 System.out.println("===This is a person==="); 67 IAnimal person = new Person2(); 68 person.eat(); 69 person.run(); 70 person.sleep(); 71 person.speak(); 72 73 System.out.println("\n===This is a pig==="); 74 IAnimal pig = new Pig(); 75 pig.eat(); 76 pig.run(); 77 pig.sleep(); 78 pig.speak(); 79 } 80 } java中的interface2. 為何要用接口
接口提取了一群類共同的函數(shù)，可以把接口當(dāng)做一個(gè)函數(shù)的集合。
然后讓子類去實(shí)現(xiàn)接口中的函數(shù)。
這么做的意義在于歸一化，什么叫歸一化，就是只要是基于同一個(gè)接口實(shí)現(xiàn)的類，那么所有的這些類產(chǎn)生的對(duì)象在使用時(shí)，從用法上來說都一樣。
?
歸一化的好處在于：
1. 歸一化讓使用者無需關(guān)心對(duì)象的類是什么，只需要的知道這些對(duì)象都具備某些功能就可以了，這極大地降低了使用者的使用難度。
2. 歸一化使得高層的外部使用者可以不加區(qū)分的處理所有接口兼容的對(duì)象集合
2.1：就好象linux的泛文件概念一樣，所有東西都可以當(dāng)文件處理，不必關(guān)心它是內(nèi)存、磁盤、網(wǎng)絡(luò)還是屏幕（當(dāng)然，對(duì)底層設(shè)計(jì)者，當(dāng)然也可以區(qū)分出“字符設(shè)備”和“塊設(shè)備”，然后做出針對(duì)性的設(shè)計(jì)：細(xì)致到什么程度，視需求而定）。
2.2：再比如：我們有一個(gè)汽車接口，里面定義了汽車所有的功能，然后由本田汽車的類，奧迪汽車的類，大眾汽車的類，他們都實(shí)現(xiàn)了汽車接口，這樣就好辦了，大家只需要學(xué)會(huì)了怎么開汽車，那么無論是本田，還是奧迪，還是大眾我們都會(huì)開了，開的時(shí)候根本無需關(guān)心我開的是哪一類車，操作手法（函數(shù)調(diào)用）都一樣
3. 模仿interface
在python中根本就沒有一個(gè)叫做interface的關(guān)鍵字，如果非要去模仿接口的概念
可以借助第三方模塊：
http://pypi.python.org/pypi/zope.interface
twisted的twisted\internet\interface.py里使用zope.interface
文檔https://zopeinterface.readthedocs.io/en/latest/
設(shè)計(jì)模式：https://github.com/faif/python-patterns
?
也可以使用繼承：?
繼承的兩種用途
一：繼承基類的方法，并且做出自己的改變或者擴(kuò)展（代碼重用）：實(shí)踐中，繼承的這種用途意義并不很大，甚至常常是有害的。因?yàn)樗沟米宇惻c基類出現(xiàn)強(qiáng)耦合。
二：聲明某個(gè)子類兼容于某基類，定義一個(gè)接口類（模仿java的Interface），接口類中定義了一些接口名（就是函數(shù)名）且并未實(shí)現(xiàn)接口的功能，子類繼承接口類，并且實(shí)現(xiàn)接口中的功能
class Interface:#定義接口Interface類來模仿接口的概念，python中壓根就沒有interface關(guān)鍵字來定義一個(gè)接口。def read(self): #定接口函數(shù)readpassdef write(self): #定義接口函數(shù)writepassclass Txt(Interface): #文本，具體實(shí)現(xiàn)read和writedef read(self):print('文本數(shù)據(jù)的讀取方法')def write(self):print('文本數(shù)據(jù)的讀取方法')class Sata(Interface): #磁盤，具體實(shí)現(xiàn)read和writedef read(self):print('硬盤數(shù)據(jù)的讀取方法')def write(self):print('硬盤數(shù)據(jù)的讀取方法')class Process(Interface):def read(self):print('進(jìn)程數(shù)據(jù)的讀取方法')def write(self):print('進(jìn)程數(shù)據(jù)的讀取方法')上面的代碼只是看起來像接口，其實(shí)并沒有起到接口的作用，子類完全可以不用去實(shí)現(xiàn)接口?，這就用到了抽象類
?
七、抽象類
1 什么是抽象類
? ? 與java一樣，python也有抽象類的概念但是同樣需要借助模塊實(shí)現(xiàn)，抽象類是一個(gè)特殊的類，它的特殊之處在于只能被繼承，不能被實(shí)例化
2 為什么要有抽象類
??? 如果說類是從一堆對(duì)象中抽取相同的內(nèi)容而來的，那么抽象類就是從一堆類中抽取相同的內(nèi)容而來的，內(nèi)容包括數(shù)據(jù)屬性和函數(shù)屬性。
比如我們有香蕉的類，有蘋果的類，有桃子的類，從這些類抽取相同的內(nèi)容就是水果這個(gè)抽象的類，你吃水果時(shí)，要么是吃一個(gè)具體的香蕉，要么是吃一個(gè)具體的桃子。。。。。。你永遠(yuǎn)無法吃到一個(gè)叫做水果的東西。
? ? 從設(shè)計(jì)角度去看，如果類是從現(xiàn)實(shí)對(duì)象抽象而來的，那么抽象類就是基于類抽象而來的。
從實(shí)現(xiàn)角度來看，抽象類與普通類的不同之處在于：抽象類中只能有抽象方法（沒有實(shí)現(xiàn)功能），該類不能被實(shí)例化，只能被繼承，且子類必須實(shí)現(xiàn)抽象方法。這一點(diǎn)與接口有點(diǎn)類似，但其實(shí)是不同的，即將揭曉答案
3. 在python中實(shí)現(xiàn)抽象類
1 #_*_coding:utf-8_*_ 2 __author__ = 'Linhaifeng' 3 #一切皆文件 4 import abc #利用abc模塊實(shí)現(xiàn)抽象類 5 6 class All_file(metaclass=abc.ABCMeta): 7 all_type='file' 8 @abc.abstractmethod #定義抽象方法，無需實(shí)現(xiàn)功能 9 def read(self): 10 '子類必須定義讀功能' 11 pass 12 13 @abc.abstractmethod #定義抽象方法，無需實(shí)現(xiàn)功能 14 def write(self): 15 '子類必須定義寫功能' 16 pass 17 18 # class Txt(All_file): 19 # pass 20 # 21 # t1=Txt() #報(bào)錯(cuò),子類沒有定義抽象方法 22 23 class Txt(All_file): #子類繼承抽象類，但是必須定義read和write方法 24 def read(self): 25 print('文本數(shù)據(jù)的讀取方法') 26 27 def write(self): 28 print('文本數(shù)據(jù)的讀取方法') 29 30 class Sata(All_file): #子類繼承抽象類，但是必須定義read和write方法 31 def read(self): 32 print('硬盤數(shù)據(jù)的讀取方法') 33 34 def write(self): 35 print('硬盤數(shù)據(jù)的讀取方法') 36 37 class Process(All_file): #子類繼承抽象類，但是必須定義read和write方法 38 def read(self): 39 print('進(jìn)程數(shù)據(jù)的讀取方法') 40 41 def write(self): 42 print('進(jìn)程數(shù)據(jù)的讀取方法') 43 44 wenbenwenjian=Txt() 45 46 yingpanwenjian=Sata() 47 48 jinchengwenjian=Process() 49 50 #這樣大家都是被歸一化了,也就是一切皆文件的思想 51 wenbenwenjian.read() 52 yingpanwenjian.write() 53 jinchengwenjian.read() 54 55 print(wenbenwenjian.all_type) 56 print(yingpanwenjian.all_type) 57 print(jinchengwenjian.all_type)4. 抽象類與接口
抽象類的本質(zhì)還是類，指的是一組類的相似性，包括數(shù)據(jù)屬性（如all_type）和函數(shù)屬性（如read、write），而接口只強(qiáng)調(diào)函數(shù)屬性的相似性。
抽象類是一個(gè)介于類和接口直接的一個(gè)概念，同時(shí)具備類和接口的部分特性，可以用來實(shí)現(xiàn)歸一化設(shè)計(jì)?
?
八、繼承實(shí)現(xiàn)的原理
1 繼承順序
在Java和C#中子類只能繼承一個(gè)父類，而Python中子類可以同時(shí)繼承多個(gè)父類，如A(B,C,D)
如果繼承關(guān)系為非菱形結(jié)構(gòu)，則會(huì)按照先找B這一條分支，然后再找C這一條分支，最后找D這一條分支的順序直到找到我們想要的屬性
如果繼承關(guān)系為菱形結(jié)構(gòu)，那么屬性的查找方式有兩種，分別是：深度優(yōu)先和廣度優(yōu)先
1 class A(object): 2 def test(self): 3 print('from A') 4 5 class B(A): 6 def test(self): 7 print('from B') 8 9 class C(A): 10 def test(self): 11 print('from C') 12 13 class D(B): 14 def test(self): 15 print('from D') 16 17 class E(C): 18 def test(self): 19 print('from E') 20 21 class F(D,E): 22 # def test(self): 23 # print('from F') 24 pass 25 f1=F() 26 f1.test() 27 print(F.__mro__) #只有新式才有這個(gè)屬性可以查看線性列表，經(jīng)典類沒有這個(gè)屬性 28 29 #新式類繼承順序:F->D->B->E->C->A 30 #經(jīng)典類繼承順序:F->D->B->A->E->C 31 #python3中統(tǒng)一都是新式類 32 #pyhon2中才分新式類與經(jīng)典類?
2 繼承原理（python如何實(shí)現(xiàn)的繼承）
python到底是如何實(shí)現(xiàn)繼承的，對(duì)于你定義的每一個(gè)類，python會(huì)計(jì)算出一個(gè)方法解析順序(MRO)列表，這個(gè)MRO列表就是一個(gè)簡單的所有基類的線性順序列表，例如
1 >>> F.mro() #等同于F.__mro__ 2 [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]為了實(shí)現(xiàn)繼承,python會(huì)在MRO列表上從左到右開始查找基類,直到找到第一個(gè)匹配這個(gè)屬性的類為止。
而這個(gè)MRO列表的構(gòu)造是通過一個(gè)C3線性化算法來實(shí)現(xiàn)的。我們不去深究這個(gè)算法的數(shù)學(xué)原理,它實(shí)際上就是合并所有父類的MRO列表并遵循如下三條準(zhǔn)則:
1.子類會(huì)先于父類被檢查
2.多個(gè)父類會(huì)根據(jù)它們?cè)诹斜碇械捻樞虮粰z查
3.如果對(duì)下一個(gè)類存在兩個(gè)合法的選擇,選擇第一個(gè)父類
?
九、子類中調(diào)用父類的方法
方法一：指名道姓，即父類名.父類方法()
1 #_*_coding:utf-8_*_ 2 __author__ = 'Linhaifeng' 3 4 class Vehicle: #定義交通工具類 5 Country='China' 6 def __init__(self,name,speed,load,power): 7 self.name=name 8 self.speed=speed 9 self.load=load 10 self.power=power 11 12 def run(self): 13 print('開動(dòng)啦...') 14 15 class Subway(Vehicle): #地鐵 16 def __init__(self,name,speed,load,power,line): 17 Vehicle.__init__(self,name,speed,load,power) 18 self.line=line 19 20 def run(self): 21 print('地鐵%s號(hào)線歡迎您' %self.line) 22 Vehicle.run(self) 23 24 line13=Subway('中國地鐵','180m/s','1000人/箱','電',13) 25 line13.run()方法二：super()
1 class Vehicle: #定義交通工具類 2 Country='China' 3 def __init__(self,name,speed,load,power): 4 self.name=name 5 self.speed=speed 6 self.load=load 7 self.power=power 8 9 def run(self): 10 print('開動(dòng)啦...') 11 12 class Subway(Vehicle): #地鐵 13 def __init__(self,name,speed,load,power,line): 14 #super(Subway,self) 就相當(dāng)于實(shí)例本身 在python3中super()等同于super(Subway,self) 15 super().__init__(name,speed,load,power) 16 self.line=line 17 18 def run(self): 19 print('地鐵%s號(hào)線歡迎您' %self.line) 20 super(Subway,self).run() 21 22 class Mobike(Vehicle):#摩拜單車 23 pass 24 25 line13=Subway('中國地鐵','180m/s','1000人/箱','電',13) 26 line13.run()了解部分：
即使沒有直接繼承關(guān)系，super仍然會(huì)按照mro繼續(xù)往后查找
1 #A沒有繼承B,但是A內(nèi)super會(huì)基于C.mro()繼續(xù)往后找 2 class A: 3 def test(self): 4 super().test() 5 class B: 6 def test(self): 7 print('from B') 8 class C(A,B): 9 pass 10 11 c=C() 12 c.test() #打印結(jié)果:from B 13 14 15 print(C.mro()) 16 #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]指名道姓與super()的區(qū)別
1 #指名道姓 2 class A: 3 def __init__(self): 4 print('A的構(gòu)造方法') 5 class B(A): 6 def __init__(self): 7 print('B的構(gòu)造方法') 8 A.__init__(self) 9 10 11 class C(A): 12 def __init__(self): 13 print('C的構(gòu)造方法') 14 A.__init__(self) 15 16 17 class D(B,C): 18 def __init__(self): 19 print('D的構(gòu)造方法') 20 B.__init__(self) 21 C.__init__(self) 22 23 pass 24 f1=D() #A.__init__被重復(fù)調(diào)用 25 ''' 26 D的構(gòu)造方法 27 B的構(gòu)造方法 28 A的構(gòu)造方法 29 C的構(gòu)造方法 30 A的構(gòu)造方法 31 ''' 32 33 34 #使用super() 35 class A: 36 def __init__(self): 37 print('A的構(gòu)造方法') 38 class B(A): 39 def __init__(self): 40 print('B的構(gòu)造方法') 41 super(B,self).__init__() 42 43 44 class C(A): 45 def __init__(self): 46 print('C的構(gòu)造方法') 47 super(C,self).__init__() 48 49 50 class D(B,C): 51 def __init__(self): 52 print('D的構(gòu)造方法') 53 super(D,self).__init__() 54 55 f1=D() #super()會(huì)基于mro列表,往后找 56 ''' 57 D的構(gòu)造方法 58 B的構(gòu)造方法 59 C的構(gòu)造方法 60 A的構(gòu)造方法 61 '''當(dāng)你使用super()函數(shù)時(shí),Python會(huì)在MRO列表上繼續(xù)搜索下一個(gè)類。只要每個(gè)重定義的方法統(tǒng)一使用super()并只調(diào)用它一次,那么控制流最終會(huì)遍歷完整個(gè)MRO列表,每個(gè)方法也只會(huì)被調(diào)用一次（注意注意注意：使用super調(diào)用的所有屬性，都是從MRO列表當(dāng)前的位置往后找，千萬不要通過看代碼去找繼承關(guān)系，一定要看MRO列表）
?
?
二 多態(tài)與多態(tài)性
一、多態(tài)
多態(tài)指的是一類事物有多種形態(tài)
動(dòng)物有多種形態(tài)：人，狗，豬
1 import abc 2 class Animal(metaclass=abc.ABCMeta): #同一類事物:動(dòng)物 3 @abc.abstractmethod 4 def talk(self): 5 pass 6 7 class People(Animal): #動(dòng)物的形態(tài)之一:人 8 def talk(self): 9 print('say hello') 10 11 class Dog(Animal): #動(dòng)物的形態(tài)之二:狗 12 def talk(self): 13 print('say wangwang') 14 15 class Pig(Animal): #動(dòng)物的形態(tài)之三:豬 16 def talk(self): 17 print('say aoao')文件有多種形態(tài)：文本文件，可執(zhí)行文件
1 import abc 2 class File(metaclass=abc.ABCMeta): #同一類事物:文件 3 @abc.abstractmethod 4 def click(self): 5 pass 6 7 class Text(File): #文件的形態(tài)之一:文本文件 8 def click(self): 9 print('open file') 10 11 class ExeFile(File): #文件的形態(tài)之二:可執(zhí)行文件 12 def click(self): 13 print('execute file')?
二、多態(tài)性
一 什么是多態(tài)動(dòng)態(tài)綁定（在繼承的背景下使用時(shí)，有時(shí)也稱為多態(tài)性
態(tài)性是指在不考慮實(shí)例類型的情況下使用實(shí)例
?
多態(tài)性分為靜態(tài)多態(tài)性和動(dòng)態(tài)多態(tài)性
靜態(tài)多態(tài)性：如任何類型都可以用運(yùn)算符+進(jìn)行運(yùn)算
動(dòng)態(tài)多態(tài)性：如下
1 peo=People() 2 dog=Dog() 3 pig=Pig() 4 5 #peo、dog、pig都是動(dòng)物,只要是動(dòng)物肯定有talk方法 6 #于是我們可以不用考慮它們?nèi)叩木唧w是什么類型,而直接使用 7 peo.talk() 8 dog.talk() 9 pig.talk() 10 11 #更進(jìn)一步,我們可以定義一個(gè)統(tǒng)一的接口來使用 12 def func(obj): 13 obj.talk()二 為什么要用多態(tài)性（多態(tài)性的好處）
其實(shí)大家從上面多態(tài)性的例子可以看出，我們并沒有增加什么新的知識(shí)，也就是說python本身就是支持多態(tài)性的，這么做的好處是什么呢？
1.增加了程序的靈活性
以不變應(yīng)萬變，不論對(duì)象千變?nèi)f化，使用者都是同一種形式去調(diào)用，如func(animal)
2.增加了程序額可擴(kuò)展性
通過繼承animal類創(chuàng)建了一個(gè)新的類，使用者無需更改自己的代碼，還是用func(animal)去調(diào)用?
1 >>> class Cat(Animal): #屬于動(dòng)物的另外一種形態(tài)：貓 2 ... def talk(self): 3 ... print('say miao') 4 ... 5 >>> def func(animal): #對(duì)于使用者來說，自己的代碼根本無需改動(dòng) 6 ... animal.talk() 7 ... 8 >>> cat1=Cat() #實(shí)例出一只貓 9 >>> func(cat1) #甚至連調(diào)用方式也無需改變，就能調(diào)用貓的talk功能 10 say miao 11 12 ''' 13 這樣我們新增了一個(gè)形態(tài)Cat，由Cat類產(chǎn)生的實(shí)例cat1，使用者可以在完全不需要修改自己代碼的情況下。使用和人、狗、豬一樣的方式調(diào)用cat1的talk方法，即func(cat1) 14 '''三 ?鴨子類型
python程序員通常根據(jù)這種行為來編寫程序。例如，如果想編寫現(xiàn)有對(duì)象的自定義版本，可以繼承該對(duì)象
也可以創(chuàng)建一個(gè)外觀和行為像，但與它無任何關(guān)系的全新對(duì)象，后者通常用于保存程序組件的松耦合度。
例1：利用標(biāo)準(zhǔn)庫中定義的各種‘與文件類似’的對(duì)象，盡管這些對(duì)象的工作方式像文件，但他們沒有繼承內(nèi)置文件對(duì)象的方法
1 #二者都像鴨子,二者看起來都像文件,因而就可以當(dāng)文件一樣去用 2 class TxtFile: 3 def read(self): 4 pass 5 6 def write(self): 7 pass 8 9 class DiskFile: 10 def read(self): 11 pass 12 def write(self): 13 pass例2：其實(shí)大家一直在享受著多態(tài)性帶來的好處，比如Python的序列類型有多種形態(tài)：字符串，列表，元組，多態(tài)性體現(xiàn)如下
1 #str,list,tuple都是序列類型 2 s=str('hello') 3 l=list([1,2,3]) 4 t=tuple((4,5,6)) 5 6 #我們可以在不考慮三者類型的前提下使用s,l,t 7 s.__len__() 8 l.__len__() 9 t.__len__() 10 11 len(s) 12 len(l) 13 len(t)?
三 封裝
一、封裝定義
1. 引子
從封裝本身的意思去理解，封裝就好像是拿來一個(gè)麻袋，把小貓，小狗，小王八，還有alex一起裝進(jìn)麻袋，然后把麻袋封上口子。照這種邏輯看，封裝=‘隱藏’，這種理解是相當(dāng)片面的
2. 先看如何隱藏
在python中用雙下劃線開頭的方式將屬性隱藏起來（設(shè)置成私有的）
1 #其實(shí)這僅僅這是一種變形操作且僅僅只在類定義階段發(fā)生變形 2 #類中所有雙下劃線開頭的名稱如__x都會(huì)在類定義時(shí)自動(dòng)變形成：_類名__x的形式： 3 4 class A: 5 __N=0 #類的數(shù)據(jù)屬性就應(yīng)該是共享的,但是語法上是可以把類的數(shù)據(jù)屬性設(shè)置成私有的如__N,會(huì)變形為_A__N 6 def __init__(self): 7 self.__X=10 #變形為self._A__X 8 def __foo(self): #變形為_A__foo 9 print('from A') 10 def bar(self): 11 self.__foo() #只有在類內(nèi)部才可以通過__foo的形式訪問到. 12 13 #A._A__N是可以訪問到的， 14 #這種，在外部是無法通過__x這個(gè)名字訪問到。這種變形需要注意的問題是：
1.這種機(jī)制也并沒有真正意義上限制我們從外部直接訪問屬性，知道了類名和屬性名就可以拼出名字：_類名__屬性，然后就可以訪問了，如a._A__N，即這種操作并不是嚴(yán)格意義上的限制外部訪問，僅僅只是一種語法意義上的變形，主要用來限制外部的直接訪問。
2.變形的過程只在類的定義時(shí)發(fā)生一次,在定義后的賦值操作，不會(huì)變形
3.在繼承中，父類如果不想讓子類覆蓋自己的方法，可以將方法定義為私有的
1 #正常情況 2 >>> class A: 3 ... def fa(self): 4 ... print('from A') 5 ... def test(self): 6 ... self.fa() 7 ... 8 >>> class B(A): 9 ... def fa(self): 10 ... print('from B') 11 ... 12 >>> b=B() 13 >>> b.test() 14 from B 15 16 17 #把fa定義成私有的，即__fa 18 >>> class A: 19 ... def __fa(self): #在定義時(shí)就變形為_A__fa 20 ... print('from A') 21 ... def test(self): 22 ... self.__fa() #只會(huì)與自己所在的類為準(zhǔn),即調(diào)用_A__fa 23 ... 24 >>> class B(A): 25 ... def __fa(self): 26 ... print('from B') 27 ... 28 >>> b=B() 29 >>> b.test() 30 from A3.?封裝不是單純意義的隱藏
1）封裝數(shù)據(jù)：將數(shù)據(jù)隱藏起來這不是目的。隱藏起來然后對(duì)外提供操作該數(shù)據(jù)的接口，然后我們可以在接口附加上對(duì)該數(shù)據(jù)操作的限制，以此完成對(duì)數(shù)據(jù)屬性操作的嚴(yán)格控制。
1 class Teacher: 2 def __init__(self,name,age): 3 # self.__name=name 4 # self.__age=age 5 self.set_info(name,age) 6 7 def tell_info(self): 8 print('姓名:%s,年齡:%s' %(self.__name,self.__age)) 9 def set_info(self,name,age): 10 if not isinstance(name,str): 11 raise TypeError('姓名必須是字符串類型') 12 if not isinstance(age,int): 13 raise TypeError('年齡必須是整型') 14 self.__name=name 15 self.__age=age 16 17 18 t=Teacher('lucy',18) 19 t.tell_info() 20 21 t.set_info('lucy',19) 22 t.tell_info()2) 封裝方法：目的是隔離復(fù)雜度
封裝方法舉例：?
1. 你的身體沒有一處不體現(xiàn)著封裝的概念：你的身體把膀胱尿道等等這些尿的功能隱藏了起來，然后為你提供一個(gè)尿的接口就可以了（接口就是你的。。。，），你總不能把膀胱掛在身體外面，上廁所的時(shí)候就跟別人炫耀：hi，man，你瞅我的膀胱，看看我是怎么尿的。
2. 電視機(jī)本身是一個(gè)黑盒子，隱藏了所有細(xì)節(jié)，但是一定會(huì)對(duì)外提供了一堆按鈕，這些按鈕也正是接口的概念，所以說，封裝并不是單純意義的隱藏！！！
3.?快門就是傻瓜相機(jī)為傻瓜們提供的方法，該方法將內(nèi)部復(fù)雜的照相功能都隱藏起來了
提示：在編程語言里，對(duì)外提供的接口（接口可理解為了一個(gè)入口），可以是函數(shù)，稱為接口函數(shù)，這與接口的概念還不一樣，接口代表一組接口函數(shù)的集合體。
1 #取款是功能,而這個(gè)功能有很多功能組成:插卡、密碼認(rèn)證、輸入金額、打印賬單、取錢 2 #對(duì)使用者來說,只需要知道取款這個(gè)功能即可,其余功能我們都可以隱藏起來,很明顯這么做 3 #隔離了復(fù)雜度,同時(shí)也提升了安全性 4 5 class ATM: 6 def __card(self): 7 print('插卡') 8 def __auth(self): 9 print('用戶認(rèn)證') 10 def __input(self): 11 print('輸入取款金額') 12 def __print_bill(self): 13 print('打印賬單') 14 def __take_money(self): 15 print('取款') 16 17 def withdraw(self): 18 self.__card() 19 self.__auth() 20 self.__input() 21 self.__print_bill() 22 self.__take_money() 23 24 a=ATM() 25 a.withdraw() 隔離復(fù)雜度的例子3) 了解
python并不會(huì)真的阻止你訪問私有的屬性，模塊也遵循這種約定，如果模塊名以單下劃線開頭，那么from module import *時(shí)不能被導(dǎo)入,但是你from module import _private_module依然是可以導(dǎo)入的
其實(shí)很多時(shí)候你去調(diào)用一個(gè)模塊的功能時(shí)會(huì)遇到單下劃線開頭的(socket._socket,sys._home,sys._clear_type_cache),這些都是私有的，原則上是供內(nèi)部調(diào)用的，作為外部的你，一意孤行也是可以用的，只不過顯得稍微傻逼一點(diǎn)點(diǎn)
python要想與其他編程語言一樣，嚴(yán)格控制屬性的訪問權(quán)限，只能借助內(nèi)置方法如__getattr__
?
二、 特性(property)?
什么是特性property
property是一種特殊的屬性，訪問它時(shí)會(huì)執(zhí)行一段功能（函數(shù)）然后返回值
例一：BMI指數(shù)（bmi是計(jì)算而來的，但很明顯它聽起來像是一個(gè)屬性而非方法，如果我們將其做成一個(gè)屬性，更便于理解）
成人的BMI數(shù)值： 過輕：低于18.5 正常：18.5-23.9 過重：24-27 肥胖：28-32 非常肥胖, 高于32 體質(zhì)指數(shù)（BMI）=體重（kg）÷身高^2（m） EX：70kg÷（1.75×1.75）=22.86 1 class People: 2 def __init__(self,name,weight,height): 3 self.name=name 4 self.weight=weight 5 self.height=height 6 @property 7 def bmi(self): 8 return self.weight / (self.height**2) 9 10 p1=People('lucy',45,1.65) 11 print(p1.bmi)為什么要用property
將一個(gè)類的函數(shù)定義成特性以后，對(duì)象再去使用的時(shí)候obj.name,根本無法察覺自己的name是執(zhí)行了一個(gè)函數(shù)然后計(jì)算出來的，這種特性的使用方式遵循了統(tǒng)一訪問的原則
除此之外，看下
1 ps：面向?qū)ο蟮姆庋b有三種方式: 2 【public】 3 這種其實(shí)就是不封裝,是對(duì)外公開的 4 【protected】 5 這種封裝方式對(duì)外不公開,但對(duì)朋友(friend)或者子類(形象的說法是“兒子”,但我不知道為什么大家 不說“女兒”,就像“parent”本來是“父母”的意思,但中文都是叫“父類”)公開 6 【private】 7 這種封裝對(duì)誰都不公開python并沒有在語法上把它們?nèi)齻€(gè)內(nèi)建到自己的class機(jī)制中，在C++里一般會(huì)將所有的所有的數(shù)據(jù)都設(shè)置為私有的，然后提供set和get方法（接口）去設(shè)置和獲取，在python中通過property方法可以實(shí)現(xiàn)
1 class Foo: 2 def __init__(self,val): 3 self.__NAME=val #將所有的數(shù)據(jù)屬性都隱藏起來 4 5 @property 6 def name(self): 7 return self.__NAME #obj.name訪問的是self.__NAME(這也是真實(shí)值的存放位置) 8 9 @name.setter 10 def name(self,value): 11 if not isinstance(value,str): #在設(shè)定值之前進(jìn)行類型檢查 12 raise TypeError('%s must be str' %value) 13 self.__NAME=value #通過類型檢查后,將值value存放到真實(shí)的位置self.__NAME 14 15 @name.deleter 16 def name(self): 17 raise TypeError('Can not delete') 18 19 f=Foo('egon') 20 print(f.name) 21 # f.name=10 #拋出異常'TypeError: 10 must be str' 22 del f.name #拋出異常'TypeError: Can not delete' 1 class Foo: 2 def __init__(self,val): 3 self.__NAME=val #將所有的數(shù)據(jù)屬性都隱藏起來 4 5 def getname(self): 6 return self.__NAME #obj.name訪問的是self.__NAME(這也是真實(shí)值的存放位置) 7 8 def setname(self,value): 9 if not isinstance(value,str): #在設(shè)定值之前進(jìn)行類型檢查 10 raise TypeError('%s must be str' %value) 11 self.__NAME=value #通過類型檢查后,將值value存放到真實(shí)的位置self.__NAME 12 13 def delname(self): 14 raise TypeError('Can not delete') 15 16 name=property(getname,setname,delname) #不如裝飾器的方式清晰?
三、封裝與擴(kuò)展性
封裝在于明確區(qū)分內(nèi)外，使得類實(shí)現(xiàn)者可以修改封裝內(nèi)的東西而不影響外部調(diào)用者的代碼；而外部使用用者只知道一個(gè)接口(函數(shù))，只要接口（函數(shù)）名、參數(shù)不變，使用者的代碼永遠(yuǎn)無需改變。這就提供一個(gè)良好的合作基礎(chǔ)——或者說，只要接口這個(gè)基礎(chǔ)約定不變，則代碼改變不足為慮。
1 #類的設(shè)計(jì)者 2 class Room: 3 def __init__(self,name,owner,width,length,high): 4 self.name=name 5 self.owner=owner 6 self.__width=width 7 self.__length=length 8 self.__high=high 9 def tell_area(self): #對(duì)外提供的接口，隱藏了內(nèi)部的實(shí)現(xiàn)細(xì)節(jié)，此時(shí)我們想求的是面積 10 return self.__width * self.__length 11 12 13 #使用者 14 >>> r1=Room('臥室','egon',20,20,20) 15 >>> r1.tell_area() #使用者調(diào)用接口tell_area 16 17 18 #類的設(shè)計(jì)者，輕松的擴(kuò)展了功能，而類的使用者完全不需要改變自己的代碼 19 class Room: 20 def __init__(self,name,owner,width,length,high): 21 self.name=name 22 self.owner=owner 23 self.__width=width 24 self.__length=length 25 self.__high=high 26 def tell_area(self): #對(duì)外提供的接口，隱藏內(nèi)部實(shí)現(xiàn)，此時(shí)我們想求的是體積,內(nèi)部邏輯變了,只需求修該下列一行就可以很簡答的實(shí)現(xiàn),而且外部調(diào)用感知不到,仍然使用該方法，但是功能已經(jīng)變了 27 return self.__width * self.__length * self.__high 28 29 30 #對(duì)于仍然在使用tell_area接口的人來說，根本無需改動(dòng)自己的代碼，就可以用上新功能 31 >>> r1.tell_area()?
轉(zhuǎn)載于:https://www.cnblogs.com/eric_yi/p/8451338.html
總結(jié)
以上是生活随笔為你收集整理的二 面向对象三大特性的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Eclipse Add generate
- 下一篇： sql 中 limit 与 limit，