角色: 学校、学员、课程、讲师、管理员
要求:
1. 创建北京、上海 2 所学校 ---> 管理员创建学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 创建讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师
6. 提供两个角色接口
6.1 学员视图， 可以注册，选择课程（等同于选择班级）
6.2 讲师视图， 讲师可管理自己的课程， 上课时选择班级，
查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程
7. 上面的操作产生的数据都通过pickle序列化保存到文件里
- pickle 可以帮我们保存对象
1、需求分析 （课程与班级合为一体）
- 管理视图
- 1.注册
- 2.登录
- 3.创建学校
- 4.创建课程(先选择学校)
- 5.创建讲师
- 学员视图
- 1.注册
- 2.登录功能
- 3.选择校区
- 4.选择课程（先选择校区，再选择校区中的某一门课程）
- 学生选择课程，课程也选择学生
- 5.查看分数
- 讲师视图
- 1.登录
- 2.查看教授课程
- 3.选择教授课程
- 4.查看课程下学生
- 5.修改学生分数
2、程序的架构设计
- 三层架构
- 用户视图层
- 用于与用户进行交互的
- 小的逻辑判断,比如注册功能中两次密码是否一致的校验
- core
- src.py 主视图
- admin.py
admin_view
- student.py
student_view
- teacher.py
teacher_view
- 逻辑接口层
- 核心业务逻辑的处理
- interface
- admin_interface.py
- student_interface.py
- teacher_interface.py
- 数据处理层
- 做数据的处理，比如数据的 增、删、查、改
- db
- models.py
- 用于存放所有类，管理所有的类
- Base:
# 保存数据
- save(self):
db_handler.save_data()
@classmethod
- select(cls, username):
obj = db_handler.select_data(cls, username)
return obj
- Admin(Base)
- __init__(self, admin_name, pwd):
self.user = admin_name
self.pwd = pwd
# 管理员的创建学校方法
- create_school():
school_obj = School()
school_obj.save()
# 管理员的创建课程方法
- create_course(school_obj, course_name):
course_obj = Course()
course_obj.save()
school_obj.course_list.append(course_name)
# 管理员的创建老师方法
- create_teacher(self, teacher_name, teacher_pwd):
tea_obj = Teacher(teacher_name, teacher_pwd)
tea_obj.save()
- School(Base):
__init__(self, school_name, school_addr)
self.user = school_name
self.addr = school_addr
self.course_list = []
- Course(Base):
__init__(self, course_name):
self.user = course_name
self.student_list = []
- Teacher(Base):
__init__(self, teacher_name, teacher_pwd):
self.user = teacher_name
self.pwd = teacher_pwd
self.course_list_from_teacher = []
- db_handler.py
- save_data(obj) 保存 对象
- 拼接文件夹，以类名当做文件夹管理文件
class_name = obj.__class__.__name__
- 再拼接文件，然后把对象通过pickle序列化到pickle文件中
- select_data(cls, username):
- 拼接文件夹，以类名当做文件夹管理文件
class_name = cls.__name__
- 再拼接文件，然后把通过pickle反序列化得到pickle文件中的对象
- ATM + 购物车
- 存放 json格式的数据
- dict --> json
- 选课系统(******)
- pickle 保存对象
- object ---> pickle
3、分任务开发
4、测试
5、线上
选课系统总结：
- 管理员
- 注册
1.用户在视图层输入用户名与密码，交给接口层
2.接口层调用数据层中的models.select进行校验。
3.若不存在则创建，并将注册成功返回给视图层。
- 登录
1.用户在视图层输入用户名与密码，交给接口层
2.接口层调用数据层中的models.select进行校验。
3.若存在则校验密码，并将登录成功返回给视图层。
- 创建学校
1.让用户输入学校名与学校地址
2.调用管理员创建学校接口
3.判断学校是否存在，若存在不让创建
4.若不存在，则调用接口层创建学校，获取管理员对象的创建学校方法保存学校
5.将结果返回给视图层。
- 创建课程
1.获取所有学校，并打印，让用户选择
2.获取用户选择的学校与 创建的课程，交给接收层
3.接口层调用 管理员对象中的 创建课程方法，保存课程对象。
4.课程需要绑定给学校对象，最终将创建成功的结果返回给视图层。
- 创建老师
1.让用户输入老师的名称
2.调用接口层，接口层中设置默认密码 123，调用数据层。
3.判断老师是否存在，不存在则调用 管理员对象中的 创建老师方法。
4.保存老师对象，并将结果返回视图层。
- 学生
- 注册
- 同上
- 登录
- 同上
- 选择学校
1.获取所有学校，让学生选择，将选择的学校传给接口层
2.接口层判断当前学生是否选择学校
3.若没有选择，则调用学生对象中的添加学校方法。
4.将添加后消息返回给视图层。
- 选择课程
1.先获取当前学生所在学校的所有课程，并选择
2.接口层将选择后课程，调用数据层的添加课程方法保存。
3.学生对象中课程列表添加该课程，设置课程分数默认为0。
4.最终将结果返回给视图层
- 查看成绩
1.直接调用接口层
2.接口层调用数据层中的查看成绩方法
3.返回成绩给视图层并打印。
- 老师
- 登录
- 同上
- 查看教授课程
1.直接调用接口层，获取老师对象下课程列表数据
2.若有则打印，没有则退出
- 选择教授课程
1.调用接口层中的选择教授课程接口，调用数据层中该课程下所有的学生返回给视图层
2.打印所有的课程，让老师选择，若老师课程中有该课程则不让添加。
3.没有，则调用 老师对象中的 添加课程方法进行添加。
- 查看课程下学生
1.直接获取老师对象下所有的课程，选择课程
2.从老师对象中，调用查看课程下学生方法，获取 课程对象下 所有的学生，返回给视图层
3.视图层打印 该课程下所有的学生。
- 修改学生分数
1.直接获取老师对象下所有的课程，选择课程
2.从老师对象中，调用查看课程下学生方法，获取 课程对象下 所有的学生，返回给视图层
3.视图层打印 该课程下所有的学生，并让用户选择需要修改分数的学生。
4.调用老师修改分数接口，获取老师对象，调用对象中的修改分数方法
5.获取学生对象中的 score_dict 分数字典，进行修改。
from core import src
if __name__ == '__main__':
src.run()
from core import admin
from core import student
from core import teacher
func_dict = {
'0':exit,
'1':admin.admin_view,
'2':student.student_view,
'3':teacher.teacher_view,
}
def run():
while True:
print('''
========欢迎来到选课系统========
0.退出
1.管理员功能
2.学生功能
3.老师功能
=============end=============
''')
choice = input('请输入功能编号： ').strip()
if choice not in func_dict:
print('输入有误，请重新输入')
continue
func_dict[choice]()
from lib import common
from interface import admin_interface
from interface import common_interface
admin_info = {'user':None}
# 1.注册
def register():
while True:
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
re_password = input('请确认密码：').strip()
if password == re_password:
flag,msg = admin_interface.admin_register_interface(username,password)
if flag:
print(msg)
break
else:
print(msg)
else:
print('两次密码不一致，请重新输入')
# 2.登录
def login():
while True:
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
flag,msg = common_interface.login_interface(username,password,usertype='admin')
if flag:
print(msg)
admin_info['user'] = username
break
else:
print(msg)
# 3.创建学校
@common.auth(role= 'admin')
def create_school():
while True:
school_name = input('请输入学校名称：').strip()
school_addr = input('请输入学校地址：').strip()
flag,msg = admin_interface.create_school_interface(school_name,school_addr,admin_info['user'])
if flag:
print(msg)
break
else:
print(msg)
# 4.创建课程
@common.auth(role= 'admin')
def create_course():
while True:
flag,school_list_or_msg =common_interface.get_all_school_interface()
if flag:
for index,school_name in enumerate(school_list_or_msg):
print('编号：%s 学校名：%s'%(index,school_name))
choice = input('请输入学校编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(school_list_or_msg)):
print('请输入正确编号')
continue
school_name = school_list_or_msg[choice]
course_name = input('请输入创建课程的名称：').strip()
flag,msg = admin_interface.create_course_interface(school_name,course_name,admin_info['user'])
if flag:
print(msg)
break
else:
print(msg)
else:
print(school_list_or_msg)
break
# 5.创建讲师
@common.auth(role= 'admin')
def create_teacher():
while True:
teacher_name = input('请输入老师的名字：').strip()
flag,msg = admin_interface.create_teacher_interface(teacher_name,admin_info['user'])
if flag:
print(msg)
break
else:
print(msg)
#6.修改账户密码
def change_pwd():
while True:
user = input('请输入账号名：').strip()
new_pwd = input('请输入新密码：').strip()
re_new_pwd= input('请确认密码：').strip()
if new_pwd == re_new_pwd:
flag,msg = common_interface.change_pwd_interface(user,new_pwd,usertype = 'admin')
if flag:
print(msg)
break
else:
print(msg)
else:
print('两次密码不一致')
func_dict = {
'1' : register,
'2' : login,
'3' : create_school,
'4' : create_course,
'5' : create_teacher,
'6' : change_pwd
}
def admin_view():
while True:
print('''
---------欢迎来到管理员功能---------
0.退出
1.注册
2.登录
3.创建学校
4.创建课程
5.创建讲师
6.修改账户密码
-------------end---------------
''')
choice = input('请输入功能编号： ').strip()
if choice == '0':
if admin_info['user']:
admin_info['user'] = None
break
if choice not in func_dict:
print('输入有误，请重新输入')
continue
func_dict[choice]()
from lib import common
from interface import common_interface
from interface import teacher_interface
teacher_info = {'user':None}
# 1.登录
def login():
while True:
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
flag,msg = common_interface.login_interface(username,password,usertype='teacher')
if flag:
print(msg)
teacher_info['user'] = username
break
else:
print(msg)
# 2.选择校区
@common.auth(role= 'teacher')
def choose_school():
while True:
flag,school_list_or_msg =common_interface.get_all_school_interface()
if flag:
for index,school_name in enumerate(school_list_or_msg):
print('编号：%s 学校名：%s'%(index,school_name))
choice = input('请输入学校编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(school_list_or_msg)):
print('请输入正确编号')
continue
school_name = school_list_or_msg[choice]
msg = teacher_interface.choose_school_interface(school_name,teacher_info['user'])
print(msg)
break
else:
print(school_list_or_msg)
break
# 3.选择课程
@common.auth(role= 'teacher')
def choose_course():
while True:
flag,course_list_or_msg = teacher_interface.show_course_interface(teacher_info['user'])
if flag:
for index,course_name in enumerate(course_list_or_msg):
print('编号：%s 课程名：%s'%(index,course_name))
choice = input('请输入课程编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(course_list_or_msg)):
print('请输入正确编号')
continue
course_name = course_list_or_msg[choice]
msg = teacher_interface.choose_course_interface(course_name,teacher_info['user'])
print(msg)
break
else:
print(course_list_or_msg)
break
# 4.查看教授课程
@common.auth(role= 'teacher')
def check_course():
flag,course_list_or_msg = teacher_interface.check_course_interface(teacher_info['user'])
if flag:
print(course_list_or_msg)
else:
print(course_list_or_msg)
# 5.查看课程下学生
@common.auth(role= 'teacher')
def check_student():
while True:
flag,course_list_or_msg = teacher_interface.check_course_interface(teacher_info['user'])
if flag:
for index,course_name in enumerate(course_list_or_msg):
print('编号：%s 课程名：%s'%(index,course_name))
choice = input('请输入课程编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(course_list_or_msg)):
print('请输入正确编号')
continue
course_name = course_list_or_msg[choice]
flag,student_list_or_msg = teacher_interface.check_student_interface(course_name, teacher_info['user'])
if flag:
print(student_list_or_msg)
break
else:
print(student_list_or_msg)
break
else:
print(course_list_or_msg)
break
# 6.修改学生分数
@common.auth(role= 'teacher')
def change_score():
while True:
flag,course_list_or_msg = teacher_interface.check_course_interface(teacher_info['user'])
if flag:
for index,course_name in enumerate(course_list_or_msg):
print('编号：%s 课程名：%s'%(index,course_name))
choice = input('请输入课程编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(course_list_or_msg)):
print('请输入正确编号')
continue
course_name = course_list_or_msg[choice]
flag,student_list_or_msg = teacher_interface.check_student_interface(course_name, teacher_info['user'])
if flag:
for index,student_name in enumerate(student_list_or_msg):
print('编号：%s 学生名：%s' % (index, student_name))
choice = input('请输入学生编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(student_list_or_msg)):
print('请输入正确编号')
continue
student_name = student_list_or_msg[choice]
score = input('请输入需要修改的成绩:').strip()
if not score.isdigit():
print('请输入数字')
continue
score = int(score)
flag,msg = teacher_interface.change_score_interface(
course_name,student_name,score,teacher_info['user']
)
if flag:
print(msg)
break
else:
print(student_list_or_msg)
break
else:
print(course_list_or_msg)
break
#7.修改账户密码
def change_pwd():
while True:
user = input('请输入账号名：').strip()
new_pwd = input('请输入新密码：').strip()
re_new_pwd= input('请确认密码：').strip()
if new_pwd == re_new_pwd:
flag,msg = common_interface.change_pwd_interface(user,new_pwd,usertype = 'teacher')
if flag:
print(msg)
break
else:
print(msg)
else:
print('两次密码不一致')
func_dict = {
'1' : login,
'2' : choose_school,
'3' : choose_course,
'4' : check_course,
'5' : check_student,
'6': change_score,
'7':change_pwd
}
def teacher_view():
while True:
print('''
---------欢迎来到教师功能---------
0.退出
1.登录
2.选择校区
3.选择课程
4.查看教授课程
5.查看课程下学生
6.修改学生分数
7.修改账户密码
-------------end---------------
''')
choice = input('请输入功能编号： ').strip()
if choice == '0':
if teacher_info['user']:
teacher_info['user'] = None
break
if choice not in func_dict:
print('输入有误，请重新输入')
continue
func_dict[choice]()
from lib import common
from interface import common_interface
from interface import student_interface
student_info = {'user':None}
# 1.注册
def register():
while True:
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
re_password = input('请确认密码：').strip()
if password == re_password:
flag,msg = student_interface.student_register_interface(username,password)
if flag:
print(msg)
break
else:
print(msg)
else:
print('两次密码不一致，请重新输入')
# 2.登录功能
def login():
while True:
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
flag,msg = common_interface.login_interface(username,password,usertype='student')
if flag:
print(msg)
student_info['user'] = username
break
else:
print(msg)
# 3.选择校区
@common.auth(role= 'student')
def choose_school():
while True:
flag,school_list_or_msg =common_interface.get_all_school_interface()
if flag:
for index,school_name in enumerate(school_list_or_msg):
print('编号：%s 学校名：%s'%(index,school_name))
choice = input('请输入学校编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(school_list_or_msg)):
print('请输入正确编号')
continue
school_name = school_list_or_msg[choice]
flag,msg = student_interface.choose_school_interface(school_name,student_info['user'])
if flag:
print(msg)
break
else:
print(msg)
break
else:
print(school_list_or_msg)
break
# 4.选择课程
@common.auth(role= 'student')
def choose_course():
while True:
flag,course_list_or_msg = student_interface.show_course_interface(student_info['user'])
if flag:
for index,school_name in enumerate(course_list_or_msg):
print('编号：%s 课程名：%s'%(index,school_name))
choice = input('请输入课程编号：').strip()
if not choice.isdigit():
print('请输入数字')
continue
choice = int(choice)
if choice not in range(len(course_list_or_msg)):
print('请输入正确编号')
continue
course_name = course_list_or_msg[choice]
flag,msg = student_interface.choose_course_interface(course_name,student_info['user'])
if flag:
print(msg)
break
else:
print(msg)
break
else:
print(course_list_or_msg)
break
# 5.查看分数
@common.auth(role= 'student')
def check_score():
score_list_or_msg = student_interface.check_score_interface(student_info['user'])
print(score_list_or_msg)
#6.修改账户密码
def change_pwd():
while True:
user = input('请输入账号名：').strip()
new_pwd = input('请输入新密码：').strip()
re_new_pwd= input('请确认密码：').strip()
if new_pwd == re_new_pwd:
flag,msg = common_interface.change_pwd_interface(user,new_pwd,usertype = 'student')
if flag:
print(msg)
break
else:
print(msg)
else:
print('两次密码不一致')
func_dict = {
'1' : register,
'2' : login,
'3' : choose_school,
'4' : choose_course,
'5' : check_score,
'6' : change_pwd
}
def student_view():
while True:
print('''
---------欢迎来到学生功能---------
0.退出
1.注册
2.登录功能
3.选择校区
4.选择课程
5.查看分数
6.修改账户密码
-------------end---------------
''')
choice = input('请输入功能编号： ').strip()
if choice == '0':
if student_info['user']:
student_info['user'] = None
break
if choice not in func_dict:
print('输入有误，请重新输入')
continue
func_dict[choice]()
#登陆认证装饰器
def auth(role):
from core import admin,student,teacher
def login_auth(func):
def wrapper(*args,**kwargs):
if role == 'admin':
if admin.admin_info['user']:
res = func(*args,**kwargs)
return res
else:
admin.login()
elif role == 'student':
if student.student_info['user']:
res = func(*args,**kwargs)
return res
else:
student.login()
elif role == 'teacher':
if teacher.teacher_info['user']:
res = func(*args,**kwargs)
return res
else:
teacher.login()
else:
print('当前视图没有权限')
return wrapper
return login_auth
from db import models
#管理员注册接口
def admin_register_interface(username,password):
admin_obj = models.Admin.select(username)
if admin_obj:
return False,'用户已存在！'
else:
admin_obj = models.Admin(username,password)
admin_obj.save()
return True,'注册成功！'
#管理员创建学校接口
def create_school_interface(school_name,school_addr,admin_name):
school_obj = models.School.select(school_name)
if school_obj:
return False,'学校已存在！'
else:
admin_obj = models.Admin.select(admin_name)
admin_obj.create_school(school_name,school_addr)
return True,'学校创建成功！'
#管理员创建课程接口
def create_course_interface(school_name,course_name,admin_name):
school_obj = models.School.select(school_name)
if course_name in school_obj.course_list_from_school:
return False,'课程已存在！'
else:
admin_obj = models.Admin.select(admin_name)
admin_obj.create_course(course_name,school_obj)
return True,'[%s]课程创建成功！绑定给校区[%s]'%(course_name,school_name)
#管理员创建讲师接口
def create_teacher_interface(teacher_name,admin_name,teacher_pwd = '123'):
teacher_obj = models.Teacher.select(teacher_name)
if teacher_obj:
return False,'教师已存在！'
else:
admin_obj = models.Admin.select(admin_name)
admin_obj.create_teacher(teacher_name,teacher_pwd)
return True,'教师创建成功！'
import os
from conf import settings
from db import models
#公共登录接口
def login_interface(username,password,usertype):
# obj = None
if usertype == 'admin':
obj = models.Admin.select(username)
elif usertype == 'student':
obj = models.Student.select(username)
elif usertype == 'teacher':
obj = models.Teacher.select(username)
else:
return False,'登录角色不对，请输入角色'
if obj:
if password == obj.pwd:
return True,'登录成功！'
else:
return False,'密码错误！'
else:
return False,'用户名不存在！'
#修改密码接口
def change_pwd_interface(user,new_pwd,usertype):
if usertype == 'admin':
obj = models.Admin.select(user)
elif usertype == 'student':
obj = models.Student.select(user)
elif usertype == 'teacher':
obj = models.Teacher.select(user)
else:
return False,'登录角色不对，请输入角色'
if obj:
obj.change_pwd(new_pwd)
return True,'修改密码成功'
else:
return False,'修改的用户不存在，请重新输入'
#获取所有学校名称的接口
def get_all_school_interface():
school_dir=os.path.join(settings.DB_PATH,'school')
if not os.path.exists(school_dir):
return False,'没有学校，请先联系管理员'
else:
school_list = os.listdir(school_dir)
return True,school_list
from db import models
#教师选择校区接口
def choose_school_interface(school_name,teacher_name):
tea_obj = models.Teacher.select(teacher_name)
if tea_obj.school:
return '当前教师已经选择过学校'
else:
tea_obj.choose_school(school_name)
return '选择学校成功'
#获取教师所在学校下所有课程
def show_course_interface(teacher_name):
tea_obj = models.Teacher.select(teacher_name)
school_name = tea_obj.school
if school_name:
school_obj = models.School.select(school_name)
course_list = school_obj.course_list_from_school
if course_list:
return True,course_list
else:
return False,'所选学校没有课程，请联系管理员'
else:
return False,'暂未选择校区，请先选择校区'
# 教师选择教授课程接口
def choose_course_interface(course_name,teacher_name):
tea_obj = models.Teacher.select(teacher_name)
if course_name in tea_obj.course_list_from_teacher:
return '教师已经选择过该课程'
else:
tea_obj.choose_course(course_name)
return '选择课程成功'
# 教师查看教授课程接口
def check_course_interface(teacher_name):
tea_obj = models.Teacher.select(teacher_name)
course_list = tea_obj.show_course()
if course_list:
return True,course_list
else:
return False,'暂无课程，请先选择课程'
# 教师查看课程下学生接口
def check_student_interface(course_name,teacher_name):
tea_obj = models.Teacher.select(teacher_name)
student_list = tea_obj.check_student(course_name)
if student_list:
return True,student_list
else:
return False,'课程下没有学生'
# 教师修改学生分数接口
def change_score_interface(course_name,student_name,score,teacher_name):
tea_obj = models.Teacher.select(teacher_name)
tea_obj.change_score(course_name,student_name,score)
return True,'修改分数成功'
from interface import common_interface
from db import models
#学生注册接口
def student_register_interface(username, password):
student_obj = models.Student.select(username)
if student_obj:
return False, '学生用户已存在！'
else:
student_obj = models.Student(username, password)
student_obj.save()
return True, '注册成功！'
#学生选择校区接口
def choose_school_interface(school_name,student_name):
stu_obj = models.Student.select(student_name)
if stu_obj.school:
return False,'当前学生已经选择过学校'
else:
stu_obj.choose_school(school_name)
return True,'选择学校成功'
#展示学生课程接口
def show_course_interface(student_name):
stu_obj = models.Student.select(student_name)
if stu_obj.school:
school_obj = models.School.select(stu_obj.school)
if school_obj.course_list_from_school:
return True,school_obj.course_list_from_school
else:
return False, '所选学校没有课程，请联系管理员'
else:
return False,'暂未选择校区，请先选择校区'
#学生选择课程接口
def choose_course_interface(course_name,student_name):
stu_obj = models.Student.select(student_name)
if course_name in stu_obj.course_list_from_student:
return False,'当前学生已经选择过该课程'
else:
stu_obj.choose_course(course_name)
return True,'选择课程成功'
#学生查看分数接口
def check_score_interface(student_name):
stu_obj = models.Student.select(student_name)
if stu_obj.score_dict:
return stu_obj.score_dict
else:
return '暂未选择课程，请先选择课程'
from db import db_handler
class Base:
def save(self):
db_handler.save_data(self)
@classmethod
def select(cls, username):
obj = db_handler.select_data(cls, username)
return obj
class School(Base):
def __init__(self,name,addr):
self.user = name
self.addr = addr
self.course_list_from_school= []
class Course(Base):
def __init__(self,course_name):
self.user = course_name
self.teacher_list = []
self.student_list = []
class Admin(Base):
def __init__(self,user,pwd):
self.user = user
self.pwd = pwd
#管理员创建学校
def create_school(self,school_name,school_addr):
school_obj = School(school_name,school_addr)
school_obj.save()
#管理员创建学生
def create_course(self,course_name,school_obj):
course_obj = Course(course_name)
course_obj.save()
school_obj.course_list_from_school.append(course_name)
school_obj.save()
#管理员创建老师
def create_teacher(self,teacher_name,teacher_pwd):
teacher_obj = Teacher(teacher_name,teacher_pwd)
teacher_obj.save()
#管理员修改密码
def change_pwd(self,new_pwd):
self.pwd = new_pwd
self.save()
class Student(Base):
def __init__(self,user,pwd):
self.user = user
self.pwd = pwd
self.school = None
self.course_list_from_student = []
self.score_dict = {}
self.paid = {}
#学生选择学校
def choose_school(self,school_name):
self.school = school_name
self.save()
#学生选择课程
def choose_course(self,course_name):
self.course_list_from_student.append(course_name)
self.score_dict[course_name] = 0
self.save()
course_obj = Course.select(course_name)
course_obj.student_list.append(self.user)
course_obj.save()
#学生修改密码
def change_pwd(self,new_pwd):
self.pwd = new_pwd
self.save()
class Teacher(Base):
def __init__(self,teacher_name,teacher_pwd):
self.user = teacher_name
self.pwd = teacher_pwd
self.school = None
self.course_list_from_teacher = []
#教师查看教授课程
def show_course(self):
return self.course_list_from_teacher
#教师选择学校
def choose_school(self,school_name):
self.school = school_name
self.save()
#教师选择课程
def choose_course(self,course_name):
self.course_list_from_teacher.append(course_name)
self.save()
course_obj = Course.select(course_name)
course_obj.teacher_list.append(self.user)
course_obj.save()
#查看教师所选课程的学生
def check_student(self,course_name):
course_obj = Course.select(course_name)
return course_obj.student_list
#教师修改分数
def change_score(self,course_name,student_name,score):
sut_obj = Student.select(student_name)
sut_obj.score_dict[course_name] = score
sut_obj.save()
#教师修改密码
def change_pwd(self,new_pwd):
self.pwd = new_pwd
self.save()
import os
import pickle
from conf import settings
#保存数据，返回None
def save_data(obj): #传一个对象进来
class_name = obj.__class__.__name__ #获取对象所在的类的名称
user_dir_path = os.path.join(settings.DB_PATH,class_name) #拼接以类名为文件名的文件路径
if not os.path.exists(user_dir_path): #如果该文件不存在则创建
os.mkdir(user_dir_path)
user_path = os.path.join(user_dir_path, obj.user) #拼接以对象的user属性名称为文件名的文件路径
with open(user_path,'wb') as f:
pickle.dump(obj,f) #将以pickle格式写入文件中
#选择数据，返回obj或者None
def select_data(cls,username): #传一个类及 进来
class_name = cls.__name__ #获取类的名称
user_dir_path = os.path.join(settings.DB_PATH,class_name) #拼接以类名为文件名的文件路径
if not os.path.exists(user_dir_path): #如果该文件不存在则创建
os.mkdir(user_dir_path)
user_path = os.path.join(user_dir_path,username) #拼接以username为文件名的文件路径
if os.path.exists(user_path): #如果文件存在，
with open(user_path,'rb') as f:
obj = pickle.load(f) #如果文件存在，则把读取文件中的pickle格式的内容
return obj
else:
return None
import os
#根目录文件路径
BASE_PATH = os.path.dirname(os.path.dirname(__file__))
#存储数据的文件路径
DB_PATH = os.path.join(BASE_PATH,'db')
因篇幅问题不能全部显示，请点此查看更多更全内容
Copyright © 2019- huatuo7.cn 版权所有 湘ICP备2022005869号-9
违法及侵权请联系：TEL:199 18 7713 E-MAIL:2724546146@qq.com
本站由北京市万商天勤律师事务所王兴未律师提供法律服务