AI 助理
备案控制台
开发者社区 云原生 文章 正文

Python编写的10个小游戏完整版

2023-05-23 635
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
应用实时监控服务-应用监控，每月50GB免费额度
应用实时监控服务-用户体验监控，每月100OCU免费额度
可观测可视化 Grafana 版，10个用户账号 1个月
简介： Python编写的10个小游戏完整版
  1. 猜数字游戏

​

python
import random

number = random.randint(1, 100)
guess = int(input('请猜一个1到100之间的数字：'))
while guess != number:
    if guess > number:
        print('猜大了')
    else:
        print('猜小了')
    guess = int(input('请重新猜一个1到100之间的数字：'))
print('恭喜你，猜对了！')
  1. 石头剪刀布游戏
python
import random

options = ['石头', '剪刀', '布']
computer_choice = random.choice(options)
user_choice = input('请出拳（石头、剪刀、布）：')
print('你出了', user_choice)
print('电脑出了', computer_choice)
if user_choice == computer_choice:
    print('平局')
elif user_choice == '石头' and computer_choice == '剪刀' or \
     user_choice == '剪刀' and computer_choice == '布' or \
     user_choice == '布' and computer_choice == '石头':
    print('你赢了')
else:
    print('你输了')
  1. 猜单词游戏
python
import random

words = ['apple', 'banana', 'cherry', 'orange', 'pear']
word = random.choice(words)
letters = set(word)
correct_guesses = set()
incorrect_guesses = set()
tries = 6

while tries > 0 and letters != correct_guesses:
    print('可用次数：', tries)
    print('已猜对的字母：', ' '.join(correct_guesses))
    print('已猜错的字母：', ' '.join(incorrect_guesses))
    guess = input('请猜一个字母：')
    if guess in letters:
        correct_guesses.add(guess)
    else:
        incorrect_guesses.add(guess)
        tries -= 1

if letters == correct_guesses:
    print('恭喜你，猜对了！单词是', word)
else:
    print('很遗憾，你没有猜对。单词是', word)
  1. 猜词游戏
python
import random

words = ['apple', 'banana', 'cherry', 'orange', 'pear']
word = random.choice(words)
shuffle_word = list(word)
random.shuffle(shuffle_word)

print('请猜这个单词：', ''.join(shuffle_word))
guess = input('请输入你的答案：')
if guess == word:
    print('恭喜你，猜对了！')
else:
    print('很遗憾，你没有猜对。正确答案是', word)

5.数字连连看游戏

python
import random

numbers = list(range(1, 9)) * 2
random.shuffle(numbers)

def display_board():
    for i in range(0, 16, 4):
        print(numbers[i:i+4])

def remove_numbers(x1, y1, x2, y2):
    global numbers
    numbers[x1*4+y1] = 0
    numbers[x2*4+y2] = 0

def is_valid_move(x1, y1, x2, y2):
    if x1 == x2 and abs(y1-y2) == 1:
        return True
    if y1 == y2 and abs(x1-x2) == 1:
        return True
    return False

display_board()
while True:
    x1 = int(input('请输入第一个数字的行号（0-3）：'))
    y1 = int(input('请输入第一个数字的列号（0-3）：'))
    x2 = int(input('请输入第二个数字的行号（0-3）：'))
    y2 = int(input('请输入第二个数字的列号（0-3）：'))
    if is_valid_move(x1, y1, x2, y2) and numbers[x1*4+y1] == numbers[x2*4+y2]:
        remove_numbers(x1, y1, x2, y2)
        display_board()
        if all(num == 0 for num in numbers):
            print('恭喜你，游戏结束！')
            break
    else:
        print('无效的移动，请重新输入。')
  1. 猜单词游戏（升级版）
python
import random

words = ['apple', 'banana', 'cherry', 'orange', 'pear']
word = random.choice(words)
letters = set(word)
correct_guesses = set()
incorrect_guesses = set()
tries = 6

