Python全栈之路----面向对象开发----继承与派生

什么是继承？

继承指的是类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代码重用问题

继承是一种建立新类的方式，在python中，新建的类能够继承一个或多个父类，父类又能够成为基类或超类，新建的类称为派生类或子类

派生

固然子类也能够添加本身新的属性或者在本身这里从新定义这些属性（不会影响到父类），须要注意的是，一旦从新定义了本身的属性且与父类重名，那么调用新增的属性时，就以本身为准了。

class Hero:
    def __init__(self, nickname, life_value, aggressivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggressivity = aggressivity

    def attack(self, enemy):
        enemy.life_value -= self.aggressivity

class Garen(Hero):
    camp = 'Demacia'

class Riven(Hero):
    camp = 'Noxus'

g = Garen('草丛伦', 100, 30)

在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能须要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，所以即使是self参数也要为其传值

经典类与新式类(关于新式类与经典类的区别，咱们稍后讨论)

1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
3.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
4.在python3中，不管是否继承object，都默认继承object，即python3中全部类均为新式类

继承的实现原理

        python究竟是如何实现继承的，对于你定义的每个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的全部基类的线性顺序列表，例如

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, 
<class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

        为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。而这个MRO列表的构造是经过一个C3线性化算法来实现的。咱们不去深究这个算法的数学原理,它实际上就是合并全部父类的MRO列表并遵循以下三条准则:

1. 子类会先于父类被检查
2. 多个父类会根据它们在列表中的顺序被检查
3. 若是对下一个类存在两个合法的选择,选择第一个父类

           在Java和C#中子类只能继承一个父类，而Python中子类能够同时继承多个父类，若是继承了多个父类，那么属性的查找方式有两种，分别是：深度优先和广度优先。

 

示范代码

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass

f1=F()
f1.test()
print(F.__mro__)

在子类中调用父类的方法

在子类派生出的新方法中，每每须要重用父类的方法，咱们有两种方式实现

方式一：指名道姓，即父类名.父类方法() 不依赖继承    方式二：super() 依赖继承

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)  # 方式一：指名道姓
        '''
        python2:   super(Subway, self).__init__(line)  # 方式二：super(子类名, self).调用函数名(父类里面的参数) 
        python 3:  super().__init__(line)  # 可省略super括号里的部分
                    即便没有直接继承关系，super仍然会按照mro继续日后查找
        '''
        self.line = line

    def run(self):
        print('地铁%s号线欢迎您' % self.line)
        Vehicle.run(self)


line13 = Subway('中国地铁', '180m/s', '1000人/箱', '电', 13)
line13.run()

组合VS继承

组合与继承都是有效地利用已有类的资源的重要方式。可是两者的概念和使用场景皆不一样，

1.继承的方式

经过继承创建了派生类与基类之间的关系，它是一种'是'的关系，好比白马是马，人是动物。

当类之间有不少相同的功能，提取这些共同的功能作成基类，用继承比较好，好比老师是人，学生是人

2.组合的方式

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

示例：继承与组合

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Teacher(People):
    def __init__(self,name,age,sex,job_title):
        People.__init__(self,name,age,sex)
        self.job_title=job_title
        self.course=[]
        self.students=[]


class Student(People):
    def __init__(self,name,age,sex):
        People.__init__(self,name,age,sex)
        self.course=[]


egon=Teacher('egon',18,'male','沙河霸道金牌讲师')
s1=Student('牛榴弹',18,'female')

python=Course('python','3mons',3000.0)
linux=Course('python','3mons',3000.0)

#为老师egon和学生s1添加课程
egon.course.append(python)
egon.course.append(linux)
s1.course.append(python)

#为老师egon添加学生s1
egon.students.append(s1)


#使用
for obj in egon.course:
    obj.tell_info()

总结：

当类之间有显著不一样，而且较小的类是较大的类所须要的组件时，用组合比较好