python面向对象3-多层继承 super() 私有权限 多态 类属性实例属性 类方法和静态方法

python面向对象1–类、对象、属性、魔法方法

python面向对象2–综合案例：烤地瓜、搬家具、单继承、多继承

python面向对象3-多层继承、super()、私有权限、多态、类属性实例属性、类方法和静态方法

mro

print(对象名.mro) 输出其父类和继承关系

五、 子类调用父类的同名方法和属性

故事：daqiu学到了师傅的古法，学校的，还有自己独创的。这时有顾客想要吃到独创，也想吃到师傅的古法

class Master(object):def __init__(self):self.kongfu = '[古法煎饼果子配方]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')class School(object):def __init__(self):self.kongfu = '[学校煎饼果子配方]'def make_cake(self): # 两个父类的属性和方法一样print(f'运用{self.kongfu}制作煎饼果子')# 子类class Prentice(Master, School):def __init__(self):self.kongfu = '[独制煎饼果子配方]'def make_cake(self):self.__init__()#加自己的初始化原因：如果不加自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值print(f'运用{self.kongfu}制作煎饼果子')# 调用父类方法，为保证调用的是父类的属性，必须在调用方法def make_master_cake(self):Master.__init__(self) # 要初始化之后再调用# 再次调用初始化的原因：想要调用父类的同名方法和属性，属性在init初始化位置，需要再次调用initMaster.make_cake(self) # 加上self对象def make_school_cake(self):School.__init__(self)School.make_cake(self)daqiu = Prentice()daqiu.make_cake() #运用[独制煎饼果子配方]制作煎饼果子daqiu.make_master_cake() #运用[古法煎饼果子配方]制作煎饼果子daqiu.make_school_cake() #运用[学校煎饼果子配方]制作煎饼果子daqiu.make_cake() #运用[独制煎饼果子配方]制作煎饼果子

六、 多层继承

故事：N年后，daqiu老了，想把所有技术传给其徒弟xiaoqiu

是运行多层继承。

class Master(object):def __init__(self):self.kongfu = '[古法煎饼果子配方]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')class School(object):def __init__(self):self.kongfu = '[学校煎饼果子配方]'def make_cake(self): # 两个父类的属性和方法一样print(f'运用{self.kongfu}制作煎饼果子')# 子类class Prentice(Master, School):def __init__(self):self.kongfu = '[独制煎饼果子配方]'def make_cake(self):self.__init__()#加自己的初始化原因：如果不加自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值print(f'运用{self.kongfu}制作煎饼果子')# 调用父类方法，为保证调用的是父类的属性，必须在调用方法def make_master_cake(self):Master.__init__(self) # 要初始化之后再调用# 再次调用初始化的原因：想要调用父类的同名方法和属性，属性在init初始化位置，需要再次调用initMaster.make_cake(self) # 加上self对象def make_school_cake(self):School.__init__(self)School.make_cake(self)class Tusun():passxiaoqiu = Tusun()xiaoqiu.make_cake() #运用[独制煎饼果子配方]制作煎饼果子xiaoqiu.make_master_cake() #运用[古法煎饼果子配方]制作煎饼果子xiaoqiu.make_school_cake() #运用[学校煎饼果子配方]制作煎饼果子

七、super()调用父类方法

需求：一次性调用父类School和Master

两种方法：法一：原方法 法二：super()

方法一：父类名.函数名（self）

class Prentice(Master, School):def __init__(self):self.kongfu = '[独制煎饼果子配方]'def make_cake(self):self.__init__()#加自己的初始化原因：如果不加自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值print(f'运用{self.kongfu}制作煎饼果子')# 调用父类方法，为保证调用的是父类的属性，必须在调用方法def make_master_cake(self):Master.__init__(self) # 要初始化之后再调用# 再次调用初始化的原因：想要调用父类的同名方法和属性，属性在init初始化位置，需要再次调用initMaster.make_cake(self) # 加上self对象def make_school_cake(self):School.__init__(self)School.make_cake(self)#需求：一次性调用父类School和Masterdef make_old_cake(self):#方法一：如果定义的类名修改，这里也需要修改，麻烦，且代码庞大冗余School.__init__(self)School.make_cake(self)Master.__init__(self) Master.make_cake(self)

