以下内容仅为自己python语言练手与记忆所写，代码注释大部分为al生成有任何不足之处请见谅。

各位读者有兴趣的可以完善该项目，如进行界面美化，引用数据库增加别的功能等等。

以下是各个文件的作用说明：
students.json
存储学生信息的数据文件，采用 JSON 格式。每个学生信息包含姓名（name）、数学成绩（math）、语文成绩（chinese）、英语成绩（english），是系统数据的持久化存储载体。

学生信息管理系统 tk 版.py
系统的登录界面模块，基于 Tkinter 实现。
提供用户名和密码输入框，通过check_login方法验证登录信息（默认用户名admin，密码123456）。
登录成功后销毁登录界面，跳转至主功能界面（MainPage）。

views.py
定义了系统的各个功能界面，均继承自tk.Frame：
InsertFrame：学生信息录入界面，支持输入姓名和三门成绩，验证后通过add_student保存数据。
SearchFrame：学生信息查询界面，可通过关键词搜索并在列表中显示结果。
DeleteFrame：学生信息删除界面，输入姓名后删除对应学生，并刷新列表。
UpdateFrame：学生信息修改界面，先搜索学生，再编辑信息并更新。
AboutFrame：系统关于界面，显示版本、开发者等信息。

main.py
系统的主界面模块，负责整合各功能界面并提供导航：
创建菜单栏，包含 “录入”“查询”“删除”“修改”“关于” 选项。
通过hide_all_frames和show_xxx_frame方法切换不同功能界面，默认显示录入界面。

data_handler.py
数据处理模块，提供与students.json文件交互的工具函数：
load_data/save_data：加载 / 保存 JSON 数据。
add_student/delete_student/update_student：添加 / 删除 / 更新学生信息。
search_students：根据关键词搜索学生（默认按姓名搜索）。

main.py文件

# main.py  # 1：文件说明
import tkinter as tk  # 2：导入tkinter库，用于创建GUI
from data_handler import load_data  # 3：从data_handler模块导入load_data函数（加载学生数据）
from views import InsertFrame, SearchFrame, DeleteFrame, UpdateFrame, AboutFrame  # 4：从views模块导入各功能页面类


class MainPage:  # 5：定义主页面类，管理整个系统的界面切换
    def __init__(self, root2):  # 6：初始化方法，接收主窗口对象
        self.root = root2  # 7：保存主窗口对象到实例变量
        self.root.title('学生信息管理系统 v1.0')  # 8：设置窗口标题
        self.root.geometry('700x500')  # 9：设置窗口初始大小（宽700，高500）
        self.create_page()  # 10：调用create_page方法创建菜单栏

        # 创建各个页面  # 11：注释：说明以下代码作用
        self.insert_frame = InsertFrame(self.root)  # 12：实例化录入页面（InsertFrame）
        self.search_frame = SearchFrame(self.root)  # 13：实例化查询页面（SearchFrame）
        self.delete_frame = DeleteFrame(self.root)  # 14：实例化删除页面（DeleteFrame）
        self.update_frame = UpdateFrame(self.root)  # 15：实例化修改页面（UpdateFrame）
        self.about_frame = AboutFrame(self.root)  # 16：实例化关于页面（AboutFrame）

        # 默认显示录入页面  # 17：注释：说明默认显示的页面
        self.show_insert_frame()  # 18：调用方法显示录入页面

    def create_page(self):  # 19：定义创建菜单栏的方法
        menu_bar = tk.Menu(self.root)  # 20：创建菜单栏对象

        # 向菜单栏添加命令（对应各功能页面）  # 21：注释：说明以下代码作用
        menu_bar.add_command(label='录入', command=self.show_insert_frame)  # 22：添加“录入”菜单，点击调用显示录入页面的方法
        menu_bar.add_command(label='查询', command=self.show_search_frame)  # 23：添加“查询”菜单，点击调用显示查询页面的方法
        menu_bar.add_command(label='删除', command=self.show_delete_frame)  # 24：添加“删除”菜单，点击调用显示删除页面的方法
        menu_bar.add_command(label='修改', command=self.show_update_frame)  # 25：添加“修改”菜单，点击调用显示修改页面的方法
        menu_bar.add_command(label='关于', command=self.show_about_frame)  # 26：添加“关于”菜单，点击调用显示关于页面的方法
        self.root['menu'] = menu_bar  # 设置菜单栏  # 27：将菜单栏绑定到主窗口

    def hide_all_frames(self):  # 28：定义隐藏所有页面的方法（用于切换页面时清空当前显示）
        """隐藏所有框架"""  # 29：文档字符串：说明方法功能
        self.insert_frame.pack_forget()  # 30：隐藏录入页面（取消pack布局）
        self.search_frame.pack_forget()  # 31：隐藏查询页面
        self.delete_frame.pack_forget()  # 32：隐藏删除页面
        self.update_frame.pack_forget()  # 33：隐藏修改页面
        self.about_frame.pack_forget()  # 34：隐藏关于页面

    def show_insert_frame(self):  # 35：定义显示录入页面的方法
        self.hide_all_frames()  # 36：先隐藏所有页面
        self.insert_frame.pack(fill=tk.BOTH, expand=True)  # 37：显示录入页面（填充整个窗口并允许扩展）

    def show_search_frame(self):  # 38：定义显示查询页面的方法
        self.hide_all_frames()  # 39：先隐藏所有页面
        self.search_frame.pack(fill=tk.BOTH, expand=True)  # 40：显示查询页面
        # 刷新搜索页面显示  # 41：注释：说明以下代码作用
        self.search_frame.display_students(load_data())  # 42：调用查询页面的display_students方法，加载并显示所有学生数据

    def show_delete_frame(self):  # 43：定义显示删除页面的方法
        self.hide_all_frames()  # 44：先隐藏所有页面
        self.delete_frame.pack(fill=tk.BOTH, expand=True)  # 45：显示删除页面
        # 刷新删除页面显示  # 46：注释：说明以下代码作用
        self.delete_frame.display_students(load_data())  # 47：调用删除页面的display_students方法，加载并显示所有学生数据

    def show_update_frame(self):  # 48：定义显示修改页面的方法
        self.hide_all_frames()  # 49：先隐藏所有页面
        self.update_frame.pack(fill=tk.BOTH, expand=True)  # 50：显示修改页面

    def show_about_frame(self):  # 51：定义显示关于页面的方法
        self.hide_all_frames()  # 52：先隐藏所有页面
        self.about_frame.pack(fill=tk.BOTH, expand=True)  # 53：显示关于页面


