面向对象 继承
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
posted on 2018-06-29 19:59 liangliang123456 阅读(121) 评论(0) 编辑 收藏 举报
