面向对象 继承

class Cat:
    def __init__(self,name):
        self.name = name

    def call(self):
        print('喵喵叫')
    def eat(self):
        print('%s吃' % self.name)
    def drink(self):
        print('%s喝' % self.name)
    def pull(self):
        print('%s拉' % self.name)
    def sow(self):
        print('%s撒' % self.name)
    def sleep(self):
        print('%s睡' % self.name)


class Dog:
    def __init__(self, name):
        self.name = name

    def call(self):
        print('汪汪叫')

    def eat(self):
        print('%s吃' % self.name)

    def drink(self):
        print('%s喝' % self.name)

    def pull(self):
        print('%s拉' % self.name)

    def sow(self):
        print('%s撒' % self.name)

    def sleep(self):
        print('%s睡' % self.name)

class Chook:
    def __init__(self, name):
        self.name = name

    def call(self):
        print('大爷,来玩呀....')

    def eat(self):
        print('%s吃' % self.name)

    def drink(self):
        print('%s喝' % self.name)

    def pull(self):
        print('%s拉' % self.name)

    def sow(self):
        print('%s撒' % self.name)

    def sleep(self):
        print('%s睡' % self.name)

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print('%s吃' % self.name)

    def drink(self):
        print('%s喝' % self.name)

    def pull(self):
        print('%s拉' % self.name)

    def sow(self):
        print('%s撒' % self.name)

    def sleep(self):
        print('%s睡' % self.name)

class Cat(Animal):

    def call(self):
        print('喵喵叫')

class Dog(Animal):

    def call(self):
        print('汪汪叫')
class Chook:
    def call(self):
        print('大爷,来玩呀....')

cat1 = Cat('阿花')
cat1.eat()
cat1.drink()
chook1 = Chook()
chook1.call()

继承:子类继承父类的一切.
class Cat(Animal)
Animal 叫做父类,也叫作基类.
Cat 叫做子类,也叫作派生类.

继承:子类继承父类的一切.

小练习:
Animal 父类, 人,猫,狗 name,年龄,性别,父类里面再写一个方法:eat
继承最大的特点节省代码.与其他类发生关联.

class Animal:
    nickname = '动物'
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print("%s在吃东西" % self.name)
class Person(Animal):
    pass
class Dog(Animal):
    pass
class Cat(Animal):
    pass
p1 = Person('太白',25,'男')
p1.eat()
dog1 = Dog('日天',6,'公')
dog1.eat()
print(p1.nickname)
为什么子类能找到父类的所有?? 存在父类指针的概念
print(Person.nickname)
类名,对象都可以找到父类的所有方法.

为什么子类能找到父类的所有?? 存在父类指针的概念
类名,对象都可以找到父类的所有方法.

继承去分:
单继承,多继承.
单继承: 查询顺序一直向上(新式类,经典类一样.).
python3x   python2x区别:
python3x 类默认都继承object,继承object类的类叫做新式类.
python2x 类默认什么不都继承,不继承object的类叫做经典类.如果在python2x中,你让他继承object类,就变成新式类了.

class Animal:
    nickname = '动物'

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

    def eat(self):
        print("%s在吃东西" % self.name)


class Person(Animal):

    def speek(self):
        print('%s可以用语言交流' % self.name)


class Brid(Animal):

    def __init__(self, name, age, sex, wing):  # self = b1 对象空间
        # Animal.__init__(self,name,age,sex)  # 第一种 如何在子类中执行父类方法
        super(Brid,self).__init__(name, age, sex)  # 第二种  如何在子类中执行父类方法
        self.wing = wing

    def eat(self, food):
        super().eat()
        print('%s吃%s' % (self.name, food))

    def bite(self):
        print('%s可以啄人' % self.name)


p1 = Person('太白',25,'男')
print(p1.nickname)

b1 = Brid('鹦鹉', 12, '母', '大翅膀')
b1.eat('小米')
print(b1.__dict__)
b1.eat('小米')
def func1(y,z,w):
    print(666)
def func(x,y,z,w):
    func1(y,z,w)
func(1,2,3,4)
在子类中,执行父类的方法
Animal.__init__(self,name,age,sex)  # 第一种
用这种: super().__init__(name, age, sex)  # 第二种  完整的写法 super(Brid,self).__init__(name, age, sex) 不提倡   第二种#完整的写法 

多继承:
新式类 : 广度优先

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

class B(A):

    def func(self):
        print('B')

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

class D(B,C):

    def func(self):
        print('D')

d = D()
d.func()

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

class B(A):

    def func(self):
        print('B')

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

class D(B):
    def func(self):
        print('D')
class E(C):
    def func(self):
        print('E')

class F(D,E):
    def func(self):
        print('F')

d = F()
d.func()
print(F.mro())

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

class B(A):

    def func(self):
        print('B')

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

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

class F(D,E):
    def func(self):
        print('F')