if __name__ == "__main__":  # 54：判断是否为主程序入口
    root = tk.Tk()  # 55：创建tkinter主窗口对象
    app = MainPage(root)  # 56：实例化MainPage类，传入主窗口
    root.mainloop()  # 57：启动主窗口事件循环（保持窗口显示）

views.py文件

# views.py  # 1：文件说明
import tkinter as tk  # 2：导入tkinter库
import tkinter.messagebox as messagebox  # 3：导入消息框模块（用于弹出提示）
from data_handler import *  # 4：导入data_handler模块的所有函数（处理数据读写）


class InsertFrame(tk.Frame):  # 5：定义录入页面类（继承自tk.Frame）
    def __init__(self, root):  # 6：初始化方法，接收父窗口对象
        super().__init__(master=root)  # 7：调用父类（tk.Frame）的初始化方法

        # 定义字符串变量，用于绑定输入框内容  # 8：注释：说明以下变量作用
        self.name = tk.StringVar()  # 9：存储学生姓名的变量
        self.math = tk.StringVar()  # 10：存储数学成绩的变量
        self.chinese = tk.StringVar()  # 11：存储语文成绩的变量
        self.english = tk.StringVar()  # 12：存储英语成绩的变量
        self.status = tk.StringVar()  # 13：存储状态提示信息的变量

        self.create_page()  # 14：调用create_page方法创建页面元素

    def create_page(self):  # 15：定义创建录入页面元素的方法
        # 创建标题标签  # 16：注释：说明以下代码作用
        tk.Label(self, text='学生信息录入', font=('Arial', 16)).grid(row=0, column=0, columnspan=2, pady=10)  # 17：标题“学生信息录入”，字体16号Arial，占2列，上下边距10

        # 姓名输入区域  # 18：注释：说明以下代码作用
        tk.Label(self, text='姓名：').grid(row=1, column=0, padx=10, pady=5, sticky='e')  # 19：“姓名：”标签，位于(1,0)，左右边距10，上下边距5，右对齐
        tk.Entry(self, textvariable=self.name, width=20).grid(row=1, column=1, padx=10, pady=5)  # 20：姓名输入框，绑定self.name变量，宽20，位于(1,1)

        # 数学成绩输入区域  # 21：注释：说明以下代码作用
        tk.Label(self, text='数学成绩：').grid(row=2, column=0, padx=10, pady=5, sticky='e')  # 22：“数学成绩：”标签，位于(2,0)
        tk.Entry(self, textvariable=self.math, width=20).grid(row=2, column=1, padx=10, pady=5)  # 23：数学成绩输入框，绑定self.math变量，位于(2,1)

        # 语文成绩输入区域  # 24：注释：说明以下代码作用
        tk.Label(self, text='语文成绩：').grid(row=3, column=0, padx=10, pady=5, sticky='e')  # 25：“语文成绩：”标签，位于(3,0)
        tk.Entry(self, textvariable=self.chinese, width=20).grid(row=3, column=1, padx=10, pady=5)  # 26：语文成绩输入框，绑定self.chinese变量，位于(3,1)

        # 英语成绩输入区域  # 27：注释：说明以下代码作用
        tk.Label(self, text='英语成绩：').grid(row=4, column=0, padx=10, pady=5, sticky='e')  # 28：“英语成绩：”标签，位于(4,0)
        tk.Entry(self, textvariable=self.english, width=20).grid(row=4, column=1, padx=10, pady=5)  # 29：英语成绩输入框，绑定self.english变量，位于(4,1)

        # 录入按钮和状态标签  # 30：注释：说明以下代码作用
        tk.Button(self, text='录入', command=self.record, width=10).grid(row=5, column=0, columnspan=2, pady=10)  # 31：“录入”按钮，点击调用record方法，宽10，占2列，上下边距10
        tk.Label(self, textvariable=self.status, fg='green').grid(row=6, column=0, columnspan=2)  # 32：状态提示标签，绑定self.status变量，文字绿色，占2列

    def record(self):  # 33：定义录入数据的方法
        # 验证输入  # 34：注释：说明以下代码作用
        if not self.name.get():  # 35：判断姓名是否为空（get()获取输入框内容）
            self.status.set("姓名不能为空")  # 36：设置状态提示“姓名不能为空”
            return  # 37：终止方法执行

        try:  # 38：尝试将成绩转换为浮点数（验证是否为数字）
            math_score = float(self.math.get())  # 39：将数学成绩转换为浮点数
            chinese_score = float(self.chinese.get())  # 40：将语文成绩转换为浮点数
            english_score = float(self.english.get())  # 41：将英语成绩转换为浮点数
        except ValueError:  # 42：若转换失败（输入非数字）
            self.status.set("成绩必须是数字")  # 43：设置状态提示“成绩必须是数字”
            return  # 44：终止方法执行

        # 创建学生信息字典  # 45：注释：说明以下代码作用
        student = {  # 46：定义学生信息字典
            'name': self.name.get(),  # 47：姓名
            'math': math_score,  # 48：数学成绩
            'chinese': chinese_score,  # 49：语文成绩
            'english': english_score  # 50：英语成绩
        }

        # 保存数据  # 51：注释：说明以下代码作用
        add_student(student)  # 52：调用add_student函数保存学生信息

        # 清空输入框  # 53：注释：说明以下代码作用
        self.name.set("")  # 54：清空姓名输入框
        self.math.set("")  # 55：清空数学成绩输入框
        self.chinese.set("")  # 56：清空语文成绩输入框
        self.english.set("")  # 57：清空英语成绩输入框

        self.status.set("录入成功！")  # 58：设置状态提示“录入成功！”

        # 3秒后清除状态消息  # 59：注释：说明以下代码作用
        self.after(3000, lambda: self.status.set(""))  # 60：3000毫秒（3秒）后执行匿名函数，清空状态提示


