20241217 实验四《Python程序设计》实验报告

20241217 2024-2025-2 《Python程序设计》综合实践报告

课程：《Python程序设计》
班级： 2412
姓名： 黄迅
学号：20241217
实验教师：王志强
实验日期：2025年5月14日
必修/选修： 公选课

一、实验目的
本次实验的目的是通过Python语言结合Pygame库开发一款五子棋人机对战小游戏，学习并掌握图形界面设计、事件处理、博弈逻辑实现等技术，体会人工智能在简单博弈中的应用。
二、实验分析
（一）背景
设计五子棋人机对战小游戏是因为家人很喜欢下五子棋，小时候对弈时经常“虐”得我哭笑不得，长大后设计这个小游戏让机器代替远在外求学的我可以陪家人下五子棋，也算一种愿想。五子棋规则简单但在代码上体现丰富的博弈逻辑对我来说相当有难度，上网查询后综合决定利用Python的Pygame库，最后在自己学习后的思考和Deepseek、豆包等ai的帮助下完成本次实验。
（二）功能需求
1.绘制15×15棋盘、玩家与电脑交替落子、判断五子连珠胜负；
2.电脑能优先判断必胜点和必防点，通过评分系统选择最佳落子位置，实现人机对战；
3.鼠标点击落子，游戏结束后显示结果并停留3秒，实现界面交互。
三、实验设计及实现过程
（一）导入Pygame库，用于游戏开发（图形、事件处理等），再导入随机模块，用于机器人随机选择落子点，在ai建议下导入NumPy库预留扩展。
使用Pygame库前要先下载

import pygame
import random
import numpy as np

（二）启动Pygame所有模块，在使用前调用
pygame.init()
（三）定义游戏相关常量
各个常量数据的大小上网查询得到，定义的游戏相关常量有棋盘大小（15x15路）、每个网格的像素尺寸、窗口宽度和窗口高度（棋盘外预留1格边距）、RGB颜色定义成黑色、RGB颜色定义成白色、背景色选择柔和的蓝色、提示文字颜色选择红色。

BOARD_SIZE=15
GRID_SIZE=40
WINDOW_WIDTH=GRID_SIZE * (BOARD_SIZE + 1)
WINDOW_HEIGHT=GRID_SIZE * (BOARD_SIZE + 1)
BLACK=(0, 0, 0)
WHITE=(255, 255, 255)
BLUE=(100, 149, 237)
RED=(255, 0, 0)

（四）创建游戏窗口
网上学习相关语句后利用pygame创建指定尺寸的窗口，设置窗口标题，在ai的帮助下创建时钟对象，用于控制帧率

screen=pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("五子棋人机对战小游戏")
clock=pygame.time.Clock()

（五）初始化棋盘
生成15x15的二维列表，初始全为0（二维列表，0为空，1为玩家黑棋，2为电脑白棋）

board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)]

（六）制作棋盘，给棋盘 “穿衣服”
给棋盘铺蓝色背景，画水平网格线（共15条横线，每条线间距40像素（GRID_SIZE）），画竖直直网格线（共15条竖线），绘制星位和天元（15路棋盘的星位坐标为(3,3)、(3,11)、(7,7)、(11,3)、(11,11)，代码中简化为x/y相同的点，中心7就是天元），并计算星位圆心坐标

def draw_board():
    screen.fill(BLUE)
    for i in range(BOARD_SIZE):
        # 起点：(GRID_SIZE, GRID_SIZE*(i+1))，终点：(GRID_SIZE*BOARD_SIZE, GRID_SIZE*(i+1))
        # 横线位置从第1列到第15列，行号i+1对应网格线位置（预留边框）
        pygame.draw.line(screen,BLACK,(GRID_SIZE,GRID_SIZE*(i+1)),
                         (GRID_SIZE*BOARD_SIZE, GRID_SIZE*(i+1)),2)#绘制黑色横线
        pygame.draw.line(screen,BLACK,(GRID_SIZE*(i+1),GRID_SIZE),
                         (GRID_SIZE*(i+1),GRID_SIZE*BOARD_SIZE),2)
    #绘制天元和星位
    star_points=[3, 7, 11]#15路棋盘的星位坐标，横坐标/纵坐标列表
    for x in star_points:
        for y in star_points:
            #计算星位圆心坐标（网格线交点为GRID_SIZE*(x+1), GRID_SIZE*(y+1)）
            pygame.draw.circle(screen,BLACK,
                               (GRID_SIZE*(x+1),GRID_SIZE*(y+1)),5)#画半径为5的黑色实心圆

