Python五子棋设计与实现：从GUI到AI评分表全解析

简介：一份基于Python的五子棋毕业设计资料包，面向计算机相关专业毕业生及Python游戏开发入门者。资料以论文加源码形式，完整呈现从需求分析、可行性研究、结构化系统分析到Tkinter界面实现、胜负判定、系统测试与排错的全流程，可直接用于毕业设计参考或二次开发。压缩包内共1个doc文档，约253KB，文档中既包含详细设计论文，也附有可运行的完整源码，方便对照学习。资源重点介绍了游戏可视化模块、玩家操作模块和胜负判定模块的设计，涵盖for循环、canvas组件等关键实现，并展示了主界面及玩家获胜界面；同时针对棋局判断复杂性和界面响应速度等常见问题提供了解决思路。目前已有629人学习下载，适合需要快速搭建课设框架或补充论文细节的读者。

1. 基于Python五子棋：设计与实现到底卡在哪

五子棋规则简单到一句话能说清，但用Python做一套完整的“设计+实现+源码”，难点从来不在规则，而在落子交互、胜负判定、AI算法和工程结构怎么组织。网上能搜到的五子棋源码多半能跑，但要么棋盘画得粗糙、要么没有AI只能双人对战、要么胜负判断写死只查一个方向，交课程设计或毕业设计时一眼就被问住细节。这篇按“从技术选型到AI落子再到验收”的路径展开，适合两类人：准备做基于Python的五子棋毕设、需要一套能直接讲清楚设计思路的代码骨架的同学；想用五子棋练手GUI+基础博弈算法的开发者，不需要先会Pygame，也不需要懂复杂剪枝，把棋盘、规则、AI评分表吃透就够了。

2. 五子棋的技术选型：GUI库与整体架构怎么定

2.1 用tkinter还是Pygame：三个必看的选型依据

常见做法是用tkinter或pygame做界面，两者都能完成“基于Python五子棋游戏的设计与实现”，但定位完全不同。选型可以从三个维度去看：安装成本、绘图控制力、后期扩展空间。

我一般推荐毕设项目用tkinter。理由不是Pygame不好，而是五子棋本身是回合制游戏，不需要帧循环、不需要精灵碰撞，tkinter的Canvas已经能覆盖棋盘绘制、棋子渲染、鼠标响应全部需求。源码结构也更好拆：界面层、逻辑层、AI层三个模块各干各的，答辩时讲设计思路会非常顺。如果你后续想加落子动画、背景音乐、联机对战，再迁移到Pygame也不难，因为核心逻辑和界面是解耦的。

2.2 五子棋核心模块划分与数据表示

工程结构我建议按这样的三层切分，这也是论文里“总体设计”一章最常用的画法：

# game_logic.py —— 逻辑层，与界面完全无关 # 棋盘用15x15的二维列表表示，0空 1黑子 2白子 board = [[0 for _ in range(15)] for _ in range(15)] current_player = 1 # 1黑 2白 def place_stone(row: int, col: int, player: int) -> bool: """落子，成功返回True，位置非法或已有子返回False""" if not (0 <= row < 15 and 0 <= col < 15): return False if board[row][col] != 0: return False board[row][col] = player return True

上面这段定义了最核心的落子接口。row和col是棋盘坐标，0到14对应15条线；player用1和2区分黑白方。设计要点在于逻辑层不引用任何GUI对象，这样后面做AI算法、做单元测试都很舒服。place_stone返回布尔值而不是直接抛异常，是为了让GUI层拿到False好弹提示，不让错误扩散到界面层。

# ai.py —— AI层，接收棋盘快照，返回落子坐标 def ai_move(board_snapshot: list, ai_player: int) -> tuple: """传入15x15棋盘和AI执子颜色，返回(row, col)""" # 核心逻辑：评分表遍历所有空位，选分数最高点 pass

# main.py —— 界面层，负责画棋盘、响应鼠标、调度逻辑 import tkinter as tk import game_logic import ai root = tk.Tk() canvas = tk.Canvas(root, width=600, height=600, bg="#DEB887") canvas.pack() # 绑定鼠标点击事件 canvas.bind("<Button-1>", on_click)

三层之间只通过函数调用沟通，比如on_click拿到坐标后先调game_logic.place_stone，再判断是否结束，最后调ai.ai_move。这个设计的好处是：如果要把AI改成网络对战，只需要替换ai_move这一层，逻辑层和界面层完全不用动。

2.3 棋盘坐标与像素坐标的换算：一个必踩的坑

界面层最容易写错的是坐标换算。鼠标点击获得的是像素坐标，比如Canvas宽度600像素，棋盘有15条线，边距留25像素，则每条线的间距是(600 - 2 * 25) / 14 ≈ 39.3像素。直接用鼠标像素坐标除以格子宽度，取整后就是最近的交叉点下标。