d = F()
d.func()
print(F.mro())   #查出所有顺序

经典类 : 深度优先

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

class B(A):

    def func(self):
        print('B')

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

class D(B,C):

    def func(self):
        print('D')

d = D()
d.func()

 

面向对象的三大特性：
三大特性：
继承 *****
多态*
封装***
单继承 —— 所有面向对象语言都支持
class 另外一个类名():pass         （父类  超类  基类）
class 类名（另外一个类名）：pass     （子类， 派生类）
print(类名.__bases__)  #可以去查看父类
多继承——Python
class另类1()：pass
class另类2()：pass
class类名(另类1，另类2)：pass
print(类名.__bases__)  #可以去查看父类
print(类名1.__bases__)  #可以去查看父类
object类是所有类的基类（是所有类的祖先）

class ParentClass1:
    def __init__(self,name):
        self.name = name
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass
taibai= SubClass1('哮天犬')
print(SubClass1.__bases__)

继承的作用:代码的重用性

class Role:
    def __init__(self,name,hp,ad):
        print('in Role init')
        self.name = name
        self.hp = hp
        self.ad = ad
class Person(Role):
    def __init__(self,name,sex,hp,ad):
        self.sex = sex
        Role.__init__(self,name,hp,ad)
    def attack(self,dog):
        dog.hp -= self.ad
class Dog(Role):
    def bite(self,Person):
        Person.hp -= self.ad
# 继承——代码的重用性
alex = Person('alex',None,100,1)
print(alex.__dict__)

继承的语法，在子类定义的时候括号里父类的名字
对象在寻找名字的时候：先找自己对象空间里 —>再找自己的类的空间里的 ->父类的空间里的
在自己的类中调用父类中的同名方法，指名道姓（需要自己传self参数），super方法（不需要自己传self参数）

面试题：

class Foo:
    def __init__(self):
        self.func()
    def func(self):print('in foo')
class Son(Foo):
    def func(self):print('in son')
Son()   #in  son

继承：什么是什么的关系
节省两个类之间共有的方法或者代码
如果子类和父类的一样，那么可以省略子类的，用父类的
如果是子类特有的，用子类的 —— 派生
如果两个方法，子类也有父类也有，用子类的
如果两个方法，子类也有父类也有，想用父类的：指名道姓，super

class Role:
    def __init__(self,name,hp,ad):
        print('in Role init')
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print('%s回了10点血'%self.name)
        self.hp += 10
class Person(Role):
    def __init__(self,name,sex,hp,ad):
        self.sex = sex                     # 派生属性
        self.money = 100
        Role.__init__(self,name,hp,ad)     # 指名道姓
        # super().__init__(name,hp,ad)                   # super()代表父类
        # super(Person,self).__init__(name,hp,ad)                   # super()代表父类
    def attack(self,dog):                  # 派生方法
        dog.hp -= self.ad
    def eat(self):
        if self.money >= 10:
            self.money -= 10
            # super().eat()
            Role.eat(self)
class Dog(Role):
    def __init__(self,name,kind,hp,ad):
        super().__init__(name,hp,ad)
        self.kind = kind                 # 派生属性
    def bite(self,person):
        person.hp -= self.ad

钻石继承：
找一个名字，如果这个名字在子类不存在，就会遵循一个顺序往上找。
继承关系会形成一张图，每一个类都是这个图中的节点
寻找顺序会把图中的每一个节点都找且只找一次———— 遍历算法
python3里面的所有类都是新式类
新式类的遍历算法遵循——广度优先规律

钻石继承 —— 4个类图形
D-> B -> C -> A
class A:
    def func(self):print('in A')
class B(A):
    def func(self):print('in B')
class C(A):
    def func(self):print('in C')
class D(B,C):
    def func(self):print('in D')
d = D()
d.func()    # in D

算法——路程相对最短，且最合理

找下一个点的时候，首先往深度走，但是如果这个深度的类以后还会有机会找到，那么就从广度找

class A:
    def func(self):print('in A')
class E(A):
    def func(self):print('in E')
class F(A):
    def func(self):print('in F')
class B(E):pass
class C(F):
    def func(self):print('in C')
class D(B,C):pass
print(D.mro())#D->B->E->C->F->A

supper  面试题:

class A:
    def func(self):
        print('A')
class B(A):
    def func(self):
        print('B')
        super().func()
class C(A):
    def func(self):
        print('C')
        super().func()
class D(B,C):
    def func(self):
        print('D')
        super().func()
#D().func()  #Dmro(） #D->B->C->A
# B().func()  #B().mro()#B->A
# print(B.mro())# B->A

super 并不是单纯的找父类，和mro顺序是完全对应的
新式类：继承object类的类，找名字的时候广度优先的顺序
新式类 : python3里全部都是新式类默认继承object
python2里面：
       新式类  主动继承object
       经典类 不主动继承object  ——遵循深度优先遍历算法，没有mro方法，没有super