（七）做棋子，让棋子“坐”到棋盘上
先遍历棋盘每个格子，看看有没有棋子，再用elif语句判断后画上对应黑白的棋子。

def draw_pieces():
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==1:#玩家黑棋落子
                # Pygame坐标原点在左上角，圆心坐标：列号col+1对应x轴，行号row+1对应y轴
                pygame.draw.circle(screen,BLACK,
                                   (GRID_SIZE*(col+1),GRID_SIZE*(row+1)),18)#画半径18的黑棋
            elif board[row][col] == 2:#电脑白棋落子
                pygame.draw.circle(screen,WHITE,
                                   (GRID_SIZE*(col+1),GRID_SIZE*(row+1)),18)#半径18的白棋

（八）检查是否五子连珠
先确定四个检查方向：右、下、右下、右上，遍历每个方向，检查每个方向有没有连续5个同色棋子（自己本身算1个），向右、下、右下、右上数有多少个同色棋子（正向检查），向左、上、左下、左上数有多少个同色棋子（反向检查）

def check_win(row, col, player):
    directions=[(1, 0), (0, 1), (1, 1), (1, -1)]
    for dr, dc in directions:
        count=1
        #正向检查
        r,c=row+dr,col+dc
        while 0<=r<BOARD_SIZE and 0<=c<BOARD_SIZE and board[r][c]==player:
            count+=1#同色棋子计数加1
            r+=dr#继续移动
            c+=dc
        #反向检查
        r,c=row-dr,col-dc
        while 0<=r<BOARD_SIZE and 0<=c<BOARD_SIZE and board[r][c]==player:
            count+= 1
            r-=dr
            c-=dc
        if count>= 5:#如果总数≥5，就胜利！
            return True
    return False#所有方向检查完没有满足五子连珠，返回失败

（九）评估位置
确定四个评估方向，检查四个方向；分析每一段5连珠的可能性，给不同棋形打分（活四＞冲四＞活三＞活二＞活一）；最后返回当前位置的总得分

def evaluate_position(row, col, player):
    directions=[(1,0),(0,1),(1,1),(1,-1)]
    total_score=0
    for dr, dc in directions:
        #检查四个方向
        line = []
        #取一条线上当前位置左右各4个格子，共9个格子（包括自己）
        for i in range(-4, 5):
            r,c=row+dr*i,col+dc*i#计算坐标
            if 0 <=r<BOARD_SIZE and 0<=c<BOARD_SIZE:
                line.append(board[r][c])#存入棋子，0或1或2
            else:
                line.append(-1)#边界外标记为-1
        #分析每个5连珠片段
        for i in range(5):
            segment=line[i:i+5]#提取连续5个位置的片段
            player_count=segment.count(player)#计算这个5连位置中有多少个当前玩家的棋子
            empty_count=segment.count(0)#计算有多少个空位
            opponent_count=segment.count(3-player)#检查对手的棋子，玩家为1则对手为2，反之一样
            if opponent_count==0:
                if player_count==4and empty_count== 1:
                    total_score+=10000#活四
                elif player_count==3 and empty_count==2:
                    total_score +=1000#活三
                elif player_count==2 and empty_count==3:
                    total_score+=100#活二
                elif player_count==1 and empty_count==4:
                    total_score += 10#活一
            elif player_count==4 and opponent_count==1:
                total_score+=5000#冲四（有一个对手棋子阻挡）
    return total_score