MARGIN = 25 # 棋盘边距，像素 CELL_SIZE = (600 - 2 * MARGIN) / 14 # 格子间距≈39.3 RADIUS = 16 # 棋子绘制半径，像素 def on_click(event): # 将像素坐标换算为最近的行列索引 col = int(round((event.x - MARGIN) / CELL_SIZE)) row = int(round((event.y - MARGIN) / CELL_SIZE)) # 边界检查：越界直接忽略，防止点击边角时crash if not (0 <= row <= 14 and 0 <= col <= 14): return # 转给逻辑层 if game_logic.place_stone(row, col, current_player): draw_stone(row, col, current_player)

像素坐标换算有两个容易出错的地方：一是忘记减去MARGIN，导致棋盘边缘点击时定位偏了一格；二是用int取整而不是round，会让交叉点附近的点击被吸附到错误位置。round会在0.5时取偶，但这个场景下比直接截断更接近人的直觉。换算出row和col后，一定要做边界检查，否则点击窗口角落时索引可能越界，Python虽然不会段错误，但会在列表索引时报IndexError，终端刷一大片红。

3. 五子棋核心功能实现：棋盘绘制、落子与胜负判断

3.1 棋盘与棋子的绘制参数

棋盘绘制直接影响第一观感。用tkinter的create_line画15条横线和15条竖线，用create_oval画棋子。一个常见的错误是棋子大小和格子间距不匹配，画出来要么挤在一起要么空隙太大，观感很廉价。

def draw_board(canvas): """绘制15x15棋盘骨架""" # 画横线和竖线，both: 线条跨越整个棋盘 for i in range(15): start = MARGIN + i * CELL_SIZE canvas.create_line(MARGIN, start, 600 - MARGIN, start, width=2) canvas.create_line(start, MARGIN, start, 600 - MARGIN, width=2) # 画5个星位（小圆点），传统棋盘标记 for pos in [(3, 3), (3, 11), (7, 7), (11, 3), (11, 11)]: x = MARGIN + pos[0] * CELL_SIZE y = MARGIN + pos[1] * CELL_SIZE canvas.create_oval(x - 4, y - 4, x + 4, y + 4, fill="black") def draw_stone(row, col, player): x = MARGIN + col * CELL_SIZE y = MARGIN + row * CELL_SIZE color = "black" if player == 1 else "white" canvas.create_oval(x - RADIUS, y - RADIUS, x + RADIUS, y + RADIUS, fill=color, outline="black", width=2)

RADIUS取CELL_SIZE的0.4到0.45倍比较合适，太大棋子相邻会重叠，太小棋盘显得空。create_oval的前四个参数是左上角和右下角的坐标，x - RADIUS和y + RADIUS的组合就是画一个以交叉点为中心、直径2倍RADIUS的圆。画白子时outline="black"不能省，否则白色棋子在浅色棋盘背景上会看不清边界。

3.2 胜负判断的四方向扫描与边界处理

胜负判断是五子棋源码里最容易写错的部分。网上很多版本的实现是：在落子后，从当前点向某个方向数连子，只要数到5就赢。这种写法漏掉了一个关键情况——如果有6个或更多连子，从靠近端点的那一侧数会漏判。可靠的实现是：以当前落子为中心，向正反两个方向同时扫描，累计连子数再加1。

def check_win(board, row, col, player): """从当前落子点出发，四方向探测连子数""" # 四个方向向量：水平、垂直、主对角线、副对角线 directions = [(0, 1), (1, 0), (1, 1), (1, -1)] for dr, dc in directions: count = 1 # 当前落子自身 # 正方向累加 for step in range(1, 5): nr, nc = row + dr * step, col + dc * step if 0 <= nr < 15 and 0 <= nc < 15 and board[nr][nc] == player: count += 1 else: break # 反方向累加 for step in range(1, 5): nr, nc = row - dr * step, col - dc * step if 0 <= nr < 15 and 0 <= nc < 15 and board[nr][nc] == player: count += 1 else: break if count >= 5: return True return False

这个写法里有个值得注意的细节：正方向循环步数上限是4，因为当前棋子自身已经算1个，加上4个就是5连。反方向同理。如果正方向数到4个，反方向又数到4个，count会累加到9，但九连在标准无禁手规则下也算赢，>= 5的判断能覆盖。四个方向向量里，副对角线用(1, -1)表示行增列减，正好是从左下到右上的斜线，这是最容易写反的一个方向。

判断胜负函数的调用时机也有讲究，不能在落子之前判断，否则上一局的盘面会干扰结果。正确顺序是：落子 → 重绘棋子 → 调用check_win→ 若返回True则弹出胜利提示并禁用棋盘。

3.3 悔棋与重新开始：源码里最容易缺的功能

