Python实现猜拳小游戏的多种方式

深夜遇见你

简介

猜拳小游戏是一个经典的小游戏项目，也是初学者学习编程的必要练手题目之一。在 Python 中，我们可以使用多种方式来实现一个简单的猜拳小游戏。
本文将依次介绍六种Python实现猜拳小游戏的方法，包括：使用 if-else 条件语句、使用 random 模块、使用字典映射胜负关系、for循环、while循环、函数。知识点依次堆加，这些方式各有优缺点，但无论哪种方式，都能够帮助初学者熟悉 Python 的编码语法和逻辑思维，更好地理解 Python 的基本数据类型、控制语句等内容；对于专业人士，可以根据具体需求进行选择。
实现方式一：使用 if-else 条件语句

不能使用while循环和for循环还有随机数模块，因此电脑的出拳方式的生成只能通过计算得到，而该算法只能模拟随机数的一部分特性，因此在实际应用中可能存在一定的问题。
注意，这个程序中没有使用while循环或for循环等任何循环语句，因此只会执行一次猜拳游戏。

1. # 定义常量
2. ROCK = 1
3. PAPER = 2
4. SCISSORS = 3
6. # 输出欢迎信息
7. print("欢迎来到猜拳游戏！")
8. print("游戏规则：")
9. print("1. 石头胜剪刀")
10. print("2. 剪刀胜布")
11. print("3. 布胜石头")
13. # 定义得分变量
14. player_score = 0
15. computer_score = 0
16. tie_count = 0
18. # 让玩家输入出拳方式
19. player_choice = int(input("请输入您的出拳方式（1：石头，2：剪刀，3：布）："))
21. # 判断玩家的选择
22. if player_choice == ROCK:
23.     print("你出了石头")
24. elif player_choice == PAPER:
25.     print("你出了剪刀")
26. else:
27.     print("你出了布")
29. # 生成电脑的出拳方式
30. computer_choice = ((player_score + computer_score + tie_count) % 3) + 1
32. # 输出电脑的选择
33. if computer_choice == ROCK:
34.     print("电脑出了石头")
35. elif computer_choice == PAPER:
36.     print("电脑出了剪刀")
37. else:
38.     print("电脑出了布")
40. # 判断输赢并输出结果
41. if player_choice == ROCK:
42.     if computer_choice == ROCK:
43.         print("平局")
44.         tie_count += 1
45.     elif computer_choice == PAPER:
46.         print("电脑获胜")
47.         computer_score += 1
48.     else:
49.         print("你获胜")
50.         player_score += 1
51. elif player_choice == PAPER:
52.     if computer_choice == ROCK:
53.         print("你获胜")
54.         player_score += 1
55.     elif computer_choice == PAPER:
56.         print("平局")
57.         tie_count += 1
58.     else:
59.         print("电脑获胜")
60.         computer_score += 1
61. else:
62.     if computer_choice == ROCK:
63.         print("电脑获胜")
64.         computer_score += 1
65.     elif computer_choice == PAPER:
66.         print("你获胜")
67.         player_score += 1
68.     else:
69.         print("平局")
70.         tie_count += 1
72. # 输出得分情况
73. print(f"您的得分：{player_score}，电脑的得分：{computer_score}，平局次数：{tie_count}")

复制代码

实现方式二：使用 random 模块

在使用if语句的基础上通过引入 Python 的 random 模块，实现电脑随机产生手势的功能。
注意，这个程序中没有使用while循环或for循环等任何循环语句，因此只会执行一次猜拳游戏。

1. # 使用 random 模块实现猜拳小游戏
3. import random
5. # 按照石头剪刀布的胜负规则判断输赢
6. def who_win(user_input, computer_input):
7.     win_list = [["石头","剪刀"], ["剪刀","布"], ["布","石头"]]
8.     if user_input == computer_input:
9.         return 0
10.     elif [user_input,computer_input] in win_list:
11.         return 1
12.     else:
13.         return -1
15. while True:
16.     # 玩家输入手势
17.     user_choice = input("请选择（石头/剪刀/布）：")
19.     # 随机生成电脑的手势
20.     computer_choice = random.choice(["石头", "剪刀", "布"])
21.     print("电脑选择：", computer_choice)
23.     # 判断胜负
24.     result = who_win(user_choice, computer_choice)
26.     if result == 0:
27.         print("平局，再来一局！")
28.     elif result == 1:
29.         print("你赢了！")
30.     else:
31.         print("你输了！")
33.     # 是否再来一局
34.     play_again = input("是否再来一局？（y/n）")
35.     if play_again.lower() != "y":
36.         break

复制代码

实现方式三：使用字典映射胜负关系

使用if语句与随机数模块和一个字典来映射石头剪刀布的胜负规则，并根据用户和计算机输入的选项对应的键值找到其胜出的选项

