devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python课程设计——单项选择题答题与管理系统（已利用tkinter库实现图形化界面）_用python制作答题系统

作者：Cpp五条 | 2024-04-06 09:53:08

赞

踩

用python制作答题系统

本文的单项选择题与管理系统通过面向对象实现，调用tkinter完成了基本GUI界面，文件存储方面采用txt格式化存储、读取数据，主要功能围绕基本的“增删改查”展开，详细的程序介绍可以私聊我本人获取ppt和实验报告，仅供学习和参考，转载需标明出处。

以下是部分效果图

 

 管理员密码默认为123456，后续可以在代码里更改管理员密码。

 

需要特别注意的是，目前程序仍存在一定的弊端，例如题目信息如果过长，就会影响到布局，建议不要录入题目信息或选项信息过长的题目，也可以根据具体需求，自行改到代码。

Part1：程序框架设计

 

程序框架设计上，我设计了三个类，其中两个类用来封装数据，一个类用来封装方法，如上所示图表，Problem类封装了试题的题号、题目、选项A、B、C、D、正确答案这些数据，Student类中我们有学生的用户名、账号、密码、成绩、答题时间这些成员，Manage类中封装了我们程序所需要的方法，程序整体结构分明，层次清晰，代码规范整齐。

其中，save_information方法和read_information方法之后我将着重讲解，log_in和student_login方法通过同样的底层逻辑实现，都是对循环遍历的运用来判断登录成功的条件是否满足，add_problem方法和del_problem、del_student方法是系统操作最常见的“增删查改”四大操作的“增和删”，通过input函数输入该输入的信息，将输入的信息整体打包成一个字典，字典特有的key值之后会帮助我们很好的提取所需要的数据，再将字典append到学生/试卷列表中，实现添加。而rank_student方法和analysis_student方法是对学生成绩的基本处理，其中涉及到利用sorted函数对列表实现快速排序，最后的test_begin先向函数传递学生姓名的参数，再循环遍历文件中的试题信息，来判断你的答案是否正确并计分，最后遍历文件中的学生信息来匹配函数接受到的学生姓名，将计分的成绩更新到学生的信息中，此外，还调用了time库来记录学生的答题时间信息。

   test_begin方法的实现

Part2:文件读取和写入

存储文件的时候，由于我们只能向文件写入str类型的数据，而在程序中，我们文件里的数据是放在了一个字典嵌套的列表中的，为了方便我们读取数据，我们在写入数据时，每两个数据中我们写入一个逗号作为整个字符串的分隔符。

读取数据的时候，我们读取的初始数据是一个字符串，用split函数初步处理后，就变成了一个列表，但此时还没有满足我们所需要的字典嵌套列表，所以我们进一步将整个列表按照字典的需求分成一个个的字典，在放到一个新的列表中，此时的新列表就能满足我们的使用需求。以下的图示以学生信息的读取和写入为例。

 

 

文件读取的实现

文件写入的实现

 

为了进一步理解文件读取这一部分的实现，我们设计了以下的流程图来帮助我们更生动形象的理解数据从文件到我们所需要的要求所经历过的步骤。如下图所示。

数据的处理过程

Part3:GUI设计

在GUI设计方面，我们通过tkinter库来实现，tkinter是python的内置库是一套完整的GUI开发模块的组合或套件，这些模块共同提供了强大的跨平台GUI编程的功能，所有的源码文件位于Python安装目录中lib\tkinter文件夹。

tkinter与turtle类似，无需额外安装，使用起来非常方便。tkinter提供了很多控件和消息事件，可以很快入手，非常适合开发具有界面的轻量级应用程序。

图形化界面

在布局方面，我采用了place的布局方式，同时，在答题功能的图形化过程中，还引入了frame框架来实现滑块和文本框的联动，初步掌握了GUI的布局设计，了解到事件的处理、控件之间的命令的运行逻辑。

 

以下是完整的程序代码