（十）机器人落子
这一段是我最不会的，上网查询大量资料并借助ai修改了多次后学习到的。
先检查是否有立即获胜的位置，再检查是否需要阻止玩家获胜，然后评估所有空位，选择最佳位置（靠评分系统），最后处理极端情况下无最佳位置时虽然不太可能出现）随机落子。

def robot_move():
    #第一步：先看看自己能不能赢！
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:
                board[row][col]=2#试下这里看能不能赢
                if check_win(row,col,2):
                    return True#能赢就直接落子，返回胜利
                board[row][col]=0#不能赢就撤回，假装没下过
    #第二步：如果自己赢不了，看看玩家能不能赢！
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:
                board[row][col]=1#假装玩家在这落子
                if check_win(row,col,1):#判断玩家能赢吗？
                    board[row][col]=2#能赢的话，赶紧堵上！
                    return False#防守成功，返回
                board[row][col]=0#如果玩家赢不了，撤回
    #第三步：评估所有空位，根据评分选择最佳位置
    best_score=-1#初始最低分
    best_moves=[]#最佳位置列表

    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:#空位
                #电脑进攻得分
                score_offense=evaluate_position(row, col,2)
                #电脑防守得分（阻止玩家形成好形）
                score_defense=evaluate_position(row,col,1)
                #总得分，进攻分和防守分，进攻更重要（乘以1.2倍）
                total_score=score_offense*1.2+score_defense

                if total_score>best_score:#发现更高分位置
                    best_score=total_score
                    best_moves=[(row, col)]#更新最佳位置列表
                elif total_score==best_score:#如果有同分位置，加入候选列表
                    best_moves.append((row,col))
    #如果有多个最佳位置，随机选择一个
    if best_moves:
        row,col=random.choice(best_moves)
        board[row][col]=2
        return check_win(row,col,2)#检查是否获胜并返回结果
    #极端情况下无最佳位置，随机落子选择一个位置（虽然不太可能出现这种情况）
    available_moves=[]
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:
                available_moves.append((row, col))#收集所有空位
    if available_moves:
        row, col=random.choice(available_moves)#随机选一个空位
        board[row][col]=2
        return check_win(row,col,2)
    return False

（十一）显示游戏结果
这一段我也不太会，还是学习了画图的语句后，明确了要显示的东西，让ai加工后完整得到。
在互联网的帮助下，学到了创建字体对象，红色文本，文本居中显示，文本显示到屏幕，更新画面显示，游戏结束界面停留等

