Python基础day09【面向对象(封装、继承、多态)、重写、私有权限】
生活随笔
收集整理的這篇文章主要介紹了
Python基础day09【面向对象(封装、继承、多态)、重写、私有权限】
小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.
- 視頻、源碼、課件、軟件、筆記：超全面Python基礎(chǔ)入門教程【十天課程】博客筆記匯總表【黑馬程序員】
-
Python基礎(chǔ)day09【面向?qū)ο?封裝、繼承、多態(tài))、重寫、私有權(quán)限】
-
Python基礎(chǔ)day09【試題講解《python基礎(chǔ)中期考試》】
-
Python基礎(chǔ)day09 作業(yè)解析【面向?qū)ο箢}目(簡答題+代碼題)】
?
目錄
00、復習和反饋
01、繼承的基本語法[掌握]
02、單繼承和多層繼承[理解]
03、子類重寫父類的同名方法[掌握]
04、子類調(diào)用父類的同名方法[掌握]
05、繼承中的init[掌握]
06、多繼承[理解]
6.1、多繼承簡單案例
6.2、多繼承調(diào)用指定父類中的方法
07、私有權(quán)限[理解]
7.1、私有屬性
7.2、私有方法
08、類屬性[理解]
09、類方法
10、靜態(tài)方法[掌握]
11、多態(tài)[理解]
12、鴨子類型中的多態(tài)
13、總結(jié)
14、試題講解《python基礎(chǔ)中期考試》
?
00、復習和反饋
課程考試：基礎(chǔ)概念題+基礎(chǔ)編程題
01、繼承的基本語法[掌握]
程序中的繼承
繼承：描述的類與類之間所屬關(guān)系。
基本語法：
? ? class 類B(類A):
? ? ? ?pass
稱為類B繼承類A
特點：B類的對象可以使用A類的屬性和方法。
優(yōu)點：代碼復用，重復相同的代碼不用多次書寫。
名詞：
????類A：父類、基類
????類B：子類、派生類
02、單繼承和多層繼承[理解]
""" 單繼承：如果一個類只有一個父類, 把這種繼承關(guān)系稱為單繼承; 多繼承：如果一個類有多個父類, 把這種繼承關(guān)系稱為多繼承. 多層繼承：C-->B-->A """# 1. 定義一個動物類：animal類 class Animal(object): # 對于Animal類和object類來說,單繼承# 2. 在animal類書寫play方法,輸出‘快樂地玩耍...’def play(self):print('快樂地玩耍...')# 3. 定義Dog類繼承animal類 class Dog(Animal): # Dog-->Animal是單繼承, Dog -->Animal-->object這種繼承關(guān)系稱為多層繼承def bark(self):print('汪汪汪叫...')# 定義類：XTQ類（哮天犬）, 繼承Dog類 # 多層繼承中,子類可以使用所有繼承鏈中的類中的方法和屬性 class XTQ(Dog): # XTQ-->Dog：單繼承；XTQ-->Dog-->Animal類：多層繼承passxtq = XTQ() xtq.bark() # 調(diào)用父類Dog中的方法 汪汪汪叫... xtq.play() # 調(diào)用爺爺類animal類中的方法 快樂地玩耍...03、子類重寫父類的同名方法[掌握]
重寫：子類定義和父類名字相同的方法。
為什么重寫：父類中的方法，不能滿足子類對象的需求，所以要重寫。
重寫之后的特點：子類對象調(diào)用子類自己的方法，不再調(diào)用的方法，父類對象調(diào)用父類自己的方法。
04、子類調(diào)用父類的同名方法[掌握]
?
# 1. 定義Dog類, 書寫bark方法, 輸出 汪汪汪叫 class Dog(object):def bark(self):print('汪汪叫...')# 2. 定義XTQ類,繼承Dog類. 重寫父類中的bark方法, 輸出 嗷嗷嗷叫 class XTQ(Dog):def bark(self):print('嗷嗷叫~~~')def see_host(self):"""看見主人之后,要汪汪汪叫,不能嗷嗷叫"""print('看見主人了,', end='')self.bark() # 嗷嗷叫~~~# 想要在子類中調(diào)用父類的同名方法# 方法一: 父類名.方法名(self, 其他參數(shù)), 通過‘實例對象.方法名()’調(diào)用方法,不需要給self傳遞實參值,# python解釋器會自動將對象作為實參值傳遞給self形參,如果是通過類名.方法()調(diào)用,# python解釋器就不會自動傳遞實參值,需要手動給self形參傳遞實參值Dog.bark(self) # 汪汪叫... 非常不推薦的方法：父類名(實參).方法名()，創(chuàng)建父類對象# 方法二：super(類A, self).方法名(參數(shù)), 會調(diào)用當類A的父類中的方法super(XTQ, self).bark() # 汪汪叫...，調(diào)用XTQ類父類中的bark方法# 方法三：是方法二的簡寫, super().方法名(參數(shù)) ==> super(當前類, self).方法名()super().bark() # 汪汪叫...# 創(chuàng)建XTQ類對象 xtq = XTQ() xtq.see_host()05、繼承中的init[掌握]
如果子類重寫了父類的init方法，在子類中需要調(diào)用父類的init方法，給對象添加從父類繼承的屬性。
注意：子類init方法的形參，一般都先寫父類的形參，再寫子類自己獨有的形參。
說明：雖然子類沒有定義__init__方法初始化屬性，也沒有定義實例方法，但是父類有。所以只要創(chuàng)建子類的對象，就默認執(zhí)行了那個繼承過來的__init__方法。
總結(jié)：1.子類在繼承的時候，在定義類時，小括號()中為父類的名字；2.父類的屬性、方法，會被繼承給子類。
# 1.定義Dog類 class Dog(object):def __init__(self, name):# 添加屬性self.age = 0self.name = namedef __str__(self):return f'名字：{self.name}, 年齡：{self.age}。'# 2.定義XTQ類繼承Dog類 class XTQ(Dog):# 子類重寫了父類的__init__()方法,默認不再調(diào)用父類的__init__()方法, 需要手動地調(diào)用父類的__init__()方法# 注意：子類init方法的形參，一般都先寫父類的形參，再寫子類自己獨有的形參。def __init__(self, name, color):super().__init__(name)self.color = colordef __str__(self):return f'名字：{self.name}；年齡：{self.age}；毛色：{self.color}。'# 3.創(chuàng)建XTQ類對象 xtq = XTQ('小黑', '紅色') print(xtq) # 名字：小黑；年齡：0；毛色：紅色。06、多繼承[理解]
如果一個類有兩個及以上的父類，就把這種繼承關(guān)系稱為多繼承。
說明：
6.1、多繼承簡單案例
# 1.定義Dog類,定義bark方法和eat方法 class Dog(object):def bark(self):print('汪汪叫...')def eat(self):print('啃骨頭...')# 2.定義God類,定義play方法和eat方法 class God(object):def play(self):print('在云中飄一會...')def eat(self):print('吃蟠桃仙丹...')# 3.定義XTQ類,繼承Dog類和God類 # class XTQ(Dog, God): # XTQ類有兩個父類,這種繼承關(guān)系稱為多繼承,XTQ類對象可以調(diào)用兩個父類中的屬性和方法 class XTQ(God, Dog):pass# 4.創(chuàng)建XTQ類對象 xtq = XTQ() xtq.bark() # 調(diào)用Dog父類中的方法，汪汪叫... xtq.play() # 調(diào)用God父類中的方法，在云中飄一會...xtq.eat() # 兩個父類都存在eat方法,子類對象調(diào)用的是第一個父類中的方法，吃蟠桃仙丹...6.2、多繼承調(diào)用指定父類中的方法
# 1.定義Dog類,定義bark方法和eat方法 class Dog(object):def bark(self):print('汪汪叫...')def eat(self):print('啃骨頭...')# 2.定義God類,定義play方法和eat方法 class God(object):def play(self):print('在云中飄一會...')def eat(self):print('吃蟠桃仙丹...')# 3.定義XTQ類,繼承Dog類和God類 # class XTQ(Dog, God): # XTQ類有兩個父類,這個繼承關(guān)系稱為多繼承,XTQ類對象可以調(diào)用兩個父類中的屬性和方法 class XTQ(God, Dog): # XTQ類有兩個父類,這個繼承關(guān)系稱為多繼承,XTQ類對象可以調(diào)用兩個父類中的屬性和方法def eat(self):print('子類重寫eat方法,調(diào)用子類自己的方法。')# 調(diào)用指定父類中的方法# 方法一：類名.方法名(self, 參數(shù))Dog.eat(self) # 啃骨頭...God.eat(self) # 吃蟠桃仙丹...# 方法二：super(類A, self).方法名(參數(shù))：調(diào)用類A的父類(繼承順序鏈的下一個類)中的方法super(XTQ, self).eat() # 調(diào)用God類中的方法，吃蟠桃仙丹...super(God, self).eat() # 調(diào)用Dog類中的方法，啃骨頭...# super(Dog, self).eat() # 調(diào)用object類中的方法,注意: 但object類中沒有eat方法,所以代碼報錯print('子類重寫eat方法,調(diào)用子類自己的方法。')# 4.創(chuàng)建XTQ類對象 xtq = XTQ() xtq.bark() # 調(diào)用Dog父類中的方法，汪汪叫... xtq.play() # 調(diào)用God父類中的方法，在云中飄一會...xtq.eat() # 兩個父類都存在eat方法,子類對象調(diào)用的是第一個父類中的方法# 類名.__mro__：可以查看當前類的繼承順序鏈,也叫做方法的調(diào)用順序。不需要自己定義內(nèi)容，自動定義內(nèi)容。 print(XTQ.__mro__) # (<class '__main__.XTQ'>, <class '__main__.God'>, <class '__main__.Dog'>, <class 'object'>)07、私有權(quán)限[理解]
面向?qū)ο笕筇匦?#xff1a;封裝、繼承、多態(tài)。
封裝的意義：
私有權(quán)限：在屬性名和方法名前面，加上兩個下劃線__。
總結(jié)
訪問權(quán)限控制：在什么地方可以使用和操作。
私有權(quán)限：
?? ?定義：在方法和屬性前加上兩個下劃線，就變?yōu)樗接?#xff1b;
?? ?1.不能在類外部通過對象直接訪問和使用，只能在類內(nèi)部訪問和使用；
?? ?2.不能被子類繼承。
公有：不是私有的就是公有的。
7.1、私有屬性
""" 私有屬性：只需要在原屬性名前加上兩個下劃線即可。 目的：保證數(shù)據(jù)的相對安全。 想要訪問和使用私有屬性：定義一個公有的方法,通過這個方法使用。 """ # 案例需求: 定義People類,定義屬性ICBC_money,錢不能隨便被修改,必須是合法的終端才可以操作 class People(object):def __init__(self):# python中的私有本質(zhì)是修改屬性的名字,在創(chuàng)建對象的時候,會自動地修改屬性名# 在屬性名的前邊加上‘_類名前綴’self.__ICBC_money = 0 # 定義私有屬性# 定義公有的方法,提供接口,修改余額def get_money(self):return self.__ICBC_moneydef set_money(self, money):num = input('輸入金額：')self.__ICBC_money += int(num)# self.__ICBC_money += money# 創(chuàng)建People類對象 xw = People() # 小王 # print(xw.__ICBC_money) # 實例對象.__dict__：可以查看對象具有的屬性信息,類型是字典,字典的key是屬性名,字典的value是屬性值 print('賦值之前:', xw.__dict__) xw.__ICBC_money = 1000; # 不是修改私有屬性,是重新添加一個公有屬性 print('賦值之后:', xw.__dict__) print(xw.__ICBC_money)print('------------------------------------------------------')print(xw.get_money()) # 0 xw.set_money(1000) print(xw.get_money()) # 1000 xw.set_money(-500) print(xw.get_money()) # 5007.2、私有方法
""" 私有方法：在方法的前邊加上兩個__ ,就為私有方法。 私有方法：不能在類外部訪問。 作用：一般作為類內(nèi)部的方法使用,不讓在外部直接調(diào)用,保證業(yè)務(wù)邏輯不被破壞。 """ class Dog(object):def born(self):"""生小狗的方法,生一個小狗,休息30天"""print('生了一只小狗...')self.__sleep()def __sleep(self):print('休息30天~')dog = Dog() # dog.__sleep() # 報錯 dog.born()# 生了一只小狗... # 休息30天~08、類屬性[理解]
對象(實例對象)：通過class定義的類創(chuàng)建的，即通過類實例化來的，又稱為實例、實例對象。
實例對象定義的屬性稱為實例屬性，通過實例對象(self)定義的屬性都是實例屬性。
實例屬性：每個實例對象中都存在一份，并且值可能是不一樣的。
類(類對象)：通過class定義的，又稱為類對象，是python解釋器在創(chuàng)建類的時候自動創(chuàng)建的。
作用：1.通過類對象，去定義實例對象；2.類對象可以保存一些屬性信息，稱為類屬性。
類屬性的定義：在類內(nèi)部，方法外部定義的變量就是類屬性。
類屬性在內(nèi)存中只有一份。
如何確定一個屬性是該定義為實例屬性還是類屬性？
先假設(shè)這個屬性為實例屬性，查看這個屬性值對于不同的實例對象，屬性值是否都一樣，并且需要同時變化。
如果是，則可以定義為類屬性；如果不是，則可以定義為實例屬性。
09、類方法
""" 實例方法: 類中默認定義的方法就是實例方法,第一個參數(shù)為self,表示實例對象類方法: 使用@classmethod裝飾的方法,稱為類方法,第一個參數(shù)是cls,代表的是類對象自己 什么情況定義為實例方法,什么情況定義為類方法? 1.如果在方法中使用了實例屬性,那么該方法必須定義為實例方法; 2.前提:不需要使用實例屬性.需要使用類屬性,可以將這個方法定義為類方法. """ class Dog(object):class_name = '狗類'def __init__(self, name, age):self.name = nameself.age = agedef play(self): # 實例方法print(f"小狗{self.name}，在快樂地玩耍...")# def get_class_name(self): # 是實例方法,因為沒有使用實例屬性,所以可以定義為類方法# return Dog.class_name@classmethoddef get_class_name(cls): # cls是類方法的默認形參,在調(diào)用的時候,不需要手動傳遞,python解釋器會自動傳遞return cls.class_namedog = Dog('大黃', 2) dog.play() # 小狗大黃，在快樂地玩耍... print(dog.get_class_name()) # 對象.類方法()，狗類 print(Dog.get_class_name()) # 類名.類方法()，狗類10、靜態(tài)方法[掌握]
""" 實例方法：類中默認定義的方法,就是實例方法,第一個參數(shù)為self,表示實例對象 類方法：使用@classmethod裝飾的方法,稱為類方法,第一個參數(shù)是cls,代表的是類對象自己 靜態(tài)方法：使用@staticmethod裝飾的方法,稱為靜態(tài)方法,對參數(shù)沒有特殊要求,可以有,可以沒有 什么情況定義為實例方法,什么情況定義為類方法,什么情況下靜態(tài)方法? 1.如果在方法中使用了實例屬性,那么該方法必須定義為實例方法； 2.前提：不需要使用實例屬性.需要使用類屬性,可以將這個方法定義為類方法； 3.前提：不需要使用實例屬性,同時也不需要使用類屬性,此時可以將這個方法定義為靜態(tài)方法。 """ class Dog(object):class_name = '狗類'def __init__(self, name, age):self.name = nameself.age = agedef play(self): # 實例方法print(f"小狗{self.name}，在快樂地玩耍...")@staticmethod # 定義靜態(tài)方法。靜態(tài)方法如果有參數(shù)，就必須傳遞實參值def show_info():print('這是一個Dog類！')dog = Dog('大黃', 2) dog.play() # 對象.方法名()：小狗大黃，在快樂地玩耍... dog.show_info() # 調(diào)用方法1：對象.方法名()，這是一個Dog類！ Dog.show_info() # 調(diào)用方法2：類名.方法名()，這是一個Dog類！11、多態(tài)[理解]
什么是多態(tài)？在需要使用父類對象的地方，也可以使用子類對象，這種情況就叫多態(tài)。比如，在函數(shù)中，我需要調(diào)用某一個父類對象的方法，那么我們也可以在這個地方調(diào)用子類對象的方法。
如何在程序中使用多態(tài)？可以按照以下幾個步驟來寫代碼：1.子類繼承父類；2.子類重寫父類中的方法；3.通過對象調(diào)用這個方法。
多態(tài)的好處：給call_cure(doctor)函數(shù)傳遞哪個對象，在它里面就會調(diào)用哪個對象的cure()方法，也就是說在它里面既可以調(diào)用son對象的cure()方法，也能調(diào)用father對象的cure()方法，當然也可以在它里面調(diào)用Father類其它子類對象的cure()方法，這樣可以讓call_cure(doctor)函數(shù)變得更加靈活，額外增加了它的功能，提高了它的擴展性。
""" 在需要使用父類對象的地方,也可以傳入子類對象,得到不同的結(jié)果----多態(tài) 實現(xiàn)步驟: 1.子類繼承父類; 2.子類重寫父類中的同名方法; 3.定義一個共同的方法,參數(shù)為父類對象,在方法中調(diào)用子類和父類同名的方法. """ # 1.定義DOg類 class Dog(object):def __init__(self, name):self.name = namedef play(self):print(f'小狗{self.name}, 在玩耍...')# 2.定義哮天犬類,繼承Dog類 class XTQ(Dog):# 3.重寫play方法def play(self):print(f'{self.name}, 在天上追云彩...')# 4.定義一個共同的方法, def play_with_dog(obj_dog):obj_dog.play()# 創(chuàng)建Dog類對象 dog = Dog('大黃') play_with_dog(dog) # 小狗大黃, 在玩耍...# 創(chuàng)建一個XTQ類的對象 xtq = XTQ('小黑') play_with_dog(xtq) # 小黑, 在天上追云彩...12、鴨子類型中的多態(tài)
Python(解釋型語言、動態(tài)語言)中的多態(tài)可以沒有繼承：鴨子類型語言。
# 1.定義DOg類 class Dog(object):def __init__(self, name):self.name = namedef play(self):print(f'小狗{self.name}, 在玩耍...')# 2.定義哮天犬類,繼承Dog類 class XTQ(Dog):# 3.重寫play方法def play(self):print(f'{self.name}, 在天上追云彩...')class Cat(object):def __init__(self, name):self.name = namedef play(self):print(f'小貓{self.name}, 被擼中...')# 4.定義一個共同的方法 def play_with_dog(obj_dog):obj_dog.play()# 創(chuàng)建Dog類對象 dog = Dog('大黃') play_with_dog(dog) # 小狗大黃, 在玩耍...# 創(chuàng)建一個XTQ類的對象 xtq = XTQ('小黑') play_with_dog(xtq) # 小黑, 在天上追云彩...# 創(chuàng)建一個貓類的對象 cat = Cat('小花') play_with_dog(cat) # 小貓小花, 被擼中...13、總結(jié)
欲去“惰”字，以不晚起為第一義；欲去“驕”字，以不菲人為第一義；欲去“奢”字，以不浪費為第一義；欲去“病”字，以不頹廢為第一義。
14、試題講解《python基礎(chǔ)中期考試》
Python基礎(chǔ)day09【試題講解《python基礎(chǔ)中期考試》】
總結(jié)
以上是生活随笔為你收集整理的Python基础day09【面向对象(封装、继承、多态)、重写、私有权限】的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Python基础day08 作业解析【7
- 下一篇： Python之基础