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()
流浪: 有治疗术，剑士没有！
>>>