python继承父类后继续在init中添加可继承_day04python面向对象之继承

面向对象三大特性

• 继承

• 封装

• 多态

继承

继承指的是类与类之间的关系，是一种什么是什么的关系

继承的功能之一：解决类与类之间的代码重复问题

继承是类与类之间的关系，是一种什么是什么的关系

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

在python中类的继承分为：单继承或多继承

#继承的基本形式class ParentClass1: #定义父类    passclass ParentClass2: #定义父类    passclass SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass    passclass SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类    pass# 查看继承>>> SubClass1.__bases__(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)#  __base__只查看从左到右继承的第一个子类#  __bases__则是查看所有继承的父类# 如果没有指定父类，python会默认继承object类，object是所有python的父类

多继承的数据查找：

经典类与新式类

• 只有在python2中才分新式类和经典类，python3中统一都是新式类

• 在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类

• 在python2中，显式地声明继承object的类，以及该类的子类，都是新式类

• 在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类

继承原理：(python如何实现的继承)

对于定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如

>>> F.mro()  #等同于F.__mro__[<class '__main__.F'>, __main__.D'>, __main__.

为了实现继承，python会在MRO列表上从左到右开始查找基类，直到找到第一个匹配这个属性的类为止。

而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

• 子类会先于父类被检查

• 多个父类会根据它们在列表中的顺序被检查

• 如果对下一个类存在两个合法的选择,选择第一个父类

子类中调用父类的方法

方法一：指名道姓法，即父类名.父类方法()

#_*_coding:utf-8_*___author__ = 'Linhaifeng' class Vehicle: #定义交通工具类    Country='China'    def __init__(self,name,speed,load,power):        self.name=name        self.speed=speed        self.load=load        self.power=power     def run(self):         print('开动啦...') class Subway(Vehicle): #地铁   def __init__(self,name,speed,load,power,line):       Vehicle.__init__(self,name,speed,load,power)       self.line=line    def run(self):       print('地铁%s号线欢迎您' %self.line)       Vehicle.run(self)line13=Subway('中国地铁','180m/s','1000人/箱','电',13)line13.run()

方法二：super()

super会根据mro表进行查找，即使没有直接继承关系

class Vehicle:  # 定义交通工具类    Country='China'    def __init__(self,name,speed,load,power):        self.name=name        self.speed=speed        self.load=load        self.power=power     def run(self):        print('开动啦...') class Subway(Vehicle): #地铁   def __init__(self,name,speed,load,power,line):       #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)       super().__init__(name,speed,load,power)       self.line=line    def run(self):       print('地铁%s号线欢迎您' %self.line)       super(Subway,self).run() class Mobike(Vehicle):#摩拜单车   passline13=Subway('中国地铁','180m/s','1000人/箱','电',13)line13.run() 

当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次。

(注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表)

继承与抽象

抽象就是抽取类似或者比较像的部分，划分类别，抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

继承是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构

 先抽象后继承

派生：(相对论)

派生类：在父类的基础上产生子类，产生的子类就叫做派生类

派生方法：父类里没有的方法，在子类中有了，这样的方法就叫做派生方法。

父类里有，子类也有的方法，就叫做方法的重写(就是把父类里的方法重写了)

注意的几个概念：

• 子类可以使用父类的所有属性和方法

• 如果子类有自己的方法，就执行自己的；如果子类没有自己的方法，就会找父类的。

• 如果子类里面没有找到，父类里也没有找到，就会报错

• 如果子类中实现了调用父类的方法：

• • 在类内：super(子类,self).方法名() ，supper().__init__(参数)

  • 在类外：super(子类名，对象名).方法名()

例子：

1 class Animal:      #父类  基类  超类 2     def __init__(self,name,life_value,aggr): 3         self.name= name 4         self.life_value = life_value 5         self.aggr = aggr  #攻击力 6     def eat(self): 7         self.life_value += 10  #谁调谁的血量就增加 8  9 class Person(Animal):  #子类  派生类10     def __init__(self, money, name, life_value, aggr):11         super().__init__(name, life_value, aggr)12         self.money = money  #派生出来的一个属性13     def attack(self,enemy):    #人的派生方法14         #enemy.life_value = enemy.life_value - self.aggr15         enemy.life_value -= self.aggr16 17 class Dog(Animal): #子类  派生类18     def __init__(self,name,breed, life_value,aggr):19         # Animal.__init__(self,name,breed, life_value,aggr)#让子类执行父类的方法 就是父类名.方法名(参数)，连self都得传20         super().__init__(name,life_value,aggr) #super关键字  ，都不用传self了，在新式类里的21         # super(Dog,self).__init__(name,life_value,aggr)  #上面super是简写22         self.breed = breed23     def bite(self,person):   #狗的派生方法24         person.life_value -= self.aggr25     def eat(self):  #父类方法的重写26         super().eat()27         print('dog is eating')28 29 # ha2 = Dog('旺财','哈士奇',20000,100)30 # egg = Person('egon',500,1000,50)31 # print(egg.aggr)32 # print(ha2.aggr)33 # egg.eat()34 # print(egg.life_value)35 #36 # egg.eat()37 # print(egg.life_value)38 #39 # ha2.eat()40 # print(ha2.life_value)41 #42 # print(egg.life_value)43 # ha2.bite(egg)44 # print(egg.life_value)45 #46 47 ha2 = Dog('牛头梗','旺财',20000,100)48 print(ha2.life_value)49 ha2.eat()  #如果父类有的方法子类里面也有，那么就叫做方法的重写，就不执行父类的了，去执行子类了50 print(ha2.life_value)51 52 53 super(Dog,ha2).eat() #生掉父类的方法，但是不推荐这样用54 print(ha2.life_value)55 56 #在继承中，如果子类有的方法就执行子类的57 # 如果子类没有的方法就执行父类的

