自学Python5.5-面向对象三大基本特征_继承

自学Python之路-Python基础+模块+面向对象
自学Python之路-Python网络编程
自学Python之路-Python并发编程+数据库+前端
自学Python之路-django

自学Python5.5-面向对象三大基本特征_继承

一、初始继承（单继承）

1.1  继承概念

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

• 通过继承创建的新类称为“子类”或“派生类”。
• 被继承的类称为“基类”、“父类”或“超类”。
• 继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
• 一个子类可以被多个类继承。
• 一个子类可以继承多个父类（只有在python里面才有）。

class A(object):pass   # 父类，基类，超类
class B:pass   # 父类，基类，超类
class A_son(A,B):pass # 子类，派生类
class AB_son(A):pass # 子类，派生类

没有继承父类，默认继承object 。

1.2  继承与抽象（先抽象后继承）

抽象即抽取类似或者说比较像的部分。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）。

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

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类。

# 比如举例人狗大战。 以下有两个类，你会发现两个类有共同点
class Dog:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def bitc(self,person):
        person.hp -= self.aggr
class person:
    def __init__(self,name,aggr,hp,sex):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.sex = sex
        self.money = 0
    def attack(self,dog):
        person.hp -= self.aggr
    def get_weapon(self,weapon):
        if self.money >= weapon.price:
             self.money -= weapon.price
             self.get_weapon = weapon
             self.aggr += weapon.aggr
        else:
            print("余额不足，请先充值")　　

 将以上两个类相同的地方创建一个新的类， 两个类在继承新的类。

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name  #人和狗都有自己的昵称
        self.aggr = aggr  #人和狗都有自己的攻击力
        self.hp = hp      #人和狗都有自己的生命值
class Dog(Animal):
    def bitc(self,person):
        person.hp -= self.aggr
class person(Animal):
    pass
Liu = Dog("刘老板",200,500)
print(Liu.name)

举个例子：

一个狗类： 吃、喝、看门

一个鸟类： 吃、喝、下单

class Animal:
    def __init__(self):
        print('执行Animal.__init__')
        self.func()
    def eat(self):
        print('%s eating'%self.name)
    def drink(self):
        print('%s drinking'%self.name)
    def func(self):
        print('Animal.func')
class Dog(Animal):
    def guard(self):
         print('guarding')
    def func(self):
         print('Dog.func')
class Bird(Animal):
    def __init__(self,name):
        self.name = name
    def lay(self):
        print('laying')　　

比如定义一个实例 dog = Dog（），其中产生了一个问题

当执行Dog类的时候，Dog类没有__init__(self)就执行父类Animal的__init__(self)，然后执行了self.func（），此时Animal和Dog类同时拥有self.func（），那么它执行哪个类的self.func（）？ 答案是：Dog的self.func（）

提示：

用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大。

1.3  派生

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

# 比如接上面的举例。
class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        self.kind = kind
    def bitc(self,person):
        person.hp -= self.aggr
Liu = Dog("刘老板",20,500,"吉娃娃")
print(Liu.name)     # 报错，因为只执行Dog类里面的_init_,但是里面没有name　

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def eat(self):
        print('吃药回血')
        self.hp+=100
class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp)  #
        self.kind = kind       # 派生属性（父类没有的，子类新增的属性）
class Person(Animal):
    def __init__(self,name,aggr,hp,sex):
        Animal.__init__(self,name,aggr,hp)
        self.sex = sex       # 派生属性
        self.money = 0       # 派生属性
Liu = Dog('刘老板',20,500,'吉娃娃')
Liu.eat()       #使用的继承父类animal的eat方法
print(Liu.hp)
tong = Person('tong',1,2,None)
tong.eat()      #使用的继承父类animal的eat方法
print(tong.hp)

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def eat(self):
        print('吃药回血')
        self.hp+=100
class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp)  #
        self.kind = kind       # 派生属性（父类没有的，子类有的属性）
    def bite(self,person):     # 派生方法（父类没有的，子类有的方法）
        person.hp -= self.aggr
class Person(Animal):
    def __init__(self,name,aggr,hp,sex):
        Animal.__init__(self,name,aggr,hp)
        self.sex = sex       # 派生属性
        self.money = 0       # 派生属性
    def attack(self,dog):
        dog.hp -= self.aggr
    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.money -= weapon.price
            self.weapon = weapon
            self.aggr += weapon.aggr
        else:
            print("余额不足，请先充值")
