"""
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 common from interface import admin_inerface current_info = None def 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_handels def 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_handels class 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_obj class 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 os import pickle from conf import settings def 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) # <db.models.School object at 0x000002549D045438> 学校对象 res.append(obj) # 将对象添加到列表中 # print(res,'get_all 111') return res # 返回到models 层
2.老师用户接口层 ：表示层代码
# 教师的功能代码层 from lib import common from interface import teacher_interface,admin_inerface current_info = None current_school = None def 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 common from interface import admin_inerface,student_inerface current_school = None current_info = None def 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确认缴费<y/n>:').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 models def 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 wraps def 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
扫一扫
775
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
