""" 1. 创建北京、上海 2 所学校    学校类对象    属性:名字,地址    行为: 2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开 3. 课程包含，周期，价格，通过学校创建课程      课程类对象         属性:名字,价格,周期         行为: 4. 通过学校创建班级， 班级关联课程、讲师（初始没有设置为空）    班级对象    属性:名字, 课程名称    讲师对象    属性:名字,密码,校区名称,课程名称 5. 创建学员时，选择学校，关联班级    学生对象:    属性:名字,密码 ,学校名称,班级名称,成绩 6. 创建讲师角色时要关联学校  7. 提供三个角色接口    6.1 学员视图， 可以注册，登陆, 交学费， 选择班级,查看成绩    6.2 讲师视图,登陆,(注册没有 由管理员来分配账号)， 查看班级学员列表 ， 修改所管理的学员的成绩 ,修改密码    6.3 管理视图，登陆,创建学校,创建讲师， 创建班级，创建课程,给老师指定班级 8. 上面的操作产生的数据都通过pickle序列化保存到文件里 实现的顺序 管理员  老师  学员 """ 1.模块的界面

2.管理员代码层

# 管理员代码输入层# 管理员视图层from lib import commonfrom interface import admin_inerfacecurrent_info = Nonedef register():    name = input('输入管理员姓名：').strip()    password = input('输入密码：').strip()    if name and password:        flag, msg = admin_inerface.register_interface(name, password)        if flag:            print(msg)        else:            print(msg)def login():    global current_info    name = input('输入管理员姓名：').strip()    password = input('输入密码：').strip()    if name and password:        flag, msg = admin_inerface.login_interface(name, password)        if flag:            print(msg)            current_info = name        else:            print(msg)def create_school():    """    1.输入创建学校所需要的属性 名字和地址    2.调用接口层判断 接口层拿到数据 到数据处理层处理    3.返回的到接口层 有则返回F 没有则创建    4,返回到界面 打印输出    :return:    """    school_name= input('输入学校的名字').strip()    school_addr = input('输入学校的地址：').strip()    if school_name and school_addr :        flag, msg = admin_inerface.create_school_interface(current_info, school_name, school_addr)        if flag:            print(msg)        else:            print(msg)def create_teacher():    """    1.先选择学校（老师是在学校下面的） 可以封装获取所有学校学校    2.输入老师的名字和默认密码     创建老师管理员调用接口层实列化    :return:    """    sc_names_list = admin_inerface.get_schools_interface()    # print(sc_names_list,'3333')  # ['bj_old', 'sh_old'] 3333    # 把字在通过索引的形式展现给界面层 >>>封装抽取一个独立函数    sc_name = common.get_name(sc_names_list, '校区名')    # 拿到学校的名字 判断 是否存在 在下一步 输入老师的信息    if not sc_name:        return    #  有该学习    te_name = input('输入老师的名字：').strip()    pwd = input('输入默认密码：').strip()    if te_name and pwd:        # 调用接口层        flag, msg = admin_inerface.create_teacher_interface(te_name, sc_name,pwd)        if flag:            print(msg)        else:            print(msg)def create_classes():  # 先创建课程 课程下添加班级    """    1.选择校区    2.选择课程    3.输入班级名称    4.调用接口    5.展示结果    :return:    """    sc_names = admin_inerface.get_schools_interface()    # 拿到学校名字    sc_name = common.get_name(sc_names,'校区名字')    if not sc_names:        return False, '学校未创建'    # 获取课程列表    c_course_list = admin_inerface.get_course_interface(sc_name)    # print(c_course_list,'c_course_list')    c_name = common.get_name(c_course_list,'课程名字')    if not c_name:        return False, '课程还没有创建'    # 有的话 在选择班级    cl_name = input('输入要创建的班级：').strip()    flag, msg = admin_inerface.create_classes_interface(sc_name,c_name,cl_name)    if flag:        print(msg)    else:        print(msg)def create_course():    """     选择校区就可以     你的现获取所有学校     选好学校 在改学校下创建课程    :return:    """    sc_names = admin_inerface.get_schools_interface()  # 设计列表 面向对象思想 存的都是对象    sc_name = common.get_name(sc_names, '校区名字')  # 封装    # 判断返回的校区名是否存在    if not sc_name:        return    # 有则添加课程信息    course_name = input('输入课程名字：').strip()    price = input('输入课程价格:').strip()    cycle = input('输入课程周期：').strip()    # 调用接口层 传值要设计好是位置参数    flag, msg = admin_inerface.create_course_interface(sc_name, course_name, price, cycle)    if flag:        print(msg)    else:        print(msg)# 给老师添加课程  是给老师的所在班级添加课程呢  最后式老师班级def add_course_to_teacher():    """    明确输入层要干嘛 给老师加课程    1、选择学校    2、选择一个老师    3、选择一个课程    4、选择一个班级    5、将校区名字 老师名字 课程名字 班级名字 传给接口称    :return:    """    # 获取学校名字    sc_names = admin_inerface.get_schools_interface()    sc_name = common.get_name(sc_names,'学校名字')    if not sc_name:        return    #  获取一会老师的 老师选择课程  课程之后才有班级    te_names = admin_inerface.get_teacher_interface(sc_name)  # 取所有老师的名字 不需要传参    te_name = common.get_name(te_names, '老师的名字')  # te_name = list[choice] 取值    if not te_name:        return    #     # 获取课程名字 班级也创建好了    c_names = admin_inerface.get_course_interface(sc_name)    c_name = common.get_name(c_names,'课程名字')    if not c_name:        return    # 获取班级名字    # 1.去接口层    cl_names = admin_inerface.get_classes_interface(sc_name)  # 取所有    # 调用公共方法报道名字    cl_name = common.get_name(cl_names, '班级名字')    # 判断    if not cl_name:        return    # 调用接口层 发送数数据  >>>> 接收结果    flag, msg = admin_inerface.add_course_to_teacher_interface(sc_name,c_name,te_name,cl_name)    if flag:        print(msg)    else:        print(msg)func_dic = {    "0":register,    "1":login,    "2":create_school,    "3":create_teacher,    "4":create_classes,    "5":create_course,    "6":add_course_to_teacher,}def admin_views():    msg = (""" -----欢迎 登录管理员功能层-----    0.注册    1、登录    2、创建学校    3、创建老师    4、创建班级    5、创建课程    6、选择老师课程及班级    q、退出        """)    common.select_func(func_dic, msg)

  管理员接口层代码