1. # 使用字典映射实现猜拳小游戏
3. import random
5. # 定义一个字典，表示石头剪刀布的胜负关系
6. dict = {"石头": "剪刀", "剪刀": "布", "布": "石头"}
8. while True:
9.     # 玩家输入手势
10.     user_choice = input("请选择（石头/剪刀/布）：")
12.     # 随机生成电脑的手势
13.     computer_choice = random.choice(["石头", "剪刀", "布"])
14.     print("电脑选择：", computer_choice)
16.     # 判断胜负
17.     if dict[user_choice] == computer_choice:
18.         print("你赢了！")
19.     elif user_choice == computer_choice:
20.         print("平局！")
21.     else:
22.         print("你输了！")
24.     # 是否再来一局
25.     play_again = input("是否再来一局？（y/n）")
26.     if play_again.lower() != "y":
27.         break

复制代码

实现方式四：for循环

这种实现方式使用if语句、随机数模块和一个字典来映射石头剪刀布的胜负规则，并使用for循环来实现猜拳小游戏

1. import random  
2.   
3. # 定义石头剪刀布的胜负规则  
4. rules = {  
5.     "rock": {  
6.         "scissors": "你赢了！",  
7.         "paper": "你输了！"  
8.     },  
9.     "paper": {  
10.         "rock": "你赢了！",  
11.         "scissors": "你输了！"  
12.     },  
13.     "scissors": {  
14.         "paper": "你赢了！",  
15.         "rock": "你输了！"  
16.     }  
17. }  
19. # 循环玩5局游戏  
20. for i in range(5):  
21.     # 生成随机选择  
22.     player_choice = random.choice(["rock", "paper", "scissors"])  
23.     computer_choice = random.choice(["rock", "paper", "scissors"])  
24.     print("你的选择：{}".format(player_choice))  # 输出玩家选择  
25.     print("电脑的选择：{}".format(computer_choice))  # 输出电脑选择  
26.   
27.     # 判断胜负关系并输出结果  
28.     if player_choice == computer_choice:  
29.         print("平局！")  # 如果玩家和电脑选择一样，则平局  
30.     elif rules[player_choice][computer_choice] == "你赢了！":  
31.         print(rules[player_choice][computer_choice])  # 如果玩家选择战胜电脑选择，则输出玩家胜利信息  
32.     else:  
33.         print(rules[computer_choice][player_choice])  # 如果电脑选择战胜玩家选择，则输出电脑胜利信息

复制代码

实现方式五：while循环

在原有基础上进行修改，将for循环替换为while循环；

• 增加了用户交互环节，让用户可以选择自己出拳或者输入r随机出拳的功能；
  
• 记录了游戏结果统计变量（比如用户胜利场数、电脑胜利场数和回合数），并在游戏结束时打印比分结果；
  
• 在满足三局两胜的条件时结束游戏，并询问用户是否再次开启游戏；
  

1. import random
3. # 定义一个字典，用于映射石头剪刀布的胜负规则
4. rps_dict = {'石头': '剪刀', '剪刀': '布', '布': '石头'}
6. # 初始化用户选择和电脑选择
7. user_choice = None
8. computer_choice = None
10. # 初始化游戏结果统计变量
11. user_win_count = 0
12. computer_win_count = 0
13. round_count = 0
15. # 使用while循环实现猜拳小游戏
16. while True:
17.     # 打印提示信息
18.     print("欢迎来到猜拳游戏！")
19.     print("请输入石头、剪刀或布（输入r表示随机选择）：")
21.     # 获取用户输入
22.     user_input = input().strip().lower()
24.     # 如果用户输入为r，则随机选择石头、剪刀或布
25.     if user_input == 'r':
26.         computer_choice = random.choice(list(rps_dict.values()))
28.     # 如果用户输入为有效的选项，则将其转换为对应的值并赋值给user_choice和computer_choice
29.     elif user_input in list(rps_dict.keys()):
30.         user_choice = user_input
31.         computer_choice = rps_dict[user_input]
33.     # 如果用户输入无效，则提示错误信息并继续循环
34.     else:
35.         print("输入无效，请重新输入！")
36.         continue
38.     # 判断胜负并输出结果
39.     if user_choice == computer_choice:
40.         print("平局！")
41.     elif (user_choice == '石头' and computer_choice == '剪刀') or \
42.          (user_choice == '剪刀' and computer_choice == '布') or \
43.          (user_choice == '布' and computer_choice == '石头'):
44.         print("恭喜你，你赢了！")
45.         user_win_count += 1
46.     else:
47.         print("很遗憾，你输了。")
48.         computer_win_count += 1
50.     # 打印本局游戏的结果
51.     print(f"你出了{user_choice}，电脑出了{computer_choice}")
52.     print(f"当前比分：你 {user_win_count} - {computer_win_count} 电脑\n")
54.     # 增加回合数并判断是否达到三局两胜的条件
55.     round_count += 1
56.     if user_win_count == 2:
57.         print("你已经获得三局两胜了，你赢了！")
58.         break
59.     elif computer_win_count == 2:
60.         print("很遗憾，电脑获得了三局两胜，你输了！")
61.         break
63.     # 根据用户的选择决定是否继续游戏
64.     replay = input("是否再玩一局？(y/n)").strip().lower()
65.     if replay != 'y':
66.         break
68. # 询问用户是否再次开启游戏
69. play_again = input("是否再次开启游戏？(y/n)").strip().lower()
70. if play_again == 'y':
71.     exec(open(__file__).read())
72. else:
73.     print("游戏结束！")

