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

时间  2019-12-04
标签 爬虫 游戏 栏目 网络爬虫 繁體版
原文   原文链接

1558453998799

项目实操

可是项目实操会遇到不少问题...

问题拆解

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

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

猜数字的思路

1558454462450
1558454594659

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

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

1558454943128
1558455042424

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

1558502809598

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

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

1558502829941
1558455322810

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

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

1558455417666
1558456200301

首先, 简单打印便可

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秒再运行后续代码
复制代码

咱们来作一个倒计时

1558456604202 

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('敌人死翘翘了，你赢了！') 
复制代码

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

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

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

1558456803160
1558456814914

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

1558456897068
1558456942370

小试牛刀, 练一下随机数

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

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

1558457335996

使用随机数, 修改原来的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('------------------------')
复制代码

1558457124572

怎么自动战斗呢? 从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行是重复出现的结构，除了数字是灵活变更以外，其他是一毛同样

1558457202775

应该使用for仍是while?

1558457430791
1558457442023
1558457470366 

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

1558458963504

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

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

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

1558459006107
1558495917037 

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('哎呀，你和敌人玉石俱焚了！')
复制代码

1558496071104
1558496093084
1558496117796

提示:

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('哎呀，你和敌人玉石俱焚了！')
复制代码

咱们如何计分?

1558496561008

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

1558496595010

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

1558496627798

加上计分后

1558496645045

虽然python没有++可是有+=, 因此代码还能够这么写...

1558496756964
1558496784129
1558496861371 

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('【最终结果：平局！】')
复制代码

格式化字符串

格式化以前, 咱们须要这么拼接字符串...

1558497021628

若是使用格式化字符串...

1558497051915

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

1558497108382

小做业:

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

1558497211929

代码参考

1558497343721

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

1558497480830

最新代码

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【最终结果：平局！】')
复制代码

1558497581373

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

1558498200418

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

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

1558498345327

试分析输出的结果...

# % 格式化：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修改原来的代码...

1558498764333 

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--完结撒花.mdhtml

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程