python选课系统作业

# 选课系统
# 角色:学校、学员、课程、讲师
# 要求:
# 1. 创建北京、上海 2 所学校
# 2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
# 3. 课程包含，周期，价格，通过学校创建课程
# 4. 通过学校创建班级， 班级关联课程、讲师
# 5. 创建学员时，选择学校，关联班级
# 5. 创建讲师角色时要关联学校，
# 6. 提供两个角色接口
    # 6.1 学员视图， 可以登录，注册， 选择学校，选择课程，查看成绩
    # 6.2 讲师视图， 讲师登录，选择学校，选择课程， 查看课程下学员列表 ， 修改所管理的学员的成绩
    # 6.3 管理视图，登录，注册，创建讲师， 创建班级，创建课程，创建学校
# 7. 上面的操作产生的数据都通过pickle序列化保存到文件里

分析：

角色：
    管理员：
        注册
        登录
        创建校区
        创建老师
        创建课程

    老师：
        登录
        选择教授课程
        查看课程下学生
        修改学生的成绩

    学生：
        注册
        登录
        选择校区
        选择课程
        查看成绩

类：
    抽出共有属性方法：Base
    学校：School
    学员：Student
    课程：Course
    讲师：Teacher

各个类属性和方法：

Base：
    公用方法：
    存数据：save
    取数据：select

学校：
    属性：
       学校名字：school_name   str
       学校地址：school_addr   str
       开设的课程：course_list  list

学员：
    属性：
        学员名字：student_name  str
        学员密码：student_pwd   str
        学员所属校区：school     str
        学员课程： course_list   list
        学员成绩： course_score   dict

     方法：
        学员选择校区  choose_school(school_name)
            列出所有校区的信息，学员选择
        学员选择课程  choose_course(school_name)
            学员必须先选择校区，列出该校区包含的课程
            选择相应的课程，添加到学员课程列表中，并且将用户绑定给课程

讲师：
    属性：
        讲师名字：teacher_name str
        讲师密码：teacher_pwd  str
        讲师课程: course_list  list

    方法：
        讲师选择课程： choose_course(school_name, course_name)
            先选择校区，列出该校区所有课程，讲师选择课程，如果没有选过，则添加
        讲师修改学生的成绩：change_student_score(course, student_name)
            通过自身对象中的课程列表，选择相应课程，调用课程下的所有学生信息，更改学生成绩

管理员:
    属性：
        管理员的名字：admin_name  str
        管理员的密码：admin_pwd   str

    方法：
        管理员创建学校： create_school(school_name,school_addr)
            直接输入学校的名字和地址，然后判断学校是否存在，不存在，则创建
        管理员创建讲师:  create_teacher(teacher_name)
            直接创建讲师，密码为默认
        管理员创建课程： create_course(school_name, course_name)
            先选择校区，再创建课程名字，如果不存在，则创建这个课程

那个角色登陆了就执行那个角色的功能
进入到角色选项里面了可以随时退出

下面是程序说明程图
-------------------------------------------------------------

目录结构图

一 ，下面是业务逻辑代码

1.conf下settings.py下代码

 import os

 BASE_DIR = os.path.dirname(os.path.dirname(__file__))
 BASE_DB = os.path.join(BASE_DIR, 'db')