毕设答辩时评委大概率会问“能不能悔棋”“能不能重开一局”。没有这两个功能，代码就只是“能跑”，谈不上“设计完整”。悔棋的实现核心是用一个栈记录每一步的落子位置和玩家颜色。

# 在game_logic.py中 move_stack = [] # 每项是 (row, col, player) def undo() -> bool: """悔棋：弹出最近一步并清空棋位；空栈返回False""" if not move_stack: return False row, col, player = move_stack.pop() board[row][col] = 0 return True

调用undo后，界面层需要把对应位置重绘为背景色，同时把当前回合切换到上一步的玩家。这里有一个人机对战中特别的坑：如果上一手是AI下的，悔棋一次会回到玩家回合；但如果玩家悔棋后又点了一次悔棋，把AI的上上步也撤销了，这时候AI要不要立刻补下一步？我建议只允许悔棋一次，或者每次悔棋后强制AI下一手重新计算，否则步数栈会出现不一致。

def reset_board(): """重置全局棋盘与步数栈""" global board, current_player, move_stack board = [[0 for _ in range(15)] for _ in range(15)] current_player = 1 move_stack.clear()

重新开始时要把move_stack一并清空，这是很多源码的遗漏点。栈不清空的话，新对局中连续点悔棋，会把上一局的棋子一颗颗“悔”回来，逻辑就全乱了。

4. 五子棋AI算法：评分表设计与三个必调参数

4.1 基于评分表的启发式评估：为什么不用minimax

五子棋AI的常见做法有两种，一种是基于评分表的启发式评估，另一种是博弈树加alpha-beta剪枝。minimax虽然理论完美，但标准15x15棋盘的状态空间极大，即使剪枝，初版代码的搜索深度也只能到4层左右，耗时可能超过1秒，而且实现复杂度对毕设源码并不友好。评分表方案更契合“设计与实现”这个题目的性价比要求，它把评估函数做到极致，在一层搜索内就能做出看着像“会下棋”的AI。

评分表的基本思想是：遍历棋盘所有空位，对每个空位分别以黑子视角和白子视角计算放置后的局势分数。分数由该点四个方向（横、竖、两个对角线）上能形成的棋型决定，比如连五、活四、冲四、活三、眠三、活二都对应不同分值。最后该点的总得分是“我方的进攻分+对方的防守分”，取进攻与防守之和最大的点落子。

4.2 评分表设计：五个关键棋型与分值设定

# ai.py —— 评分表核心定义 # 每个元素：(己方棋型, 对方棋型, 得分) # 己方活三1000分，对方活三2000分——防守权重更高，因为对方快赢了 SCORE_TABLE = { (5, 0): 1000000, # 连五，直接赢 (4, 0): 100000, # 活四，对面挡不住 (4, 1): 50000, # 冲四，对方必须挡 (3, 0): 10000, # 活三，对方不挡就变活四 (3, 1): 5000, # 眠三，有威胁但可控 (2, 0): 1000, # 活二，潜在威胁 }

这个表的逻辑是：棋型的分数要拉开数量级差距。连五比活四高一倍多，活四又比冲四高一倍，这样AI在计算时不会出现“冲四不如活二”这种反直觉的选择。对方的棋型在打分时如何处理很关键——我采用的方法是“对方活三按己方活三的2倍计分”，即评估某个点时，不仅计算自己放这里能形成的棋型，也计算对方放这里能形成的棋型，并把对方的威胁转化为己方的防守需求。

def evaluate_position(board, row, col, player): """计算在(row,col)放player棋子后的总分数""" temp_board = [row_list[:] for row_list in board] # 深拷贝，避免污染真实棋盘 temp_board[row][col] = player score = 0 opponent = 3 - player # 1对2，2对1 for dr, dc in [(0, 1), (1, 0), (1, 1), (1, -1)]: # 攻击分：自己放这里的收益 my_count = count_streak(temp_board, row, col, player, dr, dc) # 防守分：如果对方放在这里会多强，就得多重视这个点 opp_count = count_streak(temp_board, row, col, opponent, dr, dc) score += get_score(my_count, opp_count) return score def ai_move(board_snapshot, ai_player): """遍历所有空位，选评分最高点。若棋盘为空则当头落中间""" best_score = -1 best_move = (7, 7) # 默认天元，棋盘中心 empty_cells = [(r, c) for r in range(15) for c in range(15) if board_snapshot[r][c] == 0] if len(empty_cells) == 225: return (7, 7) # 开局的固定应对，省一次全盘扫描 for r, c in empty_cells: attack_score = evaluate_position(board_snapshot, r, c, ai_player) defend_score = evaluate_position(board_snapshot, r, c, 3 - ai_player) total = attack_score + defend_score * 0.9 # 防守权重略低 if total > best_score: best_score = total best_move = (r, c) return best_move

