面向对象三大特性：继承，多态，封装之继承代码注释部分

#单继承
# class A(object):pass   # 父类，基类，超类
# class B:pass   # 父类，基类，超类
# class A_son(A,B):pass # 子类，派生类
# class AB_son(A):pass # 子类，派生类
# 一个类 可以被多个类继承
# 一个类 可以继承多个父类  —— python里
# print(A_son.__bases__)
# print(AB_son.__bases__)
# print(A.__bases__)  # python3 -新式类# 没有继承父类默认继承object
# class Animal:
#     def __init__(self,name,aggr,hp):
#         self.name = name
#         self.aggr = aggr
#         self.hp = hp
#         self.func()  #这里调用的func是Dog类的，因为Dog类继承了Animal，并且Dog实例化一个d
#     def func(self):
#         print(123)
# class Dog(Animal):     #
#     def func(self):
#         print(456)
#     def bite(self,person):
#         person.hp -= self.aggr
# d = Dog('a',2,3)
# class Person(Animal):
#     def func(self):
#         print(345)
#     pass
# personn = Person('1',2,3)
# gelan = Dog('盖伦',200,500)
# print(gelan.name)

# 狗类 吃 喝 看门(guard)
# 鸟类 吃 喝 下蛋(lay)
# class Animal:
#     def __init__(self,name):
#         self.name = name
#         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')
# dog = Dog('二哈')
# class Bird(Animal):
#     def __init__(self,name):
#         self.name = name
#     def lay(self):
#         print('laying')
# bird = Bird('gelan')
# dog.drink()
# bird.drink()
# dog.guard()
# bird.lay()


# 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 eat(self):
#         Animal.eat(self)   # 如果既想实现新的功能也想使用父类原本的功能，还需要在子类中再调用父类
#         # self.teeth = 2
#     def bite(self,person):   # 派生方法
#         person.hp -= self.aggr
# gelan = Dog('盖伦',100,500,'德玛西亚')
# gelan.eat()
# print(gelan.hp)
# 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("余额不足，请先充值")
# alex = Person('alex',1,2,None)
# alex.eat()
# print(alex.hp)
# gelan.bite(alex)
# print(alex.hp)


# 父类中没有的属性 在子类中出现 叫做派生属性
# 父类中没有的方法 在子类中出现 叫做派生方法
# 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都有 用子类的
    # 如果还想用父类的，单独调用父类的:
    #       父类名.方法名 需要自己传self参数
    #       super().方法名 不需要自己传self
# 正常的代码中 单继承 === 减少了代码的重复
# 继承表达的是一种 子类是父类的关系
# 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)  # 只在新式类中有，python3中所有类都是新式类，super().__init__关键字，
#         self.kind = kind       # 派生属性     # 就是子类自己有一个方法，同时父类里也有，
#     def eat(self):print('dog eating')         # 那就用super或者直接在子类当中用父类名字
# gai = Dog('盖伦',200,500,'teddy')           　　# 去调,super()这里不需要穿self参数了，
# print(gai.name)                               # 因为在这里省略了两个参数
# gai.eat()                                     # super(自己的类，self自己当前的对象)
# super(Dog,gai).eat()



#多继承
# coding:utf-8
# class F:
#     def func(self): print('F')
# class A(F):pass
#     # def func(self): print('A')
# class B(A):
#     pass
#     # def func(self): print('B')
# class E(F):pass
#     # def func(self): print('E')
# class C(E):
#     pass
#     # def func(self): print('C')
# class D(B,C):
#     pass
#     # def func(self):print('D')
# d = D()
# # d.func()
# print(D.mro())

# 新式类中的继承顺序 ： 广度优先
# 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()
# print(B.mro())
#2.7
# 新式类 继承object类的才是新式类 广度优先
# 经典类 如果你直接创建一个类在2.7中就是经典类 深度优先
# print(D.mro())
# D.mro()

# 单继承 ： 子类有的用子类 子类没有用父类
# 多继承中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是
# 经典类中 深度优先
# 新式类中 广度优先
# python2.7 新式类和经典类共存，新式类要继承object
# python3   只有新式类，默认继承object
# 经典类和新式类还有一个区别  mro方法只在新式类中存在
# super 只在python3中存在
# super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

继承小结：

# 继承 ： 什么是什么的关系
# 单继承 *****
    # 先抽象再继承，几个类之间的相同代码抽象出来，成为父类
    # 子类自己没有的名字，就可以使用父类的方法和属性
    # 如果子类自己有，一定是先用自己的
    # 在类中使用self的时候，一定要看清楚self指向谁
# 多继承 ***
    # 新式类和经典类：
        # 多继承寻找名字的顺序 ： 新式类广度优先，经典类深度优先
        # 新式类中 有一个类名.mro方法，查看广度优先的继承顺序
        # python3中 有一个super方法，根据广度优先的继承顺序查找上一个类

转载于:https://www.cnblogs.com/ddjl/p/8335855.html