2.core下admin.py代码

 from interface import student_interface, teacher_interface, admin_interface, common_interface
 from lib import common

 admin_info = {
     'name': None
 }

 def admin_register():
     print('管理员注册')
     if admin_info['name']:
         print('管理员已经登陆了不能注册')
         return
     while True:
         name = input('请输入名字：').strip()
         password = input('请输入密码：').strip()
         conf_password = input('请确认密码：').strip()
         if password == conf_password:
             flag, msg = admin_interface.admin_register_interface(name, password)
             if flag:
                 print(msg)
                 break
             else:
                 print(msg)
         else:
             print('两次密码不一致')

 def admin_login():
     print('管理员登陆')
     if admin_info['name']:
         print('管理员已经登陆了不能重复登陆')
         return
     while True:
         name = input('请输入名字: ').strip()
         password = input('请输入密码: ').strip()
         flag, msg = common_interface.login_interface(name, password, 'admin')
         if flag:
             admin_info['name'] = name
             print(msg)
             break
         else:
             print(msg)

 @common.login_auth(user_type='admin')
 def create_school():
     print('创建学校')
     school_name = input('请输入学校名字: ').strip()
     address = input('请输入学校地址: ').strip()
     flag, msg = admin_interface.create_school_interface(admin_info['name'], school_name,address)
     if flag:
         print(msg)
     else:
         print(msg)

 @common.login_auth(user_type='admin')
 def create_teacher():
     print('创建老师')
     name = input('请输入老师名字: ').strip()
     flag, msg = admin_interface.create_teacher_interface(admin_info['name'], name)
     if flag:
         print(msg)
     else:
         print(msg)

 @common.login_auth(user_type='admin')
 def create_course():
     print('创建课程')
     while True:
         school_list = common_interface.check_all_schools()
         if school_list:
             for i, school in enumerate(school_list):
                 print('%s: %s' % (i, school))
             choose = input('请选择学校: ').strip()
             if choose.isdigit():
                 choose = int(choose)
                 if choose >= len(school_list):
                     continue
         name = input('请输入课程名字:').strip()
         flag, msg = admin_interface.create_course_interface(admin_info['name'], name, school_list[choose])
         if flag:
             print(msg)
             break
         else:
             print(msg)

 func_dic = {
     '': admin_register,
     '': admin_login,
     '': create_school,
     '': create_teacher,
     '': create_course,
 }

 def admin_view():
     while True:
         print("""
         1 注册
         2 登陆
         3 创建学校
         4 创建老师
         5 创建课程
         """)

         choice = input('请选择功能：').strip()
         if choice == 'q' and 'Q':
             break

         if choice not in func_dic:
             continue

         func_dic[choice]()

3.core下student.py代码

 from interface import student_interface, common_interface
 from lib import common

 student_info = {
     'name': None
 }

 def student_register():
     print('学生注册')
     if student_info['name']:
         print('已经登陆了不能在注册了')
         return
     while True:
         name = input('请输入学生名字: ').strip()
         password = input('请输入学生密码').strip()
         conf_password = input('请确认密码: ').strip()
         if password == conf_password:
             flag, msg = student_interface.student_register_interface(name, password)
             if flag:
                 print(msg)
                 break
             else:
                 print(msg)
         else:
             print('两次密码不一致')

 def student_login():
     print('学生登陆')
     if student_info['name']:
         print('已经登陆了不能重复登陆')
         return
     while True:
         name = input('请输入学生名字: ').strip()
         password = input('请输入学生密码: ').strip()
         flag, msg = common_interface.login_interface(name, password, 'student')
         if flag:
             print(msg)
             student_info['name'] = name
             break
         else:
             print(msg)

 @common.login_auth('student')
 def choose_school():
     print('选择学校')
     school_list = common_interface.check_all_schools()
     if not school_list:
         print('请联系管理员创建学校')
         return
     for i, school in enumerate(school_list):
         print('%s; %s' % (i, school))
     choice = input('请选择学校: ').strip()
     if choice.isdigit():
         choice = int(choice)
         if choice < len(school_list):
             flag, msg = student_interface.choice_school_interface(student_info['name'], school_list[choice])
             print(msg)

 @common.login_auth('student')
 def choose_course():
     print('选择课程')
     flag, course_list = student_interface.get_can_choose_course_interface(student_info['name'])
     if not flag:
         print(course_list)
         return
     for i, course in enumerate(course_list):
         print('%s: %s' % (i, course))
     choice = input('请选择课程').strip()
     if choice.isdigit():
         choice = int(choice)
         if choice < len(course_list):
             _, msg = student_interface.choose_course_interface(student_info['name'], course_list[choice])
             print(msg)
         else:
             print('请选择已经存在的课程')
     else:
         print('必须要输入数字')

 @common.login_auth('student')
 def check_score():
     print('查看分数')
     course_score_dict = student_interface.check_score_interface(student_info['name'])
     print(course_score_dict)

 func_dic = {
     '': student_register,
     '': student_login,
     '': choose_school,
     '': choose_course,
     '': check_score,
 }

 def student_view():
     while True:
         print("""
         1 注册
         2 登陆
         3 选择学校
         4 选择课程
         5 查看成绩
         """)

         choice = input('请选择功能：').strip()
         if choice == 'q' and 'Q':
             break
         if choice not in func_dic:
             continue
         func_dic[choice]()