方法2：2.1 super(当前类名，self).函数（）

super()能找回到它的父类

这样Prentice中super找到 School，再School中super找到Master

Prentice----》School----》Master

class Master(object):def __init__(self):self.kongfu = '[古法煎饼果子配方]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')class School(Master):def __init__(self):self.kongfu = '[学校煎饼果子配方]'def make_cake(self): # 两个父类的属性和方法一样print(f'运用{self.kongfu}制作煎饼果子')# 2.1 super(当前类名，self).函数（）super(School, self).__init__()super(School, self).make_cake()class Prentice( School):def __init__(self):self.kongfu = '[独制煎饼果子配方]'def make_cake(self):self.__init__()#加自己的初始化原因：如果不加自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值print(f'运用{self.kongfu}制作煎饼果子')# 调用父类方法，为保证调用的是父类的属性，必须在调用方法def make_master_cake(self):Master.__init__(self) # 要初始化之后再调用# 再次调用初始化的原因：想要调用父类的同名方法和属性，属性在init初始化位置，需要再次调用initMaster.make_cake(self) # 加上self对象def make_school_cake(self):School.__init__(self)School.make_cake(self)#需求：一次性调用父类School和Masterdef make_old_cake(self):#方法二：super()#2.1 super(当前类名，self).函数（）super(Prentice,self).__init__()super(Prentice, self).make_cake()daqiu = Prentice()daqiu.make_old_cake()#输出：#运用[学校煎饼果子配方]制作煎饼果子#运用[古法煎饼果子配方]制作煎饼果子

方法2：2.2 无参数super

相比于2.1 ，省略了参数，其余没变。更简洁，super能自动查找父类，以防父类名称改变

class Master(object):def __init__(self):self.kongfu = '[古法煎饼果子配方]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')class School(Master):def __init__(self):self.kongfu = '[学校煎饼果子配方]'def make_cake(self): # 两个父类的属性和方法一样print(f'运用{self.kongfu}制作煎饼果子')# # 2.1 super(当前类名，self).函数（）# super(School, self).__init__()# super(School, self).make_cake()# 方法二：2.2supersuper().__init__()super().make_cake()class Prentice( School):def __init__(self):self.kongfu = '[独制煎饼果子配方]'def make_cake(self):self.__init__()#加自己的初始化原因：如果不加自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值print(f'运用{self.kongfu}制作煎饼果子')# 调用父类方法，为保证调用的是父类的属性，必须在调用方法def make_master_cake(self):Master.__init__(self) # 要初始化之后再调用# 再次调用初始化的原因：想要调用父类的同名方法和属性，属性在init初始化位置，需要再次调用initMaster.make_cake(self) # 加上self对象def make_school_cake(self):School.__init__(self)School.make_cake(self)#需求：一次性调用父类School和Masterdef make_old_cake(self):# #方法一：如果定义的类名修改，这里也需要修改，麻烦，且代码庞大冗余# School.__init__(self)# School.make_cake(self)# Master.__init__(self)# Master.make_cake(self)# #方法二：super()# #2.1 super(当前类名，self).函数（）# super(Prentice,self).__init__()# super(Prentice, self).make_cake()#方法二：2.2supersuper().__init__()super().make_cake()daqiu = Prentice()daqiu.make_old_cake()#输出：#运用[学校煎饼果子配方]制作煎饼果子#运用[古法煎饼果子配方]制作煎饼果子

八、私有权限

某些属性和方法，不想继承给子类，即对其添加私有权限

故事：daqiu把技术传承给徒弟的同时，不想把自己的钱继承给徒弟

设置私有权限的方法：在属性名和方法名前面加上__

