Python 继承与多继承

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

相关知识点：

__class__.__name__的用法。

>>> class ABC:
def func(self):
print('打印类名：',__class__.__name__) #__class__一个类实例所属的类对象，__name__类或者函数的名字>>> a = ABC() #实例化一个对象
>>> a.func() #使用实例调用函数，通过__class__.__name__这个方法，会打印出实例 a 所属的类的名字
打印类名： ABC
>>>

raise 方法：

>>> 1/0 #程序的异常
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
1/0
ZeroDivisionError: division by zero
>>> raise ZeroDivisionError('division by zero') #使用raise，自动丢出异常（人为异常/自动异常）
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
raise ZeroDivisionError('division by zero')
ZeroDivisionError: division by zero
>>>

练习：

假设你正在参与一个魔幻类角色游戏的开发，公司需要你为这个游戏设计两个角色的类：

1.剑士
具有如下属性：
角色名
角色等级
生命值
攻击力
具有如下行为：
物理攻击

2.法师
具有如下属性：
角色名
角色等级
生命值
法术强度
具有如下行为：
法术攻击
治疗

练习题解答1：

剑士和法师单纯创建两个类，每个里面的属性也不一样。这两个类中有大量重复的代码，有有优化空间。

>>> class JS: #剑士
def __init__(self,name,level,blood,attack_power):
self.name = name
self.level = level
self.blood = blood
self.attack_power = attack_power
def fight(self): #方法
print('剑士：用剑攻击')
def __repr__(self): #__str__没有的时候，会去找__repr__
#使用'{}{}'.format(a,b)这种方式格式化字符串.
return '{cls}(姓名：{name},等级：{level},血量：{blood})'.format(cls=__class__.__name__,
name=self.name,
level=self.level,
blood=self.blood)>>>
class FS: #法师
def __init__(self,name,level,blood,magic_power):
self.name = name
self.level = level
self.blood = blood
self.magic_power = magic_power
def fight(self):
print('法师：用法术攻击')
def cure(self):
print('治疗')
def __repr__(self): #__str__没有的时候，会去找__repr__
return '{cls}(姓名：{name},等级：{level},血量：{blood})'.format(cls=__class__.__name__,
name=self.name,
level=self.level,
blood=self.blood)>>> a = JS('寒冰射手',18,500,100) #实例化对象a，因为类JS里面有__init__这个实例初始化函数，所以在实例对象时，必需传参数。
>>> print(a) #__repr__方法中没有return power的参数，所以不会返回100
JS(姓名：寒冰射手,等级：18,血量：500)

>>> a.fight() #使用实例调用类中的fight(self)方法。会把实例a自己传入到函数里面。
剑士：用剑攻击
>>> b.fight() #法师这个类也可以有同样的操作
法师：用法术攻击
>>>

继承关系图：

练习题解答2：

为了方便代码的管理和修改，这里会使用继承来解决这个练习题。

>>> class Role: #定义一个角色的类，这个类拥有剑士和法师共有的属性。
def __init__(self,name,level,blood):
self.name = name
self.level = level
self.blood = blood
def fight(self):
raise NotImplementedError('攻击没有实现') #Not Implemented Error 表示这个方式实现，还不能调用。必须要在 “子类”中实现（因为剑士和法师攻击技能不一样，没有共同的属性）。
def __repr__(self): #__str__没有的时候，会去找__repr__
#使用'{}{}'.format(a,b)这种方式格式化字符串.
return '{cls}(姓名：{name},等级：{level},血量：{blood})'.format(cls=__class__.__name__,
name=self.name,
level=self.level,
blood=self.blood)>>> class JS(Role): #创建一个法师的类，同时继承角色这个类；不管是剑士还是法师都应该继承一个有共同属性的类。
#这样后续就很好扩展。比如有上百个游戏人物角色，直接继承一个有共同属性的类（如：Role）。
pass>>> class FS(Role): #继承以后，什么都不用做，这个FS和Role的功能是一样的。
pass>>> a = JS('寒冰射手',18,500)
>>>
>>> print(a)
Role(姓名：寒冰射手,等级：18,血量：500)
>>> a.fight() #目前这个剑士还没有攻击的能力，因为当前剑士这个类里面没有任何方法，
#而继承的类Role里面定义的fight(self)方法设置了主动报异常的警告。因为Role是公共的属性，它不好定义剑士和法师是如何攻击的。
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
a.fight() #目前这个剑士还没有攻击的能力，因为当前剑士这个类里面没有任何方法，
File "<pyshell#1>", line 7, in fight
raise NotImplementedError('攻击没有实现') #Not Implemented Error 表示这个方式实现，还不能调用。必须要在 “子类”中实现。
NotImplementedError: 攻击没有实现>>>

练习题解答3：

使用继承 + 重写丰富属性方法。

class Role: #定义一个有共同属性的类
def __init__(self,name,level,blood):
self.name = name
self.level = level
self.blood = blood
def fight(self):
raise NotImplementedError('攻击没有实现') #Not Implemented Error 表示这个方式实现，还不能调用。必须要在 “子类”中实现。
def __repr__(self): #__str__没有的时候，会去找__repr__
#使用'{}{}'.format(a,b)这种方式格式化字符串.
return '{cls}(姓名：{name},等级：{level},血量：{blood})'.format(cls=__class__.__name__,
name=self.name,
level=self.level,
blood=self.blood)>> class JS(Role): #创建一个剑士的类，同时继承角色这个类；不管是剑士还是法师都应该继承一个有共同属性的类。
#这样后续就很好扩展。比如有上百个游戏人物角色，直接继承一个有共同属性的类（如：Role）。
#继承以后，什么都不用做，这个FS和Role的功能是一样的。
def __init__(self,name,level,blood,js_power): #不管如何，初始化方法__init__必须有。
Role.__init__(self,name,level,blood) #公共的部分使用父类Role去初始化。
self.js_power = js_power #单独的属性自己初始化
def fight(self): #父类里面有的，子类里面在写一次，叫做重写，最终只会用子类的了。
print('%s是：物理攻击'%(self.name))>>> class FS(Role): #创建一个法师的类，同时继承角色这个类
def __init__(self,name,level,blood,fs_power): #不管如何，初始化方法__init__必须有。
Role.__init__(self,name,level,blood) #公共的部分使用父类Role去初始化。
self.fs_power = fs_power #单独的属性自己初始化.
def fight(self):
print('%s是：法术攻击' % (self.name))
def cure(self):
print('%s: 有治疗术，剑士没有！'%(self.name))>>> a = JS('寒冰射手',18,500,130) #目前JS这个类初始化已经重写，增加了js_power参数。
>>> print(a)
Role(姓名：寒冰射手,等级：18,血量：500)
>>> a.fight()
寒冰射手是：物理攻击
>>>
>>>
>>> b = FS('流浪',18,500,150) #目前FS这个类初始化也已经重写，增加了fs_power参数。
>>> print(b)
Role(姓名：流浪,等级：18,血量：500)
>>> b.fight()
流浪是：法术攻击
>>> b.cure()
流浪: 有治疗术，剑士没有！
>>>