python面向过程与初始面向对象编程

让我们穿越到《龙珠》世界，一起揭开 面向对象编程 的神秘面纱吧。

面向过程编程与面向对象编程

天下第一武道会

选手登记

第 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 后同理。

我们将上述思路整合一下，就能画出决斗过程流程图啦：

搭好了整体框架，下面我们来逐步填充细节吧～

攻击，防御

循环体内有两大关键步骤，因此我们可以设计两个函数：

1. 发起攻击函数 hit()：接受 2 个参数，第一个参数表示攻击方，第二个参数表示攻击对象；
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'] - damageprint('>> 【{}】受到 {} 点伤害...\n'.format(defender['name'], damage))

提示：这里的前缀“>> ”仅起到装饰作用。你可以根据自己的喜好设计不同的输出效果哦～

编程练习

请你根据上面分析过程，完成防御攻击函数 defend()，并按照注释中的要求调用函数。

要求

1. 防御方有 20% 几率完美闪避攻击；
2. 若闪避成功，则输出 >> 【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）。这就是面向对象编程的魅力所在！

面向对象编程的概念就介绍到这里啦。

类 是抽象的模板，对象 是具象的个体。上述过程中共出现了三位角色，分别是大勇、卡卡罗特、比克大魔王，所以涉及到的对象就是他们三人。而“主持人”与“选手”是他们所属的 类。

改用另一种思维方式分析问题是一项需要不断练习才能真正领会、掌握的事，不能一蹴而就。所以本关我们重在梳理 决斗过程 逻辑，并简要了解了 面向对象编程 的概念，知道了它和我们传统的 面向过程编程 方式间的区别：

编程练习_回合制决胜负

请你根据 决斗过程流程图 和注释中的提示信息，补全代码，让卡卡罗特和比克大魔王展开决斗吧！你也可以在此基础上修改，让决斗过程更加丰富有趣哦。

决斗说明

1. 决斗采取 回合制；
2. 由卡卡罗特先发动攻击。

决斗过程流程图

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'] - damageprint('>> 【{}】受到 {} 点伤害...\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’怎能体现出我强大的招式呢？我提议，在登记信息时将我们的绝招也登记上去，决斗时各自报出技能。谁敢不从？”

主办本想拉着卡卡罗特一行人撑腰，没想到小悟空连连点头：“对呀，喊出技能名多酷哇。就这么办吧！”

哎……看来只能麻烦你改进一下之前的代码了。

要求

1. 选用 合适 的数据类型存储每位选手信息；
2. 编写 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的 类 和 对象

下章我来带你在动手编写代码过程中，逐步加深对 类 和 对象 的理解。

我们要如何定义选手类？选手与选手间的交互又要如何实现？这些问题在下一关都会得到解答。我们不见不散！