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

海星？海欣！

已于 2022-11-16 10:52:22 修改

阅读量344

点赞数

分类专栏：人工智能文章标签： python

于 2022-10-30 16:21:01 首次发布

本文链接：https://blog.csdn.net/Sun123234/article/details/127575786

版权

人工智能专栏收录该内容

27 篇文章 3 订阅

订阅专栏

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初始化位置，需要再次调用init
        Master.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初始化位置，需要再次调用init
        Master.make_cake(self)  # 加上self对象

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

class Tusun():
	pass

xiaoqiu = 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初始化位置，需要再次调用init
        Master.make_cake(self)  # 加上self对象

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

	#需求：一次性调用父类School和Master
	def 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初始化位置，需要再次调用init
        Master.make_cake(self)  # 加上self对象

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    #需求：一次性调用父类School和Master
    def 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.2super
        super().__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初始化位置，需要再次调用init
        Master.make_cake(self)  # 加上self对象

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    #需求：一次性调用父类School和Master
    def 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.2super
        super().__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):
	pass

xiaoqiu = 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 = 500


class Tusun(Prentice):
	pass

xiaoqiu = Tusun()
#print(xiaoqiu.__money) #报错
#xiaoqiu.__info_print() #报错
print(xiaoqiu.get_money())  #输出：2000000
xiaoqiu.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 = 10
    
wangcai = Dog()
xiaohei = Dog()

print(Dog.tooth)   #10
print(wangcai.tooth) #10
print(xiaohei.tooth) #10

如果想记录某项数据始终保持一致时，则定义类属性
实例属性：要求每个对象为其单独开辟一个内存空间来记录数据，而类属性为全类共享，仅占一份内存，节省空间

修改类属性

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

通过类修改：

class Dog(object):
    tooth = 10

wangcai = Dog()
xiaohei = Dog()
Dog.tooth = 20

print(Dog.tooth) #20
print(wangcai.tooth)  #20
print(xiaohei.tooth) #20

通过对象修改：

class Dog(object):
    tooth = 10

wangcai = Dog()
xiaohei = Dog()
wangcai.tooth = 20

print(Dog.tooth)  #10
print(wangcai.tooth)  #20
print(xiaohei.tooth)  #10

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

十一、类方法和静态方法

类方法

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

class Dog(object):
    __tooth = 10
    #定义类方法
    @classmethod
    def get_tooth(cls):
        return cls.__tooth

wangcai = Dog()
print(wangcai.get_tooth()) #10

静态方法

静态方法特点：装饰器@staticmethod
静态方法中不需要参数传递，有利于减少不必要的内存占用和性能消耗

class Dog(object):
    __tooth = 10
    #定义静态方法
    @staticmethod
    def info_print():
        print('这是一个静态方法')

wangcai = Dog()
wangcai.info_print()  #这是一个静态方法
Dog.info_print()  #这是一个静态方法
#即可以对象调用，也可以类调用