python3--object类，继承与派生，super方法，钻石继承问题
python3--object类，继承与派生，super方法，钻石继承问题
昨天内容复习
组合：什么有什么的关系(例:老师有生日)
class Birthday:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def fmt(self):
return '{}-{}-{}'.format(self.year, self.month, self.day)
class Teacher:
def __init__(self, name, birth):
self.name = name
self.birthday = birth
def birth_month(self):
self.birthday.fmt() # 引用组合对象的方法
return self.birthday.month # 引用组合对象的属性
birth = Birthday(1979, 10, 20)
sam = Teacher('Tom', birth) # 将对象birth传进来作为实例化Teacher的属性
print(sam.birthday.year) # 调用组合对象中的属性
print(sam.birthday.fmt()) # 调用组合对象中的方法执行结果
1979
1979-10-20
总结：组合就是把一个对象，作为另外一个类的属性
继承
猫
属性:名字 性别，品种
方法:吃 喝 爬树
狗
属性:名字 性别 品种
方法:吃 喝 看门
例
class Animal:
def __init__(self, name, sex, kind):
self.name = name
self.sex = sex
self.kind = kind
def eat(self):
print('{} is eating'.format(self.name))
def drink(self):
print('{} is drinking'.format(self.name))
class Cat(Animal):
def climb(self):
print('{} is climbing'.format(self.name))
class Dog(Animal):
def watch_door(self):
print('{} is watching door'.format(self.name))
# 1 确认自己没有init方法
# 2 看看有没有父类
# 3 发现父类Animal有init
# 4 看着父类的init方法来传参数
tom = Cat('小黑', '公', '波斯猫')
sam = Dog('旺财', '公', '哈士奇')
print(Cat.__dict__) # Cat.__dict__ Cat类的命名空间中的所有名字
print(tom.__dict__) # tom.__dict__ 对象的命名空间中的所有名字
print(Dog.__dict__) # Dog.__dict__ Dog类的命名空间中的所有名字
print(sam.__dict__) # sam.__dict__ 对象的命名空间中的所有名字
tom.eat()
tom.climb()
sam.drink()
sam.watch_door()执行结果
{'climb':
{'kind': '波斯猫', 'name': '小黑', 'sex': '公'}
{'__doc__': None, '__module__': '__main__', 'watch_door':
{'kind': '哈士奇', 'name': '旺财', 'sex': '公'}
小黑 is eating
小黑 is climbing
旺财 is drinking
旺财 is watching door
object类
class A:pass
a = A()
print(A.__bases__)执行结果,可以看到A的父类为object,在python3中，只有新式类，默认继承object类
(
上面代码的执行步骤
1 创建了一个空的对象
2 调用init方法 -- class A里面没有写init方法，怎么不报错？执行了父类object的__init__方法
3 将初始化之后的对象返回调用出
在python3中所有的类都继承了object类
查看object的源码
里面包含了__init__方法
object带双下划线的方法，有2个名字，比如双下方法，魔术方法
任何实例化都经历3步，如果类没有init,由object完成了
例1
class Animal:
def __init__(self, name, hp, ad):
self.name = name
self.hp = hp
self.ad = ad
def eat(self):
print('{}吃药回血了'.format(self.name))
class Person(Animal):
def attack(self, dog): # 派生方法
print('{}攻击了{}'.format(self.name, dog.name))
class Dog(Animal):
def bite(self, person): # 派生方法
print('{}咬了{}'.format(self.name, person.name))
sam = Person('Sam', 10, 20) # 实例化一个对象sam,
dog = Dog('花花', 10, 5) # 实例化一个对象dog
print(sam.__dict__)
print(dog.__dict__)执行结果,打印对象属性
{'hp': 10, 'name': 'Sam', 'ad': 20}
{'hp': 10, 'name': '花花', 'ad': 5}
子类有的方法，叫派生方法
比如人有sex,狗有kind，现在需要在上面的例子中，给人额外加一个属性，狗额外加一个属性，那么首先想到的是在init里面加，如下
例
class Animal:
def __init__(self, name, hp, ad):
self.name = name
self.hp = hp
self.ad = ad
def eat(self):
print('{}吃药回血了'.format(self.name))
class Person(Animal):
def __init__(self, sex):
self.sex = sex
def attack(self, dog): # 派生方法
print('{}攻击了{}'.format(self.name, dog.name))
class Dog(Animal):
def __init__(self, kind):
self.kind = kind
def bite(self, person): # 派生方法
print('{}咬了{}'.format(self.name, person.name))
sam = Person('男') # 实例化类Person,传一个参数性别
dog = Dog('哈士奇') # 实例化类Dog,传一个参数品种
print(sam.__dict__) # 打印对象sam的属性
print(dog.__dict__) # 打印对象dog的属性执行结果
{'sex': '男'}
{'kind': '哈士奇'}
why？为什么之前的属性都没有了，因为自己有了init后，它不会执行父类的init方法，那么如何执行父类的init呢？
有两种方法,第一种
class Animal:
def __init__(self, name, hp, ad):
self.name = name
self.hp = hp
self.ad = ad
def eat(self):
print('{}吃药回血了'.format(self.name))
class Person(Animal):
def __init__(self, name, hp, ad, sex):
Animal.__init__(self, name, hp, ad)
self.sex = sex
def attack(self, dog): # 派生方法
print('{}攻击了{}'.format(self.name, dog.name))
class Dog(Animal):
def __init__(self, name, hp, ad, kind):
Animal.__init__(self, name, hp, ad)
self.kind = kind
def bite(self, person): # 派生方法
print('{}咬了{}'.format(self.name, person.name))
sam = Person('Sam', 10, 20, '男')
dog = Dog('花花', 10, 5, '哈士奇')
print(sam.__dict__)
print(dog.__dict__)执行结果
{'ad': 20, 'name': 'Sam', 'sex': '男', 'hp': 10}
{'kind': '哈士奇', 'ad': 5, 'name': '花花', 'hp': 10}
可以看到,父类的属性也继承了，自己添加的属性也有，怎么实现的？
当执行init之前，开辟内存空间，self执行的是同一块内存空间，sam里面的self，指向都是一样的，在同一个类里面，self指向的都是同一个，如下图
第二种写法
class Animal:
def __init__(self, name, hp, ad):
self.name = name
self.hp = hp
self.ad = ad
def eat(self):
print('{}吃药回血了'.format(self.name))
class Person(Animal):
def __init__(self, name, hp, ad, sex):
super().__init__(name, hp, ad)
self.sex = sex
def attack(self, dog): # 派生方法
print('{}攻击了{}'.format(self.name, dog.name))
class Dog(Animal):
def __init__(self, name, hp, ad, kind):
super().__init__(name, hp, ad)
self.kind = kind
def bite(self, person): # 派生方法
print('{}咬了{}'.format(self.name, person.name))
sam = Person('Sam', 10, 20, '男')
dog = Dog('花花', 10, 5, '哈士奇')
print(sam.__dict__)
print(dog.__dict__)执行结果
{'name': 'Sam', 'hp': 10, 'sex': '男', 'ad': 20}
{'name': '花花', 'hp': 10, 'kind': '哈士奇', 'ad': 5}
在单继承中，super负责找到当前类(也就是Person和Dog的父类Animal)所在的父类，在这个时候不需要再手动传self
修改上面例子，增加新的需求：人吃药要钱，狗吃药不要钱
class Animal:
def __init__(self, name, hp, ad):
self.name = name
self.hp = hp
self.ad = ad
def eat(self):
print('eating in Animal')
self.hp += 20
class Person(Animal):
def __init__(self, name, hp, ad, sex):
super().__init__(name, hp, ad)
self.sex = sex
self.money = 100 # 设置初始钱为100
def attack(self, dog): # 派生方法
print('{}攻击了{}'.format(self.name, dog.name))
def eat(self):
super().eat() # super()方法找到父类，父类点eat(),执行父类里面的eat()方法
print('eating in Person')
self.money -= 50
class Dog(Animal):
def __init__(self, name, hp, ad, kind):
super().__init__(name, hp, ad)
self.kind = kind
def bite(self, person): # 派生方法
print('{}咬了{}'.format(self.name, person.name))
sam = Person('Sam', 10, 20, '男')
dog = Dog('花花', 10, 5, '哈士奇')
sam.eat()
print(sam.__dict__)
print(dog.__dict__)执行结果
eating in Animal
eating in Person
{'sex': '男', 'ad': 20, 'money': 50, 'name': 'Sam', 'hp': 30}
{'ad': 5, 'kind': '哈士奇', 'name': '花花', 'hp': 10}
继承
父类是新式类，那么继承的子类全部都是新式类,python3里面没有经典类
单继承 新式类
多继承 新式类(也叫钻石继承)
例子
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()执行结果,why？
D
龟壳模型
新式类 多继承 寻找名字的顺序 遵循广度优先
super在多继承中，是找下一个节点的，而不是找父类的！
总结，在python3中都是新式类，使用的是广度优先原则
super()
在单继承中就是单纯的寻找父类
在多继承中就是根据子节点所在图的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):
def func(self):
print('D')
class E(C):
def func(self):
print('E')
class F(D,E):
def func(self):
print('F')
st = F()
print(F.mro())使用F.mro()打印出寻找类的顺序
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
在python2.x中，经典类多继承使用深度优先原则
在python2.x中，不手动继承object类，都属于经典类
深度优先，一条路走到底，找不到就会回来找其他的
经典类：在python2.x版本才存在，且必须不继承object
遍历的时候遵循深度优先算法
没有mro方法
没有super()方法
新式类：在python2.x版本中，需要继承object，才是新式类
遍历的时候遵循广度优先算法
在新式类中，有mro方法
有super()方法，但是在2.x版本的解释器中，必须传参数(子类名,子类对象)
腾讯云开发者