# 管理员注册接口层层# from db.models import *from db import models,db_handelsdef register_interface(name, password):    """    :param name: 管理员名字    :param password: 管理员密码    :return: 返回是bool  和字符串提示信息    思路：        1. 直接用类名 通过models select()方法  返回是一个对象 再判断 在返回False        2.先判断名字是否存在        3.不在直接创建利用Admin 直接创建    """    admin_obj = models.Admin.select(name)    print(admin_obj)    if admin_obj:        return False, "用户已存在"    res = models.Admin(name, password)    res.save()    return True, '注册成功'# 用户登录接口def login_interface(name,pwd):    """    :param name:    :param pwd:    :return: bool + str    1.用类调取名对象    2.判断对象是否存在    3.不在则返回return    4.在判断密码    输入的和存的一样则返回正确    """    admin_obj = models.Admin.select(name)    print(admin_obj,'admin_obj')    if not admin_obj:        return False, '用户不存在'    if pwd == admin_obj.pwd:        return True, '登录成功'# 创建学校def create_school_interface(current_info, school_name, school_addr):    """    :param current_info: 当前登录的名字：    :param school_name: 学校可名    :param school_addr: 学校地址    :return: T /F    思路：        1。调用接口层    """    school_obj = models.School.select(school_name)    if school_obj:        return False, '学校已存在'    # 实列化学校    models.School(school_name, school_addr)    return True, '学校创建成功'# 创建学校def create_teacher_interface(te_name,sc_name, pwd ):    """    :param te_name: 老师的名字    :param pwd: 老师的密码    :return: 返回值    1、调用接口层将数据传输到数据处理层    2、存在则直接返回 不存在者直接实列化    3、将处理的结果都返回给用层界面    """    te_obj = models.Teacher.select(sc_name+te_name)    print(te_name,'444')    if te_obj:        return False, "老师已存在"    models.Teacher(sc_name+te_name, sc_name, pwd)    return True, "创建老师成功"# 获取所有学校def get_schools_interface():    """     # 获取的所有学校称        1.通过学校这个类获取所有学校对象        2.拿到一个返回值 是一个列表对象        3.for循环拿出每一个对象        4.通过点语法获取名字        5.产生一个新列表 （学校名字）    :return:    """    sc_list_obj = models.School.get_all()  # 可以将这个当一个类方法使用 可吧帮我们获取对象文件的列表    res = []    for i in sc_list_obj:        res.append(i.name)    return res# 接口层创建学校def create_course_interface(sc_name, course_name, price, cycle):    course_name_obj = models.Course.select(sc_name+course_name)  # 存储式拼接的格式    if course_name_obj:        return False, '课程已存在'    models.Course(sc_name+course_name, price, cycle,sc_name)  # 位置参数必须一一对应    return True, '课程创建成功'# 获取课程列表def get_course_interface(sc_name):    c_course_list = models.Course.get_all()    print('c_course_list',c_course_list)    # 拿到课程名字    res = []    for a in c_course_list:        if a.sc_name == sc_name:            res.append(a.name[len(sc_name):])    return res# 管理员创建班级def create_classes_interface(sc_name,c_name,cl_name):    """    :param sc_name: 学校名    :param c_name: 课程名    :param cl_name: 班级名    :return: 返回结果    1.调接口层 班级 moles    2.判断是否存在    3、创建    4、返回界面    """    cl_obj = models.Classes.select(sc_name+cl_name)    if cl_obj:        return False, '班级已经创建'    # =无则创建    models.Classes(sc_name+cl_name, c_name, sc_name)    return True, '班级创建成功'# 获取老师的所有名字def get_teacher_interface(sc_name):    """    老师已经创建好了    te_names = models.Teacher.get_all()    # 拿到 返回的一个老帅 对象列表    # 循环取值 获取老师 >>> 获取老师名字    :return:返回一个对象列表    """    res = []  # 123kk names    te_names = models.Teacher.get_all()    for a in te_names:        if a.sc_name == sc_name:            res.append(a.name[len(sc_name):])    return res# 接口层获取班级列表 get_all 方法def get_classes_interface(sc_name):  #    cl_names = models.Classes.get_all()    # 在接口层给他遍历    res = []    for a in cl_names:        if a.sc_name == sc_name:            res.append(a.name[len(sc_name):])    return res# 加课程接口层逻辑处理  >>>> 将接收的数据调用数据处理层 >>>返回结果def add_course_to_teacher_interface(sc_name, c_name, te_name, cl_name):    # 用models 获取数据    # c_obj = models.Classes.select(sc_name+c_name)    # if not c_obj:    #     return False, '课程已存在'    #    # # 创建    # models.Classes(sc_name+c_name, te_name, cl_name)  # models    # return True, '创建成功'    """    :param sc_name: 学校名称    :param c_name: 课程名称    :param te_name: 老师名称    :param cl_name: 班级名称    :return:    1.找到老师设置他的课程    2.找到对应的班级 设置老师    """    te_obj = models.Teacher.select(sc_name+te_name)    # 将当前课程绑定给当前老师    te_obj.c_name = c_name    te_obj.save()  # 保存课程    # 将老师关联班级    cls_obj = models.Classes.select(sc_name+cl_name)    # 判断班级是否已经选择 老师绑班级    if cls_obj.te_name == te_name:        return False, '班级已经绑定过老师了'    # 如果没有则将老师绑定给班级    cls_obj.te_name = te_name    cls_obj.save()    return True, '老师绑定班级成功'

 管理员modles 层

