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) # 抽象 # 继承 # 组合 ：什么有什么 # 继承 ：什么是什么的关系 # 先想描述的对象 # 先写出对象所对应的类 # 发现多个类之间有相同的代码 # 把相同的代码提取出来，搞成一个父类 # 先抽象，再继承 # 对象 -->类 -->基类 # 基类 -继承-> 子类 -实例化-> 对象
