猫哥教你写爬虫 014--pk小游戏

项目实操

但是项目实操会遇到很多问题...

问题拆解

在做一件事或面对一个问题的时候，将其拆解成多个步骤或多个层次，

逐步执行和解决问题，直至达到最终效果。

猜数字的思路

一般情况下是由产品经理提出明确的项目需求，由程序员来实现，

他们之间是“相爱相杀”的关系。：）

人机pk小游戏(聊聊最早的电脑游戏是怎么玩的)

这个游戏中，会随机生成玩家和敌人的属性，同时互相攻击，直至一方血量小于零

这样的战斗会持续三局，采取三局两胜制，最后输出战斗结果，公布获胜方

当项目被清晰地拆解后，剩下的就是去逐步执行，

也就是重复“执行→遇到问题→解决问题→继续执行”这个循环的过程。

首先, 简单打印即可

print('【玩家】血量：100 攻击：50')  # 自定义玩家角色的血量和攻击
print('【敌人】血量：100 攻击：30')  # 自定义敌人角色的血量和攻击
复制代码

手动攻击一次, 计算血量

print('你发起了攻击，【敌人】剩余血量50')  # 人工计算敌人血量：100-50=50
print('敌人向你发起了攻击，【玩家】剩余血量70')  # 人工计算玩家血量：100-30=70
复制代码

继续做人工计算：算一算，玩家攻击2次敌人，敌人的血量就等于0了，

这时候可以结束战斗，打印游戏结果。

print('你发起了攻击，【敌人】剩余血量0')  # 双方同时攻击，若血量出现小于等于0，游戏结束
print('敌人向你发起了攻击，【玩家】剩余血量40')
print('敌人死翘翘了，你赢了！') # 打印结果
复制代码

把这三段代码拼起来，然后我会加一些修饰视觉的换行符和分割线，让运行结果看得更清楚一点

print('【玩家】\n血量：100\n攻击：50')  # 自定义玩家角色的血量和攻击，用换行符'\n'来优化视觉
print('------------------------')  # 辅助功能，起到视觉分割的作用，让代码的运行结果更清晰
print('【敌人】\n血量：100\n攻击：30')
print('------------------------')
print('你发起了攻击，【敌人】剩余血量50')  # 人工计算敌人血量：100-50=50
print('敌人向你发起了攻击，【玩家】剩余血量70')  # 人工计算玩家血量：100-30=70
print('------------------------')
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
i = 9
while i>=0:
    print(i)
    i = i - 1
    time.sleep(1)
复制代码

如果我想设置成打印的信息间隔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('敌人死翘翘了，你赢了！') 
复制代码

这个版本的代码还有两个明显的缺陷：

一是玩家和敌人的属性（血量&攻击）是我自己说了算，那胜负早已没有悬念；

二是战斗过程中血量的变化要自己手动算，那要计算机有何用？

遇到不会的知识点怎么办?

小试牛刀, 练一下随机数

1.定义两个变量，来存储玩家血量和玩家攻击力的数值

2.血量是100-150的随机数，攻击力是30-50的随机数

3.将两个变量打印出来

import random
player_life = random.randint(100,150)
#表示玩家血量
player_attack = random.randint(30,50)
#表示玩家攻击
print(player_life)
print(player_attack)
复制代码

其实最难的是起名字...

使用随机数, 修改原来的1.0的代码

import time
import 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('------------------------')
复制代码

怎么自动战斗呢? 从1.0的版本中找点规律...

print('【玩家】 血量：130  攻击：50')  
print('【敌人】 血量：150  攻击：40')
print('你发起了攻击，【敌人】剩余血量100')  
print('敌人向你发起了攻击，【玩家】剩余血量90') 
print('------------------------')
print('你发起了攻击，【敌人】剩余血量50')  
print('敌人向你发起了攻击，【玩家】剩余血量70')
print('-----------------------')
print('你发起了攻击，【敌人】剩余血量0')  
print('敌人向你发起了攻击，【玩家】剩余血量40')
print('-----------------------')
print('敌人死翘翘了，你赢了！')
复制代码

4-6行这3行是重复出现的结构，除了数字是灵活变动之外，其余是一毛一样

