继承

# 继承的初识
# # # 面向对象的三大特性  继承，封装，多态
# # # 继承
# #
# # class Animal:
# #     breath = "呼吸"
# #     def __init__(self, name, sex, age):
# #         self.name = name
# #         self.sex = sex
# #         self.age = age
# #
# #     def sleep(self):
# #         print("睡觉")
# #        return -1

# #
# # class Person(Animal):    # 括号里面的为父类，基类，超类。括号外面的子类，派生类
# #     pass
# #
# #
# # p1 = Person("ly", "m", 99)
# #
# # # 子类以及子类实例化的对象可以访问父类的任意属性或者方法
# # print(p1.__dict__)
# # print(Person.breath)
# # print(p1.sleep())   # 实例对象·现在本类里面找，找不到就去父类，再找不到就去更上层的类。值到基类
# #
#
#
# class Animal:
#     def __init__(self, name, sex, age):
#         self.name = name
#         self.sex = sex
#         self.age = age
#
#     def eat(self, a1):
#         print("{}吃{}".format(self.name,a1))
#
#     def sleep(self):
#         print("{}睡".format(self.name))
#
#     def shit(self):
#         print("{}拉".format(self.name))
#
# class Dog(Animal):
#
#     def barking(self):
#         print("犬吠")
#
#
# class Duck(Animal):
#
#     def swimming(self):
#         print("鸭泳")
#
# class Cat(Animal):
#
#     def meow(self):
#         print("猫叫")
#
# # dog1 = Dog("嘟嘟", "s", 6)
# # dog1.sleep()
# # dog1.barking()
#
#
#
# # 既要执行子类的方法，也要执行父类的方法
#
#
# class Bird(Animal):
#     def __init__(self, sex, name, age, wing):  #  这里可以看作是5个形参
#         # 第一种方法，不常用
#         # Animal.__init__(self, name, sex, age)  # 这里把前四个实参交给父类的方法执行
#
#         # 第二种
#         # super(Bird, self).__init__(name,sex,age)
#         # 可以简写为
#         super().__init__(name,age,sex)  #常用
#         self.wing = wing
#
#     def eat(self,argv):
#         super().eat(argv)
#         print("11是头猪")


# b1 = Bird("公", "扁嘴", "6", "红翅膀，")
# b1.eat("猪")



# 继承的进阶
#继承：但继承，多继承
# 经典类，新式类。凡是继承Object都是新式类，python3中都是新式类，都默认继承Objecr, python2重默认不继承object，但可以手动继承
# 单继承。经典类和新式类查询一样，都是从下往上找


# class A:
#     def func(self):
#         print("In A")
#
# class B(A):
#     def func(self):
#         print("In B")
#
# class C(B):
#     # def func(self):
#     #     print("In C")
#     pass
# c1 = C()
# c1.func()


# 多继承。 对于新式类遵循广度优先(钻石继承)， 经典类 深度优先

class A:
    # def func(self):
    #     print("In A")
    pass

class B(A):
    # def func(self):
    #     print("In B")
    pass

class C(A):
    def func(self):
        print("In C")
    pass

class G(A):
    # def func(self):
    #     print("In G")
    pass

class D(B,G):
    # def func(self):
    #     print("In D")
    pass

class E(C):
    def func(self):
        print("In E")
    pass

class F(D,E):
    # def func(self):
    #     print("In F")
    pass


f = F()
f.func()  # 广度优先每个节点只走一次.如果后面的路线可以走到那个节点，则之前不会去走
print(F.mro())  # 可以查询继承类的顺序，
                # 广度优先[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.G'>, <class '__main__.A'>, <class 'object'>]


# 深度优先需要在python2 里面尝试 F ,D，B，A,G, E，C，
#只能是继承两个类的情况(继承两个类以上太复杂的则看mro吧)
# 广度优先一条线路走到倒数第二级，判断最后一级其他路能不能到达，如果能，则不走，不能，则走
# 深度优先，一条线路走到底


# 继承的优点：
    1.节省代码
    2.规范代码
   只执行类的方法
   只执行父类的方法
   执行本类和父类的方法
        父类名.方法名(参数)
        super().方法名(参数)