选课系统

老男孩-----上海校区

接口文件 bin目录下admin_bin 、teacher_bin ‘、student_bin 、common_bin

"""
管理员接口
"""


from db import db_hander

from db import  models

#管理员注册接口
def admin_register(username,password):
    #1,判断用户是否存在
    #调用Admin 类中的 select 方法
    #由该方法调用db_hander 中的select_data工能获取对象
    admin_obj = models.Admin.select(username)
    #1,1 如果存在不允许注册返回自己的视图层
    if admin_obj:
        return False ,'用户已经存在'
    #1.2如果不存在则注册，调用类实例化得到对象并保存
    admin_obj = models.Admin(username,password)
    #对象调用save() 会将admin_obj 传给save方法
    admin_obj.save()
    return True ,'注册成功'
#管理员登录接口
"""
def admin_login(username,password):
    #判断用户是否存在
    admin_obj=models.Admin.select(username)
    #如果不存在，则返回给视图层
    if not admin_obj:
        return False,'用户名不存在'

    #如果存在，校验密码
    if password == admin_obj.password:
        return True,'登录成功'
    else:
        return  False,'密码错误登录失败'
"""

#创建学校接口
def create_school_info(school_name,addr,admin_info):
    #1，查看学校是否存在
    school_obj=models.School.select(school_name)
    #2，如果存在，则返回False 告诉用户学校已经存在
    if school_obj:
        return False ,'学校已经存在'
    #3，如果不存在，则创建学校
    admin_obj = models.Admin.select(admin_info)  #获取当前登录的管理用户
    # 由管理员创建学校，传入学校名字已经学校地址
    admin_obj.create_school(
        school_name,addr
    )
    #4,返回创建爱你学校成功
    return True , f'{school_name}学校'


#管理员课程创建课程接口
def create_course(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.2 如果课程不存在，则创建课程，有管理员来创建
    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(teacher_name,admin_name,teacher_pwd='123'):
    #1,判断老师是否存在
    teacher_obj=models.Admin.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} 老师创建成功'

"""
老师接口
"""

from db import  models
#老师查看课程接口
def check_course_teacher(teacher_name):
    # 获取当前老师对象
    teacher_obj = models.Teacher.select(teacher_name)
    # 判断老师对象中课程列表中是否有值
    # course_list = teacher_obj.course_list_from_t
    course_list= teacher_obj.show_course

    #如果有 则返回True,无则返回Fasle
    if not course_list:
         return False ,'老师没有选择课程'
    return True ,course_list

#老师添加课程接口
def add_course_info(course_name,treacher_name):
    # 获取当前老师对象
    teacher_obj = models.Teacher.select(treacher_name)
   # 判断当前课程是否在老师课程列表中宏
    course_list=teacher_obj.course_list_from_t
   # 如果不存在则添加该课程到老师课程列表中
    if course_name in course_list:
        return False ,'该课程已经存在'
    teacher_obj.add_course(course_name)
    return True ,'添加课程完成'

#老师获取课程下学生接口

def get_student_info(course_name,teacher_name):

    #获取当前老师对象
    teacher_obj = models.Teacher.select(teacher_name)

    # 让老师对象，调用获取课程系所有学生功能
    studet_list=teacher_obj.get_student(course_name)
    # 判断课程下是否有学生
    if not studet_list:
        return False ,'学生没有选择课程'
    return True ,studet_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 ,'修改成功'

"""学生接口"""

from db import models
#创建学生注册接口
def student_register(username,pwd):
    #判断用户存在
    #调用student类中的select 方法
    #由该方法调用db_hander 中的select_data 功能获取对象
    student_obj=models.Student.select(username)
    #如果存在不允许注册，返回用户已经存在
    if student_obj:
        return False,'用户已经存在'
    #如果不存在则允许注册，调用类实例化并保存数据
    student_obj=models.Student(username,pwd)
    student_obj.save()
    return True,'注册成功'


#创建学生登录接口
"""
def student_login(username,password):
    #1,判断用户是否存在
    student_obj=models.Student.select(username)
    #2，如果不存则返回用户返回给视图
    if not student_obj:
        return False ,'用户名不存在'
    #3，如果存在则校验密码
    if password == student_obj.password:
        return  True,"登录成功"
    else:
        return False,'密码错误'
"""

#选择学校接口
def add_school(school_name,student_name):
    # 当前学生是否存在学校
    student_obj = models.Student.select(school_name)
    if student_obj.school:
        return False, '当前学生已经选择过学校了'
    #如果不存在学校，则调用学生对象中选择学校的方法，实现学生添加学校
    student_obj.add_school(school_name)
    return  True,'选择学校成功'


