18 继承,单继承,多继承,新式类,经典类.新式类遵循广度优先. 经典类遵循深度优先.

主要内容:

1. 继承的初始

　　a: 子类以及子类实例化的对象,可以访问父类的任何方法或变量.

　　b:  类名可以访问父类中的所有内容

　　c:  子类实例化的对象也可以访问父类的所有内容

class Animal:
    breath = '呼吸'
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print(self)
        print('动物都需要进食....')
class Person(Animal):  # 括号里面的 父类,基类,超类   括号外面的 子类,派生类.
    pass
p1 = Person('alex', 'laddyboy', 1000)
print(p1.__dict__)
# # 初识继承:
# # 子类以及子类实例化的对象 可以访问父类的任何方法或变量.
print(p1.breath)
# # 类名可以访问父类所有内容
print(Person.breath)
Person.eat(111)

　　d:  只执行父类的方法:子类中不要定义与父类同名的方法,要不然会先执行子类中的方法,父类中的方法不会执行.

　　e:  只执行子类的方法:  在子类创建这个方法.

　　f :   既要执行子类的方法,又要执行父类的方法:

　　　　1) : 类名.方法名(self,变量)

　　　　2) : super().方法名(变量)       #自动执行父类中的__init__方法   
　　　　　　　                                   　super()  作用 :  在子类中调用父类的方法.

class Animal:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self):
        print('%s要吃....' % self.name)
    def drink(self):
        print('要喝水....')
class Cat(Animal):
    def miaow(self):
        print('喵喵叫')
class Bird(Animal):
    def __init__(self,name,age,sex,ring):
        # Animal.__init__(self,name,age,sex)     #类名.方法名(self,变量)
        super().__init__(name,age,sex)           #super(Bird,self)  #自动执行__init__方法
        self.ring = ring
    def sing(self):
        print('鸟会唱歌...')
b1 = Bird('鹦鹉',23,'公','绿翅膀')
print(b1.__dict__)

　　给方法传了一个参数

class Animal:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self,a):
        print('%s要吃....%s' % (self.name,a))
    def drink(self):
        print('要喝水....')
class Cat(Animal):
    def miaow(self):
        print('喵喵叫')
    def eat(self,a):
        super().eat(a)
        print('吃..')
# 既要执行子类中的吃,又要执行父类中的吃.
p1 = Cat('花花',2,'母')
p1.eat('老鼠')    #传了一个值

2.  经典类,新式类

　　a:  新式类:凡是继承object类都是新式类;python3  中所有的类都是新式类,因为python3 中默认继承object

　　b:  经典类:不继承object类都是经典类

　　　　python2 :既有新式类又有经典类,所有的类都默认不继承object类,所有的类默认都是经典类.

　　　　　　　　你可以让其继承object,成为新式类.

　　单继承:新式类,经典类查询顺序一样.

class A:
    # pass
    def func(self):
        print('IN A')

class B(A):
    pass
    # def func(self):
    #     print('IN B')

class C(B):
    pass
    # def func(self):
    #     print('IN C')

c1 = C()
c1.func()

　　多继承:新式类:遵循广度优先.

　　　　　经典类:遵循深度优先.

　　多继承的新式类:  一条路走到倒数第二级,判断,如果其他路能走到终点,则返回走另一条路,如果不能,则走到终点.

　　多继承的经典类:  一条路走到黑.

　　类名.mro():    查询类的继承顺序.

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

class B(A):
    pass
    # def func(self):
    #     print('IN B')
class C(A):
    pass
    # def func(self):
    #     print('IN C')
class D(B):
    pass
    # def func(self):
    #     print('IN D')
class E(C):
    pass
    # def func(self):
    #     print('IN E')
class F(D,E):
    pass
    # def func(self):
    #     print('IN F')
f1 = F()
f1.func()

　继承的面试题1:

class Parent:
    def func(self):
        print('in Parent func')

    def __init__(self):
        self.func()

class Son(Parent):
    def func(self):
        print('in Son func')

son1 = Son()          #类名加()实例化一个对象,创建一个son1对象空间,自动执行__init__方法,现在son1对象空间找,如果没有找到,到
                      # 父类中找,找到了,然后执行func函数,现在子类中找,看有没有func函数,如果有就执行,没有去父类中找.