选课系统

db>>>db_handler.py

# 思路
save_obj(obj)	# 保存对象
1.先获取对象所在文件路径	
	文件夹名为	obj.__class__.__name__ 	即对象所在类的类名  
2.所在文件夹路径不存在 则创建 os.mkdir()
3.所在文件夹路径存在的话 则拼接对象文件的路径名 保存对象

get_obj(cls, name)	# 获取对象	
1.拼接对象的文件路径	类名文件夹 + 对象名文件
2.路径存在则返回对象名	return obj

get_all_obj(cls)	# 获取全部对象
1.拼接文件夹路径	文件夹名 cls.__name__	
2.返回文件夹下所有文件名 	return os.listdir(file_path)

from conf import settings
import os
import pickle


def save_obj(obj):
    # 1.获取当前对象所在文件夹路径、因为保存的为对象肯定有其所属的类
    # 所属类名作为其所在文件夹 
    file_path = os.path.join(settings.DB_DIR, obj.__class__.__name__)
    # 2.判断路径是否存在
    if not os.path.exists(file_path):
        os.mkdir(file_path)
    # 3.存在则拼接对象的文件路径
    obj_file_path = os.path.join(file_path, obj.name)
    with open(obj_file_path, 'wb') as f:
        pickle.dump(obj, f)


def get_obj(cls, name):
    # 1.拼接对象的文件路径
    obj_file_path = os.path.join(settings.DB_DIR, cls.__name__, name)
    # 2.判断对象路径是否存在
    if os.path.exists(obj_file_path):
        with open(obj_file_path, 'rb') as f:
            obj = pickle.load(f)
            return obj


def get_all_obj(cls):
    # 1.拼接文件夹路径
    file_path = os.path.join(settings.DB_DIR, cls.__name__)
    if os.path.exists(file_path):
        # 2.列举文件夹下所有文件名称
        return os.listdir(file_path)

db>>>models.py

from db import db_handler


class BaseClass:
    def save(self):		# 保存对象
        db_handler.save_obj(self)	

    @classmethod	# 绑定给类的方法
    def get_obj(cls, name):		# 获取对象
        return db_handler.get_obj(cls, name)

    @classmethod	# 绑定给类的方法
    def get_all_obj(cls):		# 获取全部对象
        return db_handler.get_all_obj(cls)


class Student(BaseClass):
    def __init__(self, name, pwd):	
        self.name = name
        self.pwd = pwd
        self.school = None	
        self.course_list = []
        self.score = {}  # {'课程1':分数, '课程2':分数}
        self.save()


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


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


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


class Admin(BaseClass):
    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd
        self.save()
	
    def create_school(self, school_name, addr):
        return School(school_name, addr)

    def create_course(self, course_name, course_price, course_period):
        return Course(course_name, course_price, course_period)

    def create_teacher(self, teacher_name, pwd):
        return Teacher(teacher_name, pwd)

lib>>>common.py

# 有参装饰器用于验证登录
# 传的参数为用户类型(admin/teacher/student)

def login_auth(user_type):
    def outer(func_name):
        def inner(*args, **kwargs):
            from core import admin_view, student_view, teacher_view
            module_dict = {
                'admin': admin_view,
                'teacher': teacher_view,
                'student': student_view
            }
            # 通过不同的传参查看对应视图登录状态
            module_name = module_dict.get(user_type)
            if module_name.login_status.get('name'):
                res = func_name(*args, **kwargs)
                return res
            else:
                print('%s 暂无登录 请先登录'%user_type)
                module_name.login()
        return inner
    return outer


# 选择功能 （选课/选校/选学生）
# 传入列表根据所选编号取出列表元素
def choose_interface(list):
    for num, name in enumerate(list, start=1):
        print(num, name)
    choice = input('请输入想要选择的编号(q)>>>:').strip()
    if choice == 'q':
        return True, 'q'
    if not choice.isdigit():
        return False, '编号必须是纯数字'
    choice = int(choice)
    if choice not in range(1, len(list) + 1):
        return False, '编号不在范围内 请输入正确编号'
    return True, list[choice - 1]