#/获取学生所在学校所有课程接口
def get_course_list(student_name):
    #1,获取当前学生对象
    student_obj=models.Student.select(student_name)
    school_name=student_obj.school
    # 2,判断当前学生是否由学校，如果没有则返回False
    if not school_name:
        return False ,'没有学校，请先选择学校'
    #3，开始获取学校对象中的课程列表
    school_obj= models.School.select(school_name)
    # 3.1 判断当前学校中是否有课程，如果没有，则联系管理员
    course_list = school_obj.course_list
    if not course_list:
        return False,'没有课程，请先联系管理员创建'
    #3.2
    return  True,course_list#


#学生选择课程接口
def add_course_info(course_name,student_name):
    #当前课程是否已经存在于学生课程列表中
    student_obj=models.Student.select(student_name)
    if course_name in student_obj.course_list:
        return False ,'选择的课程已经存在'
    #2，调用学生对象中添加课程方法
    student_obj.add_course(course_name)
    return True,f'{student_name} 课程添加成功'

#学生查看分数接口

def check_score(student_name):
    student_obj= models.Student.select(student_name)
    if student_obj.score:
        return  student_obj.score

"""
公共接口
"""
import os
from config import settings
from db import models
#获取所有学校名称接口

def get_all_school():
    #获取学校文件夹路径
    school_dir=os.path.join(
        settings.DB_PATH,'School'
    )

    #判断文件夹是否存在

    if not  os.path.exists(school_dir):
        return  False ,'学校不存在'
    #如果存在则将文件夹中所有文件的名字打印出来
    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,"登录的角色不存在"
    # 判断用户是否存在
    if obj:
        if pwd == obj.pwd:
            return True,'登录成功'
        else:
            return False,'登录失败'
    else:
        return False,'用户不存在'



#获取学校下所有课程接口

