让我们穿越到《龙珠》世界，一起揭开 面向对象编程 的神秘面纱吧。
面向过程编程与面向对象编程
天下第一武道会
选手登记
第 22 届天下第一武道会即将召开，各路武术高手齐聚一堂，其中最受瞩目的，当属卡卡罗特（孙悟空）一行人，以及比克大魔王为首的邪恶力量。
每名选手在报名参加武道会时，都需要填写报名表。你觉得下列哪种数据类型 更适合 用于存储每名选手的个人信息呢？
整数型？浮点型？字符串？列表型？还是字典类型呢？？？
🤔️ 嗯……选手所填写的报名表中包含 多种信息，每条信息的 类别 与 具体内容 间存在一一对应的关系。这么看来，我们应该使用 字典 来存储信息。
😉 相信这对你来说已经是小菜一碟了。储存好选手们的信息，天下第一武道会终于可以开始啦！
决斗方式
本届武道会采取 回合制 决斗方式，即一方进攻后，攻防交换，轮到另一方进攻。如此不断重复，直到某一方 生命值降为 0 或 0 以下，判定为战败。
回合制战斗这类形式，决斗双方会不断 重复“A 攻击 B 防御、B 攻击 A 防御” 这一过程，所以我们用 循环结构 来表示，这是没有问题的。但是，决斗 直到 某一方生命值降为 0 或 0 以下才会停止，我们无法预先估计循环次数，因此比起 for 型循环，这里更适合用 while 型循环结构来表示喔。
确定了整体结构后，我们来继续思考：决斗过程是 A 攻击 B 防御、B 攻击 A 防御，然后又轮到 A 攻击 B 防御、B 攻击 A 防御。因此，循环体内最重要的两个步骤就是 发起攻击、防御攻击。
而每次有人发动攻击，都可能使防御方重伤倒地不起（生命值降为 0 或 0 以下），所以 A 打 B 之后，我们需要判断一下，此时 B 生命值是否小于等于 0。如果小于等于 0，则 B 战败、A 获胜。B 打 A 后同理。
我们将上述思路整合一下，就能画出决斗过程流程图啦：
搭好了整体框架，下面我们来逐步填充细节吧～
攻击，防御
循环体内有两大关键步骤，因此我们可以设计两个函数：
- 发起攻击函数
hit()：接受 2 个参数，第一个参数表示攻击方，第二个参数表示攻击对象；- 防御攻击函数
defend()：接受 2 个参数，第一个参数表示受到攻击的人，第二个参数表示受到的伤害。
发动攻击函数 hit() 比较好办，我们只要让攻击方大喝一声“哋”，接着调用 defend() 函数，让防御方防御即可。写成代码的话就是这样：
# 发动攻击
def hit(attacker, target):
print('>> 【{}】发起攻击，\n'.format(attacker['name']))
defend(target, attacker['ATK'])在防御攻击函数 defend() 中，我们则可以加一些花样——卡卡罗特和比克大魔王这样的武林高手，肯定不会傻愣愣地站在原地挨打。因此我们可以设定，当某人防御攻击时，有 20% 几率完美闪避，毫发无损。
那么新的问题就来了：我们要如何体现这“20% 几率闪避”呢？
这就要用到我们在 前面 几关学习过的 random 模块中的 randint() 方法了。
randint() 方法接受两个整数，将返回包括这两个整数之间、加上两个数本身在内的所有整数。
借助 randint() 函数，我们就能设计闪避机制了。首先，我们随机生成一个 1～100 之间的整数（包括 1 和 100）。此时，它有 1% 的可能是 1，有 1% 的可能是 2，有 1% 的可能是 3……即，它有 20% 的可能小于等于 20。
所以，判定防御方是否闪避成功的问题，就可以转化为判断生成的随机数是否小于等于 20 的问题。写成代码的话就是这样：
from random import randint
# 防御攻击
def defend(defender, damage):
# 若生成的随机数小于等于 20，则闪避成功
if randint(1, 100) <= 20:
print('>> 【{}】完美躲避了攻击！\n'.format(defender['name']))
# 否则扣除对应生命值
else:
defender['HP'] = defender['HP'] - damage
print('>> 【{}】受到 {} 点伤害...\n'.format(defender['name'], damage))提示：这里的前缀“>> ”仅起到装饰作用。你可以根据自己的喜好设计不同的输出效果哦～
编程练习
请你根据上面分析过程，完成防御攻击函数 defend()，并按照注释中的要求调用函数。
要求
- 防御方有 20% 几率完美闪避攻击；
- 若闪避成功，则输出 >> 【xxx】完美躲避了攻击！；否则输出 >> 【xxx】受到 xxx 点伤害。
from random import randint
# 选手信息
kakarot = {'name': '卡卡罗特', 'HP': 100, 'ATK': 25}
piccolo = {'name': '比克大魔王', 'HP': 150, 'ATK': 15}
# 发动攻击
def hit(attacker, target):
print('>> 【{}】发起攻击，\n'.format(attacker['name']))
defend(target, attacker['ATK'])
# 在下面进行代码补充
# 防御攻击
# 调用函数，让卡卡罗特向比克大魔王发动攻击
# 调用函数，让比克大魔王向卡卡罗特发动攻击补充后打代码为：
from random import randint
# 选手信息
kakarot = {'name': '卡卡罗特', 'HP': 100, 'ATK': 25}
piccolo = {'name': '比克大魔王', 'HP': 150, 'ATK': 15}
# 发动攻击
def hit(attacker, target):
# print(attacker)
print('>> 【{}】发起攻击，\n'.format(attacker['name']))
defend(target, attacker['ATK'])
# 防御攻击
def defend(target, atk):
if randint(1,100) <= 20:
# 如果有闪避，则完美闪避
print('>> 【{}】完美躲避了攻击！'.format(target['name']))
else:
# 如果没有闪避，则被攻击，收到上海
print('>> 【{}】受到 {} 点伤害'.format(target['name'], atk))
# 调用函数，让卡卡罗特向比克大魔王发动攻击
hit(kakarot, piccolo)
# 调用函数，让比克大魔王向卡卡罗特发动攻击
hit(piccolo, kakarot)
# 输出结果为：
# >> 【卡卡罗特】发起攻击，
# >> 【比克大魔王】受到 25 点伤害
# >> 【比克大魔王】发起攻击，
# >> 【卡卡罗特】受到 15 点伤害太棒啦！循环体内两大步骤都搞定了，最后，我们只需要把这几个“零件”组装到一起，就能让选手们展开决斗了。
不过，我们目前编写的这一版代码还存在两大问题：
第一大问题是，由于我们是用 字典类型变量 存储选手信息的，所以每新增一位选手，我们都需要 重复定义相同数据结构，多少还是有些麻烦。我们有没有什么方法，能够定义出一个通用的选手 模板 呢？
第二大问题是，我们调用 hit() 函数让 A 向 B 发动攻击时，编写出的代码是 hit(A, B)。按照我们的语言习惯，可能会被误解为“同时攻击 A 和 B”（hit A and B）。我们有没有什么方法能够让代码更符合我们的认知习惯呢？
解决这两个问题的方法并不难。它所要用到的 Python 语法，就是我们本单元的重点——类。困难的地方在于，这次我们不仅要学习新的语法，还要学习一种新的分析问题方式——面向对象编程。
两种重要编程思想
编程届一直存在两种编程思想，一种是 面向过程，另一种是 面向对象。首先让我们来看看什么是 面向过程编程。
面向过程编程
面向过程编程 方式将程序看作 命令 的集合，按照 问题解决步骤 编写程序。我们一直以来就是用这种方式分析问题、编写程序的。
比如我们在分析决斗过程时，先将决斗过程拆解为两大步骤，为每个步骤设计函数实现，最终代码结构是这样的：
# 选手信息
kakarot = {'name': '卡卡罗特', 'HP': 100, 'ATK': 25}
piccolo = {'name': '比克大魔王', 'HP': 150, 'ATK': 15}
# 发动攻击
def hit(attacker, target):
pass
# 防御攻击
def defend(defender, damage):
pass
# 展开决斗
while True:
# 每回合开始，由卡卡罗特先发动攻击
hit(kakarot, piccolo)
# 判断此时决斗是否分出胜负
if piccolo['HP'] <= 0:
break
# 若未分出胜负，则攻防交换，由比克大魔王发动攻击
hit(piccolo, kakarot)
# 判断此时决斗是否分出胜负
if kakarot['HP'] <= 0:
break提示：此处代码省略了函数实现细节。
可以看到，用面向过程思想写出来的代码最大优点在于 步骤清晰。但与此同时我们也注意到：程序中的 数据 与 函数 间是十分松散的，只有编写代码的我们心里清楚 hit() 函数中的 attacker 参数与 target 参数，实际上是由 'name' 键、'HP' 键和 'ATK' 键构成的字典类型变量。
理想状况下我们当然可以记住每个变量的类型、结构。可是，如果问题规模不断扩大，我们又该怎么办呢？
比如对于一场真实的武道会来说，我们不仅要存储选手们的信息，还要存储主持人、裁判等 不同身份 的人的信息；我们不仅要表现决斗过程，还要表现赛前抽签、主持人主持比赛、裁判判决比赛等过程……此时若继续采用 面向过程编程 思想，那我们编写出的程序势必会结构混乱。即使把它们拆解成一个个模块，也是治标不治本。
如果想“治本”，则需要转变看待问题的角度，尝试用 面向对象编程 思想重新审视周遭的一切。
面向对象编程
想弄明白什么是 面向对象编程，首先我们要明白什么是 对象。
咳咳，这里的“对象”指的肯定不是伴侣，而是 具有一系列特征和行为的个体。我们需要解决的问题，则可看作 对象与对象之间的交互。比如在天下第一武道会中，每名选手都是独立的个体，可视作一个 对象。一场决斗是两位选手之间的对决，即两个对象之间的交互。
进一步地我们发现，虽然 对象 A 和 对象 B 是独立的个体，但他们都有姓名、生命值、攻击力这三样 特征，都有 发动攻击 和 防御攻击 这两样行为。因此我们可以说他们是同一 类 的。这里不妨为它取名为 选手类。
运用这一思想，我们能够轻松地应对大规模问题——
由于主持人、裁判、选手之间 特征 和可以做出的 行为 各不相同，因此我们可以定义出三大 类 描述他们，后续任务无非就是将这三个类写成代码：
不知道你发现了吗？在用 面向对象编程 思想分析问题时，我们并没有关注 问题解决步骤，而是从 对象 出发，先弄清楚什么样的对象能做什么事，再从中归纳总结出几大 类，每个 类 都有自己着自己的特征与行为。
这就是 面向对象编程 与 面向过程编程 的最大区别。面向对象编程 方法将编程视作 对象 的集合，从 对象与对象间的交互 角度出发思考问题。
这种思维方式更贴近我们平时认知世界的直觉。因此即使我们不明白类相关的语法规则和背后的实现逻辑，也能够按照我们的生活经验推断出代码对应的含义。比如对于下面这段代码：
kakarot = Player('卡卡罗特', 100, 25)
piccolo = Player('比克大魔王', 150, 15)
kakarot.hit(piccolo)不妨猜猜看，代码第三行 kakarot.hit(piccolo) 描述了一种怎样的行为呢？
A：
kakarot攻击piccolo
B：piccolo攻击kakarot
C：kakarot和piccolo同时受到了攻击答案当然选A了。是不是很简单
从“kakarot”、“hit”、“piccolo”这三个词的顺序我们不难推断出，这行代码是在描述 kakarot 攻击 piccolo（Kakarot hit Piccolo）。这就是面向对象编程的魅力所在！
面向对象编程的概念就介绍到这里啦。
类 是抽象的模板，对象 是具象的个体。上述过程中共出现了三位角色，分别是大勇、卡卡罗特、比克大魔王，所以涉及到的对象就是他们三人。而“主持人”与“选手”是他们所属的 类。
改用另一种思维方式分析问题是一项需要不断练习才能真正领会、掌握的事，不能一蹴而就。所以本关我们重在梳理 决斗过程 逻辑，并简要了解了 面向对象编程 的概念，知道了它和我们传统的 面向过程编程 方式间的区别：
编程练习_回合制决胜负
请你根据 决斗过程流程图 和注释中的提示信息，补全代码，让卡卡罗特和比克大魔王展开决斗吧！你也可以在此基础上修改，让决斗过程更加丰富有趣哦。
决斗说明
- 决斗采取 回合制；
- 由卡卡罗特先发动攻击。
决斗过程流程图
from random import randint
# 选手信息
kakarot = {'name': '卡卡罗特', 'HP': 100, 'ATK': 25}
piccolo = {'name': '比克大魔王', 'HP': 150, 'ATK': 15}
# 发动攻击
def hit(attacker, target):
print('>> 【{}】发起攻击，\n'.format(attacker['name']))
defend(target, attacker['ATK'])
# 防御攻击
def defend(defender, damage):
# 若生成的随机数小于等于 20，则闪避成功
if randint(1, 100) <= 20:
print('>> 【{}】完美躲避了攻击！\n'.format(defender['name']))
# 否则扣除对应生命值
else:
defender['HP'] = defender['HP'] - damage
print('>> 【{}】受到 {} 点伤害...\n'.format(defender['name'], damage))
# 展开决斗
while True:
# 每回合开始，由卡卡罗特先发动攻击
hit(kakarot, piccolo)
# 判断此时决斗是否分出胜负
if piccolo['HP'] <= 0:
print('{}获胜'.format(kakarot['name']))
break
# 若未分出胜负，则攻防交换，由比克大魔王发动攻击
hit(piccolo, kakarot)
# 判断此时决斗是否分出胜负
if kakarot['HP'] <= 0:
print('{}获胜'.format(piccolo['name']))
break
# 输出结果为：（获胜结果是随机的）
# >> 【卡卡罗特】发起攻击，
# >> 【比克大魔王】受到 25 点伤害...
# >> 【比克大魔王】发起攻击，
# >> 【卡卡罗特】受到 15 点伤害...
# >> 【卡卡罗特】发起攻击，
# >> 【比克大魔王】受到 25 点伤害...
# >> 【比克大魔王】发起攻击，
# >> 【卡卡罗特】受到 15 点伤害...
# >> 【卡卡罗特】发起攻击，
# >> 【比克大魔王】受到 25 点伤害...
# >> 【比克大魔王】发起攻击，
# >> 【卡卡罗特】受到 15 点伤害...
# >> 【卡卡罗特】发起攻击，
# >> 【比克大魔王】受到 25 点伤害...
# >> 【比克大魔王】发起攻击，
# >> 【卡卡罗特】受到 15 点伤害...
# >> 【卡卡罗特】发起攻击，
# >> 【比克大魔王】受到 25 点伤害...
# >> 【比克大魔王】发起攻击，
# >> 【卡卡罗特】受到 15 点伤害...
# >> 【卡卡罗特】发起攻击，
# >> 【比克大魔王】受到 25 点伤害...
# 卡卡罗特获胜编程练习_决斗时喊出技能名不是很酷吗
不好了不好了，比克大魔王率领一众小弟包围了武道会主办方，说：“哼，区区‘攻击力 15’怎能体现出我强大的招式呢？我提议，在登记信息时将我们的绝招也登记上去，决斗时各自报出技能。谁敢不从？”
主办本想拉着卡卡罗特一行人撑腰，没想到小悟空连连点头：“对呀，喊出技能名多酷哇。就这么办吧！”
哎……看来只能麻烦你改进一下之前的代码了。
要求
- 选用 合适 的数据类型存储每位选手信息；
- 编写
hit()函数，该函数接受两个参数attacker和target，表示attacker随机使用自己任意一个技能，向target发动攻击。
另外，进攻方在攻击时，要喊出自己使用了什么技能，就像这样：
hit(kakarot, piccolo)
# 输出：>> 【卡卡罗特】使出残象拳向【比克大魔王】发动攻击，数据说明
卡卡罗特（kakarot）
- 生命值（HP）：100
- 技能（SKILLS）：
- 残象拳：威力 10
- 八手拳：威力 15
- 变身赛亚人：威力 50
比克大魔王（piccolo）
- 生命值（HP）：150
- 技能（SKILLS）：
- 魔光线：威力 10
- 魔光炮：威力 15
- 爆裂魔光炮：威力 20
# 请在此处登记卡卡罗特选手信息
# 请在此处登记比克大魔王选手信息
# 请在此处定义 hit() 函数
# 调用 hit() 函数优化后代码（非固定答案）：
import random
# 请在此处登记卡卡罗特选手信息
kakarot = {
'name':'卡卡罗特','HP':'100',
'技能':[
{'name':'残象拳','damage':'80'},
{'name':'八手拳','damage':'15'},
{'name':'变身赛亚人','damage':'50'}
]
}
# 请在此处登记比克大魔王选手信息
piccolo = {
'name':'比克大魔王','HP':'150',
'技能':[
{'name':'魔光线','damage':'10'},
{'name':'魔光炮','damage':'10'},
{'name':'爆裂魔光炮','damage':'20'}
]
}
# 请在此处定义 hit() 函数
def hit(attacker, target):
# 技能
skill = random.choice(attacker['技能'])['name']
print('>> 【{}】使出{}向【{}】发动攻击，'.format(attacker['name'],
skill, target['name']
))
# 调用 hit() 函数
hit(kakarot, piccolo)下章预告：python的 类 和 对象
下章我来带你在动手编写代码过程中，逐步加深对 类 和 对象 的理解。
我们要如何定义选手类？选手与选手间的交互又要如何实现？这些问题在下一关都会得到解答。我们不见不散！
