2
练习 - 再来一盘
Hi，又见面了。如前面的预告，这一关是我们的第一个项目实操关卡。
正式实操前，我想先和你聊一聊设置项目实操关卡的目的。
在课程筹备、上线的过程中，我收到了许多学员咨询的问题，其中有一个问题尤为典型：
当我回顾自己学习编程的历程，这个答案是呼之欲出的 —— 项目实操。我始终无法忘记当我初次独立完成一个项目，那种仿佛站在世界的山巅，觉得自己无所不能的激动之情。
这种能看到自己学习成果的喜悦，可能是促使我在这条路上越走越远的原动力之一。我非常希望屏幕前的你也能感受到这份喜悦，早日感受到编程技能给你带来的变化，并因这些变化感到快乐，坚定地往下走。
基于我的教学理念，我希望大家能通过实战去成长，这体现在：能在学习初期就知道什么是关键知识，了解专业程序员一般是怎么思考和解决问题的，在一遍遍分析问题、拆解问题及解决问题的过程中真正地理解知识，并用这些知识来解决自己的问题。
考虑到实际项目较为复杂，在课程初期知识有限的情况下，对新手并不友好。因此，我根据实际情况为大家定制了5个实操项目：
在第一个小游戏项目中，我们会运用所学知识（也会适量补充一些新知识），一起完成一个文字版的人机对战小游戏，并逐步增加游戏的功能，让它变得更真实、更好玩。
中间的两个项目我会带大家编写两个实用的小程序，同时通过项目实操来感受两种不同的编程方式。
在自动化办公项目中，我们会接触两个与实际工作有关的项目，体会Python带给我们的便利性，希望能对你利用编程知识提升自身工作效率有所启发。
我会手把手地带你，走完项目实现的全程（虽然是迷你项目），以及当我们遇到难点时，如何寻找解决方案突破困境。
接下来，我想先和你谈谈一个项目一般是怎么完成的。更具体的说，程序员是如何思考和解决问题的呢？
我认为其中一个很重要的能力是【问题拆解】。问题拆解，指的是在做一件事或面对一个问题的时候，将其拆解成多个步骤或多个层次，逐步执行和解决问题，直至达到最终效果。
举个例子，在上一关的末尾，我们就将一个猜数字游戏拆解成四个目标：
当然这种拆解问题的思维并不少见。不过可能是出于长期编写代码的习惯，程序员会将问题拆得更细致一些，即拆到无法再拆为止。
像这样，我会将完成一个项目的流程总结为以下三步：
明确项目目标，是指我们希望程序达成什么目的，实现什么功能，从而帮我们将项目拆解成不同的单元；而一个妥当的拆解方案，难度适度递增，能帮我们逐步顺利执行，最终完成项目。这三个步骤可以说是环环相扣的。
那么接下来，我们就正式进入项目实操，在这个过程中，需要你多动动脑，动动手。
明确项目目标
在互联网公司，一般情况下是由产品经理提出明确的项目需求，由程序员来实现，他们之间是“相爱相杀”的关系。：）
今天且让我扮演一下产品经理的角色。我们此次要实现的需求是：人机PK小游戏。具体效果请参照下面的示意动图。
简单来说，这个游戏中，会随机生成玩家和敌人的属性，同时互相攻击，直至一方血量小于零。
另外，这样的战斗会持续三局，采取三局两胜制，最后输出战斗结果，公布获胜方。
单选题
看到这个运行效果，请你先评估一下，自己能独立完成吗？
A.
没问题，对我来说是小菜一碟。
B.
难度适中，老师适当点拨一下应该不成问题。
C.
感觉好难啊，前面课白上了，溜了溜了。
别慌，其实并不难，只要你集中精力，老师会带着你一定能做出来的！
明确了项目要实现什么效果后，就可以对项目进行拆解了。
分析过程，拆解项目
编写代码，我们无须苛求一步到位。尤其对于刚接触编程的学习者来说，层层递进、逐渐提升难度才能达到更好的练习效果。
为了让你暖暖身，同时照顾大部分同学的学习节奏，我从“功能叠加、难度递增”这个角度考虑，将我们要实现的小游戏拆分成了三个版本。
版本1.0，主要是帮我们理清战斗逻辑。而版本2.0和3.0，会涉及到一些新的知识点，到时遇到了再和大家介绍。
当项目被清晰地拆解后，剩下的就是去逐步执行，也就是重复“执行→遇到问题→解决问题→继续执行”这个循环的过程。
下面，开始正式写代码咯，让我们一个一个版本来攻克吧！
逐步执行，代码实现
首先，我们来看看版本1.0该怎么实现。
版本1.0：自定属性，人工PK
第一阶段的代码，我们的主要任务是理清战斗的逻辑，再用print()函数将战斗过程打印在终端。
我们先来思考一下，一个人机PK游戏最基础的元素是什么，我们可以拿最经典的拳皇游戏来脑补一下。
根据这一版本的设定，我们要做的主要有三步：1.规定并显示出玩家和敌人的属性 2.双方同时互相攻击，血量根据对方的攻击力扣除 3.若有一方血量小于等于0，游戏结束。
为了让我们的思路保持清晰，画成流程图就是这样子的：
别说你平时不玩游戏，不知道该怎么动手。这个版本的所有步骤，都还很不“智能”，只用到了唯一一个函数Print()。也就是说，我们只要把步骤一个一个打印上去，就算成功啦。
好，我们从第1步开始：设定【玩家】和【敌人】的属性，即【血量】和【攻击】。
1
2
第2步：手动计算攻击一次，双方各自所剩的血量。
1
2
第3步：继续做人工计算：算一算，玩家攻击2次敌人，敌人的血量就等于0了，这时候可以结束战斗，打印游戏结果。
1
2
3
4
很简单吧！现在我们要做的，就是把这三段代码拼起来，然后我会加一些修饰视觉的换行符和分割线，让运行结果看得更清楚一点。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
现在，请你直接运行一下代码，看看结果是不是如我们所愿。
已完成课堂练习
重做
分享
main.py
1
print(‘【玩家】\n血量：100\n攻击：50’)
2
print(‘————————————‘)
3
4
print(‘【敌人】\n血量：100\n攻击：30’)
5
print(‘————————————‘)
6
7
print(‘你发起了攻击，【敌人】剩余血量50’)
8
print(‘敌人向你发起了攻击，【玩家】剩余血量70’)
9
print(‘————————————‘)
10
11
print(‘你发起了攻击，【敌人】剩余血量0’)
12
print(‘敌人向你发起了攻击，【玩家】剩余血量40’)
13
print(‘———————————-‘)
14
15
print(‘敌人死翘翘了，你赢了！’)
终端
唔…虽然看起来还有点儿意思，但所有信息一下子都蹦跶出来，一点都没有体现游戏的进程感。
所以，为了让打印出的东西能有时间间隔地依次出现，我们需要设置一个类似“计时器”的东西。在Python里，我们需要用到两行代码来实现：（敲黑板，很简单的新知识）
1
2
3
4
这里有个新名词——模块，它是Python里一个重要的概念，我会在第16关给你详细介绍一番。
你可以把模块想象成是一个装着许多神奇函数的百宝箱，不过想要使用这个百宝箱里的函数，得先用 import 模块名 这样一句代码来打开它。
然后这里我们想使用time模块里的sleep()函数，也就是让代码运行结果不要一次性全部出现，而是分批分批的出现。就要写成time.sleep(secs)的形式。
如果我想设置成打印的信息间隔1.5秒出现，代码就可以这么写：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
好，看懂了代码，我们来直接运行下看下效果。
已完成课堂练习
重做
分享
main.py
1
import time #通常import语句会写到代码的开头
2
3
print(‘【玩家】\n血量：100\n攻击：50’)
4
print(‘————————————‘)
5
time.sleep(1.5)
6
#暂停1.5秒，再继续运行后面的代码
7
8
print(‘【敌人】\n血量：100\n攻击：30’)
9
print(‘————————————‘)
10
time.sleep(1.5)
11
12
print(‘你发起了攻击，【敌人】剩余血量50’)
13
print(‘敌人向你发起了攻击，【玩家】剩余血量70’)
14
print(‘————————————‘)
15
time.sleep(1.5)
16
17
print(‘你发起了攻击，【敌人】剩余血量0’)
18
print(‘敌人向你发起了攻击，【玩家】剩余血量40’)
终端
呼～总算完成了版本1.0，不过我想你一定在心里默默吐槽，一句句用print()写也太蠢太弱鸡了吧。
没错，不过代码嘛，总得一步步实现。就先当作是小小的热身。
而且，这个版本的代码还有两个明显的缺陷：一是玩家和敌人的属性（血量&攻击）是我自己说了算，那胜负早已没有悬念；二是战斗过程中血量的变化要自己手动算，那要计算机有何用？
你放心，这些都是我们会在版本2.0解决的问题。
版本2.0：随机属性，自动PK
如前所述，这个阶段，我们主要新增【随机属性】和【自动战斗】两个功能，画成流程图是这样子的：
想一想：自己来定义双方角色的属性，那简直是黑箱操作，胜负早已注定。所以，为了游戏公平，我们要让属性由自己说了算变成随机生成。
现在问题来了，要随机生成属性（数字），这课堂里又没教。怎么办？
单选题
这时，你更倾向：
A.
继续点enter，老师会教的。
B.
微信问助教，助教会懂的。
C.
自己去查下，网上会有的。
这也是老师最建议的做法，自己能独立解决问题的话，会超有满足感。
并不是老师想偷懒或者收了广告费，不过自己上网搜索确实是老师最推荐的方式。因为Python里包含的零碎知识点多如牛毛，我无法在有限的课堂里为大家逐一穷尽。
你现在已经掌握了一定的代码阅读能力，遇到卡点后上网搜索，其实就能解决目前你绝大多数的问题。“不懂就查”也是程序员的工作习惯之一呢。
接下来，我们尝试在某度上搜索“Python 随机生成数字”（有条件的优先使用Google，搜索结果会更干净）。
看起来都差不多，那就点一个进去看下吧。
我们看这段文字可以发现，要随机生成整数，就要用到random模块里的randint()函数，括号里放的是两个整数，划定随机生成整数的范围。
请你阅读下列代码注释，然后点击运行。
已完成课堂练习
重做
分享
main.py
1
#可以多运行几次，看看结果是不是随机生成的~
2
3
import random
4
#调用random模块，与
5
a = random.randint(1,100)
6
# 随机生成1-100范围内（含1和100）的一个整数，并赋值给变量a
7
print(a)
终端
好，现在终于轮到你动手敲代码了！
请听题：1.定义两个变量，来存储玩家血量和玩家攻击力的数值 2.血量是100-150的随机数，攻击力是30-50的随机数 3.将两个变量打印出来
已完成课堂练习
重做
分享
main.py
1
#提示：调用模块需在开头写上import 模块名，这里需要用到random模块
2
import random
3
a=random.randint(100,150)
4
b=random.randint(30,50)
5
print(a)
6
print(b)
终端
老师的答案是这样的：
1
2
3
4
5
6
7
应该没问题吧？不过可能稍微卡住的你不是生成随机数，反而是给变量取名字。
标准的变量名最好是用英文来表达含义，如果是多个单词组成，需要用英文下划线_来隔开。
对于取英文变量名，很多英语水平在高考即巅峰的同学会感到头疼，这里我推荐大家一个网站:CODELF，输入中文就可以看到别人是怎么命名的。
好，我们已经知道如何生成随机属性，下面我们就要将属性展示打印出来，请阅读下列代码，弄懂每一行的含义：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
那截至目前，我们已经完成了随机生成属性和展示属性，接下来我们就来实现”自动战斗”。
要怎么实现自动战斗呢？如果一头雾水的话，可以先尝试从版本1.0的人为战斗来寻找规律：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
我们可以发现，4-6行这3行是重复出现的结构，除了数字是灵活变动之外，其余是一毛一样的。
单选题
这时，根据我们已学知识，我们应该用什么来解决重复劳动？
A.
条件判断语句
B.
循环语句
答对了！
答对了！接下来可以进一步思考是该用for循环还是while循环。
说到循环，我们就要思考是要使用for循环还是while循环了。
因为现在双方的血量和攻击是随机生成，不是固定的。所以我们不知道具体要战斗多少回合才能分出胜负，也就是循环次数不明确，那自然要用while循环。
我们进一步思考：while后面要接什么条件呢，也就是说什么条件下，战斗过程会一直持续呢？请你思考一下。
单选题
一个简单的问题，在什么条件下，战斗过程（循环）会一直持续？
A.
玩家和敌人血量有一方大于0
B.
玩家和敌人血量均大于0
C.
玩家和敌人血量有一方小于0
答案是B
答案是B，如果有一方血量小于等于0，战斗就结束了。
所以我们现在确定了让循环执行需要满足的条件就是——双方血量均大于零，也就是不死不休。
可见while后面要同时满足两个条件，即这两个条件要同时为真，所以我们要用and来连接，用代码来表示就是：
1
2
现在我们确定了执行while循环的条件，接下来就是要填充循环内部的内容。
根据刚才的分析，我们希望循环的内容是双方互相攻击，掉血的过程。
1
2
3
其中【敌人】剩余血量=敌人当前血量-玩家攻击，【玩家】剩余血量=玩家当前血量-敌人攻击。
事实上我们之前已经定义好了这四个变量，每一次互相伤害后，player_life（玩家血量）和enemy_life（敌人血量）都会被重新赋值，所以转换为代码逻辑就是：
1
2
3
好，自动攻击的基础逻辑也已经理清楚了。我们先合并一下这之前写过的代码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
接下来，我们只需要补充完成while循环语句，让双方自动战斗、扣血的过程循环起来，现在就请你动手试一试，修改下面代码，完成这个功能。（可点击代码框的放大功能）
已完成课堂练习
重做
分享
main.py
1
import time, random
2
3
# 生成随机属性
4
player_life = random.randint(100, 150)
5
player_attack = random.randint(30, 50)
6
enemy_life = random.randint(100, 150)
7
enemy_attack = random.randint(30, 50)
8
9
# 展示双方属性
10
print(‘【玩家】’ + ‘血量：’ + str(player_life) + ‘攻击：’ + str(player_attack))
11
print(‘————————————‘)
12
time.sleep(1)
13
print(‘【敌人】’ + ‘血量：’ + str(enemy_life) + ‘攻击：’ + str(enemy_attack))
14
print(‘————————————‘)
15
time.sleep(1)
16
17
# 双方PK
18
while (player_life > 0) and (enemy_life > 0):
终端
如果你能顺利完成，很棒哟！老师的答案是这样子的：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
我们直接运行一下，看看结果。
已完成课堂练习
重做
分享
main.py
1
import time,random
2
3
player_life = random.randint(100,150)
4
player_attack = random.randint(30,50)
5
enemy_life = random.randint(100,150)
6
enemy_attack = random.randint(30,50)
7
8
print(‘【玩家】\n’+’血量：’+str(player_life)+’\n攻击：’+str(player_attack))
9
print(‘————————————‘)
10
time.sleep(1)
11
print(‘【敌人】\n’+’血量：’+str(enemy_life)+’\n攻击：’+str(enemy_attack))
12
print(‘————————————‘)
13
time.sleep(1)
14
15
while (player_life >0) and (enemy_life > 0):
16
player_life = player_life - enemy_attack
17
enemy_life = enemy_life - player_attack
18
print(‘你发起了攻击，【敌人】剩余血量’+str(enemy_life))
终端
你应该能感受到，版本2.0总算像模像样了，慢慢逼近我们的项目目标。
不过它还没有实现：打印出每局结果，三局两胜，并打印最终战果的功能。这就是我们在版本3.0要增加的功能。
一鼓作气，让我们顺势攻克最后一座山头。
版本3.0：打印战果，三局两胜
对比版本2.0，在版本3.0中，我们想要增加的功能是：1.打印战果：每局战斗后，根据胜负平的结果打印出不同的提示；2.三局两胜：双方战斗三局，胜率高的为最终赢家。
我反复解释新增功能，是因为这样不断地明确项目的阶段性目标，可以让自己持续专注地推进项目。
单选题
不过我觉得有必要在这个节点询问下你的状态如何，现在的你更符合下列哪种描述？
A.
继续不要停，感觉体内的代码之魂正熊熊燃烧
B.
感觉还好，和刚上课时的状态差不多
C.
感觉脑子不够用有点晕，跟不上老师的节奏
别着急，可以先休息一下，精力和专注力恢复了再继续课程，我也会放慢我的教学节奏。
休息好了吧？现在我们回到项目上，我们首先要为游戏增加“打印战果”（单局）的功能。
根据常识，结果会有胜利，失败和平局三种。那么这时候我们就得使用条件判断语句，根据不同的条件输出不同的结果。
我们先一起写一个玩家胜利的条件判断试试，请你思考一下，然后点击回车看我的答案。
1
2
怎么样，你跟我的想法应该差不多吧~那现在就请你补充下列代码，把完整的条件判断语句写出来，为游戏增加“打印战果”（单局）的功能吧！
已完成课堂练习
重做
分享
main.py
1
import time,random
2
3
# 生成双方角色，并生成随机属性。
4
player_life = random.randint(100,150)
5
player_attack = random.randint(30,50)
6
enemy_life = random.randint(100,150)
7
enemy_attack = random.randint(30,50)
8
9
# 展示双方角色的属性
10
print(‘【玩家】\n’+’血量：’+str(player_life)+’\n攻击：’+str(player_attack))
11
print(‘————————————‘)
12
time.sleep(1)
13
print(‘【敌人】\n’+’血量：’+str(enemy_life)+’\n攻击：’+str(enemy_attack))
14
print(‘————————————‘)
15
time.sleep(1)
16
17
# 双方PK
18
while player_life > 0 and enemy_life > 0:
终端
做出来了吗？你可以对比下老师的答案和你的有没什么区别，当然条件顺序不一样是无所谓的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
好啦，我们继续前进。版本3.0也只剩最后的“三局两胜”了，准备好迎接最后的挑战了吗？
同样的，我们可以将其拆分成两个部分：先来个三局，再判断最终胜负。
首先我们来看，三局战斗也是一个可以循环的结构，且循环次数是固定的，所以要用到for循环。
在这里我们可以使用for i in range( )的结构，我们先来回顾一下之前学过的range()函数：
现在，你有思路了吗？尝试把代码打出来吧，让战斗循环三局。（先不用统计最后的结果）
给两个提示：1.想清楚哪些代码要嵌套到for循环里，即一局战斗里包括什么信息。确定了for写在哪里之后，一局战斗包含的所有信息都要缩进；2.细节也需要留意，如局与局之间要怎么区分开来（时间间隔&打印局数信息）
已完成课堂练习
重做
分享
main.py
1
import time,random
2
3
# 生成双方角色，并生成随机属性。
4
player_life = random.randint(100,150)
5
player_attack = random.randint(30,50)
6
enemy_life = random.randint(100,150)
7
enemy_attack = random.randint(30,50)
8
9
# 展示双方角色的属性
10
print(‘【玩家】\n’+’血量：’+str(player_life)+’\n攻击：’+str(player_attack))
11
print(‘————————————‘)
12
time.sleep(1)
13
print(‘【敌人】\n’+’血量：’+str(enemy_life)+’\n攻击：’+str(enemy_attack))
14
print(‘————————————‘)
15
time.sleep(1)
16
17
# 双方PK
18
while player_life > 0 and enemy_life > 0:
19
player_life = player_life - enemy_attack
20
enemy_life = enemy_life - player_attack
21
print(‘你发起了攻击，【敌人】剩余血量’+str(enemy_life))
22
print(‘敌人向你发起了攻击，【玩家】剩余血量’+str(player_life))
23
print(‘———————————-‘)
24
time.sleep(1.5)
25
26
# 打印战果
27
if player_life > 0 and enemy_life <= 0:
28
print(‘敌人死翘翘了，你赢了’)
29
elif player_life <= 0 and enemy_life > 0:
30
print(‘悲催，敌人把你干掉了！’)
31
else:
32
print(‘哎呀，你和敌人同归于尽了！’)
33
终端
如果做起来有些障碍，检查一下是否存在上面提示的这几个问题：1. for循环语句的位置放的对不对？这个关键在于，你想让哪些信息被循环展示。例如：如果你错将for循环语句放在了【随机属性】 和【自动战斗】之间，那每一局的战斗信息会是一样的，也就不存在什么三局两胜了。
2.你写完for循环语句后，需要缩进的信息【整体】缩进了吗？如果没有缩进，可能存在报错，或者只有部分战斗信息循环的情况。
3.细节注意到了吗？局与局之间要有明显间隔，那我们可以同时使用time.sleep()和print(‘现在是第x局’)来完美解决这个问题。此外，遇到各种报错的话，记得去搜索一下，看看报的是什么错，先自己尝试解决看看。
好，现在来看我的答案，请你主要看3-5行（后面内容都要放在for循环内部），然后运行看看效果。
已完成课堂练习
重做
分享
main.py
1
import time,random
2
3
for i in range(1,4):
4
time.sleep(1.5) # 让局与局之间有较明显的有时间间隔
5
print(‘ \n——————现在是第’+str(i)+’局，ready go!——————‘) # 作为局的标记
6
7
player_life = random.randint(100,150)
8
player_attack = random.randint(30,50)
9
enemy_life = random.randint(100,150)
10
enemy_attack = random.randint(30,50)
11
12
# 展示双方角色的属性
13
print(‘【玩家】\n’+’血量：’+str(player_life)+’\n攻击：’+str(player_attack))
14
print(‘————————————‘)
15
time.sleep(1)
16
print(‘【敌人】\n’+’血量：’+str(enemy_life)+’\n攻击：’+str(enemy_attack))
17
print(‘————————————‘)
18
time.sleep(1)
终端
OK，打三局这个需求也成功了。现在我们距离最后的终点只剩一步之遥，只有“统计三局两胜的结果”这个功能还没实现了。
我们可以想一想，平常我们是怎么统计比赛结果呢？
好比乒乓球比赛，有一方赢了一局就翻一下计分牌，让数字+1，最后看哪边的数字大就是哪边获胜。
对于计算机也是如此：它靠数据思考，比如拿数据做计算、做条件判断、做循环等。所以这里的关键就在于，要给计算机数据。
那么仿照计分牌的做法，我们的解决方法也就出来了：采取计分的方式，赢一局记一分，平局不计分。
所以，我们要给计算机一个空白的“计分板”，用于存放【玩家】和【敌人】每一局的得分。
1
2
3
4
那什么情况下，这两个变量会变动（+1）呢？自然是要与具体每一局的结果挂钩，这时候可以回看我们计算输赢的条件判断语句。
1
2
3
4
5
6
然后，我们将敌人和玩家各自赢的局数给算出来：
1
2
3
4
5
6
7
8
9
10
11
这样三局过后，player_victory和enemy_victory会被赋上新的值。给你一个小技巧：player_victory = player_victory + 1，总是这样写有点烦人，我们可以写作player_victory += 1，这两个代码是等价的，都代表”如果if后的条件满足，变量就+1”。
这也是程序员是追求“极简”的体现。好，我们把这段代码替换一下：
1
2
3
4
5
6
7
8
9
10
11
现在，我们只需要再用一次条件判断，比较两个变量的大小就能知道谁输谁赢了。
我会把思维逻辑展示给你，然后请你将它转换为代码就可以了。注意思考：这一次的条件判断，要不要缩进呢？
现在，请你动手把最后一步的代码，敲出来吧。加油，胜利就在前方！
已完成课堂练习
重做
分享
main.py
1
import time,random
2
3
player_victory = 0
4
enemy_victory = 0
5
6
for i in range(1,4):
7
time.sleep(2) # 让局与局之间有较明显的有时间间隔
8
print(‘ \n——————现在是第’+str(i)+’局——————‘) # 作为局的标记
9
10
player_life = random.randint(100,150)
11
player_attack = random.randint(30,50)
12
enemy_life = random.randint(100,150)
13
enemy_attack = random.randint(30,50)
14
15
# 展示双方角色的属性
16
print(‘【玩家】\n’+’血量：’+str(player_life)+’\n攻击：’+str(player_attack))
17
print(‘————————————‘)
18
time.sleep(1)
19
print(‘【敌人】\n’+’血量：’+str(enemy_life)+’\n攻击：’+str(enemy_attack))
20
print(‘————————————‘)
21
time.sleep(1)
22
23
# 双方PK
24
while player_life > 0 and enemy_life > 0:
25
player_life = player_life - enemy_attack
26
enemy_life = enemy_life - player_attack
27
print(‘你发起了攻击，【敌人】剩余血量’+str(enemy_life))
28
print(‘敌人向你发起了攻击，【玩家】剩余血量’+str(player_life))
29
print(‘———————————-‘)
30
time.sleep(1.5)
31
32
#打印最终战果
33
if player_life > 0 and enemy_life <= 0:
34
player_victory += 1
35
print(‘敌人死翘翘了，你赢了！’)
36
elif player_life <= 0 and enemy_life > 0:
37
enemy_victory += 1
38
print(‘悲催，敌人把你干掉了！’)
39
else:
40
print(‘哎呀，你和敌人同归于尽了！’)
41
42
#判断最终结果
43
if player_victory>1:
44
print(‘player win’)
45
elif enemy_victory>1:
46
print(‘enemy win’)
终端
写出来没？我觉得，你应该没啥问题~ 我们还是回顾一下最后一步，将条件判断的思维逻辑转换成代码逻辑的话是这样子的：
所以老师的答案是这样子的，需要注意的是最终判断结果要放在for循环外面，也就是不用缩进。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
我们可算把最后代码写出来了！如果你是从头学起的新手，这四十几行的代码可能你目前打过最长的代码了吧？别客气，为你自己鼓鼓掌！
按照惯例，我应该要为你放烟花：
不过，这还没完呢。作为一个程序员，代码是我们的名片，我们会追求更加优雅的，方便他人阅读的代码，所以上述代码还有一些优化空间。
所以，以下是彩蛋时间，我会教大家一个新的知识点——【格式化字符串】，作为这一关的收尾。
什么意思呢，上面有这么两行代码，是用来展示双方角色的属性的：
1
2
我们在用+拼接字符串和变量的时候，常常需要考虑变量是什么类型的数据，如果不是字符串类型，还先需要str()函数转换。
并且一句话常常要拼接成好几个部分，然后我们要考虑每一对引号‘ ‘的起始位置，好麻烦，相信你多少会有点体会。
所以，为了更方便地实现不同数据类型的拼接，用【格式符%】是更常用更便利的一种方式。
我们可以把%想象成：图书馆里用来占位的一本书。先占一个位置，之后再填上实际的变量。举个例子：下面这两种写法是相同的，请你着重研究下第二行的语法。
1
2
我们看到格式符%后面有一个字母s，这是一个类型码，用来控制数据显示的类型。%s就表示先占一个字符串类型的位置。
还有其他常见的类型码如下图所示：
占完位置之后，我们要以%的形式在后面补上要填充的内容，如此一来我们就免去了转换类型的烦恼。如果是多个数据，就要把它们放进括号，按顺序填充，用逗号隔开。
举个例子，你可以运行一下，对比下列输出的结果：
已完成课堂练习
重做
分享
main.py
1
lucky = 8
2
print(‘我的幸运数字是%d’ % lucky)
3
print(‘我的幸运数字是%d’ % 8)
4
print(‘我的幸运数字是%s’ % ‘小龙女的生日816’)
5
print(‘我的幸运数字是%d和%d’ % (8,16))
终端
一个小小的提示：%后面的类型码用什么，取决于你希望这个%占住的这个位置的数据以什么类型展示出来，如果你希望它以字符串形式展示，那就写%s，如果你希望它以整数形式展示，那就写%d。
这就出现了一些容易混淆的地方，比如，请运行以下的代码：
已完成课堂练习
重做
分享
main.py
1
print(‘我的幸运数字是%d’ % 8) #8以整数展示
2
print(‘我的幸运数字是%s’ % 8) #8以字符串展示
3
4
print(8) #整数8与字符串’8’打印出来的结果是一样的
5
print(‘8’)
终端
选用了不同的类型码，打印出的结果却是一样，原因也已经在代码注释中写清楚了：因为整数8与字符串’8’的打印结果是一样的，所以选两种类型码都OK。但这种“都OK”的情况仅限于整数，对文字是行不通的：
已跳过课堂练习
重做
分享
main.py
1
#运行后报错，请点击“跳过本题”
2
print(‘我的幸运数字是%s’ % ‘小龙女的生日816’)
3
print(‘我的幸运数字是%d’ % ‘小龙女的生日816’)
终端
会报错，对吧？好啦，现在你应该更懂这个格式化字符串该怎么用了。
那就看回我们之前的代码，如果把一开始用+拼接的字符串都替换成%格式符表示，我们先替换一部分试试
1
2
3
4
5
6
7
8
你也许想问我，这里的%s是不是都能换成%d，答案是“YES!”，因为这里的变量i,player_life,player_attack统统都是整数。
好，我们这次先选择使用%s，来看完整的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
是不是看起来清爽了些？如果还不习惯这种表示方法没有关系，老师会在后续的课程里强化，多写几次就习惯啦。
现在我保证真是最后一步了，请你直接运行下面的代码，感受一下我们这一路走来的成果吧。
已完成课堂练习
重做
分享
main.py
1
import time
2
import random
3
4
player_victory = 0
5
enemy_victory = 0
6
7
for i in range(1,4):
8
time.sleep(1.5)
9
print(‘ \n——————现在是第 %s 局——————‘ % i)
10
player_life = random.randint(100,150)
11
player_attack = random.randint(30,50)
12
enemy_life = random.randint(100,150)
13
enemy_attack = random.randint(30,50)
14
15
print(‘【玩家】\n血量：%s\n攻击：%s’ % (player_life,player_attack))
16
print(‘————————————‘)
17
time.sleep(1)
18
print(‘【敌人】\n血量：%s\n攻击：%s’ % (enemy_life,enemy_attack))
终端
以上就是我们的第一节项目实操课啦，主要用到的还是我们先前学的循环语句和条件判断语句，不知看到这里的你，是否觉得还算轻松愉快，也有一些成就感？
更为重要的，其实不是我们做出了什么项目，而是我们能否灵活运用知识，和掌握做项目的方法。希望现在的你，对学习编程有了与我同样的感受。
最后我们再来回顾一下做项目的三个步骤。
下一关呢，我会尝试讲一讲“编程思维”，而不是这么快就继续讲一些新的知识。因为看到了同学们给助教的一些课程和练习中的障碍反馈，我希望能够在学习的路上，一路陪伴你走向更远的地方，也带给你更宽阔的视野。
而在编程学习中，更宽阔的视野无疑来自编程技能背后的种种思维。
所以，下一关我会针对同学们在学习Python时会遇到的两大瓶颈，提出一些解决方案。我们下一关见！
再啰嗦一句，课后练习记得要去做哦！
更多练习>>>>>>
练习 - 再来一盘
中等
游戏玩得不过瘾？那就再来一盘吧。
print('【玩家】血量：100 攻击：50') # 自定义玩家角色的血量和攻击print('【敌人】血量：100 攻击：30') # 自定义敌人角色的血量和攻击
print('你发起了攻击，【敌人】剩余血量50') # 人工计算敌人血量：100-50=50print('敌人向你发起了攻击，【玩家】剩余血量70') # 人工计算玩家血量：100-30=70
print('你发起了攻击，【敌人】剩余血量0') # 双方同时攻击，若血量出现小于等于0，游戏结束print('敌人向你发起了攻击，【玩家】剩余血量40')print('敌人死翘翘了，你赢了！') # 打印结果
print('【玩家】\n血量：100\n攻击：50') # 自定义玩家角色的血量和攻击，用换行符'\n'来优化视觉print('------------------------') # 辅助功能，起到视觉分割的作用，让代码的运行结果更清晰print('【敌人】\n血量：100\n攻击：30')print('------------------------')print('你发起了攻击，【敌人】剩余血量50') # 人工计算敌人血量：100-50=50print('敌人向你发起了攻击，【玩家】剩余血量70') # 人工计算玩家血量：100-30=70print('------------------------')print('你发起了攻击，【敌人】剩余血量0') # 双方同时攻击，若血量出现小于等于0，游戏结束print('敌人向你发起了攻击，【玩家】剩余血量40')print('-----------------------')print('敌人死翘翘了，你赢了！') # 打印结果
import time #调用time模块time.sleep(secs) #使用time模块下面的sleep()函数，括号里填的是间隔的秒数（seconds，简称secs）#time.sleep(1.5)就表示停留1.5秒再运行后续代码
import time #通常import语句会写到代码的开头print('【玩家】\n血量：100\n攻击：50') print('------------------------') time.sleep(1.5)#暂停1.5秒，再继续运行后面的代码print('【敌人】\n血量：100\n攻击：30')print('------------------------')time.sleep(1.5)#同上print('你发起了攻击，【敌人】剩余血量50') print('敌人向你发起了攻击，【玩家】剩余血量70') print('------------------------')time.sleep(1.5)print('你发起了攻击，【敌人】剩余血量0') print('敌人向你发起了攻击，【玩家】剩余血量40')print('-----------------------')time.sleep(1.5)print('敌人死翘翘了，你赢了！')
import randomplayer_life = random.randint(100,150)#表示玩家血量player_attack = random.randint(30,50)#表示玩家攻击print(player_life)print(player_attack)
import timeimport random#也可合并写成一行：import time,random# 生成随机属性player_life = random.randint(100,150) # “player_life” 代表玩家血量player_attack = random.randint(30,50) # “player_attack” 代表玩家攻击enemy_life = random.randint(100,150) # “enemy_life” 代表敌人血量enemy_attack = random.randint(30,50) # “enemy_attack” 代表敌人攻击# 展示双方角色的属性print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))#player_life和player_attack的数据类型都是整数，所以拼接时需要先用str()转换print('------------------------')time.sleep(1)#暂停一秒再执行后续代码print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))print('------------------------')
print('【玩家】 血量：130 攻击：50') print('【敌人】 血量：150 攻击：40')print('你发起了攻击，【敌人】剩余血量100') print('敌人向你发起了攻击，【玩家】剩余血量90') print('------------------------')print('你发起了攻击，【敌人】剩余血量50') print('敌人向你发起了攻击，【玩家】剩余血量70')print('-----------------------')print('你发起了攻击，【敌人】剩余血量0') print('敌人向你发起了攻击，【玩家】剩余血量40')print('-----------------------')print('敌人死翘翘了，你赢了！')
while (player_life >= 0) and (enemy_life >= 0):#and两边的条件分别用括号括起，是一种习惯，方便阅读
print('你发起了攻击，【敌人】剩余血量xxx') print('敌人向你发起了攻击，【玩家】剩余血量xxx') print('------------------------')
player_life = player_life - enemy_attack enemy_life = enemy_life - player_attack #赋值语句的执行顺序是先计算等号右边，再赋值给左边的变量
import time,random# 生成随机属性player_life = random.randint(100,150) player_attack = random.randint(30,50) enemy_life = random.randint(100,150) enemy_attack = random.randint(30,50) # 展示双方角色的属性print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))#player_life和player_attack都是整数类型，所以拼接时需要先用str()转换print('------------------------')time.sleep(1)print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))print('------------------------')time.sleep(1)while (player_life >0) and (enemy_life > 0): player_life = player_life - enemy_attack enemy_life = enemy_life - player_attack
import time,randomplayer_life = random.randint(100,150) player_attack = random.randint(30,50) enemy_life = random.randint(100,150) enemy_attack = random.randint(30,50) print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))print('------------------------')time.sleep(1)print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))print('------------------------')time.sleep(1)while (player_life >0) and (enemy_life > 0): player_life = player_life - enemy_attack enemy_life = enemy_life - player_attack print('你发起了攻击，【敌人】剩余血量'+str(enemy_life)) #player_life是整数，所以拼接时要先用str()转换 print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life)) print('------------------------') time.sleep(1.5) # 为了体现出战斗回合，这里停顿1.5秒
if player_life > 0 and enemy_life <= 0: print('敌人死翘翘了，你赢了')
import time,random# 生成双方角色，并生成随机属性。player_life = random.randint(100,150)player_attack = random.randint(30,50)enemy_life = random.randint(100,150)enemy_attack = random.randint(30,50)# 展示双方角色的属性print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))print('------------------------')time.sleep(1)print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))print('------------------------')time.sleep(1)# 双方PKwhile player_life > 0 and enemy_life > 0: player_life = player_life - enemy_attack enemy_life = enemy_life - player_attack print('你发起了攻击，【敌人】剩余血量'+str(enemy_life)) print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life)) print('-----------------------') time.sleep(1.5)# 打印战果if player_life > 0 and enemy_life <= 0: print('敌人死翘翘了，你赢了')elif player_life <= 0 and enemy_life > 0: print('悲催，敌人把你干掉了！')else: print('哎呀，你和敌人同归于尽了！')
player_victory = 0#存放玩家赢的局数。enemy_victory = 0#存放敌人赢的局数
if player_life > 0 and enemy_life <= 0: #玩家赢 print('敌人死翘翘了，你赢了')elif player_life <= 0 and enemy_life > 0: #敌人赢 print('悲催，敌人把你干掉了！')else: #平局 print('哎呀，你和敌人同归于尽了！')
player_victory = 0enemy_victory = 0if player_life > 0 and enemy_life <= 0: player_victory = player_victory + 1 print('敌人死翘翘了，你赢了！')elif player_life <= 0 and enemy_life > 0: enemy_victory = enemy_victory + 1 print('悲催，敌人把你干掉了！')else: print('哎呀，你和敌人同归于尽了！')
player_victory = 0enemy_victory = 0if player_life > 0 and enemy_life <= 0: player_victory += 1 print('敌人死翘翘了，你赢了！')elif player_life <= 0 and enemy_life > 0: enemy_victory += 1 print('悲催，敌人把你干掉了！')else: print('哎呀，你和敌人同归于尽了！')
import time,randomplayer_victory = 0enemy_victory = 0for i in range(1,4): time.sleep(2) # 让局与局之间有较明显的有时间间隔 print(' \n——————现在是第'+str(i)+'局——————') # 作为局的标记 player_life = random.randint(100,150) player_attack = random.randint(30,50) enemy_life = random.randint(100,150) enemy_attack = random.randint(30,50) # 展示双方角色的属性 print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack)) print('------------------------') time.sleep(1) print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack)) print('------------------------') time.sleep(1) # 双方PK while player_life > 0 and enemy_life > 0: player_life = player_life - enemy_attack enemy_life = enemy_life - player_attack print('你发起了攻击，【敌人】剩余血量'+str(enemy_life)) print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life)) print('-----------------------') time.sleep(1.5) #打印最终战果 if player_life > 0 and enemy_life <= 0: player_victory += 1 print('敌人死翘翘了，你赢了！') elif player_life <= 0 and enemy_life > 0: enemy_victory += 1 print('悲催，敌人把你干掉了！') else: print('哎呀，你和敌人同归于尽了！')if player_victory > enemy_victory : time.sleep(1) print('【最终结果：你赢了！】')elif enemy_victory > player_victory: print('【最终结果：你输了！】')else: print('【最终结果：平局！】')
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
print('血量：'+str(player_life)+' 攻击：'+str(player_attack))print('血量：%s 攻击：%s' % (player_life,player_attack))
print(' \n——————现在是第'+str(i)+'局——————') #替换前print(' \n——————现在是第 %s 局——————' % i) #替换后print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack)) #替换前print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack)) #替换后print('敌人发起了攻击，【玩家】剩余血量'+str(player_life)) #替换前print('敌人发起了攻击，【玩家】剩余血量%s' % player_life) #替换后
import timeimport randomplayer_victory = 0enemy_victory = 0for i in range(1,4): time.sleep(1.5) print(' \n——————现在是第 %s 局——————' % i) #对比之前：(' \n——————现在是第'+str(i)+'局——————') player_life = random.randint(100,150) player_attack = random.randint(30,50) enemy_life = random.randint(100,150) enemy_attack = random.randint(30,50) print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack)) print('------------------------') time.sleep(1) print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack)) print('-----------------------') time.sleep(1) while player_life > 0 and enemy_life > 0: player_life = player_life - enemy_attack enemy_life = enemy_life - player_attack print('你发起了攻击，【敌人】剩余血量%s' % enemy_life) print('敌人向你发起了攻击，【玩家】的血量剩余%s' % player_life) print('-----------------------') time.sleep(1.2) if player_life > 0 and enemy_life <= 0: player_victory += 1 print('敌人死翘翘了，你赢了！') elif player_life <= 0 and enemy_life > 0: enemy_victory += 1 print('悲催，敌人把你干掉了！') else: print('哎呀，你和敌人同归于尽了！')if player_victory > enemy_victory : time.sleep(1) print('\n【最终结果：你赢了！】')elif enemy_victory > player_victory: print('\n【最终结果：你输了！】')else: print('\n【最终结果：平局！】')
