面向对象编程(继承)---Python版(案例详解)

本篇是面向对象编程第二章-----继承特性详解,欢迎阅读学习,一起进步


  • Python专栏请参考:人生苦短-我学python

文章目录

      • 一.继承介绍
      • 二.单继承:子类只继承一个父类
      • 三.多继承:子类继承多个父类
      • 四.子类重写父类的同名属性和方法
      • 五.子类调用父类同名属性和方法
      • 六.多层继承
      • 八.super()的使用


一.继承介绍

现实中的继承

面向对象编程(继承)---Python版(案例详解)_第1张图片

程序中的继承

  • 在程序中,继承描述的是多个类之间的所属关系。
  • 如果一个类A里面的属性和方法可以复用,则可以通过继承的方式,传递到类B里。
  • 那么类A就是基类,也叫做父类;类B就是派生类,也叫做子类。
# 父类
class A(object):
    def __init__(self):
        self.num = 10

    def print_num(self):
        print(self.num + 10)
# 子类
class B(A):
    pass


b = B()
print(b.num)
b.print_num()
  • 输出结果
10
20

二.单继承:子类只继承一个父类

故事情节:煎饼果子老师傅在煎饼果子界摸爬滚打几十年,拥有一身精湛的煎饼果子技术,并总结了一套"古法煎饼果子配方"。

可是老师傅年迈已久,在嗝屁之前希望把自己的配方传承下去,于是老师傅把配方传给他的徒弟大猫…