# 类的封装(属性和方法)# 类的抽取from db import db_handelsclass BaseClass(object):    # 方法可以将查询方法封装到类中 可以通过类来调用    # def save()    def save(self):        db_handels.db_save(self)    @classmethod  # 为什么绑定给雷用 因为自动就将类当做第一对象传入 后面拼接路径    def select(cls, name):        res = db_handels.db_select(cls, name)        return res    # 发封装一个类方法  直接将类作为第一参数传过来    @classmethod    def get_all(cls):        # 获取需要返回到接口层        list_obj = db_handels.get_all(cls)        return list_objclass Admin(BaseClass):    # 属性 及方法    def __init__(self, name, pwd):        self.name = name        self.pwd = pwd        self.save()class School(BaseClass):    def __init__(self,school_name,school_addr):        self.name = school_name  # 自己的名称空间 优先实列化初始值        self.addr = school_addr        self.save()class Course(BaseClass):     def __init__(self,name,price,cycle,school_name):         self.name = name         self.price = price         self.cycle = cycle         self.sc_name = school_name         self.save()class Classes(BaseClass):    def __init__(self,name,course_name, school_name):        self.name = name        self.te_name = None  # 暂时还没有老师        self.sc_name = school_name  # 创建班级需要传学校        self.c_name = course_name  # 创建班级需要传课程        self.save()class Teacher(BaseClass):    def __init__(self,te_name,school_name,pwd='123'):        self.name = te_name        self.pwd = pwd        self.sc_name = school_name        self.c_name = None  # 课程名字哦        self.save()class Student(BaseClass):    def __init__(self, name, pwd, school_name):        self.name = name        self.pwd = pwd        self.sc_name = school_name  # 学校是泥在创建学生要先选的 初始化阶段要进行 实列化传值        self.class_name = None  # 班级        self.score = None        self.is_pay = False  # 是否付费属性        self.save()

 管理员handles 层代码