这里有两个参数直接决定AI强弱：防守权重0.9和空局默认点。防守权重越大，AI越保守，倾向于堵对方而非自己做棋；越小越激进，可能只顾自己连五而漏防。0.9是相对均衡的值，如果你希望AI显得聪明，可以改成0.8试试——它会在对方只有活三时果断做自己的活三，形成对攻；如果改成1.0，会明显防守过重，每一步都在堵路，攻击力很弱。count_streak的职责是统计在指定方向上，从当前点出发连续同色棋子的数量。

4.3 一个让AI更聪明的优化：空位邻域裁剪

全棋盘225个空位逐个评估，每步大约要算225 * 4个方向，性能其实没问题，Python跑下来也就几十毫秒。但有个明显的策略缺陷：AI会在离棋子很远的地方乱下，比如棋盘左上角有个黑子，AI评估右下角的点时发现没有东西可堵、也没有东西可连，分数是0，但0比负数大，最后AI可能落在某个无关位置。解决方式是只评估已有棋子周围2格范围内的空位。

def get_candidate_moves(board, radius=2): """获取所有已有棋子半径radius内的空位""" candidates = set() for r in range(15): for c in range(15): if board[r][c] == 0: # 扫描这个空位周围radius格有没有棋子 for dr_dc in neighbors_within(board, r, c, radius): if board[dr_dc[0]][dr_dc[1]] != 0: candidates.add((r, c)) break if not candidates: # 开局棋盘全空，直接落中心 return [(7, 7)] return list(candidates)

加上邻域裁剪后，不仅AI更“像人”，而且计算量从225次评估降到可能不足30次，为后续扩展搜索深度留出了性能余量。radius=2是兼顾计算量与棋感的经验值，改小到1会让AI看不出间隔两格的棋型，改大到3会引入远端噪音。需要注意裁剪后棋盘全空时返回(7,7)天元位，这样黑棋开局必然占据中心，是五子棋的标准策略。

5. 从能下到能交：五子棋系统的验证口径与论文映射

5.1 边界用例测试清单：四个必测的胜负场景

写完代码别急着写论文，先把胜负判断和AI逻辑的边界用例跑一遍。我常用的测试方法是单独写一个测试脚本，直接import逻辑层，不启动GUI。

# test_cases.py —— 手动构造棋盘，验证胜负判断与AI import game_logic import ai def test_horizontal_win(): """测试横向五连判定""" board = [[0]*15 for _ in range(15)] for i in range(5): board[7][i] = 1 # 第7行第0~4列全是黑子 assert game_logic.check_win(board, 7, 4, 1) is True print("横向五连判定通过") def test_diagonal_win(): """测试斜向五连判定""" board = [[0]*15 for _ in range(15)] for i in range(5): board[5 + i][5 + i] = 2 # 主对角线白子五连 assert game_logic.check_win(board, 9, 9, 2) is True print("对角线五连判定通过")

除横向和对角线外，务必测长连。按无禁手规则，六个连子也是赢，所以把board[7][0]到board[7][5]全放黑子，从中间位置（比如7,3）触发check_win，必须返回True。很多简化版实现只从落子点向外数4个格子，在长连时从中间落子只数到一侧3个、另一侧2个，加起来6个却漏判，这类bug在测试里一跑就原形毕露。

AI方面的测试重点是：给定一个对方已经四连且两端都空白的局面，AI必须优先堵中间而非自己做冲三。手动构造一个这样的盘面，断言ai_move返回的位置是堵截点。如果AI答错，大概率是防守权重算错了或评分表里冲四和活三的分值倒挂。

5.2 性能数据采集：论文里最有说服力的实验数据

论文的“系统测试”章节需要数据支撑，建议在源码里加一段计时代码记录AI决策耗时。做法是在ai_move外层包一个time.time()记录前后差值。

import time start = time.time() move = ai.ai_move(game_logic.board, ai_player=2) elapsed = time.time() - start print(f"AI决策点: {move}, 耗时: {elapsed * 1000:.1f}ms")

以现代台式机或笔记本运行上面代码，评分表AI的决策时间通常在10到80毫秒之间，完全可以满足“落子后1秒内响应”的交互要求。测试时记录三组数据：开局阶段（空盘）、中盘（约30手）、收官（约50手）的决策耗时，和满分结果一起写入论文测试表，比“系统运行流畅”这种话有说服力得多。

5.3 实现与论文结构对照：一张表说清

答辩时常见的问题是“AI算法原理是什么”“为什么这么设计”。评分表方案的优势在于，你可以从AI的行为反推设计思路：AI优先堵四连，是因为防守分计算时同样套用了count_streak，把对方落子的威胁量化成了分数；AI会在空局落天元，是因为空局候选列表返回了默认值。这些细节在实现中都能观察到，答辩时能答得越多，源码的完整度就越经得起追问。

本文还有配套的精品资源，点击获取