class Prentice(Master, School):def __init__(self):self.kongfu = '[独制煎饼果子配方]'self.__money = 2000000 #设置私有属性#定义私有方法def __info_print(self):print('这是私有方法')class Tusun(Prentice):passxiaoqiu = Tusun()print(xiaoqiu.__money) #报错xiaoqiu.__info_print() #报错

获取和修改私有属性值

私有属性和私有方法只能在类的里面进行访问和修改

由于没有限定为私有类，所以在类里面可以相互传，

一般定义函数名get_xx来获取私有属性，定义set_xx用来修改私有属性值。

class Prentice(object):def __init__(self):self.kongfu = '[独制煎饼果子配方]'self.__money = 2000000 #设置私有属性#定义函数：获取私有属性值def get_money(self):return self.__money#定义函数：修改私有属性值def set_money(self):self.__money = 500class Tusun(Prentice):passxiaoqiu = Tusun()#print(xiaoqiu.__money) #报错#xiaoqiu.__info_print() #报错print(xiaoqiu.get_money()) #输出：2000000xiaoqiu.set_money()print(xiaoqiu.get_money()) #输出：500

九、多态

多态：传入不同的对象，产生不同的结果

定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果

步骤

定义父类：并提供公共方法定义子类：并重写父类方法传递子类对象给调用者，可以看到不同子类执行效果不同

案例

需求：警务人员和警犬一起工作，携带不同警犬执行不同功能

两个类：工作人员、警犬

两种警犬：追击敌人，追查毒品

#需求：警务人员和警犬一起工作，携带不同警犬执行不同功能#1，定义父类 提供公共方法 ：警犬和人class Dog(object):def work(self):pass#2，定义子类：并重写父类方法 ：两种警犬class ArmyDog(Dog):def work(self):print('追击敌人。。')class DrugDog(Dog):def work(self):print('追击毒品。。')class Person(object):def work_with_dog(self,dog):dog.work()# 3，传递子类对象给调用者，可以看到不同子类执行效果不同 ：ad = ArmyDog()dd = DrugDog()daqiu = Person()daqiu.work_with_dog(ad) #追击敌人。。daqiu.work_with_dog(dd) #追击毒品。。

十、类属性和实例属性

类属性

设置类属性

访问类属性

修改类属性

类属性是类对象所拥有的属性，它被该类的所有实例对象所共有

类属性可以使用类对象或实例对象访问

class Dog(object):tooth = 10wangcai = Dog()xiaohei = Dog()print(Dog.tooth) #10print(wangcai.tooth) #10print(xiaohei.tooth) #10

如果想记录某项数据始终保持一致时，则定义类属性

实例属性：要求每个对象为其单独开辟一个内存空间来记录数据，而类属性为全类共享，仅占一份内存，节省空间

修改类属性

修改类属性，只能对类对象修改，不能通过实例对象修改

通过类修改：

class Dog(object):tooth = 10wangcai = Dog()xiaohei = Dog()Dog.tooth = 20print(Dog.tooth) #20print(wangcai.tooth) #20print(xiaohei.tooth) #20

通过对象修改：

class Dog(object):tooth = 10wangcai = Dog()xiaohei = Dog()wangcai.tooth = 20print(Dog.tooth) #10print(wangcai.tooth) #20print(xiaohei.tooth) #10

通过对象修改：并不是修改了类属性，而是给对象创建了一个同名属性

十一、类方法和静态方法

类方法

装饰器@classmethod 标识其为类方法，第一个参数必须是类对象，cls作为第一个参数

class Dog(object):__tooth = 10#定义类方法@classmethoddef get_tooth(cls):return cls.__toothwangcai = Dog()print(wangcai.get_tooth()) #10

静态方法

静态方法特点：装饰器@staticmethod

静态方法中不需要参数传递，有利于减少不必要的内存占用和性能消耗

class Dog(object):__tooth = 10#定义静态方法@staticmethoddef info_print():print('这是一个静态方法')wangcai = Dog()wangcai.info_print() #这是一个静态方法Dog.info_print() #这是一个静态方法#即可以对象调用，也可以类调用