# 存数据 （对象）import osimport picklefrom conf import settingsdef db_save(obj):  # obj 是save（）自动将对象传过来    # 拼接路径 判断路径保存    PATH = os.path.join(settings.DB_PATH, obj.__class__.__name__.lower())    if not os.path.exists(PATH):        os.makedirs(PATH)    path = os.path.join(PATH, obj.name)    # 将对象写入文件    with open(path, 'wb')as f:        pickle.dump(obj, f)        f.flush()# 数据处理层# select() 查询获取def db_select(cls, name):    # print(cls,'111')  类    # 拼接路径主要判断有没有当前路径    PATH = os.path.join(settings.DB_PATH, cls.__name__.lower())    # print(PATH, 'path')    # print(PATH,'4444')    if not os.path.exists(PATH):        os.makedirs(PATH)    # 再判断文件路径    user_path = os.path.join(PATH, name)    if not os.path.exists(user_path):        return    # print(user_path, 'user_path')    with open(user_path, 'rb')as f:        res_obj = pickle.load(f)        # print(res_obj, 'res_obj')        return res_obj# 获取所有对象的类方法def get_all(cls):    # 拼接路径    path = os.path.join(settings.DB_PATH, cls.__name__.lower())    if not os.path.exists(path):        return    # # 拼接文件路径    # user_path = os.path.join(path, name)    # with open(user_path, 'rd')    #拿到当前文件夹下的所有文件    res = []    for a in os.listdir(path):  # 这里的a 是 当前path 下的所有文件对象        # print(names,'names')  #        # 直接点用select() 拿到返回对象        obj = db_select(cls, a)  # 调用 数据获取对象        # print('obj', obj)  # 
     
       学校对象        res.append(obj)  # 将对象添加到列表中    # print(res,'get_all  111')    return res  # 返回到models 层
     

 2.老师用户接口层 ：表示层代码