应该使用for还是while?

while (player_life >= 0) and (enemy_life >= 0):
#and两边的条件分别用括号括起，方便查看优先级
复制代码

【敌人】剩余血量=敌人当前血量-玩家攻击，【玩家】剩余血量=玩家当前血量-敌人攻击

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))
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秒  
复制代码

对比版本2.0，在版本3.0中，我们想要增加的功能是：

1.打印战果：每局战斗后，根据胜负平的结果打印出不同的提示；

2.三局两胜：双方战斗三局，胜率高的为最终赢家。

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)
# 双方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:
    print('敌人死翘翘了，你赢了')
elif player_life <= 0 and enemy_life > 0:
    print('悲催，敌人把你干掉了！')
else:
    print('哎呀，你和敌人同归于尽了！')
复制代码

提示:

1.想清楚哪些代码要嵌套到for循环里，即一局战斗里包括什么信息。确定了for写在哪里之后，一局战斗包含的所有信息都要缩进；

2.细节也需要留意，如局与局之间要怎么区分开来（时间间隔&打印局数信息）

import time,random
for i in range(1,4):
    time.sleep(1.5)  # 让局与局之间有较明显的有时间间隔
    print(' \n——————现在是第'+str(i)+'局，ready go!——————')  # 作为局的标记
 
    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:
        print('敌人死翘翘了，你赢了')
    elif player_life <= 0 and enemy_life > 0:
        print('悲催，敌人把你干掉了！')
    else:
        print('哎呀，你和敌人同归于尽了！')
复制代码

我们如何计分?

我们的策略 采取计分的方式，赢一局记一分，平局不计分。

原来代码有这么一段...

加上计分后

虽然python没有++但是有+=, 所以代码还可以这么写...

import time,random
player_victory = 0
enemy_victory = 0
for 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('【最终结果：平局！】')
复制代码

格式化字符串

格式化之前, 我们需要这么拼接字符串...

如果使用格式化字符串...

所谓格式化字符串, 有点像填空...

小作业:

使用格式化字符串的方式, 输出如下结果

代码参考

使用字符串格式化, 把原来的代码进行替换...

最新代码

import time
import random
player_victory = 0
enemy_victory = 0
for 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【最终结果：平局！】')
复制代码

扩展, 游戏结束时, 询问你, 是否要再来一局, 如果回复是继续, 其他退出

实现根据输入退出循环, 有两种方式

break

# 请你补充2行代码，完成方案1的思路验证。
while True:
    a1 = input('要继续游戏吗，请输入n退出，输入其他继续：')
    if a1 == 'n':
        break
复制代码

变量赋值False

# 请你补充4行代码，完成方案1的思路验证。
again = True
while again:
    a2 = input('要继续游戏吗，请输入y继续，输入其他退出：')
    if a2 != 'y':
        again = False
复制代码

最新代码