conf>>>settings.py

import os

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

start.py

# 启动py文件
import os
import sys

sys.path.append(os.path.dirname(__file__))

from core import src

if __name__ == '__main__':
    src.main()

core>>>src.py

# 主视图
from core import admin_view, teacher_view, student_view

view_dict = {
    '1': admin_view,
    '2': teacher_view,
    '3': student_view,
}


def main():
    while True:
        print("""
        ==============选课系统=================
                    1.管理员视图
                    2.讲师视图
                    3.学员视图
        ======================================
        """)
        choice = input('请输入想要载入的视图编号>>>:').strip()
        if choice in view_dict:
            view_name = view_dict.get(choice)
            view_name.main()
        else:
            print('请输入正确的视图编号')

逻辑核心部分

core>>>admin_view.py

# 思路

1.注册：
	input: name pwd 
        传参name pwd调接口register_interface
2.登录
	input: name pwd
        传参name pwd调接口login_interface
    	登录成功则修改登录状态  login_status['name']=当前用户名
3.创建学校
	input: name addr
        调create_school_interface()创建学校信息
4.创建课程
        调get_all_school_interface()获取学校列表
        调choose_interface(学校列表)选择学校
	调create_school_interface()创建课程信息
5.创建讲师
	input: name pwd
        调create_teacher_interface()创建讲师信息

from interface import admin_interface
from lib import common

login_status = {
    'name': None
}


def register():
    name = input('请输入用户名>>>:').strip()
    pwd = input('请输入密码>>>:').strip()
    re_pwd = input('请重复密码>>>:').strip()
    if not re_pwd == pwd:
        print('两次密码不一致')
        return
    flag, msg = admin_interface.register_interface(name, pwd)
    print(msg)


def login():
    name = input('请输入用户名>>>:').strip()
    pwd = input('请输入密码>>>:').strip()
    flag, msg = admin_interface.login_interface(name, pwd)
    if flag:
        login_status['name'] = name
    print(msg)


@common.login_auth('admin')
def create_school():
    name = input('请输入学校名>>>:').strip()
    addr = input('请输入学校地址>>>:').strip()
    flag, msg = admin_interface.create_school_interface(name, addr, login_status.get('name'))
    print(msg)


@common.login_auth('admin')
def create_course():
    # 1.先选择学校 再创建课程
    flag, msg_or_school_obj_list = admin_interface.get_all_school_interface()
    if not flag:
        print(msg_or_school_obj_list)
        return
    # 2.选择学校
    while True:
        
        flag, msg_or_school_name = common.choose_interface(msg_or_school_obj_list)
        if msg_or_school_name == 'q':
            break
        if not flag:
            print(msg_or_school_name)
            continue

        # 3.在该学校下创建课程
        course_name = input('请输入课程名>>>:').strip()
        course_price = input('请输入课程价格(元)>>>:').strip()
        course_period = input('请输入课程课时(月)>>>:').strip()
        flag, msg = admin_interface.create_course_interface(msg_or_school_name,
                                                            course_name,
                                                            course_price,
                                                            course_period,
                                                            login_status.get('name'))
        print(msg)


@common.login_auth('admin')
def create_teacher():
    name = input('请输入讲师用户名>>>:').strip()
    pwd = input('请输入讲师密码>>>:').strip()
    flag, msg = admin_interface.create_teacher_interface(name,
                                                         pwd,
                                                         login_status.get('name'))
    print(msg)




func_dict = {
    '1': register,
    '2': login,
    '3': create_school,
    '4': create_course,
    '5': create_teacher
}


def main():
    while True:
        print("""
        ==============管理员视图=================
        1.注册
        2.登录
        3.创建学校
        4.创建课程
        5.创建讲师
        ======================================
        """)
        choice = input('请输入想要执行的操作编号(q)>>>:').strip()
        if choice == 'q': return
        if choice in func_dict:
            func_name = func_dict.get(choice)
            func_name()
        else:
            print('请输入正确的操作编号')

