Python父子关系——继承（反恐精英案例，应用与练习）

继承描述的是一种类间关系，一个类A从另一个类B获取成员信息，称类A继承自类B。

提供成员信息的类称父类(基类)，获取成员信息的类称子类(派生类)。

1.2 继承的作用

子类可以使用父类的成员(成员变量，成员方法)

1.3 继承的语法格式

class 类名(父类名)：
    pass
复制代码

1.4 获取继承关系图谱

使用 Python 内置属性__mro__可以查看继承关系

语法格式：类名. mro

说明：mro即Method Resolution Order方法解析顺序，所有类都有一个共同的父类boject，来自Python系统默认。

1.5 注意事项

• 子类可以添加父类没有的成员
• 父类私有成员不可被继承

2.重写

2.1 重写的概念

重写指在子类中定义与父类相同名称的成员方法。

2.2 重写的作用

子类对父类的成员方法进行重写后，使用子类对象调用该方法时，将执行子类中重写后的方法

2.3 在子类中访问父类被重写的方法

格式一：父类名.方法名(对象)

格式二：super(本类名，对象).方法名 ()

(推荐)格式三：super().方法名 ()

3. 多继承

3.1 多继承的概念

一个类同时继承多个类，称为多继承

3.2 定义多继承语法格式

class 类名(父类名1，父类名2...):
    pass
复制代码

3.3 多继承关系中访问父类成员冲突

多继承关系中，当多个父类具有同名的成员，子类调时该成员时先调用继承关系中的第一个声明的类成员。

4. 多态

4.1 多态的概念

一个对象具有多种形态，字不同的使用环境中以不同的形态展示其功能，称该对象具有多态特征。

例：一个人，既是老师，也是父亲，也是司机等。

4.2 鸭子类型

鸭子类型是一种特殊的调用现象，当对象在语法层面能够满足调用关系，但对象并不具有对应的对象形态，称该对象此时具备鸭子类型。

鸭子类型是一种特殊的多态表现形式。

例：浮在水上的没飞的鸟，远观称其鸭子，鸭子没飞，浮在水面。但理论上不是鸭子。

4.3 注意事项

多态通常发生在继承关系的基础之上。

案例：反恐精英基础版

"""
演示反恐精英案例
对一个匪徒
分析：
1.定义人类，描述公共属性 life:100  name:姓名要传参
2.定义出英雄与恐怖分子类
3.定义主函数描述枪战过程 main，创建两个对象
4.定义开枪方法，分成两个方法，Hero Is都有
    定义的方法要传入被射击的对象
    被射击对象的生命值要进行减少
5.主程序中调用开枪操作
6.开枪操作后，要在主程序中显示每个人的状态信息
7.定义Person类的__str__方法，用于显示每个人的状态
8.设置开枪操作为反复操作
    再设置停止条件：一方生命值<=0
    停止循环使用break
"""
class Person:  # 定义人类
    def __init__(self,name):  # 定义公有变量名字和hp
        self.name = name
        self.hp = 100

    def __str__(self):      # 返回对应人的当前血量
        return "%s当前生命值为：%d" % (self.name, self.hp)

class Hero(Person):     # 定义英雄类，定义开枪成员方法
    def fire(self,p):
        damage = 40    # 伤害
        # 谁向谁开枪，只有一个self参数，定义一个形参p，接收开枪和受伤人
        print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
        p.hp -= damage  # 受伤人hp自减

class Is(Person):  # 同上
    def fire(self,p):
        damage = 10
        print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
        p.hp -= damage
    
def main():   # 定义主函数
# 定义h对象，同时传参名字，继承父类Person的name属性，调用时显示
    h = Hero("【英雄】")  
# 定义is1对象,同上
    is1 = Is("【老大】")    
    while True:    # 无限循环
        h.fire(is1)   # 传参h开火，开火对象是is1
        is1.fire(h)   # 传参is1开火，开火对象是h
        print(h)
        print(is1)
    # 设置结束条件
        if h.hp <= 0:
            print("%s死亡，枪战结束" % h.name)
            break
        if is1.hp <= 0:
            print("所有恐怖份子全部死亡，枪战结束")
            break
main()  # 调用主函数
复制代码

案例：反恐精英修复版