import time
import random
player_victory = 0
enemy_victory = 0
while True:
    for i in range(1,4):
        time.sleep(1.5)
        print('  \n——————现在是第 %s 局——————' % 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【最终结果：平局！】')
    res = input('要不要再来一局? (回复"是"再来一局, 其他退出...) ')
    if res != '是':
        break
复制代码

更强大的字符串格式化format

试分析输出的结果...

# % 格式化：str % ()
print('%s%d'%('数字：',0))
print('%d，%d'%(0,1))
print('%d，%d，%d'%(0,1,0))
name1 = 'Python'
print('I am learning %s'% name1)  # 注：当只跟一个数据时，%后可不加括号，format()一定要有。
# format()格式化函数：str.format()
print('\n{}{}'.format('数字：',0))  # 优势1：不用担心用错类型码。
print('{}，{}'.format(0,1))  # 不设置指定位置时，默认按顺序对应。
print('{1}，{0}'.format(0,1))  # 优势2：当设置指定位置时，按指定的对应。
print('{0}，{1}，{0}'.format(0,1))  # 优势3：可多次调用format后的数据。
name2 =  'Python基础语法'
print('我正在学{}'.format(name2))  # format()函数也接受通过参数传入数据。
复制代码

使用format修改原来的代码...

import time
import random
player_victory = 0
enemy_victory = 0
while True:
    for i in range(1,4):
        time.sleep(1.5)
        print('  \n——————现在是第 {} 局——————'.format(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血量：{}\n攻击：{}'.format(player_life,player_attack))
        print('------------------------')
        time.sleep(1)
        print('【敌人】\n血量：{}\n攻击：{}'.format(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('敌人发起了攻击，【玩家】剩余血量{}'.format(player_life))
            print('你发起了攻击，【敌人】的血量剩余{}'.format(enemy_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【最终结果：平局！】')
    res = input('要不要再来一局? (回复"是"再来一局, 其他退出...) ')
    if res != '是':
        break
复制代码

快速跳转:

猫哥教你写爬虫 000--开篇.md
猫哥教你写爬虫 001--print()函数和变量.md
猫哥教你写爬虫 002--作业-打印皮卡丘.md
猫哥教你写爬虫 003--数据类型转换.md
猫哥教你写爬虫 004--数据类型转换-小练习.md
猫哥教你写爬虫 005--数据类型转换-小作业.md
猫哥教你写爬虫 006--条件判断和条件嵌套.md
猫哥教你写爬虫 007--条件判断和条件嵌套-小作业.md
猫哥教你写爬虫 008--input()函数.md
猫哥教你写爬虫 009--input()函数-人工智能小爱同学.md
猫哥教你写爬虫 010--列表,字典,循环.md
猫哥教你写爬虫 011--列表,字典,循环-小作业.md
猫哥教你写爬虫 012--布尔值和四种语句.md
猫哥教你写爬虫 013--布尔值和四种语句-小作业.md
猫哥教你写爬虫 014--pk小游戏.md
猫哥教你写爬虫 015--pk小游戏(全新改版).md
猫哥教你写爬虫 016--函数.md
猫哥教你写爬虫 017--函数-小作业.md
猫哥教你写爬虫 018--debug.md
猫哥教你写爬虫 019--debug-作业.md
猫哥教你写爬虫 020--类与对象(上).md
猫哥教你写爬虫 021--类与对象(上)-作业.md
猫哥教你写爬虫 022--类与对象(下).md
猫哥教你写爬虫 023--类与对象(下)-作业.md
猫哥教你写爬虫 024--编码&&解码.md
猫哥教你写爬虫 025--编码&&解码-小作业.md
猫哥教你写爬虫 026--模块.md
猫哥教你写爬虫 027--模块介绍.md
猫哥教你写爬虫 028--模块介绍-小作业-广告牌.md
猫哥教你写爬虫 029--爬虫初探-requests.md
猫哥教你写爬虫 030--爬虫初探-requests-作业.md
猫哥教你写爬虫 031--爬虫基础-html.md
猫哥教你写爬虫 032--爬虫初体验-BeautifulSoup.md
猫哥教你写爬虫 033--爬虫初体验-BeautifulSoup-作业.md
猫哥教你写爬虫 034--爬虫-BeautifulSoup实践.md
猫哥教你写爬虫 035--爬虫-BeautifulSoup实践-作业-电影top250.md
猫哥教你写爬虫 036--爬虫-BeautifulSoup实践-作业-电影top250-作业解析.md
猫哥教你写爬虫 037--爬虫-宝宝要听歌.md
猫哥教你写爬虫 038--带参数请求.md
猫哥教你写爬虫 039--存储数据.md
猫哥教你写爬虫 040--存储数据-作业.md
猫哥教你写爬虫 041--模拟登录-cookie.md
猫哥教你写爬虫 042--session的用法.md
猫哥教你写爬虫 043--模拟浏览器.md
猫哥教你写爬虫 044--模拟浏览器-作业.md
猫哥教你写爬虫 045--协程.md
猫哥教你写爬虫 046--协程-实践-吃什么不会胖.md
猫哥教你写爬虫 047--scrapy框架.md
猫哥教你写爬虫 048--爬虫和反爬虫.md
猫哥教你写爬虫 049--完结撒花.md

转载于:https://juejin.im/post/5cfc4ad7e51d45777540fd7e