本文已参与「新人创作礼」活动，一起开启掘金创作之路。

面向对象-继承

目标

• 继承的概念
• 单继承
• 多继承
• 子类重写父类的同名属性和方法
• 子类调用父类的同名属性和方法
• 多层继承
• super()
• 私有属性和私有方法

继承的概念

继承在生活中，一般指的是子女继承父亲的财产，这种行为我们称为继承

类

不同的python版本类的代码书写形式不同

python2.0之下

经典类

class 类名:
    代码

python3.0之下

新式类

class 类名(object):
    代码

代码体验

python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下

#父类A
class A(object):
    def __init__(self):
        #实例属性
        self.num = 1
        
        #实例方法
    def info_print(self):
        #这里print打印了的是self.num
        #而self.num = 1
        
        print(self.num)
        
#子类B
class B(A):
    #这个子类他括号里面写的是A，也就是说他继承的是父类A
    
    pass
​
#创建对象
result = B()
#对象调用info_print()
#输出的结果是1
result.info_print()
​
#通过结果分析,我们创建对象B但是对象B继承了父类A的所有属性和实例方法元素等等，那么A类有的B类也有，这就说明了为什么能输出1了

单继承

简单的说就是一个是师傅只传授给一个徒弟，一个徒弟只继承一个师傅，这些形式的继承称为单继承

#师傅类
class shifu(object):
    #定义init魔法方法
    def __init__(self):
        #定义一个属性jianbing
        self.jianbing = '[秘制煎饼配方]'
    #定义一个实例方法
    def make_cake(self):
        #调用jianbing
        print(f'运用{self.jianbing}制作煎饼')
        
        
#徒弟类，继承师傅类
​
class tudi(shifu):
    pass
​
​
​
#创建对象
jian = tudi()
​
#验证调用
​
jian.make_cake()
        

标准输出：

运用[秘制煎饼配方]制作煎饼

多继承

简单的说就是，一个徒弟继承了多个师傅的看家本领

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
#创建徒弟
class tudi(shifu,shifu2):
    #继承了两个师傅
    pass
​
​
#创建对象
kaishi = tudi()
kaishi.make_cake()
​

标准输出：

运用[嘎嘣脆煎饼配方]制作煎饼

为什么只打印了第一个师傅的

首先两个师傅都用的是make_cake()这个实例方法，在同名的时候提供先后顺序来继承

我想先继承第二个师傅

没问题

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
#创建徒弟
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    pass
​
​
#创建对象
kaishi = tudi()
kaishi.make_cake()
​

标准输出：

运用[脆到骨子炸鸡配方]制作炸鸡

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

当徒弟创建了一个配合配合的实例名和前面两个师傅一样的，但是呢创建对象只创建徒弟的，在输出的时候，是会输出徒弟创建的配方的

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
    def make_cake(self):
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
#创建对象
kaishi = tudi()
kaishi.make_cake()
​

扩展

如何快速知道继承顺序

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    pass
      
#创建对象
kaishi = tudi()
kaishi.make_cake()
​
#快速知道继承顺序
print (tudi.__mro__)

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

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
    def make_shifu_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        
    def make_shifu2_cake(self):
        shifu2.__init__(self)
        shifu2.make_cake(self)
​
​
#创建对象
kaishi = tudi()
kaishi.make_cake()
​
​
kaishi.make_shifu_cake()
kaishi.make_shifu2_cake()

标准输出：

运用[独创嘎嘣脆煎饼]制作煎饼
运用[嘎嘣脆煎饼配方]制作煎饼
运用[脆到骨子炸鸡配方]制作炸鸡

多层继承

简单来说就是师傅比较长寿，他徒弟孙子都成年了，他还在世，那么这时候，他的徒孙就要继承他爸爸也就是师傅徒弟的本领，但是徒弟的本来是继承于师傅的，间接性的说，就是徒孙继承了师傅的本领【有点绕口，理解理解】

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
    def make_shifu_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        
    def make_shifu2_cake(self):
        shifu2.__init__(self)
        shifu2.make_cake(self)
​
#创建徒弟的孙子，师傅把本领传给徒弟孙子
class tushun(tudi):
    #徒孙继承的是他爸爸也就是师傅的徒弟
    pass
        
        
#创建对象
kaishi = tushun()
kaishi.make_cake()
​
​
kaishi.make_shifu_cake()
kaishi.make_shifu2_cake()

标准输出：

运用[独创嘎嘣脆煎饼]制作煎饼
运用[嘎嘣脆煎饼配方]制作煎饼
运用[脆到骨子炸鸡配方]制作炸鸡

super()调用父类方法

普通方法

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
    def make_shifu_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        
    def make_shifu2_cake(self):
        shifu2.__init__(self)
        shifu2.make_cake(self)
        #合并两个类似
    def make_old_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        shifu2.__init__(self)
        shifu2.make_cake(self)