组合

组合与继承都是有效地利用已有类的资源的重要方式

组合：在一个类中以另外一个类的对象作为数据属性，称为类的组合，也就是说一个类的属性是另一个类的对象，就是组合。

例子：圆环是由两个圆组成的，圆环的面积就是外圆的面积减去内圆的面积。圆环的周长就是内圆的周长加上外圆的周长，这个时候，我们首先设计一个圆形类，计算一个圆的面积和圆的周长。然后在‘圆环类’组合圆形的实例作为自己的属性来用

(这样的目的就是为了不用在写面积和周长的方法了，直接组合圆类的面积和方法去求解。减少了代码的重用)

 1 from math import pi 2 class Circle: 3     def __init__(self,r): 4         self.r=r 5     def perimater(self): 6         return 2*pi*self.r 7     def area(self): 8         return pi*self.r*self.r 9 # print(Circle.perimater('r',2))10 # print(Circle.area('r',3))11 12 13 class Circle_ring: #定义一个圆环类14     def __init__(self,outside_r,inside_r):15         outside_bijiao = max(outside_r,inside_r)16         intside_bijiao = min(outside_r, inside_r)17         self.outsize_circle = Circle(outside_bijiao) #实例化一个大圆形  作为self.outside_circle属性的值18         self.intsize_circle = Circle(intside_bijiao) #实例化一个小圆环19     def area(self):20         return self.outsize_circle.area()-self.intsize_circle.area()21     def perimater(self):22         return self.intsize_circle.perimater()+self.outsize_circle.perimater()23 24 25 r1 = Circle_ring(10,20)  #实例化26 print(r1.area())27 print(r1.perimater())

组合的两种方式：

• 在__init__方法里面组合

• 在外面组合

 # 在__init__方法里面组合 1 class BirthDate: 2     def __init__(self,year,month,day): 3         self.year=year 4         self.month = month 5         self.day = day 6 class Course: 7     def __init__(self,name,price,period): #period为周期 8         self.name =name 9         self.price = price10         self.period = period11 class Teacher:12     def __init__(self,name,salary,year,month,day,price,period): #那么这个里面也要把该有的属性传进去13         self.birth = BirthDate(year,month,day) #在里面组合(将BirthDate里面有的属性传入进去)14         self.course=Course(name,price,period)15         self.name = name16         self.salary = salary17 # 实例化方法一:18 egg = Teacher('egon',2000,1999,12,2,'6 months','15800')  #也要实例化，Teacher类里面的属性都得实例化19 print(egg.birth.month)  #当然老师也有生日，就让egg.birth.month20 print(egg.course.period)21 22 # 实例化方法二:23 egg.birth=BirthDate(1996,22,4)24 print(egg.birth.month)# 在类外面实例化组合 1 class BirthDate: 2     def __init__(self,year,month,day): 3         self.year=year 4         self.month = month 5         self.day = day 6 class Course: 7     def __init__(self,name,price,period): #period为周期 8         self.name =name 9         self.price = price10         self.period = period11 class Teacher:12     def __init__(self,name,salary,course):13         self.name = name14         self.salary = salary15         self.course = course16 #17 # #在外面组合。(组合就是一个类的属性是另一个类的对象)18 19 egg = Teacher('egon',2000,'python')20 egg.birth=BirthDate(1996,22,4) #直接给egg一个birth的属性，21 print(egg.birth.year)22 23 egg.course =Course('python','6 months',15800)24 print(egg.course.period)

继承的方式

• 通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马

• 当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人

组合的方式

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3...

class OldboyPeople:  # 定义老男孩人这个基类    school = 'oldboy'    def __init__(self,name,age,sex):        self.name=name        self.age=age        self.sex=sex    def eat(self):        print('is eating')class OldboyStudent(OldboyPeople):  #老男孩学生类，继承OldboyPeople类    def __init__(self,name,age,sex):        OldboyPeople.__init__(self,name,age,sex)        self.course=[]    def learn(self):        print('%s is learning'  %self.name)class OldboyTeacher(OldboyPeople):    def __init__(self,name,age,sex,salary,title):        OldboyPeople.__init__(self,name,age,sex)        self.salary=salary        self.title=title        self.course=[]    def teach(self):        print('%s is teaching'  %self.name)class Course:    def __init__(self,course_name,course_period,course_price):        self.course_name=course_name        self.course_period=course_period        self.course_price=course_price    def tell_info(self):        print('' %(self.course_name,self.course_period,self.course_price))python=Course('Python','6mons',3000)  # 实例化课程linux=Course('Lnux','3mons',2000)bigdata=Course('BigData','1mons',1000)# 实例化老师egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河霸道金牌讲师')              egon_obj.course.append(python) # 为老师添加课程到课程列表egon_obj.course.append(linux) for obj in egon_obj.course:    # 循环打印egon老师的课程列表    obj.tell_info()            yl_obj=OldboyStudent('yanglei',28,'female')   # 实例化学生yl_obj.course.append(python)   # 为学生添加课程到课程列表for i in yl_obj.course:    i.tell_info()