python学习 day20 (3月27日)----(单继承多继承c3算法）

继承：

　　　　提高代码的重用性，减少了代码的冗余

　　这两个写法是一样的

　　Wa('青蛙').walk()    #青蛙 can walk

　　wa = Wa('青蛙')

　　wa.walk()           #青蛙 can walk

1.单继承
麻烦的写法（为什么要有单继承）
　　如果多个类相似的情况下（每个都写一遍有大量重复 浪费麻烦）

class Tiger(object):

    def __init__(self,name):

        self.name = name

    def walk(self):

        print('%s can walk'%self.name)

    def swim(self):

        print('%s can swim'%self.name)

Tiger('老虎').walk()

class Swan(object):

    def __init__(self,name):

        self.name = name

    def walk(self):

        print('%s can walk'%self.name)

    def fly(self):

        print('%s can fly'%self.name)

Swan('鹦鹉').fly()

class Wa(object):

    def __init__(self,name):

        self.name = name

    def walk(self):

        print('%s can walk'%self.name)

    def swim(self):

        print('%s can swim' % self.name)

Wa('青蛙').walk()    #青蛙 can walk

wa = Wa('青蛙')

wa.walk()           #青蛙 can walk

class Er(object):

    def __init__(self,name):

        self.name = name

    def walk(self):

        print('%s can walk'%self.name)

    def swim(self):

        print('%s can swim' % self.name)

    def fly(self):

        print('%s can fly'%self.name)

# Er('天鹅').swim()

Er('天鹅').fly()

继承

　　创建一个父类

　　子类用父类的属性和方法因为都差不多

　　子类也可以新建自己特殊的属性和方法，通过super().__init__(相同元素) 和父类名.__init__(self,相同元素)

　　方法的话自己新建不必返回父类

class Animal(object):

    def __init__(self,name,kind):

        self.name = name

        self.kind = kind            #多了不是很好

    def walk(self):

        print('%s can walk'%self.name)

    def swim(self):

        print('%s can swim' % self.name)

    def fly(self):                  #可以有任意个

        print('%s can fly'%self.name)

class Tiger(Animal):pass

class Bird(Animal):

    def __init__(self,name,kind,eyes_color):  #小心 元素必须与父类相同

        # super().__init__(name,kind)

        # super(Bird,self).__init__(name,kind)  #注意 括号前面的元素是子类 当前类  告诉父类

        Animal.__init__(self,name,kind)     #注意 没有括号

        self.eyes_color = eyes_color  #自己的属性 自己赋值

    def say(self):

        print("%s can say like people"%self.name)

laohu = Tiger('老虎','公')      # 实参与形参一一对应  即动物的属性此对象都有 也麻烦

print(laohu.walk(),laohu.fly(),laohu.name)        # 父类的方法和属性都可以用了 继承

yingwu = Bird('鹦鹉','公','blue')      # 最好变量名 有意义  不是 abcd 。。。

print(yingwu.fly(),yingwu.eyes_color,yingwu.say())

多继承

引子：

各种动物，每一种动物都是一个类

青蛙、天鹅、老虎、鹦鹉

青蛙 ：走，游泳

天鹅 ：走，游泳，飞

老虎 ：走，游泳

鹦鹉 ：走，飞，说话

class FlyAnimal:

    def fly(self):pass

class SwimAnimal:

    def swim(self):pass

    def eat():pass

class WalkAnimal:

    def walk(self):pass

    def eat():pass

class Frog(SwimAnimal,WalkAnimal): pass

class Tiger(SwimAnimal,WalkAnimal):pass

class Swan(FlyAnimal,SwimAnimal,WalkAnimal):pass

class Parrot(FlyAnimal,WalkAnimal):

    def talk(self):

        pass

class Frog(SwimAnimal,WalkAnimal): pass
class Tiger(SwimAnimal,WalkAnimal):pass
class Swan(FlyAnimal,SwimAnimal,WalkAnimal):pass
class Parrot(FlyAnimal,WalkAnimal):
def talk(self):
　　pass

多继承 是python语言中特有的继承方式

java语言中不支持多继承的，C# 也不支持多继承

C++支持多继承

c c++ c# java

多继承和单继承是一样的

    如果对象使用名字

    是子类中有的，那么一定用子类的

    子类没有，可以到多个父类中去寻找

如果多个和父类都有，那么用谁的

 如果父类子类都想用，super(),父类名.方法名

算法：
1钻石继承问题

代码实现：

钻石继承问题

class A(object):

    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()

　　逐个隐藏函数来查看调用顺序

# super().func() 左想

class A(object):

    def func(self):

        print('a',end='')

class B(A):

    pass

    def func(self):

        super().func()

        print('b',end='')

class C(A):

    pass

    def func(self):

        super().func()

        print('c',end='')

class D(B,C):

    pass

    def func(self):

        super().func()

        print('d',end='')

b = B()

b.func()

print()

d = D()

d.func()

# 在多继承中，super就只和mro顺序有关系，和父类子类没有关系了

2乌龟继承顺序

代码实现：

乌龟继承问题

class A(object):

    def func(self):

        print('a')

class B(A):

    pass

    # def func(self):

    #     print('b')

class C(A):

    pass

    # def func(self):

    #     print('c')

class D(B):

    pass

    # def func(self):

    #     print('d')

class E(C):

    pass

    # def func(self):

    #     print('e')

class F(D,E):

    pass

    # def func(self):

    #     print('f')

f = F()

f.func()

过程实现：

# C3算法

# A= [AO]

# B = B ,B节点的父类对应的顺序

# B = B ,A节点顺序

# B = B ,[AO]

# 提取第一个点

    # 如果从左到右第一个类，

    # 在后面的继承顺序中也是第一个，或者不再出现在后面的继承顺序中

    # 那么就可以把这个点提取出来，作为继承顺序中的第一个类

# B = [AO]

# BA = [O]

# B这个节点的继承顺序 ：[BAO]

# C = C,[AO]

# C = [AO]

# CA = [O]

# C这个节点的继承顺序 :[CAO]

# l(D) = D + [BAO]

# D = [BAO]

# [DBAO]

# l(E) = E + [CAO]

# [ECAO]

# L[F] = F,[BAO],[ECAO]

# [F] = [DBAO],[ECAO]

# [FD] = [BAO],[ECAO]

# [FDB] = [AO],[ECAO]

# [FDB] = [AO],[ECAO]

# [FDBE] = [AO],[CAO]

# [FDBEC] = [AO],[AO]

# [FDBECA] = [O],[O]

# [FDBECAO]

广度优先

    C3算法

99%的情况都可以用眼睛看出来

但是仍然有1%的情况是看不出来的

C3算法是怎么计算的

C3算法代码实现

class A(object):

    def func(self):

        print('a')

class B(A):

    pass

    def func(self):

        print('b')

class C(A):

    pass

    def func(self):

        print('c')

class F:

    pass

    def func(self):

        print('f')

class D(A,F):

    pass

    # def func(self):

    #     print('d')

class E(B,C,F):

    pass

    def func(self):

        print('e')

class G(C,D):

    pass

    def func(self):

        print('g')

class H(E,G):

    pass

    def func(self):

        print('h')

print(H.mro())   # 就是帮助我们来展示c3算法的继承顺序

在python2.7中

　　主动继承object才是新式类，默认是经典类

# coding:utf-8

# 新式类 继承object

# 经典类 只在py2.x中有 默认不继承object

# 多继承

# 遵循的是深度优先

class A:pass

    # def func(self):

    #     print('a')

class B(A):

    pass

    # def func(self):

    #     print('b')

class C(A):

    pass

    def func(self):

        print('c')

class D(B,C):pass

    # def func(self):

    #     print('d')

d = D()

d.func()

继承总结

单继承
    子类有的就用子类的
    没有的就用父类的
    如果父类子类都想用，super(),父类名.方法名
多继承
    新式类 ：
          继承object
          py2 要主动继承object才是新式类，默认是经典类
                    python2   必须 super(现在类，self) 传给父类(object)
          遵循的是广度优先算法，C3算法
          有super()的，super遵循mro顺序的
          有mro()方法

    经典类 ：
          不继承object
          多个类之间去寻找方法的时候遵循深度优先
          没有super方法
          也没有mro
          只在python2 中存在

人狗大战：

　　继承写法

class Animal(object):

    def __init__(self,name,blood,ad):

        self.name = name

        self.hp = blood

        self.ad = ad

class Dog(Animal):

    def __init__(self,name,blood,ad,kind):

        super().__init__(name,blood,ad)

        self.kind = kind

    def bite(self,person):

        person.hp -= self.ad

        print('%s攻击了%s，%s掉了%s点血' % (self.name, person.name, person.name, self.ad))

class Person(Animal):

    def __init__(self,name,hp,ad,sex):

        super().__init__(name,hp,ad)

        self.sex = sex

    def fight(self,dog):

        dog.hp -= self.ad

        print('%s攻击了%s，%s掉了%s点血'%(self.name,dog.name,dog.name,self.ad))

hei = Dog('小黑',300,20,'哈士奇')

alex = Person('alex',20,1,'不详')

alex.fight(hei)

print(hei.hp)

hei.bite(alex)

print(alex.hp)

# 抽象

# 继承

# 组合 ：什么有什么

# 继承 ：什么是什么的关系

    # 先想描述的对象

    # 先写出对象所对应的类

    # 发现多个类之间有相同的代码

    # 把相同的代码提取出来，搞成一个父类

# 先抽象，再继承

# 对象 -->类 -->基类

# 基类 -继承-> 子类 -实例化-> 对象

巴特西

python学习 day20 (3月27日)----(单继承多继承c3算法）

最新文章

热门文章