Liu = Dog('刘老板',20,500,'吉娃娃')
Liu.eat()       #使用的继承父类animal的eat方法
print(Liu.hp)

tong = Person('tong',1,2,None)
tong.eat()      #使用的继承父类animal的eat方法
print(tong.hp)

Liu.bite(tong) #使用Dog类自己的派生方法
print(tong.hp)

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

在python3中，子类执行父类的方法也可以直接用super方法。

class A:
    def hahaha(self):
        print('A')

class B(A):
    def hahaha(self):
        super().hahaha()
        #super(B,self).hahaha()
        #A.hahaha(self)
        print('B')

a = A()
b = B()
b.hahaha()
super(B,b).hahaha()

 总结：

• 父类中没有的属性 在子类中出现 叫做派生属性
• 父类中没有的方法 在子类中出现 叫做派生方法
• 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
• 如果父类、子类都有，使用子类的
•      如果还想用父类的，单独调用父类的
•      父类名.方法名，需要自己传self参数
•      super().方法名，不需要自己传只在新式类中有，python3中所有类都是新式类
• 正常的代码中，单继承 === 减少了代码的重复
• 继承表达的是一种 子类是父类的关系

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def eat(self):
        print('吃药回血')
        self.hp+=100
class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        super().__init__(name,aggr,hp)    #等价于Animal.__init__(self,name,aggr,hp)，不需要传self
        self.kind = kind       # 派生属性（父类没有的，子类新增的属性）
Liu = Dog('刘老板',20,500,'吉娃娃')
Liu.eat()          #使用的继承父类animal的eat方法
print(Liu.hp)

super（）可以在类内使用，也可以在类外使用。

• super（）在类内使用：不需要传默认参数，就是类名和self
• super（）在类外使用：必须传类名和对象名

#super（）在类外和类内
class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def eat(self):
        print('吃药回血')
        self.hp+=100
class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        super().__init__(name,aggr,hp)    #等价于Animal.__init__(self,name,aggr,hp)
        self.kind = kind       # 派生属性（父类没有的，子类新增的属性）
    def eat(self):print("dog eating")
Liu = Dog('刘老板',20,500,'吉娃娃')
print(Liu.name)
Liu.eat()             # 执行的是Dog类里面的def eat(self):print("dog eating")
super(Dog,Liu).eat()  # 执行的是父类里面的def eat(self):

二、多继承

class A:
    def func(self):print("A")
class B:
    def func(self):print("B")
class C:
    def func(self):print("C")
class D(A,B,C):  # D类继承A,B,C，多继承
    def func(self):print("D")

d = D()
d.func()   #此时调用的D类的func()

class A:
    def func(self):print("A")
class B:
    def func(self):print("B")
class C:
    def func(self):print("C")
class D(A,B,C):  # D类继承A,B,C，多继承
    pass
    #def func(self):print("D")

d = D()
d.func()   #此时调用的A类的func(),因为class D(A,B,C),A类离D最近

2.1 多继承---经典案例----菱形继承（钻石继承）

B、C继承A，D继承B、C

class A:
    def func(self):print("A")
class B(A):   # B类继承A
    def func(self):print("B")
class C(A):   # C类继承A
    def func(self):print("C")
class D(B,C):  # D类继承B,C
    pass
    #def func(self):print("D")

d = D()
d.func()  

class A:
    def func(self):print("A")
class B(A):   # B类继承A
    pass
    #def func(self):print("B")
class C(A):   # C类继承A
    def func(self):print("C")
class D(B,C):  # D类继承B,C
    pass
    #def func(self):print("D")

d = D()
d.func()

class A:
    def func(self):print("A")
class B(A):   # B类继承A
    pass
    #def func(self):print("B")
class C(A):   # C类继承A
    pass
    #def func(self):print("C")
class D(B,C):  # D类继承B,C
    pass
    #def func(self):print("D")

d = D()
d.func()

同理以下两个问题，继承顺序如下图：

 

 

2.2  总结

多继承中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是什么？

• 经典类中 深度优先
• 新式类中 广度优先

① python2.7 新式类和经典类共存，新式类要继承object

② python3 只有新式类，默认继承object

③ 经典类和新式类还有一个区别：mro方法只在新式类中存在，类名.mro方法，查看广度优先的继承顺序。

④ super 只在python3中存在

⑤ super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

class A(object):
    def func(self): print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()
        print('D')

b = D()
b.func()　　

......