def show_result(winner):
    font = pygame.font.SysFont('Arial',48)#创建Arial，字号48
    if winner==1:
        text=font.render("你赢了！",True,RED)#红色文本
    else:
        text=font.render("电脑赢了！",True,RED)
    #文本居中显示
    text_rect=text.get_rect(center=(WINDOW_WIDTH//2,WINDOW_HEIGHT//2))
    screen.blit(text,text_rect)
    pygame.display.flip()
    pygame.time.wait(3000)#游戏结束界面显示3秒

(十二）主游戏循环
思路是定义玩家落子和电脑落子回合，处理一些鼠标点击、窗口关闭等事件，画上棋盘和棋子，玩家先下子，获取鼠标点击坐标，再切换到电脑回合，游戏未结束就一直循环，如果游戏结束，显示结果停留界面3秒，退出Pygame。又在ai的帮助下添加了更新画面和控制帧率为60帧/秒的语句。开始没使用程序入口点，电脑画面总是闪退，查询后加上这条语句才能正常显示并运行。这个大部分在外力帮助下完成，好在自己学得懂。

def main():
    #True=玩家落子，False=电脑落子
    player_turn=True
    game_over=False#游戏是否结束1
    winner=None#获胜者，1=是家，2是电脑
    while not game_over:
        #处理事件（鼠标点击、窗口关闭等）
        for event in pygame.event.get():
            if event.type==pygame.QUIT:#窗口关闭事件
                game_over=True#标记游戏结束
            elif event.type==pygame.MOUSEBUTTONDOWN and player_turn and not game_over:#玩家鼠标点击落子
                x, y=event.pos#获取鼠标点击坐标
                col=round((x-GRID_SIZE)/GRID_SIZE)#计算点击位置对应坐标的列和行（减去边框宽度，除以网格大小并取整）
                row=round((y-GRID_SIZE)/GRID_SIZE)
                #坐标在棋盘内且为空位
                if 0 <=row<BOARD_SIZE and 0<=col<BOARD_SIZE and board[row][col]==0:
                    board[row][col]=1#让玩家落黑棋
                    if check_win(row,col,1):#检查玩家是否获胜
                        game_over=True
                        winner=1
                    else:
                        player_turn=False#轮到电脑回合

        #电脑回合（游戏未结束）
        if not player_turn and not game_over:
            if robot_move():
                game_over=True
                winner=2
            else:
                player_turn=True#回到玩家回合
        #画棋盘和棋子
        draw_board()
        draw_pieces()
        #如果游戏结束，显示结果
        if game_over and winner:
            show_result(winner)
            game_over=True#确保只显示一次

        pygame.display.flip()#更新画面
        clock.tick(60)#控制帧率为60帧每秒
    pygame.quit()#退出Pygame
#程序入口点，自动调用main()函数启动游戏
if __name__ == "__main__":
    main()

（十三）完整源代码如下

import pygame
import random
import numpy as np

pygame.init()

BOARD_SIZE=15
GRID_SIZE=40
WINDOW_WIDTH=GRID_SIZE*(BOARD_SIZE+1)
WINDOW_HEIGHT=GRID_SIZE*(BOARD_SIZE+1)
BLACK=(0,0,0)
WHITE=(255,255,255)
BLUE=(100,149,237)
RED=(255,0,0)

screen=pygame.display.set_mode((WINDOW_WIDTH,WINDOW_HEIGHT))
pygame.display.set_caption("五子棋人机对战小游戏")
clock=pygame.time.Clock()
board=[[0]*BOARD_SIZE for _ in range(BOARD_SIZE)]

def draw_board():
    screen.fill(BLUE)
    for i in range(BOARD_SIZE):
        # 起点：(GRID_SIZE, GRID_SIZE*(i+1))，终点：(GRID_SIZE*BOARD_SIZE, GRID_SIZE*(i+1))
        # 横线位置从第1列到第15列，行号i+1对应网格线位置（预留边框）
        pygame.draw.line(screen,BLACK,(GRID_SIZE,GRID_SIZE*(i+1)),
                         (GRID_SIZE*BOARD_SIZE, GRID_SIZE*(i+1)),2)#绘制黑色横线
        pygame.draw.line(screen,BLACK,(GRID_SIZE*(i+1),GRID_SIZE),
                         (GRID_SIZE*(i+1),GRID_SIZE*BOARD_SIZE),2)
    #绘制天元和星位
    star_points=[3, 7, 11]#15路棋盘的星位坐标，横坐标/纵坐标列表
    for x in star_points:
        for y in star_points:
            #计算星位圆心坐标（网格线交点为GRID_SIZE*(x+1), GRID_SIZE*(y+1)）
            pygame.draw.circle(screen,BLACK,
                               (GRID_SIZE*(x+1),GRID_SIZE*(y+1)),5)#画半径为5的黑色实心圆

def draw_pieces():
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==1:#玩家黑棋落子
                # Pygame坐标原点在左上角，圆心坐标：列号col+1对应x轴，行号row+1对应y轴
                pygame.draw.circle(screen,BLACK,
                                   (GRID_SIZE*(col+1),GRID_SIZE*(row+1)),18)#画半径18的黑棋
            elif board[row][col] == 2:#电脑白棋落子
                pygame.draw.circle(screen,WHITE,
                                   (GRID_SIZE*(col+1),GRID_SIZE*(row+1)),18)#半径18的白棋


#检查是否五子连珠
def check_win(row, col, player):
    directions=[(1, 0), (0, 1), (1, 1), (1, -1)]
    for dr, dc in directions:
        count=1
        #正向检查
        r,c=row+dr,col+dc
        while 0<=r<BOARD_SIZE and 0<=c<BOARD_SIZE and board[r][c]==player:
            count+=1#同色棋子计数加1
            r+=dr#继续移动
            c+=dc
        #反向检查
        r,c=row-dr,col-dc
        while 0<=r<BOARD_SIZE and 0<=c<BOARD_SIZE and board[r][c]==player:
            count+= 1
            r-=dr
            c-=dc
        if count>= 5:#如果总数≥5，就胜利！
            return True
    return False#所有方向检查完没有满足五子连珠，返回失败


#评估位置
def evaluate_position(row, col, player):
    directions=[(1,0),(0,1),(1,1),(1,-1)]
    total_score=0
    for dr, dc in directions:
        #检查四个方向
        line = []
        #取一条线上当前位置左右各4个格子，共9个格子（包括自己）
        for i in range(-4, 5):
            r,c=row+dr*i,col+dc*i#计算坐标
            if 0 <=r<BOARD_SIZE and 0<=c<BOARD_SIZE:
                line.append(board[r][c])#存入棋子，0或1或2
            else:
                line.append(-1)#边界外标记为-1
        #分析每个5连珠片段
        for i in range(5):
            segment=line[i:i+5]#提取连续5个位置的片段
            player_count=segment.count(player)#计算这个5连位置中有多少个当前玩家的棋子
            empty_count=segment.count(0)#计算有多少个空位
            opponent_count=segment.count(3-player)#检查对手的棋子，玩家为1则对手为2，反之一样
            if opponent_count==0:
                if player_count==4and empty_count== 1:
                    total_score+=10000#活四
                elif player_count==3 and empty_count==2:
                    total_score +=1000#活三
                elif player_count==2 and empty_count==3:
                    total_score+=100#活二
                elif player_count==1 and empty_count==4:
                    total_score += 10#活一
            elif player_count==4 and opponent_count==1:
                total_score+=5000#冲四（有一个对手棋子阻挡）
    return total_score

#机器人落子
def robot_move():
    #第一步：先看看自己能不能赢！
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:
                board[row][col]=2#试下这里看能不能赢
                if check_win(row,col,2):
                    return True#能赢就直接落子，返回胜利
                board[row][col]=0#不能赢就撤回，假装没下过
    #第二步：如果自己赢不了，看看玩家能不能赢！
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:
                board[row][col]=1#假装玩家在这落子
                if check_win(row,col,1):#判断玩家能赢吗？
                    board[row][col]=2#能赢的话，赶紧堵上！
                    return False#防守成功，返回
                board[row][col]=0#如果玩家赢不了，撤回
    #第三步：评估所有空位，根据评分选择最佳位置
    best_score=-1#初始最低分
    best_moves=[]#最佳位置列表

    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:#空位
                #电脑进攻得分
                score_offense=evaluate_position(row, col,2)
                #电脑防守得分（阻止玩家形成好形）
                score_defense=evaluate_position(row,col,1)
                #总得分，进攻分和防守分，进攻更重要（乘以1.2倍）
                total_score=score_offense*1.2+score_defense

                if total_score>best_score:#发现更高分位置
                    best_score=total_score
                    best_moves=[(row, col)]#更新最佳位置列表
                elif total_score==best_score:#如果有同分位置，加入候选列表
                    best_moves.append((row,col))
    #如果有多个最佳位置，随机选择一个
    if best_moves:
        row,col=random.choice(best_moves)
        board[row][col]=2
        return check_win(row,col,2)#检查是否获胜并返回结果
    #极端情况下无最佳位置，随机落子选择一个位置（虽然不太可能出现这种情况）
    available_moves=[]
    for row in range(BOARD_SIZE):
        for col in range(BOARD_SIZE):
            if board[row][col]==0:
                available_moves.append((row, col))#收集所有空位
    if available_moves:
        row, col=random.choice(available_moves)#随机选一个空位
        board[row][col]=2
        return check_win(row,col,2)
    return False


#显示游戏结果
def show_result(winner):
    font = pygame.font.SysFont('Arial',48)#创建Arial，字号48
    if winner==1:
        text=font.render("你赢了！",True,RED)#红色文本
    else:
        text=font.render("电脑赢了！",True,RED)
    #文本居中显示
    text_rect=text.get_rect(center=(WINDOW_WIDTH//2,WINDOW_HEIGHT//2))
    screen.blit(text,text_rect)
    pygame.display.flip()
    pygame.time.wait(3000)#游戏结束界面显示3秒

#主游戏循环
def main():
    #True=玩家落子，False=电脑落子
    player_turn=True
    game_over=False#游戏是否结束1
    winner=None#获胜者，1=是家，2是电脑
    while not game_over:
        #处理事件（鼠标点击、窗口关闭等）
        for event in pygame.event.get():
            if event.type==pygame.QUIT:#窗口关闭事件
                game_over=True#标记游戏结束
            elif event.type==pygame.MOUSEBUTTONDOWN and player_turn and not game_over:#玩家鼠标点击落子
                x, y=event.pos#获取鼠标点击坐标
                col=round((x-GRID_SIZE)/GRID_SIZE)#计算点击位置对应坐标的列和行（减去边框宽度，除以网格大小并取整）
                row=round((y-GRID_SIZE)/GRID_SIZE)
                #坐标在棋盘内且为空位
                if 0 <=row<BOARD_SIZE and 0<=col<BOARD_SIZE and board[row][col]==0:
                    board[row][col]=1#让玩家落黑棋
                    if check_win(row,col,1):#检查玩家是否获胜
                        game_over=True
                        winner=1
                    else:
                        player_turn=False#轮到电脑回合

        #电脑回合（游戏未结束）
        if not player_turn and not game_over:
            if robot_move():
                game_over=True
                winner=2
            else:
                player_turn=True#回到玩家回合
        #画棋盘和棋子
        draw_board()
        draw_pieces()
        #如果游戏结束，显示结果
        if game_over and winner:
            show_result(winner)
            game_over=True#确保只显示一次

        pygame.display.flip()#更新画面
        clock.tick(60)#控制帧率为60帧每秒
    pygame.quit()#退出Pygame
#程序入口点，自动调用main()函数启动游戏
if __name__ == "__main__":
    main()

（十四）代码上传到码云

码云链接：https://gitee.com/huangxun913/pythonandfanwan/commit/78d7451350aca41369232621ee33e8d1feb8a396

四、运行结果

https://www.bilibili.com/video/BV1v8T7z3ExC/?pop_share=1&vd_source=4bc8b4c7cc0447b16e5b5ba12c3bc3c5

五、实验总结和感悟
本次选择的实验对于基础一般的我来说难度真的很大，前前后后磨了一周多（挑选那一周的空余时间，大部分是周五周六周日）。在做实验前自己先花了时间复习之前课上学习的很多已经忘了的语句和知识等等，但是练习得比较少就总会有些生疏。上网查询后，综合考虑，我决定使用Pygame库来实现这个小游戏。说实话，敲出这个五子棋小游戏的代码太需要超强的逻辑了，比如检查是否五子连珠、评估得分、电脑落子决策坐标转换等等，一开始脑子晕乎乎的，自己的逻辑十分混乱，无从下手就找网上一些制作五子棋游戏的视频，但是网上的视频大多是自己和自己下五子棋，我的想做的是人机对战，而找到的唯一的AI智能对战五子棋游戏视频没有源代码参考只有结果演示过程，所以很多视频对我帮助不大，于是我求助ai学习策略，所以本次实验我很多是在大模型的帮助下完成的。学习后我脑子里的思路就慢慢地很清楚了，知道自己要写什么，明白要给电脑机器一个什么样的应对策略，但是没学习那些操作语句前对于怎么把那些东西写出来还是比较迷茫。确认自己的思路后，为了完成本实验，我上网查了许多本次的代码里运用的和pygame有关的语句，比如Pygame初始化、图形绘制、事件处理、时间控制、显示与画面更新、退出游戏等等，其实理解这些东西有些困难，不过求助ai解释后能很顺利地知道怎么使用这些语句。敲打的过程中任然是困难重重，甚至想过是否要降低要求，不实现人机对战，就自己和自己对战并且不绘制图形，只通过在pycharm下方的运行狂框里以16×16的点代表可下棋的地方，x号代表一方，#号代表另一方，通过输入二位坐标来实现自我对战五子棋。最终还是没放弃，可能因为那不是我想做到的东西吧。后来，一点一点尝试，盯着屏幕在无数次大模型的建议和修改下，我深深地认可了这个代码，知道它怎么写出来的，它的每一句在表达什么，某天的凌晨0点23分完整的代码终于呈现出来，宿舍是安静漆黑的，电脑电量是51%，窗帘遮着外面什么也看不到，但我觉得应该是一片星汉灿烂！

六、参考资料
1.学习通上Python的课件
2.b站上的Python制作五子棋视频
3.学习Pygame语句：
https://c.biancheng.net/pygame/the-first-programm.html
https://c.biancheng.net/pygame/event.html
https://c.biancheng.net/pygame/draw.html
https://c.biancheng.net/pygame/font.html
https://zhuanlan.zhihu.com/p/618198911
4.Deepseek、豆包等的修改建议

七、关于2025春季《Python程序设计》课程的总结、感想体会、意见和建议
Python这门课在拥有有趣的灵魂的王老师的带领下很有意思，至今脑海里犹回忆得起“人生苦短，我用Python!”“我命由我不由天”“电科院吴彦祖”“电科院马诚开”“你挂了”等等。学Python前一些学长学姐告诉我比较轻松、随便学学就行，自己真正学的过程中整体上并不觉得轻松，前面学的东西还好，后面学的东西要真真切切地理解还是不容易，再加上我周三白天是满课，下午的最后两节还是游泳课，游完泳后总是拖着疲惫的身子来上Python，所以整个Python课的过程中，我很难免疲惫得打瞌睡导致一些重要的知识点没听，后面一些内容听了也不理解，这是对自己态度不够认真的批评。最大的感悟还是Python真的很有用，体会到了学姐说的“c语言很长的语句用Python几行就写完了”，这也是我选修Python程序设计课的最重要的原因。从基础语法起步，逐步熟悉变量、数据类型、控制结构、函数定义与调用，再到深入学习面向对象编程，理解类与对象等，脑海里慢慢构建起较完整的Python知识体系。实验课的过程中我再次体会到Python简洁灵活的特性，它的可读性和简洁性能够在较少的代码实现各种复杂功能，这也让编程变得高效。但是跟着老师敲打代码是远远不够的，想要掌握Python还需要自己好好磨练一番，勤动手，勤敲打，并在课后课前及时复习。很感动的一件事是王老师真的很忙，但是很耐心地帮我配置之前出错的编译器，真的很感谢。在相处的过程中，真的有受到王老师对电科院的热爱的渲染，像“7号实验室”呀，“见证凌晨四点的电科院”呀，“这首歌是《富丰路7号》”呀，都可以感受到老学长兼老师对电科院的感情，也慢慢地让我对电科院有很大的认同感。我对整个课程没啥意见，老师挺好的，同学挺好的，这门课挺好的。建议的话，真的很喜欢某次在课程后面老师让我们自习的时候放一些小歌，一边敲代码一边轻哼很开心，也很喜欢大家一起听歌，情怀满满，如果每次最后自习的时间能放15-20分钟小歌就更好了，不过没有也可以哒。最后，希望Python陪同我一路生花，我将在朝拜Python的路上等身长扣哈哈。