def get_course_in_school(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

配置文件目录config 下setting.py 文件

import  os
BASE_PATH = os.path.dirname(
    os.path.dirname(__file__)
)

DB_PATH=os.path.join(BASE_PATH,'db')

主程序目录core 下文件 admin  studnet  teacher src

"""
管理员视图
"""
#注册
admin_info={
    'user':None
}
from bin import admin_bin
from lib import common
from bin import common_bin
def registered():
    while True:
        username=input("请输入您的用户名").strip()
        password=input("请输入您的密码").strip()
        re_password=input("请再次确认您的密码").strip()
        if password == re_password:
            flag,msg = admin_bin.admin_register(
                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_bin.login_interface(
            username,password,user_type='admin'
        )
        if flag:    #如果为真True
            print(msg)
            admin_info['user']=username  # 可变类型不需要global
            break
        else:
            print(msg)

#创建学校
@common.auth('admin')
def create_school():
    while True:
        school_name=input("请输入学校名称")
        addr=input("请输入学校地址")
        flag,msg=admin_bin.create_school_info(
            school_name,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_msg=common_bin.get_all_school()
        if not flag:
            print(school_list_msg)
            break
        for index,school_name in enumerate(school_list_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_msg)):
            print("请输入正确的编号")
            continue
        #获取用户输入的学校名字
        school_name = school_list_msg[choice]
        #2，选择学校后输入课程名称
        course_name = input("请输入创建的课程的名称").strip()
        #3，调用创建课程接口，让管理员创建课程
        flag,msg=admin_bin.create_course(
            school_name,course_name,admin_info.get('user')
        )
        if flag:
            print(msg)
            break
        else:
            print(msg)
#创建老师
@common.auth('admin')
def create_teacher():
    while True:
        teacher_name=input("请输入老师的名字").strip()
        #调用接口创建老师
        flag,msg=admin_bin.create_teacher(
            teacher_name,admin_info.get('user')
        )
        if flag:
            print(msg)
            break
        else:
            print(msg)

func_dic={
    '1':registered,
    '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_dic:
            print("您输入的有误请重新选择")
            continue
        func_dic.get(choice)()

"""
学生视图

"""
#注册
from lib import common
from bin import studeny_bin
from bin import common_bin

student_info={
    'user':None
}
#注册
def registered():
    while True:
        student_name=input("请输入您的名字")
        student_pwd=input("请输入您的密码")
        re_student_pwd=input("请再次确认您的密码")
        if student_pwd == re_student_pwd:
            flag,msg=studeny_bin.student_register(
                student_name,student_pwd
            )
            if flag:
                print(msg)
                break
            else:
                print(msg)
        else:
            print("两次密码不一致，请重新输入")

#登录
def login():
    while True:
        username=input("请输入您的账号").strip()
        password=input("请输入您的密码").strip()
        #调用登录接口
        flag,msg = common_bin.login_interface(
            username,password,user_type='student'
        )
        if flag:
            print(msg)
            #记录登录状态
            student_info['user']=username
            break
        else:
            print(msg)

#选择学校
# @common.auth('student')
def chose_school():
    # 获取所有学校让学生选择
    while True:
        flag,school_list=common_bin.get_all_school()
        if 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]
        #3,开始调用学生选择学校接口
        flag,msg=studeny_bin.add_school(
            school_name,student_info.get('user')
        )
        if flag:
            print(msg)
            break
        else:
            print(msg)
#选择课程
# @common.auth('student')
def chose_course():
    while True:
        #1,先获取当前学生所在学校的课程列表
       flag,course_list= studeny_bin.get_course_list(
            student_info.get('user')
       )
       if not flag:
            print(course_list)
            return
    #打印课程列表，并让用户选择课程
       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=studeny_bin.add_course_info(
           course_name,student_info.get('user')
       )
       if flag:
           print(msg)
           break
       else:
           print(msg)

#查看分数
# @common.auth('student')
def select_fraction():
    score=studeny_bin.check_score(
        student_info.get('user')
    )
    if not score:
        print('没有选择课程')
    print(score)
#交学费
# @common.auth('student')
def pay_tuition():
    pass

func_dict={
    '1':registered,
    '2':login,
    '3':chose_school,
    '4':chose_course,
    '5':select_fraction,
    '6':pay_tuition,
}

def student_view():
    while True:
        print("""
        -1，注册
        -2，登录功能
        -3，选择校区
        -4，选择课程（先选择校区，在选择校区中的一门课程）
            --学生选择课程，课程选择学生
        -5.查看分数
        -6.交学费
        
        """)
        choice = input("请输入您的选择").strip()
        if choice == 'q':
            break
        if choice not in func_dict:
            print("您输入的有误请重新输入")
            continue
        func_dict.get(choice)()

"""
老师视图

"""
from bin import common_bin
from bin import teacher_bin
from lib import  common

teacher_info = {
    'user': None
}


def login():
    """登录"""
    while True:
        username = input("请输入您的用户名").strip()
        password = input("请输入您的密码").strip()
        flag, msg = common_bin.login_interface(
            username, password, user_type='teacher'
        )
        if flag:
            print(msg)
            teacher_info['user'] = username
            break
        else:
            print(msg)


# @common.auth('teacher')
#查看教授课程
def select_course():
    flag,course_list= teacher_bin.check_course_teacher(
        teacher_info.get('user')
    )
    if flag:
        print(course_list)
    else:
        print(course_list)


# @common.auth('teacher').
"""选择教授课程"""
def chose_course():
    #1 先打印所有学校并选择
    while True:
        flag,school_list=common_bin.get_all_school()
        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] # 获取学校名称
    #2，从选择的学校中获取所有的课程
        flag2,course_list=common_bin.get_course_in_school(
        school_name
        )
        if not  flag2:
          print(course_list)
          break
        for index2,course_name in enumerate(course_list):
            print(f'编号{index2} 课程名字{course_name}')
        choice2 = input("请输入编号")
        if not choice2.isdigit():
            print("输入有误")
            continue
        choice2= int(choice2)
        if choice2 not in range(len(course_list)):
            print('输入有误')
            continue
        #获取课程名称
        course_name = course_list[choice2]

    #3 调用选择教授课程接口，将课程添加到老师课程列表中
        flag3,msg=teacher_bin.add_course_info(
            course_name, teacher_info.get('user')
        )
        if flag3:
            print(msg)
            break
        else:
            print(msg)

# @common.auth('teacher')
def course_student():
    """查看课程下的学生"""
    while True:
        #1,获取当前老师所在课程
        flag,course_list = teacher_bin.check_course_teacher(
            teacher_info.get('user')
        )
        if not flag:
            print(course_list)
            break
        #2，获取所有课程，并让老师选择
        for index,course_name in enumerate(course_list):
            print(f'编号{index} 课程名{course_name}')
        choice = input('请输入编号')
        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_bin.get_student_info(
            course_name,teacher_info.get('user')
        )
        if flag2:
            print(student_list)
            break

        else:
            print(student_list)
            break

# @common.auth('teacher')
def modify():
    """修改分数"""
    #1,先获取老师下所有的课程，并选择
    #2， 获取选择的课程下所有的学生，并选择要修改的学生
    #3， 调用修稿学生分数接口修改分数
    while True:
        #调用获取当前老师下所有的课程接口
        flag,course_list = teacher_bin.check_course_teacher(
            teacher_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('请输入课程编号')
        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_bin.get_student_info(
            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("请输入编号")
        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_bin.change_score_interface(
            course_name,student_name,score,teacher_info.get('user')
        )
        if flag3:
            print(msg)
            break


fun_dic = {

}


def teacher_view():
    while True:
        print("""
        -- 1.登录
        --2.查看教授课程
        --3.选择教授课程
        --4.查看课程下的学生            
        --5.修改学生分数
        """)
        choice = input("请输入您的选择").strip()
        if choice == 'q':
            break
        if choice not in fun_dic:
            print("您输入的有误，请重新选择")
            continue
        fun_dic.get(choice)()

"""
主视图
"""

from core import admin
from core import student
from core import teacher
chose_dic={
    '1':admin.admin_view,
    '2':student.student_view,
    '3':teacher.teacher_view,
}

def run():
    while True:
        print("""
        欢迎来到老男孩
        1，管理员功能
        2，学生功能
        3，老师功能
        q，退出
        
        """)
        chose = input("请输入功能编号").strip()
        if chose == 'q':
            break
        if chose not in chose_dic:
            print("输入有误请重新输入")
            continue
        chose_dic.get(chose)()

数据目录  db_hander ,modles 和新增数据文件存在

"""
保存数据，查看数据
"""
import  os
from config import settings
import pickle
def save_data(obj):
    #1,获取对象的保存文件夹路径
    #2，以类名 当做 文件夹的名字
    #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.username #  "username" 类中初始化是也必须是username
    )
    #4,打开文件保存对象，
    with open(user_path,'wb') as f:
        pickle.dump(obj,f)

def select_data(cls,username):
    #由cls获取类名
    cls_name = cls.__name__
    user_dic_patch= os.path.join(
        settings.DB_PATH,cls_name
    )
    #2，拼接查看用户的pickle 文件路径，
    user_patch=os.path.join(
        user_dic_patch,username
    )
    #3,判断用户是否存在，再打开，并返回如果不存在则代表用户不存在
    if os.path.exists(user_patch):
        #5,打开文件
        with open(user_patch,'rb') as f:
            obj= pickle.load(f)
            return  obj

"""
用于存放类
"""
# 学校类、学员类、课程类、讲师类、 管理员类

from db import db_hander
# 让所有类继承 查看数据、保存数据的方法
class Father:
    def save(self): #保存对象数据
        db_hander.save_data(self)

    #查看数据
    @classmethod  #将函数类话
    def select(cls,username):
        obj = db_hander.select_data(cls,username)
        return  obj
#管路员类


class Admin(Father):
    def __init__(self,username,password):
        self.username=username
        self.password = password
    #创建学校
    def create_school(self,school_name,addr):
        #调用方法内部来调用学校实例化的得到对象保存
        school_obj=School(school_name,addr)
        school_obj.save()
    #创建课程
    def create_course(self,school_obj,course_name):
        #1，调用课程类，实例化创建课程
        course_obj=(course_name)
        course_obj.save()
        #2，获取当前学校对象，并将课程添加到课程列表中
        school_obj.course_list.append(course_name)
    #创建讲师
    def create_teacher(self,teacher_name,teacher_pwd):
        #1,调用老师类，实例化的到老师对象，并保存
        teacher_obj=Teacher(teacher_name,teacher_pwd)
        teacher_obj.save()




#学生类
class Student(Father):
    def __init__(self,username,pwd):
        self.username=username
        self.pwd=pwd
        self.school = None #一个学生只能有一个校区
        self.course_list=[]  # 一个学生可以选择多门课程
        self.score={} #{"course_name":0}
        self.pay = {} #{"course_name":0}

    #学生添加学校方法
    def add_school(self,school_name):
        self.school=school_name
        self.save()
    #学生选择课程方法
    def add_course(self,course_name):
        #1学生列表添加课程
        self.course_list.append(course_name)
        #2 给学生选择的课程设置默认分数
        self.score[course_name]=0
        self.save()
        #3学生选择的课程对象添加学生
        course_obj=Course.select(course_name)
        course_obj.student_list.append(self.username)
        course_obj.save()
#课程类
class Course(Father):
    def __init__(self,course_name):
        self.username=course_name
        self.student_list=[]
#讲师类
class Teacher(Father):
    def __init__(self,teacher_name,teacher_pwd):
        self.username=teacher_name
        self.pwd=teacher_pwd
        self.course_list_from_t=[]

    def show_course(self):
        """查看课程接口"""
        return self.course_list_from_t
    def add_course(self,course_name):
        """老师添加课程"""
        self.course_list_from_t.append(course_name)
        self.save()
    def get_student(self,course_name):
        course_obj=Course.select(course_name)
        return course_obj.course_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()

#学校类

class School(Father):
    def __init__(self,name,addr):
        #必须写self.user=name
        #因为db_hander 里面的select_data 统一规范
        self.username=name
        self.addr = addr
        self.course_list=[]#每所学校都应该有相应的课程

公用目录lib 公共方法使用文件 common,py

"""
公共方法
"""
from core import  admin
from core import teacher
from core import student
#登录认证装饰器,有参装饰器
def auth(role):
    def login_auth(func):
        def warpper(*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 warpper
    return login_auth

启动文件  start.py

"""
程序启动文件
"""
import os,sys
from core import src


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

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