# 教师的功能代码层from lib import commonfrom interface import teacher_interface,admin_inerfacecurrent_info = Nonecurrent_school = Nonedef login():    global current_info, current_school  # 升为全局变量一会记得保存当前用户的登录状态    while True:        # 先选择学校        # 在选择登录        sc_names = admin_inerface.get_schools_interface()        sc_name = common.get_name(sc_names, '选择的校区')        if not sc_name:            return        name = input('输入老师名字：').strip()        pwd = input('输入老师密码：').strip()        if name and pwd:            flag, msg = teacher_interface.login_interface(name, pwd,sc_name)            if flag:                print(msg)                current_info = name                current_school = sc_name                break            else:                print(msg)# 暂时def show_class():  # 全部    """获取这个老师下的班级    思路：根据当前的学校 和 用户名    1.先拿到所有的班级 在比对这个老师的是否是这个学校 和这个老师返回一个列表    2.返回到界循环打印 或者枚举    :return:    """    # 调用接口层    class_list = teacher_interface.get_classes_list(current_info, current_school)    if not class_list:        return '暂无班级列表'    # 打印 当前的班级列表    for a in class_list:        print(class_list.index(a), a)# 查看当前老师下的学生def check_student():    """    # 拿到所有 的班级 在 在获取 班级下所有的学生    #    :return:    """    class_list = teacher_interface.get_classes_list(current_info,current_school)    # 获取班级名字    cls_name = common.get_name(class_list, '班级名字')    if not class_list:  # 有班级列表        return    # 有则 老师获取所有学生    stu_dic_list = teacher_interface.get_stu_list_interface(current_school,cls_name)    if not list:  # 暂时还没有学员        print('暂时没有学生列表')        return    # 在打印字符串拼接 显示个人信息 [{'name':'jason}]    print('%-8s %-8s %-8s %-8s %-8s'%('name','sc_name','class_name','score','is_pay'))    for stu_dic in stu_dic_list:        print('%-8s %-8s %-8s %-8s %-8s '              %(stu_dic['name'],                stu_dic['sc_name'],stu_dic['class_name'],stu_dic['score'],                stu_dic['is_pay']))# 修改老师密码def change_pwd():    """    对新密码新进限制    :return:    """    new_pwd = input('输入要修改的密码：').strip()    if len(new_pwd) >=6 and new_pwd.isalnum():        flag = teacher_interface.change_pwd_interface(current_info,current_school, new_pwd)        if flag:            print('密码修改成功')        else:            print('修改未成功')# 修改学生成绩def change_score():    """    需求：修改学生成绩必须获取所有学生 <<< 遍历所有学生 判断 是否当前 学校下的学生和    1.老师登陆有自己的学校    2.    :return:    """    # 1.获取班级 当前老师的班级    cl_list = teacher_interface.get_classes_interface(current_info,current_school)    cl_name = common.get_name(cl_list, '老师班级')    if not cl_name:        return    # 获取班级下的学生    students = teacher_interface.get_stu_list_interface(current_school, cl_name)    if not students:  # 列表套字典        return '班级下没有学生'    # 2.获取学生    stu_name = common.get_name([stu['name'] for stu in students], '学生信息')    if not stu_name:        return    while True:        score = input('输入修该的分数：').strip()        if not common.is_number(score):            print('请输入浮点数')            continue        # 调用接口也层修改 解压赋值 一一对应        flag, msg = teacher_interface.change_score_interface(current_school, stu_name, float(score))        if flag:            print(msg)            break        else:            print(msg)func_dic= {    "1":login,    "2":show_class,    "3":check_student,    "4":change_pwd,    "5":change_score,}def teacher_views():    msg = ("""    1.登陆    2.查看班级    3.查看学员    4.修改密码    5.修改成绩    q.退出           """)    common.select_func(func_dic,msg)

 老师接口层代码：业务逻辑代码处理层代码