4.core下teacher.py代码

 from interface import common_interface, teacher_interface
 from lib import common

 teacher_info = {
     'name': None
 }

 def teacher_login():
     print('老师登陆')
     if teacher_info['name']:
         print('老师已经登陆了不能重复登陆')
         return
     while True:
         name = input('请输入老师名字: ').strip()
         password = input('请输入老师密码: ').strip()
         flag, msg = common_interface.login_interface(name, password, 'teacher')
         if flag:
             print(msg)
             teacher_info['name'] = name
             break
         else:
             print(msg)

 @common.login_auth('teacher')
 def choose_teach_course():
     print('选择要教授的课程')
     while True:
         course_list = teacher_interface.get_all_course()
         if not course_list:
             print('现在还没有课程,请联系管理员创建课程')
             break
         else:
             for i, course_list in enumerate(course_list):
                 print('%s; %s' % (i, course_list))
                 choice = input('请选择课程: ').strip()
                 if choice.isdigit():
                     choice = int(choice)
                     if choice >= len(course_list): continue
                     flag, msg = teacher_interface.choose_teacher_course_interface(teacher_info['name'], course_list[choice])
                     if flag:
                         print(msg)
                         break
                     else:
                         print(msg)
                 else:
                     print('必须输入数字')

 @common.login_auth('teacher')
 def check_course():
     print('查看教授的课程')
     course_list = teacher_interface.check_all_teacher_course(teacher_info['name'])
     if course_list:
         for course in course_list:
             print(course)
     else:
         print('你还没有选择课程, 先去选择课程吧')

 @common.login_auth('teacher')
 def check_student():
     count = 0
     print('查看学生')
     course_list = teacher_interface.check_all_teacher_course(teacher_info['name'])
     if course_list:
         for i, course in enumerate(course_list):
             print(i, course)
         choice = input('选择要查看课程下的学生: ').strip()
         if choice.isdigit():
             choice = int(choice)
             if choice < len(course_list):
                 student_list = teacher_interface.check_student_in_course(course_list[choice])
                 for j, student in enumerate(student_list):
                     count += j
                     print('%s : %s 一共有%s个学生' % (j, student, count))
             else:
                 print('请选择的课程')
         else:
             print('请输入数字')

 @common.login_auth('teacher')
 def modify_score():
     count = 0
     print('查看学生')
     course_list = teacher_interface.check_all_teacher_course(teacher_info['name'])
     if course_list:
         for i, course in enumerate(course_list):
             print(i, course)
         choice = input('选择要查看课程下的学生: ').strip()
         if choice.isdigit():
             choice = int(choice)
             if choice < len(course_list):
                 student_list = teacher_interface.check_student_in_course(course_list[choice])
                 for j, student in enumerate(student_list):
                     count += j
                     print('%s : %s 一共有%s个学生' % (j, student, count))
                 choose = input('请选择学生: ').strip()
                 if choose.isdigit():
                     choose = int(choose)
                     if choose < len(student_list):
                         score = input('请输入学生要修改的的分数: ').strip()
                         if score.isdigit():
                             score = int(score)
                             flag, msg = teacher_interface.modify_score(teacher_info['name'],
                                                                        course_list[choice],
                                                                        student_list[choose], score)
                             print(msg)
                         else:
                             print('分数必须输入数字')
                     else:
                         print('请选择存在的学生')
             else:
                 print('请选择存在的课程')
         else:
             print('请输入数字')
     else:
         print('请选择课程')

 func_dic = {
     '': teacher_login,
     '': choose_teach_course,
     '': check_course,
     '': check_student,
     '': modify_score,
 }

 def teacher_view():
     while True:
         print("""
         1 登陆
         2 选择课程
         3 查看课程
         4 查看学生
         5 修改学生成绩
         """)

         choice = input('请选择功能：').strip()
         if choice == 'q' and 'Q':
             break
         if choice not in func_dic:
             continue
         func_dic[choice]()