"""
演示反恐精英案例——修复版
对一个匪徒
分析：
-----------------------基础版-----------------------
1.定义人类，描述公共属性 life:100  name:姓名要传参
2.定义出英雄与恐怖分子类
3.定义主函数描述枪战过程 main，创建两个对象
4.定义开枪方法，分成两个方法，Hero Is都有
    定义的方法要传入被射击的对象
    被射击对象的生命值要进行减少
5.主程序中调用开枪操作
6.开枪操作后，要在主程序中显示每个人的状态信息
7.定义Person类的__str__方法，用于显示每个人的状态
8.设置开枪操作为反复操作
    再设置停止条件：一方生命值<=0
    停止循环使用break
-----------------------修复版-----------------------
9.修复英雄的信息显示模式
    状态描述 0 - 1- 70 - 99- 100
    if..elif..   and组合条件
10.修复生命值为负的问题
    射击时如果生命值<伤害值，生命值 = 0，否则正常减生命
"""
class Person:  # 定义人类
    def __init__(self,name):  # 定义公有变量名字和hp
        self.name = name
        self.hp = 100

    def __str__(self):      # 返回对应人的当前血量
        return "%s当前生命值为：%d" % (self.name, self.hp)

class Hero(Person):     # 定义英雄类，定义开枪成员方法
    def fire(self,p):
        damage = 40    # 伤害
        # 谁向谁开枪，只有一个self参数，定义一个形参p，接收开枪和受伤人
        print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
        if p.hp < damage:  # 受伤人的hp小于开枪人的伤害时
            p.hp = 0        # 赋值0，修复出现负生命值情况
        else:
            p.hp -= damage  # 受伤人hp自减
    
    # 重写父类的str方法，调用子类英雄时，使用子类中的str
    def __str__(self):     
    # 调用时必定传的是英雄参数，所以以下self都代表的英雄对象
        # 状态 state = "？"
        if self.hp == 100:
            state = "无伤"
        elif self.hp >= 70 and self.hp < 100:
            state = "轻伤"
        elif self.hp >= 1 and self.hp < 70:
            state = "重伤"
        elif self.hp >= 0:
            state = "挂了"
        return "%s当前状态为：%s" % (self.name, state)  # 返回状态

class Is(Person):  # 同上
    def fire(self,p):
        damage = 10
        print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
        if p.hp < damage:  # 受伤人的hp小于开枪人的伤害时
            p.hp = 0        # 赋值0，修复出现负生命值情况
        else:
            p.hp -= damage  # 受伤人hp自减
    
def main():   # 定义主函数
# 定义h对象，同时传参名字，继承父类Person的name属性，调用时显示
    h = Hero("【英雄】")  
# 定义is1对象,同上
    is1 = Is("【老大】")    
    while True:    # 无限循环
        h.fire(is1)   # 传参h开火，开火对象是is1
        is1.fire(h)   # 传参is1开火，开火对象是h
        print(h)
        print(is1)
        print()   # 打印空行，隔开每轮开枪
    # 设置结束条件
        if h.hp <= 0:
            print("%s死亡，枪战结束" % h.name)
            break
        if is1.hp <= 0:
            print("所有恐怖份子全部死亡，枪战结束")
            break
main()  # 调用主函数
复制代码

案例：反恐精英加强版

"""
演示反恐精英案例——加强版
对三个匪徒
分析：
-----------------------基础版-----------------------
1.定义人类，描述公共属性 life:100  name:姓名要传参
2.定义出英雄与恐怖分子类
3.定义主函数描述枪战过程 main，创建两个对象
4.定义开枪方法，分成两个方法，Hero Is都有
    定义的方法要传入被射击的对象
    被射击对象的生命值要进行减少
5.主程序中调用开枪操作
6.开枪操作后，要在主程序中显示每个人的状态信息
7.定义Person类的__str__方法，用于显示每个人的状态
8.设置开枪操作为反复操作
    再设置停止条件：一方生命值<=0
    停止循环使用break
-----------------------修复版-----------------------
9.修复英雄的信息显示模式
    状态描述 0 - 1- 70 - 99- 100
    if..elif..   and组合条件
10.修复生命值为负的问题
    射击时如果生命值<伤害值，生命值 = 0，否则正常减生命
-----------------------加强版-----------------------
11.创建三个恐怖份子对象
    三个对象都要开枪，三个对象都要打印状态
12.修复结束条件为三个恐怖份子都死亡
    三个满足同时死亡 and
13.解决向三个恐怖份子开枪的问题
    随机数：random
    步骤1:使用random    import random  必须写在所有程序的前面
    步骤2：使用random.randint(1,3) 可以产生1到3的随机数
    产生一个随机数，判断是几就向几号敌人开枪

"""
import random   # 定义random
class Person:  # 定义人类
    def __init__(self,name):  # 定义公有变量名字和hp
        self.name = name
        self.hp = 100

    def __str__(self):      # 返回对应人的当前血量
        return "%s当前生命值为：%d" % (self.name, self.hp)

