貓哥教你寫爬蟲 014--pk小遊戲

時間 2019-12-04

標籤爬蟲遊戲欄目網絡爬蟲简体版

原文原文鏈接

項目實操

可是項目實操會遇到不少問題...

問題拆解

在作一件事或面對一個問題的時候，將其拆解成多個步驟或多個層次，

逐步執行和解決問題，直至達到最終效果。

猜數字的思路

通常狀況下是由產品經理提出明確的項目需求，由程序員來實現，

他們之間是「相愛相殺」的關係。：）

人機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
複製代碼