class SearchFrame(tk.Frame):  # 61：定义查询页面类（继承自tk.Frame）
    def __init__(self, root):  # 62：初始化方法，接收父窗口对象
        super().__init__(master=root)  # 63：调用父类初始化方法
        self.search_keyword = tk.StringVar()  # 64：存储搜索关键词的变量
        self.create_page()  # 65：调用create_page方法创建页面元素

    def create_page(self):  # 66：定义创建查询页面元素的方法
        # 标题  # 67：注释：说明以下代码作用
        tk.Label(self, text='学生信息查询', font=('Arial', 16)).grid(row=0, column=0, columnspan=3, pady=10)  # 68：标题“学生信息查询”，占3列

        # 搜索区域  # 69：注释：说明以下代码作用
        tk.Label(self, text='搜索关键词：').grid(row=1, column=0, padx=5, pady=5, sticky='e')  # 70：“搜索关键词：”标签，位于(1,0)
        tk.Entry(self, textvariable=self.search_keyword, width=20).grid(row=1, column=1, padx=5, pady=5)  # 71：搜索输入框，绑定self.search_keyword变量，位于(1,1)
        tk.Button(self, text='搜索', command=self.search).grid(row=1, column=2, padx=5, pady=5)  # 72：“搜索”按钮，点击调用search方法，位于(1,2)

        # 创建列表框和滚动条  # 73：注释：说明以下代码作用
        self.listbox = tk.Listbox(self, width=50, height=15)  # 74：创建列表框（显示查询结果），宽50，高15
        self.listbox.grid(row=2, column=0, columnspan=3, padx=10, pady=10)  # 75：列表框布局，占3列

        scrollbar = tk.Scrollbar(self, orient="vertical")  # 76：创建垂直滚动条
        scrollbar.config(command=self.listbox.yview)  # 77：绑定滚动条与列表框的y轴视图（滚动时列表框同步滚动）
        scrollbar.grid(row=2, column=3, sticky='ns', pady=10)  # 78：滚动条布局，位于(2,3)，上下拉伸
        self.listbox.config(yscrollcommand=scrollbar.set)  # 79：绑定列表框与滚动条（列表框滚动时更新滚动条位置）

        # 初始显示所有学生  # 80：注释：说明以下代码作用
        self.display_students(load_data())  # 81：调用display_students方法，加载并显示所有学生数据

    def search(self):  # 82：定义搜索方法
        keyword = self.search_keyword.get()  # 83：获取搜索关键词
        students = search_students(keyword)  # 84：调用search_students函数查询学生（返回匹配结果）
        self.display_students(students)  # 85：调用display_students方法显示查询结果

    def display_students(self, students):  # 86：定义显示学生数据的方法（接收学生列表）
        self.listbox.delete(0, tk.END)  # 87：清空列表框（从第0项到最后一项）
        for student in students:  # 88：遍历学生列表
            # 格式化学生信息字符串  # 89：注释：说明以下代码作用
            info = f"姓名: {student['name']}, 数学: {student['math']}, 语文: {student['chinese']}, 英语: {student['english']}"  # 90：拼接学生信息（姓名+各科成绩）
            self.listbox.insert(tk.END, info)  # 91：将格式化信息插入列表框末尾