​
#创建徒弟的孙子，师傅把本领传给徒弟孙子
class tushun(tudi):
    #徒孙继承的是他爸爸也就是师傅的徒弟
    pass
        
        
#创建对象
kaishi = tushun()
kaishi.make_cake()
​
​
kaishi.make_old_cake()

标准输出：

运用[独创嘎嘣脆煎饼]制作煎饼
运用[嘎嘣脆煎饼配方]制作煎饼
运用[脆到骨子炸鸡配方]制作炸鸡

super()方法

带参数写法

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        
        
        #super(当前类名，self).函数（）
        super(shifu2,self).__init__()
        super(shifu2,self).make_cake()
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
    def make_shifu_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        
    def make_shifu2_cake(self):
        shifu2.__init__(self)
        shifu2.make_cake(self)
        #合并两个类似
    def make_old_cake(self):
        
        
        
        #super(当前类名，self).函数（）
        super(tudi,self).__init__()
        super(tudi,self).make_cake()
​
​
        
#创建对象
kaishi = tudi()
​
kaishi.make_old_cake()

标准输出：

运用[脆到骨子炸鸡配方]制作炸鸡
运用[嘎嘣脆煎饼配方]制作煎饼

无参数super()

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        super().__init__()
        super().make_cake()        
    
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
    def make_cake(self):
        self.__init__()
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
    def make_shifu_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        
    def make_shifu2_cake(self):
        shifu2.__init__(self)
        shifu2.make_cake(self)
        #合并两个类似
    def make_old_cake(self):
        
        
        
        #super(当前类名，self).函数（）
        super().__init__()
        super().make_cake()
​
​
        
#创建对象
kaishi = tudi()
​
kaishi.make_old_cake()

标准输出：

运用[脆到骨子炸鸡配方]制作炸鸡
运用[嘎嘣脆煎饼配方]制作煎饼

私有权限

定义私有属性和私有方法

私有权限是什么呢，就是我把做煎饼的配方传你了，但是我的做煎饼工具不能给你

你要自己去买，这就是私权

设置私有权限的方法：在属性名和方法名，前面，加上两个下划线__

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        super().__init__()
        super().make_cake()        
    
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
        self.__gongju= '三轮车'
        
        
    #定义私有方法
    def __info_print(self):
        pinrt(self.gabengcui)
        pinrt(self.__gongju)
        
        
        
        
        
    def make_cake(self):
        self.__init__()
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
    def make_shifu_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        
    def make_shifu2_cake(self):
        shifu2.__init__(self)
        shifu2.make_cake(self)
        
        
        
#徒孙
class tushun(tudi):
    pass
​
​
​
kaishi = tudi()
print(kaishi.__gongju)
kaishi.__info_print()
​
​
​
​
che = tushun()
​
print(che.__gongju)
che.__info_print()

获取和修改私有属性值

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

#创建一号师傅
class shifu(object):
    def __init__(self):
        self.gabengcui = '[嘎嘣脆煎饼配方]'
    def make_cake(self):
        print(f'运用{self.gabengcui}制作煎饼')
        
 #创建二号师傅
class shifu2(object):
    def __init__(self):
        self.zhaji = '[脆到骨子炸鸡配方]'
    def make_cake(self):
        print(f'运用{self.zhaji}制作炸鸡')
        super().__init__()
        super().make_cake()        
    
        
#徒弟创建配方
class tudi(shifu2,shifu):
    #继承顺序改改
    #继承了两个师傅
    def __init__(self):
        self.gabengcuijianbing = '[独创嘎嘣脆煎饼]'
        self.__gongju= '三轮车'
        
        
    #获取私有属性
    def get_gongju(self):
        return self.__gongju
    #修改私有属性
    def set_gongju(self):
        self.__gongju = '四轮车'
    
    
    
    
    
    def __info_print(self):
        print('这是私有方法')
       
​
        
        
        
    def make_cake(self):
        self.__init__()
        print(f'运用{self.gabengcuijianbing}制作煎饼')
      
    def make_shifu_cake(self):
        shifu.__init__(self)
        shifu.make_cake(self)
        
    def make_shifu2_cake(self):
        shifu2.__init__(self)
        shifu2.make_cake(self)
        
        
        
#徒孙
class tushun(tudi):
    pass
​
kaishi = tushun()
print(kaishi.get_gongju())
#打印结果为三轮车
#修改他为四轮车
kaishi.set_gongju()
#打印看看是不是修改了
print(kaishi.get_gongju())
#打印结果
#标准输出：
#三轮车
#四轮车

总结

继承的写法

• 子类默认拥有父类的所有属性和方法
• 子类重写父类同名方法和属性
• 子类调用父类同名方法和属性

super()方法快速调用父类方法

私有权限

• 不能继承给子类的属性和方法需要添加私有权限
• 语法

class 类名():
    #私有属性
    __属性名 = 值
    # 私有方法
    def __函数名(self):
        代码 

\