继承描述的是一种类间关系，一个类A从另一个类B获取成员信息，称类A继承自类B。
提供成员信息的类称父类(基类)，获取成员信息的类称子类(派生类)。
1.2 继承的作用
子类可以使用父类的成员(成员变量，成员方法)
1.3 继承的语法格式
class 类名(父类名)：
pass
复制代码
进群：960410445 即可获取数十套PDF以及大量的学习教程哦！
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() # 调用主函数
复制代码
网友评论