interface>>>admin_interface.py


from db import models


def register_interface(name, pwd):
    # 1.校验用户名是否存在
    obj = models.Admin.get_obj(name)
    if obj:
        return False, f'管理员 {name} 已存在'
    # 2.不存在则调用接口创建对象并保存
    models.Admin(name, pwd)
    return True, f'{name}注册成功'


def login_interface(name, pwd):
    # 1.获取用户数据
    obj = models.Admin.get_obj(name)
    if not obj:
        return False, '用户名不存在'
    # 2.校验密码
    if obj.pwd == pwd:
        return True, '登录成功'
    return False, '用户名或密码错误'


def create_school_interface(name, addr, admin_name):
    # 1.判断学校是否存在
    school_obj = models.School.get_obj(name)
    if school_obj:
        return False, f'学校 {name} 已存在'
    # 2.不存在则创建
    # 2.1先获取管理员对象 因为需要管理员调用创建功能
    admin_obj = models.Admin.get_obj(admin_name)
    # 2.2管理员调用创建功能
    admin_obj.create_school(name, addr)
    return True, f'管理员: {admin_name} 创建了学校: {name} 地址在: {addr}'


def get_all_school_interface():
    school_obj_list = models.School.get_all_obj()
    if school_obj_list:
        return True, school_obj_list
    return False, '当前没有创建任何学校'


def create_course_interface(school_name, course_name, course_price, course_period, admin_name):
    # 1.先判断课程是否存在
    course_obj_name = f'{school_name}_{course_name}'
    course_obj = models.Course.get_obj(course_obj_name)
    if course_obj:
        return False, f'当前课程：{course_name} 已存在'
    # 2.不存在则管理员创建
    # 2.1先获取管理员对象
    admin_obj = models.Admin.get_obj(admin_name)
    # 2.2管理员创建课程
    admin_obj.create_course(course_obj_name, course_price, course_period)
    # 3.学校添加课程
    # 3.1先获取学校对象
    school_obj = models.School.get_obj(school_name)
    # 3.2学校对象的课程列表里添加课程
    school_obj.course_list.append(course_obj_name)
    # print(school_obj.course_list)
    school_obj.save()
    return True, f'管理员：{admin_name} 在学校：{school_name} 创建了课程：{course_name}'


def create_teacher_interface(name, pwd, admin_name):
    # 1.校验讲师是否已存在
    teacher_obj = models.Teacher.get_obj(name)
    if teacher_obj:
        return False, f'讲师: {name} 已存在'
    # 2.不存在则管理员创建
    admin_obj = models.Admin.get_obj(admin_name)
    admin_obj.create_teacher(name, pwd)
    return True, f'管理员: {admin_name} 成功创建讲师: {name}'

core>>>student_view.py

# 思路
1.注册
2.登录
3.学员选择学校
      调用is_choice_interface() 判断是否已选学校
      未选择则调用 get_all_school_interface()  获取学校列表
      调用choose_interface()  取出选择的学校名
      调用select_school_interface() 绑定信息 给学生school属性修改值
4.学员选择课程
      调用get_school_name() 获取学生所在学校
      调用get_all_course() 获取该校所有的课程
      调用choose_interface() 获取选择的课程名
      调用select_course_interface() 绑定课程  新增学生course_list列表  使成绩默认None
5.学员查看分数
      调用 view_score_interface() 获取返回的score字典

from interface import student_interface
from lib import common

login_status = {
    'name': None
}


def register():
    name = input('请输入用户名>>>:').strip()
    pwd = input('请输入密码>>>:').strip()
    re_pwd = input('请重复密码>>>:').strip()
    if not re_pwd == pwd:
        print('两次密码不一致')
        return
    flag, msg = student_interface.register_interface(name, pwd)
    print(msg)


def login():
    name = input('请输入用户名>>>:').strip()
    pwd = input('请输入密码>>>:').strip()
    flag, msg = student_interface.login_interface(name, pwd)
    if flag:
        login_status['name'] = name
    print(msg)