class Hero(Person):     # 定义英雄类，定义开枪成员方法
    def fire(self,p):
        damage = 40    # 伤害
        # 谁向谁开枪，只有一个self参数，定义一个形参p，接收开枪和受伤人
        print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
        if p.hp < damage:  # 受伤人的hp小于开枪人的伤害时
            p.hp = 0        # 赋值0，修复出现负生命值情况
        else:
            p.hp -= damage  # 受伤人hp自减
    
    # 重写父类的str方法，调用子类英雄时，使用子类中的str
    def __str__(self):     
    # 调用时必定传的是英雄参数，所以以下self都代表的英雄对象
        # 状态 state = "？"
        if self.hp == 100:
            state = "无伤"
        elif self.hp >= 70 and self.hp < 100:
            state = "轻伤"
        elif self.hp >= 1 and self.hp < 70:
            state = "重伤"
        elif self.hp >= 0:
            state = "挂了"
        return "%s当前状态为：%s" % (self.name, state)  # 返回状态

class Is(Person):  # 同上
    def fire(self,p):
        damage = 10
        print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
        if p.hp < damage:  # 受伤人的hp小于开枪人的伤害时
            p.hp = 0        # 赋值0，修复出现负生命值情况
        else:
            p.hp -= damage  # 受伤人hp自减
    
def main():   # 定义主函数
# 定义h对象，同时传参名字，继承父类Person的name属性，调用时显示
    h = Hero("【英雄】")  
# 定义三个恐怖份子对象,同上
    is1 = Is("【老大】")
    is2 = Is("【老二】")
    is3 = Is("【老三】")
    while True:    # 无限循环
        x = random.randint(1,3)   # 随机产生1-3 
        if x == 1:         # 如果是1，让英雄向老大开枪
            h.fire(is1)
        elif x == 2:        # 向老二开枪
            h.fire(is2)
        else:                  # 同理
            h.fire(is3)
        is1.fire(h)   # 传参is1开火，开火对象是h
        is2.fire(h)   # 恐怖分子开火
        is3.fire(h)
        print(h)     # 打印4个人的信息
        print(is1)
        print(is2)
        print(is3)
        print()   # 打印空行，隔开每轮开枪
    # 设置结束条件
        if h.hp <= 0:
            print("%s死亡，枪战结束" % h.name)
            break
        # 修复恐怖份子结束的条件
        if is1.hp <= 0 and is2.hp <= 0 and is3.hp <= 0:   
            print("所有恐怖份子全部死亡，枪战结束")
            break
main()  # 调用主函数
复制代码

恐怖分子人数增加，可适当调低伤害

反恐精英超级加强版