5.core下src.py代码

 from core import admin, student, teacher

 func_dic = {
     '': admin.admin_view,
     '': student.student_view,
     '': teacher.teacher_view

 }

 def run():
     while True:
         print("""
         1 管理员视图
         2 学生视图
         3 老师视图
         """)
         choice = input('请选择：').strip()
         if choice not in func_dic:
             continue
         func_dic[choice]()

二 ，下面是db文件代码

1.db_handler.py代码

 from conf import settings
 import os
 import pickle

 def save(obj):
     path_dir = os.path.join(settings.BASE_DB, obj.__class__.__name__.lower())
     if not os.path.isdir(path_dir):
         os.mkdir(path_dir)
     path_obj = os.path.join(path_dir, obj.name)
     with open(path_obj, 'wb') as f:
         pickle.dump(obj, f)

 def select(name, dir_type):
     path_dir = os.path.join(settings.BASE_DB, dir_type)
     if not os.path.isdir(path_dir):
         os.mkdir(path_dir)
     path_obj = os.path.join(path_dir, name)
     if os.path.exists(path_obj):
         with open(path_obj, 'rb')as f:
             return pickle.load(f)
     else:
         return None

2.modles.py

 from db import db_handler

 class BaseClass:
     def save(self):
         db_handler.save(self)

     @classmethod
     def get_obj_by_name(cls, name):
         return db_handler.select(name, cls.__name__.lower())

 class Admin(BaseClass):
     def __init__(self, name, password):
         self.name = name
         self.password = password
         self.save()

     def create_school(self, school_name, addr):
         School(school_name, addr)

     def create_course(self, name):
         Course(name)

     def create_teacher(self, name, password):
         Teacher(name, password)

 class Teacher(BaseClass):
     def __init__(self, name, password):
         self.name = name
         self.password = password
         self.course_list = []
         self.save()

     def add_course(self, course_name):
         self.course_list.append(course_name)
         self.save()

     def modify_score(self, student, course_name, score):
         student.score[course_name] = score
         student.save()

 class Student(BaseClass):
     def __init__(self, name, password):
         self.name = name
         self.password = password
         self.score = {}
         self.school = None
         self.course_list = []
         self.save()

     def get_school(self):
         return self.school

     def choose_school(self, school_name):
         self.school = school_name
         self.save()

     def add_course(self, course_name):
         self.course_list.append(course_name)
         self.score[course_name] = 0
         self.save()

 class School(BaseClass):
     def __init__(self, name, addr):
         self.name = name
         self.addr = addr
         self.course_list = []
         self.save()

     def add_course(self, course_name):
         self.course_list.append(course_name)
         self.save()

 class Course(BaseClass):
     def __init__(self, name):
         self.name = name
         self.student_list = []
         self.save()

 

三 ，下面是接口api文件 interface

1.admin_interface

 from db import modles

 def admin_register_interface(name, password):
     admin_obj = modles.Admin.get_obj_by_name(name)
     if admin_obj:
         return False, '管理员已经存在'
     else:
         modles.Admin(name, password)
         return True, '注册成功'

 def create_school_interface(admin_name, school_name, addr):
     school_obj = modles.School.get_obj_by_name(school_name)
     if school_obj:
         return False, '学校已经存在'
     else:
         admin_obj = modles.Admin.get_obj_by_name(admin_name)
         admin_obj.create_school(school_name, addr)
         return True, '学校创建成功'

 def create_teacher_interface(admin_name, name, password = ''):
     obj = modles.Teacher.get_obj_by_name(name)
     if obj:
         return False, '老师已经存在'
     else:
         admin_obj = modles.Admin.get_obj_by_name(admin_name)
         admin_obj.create_teacher(name, password)
         return True, '老师创建成功'

 def create_course_interface(admin_name, course_name, school_name):
     obj = modles.Course.get_obj_by_name(course_name)
     if obj:
         return False, '课程已经存在'
     else:
         admin_obj = modles.Admin.get_obj_by_name(admin_name)
         admin_obj.create_course(course_name)
         school_obj = modles.School.get_obj_by_name(school_name)
         school_obj.add_course(course_name)
         return True, '课程已经创建成功'