@common.login_auth('student')
def select_school():
    # 1.先确认是否已选有学校
    is_choice, msg = student_interface.is_choice_interface(login_status.get('name'))
    if is_choice:
        print(msg)
        return
    # 2.获取所有校名供选择
    flag, msg_or_school_list = student_interface.get_all_school_interface()
    if not flag:
        print(msg_or_school_list)
        return
    # 3.选择学校
    while True:
        
        flag, msg_or_school_name = common.choose_interface(msg_or_school_list)
        if msg_or_school_name == 'q':
            break
        if not flag:
            print(msg_or_school_name)
            continue
        # 3.绑定学校信息
        flag, msg = student_interface.select_school_interface(msg_or_school_name, login_status.get('name'))
        print(msg)
        # 因为只能选一次学校 一旦选了就退出
        break


@common.login_auth('student')
def select_course():
    # 1.先获取学生所在学校
    flag, msg_or_school_name = student_interface.get_school_name(login_status.get('name'))
    if not flag:
        # 没选学校
        print(msg_or_school_name)
        return
    # 2.选取当前学校下的课程
    flag, msg_or_course_list = student_interface.get_all_course(msg_or_school_name)
    if not flag:
        # 学校还没有课程
        print(msg_or_course_list)
        return
    # 3.选课
    while True:
       
        flag, msg_or_course_name = common.choose_interface(msg_or_course_list)
        if msg_or_course_name == 'q':
            break
        if not flag:
            print(msg_or_course_name)
            continue
        # 4.绑定课程
        flag, msg = student_interface.select_course_interface(msg_or_course_name, login_status.get('name'))
        print(msg)



@common.login_auth('student')
def view_score():
    flag, score_dict = student_interface.view_score_interface(login_status.get('name'))
    print('学员各科分数字典:',score_dict)


func_dict = {
    '1': register,
    '2': login,
    '3': select_school,
    '4': select_course,
    '5': view_score
}


def main():
    while True:
        print("""
            ==============学员视图=================
            1.注册
            2.登录
            3.学员选择学校
            4.学员选择课程
            5.学员查看分数
            ======================================
            """)
        choice = input('请输入想要执行的操作编号(q)>>>:').strip()
        if choice == 'q': return  # 返回上一层功能选择
        if choice in func_dict:
            func_name = func_dict.get(choice)
            func_name()
        else:
            print('请输入正确的操作编号')

interface>>>student_interface.py

from db import models


def register_interface(name, pwd):
    student_obj = models.Student.get_obj(name)
    if student_obj:
        return False, f'学员: {name} 已存在'
    models.Student(name, pwd)
    return True, f'学员: {name} 注册成功'


def login_interface(name, pwd):
    student_obj = models.Student.get_obj(name)
    if not student_obj:
        return False, '学员不存在'
    if pwd == student_obj.pwd:
        return True, '登录成功'
    return False, '用户名或密码错误'


def is_choice_interface(student_name):
    student_obj = models.Student.get_obj(student_name)
    if not student_obj.school:
        return False, '当前学员还没有选择学校'
    return True, f'当前学员已选择了学校: {student_obj.school}'


def get_all_school_interface():
    school_obj_list = models.School.get_all_obj()
    if school_obj_list:
        return True, school_obj_list
    return '当前还没有学校可选择'


def select_school_interface(school_name, student_name):
    # 给学生对象的school加内容
    student_obj = models.Student.get_obj(student_name)
    student_obj.school = school_name
    student_obj.save()
    return True, f'成功选择学校: {school_name}'


def get_school_name(student_name):
    student_obj = models.Student.get_obj(student_name)
    if student_obj.school:
        return True, student_obj.school
    return False, '还没有选择学校哦 不能选课'


def get_all_course(school_name):
    school_obj = models.School.get_obj(school_name)
    course_list = school_obj.course_list
    if course_list:
        return True, course_list
    return False, '该学校暂无课程'