class DeleteFrame(tk.Frame):  # 92：定义删除页面类（继承自tk.Frame）
    def __init__(self, root):  # 93：初始化方法，接收父窗口对象
        super().__init__(master=root)  # 94：调用父类初始化方法
        self.delete_name = tk.StringVar()  # 95：存储待删除学生姓名的变量
        self.status = tk.StringVar()  # 96：存储状态提示信息的变量
        self.create_page()  # 97：调用create_page方法创建页面元素

    def create_page(self):  # 98：定义创建删除页面元素的方法
        # 标题  # 99：注释：说明以下代码作用
        tk.Label(self, text='删除学生信息', font=('Arial', 16)).grid(row=0, column=0, columnspan=2, pady=10)  # 100：标题“删除学生信息”，占2列

        # 输入区域  # 101：注释：说明以下代码作用
        tk.Label(self, text='要删除的学生姓名：').grid(row=1, column=0, padx=10, pady=5, sticky='e')  # 102：“要删除的学生姓名：”标签，位于(1,0)
        tk.Entry(self, textvariable=self.delete_name, width=20).grid(row=1, column=1, padx=10, pady=5)  # 103：姓名输入框，绑定self.delete_name变量，位于(1,1)

        # 删除按钮和状态标签  # 104：注释：说明以下代码作用
        tk.Button(self, text='删除', command=self.delete, width=10).grid(row=2, column=0, columnspan=2, pady=10)  # 105：“删除”按钮，点击调用delete方法，占2列
        tk.Label(self, textvariable=self.status, fg='red').grid(row=3, column=0, columnspan=2)  # 106：状态提示标签，文字红色，占2列

        # 显示所有学生  # 107：注释：说明以下代码作用
        self.listbox = tk.Listbox(self, width=50, height=10)  # 108：创建列表框（显示所有学生），宽50，高10
        self.listbox.grid(row=4, column=0, columnspan=2, padx=10, pady=10)  # 109：列表框布局，占2列

        scrollbar = tk.Scrollbar(self, orient="vertical")  # 110：创建垂直滚动条
        scrollbar.config(command=self.listbox.yview)  # 111：绑定滚动条与列表框y轴视图
        scrollbar.grid(row=4, column=2, sticky='ns', pady=10)  # 112：滚动条布局，位于(4,2)
        self.listbox.config(yscrollcommand=scrollbar.set)  # 113：绑定列表框与滚动条

        self.display_students(load_data())  # 114：调用display_students方法，加载并显示所有学生数据

    def delete(self):  # 115：定义删除方法
        name = self.delete_name.get()  # 116：获取待删除学生姓名
        if not name:  # 117：判断姓名是否为空
            self.status.set("请输入学生姓名")  # 118：提示“请输入学生姓名”
            return  # 119：终止方法

        if delete_student(name):  # 120：调用delete_student函数删除学生（返回是否删除成功）
            self.status.set(f"成功删除学生: {name}")  # 121：提示“成功删除学生: XXX”
            self.delete_name.set("")  # 122：清空输入框
            # 刷新列表  # 123：注释：说明以下代码作用
            self.display_students(load_data())  # 124：重新加载并显示学生数据（刷新列表）
        else:  # 125：若未找到学生
            self.status.set(f"未找到学生: {name}")  # 126：提示“未找到学生: XXX”

        # 3秒后清除状态消息  # 127：注释：说明以下代码作用
        self.after(3000, lambda: self.status.set(""))  # 128：3秒后清空状态提示

    def display_students(self, students):  # 129：定义显示学生数据的方法（与SearchFrame类似）
        self.listbox.delete(0, tk.END)  # 130：清空列表框
        for student in students:  # 131：遍历学生列表
            info = f"姓名: {student['name']}, 数学: {student['math']}, 语文: {student['chinese']}, 英语: {student['english']}"  # 132：格式化学生信息
            self.listbox.insert(tk.END, info)  # 133：插入列表框