2.common_interface

 from db import modles
 import os
 from conf import settings
 from lib import common

 def login_interface(name, password, user_type):
     if user_type == 'admin':
         obj = modles.Admin.get_obj_by_name(name)
     elif user_type == 'teacher':
         obj = modles.Teacher.get_obj_by_name(name)
     elif user_type == 'student':
         obj = modles.Student.get_obj_by_name(name)
     else:
         return False, '没有这个用户类型'
     if obj:
         if obj.name == name and obj.password == password:
             return True, '%s: %s 登陆成功' % (user_type, name)
         else:
             return False, '密码不对'

     else:
         return False, '用户不存在'

 def check_all_schools():
     path = os.path.join(settings.BASE_DB, 'school')
     return common.get_all_dir_obj(path)

 def choose_course_interface(student_name, course_name):
     obj = modles.Student.get_obj_by_name(student_name)
     obj.add_course(course_name)
     return True, '选课成功'

3.student_interface

 from db import modles

 def student_register_interface(name, password):
     student_obj = modles.Student.get_obj_by_name(name)
     if student_obj:
         return False, '学生已经存在'
     else:
         modles.Student(name, password)
         return True, '注册成功'

 def choice_school_interface(student_name, school_name):
     student_obj = modles.Student.get_obj_by_name(student_name)
     school = student_obj.get_school()
     if not school:
         student_obj.choose_school(school_name)
         return True, '%s: 选择学校成功' % (student_name)
     else:
         return False, '已经选择学校了, 不能重复选择学校'

 def get_can_choose_course_interface(student_name):
     student_obj = modles.Student.get_obj_by_name(student_name)
     if not student_obj.school:
         return False, '你没有选择学校,请先选择学校'
     school_obj = modles.School.get_obj_by_name(student_obj.school)
     if school_obj.course_list:
         return True, school_obj.course_list
     else:
         return False, "该学校下没有课程"

 def choose_course_interface(student_name, course_name):
     obj = modles.Student.get_obj_by_name(student_name)
     obj.add_course(course_name)
     return True, '选课成功'

 def check_score_interface(student_name):
     obj = modles.Student.get_obj_by_name(student_name)
     return obj.score

 

4.teacher_nterface

 from db import modles
 import os
 from conf import settings
 from lib import common

 def get_all_course():
     path = os.path.join(settings.BASE_DB, 'course')
     return common.get_all_dir_obj(path)

 def choose_teacher_course_interface(teacher_name, course_name):
     teacher_obj = modles.Teacher.get_obj_by_name(teacher_name)
     if course_name not in teacher_obj.course_list:
         teacher_obj.add_course(course_name)
         return True, '选择课程成功'
     else:
         return False, '你已经选择了本门课程'

 def check_all_teacher_course(teacher_name):
     teacher_obj = modles.Teacher.get_obj_by_name(teacher_name)
     return teacher_obj.course_list

 def check_student_in_course(course_name):
     course_obj = modles.Course.get_obj_by_name(course_name)
     return course_obj.student_list

 def modify_score(teacher_name, course_name, student_name, score):
     teacher_obj = modles.Teacher.get_obj_by_name(teacher_name)
     student_obj = modles.Student.get_obj_by_name(student_name)
     teacher_obj.modify_score(student_obj, course_name, score)
     return True, '修改分数成功'

四 ， 下面是lib代码

1.common下代码

 import os

 def login_auth(user_type):
     from core import admin, student, teacher

     def auth(func):

         def wrapper(*args, **kwargs):
             if user_type == 'admin':
                 if not admin.admin_info['name']:
                     admin.admin_login()
                 else:
                     return func(*args, **kwargs)
             if user_type == 'teacher':
                 if not teacher.teacher_info['name']:
                     teacher.teacher_login()
                 else:
                     return func(*args, **kwargs)
             if user_type == 'student':
                 if not student.student_info['name']:
                     student.student_login()
                 else:
                     return func(*args, **kwargs)

         return wrapper

     return auth

 def get_all_dir_obj(path):
     if os.path.exists(path):
         obj_list = os.listdir(path)
         return obj_list
     else:
         return None