本项目涉及创建一个选课系统，包括北京、上海两所学校，提供Linux、Python、Go三门课程。管理员创建学校和课程，讲师管理课程及成绩，学员选择学校和课程。所有操作使用Python的pickle库保存数据，项目结构清晰，包含管理员、学员和讲师的接口实现。
基础需求：85%
角色: 学校、学员、课程、讲师、管理员
要求:
- 创建北京、上海 2 所学校 —> 管理员创建学校
- 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
- 课程包含，周期，价格，通过学校创建课程
- 创建讲师
- 创建学员时，选择学校，关联班级
- 创建讲师
- 提供两个角色接口
6.1 学员视图， 可以注册，选择课程（等同于选择班级）
6.2 讲师视图， 讲师可管理自己的课程， 上课时选择班级，
查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程 - 上面的操作产生的数据都通过pickle序列化保存到文件里
- pickle 可以帮我们保存对象
conf
-settings
import os
BASE_PATH= os.path.dirname(
os.path.dirname(__file__)
)
DB_PATH =os.path.join(
BASE_PATH,"db"
)
core
-admin
'''管理员视图'''
from interface import admin_interface
from interface import common_interface
from lib import common
admin_info = {
"user":None
}
#注册
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("两次密码不一致，请重新输入")
#登录
def login():
while True:
username = input("请输入用户名:").strip()
password = input("请输入密码:").strip()
#1.调用管理员登录接口
flag,msg = common_interface.login_interface(
username,password,user_type = "admin")
if flag:
print(msg)
#记住当前登录状态
admin_info["user"] = username
break
else:
print(msg)
#创建学校
@common.auth("admin")
def create_school():
while True:
#1.让用户输入学校名称与地址
school_name = input("请输入学校名称:").strip()
school_addr = input("请输入学校地址:").strip()
#2.调用接口保存学校
flag,msg = admin_interface.create_school_interface(
#学校名，学校地址，创建学校的管理员
school_name,school_addr,admin_info.get("user")
)
if flag:
print(msg)
break
else:
print(msg)
#创建课程
@common.auth("admin")
def create_course():
while True:
#1.让管理员先选择学校
#1.1调用接口获取所有学校名称并打印
flag,school_list_or_msg = common_interface.get_all_school_interface()
if not flag:
print(school_list_or_msg)
break
for index,school_name in enumerate(school_list_or_msg):
print(f"编号{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]
#2.选择学校后再输入课程名称
course_name = input("请输入需要创建的课程名称:").strip()
#3.调用创建课程接口，让管理员创建课程
flag,msg = admin_interface.create_course_interface(
#传递学校的目的是为了关联课程
school_name,course_name,admin_info.get("user")
)
if flag:
print(msg)
break
else:
print(msg)
#创建讲师
@common.auth("admin")
def create_teacher():
while True:
# 1.让管理员输入创建的老师名字
teacher_name = input("请输入老师的名字:").strip()
# 2.调用接口，创建老师
flag, msg = admin_interface.create_teacher_interface(
teacher_name, admin_info.get("user")
)
if flag:
print(msg)
break
else:
print(msg)
func_dict = {
"1":register,
"2":login,
"3":create_school,
"4":create_course,
"5":create_teacher,
}
#管理员视图函数
def admin_view():
while True:
print('''
-1.注册
-2.登录
-3.创建学校
-4.创建课程
-5.创建讲师
''')
choice = input("请输入功能编号:").strip()
if choice == "q":
break
if choice not in func_dict:
print("输入有误，请重新输入")
continue
else:
func_dict.get(choice)()
-src
# -*- coding: utf-8 -*-
'''
用户视图层的主视图
'''
from core import admin
from core import student
from core import teacher
func_dict = {
"1":admin.admin_view,
"2":student.student_view,
"3":teacher.teacher_view,
}
def run():
while True:
print('''
=======欢迎来到选课系统======
1.管理员功能
2.学生功能
3.老师功能
=============end==========''')
choice = input("请输入功能编号:").strip()
if choice not in func_dict:
print("输入有误，请重新输入")
continue
else:
func_dict.get(choice)()
-student
# -*- coding: utf-8 -*-
'''学生视图'''
from lib import common
from interface import student_interface
from interface import common_interface
student_info = {
"user":None
}
#注册
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("两次密码不一致，请重新输入")
#登录
def login():
while True:
username = input("请输入用户名:").strip()
password = input("请输入密码:").strip()
# 1.调用管理员登录接口
flag, msg = common_interface.login_interface(
username, password,user_type = "student")
if flag:
print(msg)
# 记住当前登录状态
student_info["user"] = username
break
else:
print(msg)
#选择校区
@common.auth("student")
def choice_school():
while True:
#获取所有学校，让学生选择
flag,school_list = common_interface.get_all_school_interface()
if not flag:
print(school_list)
break
for index,school_name in enumerate(school_list):
print(f"编号:{index} 学校名:{school_name}")
#让学生选择输入学校编号
choice = input("请输入选择的学校编号:").strip()
if not choice.isdigit():
print("输入有误")
continue
choice = int(choice)
if choice not in range(len(school_list)):
print("输入编号有误")
continue
school_name = school_list[choice]
#调用学生选择学校接口
msg = student_interface.add_school_interface(
school_name,student_info.get("user"))
print(msg)
break
#选择课程
@common.auth("student")
def choice_course():
while True:
#先获取当前学生所在学校的课程列表
flag,course_list = student_interface.get_course_interface(
student_info.get("user")
)
if not flag:
print(course_list)
break
#打印课程列表并让用户选择课程
for index,course_name in enumerate(course_list):
print(f"编号:{index} 课程名:{course_name}")
#让学生选择输入学校编号
choice = input("请输入选择的课程编号:").strip()
if not choice.isdigit():
print("输入有误")
continue
choice = int(choice)
if choice not in range(len(course_list)):
print("输入编号有误")
continue
#获取选择的课程名
course_name = course_list[choice]
#调用学生选择课程接口
flag,msg = student_interface.add_course_interface(
course_name,student_info.get("user"))
if flag:
print(msg)
break
else:
print(msg)
#查看分数
@common.auth("student")
def check_score():
#直接调用查看分数接口
score_dict = student_interface.check_score_interface(
student_info.get("user")
)
if not score_dict:
print("没有选择课程")
print(score_dict)
func_dict = {
"1": register,
"2":login,
"3": choice_school,
"4": choice_course,
"5": check_score,
}
#学生视图函数
def student_view():
while True:
print('''
-1.注册
-2.登录
-3.选择校区
-4.选择课程
-5.查看分数
''')
choice = input("请输入功能编号:").strip()
if choice == "q":
break
if choice not in func_dict:
print("输入有误，请重新输入")
continue
else:
func_dict.get(choice)()
-teacher
# -*- coding: utf-8 -*-
'''讲师视图'''
from lib import common
from interface import common_interface
from interface import teacher_interface
teacher_info = {
"user":None
}
#登录
def login():
while True:
username = input("请输入用户名:").strip()
password = input("请输入密码:").strip()
# 1.调用管理员登录接口
flag, msg = common_interface.login_interface(
username, password, user_type="teacher")
if flag:
print(msg)
# 记住当前登录状态
teacher_info["user"] = username
break
else:
print(msg)
#查看教授课程
@common.auth("teacher")
def check_course():
flag,course_list = teacher_interface.check_course_interface(
teacher_info.get("user")
)
if flag:
print(course_list)
else:
print(course_list)
#选择教授课程
@common.auth("teacher")
def choose_course():
while True:
#先打印所有学校并选择
flag, school_list = common_interface.get_all_school_interface()
if not flag:
print(school_list)
break
for index, school_name in enumerate(school_list):
print(f"编号:{index} 学校名:{school_name}")
choice = input("请输入选择的学校编号:").strip()
if not choice.isdigit():
print("输入有误")
continue
choice = int(choice)
if choice not in range(len(school_list)):
print("输入编号有误")
continue
#获取选择的学校名称
school_name = school_list[choice]
#从选择的学校中获取所有的课程
flag2,course_list = common_interface.get_course_in_school_interface(school_name)
if not flag2:
print(course_list)
break
for index2, course_name in enumerate(course_list):
print(f"编号:{index2} 课程名:{course_name}")
choice2 = input("请输入选择的课程编号:").strip()
if not choice2.isdigit():
print("输入有误")
continue
choice2 = int(choice2)
if choice2 not in range(len(course_list)):
print("输入编号有误")
continue
# 获取选择的课程名称
course_name = course_list[choice2]
#调用选择教授课程接口将该课程添加到老师课程列表中
flag3,msg = teacher_interface.add_course_interface(
course_name,teacher_info.get("user")
)
if flag3:
print(msg)
break
else:
print(msg)
#查看课程下学生
@common.auth("teacher")
def check_stu_from_course():
while True:
#调用获取当前老师下所有的课程接口
flag, course_list = teacher_interface.check_course_interface(
teacher_info.get("user")
)
if not flag:
break
#打印所有课程并让老师选择
for index, course_name in enumerate(course_list):
print(f"编号:{index} 课程名:{course_name}")
choice = input("请输入选择的课程编号:").strip()
if not choice.isdigit():
print("输入有误")
continue
choice = int(choice)
if choice not in range(len(course_list)):
print("输入编号有误")
continue
# 获取选择的课程名称
course_name = course_list[choice]
#利用当前课程名称获取所有学生
flag2,student_list = teacher_interface.get_student_interface(
course_name,teacher_info.get("user"))
if flag2:
print(student_list)
break
else:
print(student_list)
break
#修改学生分数
@common.auth("teacher")
def change_score_from_student():
#先获取老师下所有的课程并选择
#获取选择的课程下所有的学生，并选择修改的学生
while True:
# 调用获取当前老师下所有的课程接口
flag, course_list = teacher_interface.check_course_interface(
teacher_info.get("user")
)
if not flag:
break
# 打印所有课程并让老师选择
for index, course_name in enumerate(course_list):
print(f"编号:{index} 课程名:{course_name}")
choice = input("请输入选择的课程编号:").strip()
if not choice.isdigit():
print("输入有误")
continue
choice = int(choice)
if choice not in range(len(course_list)):
print("输入编号有误")
continue
# 获取选择的课程名称
course_name = course_list[choice]
# 利用当前课程名称获取所有学生
flag2, student_list = teacher_interface.get_student_interface(
course_name, teacher_info.get("user"))
if not flag2:
print(student_list)
break
#打印所有学生让老师选择
for index2,student_name in enumerate(student_list):
print(f"编号:{index2} 学生名:{student_name}")
choice2 = input("请输入学生编号:").strip()
if not choice2.isdigit():
print("输入有误")
continue
choice2 = int(choice2)
if choice2 not in range(len(student_list)):
print("输入编号有误")
continue
student_name = student_list[choice2]
#老师输入需要修改的分数
score = input("请输入需要修改的成绩:").strip()
if not score.isdigit():
continue
score = int(score)
#调用修改学生分数接口，修改学生分数
flag3,msg = teacher_interface.change_score_interface(
course_name,student_name,score,teacher_info.get("user")
)
if flag3:
print(msg)
break
func_dict = {
"1":login,
"2":check_course,
"3":choose_course,
"4":check_stu_from_course,
"5":change_score_from_student,
}
#老师视图函数
def teacher_view():
while True:
print('''
-1.登录
-2.查看教授课程
-3.选择教授课程
-4.查看课程下学生
-5.修改学生分数
''')
choice = input("请输入功能编号:").strip()
if choice == "q":
break
if choice not in func_dict:
print("输入有误，请重新输入")
continue
else:
func_dict.get(choice)()
db
-db_handler
# -*- coding: utf-8 -*-
'''用于保存对象与获取对象'''
import os,pickle
from conf import settings
#保存数据
def save_data(obj):
#1.获取对象的保存文件+路径
#以类名当作文件夹的名字
#obj.__class__获取当前对象的类
#obj.__class__.__name__获取类的名字
class_name = obj.__class__.__name__
user_dir_path = os.path.join(
settings.DB_PATH,class_name
)
#2.判断文件夹是否存在，不存在则创建文件夹
if not os.path.exists(user_dir_path):
os.mkdir(user_dir_path)
#3.拼接当前用户的pickle文件路径，以用户名作为文件名
user_path = os.path.join(
user_dir_path,obj.user #当前用户名字
)
#打开文件，保存对象，通过pickle处理
with open(user_path,"wb") as f:
pickle.dump(obj,f)
#查看数据
def select_data(cls,username): #Admin,username
#由cls类获取类名
class_name = cls.__name__
user_dir_path = os.path.join(
settings.DB_PATH, class_name
)
# 2.判断文件夹是否存在，不存在则创建文件夹
if not os.path.exists(user_dir_path):
os.mkdir(user_dir_path)
# 3.拼接当前用户的pickle文件路径，以用户名作为文件名
user_path = os.path.join(
user_dir_path, username # 当前用户名字
)
#4.判断文件如果存在，打开并返回，若不存在，则代表用户不存在
if os.path.exists(user_path):
# 5.打开文件，获取对象，通过pickle处理
with open(user_path, "rb") as f:
obj = pickle.load(f)
return obj
return None
-models
# -*- coding: utf-8 -*-
from db import db_handler
'''用于存放类的
学校、学员、课程、讲师、管理员'''
#父类,让所有子类继承select与sava方法
class Base():
#查看数据
@classmethod
def select(cls,username): #Admin,username
#对象 or none
obj = db_handler.select_data(cls,username)
return obj
#保存数据
def save(self):
#让db_handler中的save_data帮我保存对象数据
db_handler.save_data(self)
#管理员类
class Admin(Base):
#调用类的时候触发
#username,password
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,school_obj,course_name):
#1.调用课程类，实例化创建课程
course_obj = Course(course_name)
course_obj.save()
#2.调用当前学校对象，并将课程添加到课程列表中
school_obj.course_list.append(course_name)
#3.更新学校数据
school_obj.save()
#创建讲师
def create_teacher(self,teacher_name,teacher_pwd):
#1.调用老师类实例化，得到老师对象并保存
teacher_obj = Teacher(teacher_name,teacher_pwd)
teacher_obj.save()
#学校类
class School(Base):
def __init__(self,name,addr):
#self.user，因为db_handler里面的select_data统一规范
self.user = name
self.addr = addr
#课程列表：每所学校都有相应的课程
self.course_list = []
#学生类
class Student(Base):
def __init__(self,user,pwd):
self.user = user
self.pwd = pwd
#每个学生只能有一个校区
self.school = None
#一个学生可以选择多门课程
self.course_list = []
#学生课程分数
self.score_dict = {} #{course_name:0}
#学生添加学校方法
def add_school(self,school_name):
self.school = school_name
self.save()
#学生添加课程方法
def add_course(self,course_name):
#学生课程列表添加课程
self.course_list.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()
#课程类
class Course(Base):
def __init__(self,course_name):
self.user = course_name
self.student_list = []
#老师类
class Teacher(Base):
def __init__(self,teacher_name,teacher_pwd):
self.user = teacher_name
self.pwd = teacher_pwd
self.course_list_from_teacher = []
#老师查看教授课程方法
def show_course(self):
return self.course_list_from_teacher
#老师添加课程方法
def add_course(self,course_name):
self.course_list_from_teacher.append(course_name)
self.save()
#老师获取课程下学生方法
def get_student(self,course_name):
course_obj = Course.select(course_name)
return course_obj.student_list
#老师修改学生分数方法
def change_score(self,course_name,student_name,score):
#获取学生对象
student_obj = Student.select(student_name)
#再给学生对象中的某课程修该分数
student_obj.score_dict[course_name] = score
student_obj.save()
interface
-admin_interface
# -*- coding: utf-8 -*-
'''管理员接口'''
from db import models
#管理员注册接口
def admin_register_interface(username,password):
#1.判断用户是否存在
#调用admin类中的select方法，由该方法调用db_handler中的select_data中的功能获取对象
admin_obj = models.Admin.select(username)
#1.1若存在不允许注册，返回用户已存在给视图层
if admin_obj:
return False,"用户已存在"
#1.2若不存在则允许注册，调用类实例化得到对象并保存
admin_obj = models.Admin(username, password)
#对象调用save()会将obj传入save方法
admin_obj.save()
return True,"注册成功"
#管理员登录接口
'''
def admin_login_interface(username,password):
#1.判断用户是否存在
admin_obj = models.Admin.select(username)
#2.若用户不存在，则证明用户不存在，并返回视图层
if not admin_obj:
return False,"用户名不存在"
#3.若用户存在，则校验密码
if password == admin_obj.pwd:
return True,"登录成功"
else:
return False,"密码错误"
'''
#管理员创建学校接口
def create_school_interface(school_name,school_addr,admin_name):
#1.查看当前学校是否已存在
#school_obj -->对象，none
school_obj = models.School.select(school_name)
#2.若学校存在则返回false，告诉用户学校已存在
if school_obj:
return False,"该学校已存在"
#3.若不存在则创建学校，注意：（由管理员对象创建）
admin_obj = models.Admin.select(admin_name)
#由管理员调用学校方法并传入学校名字与地址
admin_obj.create_school(
school_name, school_addr
)
#4.返回创建学校成功给视图层
return True,f"{school_name}学校创建成功"
#管理员创建课程接口
def create_course_interface(school_name,course_name,admin_name):
#1.查看课程是否存在
# 1.1先获取学校中的课程列表
school_obj = models.School.select(school_name)
#1.2判断当前课程是否存在课程列表中
if course_name in school_obj.course_list:
return False,"当前课程已存在"
#1.3若课程不存在则创建课程
admin_obj = models.Admin.select(admin_name)
admin_obj.create_course(
school_obj,course_name
)
return True,f"{course_name}课程创建成功，绑定给{school_name}校区"
#管理员创建老师接口
def create_teacher_interface(teacher_name,admin_name,teacher_pwd = "123"):
#1.判断老师是否存在
teacher_obj = models.Teacher.select(teacher_name)
#2.若存在，则返回不能创建
if teacher_obj:
return False,"老师已存在"
#3.若不存在，让管理员创建
admin_obj = models.Admin.select(admin_name)
admin_obj.create_teacher(teacher_name,teacher_pwd)
return True,f"{teacher_name}老师创建成功"
-common_interface
# -*- coding: utf-8 -*-
'''公共接口'''
import os
from conf import settings
from db import models
#获取所有学校名称接口
def get_all_school_interface():
#1.获取学校文件夹路径
school_dir = os.path.join(settings.DB_PATH,"School")
#2.判断文件夹是否存在
if not os.path.exists(school_dir):
return False,"没有学校，请先联系管理员"
#3.文件夹若存在则获取文件夹中所有名字
school_list = os.listdir(school_dir)
return True,school_list
#公共登录接口
def login_interface(user,pwd,user_type):
if user_type == "admin":
obj = models.Admin.select(user)
elif user_type == "student":
obj = models.Student.select(user)
elif user_type == "teacher":
obj = models.Teacher.select(user)
else:
return False,"登录角色不对，请输入角色"
#1.判断用户是否存在
if obj:
# 2.若用户存在，则校验密码
if pwd == obj.pwd:
return True, "登录成功"
else:
return False, "密码错误"
else:
#3.若用户不存在，则证明用户不存在，并返回视图层
return False,"用户名不存在"
#获取学校下所有课程接口
def get_course_in_school_interface(school_name):
#获取学校对象
school_obj = models.School.select(school_name)
#获取学校对象下所有课程
course_list= school_obj.course_list
if not course_list:
return False,"该学校没有课程"
return True,course_list
-student_interface
# -*- coding: utf-8 -*-
'''学生接口层'''
from db import models
#学生注册接口
def student_register_interface(user,pwd):
#1.判断用户是否存在
#调用student类中的select方法，由该方法调用db_handler中的select_data中的功能获取对象
student_obj = models.Student.select(user)
#1.1若存在不允许注册，返回用户已存在给视图层
if student_obj:
return False,"学生用户已存在"
#1.2若不存在则允许注册，调用类实例化得到对象并保存
student_obj = models.Student(user,pwd)
#对象调用save()会将obj传入save方法
student_obj.save()
return True,"注册成功"
#学生登录接口
'''
def studnet_login_interface(user,pwd):
#1.判断用户是否存在
student_obj = models.Student.select(user)
#2.若用户不存在，则证明用户不存在，并返回视图层
if not student_obj:
return False,"用户名不存在"
#3.若用户存在，则校验密码
if pwd == student_obj.pwd:
return True,"登录成功"
else:
return False,"密码错误"
'''
#学生选择学校接口
def add_school_interface(school_name,student_name):
#判断当前学生是否存在学校
student_obj = models.Student.select(student_name)
if student_obj.school:
return "当前学生已经选择过学校了"
#若不存在学校，则调用学生对象中选择学校的方法，实现学生添加学校
student_obj.add_school(school_name)
return "选择学校成功"
#获取学生所在所有课程接口
def get_course_interface(student_name):
#获取当前学生对象
student_obj = models.Student.select(student_name)
school_name = student_obj.school
#判断当前学生是否有学校，若没有则返回false
if not school_name:
return False,"没有学校,请先选择学校"
#开始获取学校对象中的课程列表
school_obj = models.School.select(school_name)
#判断当前学校中是否有课程，若没有则联系管理员
if not school_obj.course_list:
return False,"没有课程,请先联系管理员创建"
#若有则返回课程列表
return True,school_obj.course_list
#学生选择课程接口
def add_course_interface(course_name,student_name):
#先判断当前课程是否已经存在学生课程列表中
student_obj = models.Student.select(student_name)
if course_name in student_obj.course_list:
return False,"该课程已经选择过了"
#调用学生对象中添加课程的方法
student_obj.add_course(course_name)
return True,f"{course_name}课程添加成功"
#学生查看分数接口
def check_score_interface(student_name):
student_obj = models.Student.select(student_name)
if student_obj.score_dict:
return student_obj.score_dict
-teacher_interface
# -*- coding: utf-8 -*-
'''老师接口层'''
#老师查看课程接口
from db import models
def check_course_interface(teacher_name):
#获取当前老师对象
teacher_obj = models.Teacher.select(teacher_name)
#判断老师对象中课程列表是否有值，若有则返回True，无则返回False
# 让老师对象调用查看教授课程方法，返回课程
course_list = teacher_obj.show_course()
if not course_list:
return False,"老师没有选择课程"
return True,course_list
#老师添加课程接口
def add_course_interface(course_name,teacher_name):
#先获取当前老师对象
teacher_obj = models.Teacher.select(teacher_name)
#判断当前课程是否在老师的课程列表中
course_list = teacher_obj.course_list_from_teacher
if course_name in course_list:
return False,"该课程已存在"
#若不存在则添加该课程到老师的课程列表中
teacher_obj.add_course(course_name)
return True,"添加课程成功"
#老师查看获取课程下学生接口
def get_student_interface(course_name,teacher_name):
#获取当前老师对象
teacher_obj = models.Teacher.select(teacher_name)
#让当前老师对象调用获取课程下学生内容
student_list = teacher_obj.get_student(course_name)
#判断课程下是否有学生
if not student_list:
return False,"学生没有选择该课程"
return True,student_list
#老师修改分数接口
def change_score_interface(course_name,student_name,score,teacher_name):
#获取老师对象
teacher_obj = models.Teacher.select(teacher_name)
#让老师对象调用修改分数方法
teacher_obj.change_score(course_name,student_name,score)
return True,"修改分数成功"
lib
-common
# -*- coding: utf-8 -*-
'''公共方法'''
#登录认证装饰器
#多用户认证装饰器
def auth(role):
'''
:param role: 角色 --》管理员，学生，老师
:return:
'''
from core import admin,student,teacher
def login_auth(func):
def inner(*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 inner
return login_auth
-start
'''启动文件入口'''
import os,sys
sys.path.append(os.path.dirname(__file__))
from core import src
if __name__ == '__main__':
src.run()
read_me.md
角色: 学校、学员、课程、讲师、管理员
要求:
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.程序架构设计
-三层架构(MVC)
-用户视图层
-用于与用户进行交互
-小的逻辑判断，比如注册功能中两次密码是否一致的校验
-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()
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():
course_obj = Course()
course_obj.save
school_obj.course_list.append(course_name)
#管理员创建老师方法
-create_teacher(self,teacher_name,teacher_pwd):
teacher_obj = Teacher(teacher_name,teacher_pwd)
teacher_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分数字典进行修改
扫一扫
3012
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