# 定义一个Master类
class Master(object):
    def __init__(self):
        # 属性
        self.kongfu = "古法煎饼果子配方" 

    # 实例方法
    def make_cake(self):
        print("按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 定义Prentice类,继承了 Master,则Prentice是子类,Master是父类。
class Prentice(Master): 
    # 子类可以继承父类所有的属性和方法,哪怕子类没有自己的属性和方法,也可以使用父类的属性和方法。
    pass                

# laoli = Master()
# print(laoli.kongfu)
# laoli.make_cake()

damao = Prentice()  # 创建子类实例对象
print(damao.kongfu) # 子类对象可以直接使用父类的属性
damao.make_cake()   # 子类对象可以直接使用父类的方法
古法煎饼果子配方
按照 <古法煎饼果子配方> 制作了一份煎饼果子...
  • 说明:虽然子类没有定义__init__方法初始化属性,也没有定义实例方法,但是父类有。所以只要创建子类的对象,就默认执行了那个继承过来的__init__方法

三.多继承:子类继承多个父类

  • 剧情发展

大猫掌握了师傅的配方,可以制作古法煎饼果子。但是大猫是个爱学习的好孩子,他希望学到更多的煎饼果子的做法,于是通过百度搜索,找到了一家煎饼果子培训学校。(多继承)

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量,属性

    def make_cake(self):                    # 实例方法,方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def dayandai(self):
        print("师傅的大烟袋..")

class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def xiaoyandai(self):
        print("学校的小烟袋..")

# class Prentice(School, Master):  # 多继承,继承了多个父类(School在前)
#     pass

# damao = Prentice()
# print(damao.kongfu)
# damao.make_cake()
# damao.dayandai()
# damao.xiaoyandai()


class Prentice(Master, School):  # 多继承,继承了多个父类(Master在前)
    pass

damao = Prentice()
print(damao.kongfu) # 执行Master的属性
damao.make_cake() # 执行Master的实例方法

# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)

damao.dayandai() # 不重名不受影响
damao.xiaoyandai()
古法煎饼果子配方
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
(<class '__main__.Prentice'>, <class '__main__.Master'>, <class '__main__.School'>, <class 'object'>)
师傅的大烟袋..
学校的小烟袋..
  • 说明:
  • ①多继承可以继承多个父类,也继承了所有父类的属性和方法
  • ②注意:如果多个父类中有同名的 属性和方法,则默认使用第一个父类的属性和方法(根据类的魔法属性mro的顺序来查找)
  • ③多个父类中,不重名的属性和方法,不会有任何影响。

四.子类重写父类的同名属性和方法

剧情发展:

大猫掌握了 师傅的配方 和 学校的配方,通过研究,大猫在两个配方的基础上,创建了一种全新的煎饼果子配方,称之为
“猫氏煎饼果子配方”。(子类重写父类同名属性和方法)

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"

    def make_cake(self):
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(School, Master):  # 多继承,继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 如果子类和父类的方法名和属性名相同,则默认使用子类的
# 叫 子类重写父类的同名方法和属性
damao = Prentice()
print(damao.kongfu) # 子类和父类有同名属性,则默认使用子类的
damao.make_cake() # 子类和父类有同名方法,则默认使用子类的

# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)
猫氏煎饼果子配方
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
(<class '__main__.Prentice'>, <class '__main__.School'>, <class '__main__.Master'>, <class 'object'>)

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

剧情发展:

大猫的新配方大受欢迎,但是有些顾客希望也能吃到古法配方和 现代配方 的煎饼果子…(子类调用父类的同名属性和方法)

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量,属性

    def make_cake(self):                    # 实例方法,方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(School, Master):  # 多继承,继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        print("执行子类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
        self.__init__() # 执行本类的__init__方法,做属性初始化 self.kongfu = "猫氏...."
        print("执行子类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


    # 调用父类方法格式:父类类名.父类方法(self)
    def make_old_cake(self):
        # 不推荐这样访问父类的实例属性,相当于创建了一个新的父类对象
        # print("直接调用Master类的kongfu属性:%s" % Master().kongfu)

        # 可以通过执行Master类的__init__方法,来修改self的属性值
        print("执行Master类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
        Master.__init__(self) # 调用了父类Master的__init__方法 self.kongfu = "古法...."
        print("执行Master类的__init__方法后,self.kongfu属性:%s" % self.kongfu)
        Master.make_cake(self) # 调用父类Master的实例方法


    def make_new_cake(self):
        # 不推荐这样访问类的实例属性,相当于创建了一个新的父类对象
        # print("直接调用School类的kongfu属性:%s" % School().kongfu)

        # 可以通过执行School类的__init__方法,来修改self的属性值
        print("执行School类的__init__方法前,self.kongfu属性:%s" % self.kongfu)
        School.__init__(self) # 调用了父类School的__init__方法 self.kongfu = "现代...."
        print("执行School类的__init__方法后,self.kongfu属性:%s" % self.kongfu)
        School.make_cake(self) # 调用父类School的实例方法

# 实例化对象,自动执行子类的__init__方法
damao = Prentice()

damao.make_cake() # 调用子类的方法(默认重写了父类的同名方法)

print("--" * 10)
damao.make_old_cake() # 进入实例方法去调用父类Master的方法

print("--" * 10)
damao.make_new_cake() # 进入实例方法去调用父类School的方法

print("--" * 10)
damao.make_cake() # 调用本类的实例方法
执行子类的__init__方法前,self.kongfu属性:猫氏煎饼果子配方
执行子类的__init__方法前,self.kongfu属性:猫氏煎饼果子配方
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
--------------------
执行Master类的__init__方法前,self.kongfu属性:猫氏煎饼果子配方
执行Master类的__init__方法后,self.kongfu属性:古法煎饼果子配方
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
--------------------
执行School类的__init__方法前,self.kongfu属性:古法煎饼果子配方
执行School类的__init__方法后,self.kongfu属性:现代煎饼果子配方
[现代] 按照 <现代煎饼果子配方> 制作了一份煎饼果子...
--------------------
执行子类的__init__方法前,self.kongfu属性:现代煎饼果子配方
执行子类的__init__方法前,self.kongfu属性:猫氏煎饼果子配方
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
  • 核心点: 无论何时何地,self都表示是子类的对象。在调用父类方法时,通过传递self参数,来控制方法和属性的访问修改。

六.多层继承

剧情发展:

大猫的煎饼果子店非常红火,终于有一天,他成了世界首富!!
但是他也老了,所以他希望把 师傅的配方 和 学校的配方 以及自己的配方 继续传承下去…(多层继承)

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"

    def make_cake(self):
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(School, Master):  # 多继承,继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"
        self.money = 10000  # 亿美金

    def make_cake(self):
        self.__init__() # 执行本类的__init__方法,做属性初始化 self.kongfu = "猫氏...."
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


    # 调用父类方法格式:父类类名.父类方法(self)
    def make_old_cake(self):
        Master.__init__(self) # 调用了父类Master的__init__方法 self.kongfu = "古法...."
        Master.make_cake(self) # 调用了父类Master的实例方法


    def make_new_cake(self):
        School.__init__(self) # 调用了父类School的__init__方法 self.kongfu = "现代...."
        School.make_cake(self) # 调用父类School的实例方法,

class PrenticePrentice(Prentice): # 多层继承
    pass


pp = PrenticePrentice()
pp.make_cake() # 调用父类的实例方法
pp.make_new_cake()
pp.make_old_cake()

print(pp.money)
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
[现代] 按照 <现代煎饼果子配方> 制作了一份煎饼果子...
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
10000

八.super()的使用

剧情发展:

大猫觉得配方传承下去没问题,但是钱是辛辛苦苦挣得血汗钱,不想传给徒弟。(私有权限)

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量,属性

    def make_cake(self):  # 实例方法,方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 父类是 Master类
class School(Master):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
        super().__init__()  # 执行父类的构造方法
        super().make_cake()  # 执行父类的实例方法


# 父类是 School 和 Master
class Prentice(School, Master):  # 多继承,继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        self.__init__()  # 执行本类的__init__方法,做属性初始化 self.kongfu = "猫氏...."
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def make_all_cake(self):
        # 方式1. 指定执行父类的方法(代码臃肿)
        # School.__init__(self)
        # School.make_cake(self)
        #
        # Master.__init__(self)
        # Master.make_cake(self)
        #
        # self.__init__()
        # self.make_cake()

        # 方法2. super() 带参数版本,只支持新式类
        # super(Prentice, self).__init__() # 执行父类的 __init__方法
        # super(Prentice, self).make_cake()
        # self.make_cake()

        # 方法3. super()的简化版,只支持新式类
        super().__init__()  # 执行父类的 __init__方法
        super().make_cake()  # 执行父类的 实例方法
        self.make_cake()  # 执行本类的实例方法


damao = Prentice()
damao.make_cake()
damao.make_all_cake()

# print(Prentice.__mro__)
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
[现代] 按照 <现代煎饼果子配方> 制作了一份煎饼果子...
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
  • 知识点:
  • ①子类继承了多个父类,如果父类类名修改了,那么子类也要涉及多次修改。而且需要重复写多次调用,显得代码臃肿。
  • ②使用super() 可以逐一调用所有的父类方法,并且只执行一次。调用顺序遵循 mro 类属性的顺序。
  • 注意:如果继承了多个父类,且父类都有同名方法,则默认只执行第一个父类的(同名方法只执行一次,目前super()不支持执行多个父类的同名方法)
  • super() 在Python2.3之后才有的机制,用于通常单继承的多层继承。

  • The best investment is in yourself
    在这里插入图片描述
  • 2020.04.03 记录辰兮的第47篇博客

你可能感兴趣的:(Python基础)