系统设计部分：

  1. import os
  2. import time
  3.  
  4.  
  5. class Problem:  # 定义试题信息的类
  6.     def __init__(self, num, question, choice_a, choice_b, choice_c, choice_d, answer):
  7.         self.num = num
  8.         self.question = question
  9.         self.choice_a = choice_a
  10.         self.choice_b = choice_b
  11.         self.choice_c = choice_c
  12.         self.choice_d = choice_d
  13.         self.answer = answer
  14.  
  15.  
  16. class Student:  # 定义学生信息的类
  17.     def __init__(self, name, user_name, user_password, grade, usetime):
  18.         self.name = name
  19.         self.user_name = user_name
  20.         self.user_password = user_password
  21.         self.grade = grade
  22.         self.usetime = usetime
  23.  
  24.  
  25. # 基本功能都由这个类的方法实现
  26. class Manage:
  27.     def __init__(self):
  28.         self.StudentInfo = []
  29.         self.ProblemInfo = []
  30.  
  31.     @staticmethod
  32.     def main_menu():
  33.         print("***************")
  34.         print("1.管理员端登录")
  35.         print("2.学生端登录")
  36.         print("3.注册学生端账户")
  37.         print("4.退出系统")
  38.         print("***************")
  39.  
  40.     @staticmethod
  41.     def administrator_menu():
  42.         print("***************")
  43.         print("1.录入试题信息")
  44.         print("2.查看学生信息")
  45.         print("3.排名学生成绩")
  46.         print("4.查看试题信息")
  47.         print("5.分析总体答题情况")
  48.         print("6.删除学生信息")
  49.         print("7.删除试题信息")
  50.         print("8.返回上级")
  51.         print("***************")
  52.  
  53.     @staticmethod
  54.     def student_menu():
  55.         print("***************")
  56.         print("1.开始答题")
  57.         print("2.返回上级")
  58.         print("***************")
  59.  
  60.     @staticmethod
  61.     def log_in():
  62.         psw = int(input("请输入管理员密码"))
  63.         if psw == 123456:
  64.             Manage.administrator_menu()
  65.             while 1:
  66.                 operate_administrator = int(input("请输入要选择的操作"))
  67.                 if operate_administrator == 1:
  68.                     Manage.add_problem(start)
  69.                     Manage.administrator_menu()
  70.                 if operate_administrator == 2:
  71.                     Manage.show_student(start)
  72.                 if operate_administrator == 3:
  73.                     Manage.rank_student(start)
  74.                 if operate_administrator == 4:
  75.                     Manage.show_problem(start)
  76.                 if operate_administrator == 5:
  77.                     Manage.analysis_student(start)
  78.                 if operate_administrator == 6:
  79.                     Manage.del_student(start)
  80.                 if operate_administrator == 7:
  81.                     Manage.del_problem(start)
  82.                 if operate_administrator == 8:
  83.                     Manage.main_menu()
  84.                     return
  85.         else:
  86.             print("账号或密码错误，已返回上级！")
  87.             Manage.main_menu()
  88.  
  89.     def register(self):
  90.         print("***************")
  91.         new_student = Student(name=input("输入你的用户名"),
  92.                               user_name=input("输入你的账号"),
  93.                               user_password=input("输入你的密码"),
  94.                               grade="暂无成绩",
  95.                               usetime="暂无信息")
  96.         temp = {"用户名": new_student.name, "账号": new_student.user_name, "密码": new_student.user_password,
  97.                 "成绩": new_student.grade, "答题时间": new_student.usetime}
  98.         # 这里的new_student不能直接传入列表，要放在一个字典里把数据”打包“过去
  99.         self.StudentInfo.append(temp)
  100.         print("注册成功！")
  101.         self.save_information()
  102.         self.main_menu()
  103.  
  104.     def student_login(self):
  105.         print("***************")
  106.         temp1 = input("请输入你的账号")
  107.         temp2 = input("请输入你的密码")
  108.         if len(self.StudentInfo) == 0:
  109.             # 如果学生信息为空，说明还没有账号注册，当作账号或密码错误处理
  110.             print("账号或密码错误！已返回上级")
  111.             self.main_menu()
  112.             return
  113.         for stu in self.StudentInfo:  # 循环遍历列表判断账号和密码是否正确
  114.             if stu["账号"] == temp1 and stu["密码"] == temp2:
  115.                 print("登录成功！欢迎你%s同学" % (stu["用户名"]))
  116.                 self.student_menu()
  117.                 while 1:
  118.                     operate_student = int(input("请输入要选择的操作"))
  119.                     if operate_student == 1:
  120.                         self.test_begin(stu["用户名"])
  121.                         self.main_menu()
  122.                         return
  123.                     if operate_student == 2:
  124.                         self.main_menu()
  125.                         return
  126.         else:
  127.             print("账号或密码错误！已返回上级")
  128.             self.main_menu()
  129.  
  130.     def add_problem(self):
  131.         new_problem = Problem(num=input("输入题号"),
  132.                               question=input("输入题目"),
  133.                               choice_a=input("输入选项A"),
  134.                               choice_b=input("输入选项B"),
  135.                               choice_c=input("输入选项C"),
  136.                               choice_d=input("输入选项D"),
  137.                               answer=input("输入正确答案"))
  138.         temp = {"题号": new_problem.num, "题目": new_problem.question, "选项A": new_problem.choice_a,
  139.                 "选项B": new_problem.choice_b, "选项C": new_problem.choice_c, "选项D": new_problem.choice_d,
  140.                 "正确答案": new_problem.answer}
  141.         self.ProblemInfo.append(temp)
  142.         # 和学生信息一样，试题信息也要打包在一个字典里面后添加到列表
  143.         print("录入成功！")
  144.         self.save_information()
  145.  
  146.     def del_student(self):
  147.         user_name = input("输入要删除的学生账号")
  148.         index = 0
  149.         for stu in self.StudentInfo:
  150.             if stu["账号"] == user_name:
  151.                 del self.StudentInfo[index]
  152.                 self.save_information()
  153.                 print("删除成功")
  154.                 self.administrator_menu()
  155.                 return
  156.             index += 1
  157.         print("未查询到学生信息!")
  158.         self.administrator_menu()
  159.         return
  160.  
  161.     def del_problem(self):
  162.         num = input("输入要删除的题目题号")
  163.         index = 0
  164.         for pro in self.ProblemInfo:
  165.             if pro["题号"] == num:
  166.                 del self.ProblemInfo[index]
  167.                 self.save_information()
  168.                 print("删除成功")
  169.                 self.administrator_menu()
  170.                 return
  171.             index += 1
  172.         print("未查询到试题信息!")
  173.         self.administrator_menu()
  174.         return
  175.  
  176.     def show_student(self):
  177.         if len(self.StudentInfo) == 0:
  178.             print("暂无学生信息")
  179.             self.administrator_menu()
  180.             return
  181.         for stu in self.StudentInfo:
  182.             print(stu)
  183.         input("按任意键继续")
  184.         self.administrator_menu()
  185.         return
  186.  
  187.     def show_problem(self):
  188.         if len(self.ProblemInfo) == 0:
  189.             print("暂无试题信息")
  190.         for pro in self.ProblemInfo:
  191.             print("%s:%s\n"
  192.                   "A.%s\n"
  193.                   "B.%s\n"
  194.                   "C.%s\n"
  195.                   "D.%s\n"
  196.                   "正确答案：%s"
  197.                   % (pro["题号"], pro["题目"], pro["选项A"], pro["选项B"], pro["选项C"], pro["选项D"],
  198.                      pro["正确答案"]))
  199.         input("按任意键继续")
  200.         self.administrator_menu()
  201.         return
  202.  
  203.     def test_begin(self, name):
  204.         # 答题功能的主要功能由循坏遍历列表和time模板实现
  205.         if len(self.ProblemInfo) == 0:
  206.             print("暂无试题信息")
  207.             self.student_menu()
  208.             return
  209.         grade = 0
  210.         print("Test Begin!")
  211.         start_time = time.time()
  212.         for pro in self.ProblemInfo:
  213.             print("%s:%s\n"
  214.                   "A.%s\n"
  215.                   "B.%s\n"
  216.                   "C.%s\n"
  217.                   "D.%s\n"
  218.                   % (pro["题号"], pro["题目"], pro["选项A"], pro["选项B"], pro["选项C"], pro["选项D"]))
  219.             answer = input("输入你的答案")
  220.             if answer == pro["正确答案"]:
  221.                 grade += 5
  222.         end_time = time.time()
  223.         for stu in self.StudentInfo:
  224.             if stu["用户名"] == name:
  225.                 stu["成绩"] = str(grade)
  226.                 stu["答题时间"] = str(int((end_time - start_time)))
  227.                 break
  228.         print("Test Over!\n你的成绩是%d分,用时%d秒" % (grade, end_time - start_time))
  229.         self.save_information()
  230.         return
  231.  
  232.     def rank_student(self):
  233.         if len(start.StudentInfo) == 0:
  234.             print("暂无学生信息")
  235.             return
  236.         tool = self.StudentInfo
  237.         for del_zero in tool:
  238.             if del_zero["成绩"] == "暂无成绩":
  239.                 del_zero["成绩"] = -1
  240.         temp = sorted(tool, key=lambda x: int(x["成绩"]), reverse=True)
  241.         rank = 1
  242.         for stu in temp:
  243.             if stu["成绩"] == -1:
  244.                 stu["成绩"] = "暂无成绩"
  245.             print("第%d名：%s %s分 用时%s秒" % (rank, stu["用户名"], stu["成绩"], stu["答题时间"]))
  246.             rank += 1
  247.         input("按任意键继续")
  248.         self.administrator_menu()
  249.         return
  250.  
  251.     def analysis_student(self):
  252.         # 分析参加考试的人数，平均分
  253.         if len(self.StudentInfo) == 0:
  254.             print("暂无答题信息")
  255.             self.administrator_menu()
  256.             return
  257.         print("本次测试有%d道题目" % (len(self.ProblemInfo)))
  258.         print("满分%d分" % (len(self.ProblemInfo) * 5))
  259.         student_num = 0
  260.         total = 0
  261.         for stu in self.StudentInfo:
  262.             if stu["成绩"] == "暂无成绩":
  263.                 continue
  264.             total += int(stu["成绩"])
  265.             student_num += 1
  266.         if student_num == 0:
  267.             print("暂无答题信息")
  268.             self.administrator_menu()
  269.             return
  270.         print("参与测试%d人" % student_num)
  271.         print("平均分：%0.2f" % (total / student_num))
  272.         input("按任意键继续")
  273.         self.administrator_menu()
  274.         return
  275.  
  276.     def save_information(self):  # 以字符串的数据类型向文件中写入
  277.         with open("StudentInfo.txt", "w", encoding="utf_8") as fp:
  278.             for stu in self.StudentInfo:
  279.                 fp.write(stu["用户名"])
  280.                 fp.write(",")
  281.                 fp.write(stu["账号"])
  282.                 fp.write(",")
  283.                 fp.write(stu["密码"])
  284.                 fp.write(",")
  285.                 fp.write(stu["成绩"])
  286.                 fp.write(",")
  287.                 fp.write(stu["答题时间"])
  288.                 fp.write(",")
  289.             fp.close()  # 写入的时候数据之间用”,“分割开,读取的时候再用split函数分割分别读取
  290.         with open("ProblemInfo.txt", "w", encoding="utf_8") as fp1:
  291.             for pro in self.ProblemInfo:
  292.                 fp1.write(pro["题号"])
  293.                 fp1.write(",")
  294.                 fp1.write(pro["题目"])
  295.                 fp1.write(",")
  296.                 fp1.write(pro["选项A"])
  297.                 fp1.write(",")
  298.                 fp1.write(pro["选项B"])
  299.                 fp1.write(",")
  300.                 fp1.write(pro["选项C"])
  301.                 fp1.write(",")
  302.                 fp1.write(pro["选项D"])
  303.                 fp1.write(",")
  304.                 fp1.write(pro["正确答案"])
  305.                 fp1.write(",")
  306.             fp1.close()
  307.         return
  308.  
  309.     def read_information(self):
  310.         if not os.path.exists("StudentInfo.txt"):
  311.             print("暂无学生信息，跳过读取！")
  312.         else:
  313.             with open("StudentInfo.txt", "r", encoding="utf_8") as fp:
  314.                 stu = fp.read()
  315.                 stu = stu.split(",")  # 文件的字符串split后变成列表类型，再通过列表循环读取，每次读取一批数据打包成一个字典，再append到程序当前存储信息的列表中
  316.                 stu.pop()
  317.                 for i in range(len(stu) // 5):
  318.                     stu_pass = {"用户名": stu[5 * i + 0],
  319.                                 "账号": stu[5 * i + 1],
  320.                                 "密码": stu[5 * i + 2],
  321.                                 "成绩": stu[5 * i + 3],
  322.                                 "答题时间": stu[5 * i + 4]}
  323.                     self.StudentInfo.append(stu_pass)
  324.                 fp.close()
  325.             print("学生信息读取成功！")
  326.  
  327.         if not os.path.exists("ProblemInfo.txt"):
  328.             print("暂无试卷信息，跳过读取！")
  329.         else:
  330.             with open("ProblemInfo.txt", "r", encoding="utf_8") as fp1:
  331.                 pro = fp1.read()
  332.                 pro = pro.split(",")
  333.                 pro.pop()
  334.                 for j in range(len(pro) // 7):
  335.                     pro_pass = {"题号": pro[7 * j + 0],
  336.                                 "题目": pro[7 * j + 1],
  337.                                 "选项A": pro[7 * j + 2],
  338.                                 "选项B": pro[7 * j + 3],
  339.                                 "选项C": pro[7 * j + 4],
  340.                                 "选项D": pro[7 * j + 5],
  341.                                 "正确答案": pro[7 * j + 6]}
  342.                     self.ProblemInfo.append(pro_pass)
  343.                 fp1.close()
  344.             print("试卷信息读取成功！")
  345.  
  346.  
  347. start = Manage()

 GUI设计部分：

  1. import time
  2. import tkinter as tk
  3. import SystemDesign
  4.  
  5. start = SystemDesign.Manage()
  6. start.read_information()
  7.  
  8.  
  9. # root:主菜单   root2:管理员菜单    root3:管理员登录界面   root4:学生登陆界面
  10. def administrator_menu():
  11.     root.withdraw()
  12.     root2 = tk.Tk()
  13.     root2.title("单项选择题答题与管理系统")
  14.     root2.geometry("900x700")
  15.     root2.config(background='pink')
  16.     bt1 = tk.Button(root2, text='1.录入试题信息', font=("Helvetica", 30), background='pink',
  17.                     command=lambda: func_ad_1(root2))
  18.     bt1.place(x=300, y=20)
  19.     bt2 = tk.Button(root2, text='2.查看学生信息', font=("Helvetica", 30), background='pink',
  20.                     command=lambda: func_ad_2(root2))
  21.     bt2.place(x=300, y=100)
  22.     bt3 = tk.Button(root2, text='3. 排名学生成绩', font=("Helvetica", 30), background='pink',
  23.                     command=lambda: func_ad_3(root2))
  24.     bt3.place(x=300, y=180)
  25.     bt4 = tk.Button(root2, text='4.查看试题信息', font=("Helvetica", 30), background='pink',
  26.                     command=lambda: func_ad_4(root2))
  27.     bt4.place(x=300, y=260)
  28.     bt5 = tk.Button(root2, text='5.分析总体答题情况', font=("Helvetica", 30), background='pink',
  29.                     command=lambda: func_ad_5(root2))
  30.     bt5.place(x=300, y=340)
  31.     bt6 = tk.Button(root2, text='6.删除试题信息', font=("Helvetica", 30), background='pink',
  32.                     command=lambda: func_ad_6(root2))
  33.     bt6.place(x=300, y=420)
  34.     bt7 = tk.Button(root2, text='7.删除学生信息', font=("Helvetica", 30), background='pink',
  35.                     command=lambda: func_ad_7(root2))
  36.     bt7.place(x=300, y=500)
  37.     bt8 = tk.Button(root2, text='8.返回上级', font=("Helvetica", 30), background='pink',
  38.                     command=lambda: func_ad_8(root2))
  39.     bt8.place(x=300, y=580)
  40.  
  41.  
  42. def func_ad_1(x):  # 管理员功能一
  43.     x.destroy()
  44.     root_func1 = tk.Tk()
  45.     root_func1.title("单项选择题答题与管理系统")
  46.     root_func1.geometry("900x700")
  47.     root_func1.config(background='pink')
  48.     func1title = tk.Label(root_func1, text="输入你的试题信息", font=("Helvetica", 40), background="pink")
  49.     func1title.pack()
  50.  
  51.     func1_lb1 = tk.Label(root_func1, text="题号", font=("Helvetica", 20), background="pink")
  52.     func1_lb1.place(x=220, y=80)
  53.     func1_entry1 = tk.Entry(root_func1, width=45)
  54.     func1_entry1.place(x=320, y=90)
  55.  
  56.     func1_lb2 = tk.Label(root_func1, text="题目", font=("Helvetica", 20), background="pink")
  57.     func1_lb2.place(x=220, y=120)
  58.     func1_entry2 = tk.Entry(root_func1, width=45)
  59.     func1_entry2.place(x=320, y=130)
  60.  
  61.     func1_lb3 = tk.Label(root_func1, text="选项A", font=("Helvetica", 20), background="pink")
  62.     func1_lb3.place(x=220, y=160)
  63.     func1_entry3 = tk.Entry(root_func1, width=45)
  64.     func1_entry3.place(x=320, y=170)
  65.  
  66.     func1_lb4 = tk.Label(root_func1, text="选项B", font=("Helvetica", 20), background="pink")
  67.     func1_lb4.place(x=220, y=200)
  68.     func1_entry4 = tk.Entry(root_func1, width=45)
  69.     func1_entry4.place(x=320, y=210)
  70.  
  71.     func1_lb5 = tk.Label(root_func1, text="选项C", font=("Helvetica", 20), background="pink")
  72.     func1_lb5.place(x=220, y=240)
  73.     func1_entry5 = tk.Entry(root_func1, width=45)
  74.     func1_entry5.place(x=320, y=250)
  75.  
  76.     func1_lb6 = tk.Label(root_func1, text="选项D", font=("Helvetica", 20), background="pink")
  77.     func1_lb6.place(x=220, y=280)
  78.     func1_entry6 = tk.Entry(root_func1, width=45)
  79.     func1_entry6.place(x=320, y=290)
  80.  
  81.     func1_lb7 = tk.Label(root_func1, text="正确答案", font=("Helvetica", 20), background="pink")
  82.     func1_lb7.place(x=200, y=320)
  83.     func1_entry7 = tk.Entry(root_func1, width=45)
  84.     func1_entry7.place(x=320, y=330)
  85.  
  86.     func1_bt1 = tk.Button(root_func1, text="确定", font=("Helvetica", 20), background="pink",
  87.                           command=lambda: func_ad_1_1(func1_entry1.get(), func1_entry2.get(), func1_entry3.get(),
  88.                                                       func1_entry4.get(), func1_entry5.get(), func1_entry6.get(),
  89.                                                       func1_entry7.get(), root_func1))
  90.     func1_bt1.place(x=460, y=380)
  91.  
  92.     func1_bt2 = tk.Button(root_func1, text="取消", font=("Helvetica", 20), background="pink",
  93.                           command=lambda: func_back(root_func1))
  94.     func1_bt2.place(x=560, y=380)
  95.  
  96.  
  97. def func_ad_1_1(x1, x2, x3, x4, x5, x6, x7, root_func1):  # 功能一的衍生函数
  98.     root_func1.destroy()
  99.     new_problem = SystemDesign.Problem(num=x1,
  100.                                        question=x2,
  101.                                        choice_a=x3,
  102.                                        choice_b=x4,
  103.                                        choice_c=x5,
  104.  
  105.                                        choice_d=x6,
  106.                                        answer=x7)
  107.     temp = {"题号": new_problem.num, "题目": new_problem.question, "选项A": new_problem.choice_a,
  108.             "选项B": new_problem.choice_b, "选项C": new_problem.choice_c, "选项D": new_problem.choice_d,
  109.             "正确答案": new_problem.answer}
  110.     start.ProblemInfo.append(temp)
  111.     start.save_information()
  112.     message = tk.Tk()
  113.     message.geometry("400x150")
  114.     message.title("单项选择题答题与管理系统")
  115.     message_lb = tk.Label(message, text="添加成功！", font=("等线", 30))
  116.     message_lb.config(fg="red")
  117.     message_lb.pack()
  118.     message_bt = tk.Button(message, text="返回", height=1, width=8, command=lambda: func_back(message))
  119.     message_bt.place(x=150, y=75)
  120.  
  121.  
  122. def func_back(x):
  123.     x.destroy()
  124.     administrator_menu()
  125.  
  126.  
  127. def func_ad_2(x):
  128.     x.destroy()
  129.     root_func2 = tk.Tk()
  130.     root_func2.title("单项选择题答题与管理系统")
  131.     root_func2.geometry("800x600")
  132.     bt1 = tk.Button(root_func2, text="返回", width=600, font=("Helvetica", 20), command=lambda: func_back(root_func2))
  133.     bt1.pack()
  134.     frame_func2 = tk.Frame(root_func2)
  135.     frame_func2.pack()
  136.     scrollbar1 = tk.Scrollbar(frame_func2)
  137.     scrollbar1.pack(side="right", fill="y")
  138.     scrollbar2 = tk.Scrollbar(frame_func2, orient="horizontal")
  139.     scrollbar2.pack(side="bottom", fill="x")
  140.     list_func2 = tk.Listbox(frame_func2, selectmode='browse', width=500, height=20, font=("等线", 30),
  141.                             xscrollcommand=scrollbar2.set, yscrollcommand=scrollbar1.set)
  142.     for stu in start.StudentInfo:
  143.         list_func2.insert("end", stu)
  144.     list_func2.pack()
  145.     scrollbar1.config(command=list_func2.yview)
  146.     scrollbar2.config(command=list_func2.xview)
  147.  
  148.  
  149. def func_ad_3(r):
  150.     r.destroy()
  151.     root_func3 = tk.Tk()
  152.     root_func3.title("单项选择题答题与管理系统")
  153.     root_func3.geometry("800x600")
  154.     bt1 = tk.Button(root_func3, text="返回", width=600, font=("Helvetica", 20), command=lambda: func_back(root_func3))
  155.     bt1.pack()
  156.     frame_func3 = tk.Frame(root_func3)
  157.     frame_func3.pack()
  158.     scrollbar1 = tk.Scrollbar(frame_func3)
  159.     scrollbar1.pack(side="right", fill="y")
  160.     scrollbar2 = tk.Scrollbar(frame_func3, orient="horizontal")
  161.     scrollbar2.pack(side="bottom", fill="x")
  162.     list_func3 = tk.Listbox(frame_func3, selectmode='browse', width=500, height=20, font=("等线", 30),
  163.                             xscrollcommand=scrollbar2.set, yscrollcommand=scrollbar1.set)
  164.     tool = start.StudentInfo
  165.     for del_zero in tool:
  166.         if del_zero["成绩"] == "暂无成绩":
  167.             del_zero["成绩"] = -1
  168.     temp = sorted(tool, key=lambda x: int(x["成绩"]), reverse=True)
  169.     list_stu = []
  170.     for stu in temp:
  171.         if stu["成绩"] == -1:
  172.             stu["成绩"] = "暂无成绩"
  173.         stu_pass = {"用户名": stu["用户名"],
  174.                     "成绩": stu["成绩"],
  175.                     "答题用时": stu["答题时间"]}
  176.         list_stu.append(stu_pass)
  177.     for stu in list_stu:
  178.         list_func3.insert("end", stu)
  179.  
  180.     list_func3.pack()
  181.     scrollbar1.config(command=list_func3.yview)
  182.     scrollbar2.config(command=list_func3.xview)
  183.  
  184.  
  185. def func_ad_4(x):
  186.     x.destroy()
  187.     root_func4 = tk.Tk()
  188.     root_func4.title("单项选择题答题与管理系统")
  189.     root_func4.geometry("800x600")
  190.     bt1 = tk.Button(root_func4, text="返回", width=600, font=("Helvetica", 20), command=lambda: func_back(root_func4))
  191.     bt1.pack()
  192.     frame_func4 = tk.Frame(root_func4)
  193.     frame_func4.pack()
  194.     scrollbar1 = tk.Scrollbar(frame_func4)
  195.     scrollbar1.pack(side="right", fill="y")
  196.     scrollbar2 = tk.Scrollbar(frame_func4, orient="horizontal")
  197.     scrollbar2.pack(side="bottom", fill="x")
  198.     list_func2 = tk.Listbox(frame_func4, selectmode='browse', width=500, height=20, font=("等线", 30),
  199.                             xscrollcommand=scrollbar2.set, yscrollcommand=scrollbar1.set)
  200.     for stu in start.ProblemInfo:
  201.         list_func2.insert("end", stu)
  202.     list_func2.pack()
  203.     scrollbar1.config(command=list_func2.yview)
  204.     scrollbar2.config(command=list_func2.xview)
  205.  
  206.  
  207. def func_ad_5(x):
  208.     x.destroy()
  209.     root_func5 = tk.Tk()
  210.     root_func5.title("单项选择题答题与管理系统")
  211.     root_func5.geometry("800x600")
  212.     root_func5.config(background="pink")
  213.     bt1 = tk.Button(root_func5, text="返回", width=600, font=("Helvetica", 20), command=lambda: func_back(root_func5))
  214.     bt1.pack()
  215.     lb1 = tk.Label(root_func5, background="pink", text="本次测试有%d道题目" % len(start.ProblemInfo),
  216.                    font=("Helvetica", 40))
  217.     lb1.pack()
  218.     lb2 = tk.Label(root_func5, background="pink", text="满分%d分" % (len(start.ProblemInfo) * 5),
  219.                    font=("Helvetica", 40))
  220.     lb2.pack()
  221.     student_num = 0
  222.     total = 0
  223.     for stu in start.StudentInfo:
  224.         if stu["成绩"] == "暂无成绩":
  225.             continue
  226.         total += int(stu["成绩"])
  227.         student_num += 1
  228.     lb3 = tk.Label(root_func5, background="pink", text="参与测试%d人" % student_num, font=("Helvetica", 40))
  229.     lb3.pack()
  230.     lb3 = tk.Label(root_func5, background="pink", text="平均分：%0.2f" % (total / student_num), font=("Helvetica", 40))
  231.     lb3.pack()
  232.  
  233.  
  234. def func_ad_6(x):
  235.     x.destroy()
  236.     root_func6 = tk.Tk()
  237.     root_func6.geometry("600x300")
  238.     root_func6.title("单项选择题答题与管理系统")
  239.     lb_func6 = tk.Label(root_func6, text="请输入要删除的试题题号!", font=("Helvetica", 20))
  240.     lb_func6.pack()
  241.     entry_func6 = tk.Entry(root_func6)
  242.     entry_func6.place(x=220, y=60)
  243.     bt1 = tk.Button(root_func6, height=1, width=8, text="确认",
  244.                     command=lambda: func_ad_6_1(entry_func6.get()))
  245.     bt1.place(x=220, y=100)
  246.     bt2 = tk.Button(root_func6, height=1, width=8, text="取消", command=lambda: func_back(root_func6))
  247.     bt2.place(x=300, y=100)
  248.  
  249.  
  250. def func_ad_6_1(x):
  251.     index = 0
  252.     for pro in start.ProblemInfo:
  253.         if pro["题号"] == x:
  254.             del start.ProblemInfo[index]
  255.             start.save_information()
  256.             message = tk.Tk()
  257.             message.geometry("400x150")
  258.             message.title("单项选择题答题与管理系统")
  259.             message_lb = tk.Label(message, text="删除成功！", font=("等线", 30))
  260.             message_lb.config(fg="red")
  261.             message_lb.pack()
  262.             message_bt = tk.Button(message, text="返回", height=1, width=8, command=message.destroy)
  263.             message_bt.place(x=150, y=75)
  264.             return
  265.         index += 1
  266.     message = tk.Tk()
  267.     message.geometry("400x150")
  268.     message.title("单项选择题答题与管理系统")
  269.     message_lb = tk.Label(message, text="未找到试题信息", font=("等线", 30))
  270.     message_lb.config(fg="red")
  271.     message_lb.pack()
  272.     message_bt = tk.Button(message, text="返回", height=1, width=8, command=message.destroy)
  273.     message_bt.place(x=150, y=75)
  274.  
  275.  
  276. def func_ad_7(x):
  277.     x.destroy()
  278.     root_func7 = tk.Tk()
  279.     root_func7.geometry("600x300")
  280.     root_func7.title("单项选择题答题与管理系统")
  281.     lb_func7 = tk.Label(root_func7, text="请输入要删除的学生账号!", font=("Helvetica", 20))
  282.     lb_func7.pack()
  283.     entry_func7 = tk.Entry(root_func7)
  284.     entry_func7.place(x=220, y=60)
  285.     bt1 = tk.Button(root_func7, height=1, width=8, text="确认",
  286.                     command=lambda: func_ad_7_1(entry_func7.get()))
  287.     bt1.place(x=220, y=100)
  288.     bt2 = tk.Button(root_func7, height=1, width=8, text="取消", command=lambda: func_back(root_func7))
  289.     bt2.place(x=300, y=100)
  290.  
  291.  
  292. def func_ad_7_1(x):
  293.     index = 0
  294.     for pro in start.StudentInfo:
  295.         if pro["账号"] == x:
  296.             del start.StudentInfo[index]
  297.             start.save_information()
  298.             message = tk.Tk()
  299.             message.geometry("400x150")
  300.             message.title("单项选择题答题与管理系统")
  301.             message_lb = tk.Label(message, text="删除成功！", font=("等线", 30))
  302.             message_lb.config(fg="red")
  303.             message_lb.pack()
  304.             message_bt = tk.Button(message, text="返回", height=1, width=8, command=message.destroy)
  305.             message_bt.place(x=150, y=75)
  306.             return
  307.         index += 1
  308.     message = tk.Tk()
  309.     message.geometry("400x150")
  310.     message.title("单项选择题答题与管理系统")
  311.     message_lb = tk.Label(message, text="未找到学生信息", font=("等线", 30))
  312.     message_lb.config(fg="red")
  313.     message_lb.pack()
  314.     message_bt = tk.Button(message, text="返回", height=1, width=8, command=message.destroy)
  315.     message_bt.place(x=150, y=75)
  316.  
  317.  
  318. def func_ad_8(x):
  319.     x.destroy()
  320.     root.deiconify()
  321.  
  322.  
  323. def student_menu(x):
  324.     index = 0
  325.     global grade
  326.     grade = 0
  327.     start_time = time.time()
  328.     root.withdraw()
  329.     root_stu = tk.Tk()
  330.     root_stu.title("单项选择题答题与管理系统")
  331.     root_stu.geometry("900x700")
  332.     root_stu.config(background='pink')
  333.     lb1 = tk.Label(root_stu, text="欢迎你%s同学" % x, font=("Helvetica", 40), background='pink')
  334.     lb1.pack()
  335.     bt1 = tk.Button(root_stu, text='1.开始答题', font=("Helvetica", 30), background='pink',
  336.                     command=lambda: func_stu_1(root_stu, x, index, start_time))
  337.     bt1.place(x=320, y=240)
  338.     bt2 = tk.Button(root_stu, text='2.返回上级', font=("Helvetica", 30), background='pink',
  339.                     command=lambda: func_stu_2(root_stu))
  340.     bt2.place(x=320, y=360)
  341.  
  342.  
  343. def func_stu_1(win, name, index_pro, start_time):
  344.     win.destroy()
  345.     root_func1 = tk.Tk()
  346.     root_func1.title("单项选择题答题与管理系统")
  347.     root_func1.geometry("900x700")
  348.     root_func1.config(background='pink')
  349.     func1title = tk.Label(root_func1, text="做下一题前请先提交当前题目！", font=("Helvetica", 40), background="pink")
  350.     func1title.pack()
  351.  
  352.     temp = start.ProblemInfo[index_pro]
  353.  
  354.     pro_num = tk.Label(root_func1, text="%s." % temp["题号"], font=("Helvetica", 30), background="pink", )
  355.     pro_num.place(x=200, y=80)
  356.  
  357.     pro_question = tk.Label(root_func1, text="%s" % temp["题目"], font=("Helvetica", 30), background="pink")
  358.     pro_question.place(x=260, y=80)
  359.  
  360.     pro_a = tk.Label(root_func1, text="A.%s" % temp["选项A"], font=("Helvetica", 30), background="pink")
  361.     pro_a.place(x=220, y=160)
  362.  
  363.     pro_b = tk.Label(root_func1, text="B.%s" % temp["选项B"], font=("Helvetica", 30), background="pink")
  364.     pro_b.place(x=220, y=240)
  365.  
  366.     pro_c = tk.Label(root_func1, text="C.%s" % temp["选项C"], font=("Helvetica", 30), background="pink")
  367.     pro_c.place(x=220, y=320)
  368.  
  369.     pro_d = tk.Label(root_func1, text="D.%s" % temp["选项D"], font=("Helvetica", 30), background="pink")
  370.     pro_d.place(x=220, y=400)
  371.  
  372.     pro_answer = tk.Label(root_func1, text="你的选项为", font=("Helvetica", 30), background="pink")
  373.     pro_answer.place(x=220, y=480)
  374.     answer_get = tk.Entry(root_func1, font=("Helvetica", 30), width=2)
  375.     answer_get.place(x=450, y=480)
  376.  
  377.     bt_ensure = tk.Button(root_func1, text="提 交", command=lambda: check_answer(answer_get.get(), temp["正确答案"]),
  378.                           font=("Helvetica", 30), background="pink")
  379.     bt_ensure.place(x=220, y=560)
  380.  
  381.     if index_pro == len(start.ProblemInfo) - 1:  # 目前只能下一题，且无法返回更改
  382.         for stu in start.StudentInfo:
  383.             if stu["用户名"] == name:
  384.                 stu["成绩"] = str(grade)
  385.                 stu["答题时间"] = str(int(time.time() - start_time))
  386.                 start.save_information()
  387.         bt_end = tk.Button(root_func1, text="结束考试", command=lambda: func_stu_1_1(root_func1),
  388.                            font=("Helvetica", 30), background="pink")
  389.         bt_end.place(x=480, y=560)
  390.  
  391.     else:
  392.         bt_down = tk.Button(root_func1, text="下一题",
  393.                             command=lambda: func_stu_1(root_func1, name, index_pro + 1, start_time),
  394.                             font=("Helvetica", 30),
  395.                             background="pink")
  396.         bt_down.place(x=480, y=560)
  397.  
  398.  
  399. def check_answer(x, y):
  400.     global grade
  401.     if x == y:
  402.         grade += 5
  403.  
  404.  
  405. def func_stu_1_1(x):
  406.     x.destroy()
  407.     message = tk.Tk()
  408.     message.geometry("400x150")
  409.     message.title("单项选择题答题与管理系统")
  410.     message_lb = tk.Label(message, text="答题结束！", font=("等线", 30))
  411.     message_lb.config(fg="red")
  412.     message_lb.pack()
  413.     message_bt = tk.Button(message, text="返回", height=1, width=8, command=lambda: func_stu_2(message))
  414.     message_bt.place(x=150, y=75)
  415.  
  416.  
  417. def func_stu_1_2(x):
  418.     x.destroy()
  419.     root.deiconify()
  420.  
  421.  
  422. def func_stu_2(x):
  423.     x.destroy()
  424.     root.deiconify()
  425.  
  426.  
  427. def check_psw(x, y):
  428.     if x == "123456":
  429.         y.destroy()
  430.         administrator_menu()
  431.     else:
  432.         message = tk.Tk()
  433.         message.geometry("300x150")
  434.         message.title("单项选择题答题与管理系统")
  435.         message_lb = tk.Label(message, text="密码错误！", font=("等线", 30))
  436.         message_lb.config(fg="red")
  437.         message_lb.pack()
  438.         message_bt = tk.Button(message, text="返回", height=1, width=8, command=message.destroy)
  439.         message_bt.place(x=120, y=75)
  440.  
  441.  
  442. def administrator_login():
  443.     root3 = tk.Tk()
  444.     root3.geometry("600x300")
  445.     root3.title("单项选择题答题与管理系统")
  446.     ad_login = tk.Label(root3, text="请输入管理员密码!", font=("Helvetica", 20))
  447.     ad_login.pack()
  448.     ad_login_entry = tk.Entry(root3, show="*")
  449.     ad_login_entry.place(x=220, y=60)
  450.     ad_login_bt1 = tk.Button(root3, height=1, width=8, text="确认",
  451.                              command=lambda: check_psw(ad_login_entry.get(), root3))
  452.     ad_login_bt1.place(x=220, y=100)
  453.     ad_login_bt2 = tk.Button(root3, height=1, width=8, text="取消", command=root3.destroy)
  454.     ad_login_bt2.place(x=300, y=100)
  455.  
  456.  
  457. def student_login():
  458.     root4 = tk.Tk()
  459.     root4.geometry("600x300")
  460.     root4.title("单项选择题答题与管理系统")
  461.     st_login = tk.Label(root4, text="请输入账号和密码!", font=("Helvetica", 20))
  462.     st_login.pack()
  463.     st_lb1 = tk.Label(root4, text="账号", font=6)
  464.     st_lb1.place(x=200, y=60)
  465.     st_login_entry1 = tk.Entry(root4)
  466.     st_login_entry1.place(x=250, y=60)
  467.     st_lb2 = tk.Label(root4, text="密码", font=6)
  468.     st_lb2.place(x=200, y=100)
  469.     st_login_entry2 = tk.Entry(root4)
  470.     st_login_entry2.place(x=250, y=100)
  471.     st_login_bt1 = tk.Button(root4, height=1, width=8, text="确认",
  472.                              command=lambda: student_check(st_login_entry1.get(), st_login_entry2.get(), root4))
  473.     st_login_bt1.place(x=240, y=130)
  474.     st_login_bt2 = tk.Button(root4, height=1, width=8, text="取消", command=root4.destroy)
  475.     st_login_bt2.place(x=320, y=130)
  476.     '''
  477.     bt2 = tk.Button(root, text='1.开始答题', font=("Helvetica", 30), background='pink')
  478.     bt2.place(x=300, y=180)
  479.     bt3 = tk.Button(root, text='2.返回上级', font=("Helvetica", 30), background='pink')
  480.     bt3.place(x=300, y=260)
  481.     '''
  482.  
  483.  
  484. def student_check(x, y, z):  # 检查学生的登录信息
  485.     for stu in start.StudentInfo:
  486.         if x == stu["账号"] and y == stu["密码"]:
  487.             z.destroy()
  488.             student_menu(stu["用户名"])
  489.             break
  490.     else:
  491.         message = tk.Tk()
  492.         message.geometry("400x150")
  493.         message.title("单项选择题答题与管理系统")
  494.         message_lb = tk.Label(message, text="账号或密码错误！", font=("等线", 30))
  495.         message_lb.config(fg="red")
  496.         message_lb.pack()
  497.         message_bt = tk.Button(message, text="返回", height=1, width=8, command=message.destroy)
  498.         message_bt.place(x=150, y=75)
  499.  
  500.  
  501. def student_register():  # 注册学生信息页面
  502.     root5 = tk.Tk()
  503.     root5.geometry("600x300")
  504.     root5.title("单项选择题答题与管理系统")
  505.     st_login = tk.Label(root5, text="填写你的注册信息", font=("Helvetica", 20))
  506.     st_login.pack()
  507.  
  508.     st_lb1 = tk.Label(root5, text="用户名", font=6)
  509.     st_lb1.place(x=185, y=60)
  510.     st_login_entry1 = tk.Entry(root5)
  511.     st_login_entry1.place(x=250, y=60)
  512.  
  513.     st_lb2 = tk.Label(root5, text="账号", font=6)
  514.     st_lb2.place(x=200, y=100)
  515.     st_login_entry2 = tk.Entry(root5)
  516.     st_login_entry2.place(x=250, y=100)
  517.  
  518.     st_lb2 = tk.Label(root5, text="密码", font=6)
  519.     st_lb2.place(x=200, y=140)
  520.     st_login_entry3 = tk.Entry(root5)
  521.     st_login_entry3.place(x=250, y=140)
  522.  
  523.     st_login_bt1 = tk.Button(root5, height=1, width=8, text="确认",
  524.                              command=lambda: add_student(st_login_entry1.get(), st_login_entry2.get(),
  525.                                                          st_login_entry3.get(), root5))
  526.     st_login_bt1.place(x=240, y=180)
  527.     st_login_bt2 = tk.Button(root5, height=1, width=8, text="取消", command=root5.destroy)
  528.     st_login_bt2.place(x=320, y=180)
  529.  
  530.  
  531. def add_student(x, y, z, root5):  # 注册成功后的消息弹窗页面
  532.     root5.destroy()
  533.     new_student = SystemDesign.Student(name=x,
  534.                                        user_name=y,
  535.                                        user_password=z,
  536.                                        grade="暂无成绩",
  537.                                        usetime="暂无信息")
  538.     temp = {"用户名": new_student.name, "账号": new_student.user_name, "密码": new_student.user_password,
  539.             "成绩": new_student.grade, "答题时间": new_student.usetime}
  540.     # 这里的new_student不能直接传入列表，要放在一个字典里把数据”打包“过去
  541.     start.StudentInfo.append(temp)
  542.     start.save_information()
  543.     message = tk.Tk()
  544.     message.geometry("400x150")
  545.     message.title("单项选择题答题与管理系统")
  546.     message_lb = tk.Label(message, text="添加成功！", font=("等线", 30))
  547.     message_lb.config(fg="red")
  548.     message_lb.pack()
  549.     message_bt = tk.Button(message, text="返回", height=1, width=8, command=message.destroy)
  550.     message_bt.place(x=150, y=75)
  551.  
  552.  
  553. root = tk.Tk()
  554. root.title("单项选择题答题与管理系统")
  555. root.geometry("900x600")
  556. root.config(background='pink')
  557. main_label1 = tk.Label(root, text='单项选择题答题与管理系统', font=("Helvetica", 40), background='pink')
  558. main_label1.pack()
  559. main_bt1 = tk.Button(root, text='1.管理员登录', font=("Helvetica", 30), background='pink', command=administrator_login)
  560. main_bt1.place(x=300, y=100)
  561. main_bt2 = tk.Button(root, text='2.学生端登录', font=("Helvetica", 30), background='pink', command=student_login)
  562. main_bt2.place(x=300, y=180)
  563. main_bt3 = tk.Button(root, text='3. 注册学生账户', font=("Helvetica", 30), background='pink', command=student_register)
  564. main_bt3.place(x=300, y=260)
  565. main_bt4 = tk.Button(root, text='4.退出系统', font=("Helvetica", 30), background='pink', command=exit)
  566. main_bt4.place(x=300, y=340)
  567. global grade
  568. root.mainloop()

若文章存在错误之处，欢迎指正！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/371216
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号