class UpdateFrame(tk.Frame):  # 134：定义修改页面类（继承自tk.Frame）
    def __init__(self, root):  # 135：初始化方法，接收父窗口对象
        super().__init__(master=root)  # 136：调用父类初始化方法

        # 定义变量  # 137：注释：说明以下变量作用
        self.search_name = tk.StringVar()  # 138：存储待搜索学生姓名的变量
        self.name = tk.StringVar()  # 139：存储修改后姓名的变量
        self.math = tk.StringVar()  # 140：存储修改后数学成绩的变量
        self.chinese = tk.StringVar()  # 141：存储修改后语文成绩的变量
        self.english = tk.StringVar()  # 142：存储修改后英语成绩的变量
        self.status = tk.StringVar()  # 143：存储状态提示信息的变量

        self.current_student = None  # 144：存储当前选中的学生信息（初始为None）

        self.create_page()  # 145：调用create_page方法创建页面元素

    def create_page(self):  # 146：定义创建修改页面元素的方法
        # 标题  # 147：注释：说明以下代码作用
        tk.Label(self, text='修改学生信息', font=('Arial', 16)).grid(row=0, column=0, columnspan=2, pady=10)  # 148：标题“修改学生信息”，占2列

        # 搜索区域  # 149：注释：说明以下代码作用
        tk.Label(self, text='要修改的学生姓名：').grid(row=1, column=0, padx=10, pady=5, sticky='e')  # 150：“要修改的学生姓名：”标签，位于(1,0)
        tk.Entry(self, textvariable=self.search_name, width=20).grid(row=1, column=1, padx=10, pady=5)  # 151：搜索输入框，绑定self.search_name变量，位于(1,1)
        tk.Button(self, text='搜索', command=self.search_student).grid(row=1, column=2, padx=5, pady=5)  # 152：“搜索”按钮，点击调用search_student方法，位于(1,2)

        # 信息编辑区域  # 153：注释：说明以下代码作用
        tk.Label(self, text='姓名：').grid(row=2, column=0, padx=10, pady=5, sticky='e')  # 154：“姓名：”标签，位于(2,0)
        tk.Entry(self, textvariable=self.name, width=20).grid(row=2, column=1, padx=10, pady=5)  # 155：姓名编辑框，绑定self.name变量，位于(2,1)

        tk.Label(self, text='数学成绩：').grid(row=3, column=0, padx=10, pady=5, sticky='e')  # 156：“数学成绩：”标签，位于(3,0)
        tk.Entry(self, textvariable=self.math, width=20).grid(row=3, column=1, padx=10, pady=5)  # 157：数学成绩编辑框，绑定self.math变量，位于(3,1)

        tk.Label(self, text='语文成绩：').grid(row=4, column=0, padx=10, pady=5, sticky='e')  # 158：“语文成绩：”标签，位于(4,0)
        tk.Entry(self, textvariable=self.chinese, width=20).grid(row=4, column=1, padx=10, pady=5)  # 159：语文成绩编辑框，绑定self.chinese变量，位于(4,1)

        tk.Label(self, text='英语成绩：').grid(row=5, column=0, padx=10, pady=5, sticky='e')  # 160：“英语成绩：”标签，位于(5,0)
        tk.Entry(self, textvariable=self.english, width=20).grid(row=5, column=1, padx=10, pady=5)  # 161：英语成绩编辑框，绑定self.english变量，位于(5,1)

        # 更新按钮和状态标签  # 162：注释：说明以下代码作用
        tk.Button(self, text='更新', command=self.update, width=10).grid(row=6, column=0, columnspan=2, pady=10)  # 163：“更新”按钮，点击调用update方法，占2列
        tk.Label(self, textvariable=self.status, fg='blue').grid(row=7, column=0, columnspan=2)  # 164：状态提示标签，文字蓝色，占2列

    def search_student(self):  # 165：定义搜索学生的方法
        name = self.search_name.get()  # 166：获取搜索姓名
        if not name:  # 167：判断姓名是否为空
            self.status.set("请输入学生姓名")  # 168：提示“请输入学生姓名”
            return  # 169：终止方法

        students = search_students(name)  # 170：调用search_students函数查询学生
        if students:  # 171：若查询到结果
            self.current_student = students[0]  # 172：保存第一个匹配的学生信息
            # 将学生信息填充到编辑框  # 173：注释：说明以下代码作用
            self.name.set(self.current_student['name'])  # 174：设置姓名编辑框内容
            self.math.set(self.current_student['math'])  # 175：设置数学成绩编辑框内容
            self.chinese.set(self.current_student['chinese'])  # 176：设置语文成绩编辑框内容
            self.english.set(self.current_student['english'])  # 177：设置英语成绩编辑框内容
            self.status.set("找到学生，可以修改信息")  # 178：提示“找到学生，可以修改信息”
        else:  # 179：若未找到
            self.status.set("未找到该学生")  # 180：提示“未找到该学生”
            self.clear_fields()  # 181：调用clear_fields方法清空编辑框

    def update(self):  # 182：定义更新学生信息的方法
        if not self.current_student:  # 183：判断是否已搜索到学生（current_student是否为None）
            self.status.set("请先搜索要修改的学生")  # 184：提示“请先搜索要修改的学生”
            return  # 185：终止方法

        # 验证输入  # 186：注释：说明以下代码作用
        if not self.name.get():  # 187：判断修改后姓名是否为空
            self.status.set("姓名不能为空")  # 188：提示“姓名不能为空”
            return  # 189：终止方法

        try:  # 190：验证成绩是否为数字
            math_score = float(self.math.get())  # 191：转换数学成绩为浮点数
            chinese_score = float(self.chinese.get())  # 192：转换语文成绩为浮点数
            english_score = float(self.english.get())  # 193：转换英语成绩为浮点数
        except ValueError:  # 194：转换失败
            self.status.set("成绩必须是数字")  # 195：提示“成绩必须是数字”
            return  # 196：终止方法

        # 更新信息  # 197：注释：说明以下代码作用
        updated_info = {  # 198：定义更新后的信息字典
            'name': self.name.get(),  # 199：新姓名
            'math': math_score,  # 200：新数学成绩
            'chinese': chinese_score,  # 201：新语文成绩
            'english': english_score  # 202：新英语成绩
        }

        # 调用update_student函数更新数据（传入原姓名和新信息）  # 203：注释：说明以下代码作用
        if update_student(self.current_student['name'], updated_info):  # 204：若更新成功
            self.status.set("更新成功！")  # 205：提示“更新成功！”
            self.current_student = None  # 206：清空当前学生信息
            self.search_name.set("")  # 207：清空搜索输入框
            self.clear_fields()  # 208：清空编辑框
        else:  # 209：若更新失败
            self.status.set("更新失败")  # 210：提示“更新失败”

        # 3秒后清除状态消息  # 211：注释：说明以下代码作用
        self.after(3000, lambda: self.status.set(""))  # 212：3秒后清空状态提示

    def clear_fields(self):  # 213：定义清空编辑框的方法
        self.name.set("")  # 214：清空姓名编辑框
        self.math.set("")  # 215：清空数学成绩编辑框
        self.chinese.set("")  # 216：清空语文成绩编辑框
        self.english.set("")  # 217：清空英语成绩编辑框


