python3--object类，继承与派生，super方法，钻石继承问题

发布时间：2018-04-13 20:38:05编辑：Run阅读(1914)

昨天内容复习

组合：什么有什么的关系(例:老师有生日)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完成了

例1class 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()打印出寻找类的顺序

[, , , , , , ]

在python2.x中，经典类多继承使用深度优先原则

在python2.x中，不手动继承object类，都属于经典类

深度优先，一条路走到底，找不到就会回来找其他的

经典类：在python2.x版本才存在，且必须不继承object

遍历的时候遵循深度优先算法

没有mro方法

没有super()方法

新式类：在python2.x版本中，需要继承object，才是新式类

遍历的时候遵循广度优先算法

在新式类中，有mro方法

有super()方法，但是在2.x版本的解释器中，必须传参数(子类名,子类对象)

关键字：