# 教师的功能代码from db import models# 老师接口层def login_interface(name, pwd, sc_name):    # 直接调用接口层    te_obj = models.Teacher.select(sc_name+name)    if not te_obj:        return False, '用户不存在'    if pwd == te_obj.pwd:        return True, '登录成功'# 获取老师的所有列表def get_classes_list(te_name, school_name):    """    :param te_name:    :param school_name:    :return:    1.先获取这学小的所有列表    2.循环没有一个班级对象    3,拿到班级对象点语法可以判断是否等于当前的班级下的学校名字  和当前的班级下的老师名    4.是直接切分将班级名字返回    返回一个列表    """    # 获取所有班级    cl_lists = models.Classes.get_all()    # 循环打印    res = []    for a in cl_lists:        if a.sc_name == school_name and a.te_name == te_name:            res.append(a.name[len(school_name):])  # 存的时候是有学校的    return res# h获取所有的老师def get_stu_list_interface(current_school,cls_name):    # 返回    """    :param current_school:    :param cls_name:    :return: 一个列表存储的是字典    """    stu_all_list = models.Student.get_all()    # print(stu_all_list,'stu_all_list')  # 拿到所有的学生列表对象    # for 循环    res = []    for stu in stu_all_list:        if stu.sc_name == current_school and stu.class_name == cls_name:            # 获取学生字典            stu_dic = stu.__dict__            stu_dic.pop('pwd')            # 获取学生的名字            stu_dic['name'] = stu_dic['name'][len(current_school):]            res.append(stu_dic)    return res# 老师修改密码def change_pwd_interface(current_info,current_school, new_pwd):    # 不需要判断了 注意查询老师的时候 拼接查询    te_obj = models.Teacher.select(current_school+current_info)    te_obj.pwd = new_pwd    te_obj.save()    return True, '修改成功'# 获取当前老师 的班级def get_classes_interface(te_name, sc_name):    # 获取所有    clas = models.Classes.get_all()    # 循环    res = []    for cl in clas:        if cl.te_name == te_name and cl.sc_name == sc_name:            res.append(cl.name[len(sc_name):])    return res# 修改学生成绩def change_score_interface(current_school, stu_name, score):    # 获取所有学生    stus = models.Student.get_all()    print(stus,'11111')    for stu in stus:        if stu.sc_name == current_school and stu.name == current_school+stu_name:            stu.score = score            print(stu.__dict__)            print(score,'2222')            stu.save()            return True, '修改成绩成功'## if __name__ == '__main__':  # 测试代码##     stu = models.Student('rose','123','sh_old')#     stu.class_name = 'python10'#     print(stu.__dict__)#     stu.save()

 3.学生用户层：表示层代码

# 学生函数功能层from lib import commonfrom interface import admin_inerface,student_inerfacecurrent_school = Nonecurrent_info = Nonedef register():    # 选择一个校区 在进行注册    sc_names = admin_inerface.get_schools_interface()    sc_name = common.get_name(sc_names, '选择校区')    if not sc_name:        return    while True:        name = input('输入学生名字：').strip()        pwd = input('输入学生密码：').strip()        if name and pwd:            flag, msg = student_inerface.register_interface(sc_name,name,pwd)            if flag:                print(msg)                break            else:                print(msg)def login():    # 还得选择校区    global current_school, current_info    sc_names = admin_inerface.get_schools_interface()    sc_name = common.get_name(sc_names, '选择校区')    if not sc_name:        return    while True:        name = input('输入学生名字：').strip()        pwd = input('输入学生密码：').strip()        if name and pwd:            flag, msg = student_inerface.login_interface(sc_name, name, pwd)            if flag:                print(msg)                current_info = name                current_school = sc_name                break            else:                print(msg)# 学生缴费def pay_money():    """    1.首先我们要获取这个学生 当前的学生名字  返回一个学生字典 __dict__    stu =    2. 判段是否有班级    3.判断是否缴费    4。获取当前学生的    :return:    """    while True:        stu = student_inerface.get_student_interface(current_info, current_school)        print(stu,'stu')        if not stu['class_name']:  # 名称字典空间            # 暂时没有该学生班级            print('未选择班级')            return        if stu['is_pay']:            print('你已经交过费用了')            return    # 获取当前学生的要交的钱是多少        money = student_inerface.get_money_info(current_info,current_school)        print('需要缴费金额:[%s]￥' % money)        cmd = input('输入%s确认缴费
     
      :').strip()        if cmd == 'n': break        elif cmd == 'y':            flag,msg = student_inerface.pay_money_interface(current_info,current_school)            if flag:                print(msg)            else:                print(msg)# 学生选择班级def choose_classes():    """    1.当前由学校名称    2.获取班级的名字    3.通过班级赋值    :return:    """    ls_names = student_inerface.get_cls_interface(current_info, current_school)    ls_name = common.get_name(ls_names,'班级名字')    print(ls_names,'1111')    if not ls_name:        return    # 有的话则继续    flag, msg = student_inerface.choose_cls_interface(current_school,current_info,ls_name)    if flag:        print(msg)    else:        print(msg)def check_score():    # 修改分数    """    获取学生字典对象    :return:    """    stu_dic = student_inerface.get_student_interface(current_info, current_school)    if not stu_dic:        return '暂无学生字典对象'    print('学生成绩%s' % stu_dic['score'])func_dic = {    "1":register,    "2":login,    "3":pay_money,    "4":choose_classes,    "5":check_score,}def student_views():    msg = ("""-----欢迎等录学生功能层------    1、注册    2、登录    3、交学费    4、选择班级    5、查看成绩    q、退出         """)    common.select_func(func_dic, msg)
     