def select_course_interface(course_name, student_name):
    # 1.要给学生对象的course_list加课程名course_name,给score字典加默认分数
    # 1.1获取学生对象 并判断是否选过这门课了
    student_obj = models.Student.get_obj(student_name)
    if course_name in student_obj.course_list:
        return False, '你已经选过该课了'
    # 1.2没选过就加课
    student_obj.course_list.append(course_name)
    # 1.3score字典加上对应默认分数
    student_obj.score[course_name] = None
    student_obj.save()
    # 2.课程信息上课学生列表也加上该生
    # 2.1获取课程对象
    course_obj = models.Course.get_obj(course_name)
    course_obj.student_list.append(student_name)
    course_obj.save()
    return True, f'成功选课： {course_name}'


def view_score_interface(student_name):
    student_obj = models.Student.get_obj(student_name)
    return True, student_obj.score

core>>>teacher_view.py

# 思路
1.登录
2.查看课程
      调用 get_all_school_interface() 获取全部学校名的列表
      调用 choose_interface()  获取选择的学校名
      调用 get_all_course_interface()  获取学校底下的课程名列表 并打印
3.选择课程
      调用 get_all_school_interface() 获取全部学校名的列表
      调用 choose_interface()  获取选择的学校名
      调用 get_all_course_interface()  获取学校底下的课程名列表 
      调用 choose_interface()   选取课程名
      调用 select_teach_course()  绑定老师 
4.查看学生
      调用 get_teach_course()   获取授课的课程名列表
      调用 choose_interface()   获取指定课程名
      调用 view_selected_students()    获取课程名下的学生名单      
5.设置分数
      调用 get_teach_course()   获取授课的课程名列表
      调用 choose_interface()   获取指定课程名
      调用 view_selected_students()    获取课程名下的学生名单 
      调用 choose_interface()  获取选择的学生名
      调用 update_student_score()  更新学生成绩

from interface import teacher_interface
from lib import common

login_status = {
    'name': None
}


def login():
    name = input('请输入用户名>>>:').strip()
    pwd = input('请输入密码>>>:').strip()
    flag, msg = teacher_interface.login_interface(name, pwd)
    if flag:
        login_status['name'] = name
    print(msg)


@common.login_auth('teacher')
def view_teach_course():
    # 1.先获取学校   存在则拿到整个学校列表 不存在学校返回信息
    flag, msg_or_school_list = teacher_interface.get_all_school_interface()
    if not flag:
        print(msg_or_school_list)
        return

    # 2.选择学校
    while True:
        
        flag, msg_or_school_name = common.choose_interface(msg_or_school_list)
        if msg_or_school_name == 'q':
            break
        if not flag:
            print(msg_or_school_name)
            continue
        # 3.获取该校课程
        flag, msg_or_course_list = teacher_interface.get_all_course_interface(msg_or_school_name)
        for i, course_name in enumerate(msg_or_course_list, start=1):
            print(i, course_name)
        print('==================查看结束====================')


@common.login_auth('teacher')
def select_teach_course():
    # 1.获取学校
    flag, msg_or_school_list = teacher_interface.get_all_school_interface()
    if not flag:
        print(msg_or_school_list)
        return
    # 2.选择学校
    while True:
        
        flag, msg_or_school_name = common.choose_interface(msg_or_school_list)
        if msg_or_school_name == 'q':
            break
        if not flag:
            print(msg_or_school_name)
            continue
        # 3.获取该校课程
        flag, msg_or_course_list = teacher_interface.get_all_course_interface(msg_or_school_name)
        while True:
            
            flag, msg_or_course_name = common.choose_interface(msg_or_course_list)
            if msg_or_course_name == 'q':
                break
            if not flag:
                print(msg_or_course_name)
                continue
            # 4.绑定课程
            flag, msg = teacher_interface.select_teach_course(msg_or_course_name, login_status.get('name'))
            print(msg)