class AboutFrame(tk.Frame):  # 218：定义关于页面类（继承自tk.Frame）
    def __init__(self, root):  # 219：初始化方法，接收父窗口对象
        super().__init__(master=root)  # 220：调用父类初始化方法
        self.create_page()  # 221：调用create_page方法创建页面元素

    def create_page(self):  # 222：定义创建关于页面元素的方法
        tk.Label(self, text='学生信息管理系统', font=('Arial', 16)).pack(pady=20)  # 223：系统名称标签，字体16号，上下边距20
        tk.Label(self, text='版本: v1.0').pack(pady=5)  # 224：版本信息标签，上下边距5
        tk.Label(self, text='开发人员: 等待希望').pack(pady=5)  # 225：开发人员标签，上下边距5
        tk.Label(self, text='版权所有 © 2025').pack(pady=5)  # 226：版权信息标签，上下边距5

students.json文件

[  // 1：JSON数组（存储学生信息列表）
  {  // 2：第一个学生对象
    "name": "希望",  // 3：学生姓名
    "math": 77.0,  // 4：数学成绩（浮点数）
    "chinese": 88.0,  // 5：语文成绩
    "english": 99.0  // 6：英语成绩
  },  // 7：对象结束
  {  // 8：第二个学生对象
    "name": "等待",  // 9：学生姓名
    "math": 99.0,  // 10：数学成绩
    "chinese": 99.0,  // 11：语文成绩
    "english": 99.0  // 12：英语成绩
  }  // 13：对象结束
]  // 14：数组结束