学生层业务逻辑处理层：

# 学生接口层from db import modelsdef register_interface(sc_name,name,pwd):    # 记得拼接    stu_obj = models.Student.select(sc_name+name)    if stu_obj:        return False, '学生已经存在'    models.Student(sc_name+name, pwd, sc_name)    print(stu_obj,'stu_obj')    # stu_obj.save()    return True, '注册成功'# 用户登陆def login_interface(sc_name, name, pwd):    # 先判断用户名 存在 再判断密码    stu_obj = models.Student.select(sc_name+name)    if not stu_obj:        # 直接返回        return False, "用户不存在"    if stu_obj.pwd == pwd:        return True, '用户登陆成功'# 获取当前学生信息def get_student_interface(current_info, current_school):    stus = models.Student.select(current_school+current_info)    if stus:        stu_dic = stus.__dict__        stu_dic.pop('pwd')        return stu_dic    return False# 获取当前学生要交的学费def get_money_info(stu_name,sc_name):    """    1.获取学生的    2.获取该学的班级    3。获取班级取课程对象    """    stu = models.Student.select(sc_name+stu_name)    # 班级对象    cls = models.Classes.select(sc_name+stu.class_name)  # 获取班级    # 拿到班级下的课程    c_course = models.Course.select(sc_name+cls.c_name)    return c_course.price# 学生缴费def pay_money_interface(stu_name,sc_name):    # 获取学生的缴费信息 改为T    stu_obj = models.Student.select(sc_name+stu_name)    stu_obj.is_pay = True    stu_obj.save()    return True, '缴费成功'# 获取班级列表def get_cls_interface(current_info, current_school):    cl_list = models.Classes.get_all()    res = []    for i in cl_list:        if i.name.startswith(current_school):            res.append(i.name[len(current_school):])    return res# 给学生添加班级def choose_cls_interface(current_school,current_info,ls_name):    stu_obj = models.Student.select(current_school+current_info)    if not stu_obj:        return False, '该学生不存在'    if stu_obj.class_name:  # 一个学生只能选一个班级        # print('stu_obj',stu_obj.__dict__)        return False, '已经选则班级'  # 这里是有点问题呀    stu_obj.class_name = ls_name    # print(stu_obj.__dict,'2222')    stu_obj.save()    return True, '创建班级成功'

 4. common 共用功能

# 先封装选择项from functools import wrapsdef select_func(func_dic, msg):    while True:        print(msg)        choice = input('输入功能选项：').strip()        if choice == 'q':            break        elif choice in func_dic:            func_dic.get(choice)()        else:            print('输入有误')# 获取校区名字def get_name(names_list, title):    """    :param names_list: 管理功能层传过的学校列表    :param title: 展示给用户的标题 校区  课程 老师 班级    :return:    """    while True:        if not names_list:            print('暂时还没有%s'% title)            return        # for循环 可以用枚举 这里我们尝试一个新的        for c_name in names_list:            print(names_list.index(c_name), c_name)        choice = input("输入%s编号："% title).strip()        if not choice.isdigit():            continue        choice = int(choice)        if choice not in range(len(names_list)):            print('输入的编号不存在')            continue        return names_list[choice]def is_number(score):    while True:        try:            float(score)            return True        except BaseException('输入不是浮点数') as e:            print(e)            break# 装饰器def login_auth(type):    def outer(func):        from views import admin, student, teacher        @wraps(func)        def inner(*args,**kwargs):            if type == 'admin':                module = admin            elif type == 'student':                module = student            elif type == 'teacher':                module = teacher            else:                raise Exception('没有这个模块')            if module.current_info :                res = func(*args, **kwargs)                return res            else:                return module.login()        return inner    return outer