@common.login_auth('teacher')
def view_course_student():
    # 1.先选择课程名
    flag, msg_or_teach_course_list = teacher_interface.get_teach_course(login_status.get('name'))
    if not flag:
        print(msg_or_teach_course_list)
        return
    while True:
       
        flag, msg_or_course_name = common.choose_interface(msg_or_teach_course_list)
        if msg_or_course_name == 'q':
            break
        if not flag:
            print(msg_or_course_name)
            continue
        # 2.获取课程下的学员名单
        flag, msg_or_student_list = teacher_interface.view_selected_students(msg_or_course_name)
        print(msg_or_student_list)


@common.login_auth('teacher')
def update_student_score():
    # 1.先选择课程名
    flag, msg_or_course_list = teacher_interface.get_teach_course(login_status.get('name'))
    if not flag:
        print(msg_or_course_list)
        return
    while True:
        
        flag, msg_or_course_name = common.choose_interface(msg_or_course_list)
        if msg_or_course_name == 'q':
            break
        if not flag:
            print(msg_or_course_name)
            continue
        flag, msg_or_student_list = teacher_interface.view_selected_students(msg_or_course_name)
        if not flag:
            print(msg_or_student_list)
            return
        # 2.获取课程下的学员名单

        while True:

            flag, msg_or_student_name = common.choose_interface(msg_or_student_list)
            if msg_or_student_name == 'q':
                break
            if not flag:
                print(msg_or_student_name)
                continue

            score = input('请输入修改后的成绩>>>:').strip()
            flag, msg = teacher_interface.update_student_score(msg_or_course_name,
                                                               msg_or_student_name,
                                                               login_status.get('name'),
                                                               score)
            print(msg)



func_dict = {
    '1': login,
    '2': view_teach_course,
    '3': select_teach_course,
    '4': view_course_student,
    '5': update_student_score
}


def main():
    while True:
        print("""
            ==============讲师视图=================
            1.登录
            2.查看课程
            3.选择课程
            4.查看学生
            5.设置分数
            ======================================
            """)
        choice = input('请输入想要执行的操作编号(q)>>>:').strip()
        if choice == 'q': return  # 返回上一层功能选择
        if choice in func_dict:
            func_name = func_dict.get(choice)
            func_name()
        else:
            print('请输入正确的操作编号')

interface>>>teacher_interface.py

from db import models


def login_interface(name, pwd):
    teacher_obj = models.Teacher.get_obj(name)
    if not teacher_obj:
        return False, '讲师不存在'
    if pwd == teacher_obj.pwd:
        return True, '登录成功'
    return False, '用户名或密码错误'


def get_all_school_interface():
    school_obj_list = models.School.get_all_obj()
    if not school_obj_list:
        return False, '当前没有创建任何学校'
    return True, school_obj_list


def get_all_course_interface(school_name):
    school_obj = models.School.get_obj(school_name)
    course_obj_list = school_obj.course_list
    if not course_obj_list:
        return False, '该学校暂无课程'
    return True, course_obj_list


def select_teach_course(course_name, teacher_name):
    teacher_obj = models.Teacher.get_obj(teacher_name)
    if course_name in teacher_obj.teach_course_list:
        return False, '该课程已添加 不要重复添加'
    teacher_obj.teach_course_list.append(course_name)
    teacher_obj.save()
    return True, f'成功添加课程: {course_name}'


def get_teach_course(teacher_name):
    teacher_obj = models.Teacher.get_obj(teacher_name)
    if teacher_obj.teach_course_list:
        return True, teacher_obj.teach_course_list
    return False, '当前老师还没有选课哦'


def view_selected_students(course_name):
    course_obj = models.Course.get_obj(course_name)
    if course_obj.student_list:
        return True, course_obj.student_list
    return False, '还没人选这节课欸'


def update_student_score(course_name, student_name, teacher_name, score):
    student_obj = models.Student.get_obj(student_name)
    student_obj.score[course_name] = score
    student_obj.save()
    return True, f'讲师:{teacher_name} 修改了学员：{student_name} 课程：{course_name} 的成绩为：{score}'