复制代码

实现方式六：函数

对while循环的代码进行重构使用函数进行优化

1. import random
2. from time import sleep
4. # 定义一个字典，用于映射石头剪刀布的胜负规则
5. rps_dict = {'石头': {'name': '石头', 'defeat': '布'},
6.             '剪刀': {'name': '剪刀', 'defeat': '石头'},
7.             '布': {'name': '布', 'defeat': '剪刀'}}
9. # 清屏函数，用于在每次输出前清空屏幕
10. def clear_screen():
11.     print('\033c', end='')
13. # 美化输出函数，用于打印美观的输出界面
14. def print_beautiful(message):
15.     print('='*50)
16.     print(f"{message:^50}")
17.     print('='*50)
19. # 获取用户输入函数，用于获取用户选择
20. def get_user_choice():
21.     while True:
22.         user_input = input("请选择 石头、剪刀、布：")
23.         if user_input not in rps_dict:
24.             print_beautiful("选择无效，请重新选择")
25.         else:
26.             break
27.     return rps_dict[user_input]
29. # 电脑随机选择函数
30. def get_computer_choice():
31.     return random.choice(list(rps_dict.values()))
33. # 判断胜负函数
34. def judge(user_choice, computer_choice):
35.     if user_choice == computer_choice:
36.         result = "平局！"
37.         winner = None
38.     elif user_choice['defeat'] == computer_choice['name']:
39.         result = "很遗憾，你输了。"
40.         winner = 'computer'
41.     else:
42.         result = "恭喜你，你赢了！"
43.         winner = 'user'
44.     return result, winner
46. # 打印结果函数
47. def print_result(result, user_choice, computer_choice):
48.     print_beautiful(result)
49.     sleep(1)
50.     print(f"你出了【{user_choice['name']}】，电脑出了【{computer_choice['name']}】")
52. # 根据胜负结果更新胜利次数函数
53. def update_win_count(winner, win_count):
54.     if winner == 'user':
55.         win_count['user'] += 1
56.     elif winner == 'computer':
57.         win_count['computer'] += 1
59. # 打印当前比分函数
60. def print_score(win_count):
61.     print(f"当前比分：你 {win_count['user']} - {win_count['computer']} 电脑\n")
63. # 判断是否达成胜利条件函数
64. def check_victory(win_count):
65.     if win_count['user'] == 2:
66.         print_beautiful("恭喜你，你已经获得三局两胜了，你赢了！")
67.         return True
68.     elif win_count['computer'] == 2:
69.         print_beautiful("很遗憾，电脑获得了三局两胜，你输了！")
70.         return True
71.     else:
72.         return False
74. # 再玩一局函数
75. def ask_replay():
76.     while True:
77.         replay = input("是否再玩一局？(y/n)").strip().lower()
78.         if replay not in ['y', 'n']:
79.             print_beautiful("输入无效，请重新输入")
80.         else:
81.             break
82.     return replay == 'y'
84. # 游戏结束函数
85. def game_over():
86.     print_beautiful("游戏结束！")
87.     sleep(2)
89. # 主函数，实现游戏逻辑
90. def main():
91.     clear_screen()
92.     print_beautiful("欢迎来到猜拳游戏！")
93.     win_count = {'user': 0, 'computer': 0}
95.     while True:
96.         user_choice = get_user_choice()
97.         computer_choice = get_computer_choice()
99.         result, winner = judge(user_choice, computer_choice)
100.         print_result(result, user_choice, computer_choice)
101.         update_win_count(winner, win_count)
102.         print_score(win_count)
104.         if check_victory(win_count):
105.             if not ask_replay():
106.                 break
107.             else:
108.                 win_count = {'user': 0, 'computer': 0}
109.                 clear_screen()
110.             
111.     game_over()
113. if __name__ == '__main__':
114.     main()

复制代码

来源:https://www.cnblogs.com/Hang666/p/17472848.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！