data_handler.py文件

# data_handler.py  # 1：文件说明（数据处理模块）
import os  # 2：导入os库（用于文件路径操作）
import json  # 3：导入json库（用于JSON数据读写）

DATA_FILE = "students.json"  # 4：定义数据文件名（固定为students.json）


def load_data():  # 5：定义加载学生数据的函数
    """加载学生数据"""  # 6：文档字符串：说明函数功能
    if not os.path.exists(DATA_FILE):  # 7：判断数据文件是否存在
        return []  # 8：若不存在，返回空列表

    try:  # 9：尝试读取文件（处理可能的异常）
        with open(DATA_FILE, 'r', encoding='utf-8') as f:  # 10：以只读、utf-8编码打开文件
            return json.load(f)  # 11：解析JSON数据并返回（列表类型）
    except:  # 12：若读取/解析失败（如文件损坏）
        return []  # 13：返回空列表


def save_data(students):  # 14：定义保存学生数据的函数（接收学生列表）
    """保存学生数据"""  # 15：文档字符串：说明函数功能
    with open(DATA_FILE, 'w', encoding='utf-8') as f:  # 16：以写入、utf-8编码打开文件（覆盖原内容）
        # 写入JSON数据，确保中文正常显示，缩进2空格  # 17：注释：说明参数作用
        json.dump(students, f, ensure_ascii=False, indent=2)  # 18：将学生列表转换为JSON字符串并写入文件


def add_student(student):  # 19：定义添加学生的函数（接收单个学生字典）
    """添加学生"""  # 20：文档字符串：说明函数功能
    students = load_data()  # 21：加载现有学生数据
    students.append(student)  # 22：将新学生添加到列表
    save_data(students)  # 23：保存更新后的列表


def search_students(keyword=None, field="name"):  # 24：定义搜索学生的函数（关键词默认None，搜索字段默认name）
    """搜索学生"""  # 25：文档字符串：说明函数功能
    students = load_data()  # 26：加载所有学生数据
    if not keyword:  # 27：若未输入关键词
        return students  # 28：返回所有学生

    result = []  # 29：定义结果列表
    for student in students:  # 30：遍历所有学生
        # 判断关键词是否包含在指定字段中（忽略大小写）  # 31：注释：说明判断逻辑
        if keyword.lower() in student.get(field, "").lower():  # 32：field默认是name，转换为小写后判断包含关系
            result.append(student)  # 33：若匹配，添加到结果列表
    return result  # 34：返回匹配结果


def delete_student(name):  # 35：定义删除学生的函数（接收学生姓名）
    """删除学生"""  # 36：文档字符串：说明函数功能
    students = load_data()  # 37：加载所有学生数据
    # 过滤出姓名不等于待删除姓名的学生（即保留未删除的）  # 38：注释：说明过滤逻辑
    updated_students = [s for s in students if s['name'] != name]  # 39：列表推导式过滤学生

    if len(updated_students) < len(students):  # 40：若过滤后数量减少（说明删除成功）
        save_data(updated_students)  # 41：保存更新后的列表
        return True  # 42：返回True表示删除成功
    return False  # 43：返回False表示未找到该学生