"""
演示反恐精英案例——超级加强版
对三个匪徒
加入开枪射击命中概率
加入开枪伤害值波动
加入鞭尸文字显示效果
分析：
-----------------------基础版-----------------------
1.定义人类，描述公共属性 life:100  name:姓名要传参
2.定义出英雄与恐怖分子类
3.定义主函数描述枪战过程 main，创建两个对象
4.定义开枪方法，分成两个方法，Hero Is都有
    定义的方法要传入被射击的对象
    被射击对象的生命值要进行减少
5.主程序中调用开枪操作
6.开枪操作后，要在主程序中显示每个人的状态信息
7.定义Person类的__str__方法，用于显示每个人的状态
8.设置开枪操作为反复操作
    再设置停止条件：一方生命值<=0
    停止循环使用break
-----------------------修复版-----------------------
9.修复英雄的信息显示模式
    状态描述 0 - 1- 70 - 99- 100
    if..elif..   and组合条件
10.修复生命值为负的问题
    射击时如果生命值<伤害值，生命值 = 0，否则正常减生命
-----------------------加强版-----------------------
11.创建三个恐怖份子对象
    三个对象都要开枪，三个对象都要打印状态
12.修复结束条件为三个恐怖份子都死亡
    三个满足同时死亡 and
13.解决向三个恐怖份子开枪的问题
    随机数：random
    步骤1:使用random    import random  必须写在所有程序的前面
    步骤2：使用random.randint(1,3) 可以产生1到3的随机数
    产生一个随机数，判断是几就向几号敌人开枪
-----------------------超级加强版-----------------------
14.加入开枪射击命中概率
    产生一个随机数，如果在范围内，命中，否则不命中
    文字效果要变化
    两处开枪都要重新制作
15.加入开枪伤害值波动
    产生一个随机数，作为伤害值
16.加入鞭尸文字显示效果
"""
import random   # 定义random
class Person:  # 定义人类
    def __init__(self,name):  # 定义公有变量名字和hp
        self.name = name
        self.hp = 100

    def __str__(self):      # 返回对应人的当前血量
        return "%s当前生命值为：%d" % (self.name, self.hp)

class Hero(Person):     # 定义英雄类，定义开枪成员方法
    def fire(self,p):
    # 加入命中率
        hit = random.randint(1,100)   
        if hit <= 80:    # 命中率80%
            if p.hp == 0:     # 如果受伤人的hp=0，则是鞭尸
                print("你攻击的是%s尸体，无效" % p.name)
            else:    # 如果不是，伤害也加入随机数，波动
                damage = random.randint(20,50)    # 20-50随机伤害
                print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
                if p.hp < damage:  # 受伤人的hp小于开枪人的伤害时
                    p.hp = 0  # 赋值0，修复出现负生命值情况
                else:
                    p.hp -= damage  # 受伤人hp自减
        else:
            print("未打中土匪")
    
    # 重写父类的str方法，调用子类英雄时，使用子类中的str
    def __str__(self):     
    # 调用时必定传的是英雄参数，所以以下self都代表的英雄对象
        # 状态 state = "？"
        if self.hp == 100:
            state = "无伤"
        elif self.hp >= 70 and self.hp < 100:
            state = "轻伤"
        elif self.hp >= 1 and self.hp < 70:
            state = "重伤"
        elif self.hp >= 0:
            state = "挂了"
        return "%s当前状态为：%s" % (self.name, state)  # 返回状态

class Is(Person):  # 同上
    def fire(self,p):
    # 加入命中率
        hit = random.randint(1,100)
        damage = random.randint(5,15)
        if hit > 80:
            print("%s向%s开枪，造成了%d伤害" % (self.name, p.name, damage))
            if p.hp < damage:  # 受伤人的hp小于开枪人的伤害时
                p.hp = 0        # 赋值0，修复出现负生命值情况
            else:
                p.hp -= damage  # 受伤人hp自减
        else:
            print("未打中英雄")
def main():   # 定义主函数
# 定义h对象，同时传参名字，继承父类Person的name属性，调用时显示
    h = Hero("【英雄】")  
# 定义三个恐怖份子对象,同上
    is1 = Is("【老大】")
    is2 = Is("【老二】")
    is3 = Is("【老三】")
    while True:    # 无限循环
        x = random.randint(1,3)   # 随机产生1-3 
        if x == 1:         # 如果是1，让英雄向老大开枪
            h.fire(is1)
        elif x == 2:        # 向老二开枪
            h.fire(is2)
        else:                  # 同理
            h.fire(is3)
        is1.fire(h)   # 传参is1开火，开火对象是h
        is2.fire(h)   # 恐怖分子开火
        is3.fire(h)
        print(h)     # 打印4个人的信息
        print(is1)
        print(is2)
        print(is3)
        print()   # 打印空行，隔开每轮开枪
    # 设置结束条件
        if h.hp <= 0:
            print("%s死亡，枪战结束" % h.name)
            break
        # 修复恐怖份子结束的条件
        if is1.hp <= 0 and is2.hp <= 0 and is3.hp <= 0:   
            print("所有恐怖份子全部死亡，枪战结束")
            break
main()  # 调用主函数
复制代码