选课系统需求分析
选课系统
角色:学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供三个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程
7. 上面的操作产生的数据都通过pickle序列化保存到文件里
功能提炼
1.管理员功能
注册功能
登录功能
创建学校
创建课程
创建老师
2.讲师功能
登录功能
选择课程
查看课程
查看学生分数
修改学生分数
3.学生功能
注册功能
登录功能
选择学校
选择课程
查看课程分数
选课系统架构设计
三层架构
与ATM架构设计的差异
1.第一层做分层展示
2.第三层创建models.py存储所有的类 只有该py文件内的代码有资格调用db_handler
选课系统思路梳理
属性：
学校：name,addr,course_list
课程: name,price,period,student_list,teacher_list
学生: name,pwd,school,course_list,score_dict
老师: name,pwd,course_list
管理员:name,pwd
管理员模块
用户创建
第一层：接收用户名和密码2次输入，验证密码是否一致，调用创建用户接口，传参用户名和密码
第二层：接收用户对象，判断用户是否存在，不存在直接调用第三层创建用户
用户登录
第一层：接收用户名和密码输入，调用用户登录接口，传参用户名和密码，登录成功设置用户登录状态
第二层：接收用户对象，判断用户名是否存在，判断密码是否正确，没问题直接返回用户登录成功
创建学校
第一层：接收学校名称和地址输入，调用创建学校接口，传参学校名称和地址
第二层：接收学校对象并判断学校是否存在，不存在调用管理员对象并创建学校方法。
创建课程
第一层：调用所有学校，循环遍历打印，接收输入并校验数字和范围，接收课程名称、价格、周期输入，调用创建课程接口，传参管理员和学校名称，课程名称、
价格、和周期
第二层：获取学校对象，判断课程名称是否在学校；获取管理员对象，调用管理员创建课程方法；学校对象添加新建课程名称，并保存学校对象
创建老师
第一层：接收用户名输入，调用创建用户接口，传参用户名。
第二层：接收用户对象，判断用户名是否存在，不存在直接调用第三层创建用户
学生模块
用户创建
第一层：接收用户名和密码2次输入，验证密码是否一致，调用创建用户接口，传参用户名和密码
第二层：接收用户对象，判断用户是否存在，不存在直接调用第三层创建用户
用户登录
第一层：接收用户名和密码输入，调用用户登录接口，传参用户名和密码，登录成功设置用户登录状态
第二层：接收用户对象，判断用户名是否存在，判断密码是否正确，没问题直接返回用户登录成功
选择学校
第一层：调用查询所有学校接口，循环并打印学校，接收学校编号输入，判断数字和范围，调用选择学校接口，传学校名称和学生名称
第二层：获取学生对象，判断学校名称是否为空；为空指定学校名称，并保存学生对象
选择课程
第一层：调用查询学生课程接口，传参学生名称。接收并循环打印课程列表，并判断数字和范围，设置课程临时列表，判断临时列表是否有添加课程；当退出时把
临时课程列表和学生名称传给调用选择课程的接口。
第二层：获取学生对象，判断学生对象的学校是否有值，有值返回学校对应的课程列表；获取学生对象，设置学生课程列表为集合，把传参的课程列表设置为老的
列表集合，两个进行并集把结果赋值给学生对象的课程列表，初始化课程成绩并赋值给学生对象的成绩字典，保存学生对象。循环遍历学生对象的课程列表，获取
课程对象，并把课程对象的学生列表append添加传参的学生名，最后保存课程对象。
查看分数
第一层：调用查看分数接口，传参学生名称
第二层：获取学生对象，并对学生对象的课程成绩字典判断是否有值，有值返回给第一层即可。
老师模块
用户登录
第一层：接收用户名和密码输入，调用用户登录接口，传参用户名和密码，登录成功设置用户登录状态
第二层：接收用户对象，判断用户名是否存在，判断密码是否正确，没问题直接返回用户登录成功
查看课程
第一层：获取所有学校接口查询，循环并打印学校，接收学校编号输入，判断数字和范围，调用选择学校接口，传参老师名称和学校名称
第二层：获取学校对象，判断学校对象课程列表是否有值，有值返回学校的课程列表给第一层
选择课程
第一层：获取所有课程查询接口，循环并打印课程，接收课程编号输入，判断数字和范围，设置课程临时列表，判断临时列表是否有添加课程；当退出时把
临时课程列表和老师名称传给调用选择课程的接口
第二层：获取老师对象，设置老师课程列表为集合，把传参的课程列表设置为老的列表集合，两个进行并集把结果赋值给老师对象的课程列表，并保存老师对象。循环
遍历老师的课程对象，获取课程对象，并把课程对象的老师列表append添加传参的老师名称，最后保存课程对象
查看分数
第一层：调用获取老师的教授课程接口，传参老师名称。接收课程并循环打印课程，接收课程编号输入，判断数字和范围，接收课程名称，调用查看分数接口，传参
课程名称和老师名称。
第二层：获取老师对象，查看判断老师对象课程列表是否有值，有值直接返回给第一层。获取课程对象，接收课程对象的学生列表，返回学生列表对应的课程成绩。
修改分数
第一层：调用获取老师的教授课程接口，传参老师名称。接收课程并循环打印课程，接收课程编号输入，判断数字和范围，接收课程名称，调用查看学生接口，传参
课程名称。接收学生列表并循环打印学生名称，接收学生编号输入，判断数字和范围，接收学生名称，输入修改学生的分数，调用修改分数接口，传参课程名称，
学生名称，修改分数，学生名称。
第二层：获取老师对象，判断老师对象课程列表是否有值，有值直接返回第一层。获取课程对象，获取课程对象的学生列表，并判断是否有值，有值把学生列表返回
给第一层。获取学生对象，修改学生对象的课程成绩，保存学生对象并返回修改成功。
选课系统代码汇总
第一层：
项目启动脚本start.py
import os
import sys
base_dir = os.path.dirname(__file__)
sys.path.append(base_dir)
if __name__ == '__main__':
from core import src
src.run()
展示层汇总之src.py
from core import admin_view,student_view,teacher_view
func_dict = {
'1':admin_view,
'2':student_view,
'3':teacher_view
}
def run():
while True:
print('''
1.管理员视图
2.学生视图
3.老师视图
''')
choice_num = input('请输入功能编号>>>:').strip()
if choice_num in func_dict:
func_dict.get(choice_num).run()
else:
print('请输入正常功能编号')
展示层之admin_view.py
from interface import admin_interface
from lib import common
is_login = {'username':''}
def register():
username = input('请输入用户名注册>>>:').strip()
password = input('请输入用户名密码注册>>>:').strip()
confirm_pwd = input('请输入确认密码注册>>>:').strip()
if not password == confirm_pwd:
print('两次密码不一致')
return
password = common.hash_pwd(password)
# 调用注册
flag,msg = admin_interface.register_interface(username,password)
print(msg)
def login():
username = input('请输入登录用户名>>>:').strip()
password = input('请输入登录密码>>>:').strip()
password = common.hash_pwd(password)
flag,msg = admin_interface.login_interface(username,password)
if flag:
# 添加用户登录状态
is_login['username'] = username
print(msg)
else:
print(msg)
@common.login_auth('admin')
def create_school():
school_name = input('请输入学校名称>>>:').strip()
school_addr = input('请输入学校地址>>>:').strip()
flag,msg = admin_interface.create_school_interface(is_login.get('username'),school_name,school_addr)
print(msg)
'''
第一层：获取学校名称和地址，调用接口，传参管理员名称、学校名称和地址
第二层：获取学校对象，判断是否存在，不存在获取管理员对象，调用管理员创建学校
'''
@common.login_auth('admin')
def create_course():
flag1,school_name_list = admin_interface.get_school_name_list()
if not flag1:
print(school_name_list)
return
while True:
for school_num,school_name in enumerate(school_name_list,start=1):
print(f'学校编号：{school_num}|学校名称：{school_name}')
choice_school_num = input('请输入学校编号>>>').strip()
if choice_school_num.lower()=='q':return
if not choice_school_num.isdigit():
print('学校编号必须是纯数字')
continue
choice_school_num = int(choice_school_num)
if choice_school_num not in range(1,len(school_name_list)+1):
print('学校编号超出范围了')
continue
target_school_name = school_name_list[choice_school_num-1]
course_name = input('请输入课程名称>>>:').strip()
course_price = input('请输入课程价格>>>:').strip()
course_period =input('请输入课程周期>>>:').strip()
# 调用创建课程接口
flag,msg = admin_interface.create_course_interface(is_login.get('username'),target_school_name,
course_name,course_price,course_period)
print(msg)
'''
第一层：获取所有学校名称，循环遍历，选择一个，获取课程名称、价格、周期，调用创建课程接口，传参管理员、学校名称、课程名称、价格和周期
第二层：获取所有学校并判断是否有值，有值返回；获取学校对象，判断课程名称是否在学校，没有则获取管理员对象调用创建，学校添加课程并保存学校
'''
@common.login_auth('admin')
def create_teacher():
username = input('请输入用户名注册>>>:').strip()
flag,msg = admin_interface.create_teacher_interface(is_login.get('username'),username)
print(msg)
@common.login_auth('admin')
def check_course():
admin_interface.get_all_course()
# flag,check_course_list = admin_interface.get_all_course()
# print(check_course_list)
@common.login_auth('admin')
def check_student():
admin_interface.get_all_student()
@common.login_auth('admin')
def check_teacher():
admin_interface.get_all_teacher()
func_dict = {
'1':register,
'2':login,
'3':create_school,
'4':create_course,
'5':create_teacher,
'6':check_course,
'7':check_student,
'8':check_teacher,
}
def run():
while True:
print('''
1.注册用户
2.登录用户
3.创建学校
4.创建课程
5.创建老师
6.查看课程
7.查看学生
8.查看老师
''')
choice_num = input('请输入功能编号>>>:').strip()
if choice_num.lower() == 'q':return
if choice_num in func_dict:
func_dict.get(choice_num)()
else:
print('请输入正确功能编号')
展示层之student_view.py
from interface import student_interface
from lib import common
is_login = {'username': ''}
def register():
username = input('请输入用户名注册>>>:').strip()
password = input('请输入用户名密码注册>>>:').strip()
confirm_pwd = input('请输入确认密码注册>>>:').strip()
if not password == confirm_pwd:
print('两次密码不一致')
return
password = common.hash_pwd(password)
# 调用注册
flag, msg = student_interface.register_interface(username, password)
print(msg)
def login():
username = input('请输入登录用户名>>>:').strip()
password = input('请输入登录密码>>>:').strip()
password = common.hash_pwd(password)
flag, msg = student_interface.login_interface(username, password)
if flag:
# 添加用户登录状态
is_login['username'] = username
print(msg)
else:
print(msg)
@common.login_auth('student')
def choice_school():
# 获取所有学校列表
flag1, school_name_list = student_interface.get_school_name_list()
if not flag1:
print(school_name_list)
return
while True:
for school_num, school_name in enumerate(school_name_list, start=1):
print(f'学校编号：{school_num}|学校名称：{school_name}')
choice_school_num = input('请输入学校编号>>>').strip()
if choice_school_num.lower() == 'q': return
if not choice_school_num.isdigit():
print('学校编号必须是纯数字')
continue
choice_school_num = int(choice_school_num)
if choice_school_num not in range(1, len(school_name_list) + 1):
print('学校编号超出范围了')
continue
target_school_name = school_name_list[choice_school_num - 1]
# 调用选择学校接口
flag,msg = student_interface.choice_school_interface(is_login.get('username'),target_school_name)
print(msg)
'''
第一层：调用获取所有学校并循环遍历，打印选择一个，调用选择学校接口，传参学生名称和学校名称
第二层：获取所有学校，判断是否有值，有值返回；获取学生对象，判断学生对象是否选择学校，没有选择则学生添加学校并保存学生
'''
@common.login_auth('student')
def choice_course():
# 获取学校得到该校的所有课程列表
flag1,course_name_list = student_interface.get_school_course(is_login.get('username'))
if not flag1:
print(course_name_list)
return
# 循环打印学校下的课程，获得课程列表值传给第二层(课程可能有1个或多个)
temp_course_list = []
while True:
for course_num,course_name in enumerate(course_name_list,start=1):
print(f'课程编号：{course_num}|课程名称：{course_name}')
choice_course_num = input('请输入课程编号>>>').strip()
if choice_course_num.lower() == 'q':
if not temp_course_list:
print('课程临时列表为空，请去添加吧')
continue
# 调用选择课程接口
flag,msg = student_interface.choice_course_interface(is_login.get('username'),temp_course_list)
print(msg)
return
if not choice_course_num.isdigit():
print('课程编号必须是纯数字')
continue
choice_course_num = int(choice_course_num)
if choice_course_num not in range(1, len(course_name_list) + 1):
print('课程编号超出范围了')
continue
target_course_name = course_name_list[choice_course_num - 1]
if target_course_name in temp_course_list:
print('课程已在课程临时列表里，无序重复添加')
continue
temp_course_list.append(target_course_name)
print(f'课程已添加到临时课程列表里{temp_course_list}')
'''
第一层：调用查询课程接口，传参学生姓名；获取课程列表，循环遍历，获取课程名称，添加临时课程列表，判断是否有值，没有值添加，当退出调用
选择课程接口，传参学生姓名和课程名称。
第二层：获取学生对象，判断学校是否有值，有值返回学校对应的课程；获取学生对象，接收学生课程列表，设置为老集合，设置传参列表为新集合，
两者进行并集赋值给学生的课程列表，初始化课程成绩，并把结果赋值给成绩字典，保存学生对象。循环遍历学生课程列表，获取课程对象，添加对象
对应的学生姓名，并保存课程。
'''
@common.login_auth('student')
def check_score():
flag,msg = student_interface.check_score_interface(is_login.get('username'))
print(msg)
'''
第一层：调用查看成绩接口，传参学生名称
第二层：获取学生对象，判断成绩字典是否有值，有值返回
'''
func_dict = {
'1': register,
'2': login,
'3': choice_school,
'4': choice_course,
'5': check_score
}
def run():
while True:
print('''
1.注册用户
2.登录用户
3.选择学校
4.选择课程
5.查看分数
''')
choice_num = input('请输入功能编号>>>:').strip()
if choice_num.lower() == 'q': return
if choice_num in func_dict:
func_dict.get(choice_num)()
else:
print('请输入正确功能编号')
展示层之teacher_view.py
from interface import teacher_interface
from lib import common
is_login = {'username': ''}
def login():
username = input('请输入登录用户名>>>:').strip()
password = input('请输入登录密码>>>:').strip()
flag, msg = teacher_interface.login_interface(username, password)
if flag:
# 添加用户登录状态
is_login['username'] = username
print(msg)
else:
print(msg)
@common.login_auth('teacher')
def check_course():
# 获取所有学校列表
flag1, school_name_list = teacher_interface.get_school_name_list()
if not flag1:
print(school_name_list)
return
# 只有学校列表有值才循环打印
while True:
for school_num, school_name in enumerate(school_name_list, start=1):
print(f'学校编号：{school_num}|学校名称：{school_name}')
choice_school_num = input('请输入学校编号>>>').strip()
if choice_school_num.lower() == 'q': return
if not choice_school_num.isdigit():
print('学校编号必须是纯数字')
continue
choice_school_num = int(choice_school_num)
if choice_school_num not in range(1, len(school_name_list) + 1):
print('学校编号超出范围了')
continue
target_school_name = school_name_list[choice_school_num - 1]
# 调用查看课程接口
flag,msg = teacher_interface.check_course_interface(is_login.get('username'),target_school_name)
print(msg)
@common.login_auth('teacher')
def choice_course():
# 获取所有课程列表，有值才循环打印
flag1, course_name_list = teacher_interface.get_course_name_list()
if not flag1:
print(course_name_list)
return
temp_course_list = []
while True:
for course_num, course_name in enumerate(course_name_list, start=1):
print(f'课程编号：{course_num}|课程名称：{course_name}')
choice_course_num = input('请输入课程编号>>>').strip()
# 只有选择退出时才一并把刚才添加的课程一并传给第二层
if choice_course_num.lower() == 'q':
if not temp_course_list:
print('课程临时列表为空，请去添加吧')
continue
# 调用选择课程接口
flag, msg = teacher_interface.choice_course_interface(is_login.get('username'), temp_course_list)
print(msg)
return
if not choice_course_num.isdigit():
print('课程编号必须是纯数字')
continue
choice_course_num = int(choice_course_num)
if choice_course_num not in range(1, len(course_name_list) + 1):
print('课程编号超出范围了')
continue
target_course_name = course_name_list[choice_course_num - 1]
# 判断课程是否重复添加
if target_course_name in temp_course_list:
print('课程已在课程临时列表里，无序重复添加')
continue
temp_course_list.append(target_course_name)
print(f'课程已添加到临时课程列表里{temp_course_list}')
@common.login_auth('teacher')
def check_score():
# 获取老师个人教授下的课程列表
flag1,course_list = teacher_interface.get_course_list(is_login.get('username'))
if not flag1:
print(course_list)
return
# 循环打印老师个人教授下的课程列表
while True:
for course_num,course_name in enumerate(course_list,start=1):
print(f'课程编号：{course_num}|课程名称：{course_name}')
choice_course_num = input('请输入课程编号>>>').strip()
if choice_course_num.lower()=='q':return
if not choice_course_num.isdigit():
print('课程编号必须是纯数字')
continue
choice_course_num = int(choice_course_num)
if choice_course_num not in range(1, len(course_list) + 1):
print('课程编号超出范围了')
continue
target_course_name = course_list[choice_course_num - 1]
# 调用查看分数接口
flag,msg = teacher_interface.check_score_interface(is_login.get('username'),target_course_name)
print(msg)
@common.login_auth('teacher')
def update_score():
# 获取老师个人教授下的课程列表
flag1, course_list = teacher_interface.get_course_list(is_login.get('username'))
if not flag1:
print(course_list)
return
# 循环打印个人教授下的课程列表
while True:
for course_num, course_name in enumerate(course_list, start=1):
print(f'课程编号：{course_num}|课程名称：{course_name}')
choice_course_num = input('请输入课程编号>>>').strip()
if choice_course_num.lower() == 'q': return
if not choice_course_num.isdigit():
print('课程编号必须是纯数字')
continue
choice_course_num = int(choice_course_num)
if choice_course_num not in range(1, len(course_list) + 1):
print('课程编号超出范围了')
continue
target_course_name = course_list[choice_course_num - 1]
# 通过课程获取学生
flag2,student_list = teacher_interface.get_student_list(target_course_name)
if not flag2:
print(student_list)
return
# 循环打印学生获取学生
while True:
for student_num, student_name in enumerate(student_list, start=1):
print(f'学生编号：{student_num}|学生名称：{student_name}')
choice_student_num = input('请输入学生编号>>>').strip()
if choice_student_num.lower() == 'q': return
if not choice_student_num.isdigit():
print('学生编号必须是纯数字')
continue
choice_student_num = int(choice_student_num)
if choice_student_num not in range(1, len(student_list) + 1):
print('学生编号超出范围了')
continue
# 获取目标学生
target_student_name = student_list[choice_student_num - 1]
# 设置具体修改分数
target_update_score_num = input('请输入修改的分数>>>:').strip()
# 调用修改分数接口（传参老师名称、学生名称、课程名称、课程修改分数）
flag3,msg = teacher_interface.update_score_interface(is_login.get('username'),target_student_name
,target_course_name,target_update_score_num)
if flag3:
print(msg)
return
'''
获取课程（遍历课程传参找学校）-循环遍历学校，获取修改分数，-调用接口（传参课程名称、课程分数、学校名称、老师姓名）
'''
func_dict = {
'1': login,
'2': check_course,
'3': choice_course,
'4': check_score,
'5': update_score
}
def run():
while True:
print('''
1.登录用户
2.查看课程
3.选择课程
4.查看分数
5.修改分数
''')
choice_num = input('请输入功能编号>>>:').strip()
if choice_num.lower() == 'q': return
if choice_num in func_dict:
func_dict.get(choice_num)()
else:
print('请输入正确功能编号')
第二层
接口层之admin_interface.py
from db import models
def register_interface(username,password):
admin_obj = models.Admin.select_obj(username)
if admin_obj:
return False,f'{username}已存在'
# 创建用户并判断是否有值
if len(username) == 0:
return False,f'注册名称不能为空'
models.Admin(username,password)
return True,f'{username}用户创建成功'
def login_interface(username,password):
admin_obj = models.Admin.select_obj(username)
if not admin_obj:
return False,f'{username}不存在'
if not admin_obj.pwd == password:
return False,f'{username}密码错误'
return True,f'{username}登录成功'
def create_school_interface(admin_user,school_name,school_addr):
school_obj = models.School.select_obj(school_name)
if school_obj:
return False,f'{school_name}学校已存在'
admin_obj = models.Admin.select_obj(admin_user)
admin_obj.create_school(school_name,school_addr)
return True,f'{school_name} 被管理员{admin_user}创建成功'
def get_school_name_list():
school_name_list = models.School.select_all_obj()
if not school_name_list:
return False,'学校空空如也，请联系管理员去创建学校'
return True,school_name_list
def create_course_interface(admin_user,school_name,course_name,course_price,course_period):
school_obj = models.School.select_obj(school_name)
if course_name in school_obj.course_list:
return False,f'{course_name}存在{school_name}学校里，请重新选择学校'
admin_obj = models.Admin.select_obj(admin_user)
admin_obj.create_course(course_name,course_price,course_period)
# 学校添加课程并保存
school_obj.course_list.append(course_name)
school_obj.save_obj()
return True,f'{course_name}已被管理员{admin_user}在{school_name}学校创建成功'
def create_teacher_interface(admin_user,teacher_name):
teacher_obj = models.Teacher.select_obj(teacher_name)
if teacher_obj:
return False,f'{teacher_name}用户已存在'
admin_obj = models.Admin.select_obj(admin_user)
admin_obj.create_teacher(teacher_name)
return True,f'{teacher_name}老师已被管理员{admin_user}创建成功'
def get_all_course():
all_course_list = models.Course.select_all_obj()
if all_course_list:
for course in all_course_list:
course_obj = models.Course.select_obj(course)
print(f'课程名称：{course_obj.name}|课程价格:{course_obj.price}|课程周期:{course_obj.period}|课程学生列表：{course_obj.student_list}|课程老师列表:{course_obj.teacher_list}')
def get_all_student():
all_student_list = models.Student.select_all_obj()
if all_student_list:
for student in all_student_list:
student_obj = models.Student.select_obj(student)
print(f'学生名称:{student_obj.name}\t学生学校:{student_obj.school}\t',end='\t')
if student_obj.score_dict:
for student_course,student_score in student_obj.score_dict.items():
print(f'学生课程:{student_course}\t学生成绩:{student_score}\t')
def get_all_teacher():
all_teacher_list = models.Teacher.select_all_obj()
if all_teacher_list:
for teacher in all_teacher_list:
teacher_Obj = models.Teacher.select_obj(teacher)
print(f'老师姓名：{teacher_Obj.name}\t老师课程：{teacher_Obj.course_list}')
接口层之student_interface.py
from db import models
def register_interface(username, password):
student_obj = models.Student.select_obj(username)
if student_obj:
return False, f'{username}已存在'
# 创建用户
models.Student(username, password)
return True, f'{username}用户创建成功'
def login_interface(username, password):
student_obj = models.Student.select_obj(username)
if not student_obj:
return False, f'{username}不存在'
if not student_obj.pwd == password:
return False, f'{username}密码错误'
return True, f'{username}登录成功'
def get_school_name_list():
# 获取所有学校
school_name_list = models.School.select_all_obj()
if not school_name_list:
return False, '学校空空如也，请联系管理员去创建学校'
return True, school_name_list
def choice_school_interface(student_name, school_name):
# 获取学生对象，判断学生对象学校是否有值
student_obj = models.Student.select_obj(student_name)
if student_obj.school:
return False, f'{student_name}已选择学校，无法再选'
# 设置选择学校并保存
student_obj.school = school_name
student_obj.save_obj()
return True, f'{school_name}学生已选择{school_name}'
def get_school_course(student_name):
# 获取学校对象，判断学校是否有值，有值返回学校对应的课程
student_obj = models.Student.select_obj(student_name)
if not student_obj.school:
return False, f'{student_name}还没有选择学校呢'
return True, models.School.select_obj(student_obj.school).course_list
def choice_course_interface(student_name, course_list):
# 获取学生对象并获取对象的课程列表
student_obj = models.Student.select_obj(student_name)
old_course_set_list = set(student_obj.course_list)
new_course_set_list = set(course_list)
# 通过外层列表内层集合去重方式获取课程列表并直接赋值
student_obj.course_list = list(set(old_course_set_list | new_course_set_list))
# 初始化成绩
for course_name in student_obj.course_list:
if course_name not in student_obj.score_dict:
student_obj.score_dict = {course_name: '暂无成绩' for course_name in student_obj.course_list}
student_obj.save_obj()
# 课程添加学生列表
for course_name in student_obj.course_list:
course_obj = models.Course.select_obj(course_name)
# 判断学生是否在课程学生列表里，没有才增加并保存课程对象
if not student_name in course_obj.student_list:
course_obj.student_list.append(student_name)
course_obj.save_obj()
return True,f'{student_name}已选择{course_list},目前课程列表有如下：{student_obj.course_list}'
def check_score_interface(student_name):
# 获取学生对象并判断成绩字典是否有值，有值才返回
student_obj = models.Student.select_obj(student_name)
if not student_obj.score_dict:
return False,f'{student_name}还没有选择课程呢，请先选课程'
return True,student_obj.score_dict
接口层之teacher_interface.py
from db import models
def login_interface(username, password):
teacher_obj = models.Teacher.select_obj(username)
if not teacher_obj:
return False, f'{username}不存在'
if not teacher_obj.pwd == password:
return False, f'{username}密码错误'
return True, f'{username}登录成功'
def get_school_name_list():
school_name_list = models.School.select_all_obj()
if not school_name_list:
return False, '学校空空如也，请联系管理员去创建学校'
return True, school_name_list
def check_course_interface(teacher_name,school_name):
school_obj = models.School.select_obj(school_name)
if not school_obj.course_list:
return False,f'{school_name}没有课程，请联系管理员去添加吧'
return True,school_obj.course_list
def get_course_name_list():
course_name_list = models.Course.select_all_obj()
if not course_name_list:
return False, '课程空空如也，请联系管理员去创建课程'
return True, course_name_list
def choice_course_interface(teacher_name, course_list):
# 获取老师对象
teacher_obj = models.Teacher.select_obj(teacher_name)
# 对老师对象的课程列表进行集合，方便后面添加可以去重
old_course_set_list = set(teacher_obj.course_list)
new_course_set_list = set(course_list)
# 两个集合合并去重并设置为列表方式并赋值给老师对象的课程列表，并保存老师对象
teacher_obj.course_list = list(set(old_course_set_list | new_course_set_list))
teacher_obj.save_obj()
# 课程添加老师列表
for course_name in teacher_obj.course_list:
course_obj = models.Course.select_obj(course_name)
# 判断老师是否在课程老师列表里，避免重复添加
if not teacher_name in course_obj.teacher_list:
course_obj.teacher_list.append(teacher_name)
course_obj.save_obj()
return True,f'{teacher_name}已选择{course_list},目前课程列表有如下：{teacher_obj.course_list}'
def get_course_list(teacher_name):
# 通过老师对象获取老师里的课程列表
teacher_obj = models.Teacher.select_obj(teacher_name)
if not teacher_obj.course_list:
return False,f'{teacher_name}还没有选择课程呢'
return True,teacher_obj.course_list
def check_score_interface(teacher_name,course_name):
#获取课程对象，通过课程对象获取学生列表
course_obj = models.Course.select_obj(course_name)
if not course_obj.student_list:
return False,f'{course_name}课程没有学生报名'
# print(course_obj.student_list,'----')
# 返回学生列表的所有课程成绩
# return True,{ name:models.Student.select_obj(name).score_dict for name in course_obj.student_list}
# 返回学生列表的指定课程成绩
return True,{ name:models.Student.select_obj(name).score_dict.get(course_name) for name in course_obj.student_list}
def get_student_list(course_name):
course_obj = models.Course.select_obj(course_name)
if not course_obj.student_list:
return False,f'{course_name}还没有学生学习'
return True,course_obj.student_list
def update_score_interface(teacher_name,student_name,course_name,score_num):
#获取学生对象，对学生对象的课程成绩直接修改并保存
sutdent_obj = models.Student.select_obj(student_name)
sutdent_obj.score_dict[course_name]=score_num
sutdent_obj.save_obj()
return True,f'{student_name}学生的课程{course_name}被老师{teacher_name}修改为{score_num}'
第三层
models.py
'''
学校：school_name,school_addr,course_list
课程：course_name,course_price,course_period,student_list,teacher_list
学生：student_name,student_pwd,school,course_list,score_dict
老师：teacher_name,pwd,course_list
'''
from db import db_handler
class Bases(object):
@classmethod
def select_all_obj(cls):
return db_handler.select_all_obj(cls)
@classmethod
def select_obj(cls,name):
return db_handler.select(cls,name)
def save_obj(self):
db_handler.save(self)
class Admin(Bases):
def __init__(self,username,password):
self.name = username
self.pwd = password
self.save_obj()
def create_school(self,school_name,school_addr):
School(school_name,school_addr)
def create_course(self,course_name,course_price,course_period):
Course(course_name,course_price,course_period)
def create_teacher(self,teacher_name):
Teacher(teacher_name)
class School(Bases):
def __init__(self,student_name,student_pwd):
self.name = student_name
self.pwd = student_pwd
self.course_list = []
self.save_obj()
class Course(Bases):
def __init__(self,course_name,course_price,course_period):
self.name = course_name
self.price = course_price
self.period = course_period
self.student_list = []
self.teacher_list = []
self.save_obj()
class Teacher(Bases):
def __init__(self,teacher_name,pwd='123'):
self.name = teacher_name
self.pwd = pwd
self.course_list = []
self.save_obj()
class Student(Bases):
def __init__(self,student_name,student_pwd):
self.name = student_name
self.pwd = student_pwd
self.school = None
self.course_list = []
self.score_dict = {}
self.save_obj()
db_handler.py
import os
import pickle
from conf import settings
def select(class_name,data_name):
dir_name = os.path.join(settings.DB_DIR,class_name.__name__)
# 查询动态创建
if not os.path.exists(dir_name):
os.mkdir(dir_name)
# 获取目标文件路径
file_path = os.path.join(dir_name,data_name)
if os.path.exists(file_path):
with open(file_path,'rb') as f:
return pickle.load(f)
def save(data_obj):
dir_name = os.path.join(settings.DB_DIR,data_obj.__class__.__name__)
# 查询动态创建
if not os.path.exists(dir_name):
os.mkdir(dir_name)
# 获取目标文件路径
file_path = os.path.join(dir_name,data_obj.name)
with open(file_path,'wb' )as f:
pickle.dump(data_obj,f)
def select_all_obj(class_name):
dir_path = os.path.join(settings.DB_DIR,class_name.__name__)
return os.listdir(dir_path)
公共模块common.py
import hashlib
def hash_pwd(password):
md5 = hashlib.md5()
md5.update(password.encode('utf8'))
return md5.hexdigest()
# 用户认证有参装饰器
def login_auth(type):
def outer(func_name):
def inner(*args, **kwargs):
from core import admin_view,student_view,teacher_view
mode_dict = {
'admin':admin_view,
'student':student_view,
'teacher':teacher_view
}
if type in mode_dict:
mode_name = mode_dict.get(type)
if mode_name.is_login.get('username'):
res = func_name(*args, **kwargs)
return res
else:
print('没有登录，请登录')
mode_name.login()
return inner
return outer
配置模块settings.py
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
DB_DIR = os.path.join(BASE_DIR,'db')
if not os.path.exists(DB_DIR):
os.mkdir(DB_DIR)