def update_student(name, updated_info):  # 44：定义更新学生信息的函数（原姓名+新信息字典）
    """更新学生信息"""  # 45：文档字符串：说明函数功能
    students = load_data()  # 46：加载所有学生数据
    for student in students:  # 47：遍历所有学生
        if student['name'] == name:  # 48：找到姓名匹配的学生
            student.update(updated_info)  # 49：用新信息更新该学生字典
            save_data(students)  # 50：保存更新后的列表
            return True  # 51：返回True表示更新成功
    return False  # 52：返回False表示未找到该学生

学生信息管理系统 tk 版.py文件

# 学生信息管理系统tk版.py  # 1：文件说明（程序入口，包含登录页面）
import tkinter as tk  # 2：导入tkinter库
from main import MainPage  # 3：从main模块导入MainPage类（主页面）


class LoginPage:  # 4：定义登录页面类
    def __init__(self, root2):  # 5：初始化方法，接收主窗口对象
        self.root = root2  # 6：保存主窗口对象到实例变量
        self.login_frame = tk.Frame(self.root)  # 7：创建登录页面的Frame容器
        self.login_frame.pack(pady=50)  # 8：布局Frame（上下边距50）

        self.root.title('学生信息管理系统 - 登录')  # 9：设置窗口标题
        self.root.geometry('400x300')  # 10：设置窗口初始大小（宽400，高300）

        self.username = tk.StringVar()  # 11：存储用户名的变量
        self.password = tk.StringVar()  # 12：存储密码的变量

        self.create_page()  # 13：调用create_page方法创建登录页面元素

        self.root.mainloop()  # 14：启动主窗口事件循环

    def create_page(self):  # 15：定义创建登录页面元素的方法
        # 标题  # 16：注释：说明以下代码作用
        tk.Label(self.login_frame, text='学生信息管理系统', font=('Arial', 16)).grid(row=0, column=0, columnspan=2,
                                                                                     pady=20)  # 17：系统名称标签，占2列，上下边距20

        # 用户名输入区域  # 18：注释：说明以下代码作用
        tk.Label(self.login_frame, text='用户名:').grid(row=1, column=0, padx=10, pady=10, sticky='e')  # 19：“用户名:”标签，位于(1,0)
        tk.Entry(self.login_frame, textvariable=self.username, width=20).grid(row=1, column=1, padx=10, pady=10)  # 20：用户名输入框，绑定self.username变量，位于(1,1)

        # 密码输入区域  # 21：注释：说明以下代码作用
        tk.Label(self.login_frame, text='密码:').grid(row=2, column=0, padx=10, pady=10, sticky='e')  # 22：“密码:”标签，位于(2,0)
        # 密码输入框，显示为*，绑定self.password变量  # 23：注释：说明密码框特性
        tk.Entry(self.login_frame, textvariable=self.password, show='*', width=20).grid(row=2, column=1, padx=10,
                                                                                        pady=10)  # 24：密码输入框，位于(2,1)

        # 登录按钮  # 25：注释：说明以下代码作用
        tk.Button(self.login_frame, text='登录', command=self.check_login, width=10).grid(row=3, column=0, columnspan=2,
                                                                                          pady=20)  # 26：“登录”按钮，点击调用check_login方法，占2列

        # 添加一个简单的状态标签  # 27：注释：说明以下代码作用
        self.status_label = tk.Label(self.login_frame, text='', fg='red')  # 28：创建状态标签（初始为空，文字红色）
        self.status_label.grid(row=4, column=0, columnspan=2)  # 29：标签布局，占2列

    def check_login(self):  # 30：定义验证登录的方法
        username = self.username.get()  # 31：获取用户名输入
        password = self.password.get()  # 32：获取密码输入

        # 简单的登录验证  # 33：注释：说明验证逻辑
        if username == 'admin' and password == '123456':  # 34：判断用户名和密码是否为admin/123456
            self.login_frame.destroy()  # 35：销毁登录页面Frame
            MainPage(self.root)  # 36：实例化MainPage，显示主页面
        else:  # 37：若验证失败
            self.status_label.config(text='用户名或密码错误')  # 38：设置状态标签提示“用户名或密码错误”


if __name__ == "__main__":  # 39：判断是否为主程序入口
    root = tk.Tk()  # 40：创建tkinter主窗口对象
    LoginPage(root)  # 41：实例化LoginPage类，传入主窗口（启动登录页面）