while tries > 0 and letters != correct_guesses:
    print('可用次数：', tries)
    print('已猜对的字母：', ' '.join(correct_guesses))
    print('已猜错的字母：', ' '.join(incorrect_guesses))
    guess = input('请猜一个字母或整个单词：')
    if len(guess) == 1:
        if guess in letters:
            correct_guesses.add(guess)
        else:
            incorrect_guesses.add(guess)
            tries -= 1
    else:
        if guess == word:
            correct_guesses = letters
        else:
            incorrect_guesses.add(guess)
            tries -= 1

if letters == correct_guesses:
    print('恭喜你，猜对了！单词是', word)
else:
    print('很遗憾，你没有猜对。正确答案是', word)
  1. 猜数字游戏（升级版）
python
import random

number = random.randint(1, 100)
guesses = []
while len(guesses) < 10:
    guess = int(input('请猜一个1到100之间的数字：'))
    if guess in guesses:
        print('你已经猜过这个数字了，请重新输入。')
        continue
    guesses.append(guess)
    if guess == number:
        print('恭喜你，猜对了！你用了', len(guesses), '次猜中了这个数字。')
        break
    elif guess < number:
        print('猜小了')
    else:
        print('猜大了')
else:
    print('很遗憾，你没有在规定次数内猜对。正确答案是', number)

这个游戏中，玩家需要在10次之内猜出一个1到100之间的随机数字。每次猜测后，程序会告诉玩家猜的数字是偏大还是偏小，直到玩家猜中这个数字或者用完所有的猜测次数为止。如果玩家在规定次数内猜中了这个数字，则游戏胜利；否则游戏失败。

  1. 猜拳游戏（升级版）
python
import random

options = ['石头', '剪刀', '布']
wins = {
   '石头': '剪刀', '剪刀': '布', '布': '石头'}
computer_score = 0
player_score = 0

while True:
    computer_choice = random.choice(options)
    player_choice = input('请出拳（石头、剪刀、布）：')
    print('你出了', player_choice)
    print('电脑出了', computer_choice)
    if player_choice == computer_choice:
        print('平局')
    elif wins[player_choice] == computer_choice:
        print('你赢了')
        player_score += 1
    else:
        print('你输了')
        computer_score += 1
    print('当前得分：电脑', computer_score, ', 玩家', player_score)
    if computer_score == 3 or player_score == 3:
        break

if computer_score > player_score:
    print('很遗憾，你输了。')
else:
    print('恭喜你，你赢了！')

这个游戏中，玩家和电脑进行猜拳比赛，先达到3分的一方获胜。玩家每次可以选择石头、剪刀或布中的一种，电脑也会随机选择其中的一种。根据石头、剪刀、布之间的胜负关系，程序会判断哪一方获胜，并更新双方的得分。当有一方的得分达到3分时，游戏结束，获得3分的一方获胜。

9.俄罗斯方块


# 导入必要的库
import pygame
import random

# 初始化pygame
pygame.init()

# 定义常量
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
BLOCK_SIZE = 30
FONT_SIZE = 36
FPS = 60

# 定义颜色
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)

# 定义方块形状
SHAPES = [
    [[1, 1, 1], [0, 1, 0]],
    [[2, 2], [2, 2]],
    [[0, 3, 3], [3, 3, 0]],
    [[4, 4, 0], [0, 4, 4]],
    [[5, 5, 5, 5]],
    [[6, 6, 6], [0, 0, 6]],
    [[7, 7, 7], [7, 0, 0]],
]

# 定义方块颜色
COLORS = [
    BLUE,
    YELLOW,
    GREEN,
    RED,
    WHITE,
    (255, 165, 0),
    (128, 0, 128),
]

# 定义方块类
class Block:
    def __init__(self, x, y, shape):
        self.x = x
        self.y = y
        self.shape = shape
        self.color = COLORS[SHAPES.index(shape)]
        self.rotation = 0

    def rotate(self):
        self.rotation = (self.rotation + 1) % len(self.shape)

    def get_matrix(self):
        return self.shape[self.rotation]

    def get_size(self):
        return len(self.get_matrix()), len(self.get_matrix()[0])

    def get_color(self):
        return self.color

# 定义游戏类
class Game:
    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption("俄罗斯方块")
        self.clock = pygame.time.Clock()
        self.font = pygame.font.Font(None, FONT_SIZE)
        self.score = 0
        self.board = [[0] * (SCREEN_WIDTH // BLOCK_SIZE) for _ in range(SCREEN_HEIGHT // BLOCK_SIZE)]
        self.current_block = Block(3, 0, random.choice(SHAPES))
        self.next_block = Block(0, 0, random.choice(SHAPES))
        self.game_over = False

    def draw_block(self, x, y, color):
        pygame.draw.rect(self.screen, color, (x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))

    def draw_board(self):
        for y, row in enumerate(self.board):
            for x, val in enumerate(row):
                if val > 0:
                    self.draw_block(x, y, COLORS[val - 1])

    def draw_current_block(self):
        matrix = self.current_block.get_matrix()
        size_x, size_y = self.current_block.get_size()
        for y in range(size_y):
            for x in range(size_x):
                if matrix[y][x] > 0:
                    self.draw_block(self.current_block.x + x, self.current_block.y + y, self.current_block.get_color())

    def draw_next_block(self):
        matrix = self.next_block.get_matrix()
        size_x, size_y = self.next_block.get_size()
        for y in range(size_y):
            for x in range(size_x):
                if matrix[y][x] > 0:
                    self.draw_block(x + SCREEN_WIDTH // BLOCK_SIZE + 2, y + SCREEN_HEIGHT // BLOCK_SIZE // 2, self.next_block.get_color())

    def draw_score(self):
        score_text = self.font.render("Score: {}".format(self.score), True, WHITE)
        self.screen.blit(score_text, (10, 10))

    def check_collision(self, block, dx=0, dy=0):
        matrix = block.get_matrix()
        size_x, size_y = block.get_size()
        for y in range(size_y):
            for x in range(size_x):
                if matrix[y][x] > 0:
                    if block.x + x + dx < 0 or block.x + x + dx >= SCREEN_WIDTH // BLOCK_SIZE:
                        return True
                    if block.y + y + dy >= SCREEN_HEIGHT // BLOCK_SIZE:
                        return True
                    if self.board[block.y + y + dy][block.x + x + dx] > 0:
                        return True
        return False

    def merge_block(self, block):
        matrix = block.get_matrix()
        size_x, size_y = block.get_size()
        for y in range(size_y):
            for x in range(size_x):
                if matrix[y][x] > 0:
                    self.board[block.y + y][block.x + x] = matrix[y][x]

    def remove_lines(self):
    lines_removed = 0
    y = SCREEN_HEIGHT // BLOCK_SIZE - 1
    while y >= 0:
        if all(self.board[y]):
            lines_removed += 1
            for y2 in range(y, 0, -1):
                self.board[y2] = self.board[y2 - 1][:]
            self.board[0] = [0] * (SCREEN_WIDTH // BLOCK_SIZE)
        else:
            y -= 1
    self.score += lines_removed * 100


    def update(self):
        if not self.check_collision(self.current_block, dy=1):
            self.current_block.y += 1
        else:
            self.merge_block(self.current_block)
            self.remove_lines()
            self.current_block = self.next_block
            self.next_block = Block(0, 0, random.choice(SHAPES))
            if self.check_collision(self.current_block):
                self.game_over = True

    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.game_over = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT and not self.check_collision(self.current_block, dx=-1):
                    self.current_block.x -= 1
                if event.key == pygame.K_RIGHT and not self.check_collision(self.current_block, dx=1):
                    self.current_block.x += 1
                if event.key == pygame.K_UP:
                    self.current_block.rotate()
                    if self.check_collision(self.current_block):
                        self.current_block.rotate()
                        self.current_block.rotate()
                        self.current_block.rotate()
                if event.key == pygame.K_DOWN and not self.check_collision(self.current_block, dy=1):
                    self.current_block.y += 1

    def run(self):
        while not self.game_over:
            self.screen.fill(BLACK)
            self.draw_board()
            self.draw_current_block()
            self.draw_next_block()
            self.draw_score()
            pygame.display.update()
            self.handle_events()
            self.update()
            self.clock.tick(FPS)
        pygame.quit()

if __name__ == "__main__":
    game = Game()
    game.run()

10贪吃蛇代码


# 导入必要的库
import pygame
import random

# 初始化pygame
pygame.init()

# 定义颜色
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

# 设置屏幕大小
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# 创建屏幕
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("贪吃蛇")

# 定义蛇的初始位置和大小
snake_block_size = 10
snake_speed = 15
snake_list = []
snake_length = 1
snake_x = SCREEN_WIDTH / 2
snake_y = SCREEN_HEIGHT / 2

# 定义食物的初始位置和大小
food_block_size = 10
food_x = round(random.randrange(0, SCREEN_WIDTH - food_block_size) / 10.0) * 10.0
food_y = round(random.randrange(0, SCREEN_HEIGHT - food_block_size) / 10.0) * 10.0

# 定义字体
font_style = pygame.font.SysFont(None, 50)

# 定义分数
score = 0

# 定义游戏结束函数
def game_over():
    message = font_style.render("游戏结束", True, RED)
    screen.blit(message, [SCREEN_WIDTH / 3, SCREEN_HEIGHT / 3])
    pygame.display.update()
    pygame.time.delay(2000)

# 游戏循环
game_over_flag = False
while not game_over_flag:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_over_flag = True

        # 控制蛇的移动
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                snake_x_change = -snake_block_size
                snake_y_change = 0
            elif event.key == pygame.K_RIGHT:
                snake_x_change = snake_block_size
                snake_y_change = 0
            elif event.key == pygame.K_UP:
                snake_y_change = -snake_block_size
                snake_x_change = 0
            elif event.key == pygame.K_DOWN:
                snake_y_change = snake_block_size
                snake_x_change = 0

    # 控制蛇的移动
    snake_x += snake_x_change
    snake_y += snake_y_change

    # 判断蛇是否吃到食物
    if snake_x == food_x and snake_y == food_y:
        food_x = round(random.randrange(0, SCREEN_WIDTH - food_block_size) / 10.0) * 10.0
        food_y = round(random.randrange(0, SCREEN_HEIGHT - food_block_size) / 10.0) * 10.0
        snake_length += 1
        score += 10

    # 绘制食物
    pygame.draw.rect(screen, GREEN, [food_x, food_y, food_block_size, food_block_size])

    # 绘制蛇
    snake_head = []
    snake_head.append(snake_x)
    snake_head.append(snake_y)
    snake_list.append(snake_head)
    if len(snake_list) > snake_length:
        del snake_list[0]

    for x in snake_list[:-1]:
        if x == snake_head:
            game_over_flag = True

    for x in snake_list:
        pygame.draw.rect(screen, BLUE, [x[0], x[1], snake_block_size, snake_block_size])

    # 绘制分数
    score_message = font_style.render("分数: " + str(score), True, BLACK)
    screen.blit(score_message, [0, 0])

    # 更新屏幕
    pygame.display.update()

    # 判断蛇是否撞墙
    if snake_x >= SCREEN_WIDTH or snake_x < 0 or snake_y >= SCREEN_HEIGHT or snake_y < 0:
        game_over_flag = True

    # 控制游戏速度
    pygame.time.delay(snake_speed)

# 结束pygame
pygame.quit()

这里需要补充一下 snake_x += snake_x_change snake_y += snake_y_change的初始化

​

文章标签：
Python
关键词：
Python小游戏
zhaokk
目录
相关文章
aliyun4468252351-17262
|
7月前
|
人工智能 机器人 测试技术
【python】python小游戏——开心消消乐（源码）【独一无二】
【python】python小游戏——开心消消乐（源码）【独一无二】
aliyun4468252351-17262
262 5
口-role-player
|
7月前
|
Python
python小游戏4
python小游戏4
口-role-player
76 1
口-role-player
|
7月前
|
Python
python小游戏7
python小游戏7
口-role-player
54 0
口-role-player
|
7月前
|
Python
python小游戏6
python小游戏6
口-role-player
41 0
口-role-player
|
7月前
|
Python
python小游戏5
python小游戏5
口-role-player
59 0
口-role-player
|
7月前
|
Python
python小游戏1
python小游戏1
口-role-player
66 0
虫无涯
|
7月前
|
安全 C++ Python
小游戏实战-Python实现石头剪刀布+扫雷小游戏
小游戏实战-Python实现石头剪刀布+扫雷小游戏
虫无涯
107 0
站大爷
|
7月前
|
数据可视化 安全 数据安全/隐私保护
使用Python做个可视化的“剪刀石头布”小游戏
使用Python做个可视化的“剪刀石头布”小游戏
站大爷
145 0
口-role-player
|
7月前
|
Python
python小游戏3
python小游戏3
口-role-player
58 0
口-role-player
|
7月前
|
Python
python小游戏
python小游戏
口-role-player
57 2

云原生

热门文章

最新文章

  • 1
    Docker 镜像加速器
  • 2
    Docker CE 镜像源站
  • 3
    Minikube - Kubernetes本地实验环境
  • 4
    微服务（Microservice）那点事
  • 5
    Docker的Windows容器初体验
  • 6
    Docker学习路线图 (持续更新中)
  • 7
    利用Zipkin对Spring Cloud应用进行服务追踪分析
  • 8
    谈谈 Docker Volume 之权限管理（一）
  • 9
    容器镜像服务 Docker镜像的基本使用
  • 10
    利用Helm简化Kubernetes应用部署
  • 1
    如何选择网站模板建设网站？
    11
  • 2
    杭州铭师堂的云原生升级实践
    13
  • 3
    活动速递丨AI 原生应用开发实战营·上海站邀您参会
    7
  • 4
    阿里云 SAE 邀您参加 Serverless 高可用架构挑战赛，赢取精美礼品
    10
  • 5
    MSE Nacos 2.3.2.0 发布，性能最多提升三倍，支持操作审计等安全特性
    13
  • 6
    10 分钟打造你的专属 AI 客服
    7
  • 7
    邀您参加云原生高可用技术沙龙丨云上高可用体系构建：从理论到实践
    13
  • 8
    Nacos 3.0 Alpha 发布，在安全、泛用、云原生更进一步
    15
  • 9
    云上数据安全保护：敏感日志扫描与脱敏实践详解
    18
  • 10
    Pandas数据结构：Series与DataFrame
    25

    • 相关课程

    更多
  • Python Web开发基础
  • Python爬虫实战
  • Python常用数据科学库
  • Python网络爬虫实战
  • Python完全自学手册图文教程
  • Python基础快速入门实战教程

    • 相关电子书

    更多
  • From Python Scikit-Learn to Sc
  • Data Pre-Processing in Python:
  • 双剑合璧-Python和大数据计算平台的结合

    • 相关实验场景

    更多
  • 用Python画圣诞树
  • 语言入门-1：环境构建
  • Python选择及循环结构
  • 云端Python及基本操作
  • Python网络通信程序典型应用
  • Arthas 进阶教程

    • 推荐镜像

    更多
  • python-release
  • nodejs-release
  • debian-cd
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解