python第三十五天-----作业完成--学校选课系统

选课系统：
角色:学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供两个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程

7. 上面的操作产生的数据都通过pickle序列化保存到文件里

README

学校选课系统

学生视图:可以自助注册,注册时可以选择班级,通过注册名登陆,,交学费,上课
讲师视图:通过讲师编号登陆,可以管理自己的班级,上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
管理视图: 1、创建学校. 2、查看学校.
          3、创建班级. 4、查看班级.
          5、创建讲师. 6、查看讲师.
          7、创建课程. 8、查看课程.
          9、课师关联. 10、查看课师关联.
          11、创建学员. 12、查看学员.

程序结构:
school/#程序目录
|- - -__init__.py
|- - -bin/#启动目录
|      |- - -__init__.py
|      |- - -admin.py#管理视图启动
|      |- - -initalize.py#系统初始化
|      |- - -stud.py#学生视图启动
|      |- - -teacher.py#讲师视图启动
|
|- - -cfg/#配置目录
|      |- - -__init__.py
|      |- - -config.py#配置文件
|
|- - -core/#主要程序目录
|      |- - -__init__.py
|      |- - -admin_main.py#管理视图主逻辑
|      |- - -class_main.py#主逻辑,类
|      |- - -func_main.py#主逻辑,函数
|      |- - -id_classes.py#id文件主逻辑,函数
|      |- - -log_file.py#日志函数
|      |- - -students_main.py#学生视图主逻辑
|      |- - -teacher_main.py#讲师视图主逻辑
|
|- - -db/#数据目录
|      |- - -__init__.py
|      |- - -admin_file/#管理员相关文件
|      |      |- - -
|      |
|      |- - -admin_user_list#是否初始化的检测文件
|      |
|      |- - -classes/#班级文件目录
|      |- - -course/#课程文件目录
|      |- - -school/#学校文件目录
|      |- - -students_file/#学生文件目录
|      |- - -teac_to_cour/#讲师与课程关联文件目录
|      |- - -teacher_file/#讲师文件目录
|
|
|- - -log/#日志目录
|      |- - -__init__.py

详细代码:

admin.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan

 #管理视图:创建讲师， 创建班级，创建课程

 import os ,sys
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量
 #print(BASE_DIR)
 from core import admin_main #包含目录下的文件脚本
 if __name__ == '__main__':
     admin_main.loging()

initalize.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 #初始化系统
 import os ,sys
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量
 from core import func_main
 if __name__ == '__main__':
     func_main.initialize_admin()#初始化管理员

stud.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import os ,sys
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量

 from core import students_main
 from core.func_main import stud_alize

 if __name__ == '__main__':
     while True:
         print('''
             温馨提示：如果未注册可以自助注册
             1、自助注册
             2、进入登陆
             3、退出
         ''')
         s=input('请选择:')
         if s=='':
             stud_alize()
             continue
         elif s=='':
             students_main.stud_log()
             continue
         elif s=='':
             exit()
         else:
             print('输入有误，请重输！')

teacher.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import os ,sys
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量

 from core.teacher_main import teach_log

 if __name__ == '__main__':
     teach_log()

config.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import os ,sys
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量

 ADMIN_USER_FILE=BASE_DIR+'\db\\admin_user_list'#定义管理员列表文件变量

 ADMIN_DIR=BASE_DIR+'\db\\admin_file\\'#定义管理员路径变量
 CLASS_DIR=BASE_DIR+'\db\\classes\\'#定义班级文件路径变量
 COURSE_DIR=BASE_DIR+'\db\\course\\'#定义学校课程文件路径变量
 STUD_DIR=BASE_DIR+'\db\\students_file\\'#定义学员文件路径变量
 TEACH_DIR=BASE_DIR+'\db\\teacher_file\\'#定义讲师文件路径变量
 SCHOOL_DIR=BASE_DIR+'\db\\schools\\'#定义学校路径变量
 TEAC_COUR_DIR=BASE_DIR+'\db\\teac_to_cour\\'#定义学校课程文件路径变量

 AMOUNT=300#每堂课收入基数

 USER_LOG=BASE_DIR+'\log\\user_log.log'#用户登陆日志文件
 USER_ERRO=BASE_DIR+'\log\\user_erro.log'#用户错误日志文件
 USER_OPERT=BASE_DIR+'\log\\user_operation.log'#用户操作日志文件

 ADMIN_LOG=BASE_DIR+'\log\\admin_log.log'#管理员登陆日志文件
 ADMIN_ERRO=BASE_DIR+'\log\\admin_erro.log'#管理员错误日志文件
 ADMIN_OPERT=BASE_DIR+'\log\\admin_operation.log'#管理员操作日志文件

admin_main.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import pickle
 import os ,sys
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量
 #from core import user_pass
 from core import class_main
 from core import func_main
 from core import log_file
 from cfg import config

 def loging():#运行函数
     if func_main.file_char(config.ADMIN_USER_FILE):#检测相关文件是否不存在,进行初始化
         print('系统还未进行初始化!')
         func_main.initialize_admin()#进行初始化
     while True:
         print('管理员界面'.center(60,'='))
         print('按q/Q退出<<<<\n\n ')
         user=input('用户名:').strip()
         if user=='q' or user=='Q':
             exit()
         pwd=input('密码:').strip()
         data=class_main.Admin.login(user,pwd)#检测密码
         info_str='管理员[%s] 登录成功 '%user
         log_file.admin_log(info_str)
         if data['tag']==True:
             print(data['data'].center(60,'='))
             while True:
                 print('''===========================
                 温馨提示:创建班级前请先进行课师关联1
                 请按提示操作:
                 1、创建学校. 2、查看学校.
                 3、创建班级. 4、查看班级.
                 5、创建讲师. 6、查看讲师.
                 7、创建课程. 8、查看课程.
                 9、课师关联. 10、查看课师关联.
                 11、创建学员. 12、查看学员.
                 0、退出.
                 ================================
                 ''')
                 foo=input('请选择：')
                 if foo=='':
                     func_main.car_school()
                     info_str='管理员:[%s]进行了创建学校!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.show_school()
                     info_str='管理员:[%s]进行了查看学校!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.car_classes()
                     info_str='管理员:[%s]进行了创建班级!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.show_classes()
                     info_str='管理员:[%s]进行了查看班级!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.car_teacher()
                     info_str='管理员:[%s]进行了创建讲师.'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.show_teacher()
                     info_str='管理员:[%s]进行了查看讲师!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.car_course()
                     info_str='管理员:[%s]进行了创建课程!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.show_course()
                     info_str='管理员:[%s]进行了查看课程!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.associated_course()
                     info_str='管理员:[%s]进行了课师关联.!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.show_teac_to_cour()
                     info_str='管理员:[%s]进行了查看课师关联!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.car_students()
                     info_str='管理员:[%s]进行了创建学员!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     func_main.show_students()
                     info_str='管理员:[%s]进行了查看学员!'%user
                     log_file.admin_opert(info_str)
                     continue
                 elif foo=='':
                     print("您已经成功退出！")
                     info_str='管理员[%s] 成功退出 '%user
                     log_file.admin_log(info_str)
                     exit()
                 else:
                     print("选择有误，请重新选择！")
                     continue

         else:
             print('用户名或密码错误请重输入')
             info_str='管理员[%s] 登录错误 '%user
             log_file.admin_err(info_str)
             continue

class_main.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import os ,sys,pickle,uuid,time
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量

 from cfg import config

 from core import id_classes

 #基础类
 class BasisClass(object):#基础类
     def save(self):
         file_dir=os.path.join(self.file_path,str(self.ID))#拼接文件路径
         pickle.dump(self,open(file_dir,'wb'))#序列化到文件

     @classmethod
     def open_file_list(cls):#传入当前类
         list_l=[]#定义一个列表
         for file in os.listdir(cls.file_path):#循环输出对应目录下的文件
             file_dir=os.path.join(cls.file_path,file)##拼接文件路径
             list_l.append(pickle.load(open(file_dir,'rb')))#反序列化,追加到列表
         return list_l#返回列表

 #管理员类
 class Admin(BasisClass):
     file_path=config.ADMIN_DIR#管理员路经变量
     def __init__(self,user,pwd):
         self.ID=id_classes.Admin_id(self.file_path)#自动生成唯一ID
         self.USER=user
         self.PWD=pwd
         self.create_time=time.strftime('%Y-%m-%d %H:%M:%S')#创建的时间
     @staticmethod
     def login(name,pas):
         try:
             for obj in Admin.open_file_list():
                 if obj.USER == name and obj.PWD == pas:
                     tag=True
                     error=''
                     data='\033[32;1m登录成功\033[0m'
                     break
             else:
                 raise Exception('\033[41;1m用户名或密码错误\033[0m' %name)
         except Exception as e:
             tag=False
             error=str(e)
             data=''
         return {'tag':tag,'error':error,'data':data}

 #学校类
 class SchoolName(BasisClass):
     file_path=config.SCHOOL_DIR#学校路径变量
     def __init__(self,schoo_name,addr):#学校名称 地址
         self.NAME=schoo_name#学校的名字
         self.ADDR=addr#地址
         self.ID=id_classes.Schools_id(self.file_path)#自动生成唯一ID
         self.create_time=time.strftime('%Y-%m-%d %H:%M:%S')#创建的时间
         self.amount=0#收入
     # def get_amount(self):
     #     return str(self.__amount)#返回收入
     def __str__(self):
         return self.NAME

 #班级类
 class Class_leven(BasisClass):#续承学校类
     '''班级类'''
     file_path=config.CLASS_DIR#班级所在目录
     number=0#班级数
     def __init__(self,school_id,name,teac_to_cour_id):#学校, 班级名,讲师与课程
         self.NAME=name
         self.ID=id_classes.Class_id(self.file_path)#自动生成唯一ID
         self.SCHOOL_ID=school_id#学校名字ID
         self.create_time=time.strftime('%Y-%m-%d %H:%M:%S')#创建的时间
         self.TEAC_TO_LSIT_ID=teac_to_cour_id#讲师与课程列表
         Class_leven.number+=1
     def __str__(self):
         return self.NAME

 #   '''老师类'''
 class Teacher(BasisClass):
     number=0#老师人数
     file_path=config.TEACH_DIR#讲师路经变量
     def __init__(self,name,pwd,age,sex,leve,school_id):#名字，密码,年龄，性别，学校名
         self.ID=id_classes.Teacher_id(self.file_path)
         self.NAME=name
         self.PWD=pwd
         self.AGE=age
         self.SEX=sex
         self.LEVE=leve
         self.SCHOOL_ID=school_id#关联学校
         self.amount=0#收入
         self.create_time=time.strftime('%Y-%m-%d %H:%M:%S')#创建的时间
         Teacher.number+=1#创建时加1
     def __str__(self):
         return self.NAME
     @staticmethod
     def login(name,pas):
         try:
             for obj in Teacher.open_file_list():
                 if obj.NAME == name and obj.PWD == pas:
                     tag=True
                     error=''
                     file_dir=os.path.join(obj.file_path,str(obj.ID))#拼接文件路径
                     data=file_dir#返回对应的文件
                     break
             else:
                 raise Exception('\033[41;1m用户名或密码错误\033[0m' %name)
         except Exception as e:
             tag=False
             error=str(e)
             data=''
         return {'tag':tag,'error':error,'data':data}

 #'''学生类'''
 class Students(BasisClass):
     '''学生类'''
     file_path=config.STUD_DIR#学生文件路径变量
     number=0#学生总人数
     def __init__(self,num,name,pwd,age,sex,school_id,class_leven_id,phone):#学号,名字，年龄，性别，学校，班级,电话，分数,学费
         self.ID=id_classes.Students_id(self.file_path)
         self.NUM=num
         self.NAME=name
         self.PWD=pwd
         self.AGE=age
         self.SEX=sex
         self.SCHOOL_ID=school_id
         self.CLASS_ID=class_leven_id
         self.PHONE=phone
         self.SCORE=Score(self.NUM)
         self.create_time=time.strftime('%Y-%m-%d %H:%M:%S')#创建的时间
         self.FEES=0
     def __str__(self):
         return self.NAME
     @staticmethod
     def login(name,pas):#登陆检测
         try:
             for obj in Students.open_file_list():
                 if obj.NAME == name and obj.PWD == pas:
                     tag=True
                     error=''
                     file_dir=os.path.join(obj.file_path,str(obj.ID))#拼接文件路径
                     data=file_dir#返回对应的文件
                     break
             else:
                 raise Exception('\033[41;1m用户名或密码错误\033[0m' %name)
         except Exception as e:
             tag=False
             error=str(e)
             data=''
         return {'tag':tag,'error':error,'data':data}

 #'''课程类'''
 class Course(BasisClass):
     file_path=config.COURSE_DIR#课程文件路径变量
     def __init__(self,name,cycle,fees,school_id,):#传入名字,周期,学费,学校对应的ID
         self.ID=id_classes.Course_id(self.file_path)#自动生成唯一ID
         self.NAME=name
         self.CYCLE=cycle
         self.FEES=fees
         self.SCHOOL_ID=school_id
         self.SCORE=Score(self.ID)#传入自身ID 实例化出来一个分数对象
         self.CREATE_TIME=time.strftime('%Y-%m-%d %H:%M:%S')#创建的时间
     def __str__(self):
         return self.NAME

 #讲师到课程
 class Teac_to_cour(BasisClass):
     '''讲师到课程'''
     file_path=config.TEAC_COUR_DIR#讲师到课程文件路径变量
     def __init__(self,course_name,teacher_name,school_id):#课程，讲师
         self.ID=id_classes.Teac_to_cour_id(self.file_path)#自动生成唯一ID
         self.NAME=teacher_name+'->'+course_name
         self.COURSE_NAME=course_name#课程名称
         self.TEACHER_NAME=teacher_name#讲师姓名
         self.SCHOOL_ID=school_id#学校ID
     def __str__(self):
         return self.NAME

 #分数类
 class Score():
     def __init__(self,nid):
         self.ID=nid#学号
         self.score_dict={}#分数字典

     def set(self,Teac_to_cour_id,number):
         self.score_dict[Teac_to_cour_id]=number#课程与讲师合到分数

     def get(self,Teac_to_cour_id):
         return self.score_dict[Teac_to_cour_id]#取出分数

func_main.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import os ,sys,pickle,uuid,hashlib,time

 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量
 from cfg import config
 from core import class_main
 from core import log_file

 #id生成
 def id_uu():
     return str(uuid.uuid1())
 #id生成
 def id_md5():
     id_i=hashlib.md5()
     id_i.update(bytes(str(time.time()),encoding='utf8'))
     return id_i.hexdigest()#返回用时间创建 的ID

 #初始化检测
 def file_char(name):#
     if  not os.path.exists(name):#检测相关文件是否不存在
         #info={'北京':[],'上海':[]}
         #file_pick(name,info)#进行初始化
         return True
     else:
         return False

 #初始化管理员
 def initialize_admin():
     print('系统正在初始化....')
     try:
         user = input('请输入初始化用户名：')
         pwd = input('请输入初始化密码：')
         obj = class_main.Admin(user, pwd)
         obj.save()
         with open(config.ADMIN_USER_FILE,'w') as f:
             f.write('yes')#应文件用来确认初始化
         return True
     except Exception as e:
         print(e)

 #创建学校函数
 def car_school():
     try:
         print('提示: B/b 返回上级!')
         names=input('请输入您要添加的学校名字：').strip()
         if names=='b' or names=='B':
             return
         addrs=input('请输入学校所在地址：').strip()
         if addrs=='b' or addrs=='B':
             return
         school_name_list=[(obj.NAME,obj.ADDR) for obj in class_main.SchoolName.open_file_list()]#进行学校校区重名检测用,返回列表
         if (names,addrs) in school_name_list:
             print('\033[41;1m[%s] [%s]校区 已经存在,不可重复创建\033[0m' %(names,addrs))
             return
         else:
             obj=class_main.SchoolName(names,addrs)#创建学校
             obj.save()#pickle序列化保存到文件
             print('\033[32;1m创建[%s] 学校,[%s]校区成功!\033[0m'%(names,addrs))
             return
     except Exception as e:
         print(e)

 #查看学校
 def show_school():
     for obj in class_main.SchoolName.open_file_list():
         #amo=obj.get_amount()
         print('\033[32;1m学校[%s] 地址[%s] 总收入[%s] 创建日期[%s] \033[0m'.center(60,'-') %(obj.NAME,obj.ADDR,obj.amount,obj.create_time))

 #创建课程函数
 def car_course():
     print('\033[36;1m创建课程\033[0m'.center(60,'='))
     school_list=class_main.SchoolName.open_file_list()#打开学校列表
     try:
     #while True:
         print('\033[33;1m提示: B/b 返回上级!\033[0m')
         fon=input('===============其他键确认开始创建课程:')
         if fon=='b' or fon=='B':
             return
         for k,obj in enumerate(school_list):
             print('\033[35;1m学校编号:%s,学校名称:%s,校区:%s\033[0m'%(k,obj,obj.ADDR))
         sch_name=int(input('请选择学校: '))
         school_obj=school_list[sch_name]#用数字选定学校
         # print(school_list[sch_name])
         # print(school_obj.ID.ID)
         course_name=input('请输入要创建的课程名：').strip()
         price=input('请输入课程价格: ').strip()
         period=input('请输入课程周期: ').strip()
         course_name_list=[(obj.NAME,obj.SCHOOL_ID.ID) for obj in class_main.Course.open_file_list()]#返回所有课程是名字,对应的学校列表
         if (course_name,school_obj.ID.ID) in course_name_list:#查课程名,与学校名是否存
             print('\033[43;1m课程[%s] 已经存在,不能重复创建\033[0m' %(course_name))
             return
         else:
             obj=class_main.Course(course_name,period,price,school_obj.ID)
             obj.save()
             print('\033[33;1m课程[%s] 价格[%s] 周期[%s]创建成功\033[0m' %(obj.NAME,obj.FEES,obj.CYCLE))
             return
     except Exception as e:
         return print('选择有误,请重新选择')

 #查看课程
 def show_course():
     for obj in class_main.Course.open_file_list():#调用ID类中的方法
         print('\033[32;1m[%s] [%s]校区 [%s]课程 价格[%s] 周期[%s]\033[0m'.center(60,'-')%(obj.SCHOOL_ID.get_id_file().NAME,obj.SCHOOL_ID.get_id_file().ADDR,obj.NAME,obj.FEES,obj.CYCLE))

 #创建讲师函数
 def car_teacher():
     print('\033[36;1m创建讲师\33[0m'.center(60,'='))
     school_list=class_main.SchoolName.open_file_list()#打开学校列表
     try:
     #while True:
         print('\033[33;1m提示: B/b 返回上级!\033[0m')
         fon=input('===============其他键确认开始创建讲师:')
         if fon=='b' or fon=='B':
             return
         for k,obj in enumerate(school_list):
             print('\033[35;1m学校编号:%s,学校名称:%s,校区:%s\033[0m'%(k,obj,obj.ADDR))
         sch_name=int(input('请选择学校: '))
         school_obj=school_list[sch_name]#用数字选定学校
         uname=input('请输入要创建的讲师名字：').strip()
         upwd=input('请输入讲师登陆密码：').strip()
         uleve=input('请输入讲师级别：').strip()
         uage=input('请输入年龄：').strip()
         usex=input('请输入性别：').strip()
         uname_list=[(obj.NAME,obj.SCHOOL_ID.ID) for obj in class_main.Teacher.open_file_list()]#返回所有讲师是名字,对应的学校列表
         if (uname,school_obj.ID.ID) in uname_list:#查讲师名,与学校名是否存
             print('\033[43;1m讲师[%s] 已经存在,不能重复创建\033[0m' %(uname))
             return
         else:
             obj=class_main.Teacher(uname,upwd,uage,usex,uleve,school_obj.ID)
             obj.save()
             print('\033[33;1m[%s] [%s]校区 讲师[%s] 创建成功\033[0m' %(obj.SCHOOL_ID.get_id_file().NAME,obj.SCHOOL_ID.get_id_file().ADDR,obj.NAME))
             return
     except Exception as e:
         return print('选择有误,请重新选择')

 #查看讲师
 def show_teacher():
     for obj in class_main.Teacher.open_file_list():#调用ID类中的方法
         print('\033[32;1m[%s] [%s]校区 [%s]讲师 性别:[%s] 级别[%s] 创建时间[%s]\033[0m'.center(60,'-')%(obj.SCHOOL_ID.get_id_file().NAME,obj.SCHOOL_ID.get_id_file().ADDR,obj.NAME,obj.SEX,obj.LEVE,obj.create_time))

 #创建班级函数
 def car_classes():
     print('\033[36;1m创建班级\33[0m'.center(60,'='))
     school_list=class_main.SchoolName.open_file_list()#打开学校列表
     try:
     #while True:
         print('\033[33;1m提示: B/b 返回上级!\033[0m')
         fon=input('===============其他键确认开始创建班级:')
         if fon=='b' or fon=='B':
             return
         for k,obj in enumerate(school_list):
             print('\033[35;1m学校编号:%s,学校名称:%s,校区:%s\033[0m'%(k,obj,obj.ADDR))
         sch_name=int(input('请选择学校: '))
         school_obj=school_list[sch_name]#用数字选定学校
         uname=input('请输入要创建的班级名：').strip()
         uname_list=[(obj.NAME,obj.SCHOOL_ID.ID) for obj in class_main.Class_leven.open_file_list()]#返回所有班级是名字,对应的学校列表
         if (uname,school_obj.ID.ID) in uname_list:#查课程名,与学校名是否存
             print('\033[43;1m[%s] [%s]校区 ,[%s]班级 已经存在,不能重复创建\033[0m' %(school_obj.ID.get_id_file().NAME,school_obj.ID.get_id_file().ADDR,uname))
             return
         else:
             teac_to_cour_list=class_main.Teac_to_cour.open_file_list()#打关联列表
             for k ,obj in enumerate(teac_to_cour_list):
                 if str(school_obj.ID)==str(obj.SCHOOL_ID.ID):
                     print('\033[35;1m课程编号:%s,关联的讲师:%s\033[0m'%(k,obj))
             coures_name=int(input('请选择讲师与课程'))
             teac_to_cour_obj=teac_to_cour_list[coures_name]
             obj=class_main.Class_leven(school_obj.ID,uname,teac_to_cour_obj.ID)
             obj.save()
             print('\033[33;1m[%s] [%s]校区 [%s]班级 创建成功\033[0m' %(obj.SCHOOL_ID.get_id_file().NAME,obj.SCHOOL_ID.get_id_file().ADDR,obj.NAME))
             return
     except Exception as e:
         return print('选择有误,请重新选择')

 #查看班级
 def show_classes():
     for obj in class_main.Class_leven.open_file_list():#调用ID类中的方法  学校ID   老师到课程ID
         print('\033[32;1m[%s] [%s]校区 [%s]班 所开课程:[%s]  讲师:[%s]\033[0m'.center(60,'-')%(obj.SCHOOL_ID.get_id_file().NAME,\
                                                                                       obj.SCHOOL_ID.get_id_file().ADDR,\
                                                                                       obj.NAME,\
                                                                                       obj.TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME,obj.TEAC_TO_LSIT_ID.get_id_file().TEACHER_NAME))

 #关联课程
 def associated_course():
     try:
     #while True:
         school_list=class_main.SchoolName.open_file_list()#打开学校列表
         print('课程关联'.center(60,'='))
         for k,obj in enumerate(school_list):
                 print('\033[35;1m学校编号:%s,学校名称:%s,校区:%s\033[0m'%(k,obj,obj.ADDR))
         sch_name=int(input('请选择学校: '))
         school_obj=school_list[sch_name]#用数字选定学校
         course_list=class_main.Course.open_file_list()#打开课程列表
         for k,obj in enumerate(course_list):
             if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
                 print('\033[35;1m课程编号:%s,课程名称:%s\033[0m'%(k,obj))
         cou_name=int(input('请选择课程: '))
         course_obj=course_list[cou_name]#用数字选定课程
         teacher_list=class_main.Teacher.open_file_list()#打开讲师列表
         for k,obj in enumerate(teacher_list):
             if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
                 print('\033[35;1m讲师编号:%s,讲师姓名:%s\033[0m'%(k,obj))
         teach_name=int(input('请选择讲师: '))
         teach_obj=teacher_list[teach_name]#用数字选定老师
         uname_list=[(obj.COURSE_NAME,obj.TEACHER_NAME,obj.SCHOOL_ID.ID) for obj in class_main.Teac_to_cour.open_file_list()]#返回所有关联课程列表
         if (course_obj.NAME,teach_obj.NAME,school_obj.ID.ID) in uname_list:#查课程名,与学校名是否存
             print('\033[43;1m[%s] [%s]校区 ,课程[%s]与[%s] 已经关联,不能重复关联\033[0m' %(school_obj.ID.get_id_file().NAME,school_obj.ID.get_id_file().ADDR,course_obj.NAME,teach_obj.NAME))
             return
         else:
             obj=class_main.Teac_to_cour(course_obj.NAME,teach_obj.NAME,school_obj.ID)
             obj.save()
             print('\033[33;1m[%s] [%s]校区 ,课程[%s]与[%s] 关联成功\033[0m' %(obj.SCHOOL_ID.get_id_file().NAME,obj.SCHOOL_ID.get_id_file().ADDR,obj.COURSE_NAME,obj.TEACHER_NAME))
             return
     except Exception as e:
         return print('选择有误,请重新选择')

 #查看课程关联
 def show_teac_to_cour():
     for obj in class_main.Teac_to_cour.open_file_list():
         print('\033[32;1m[%s] [%s]校区 课程:[%s]  讲师:[%s]\033[0m'.center(60,'=')%(obj.SCHOOL_ID.get_id_file().NAME,\
                                                                                       obj.SCHOOL_ID.get_id_file().ADDR,\
                                                                               obj.COURSE_NAME,obj.TEACHER_NAME))

 #学员自动注册
 def stud_alize():
     print('\033[36;1m学员自助注册\33[0m'.center(60,'='))
     school_list=class_main.SchoolName.open_file_list()#打开学校列表
     try:
     #while True:
         print('\033[33;1m提示: B/b 返回上级!\033[0m')
         fon=input('===============其他键确认开始注册:')
         if fon=='b' or fon=='B':
             return
         for k,obj in enumerate(school_list):
             print('\033[35;1m学校编号:%s,学校名称:%s,校区:%s\033[0m'%(k,obj,obj.ADDR))
         sch_name=int(input('请选择您要注册的学校: '))
         uname_list=[(obj.NUM,obj.PHONE) for obj in class_main.Students.open_file_list()]#返回所有学员的名字,对应的学校,电话号码列表
         school_obj=school_list[sch_name]#用数字选定学校
         unum=int(input('请输入您要的学号：').strip())
         if (unum)in uname_list:#查学号是否存
             print('\033[43;1m学号[%s] 已经存在,不能重复创建\033[0m' %(unum))
             return
         uname=input('请输入注册名字：').strip()
         upwd=input('请输入登陆密码：').strip()
         uphone=input('请输入电话号码:').strip()
         uage=input('请输入年龄：').strip()
         usex=input('请输入性别：').strip()
         if (uphone) in uname_list:#查电话是否存
             print('\033[43;1m学员[%s] 电话号码已经存在,不能重复创建\033[0m' %(uname))
             return
         else:
             class_list=class_main.Class_leven.open_file_list()#打开班级
             for k,obj in enumerate(class_list):
                 if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
                     print('\033[35;1m班级编号:%s, [%s]\033[0m'%(k,obj))
             uclass_name=int(input('请选择班级:'))
             class_name_obj=class_list[uclass_name]#
             obj=class_main.Students(unum,uname,upwd,uage,usex,school_obj.ID,class_name_obj.ID,uphone)
             obj.save()
             print('\033[33;1m[%s] [%s]校区 学员[%s] 注册成功\033[0m' %(obj.SCHOOL_ID.get_id_file().NAME,obj.SCHOOL_ID.get_id_file().ADDR,obj.NAME))
             return
     except Exception as e:
         return print('输入有误,请重新选择')

 #创建学员
 def car_students():
     print('\033[36;1m创建学员\33[0m'.center(60,'='))
     school_list=class_main.SchoolName.open_file_list()#打开学校列表
     try:
     #while True:
         print('\033[33;1m提示: B/b 返回上级!\033[0m')
         fon=input('===============其他键确认开始创建学员:')
         if fon=='b' or fon=='B':
             return
         for k,obj in enumerate(school_list):
             print('\033[35;1m学校编号:%s,学校名称:%s,校区:%s\033[0m'%(k,obj,obj.ADDR))
         sch_name=int(input('请选择学校: '))
         uname_list=[(obj.NUM,obj.PHONE) for obj in class_main.Students.open_file_list()]#返回所有学员的名字,对应的学校,电话号码列表
         school_obj=school_list[sch_name]#用数字选定学校
         unum=int(input('请输入要创建学员学号：').strip())
         if (unum)in uname_list:#查学号是否存
             print('\033[43;1m学号[%s] 已经存在,不能重复创建\033[0m' %(unum))
             return
         uname=input('请输入要创建学员名字：').strip()
         upwd=input('请输入学员登陆密码：').strip()
         uphone=input('请输入电话号码:').strip()
         uage=input('请输入年龄：').strip()
         usex=input('请输入性别：').strip()
         if (uphone) in uname_list:#查电话是否存
             print('\033[43;1m学员[%s] 电话号码已经存在,不能重复创建\033[0m' %(uname))
             return
         else:
             class_list=class_main.Class_leven.open_file_list()#打开班级
             for k,obj in enumerate(class_list):
                 if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
                     print('\033[35;1m班级编号:%s, [%s]\033[0m'%(k,obj))
             uclass_name=int(input('请选择班级:'))
             class_name_obj=class_list[uclass_name]#
             obj=class_main.Students(unum,uname,upwd,uage,usex,school_obj.ID,class_name_obj.ID,uphone)
             obj.save()
             print('\033[33;1m[%s] [%s]校区 学员[%s] 创建成功\033[0m' %(obj.SCHOOL_ID.get_id_file().NAME,obj.SCHOOL_ID.get_id_file().ADDR,obj.NAME))
             return
     except Exception as e:
         return print('输入有误,请重新选择')

 #查看学员
 def show_students():
     for obj in class_main.Students.open_file_list():
         print('\033[32;1m[%s] [%s]校区 学员编号:[%s] 学员姓名:[%s] 年龄:[%s] 性别:[%s] 电话:[%s] 所在班级:[%s]\033[0m'.center(60,'=')%(obj.SCHOOL_ID.get_id_file().NAME,\
                                                                                   obj.SCHOOL_ID.get_id_file().ADDR,obj.NUM,\
                                                                           obj.NAME,obj.AGE,obj.SEX,obj.PHONE,obj.CLASS_ID.get_id_file().NAME))

 #学员个人信息查看

 def show_info(obj):
     info='''\033[34;1m
         学号:{NUM}\t\t\t姓名:{NAME}\t\t\t年龄:{AGE}\t\t\t性别:{SEX}\t\t\t电话:{PHONE}

         学校:{SCHOOL}\t\t\t校区:{SCHOOL_}\t\t\t班级:{CLASS}\t\t\t学费:{FEES}\t\t\t分数:{SCORE}

         \033[0m'''.format(NUM=str(obj.NUM),NAME=obj.NAME,AGE=obj.AGE,SEX=obj.SEX,PHONE=obj.PHONE,\
                    SCHOOL=obj.SCHOOL_ID.get_id_file().NAME,SCHOOL_=obj.SCHOOL_ID.get_id_file().ADDR,\
                    CLASS=obj.CLASS_ID.get_id_file().NAME,FEES=str(obj.FEES),SCORE=obj.SCORE.score_dict)

     print(info)

 #讲师个人信息查看

 def show_teach_info(obj):
     info='''\033[34;1m
         姓名:{NAME}\t\t\t年龄:{AGE}\t\t\t性别:{SEX}\t\t\t

         学校:{SCHOOL}\t\t\t校区:{SCHOOL_}\t\t\t级别:{LEVE}\t\t\t收入:{amount}

         \033[0m'''.format(NAME=obj.NAME,AGE=obj.AGE,SEX=obj.SEX,\
                    SCHOOL=obj.SCHOOL_ID.get_id_file().NAME,SCHOOL_=obj.SCHOOL_ID.get_id_file().ADDR,\
                    LEVE=obj.LEVE,amount=str(obj.amount))

     print(info)

 #讲师操作相关函数
 def teacher_char_l(obj_teach):
     class_teach_list=[]#讲师的班级列表
     for obj in class_main.Class_leven.open_file_list():#打开班级列表
         if obj_teach.NAME==obj.TEAC_TO_LSIT_ID.get_id_file().TEACHER_NAME:#查询对应的课程老师
             class_teach_list.append(obj)#加入列表
     return class_teach_list#讲师的班级列表

 #讲师操作相关函数查看学生
 def teacher_char_class(class_teach_list):
     while True:
         for k,obj in enumerate(class_teach_list):
             print('\033[32;1m班级编号:%s 班级名称:[%s]\033[0m'%(k,obj))
         try:
             sart_class=int(input('请选择您要查看的学员班级编号:'))
             sart_class_obj=class_teach_list[sart_class]#用数字选定班级
             for obj in class_main.Students.open_file_list():#查看学生
                 if str(obj.CLASS_ID.get_id_file().NAME)==str(sart_class_obj.NAME):#查看对应班级
                     print('\033[34;1m学号:[%s] 姓名:[%s]\033[0m'%(obj.NUM,obj.NAME))
             return
         except Exception as e:
            print('选择有误,请重新选择')
     else:
         print('\033[31;1m对不起,您还没有分配班级与课程,请与校方联系!\033[0m')

 #讲师操作相关函数学员成绩
 def teacher_char_class_students(class_teach_list):
     while True:
         for k,obj in enumerate(class_teach_list):
             print('\033[32;1m班级编号:%s 班级名称:[%s]\033[0m'%(k,obj))
         try:
             sart_class=int(input('请选择您要查看的学员班级编号:'))
             sart_class_obj=class_teach_list[sart_class]#用数字选定班级
             students_list=[]
             for obj in class_main.Students.open_file_list():#查看学习
                 if str(obj.CLASS_ID.get_id_file().NAME)==str(sart_class_obj.NAME):#查看对应班级
                     #print('\033[34;1m学号:[%s] 姓名:[%s]\033[0m'%(obj.NUM,obj.NAME))
                     students_list.append(obj)#返回当前班级学员列表
             return students_list
         except Exception as e:
            print('选择有误,请重新选择')
     else:
         print('\033[31;1m对不起,您还没有分配班级与课程,请与校方联系!\033[0m')

 #获取学生上课课程函数
 def studnts_class(class_name):
     for obj in class_main.Course.open_file_list():#返回所有课程的名字
         if class_name==str(obj.NAME):
             return obj

 #交学费
 def jxf(file_dir,user):
     obj=pickle.load(open(file_dir,'rb'))
     money=input('请输入学费金额:')
     if money.isdigit():#是否为整数
         obj.FEES=obj.FEES+int(money)
         obj.save()#进行保存
         print("交费成功,金额:\033[32;1m%s\033[0m"%money)
         file_dir=os.path.join(config.SCHOOL_DIR,str(obj.SCHOOL_ID.get_id_file().ID))##拼接文件路径
         school_obj=pickle.load(open(file_dir,'rb'))#反序列化,追加到文件
         school_obj.amount+=int(money)
         school_obj.save()#进行保存
         info_str='%s 学员进行交费,金额:[%s]'%(user,money)
         log_file.user_opert(info_str)
     else:
         print('请正确输入整数!')

id_classes.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import pickle,os
 from core import func_main
 # ID 类
 class id_mode(object):#id 基础类
     def __init__(self,file_path):
         self.ID=func_main.id_uu()##自动生成唯一ID
         self.File_path=file_path#传入的路径
     def __str__(self):
         return self.ID
     def get_id_file(self):#通过ID找到对应文件
         for filename in os.listdir(self.File_path):
             if filename == self.ID:
                 file_dir=os.path.join(self.File_path,self.ID)#拼接文件路径
                 return pickle.load(open(file_dir,'br'))#返回反序列化的文件对象
         return None

 class Admin_id(id_mode):#管理员类
     def __init__(self,file_path):
         super(Admin_id,self).__init__(file_path)    #

 class Class_id(id_mode):#班级类
     def __init__(self,file_path):
         super(Class_id,self).__init__(file_path)

 class Course_id(id_mode):#课程类\
     def __init__(self,file_path):
         super(Course_id,self).__init__(file_path)

 class Schools_id(id_mode):#学校类
     def __init__(self,file_path):
         super(Schools_id,self).__init__(file_path)

 class Students_id(id_mode):#学生类
      def __init__(self,file_path):
         super(Students_id,self).__init__(file_path)

 class Teac_to_cour_id(id_mode):#讲师到课程类
      def __init__(self,file_path):
         super(Teac_to_cour_id,self).__init__(file_path)

 class Teacher_id(id_mode):#讲师类
      def __init__(self,file_path):
         super(Teacher_id,self).__init__(file_path)

log_file.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 #日志记录相关函数
 import os,logging,time
 from cfg import config

 def log_err(info_str):#错误日志,传入的错误内容
     logger=logging.getLogger('用户登陆错误日志')#设置日志模块
     logger.setLevel(logging.DEBUG)
     fh=logging.FileHandler(config.USER_ERRO,encoding='utf-8')#写入文件
     fh.setLevel(logging.DEBUG)#写入信息的级别
     fh_format=logging.Formatter('%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')#日志格式
     fh.setFormatter(fh_format)#关联格式
     logger.addHandler(fh)#添加日志输出模式
     logger.warning(info_str)
     return 0

 def log_log(info_str):#登陆日志,传入内容
     logger=logging.getLogger('用户成功登陆日志')#设置日志模块
     logger.setLevel(logging.DEBUG)
     fh=logging.FileHandler(config.USER_LOG,encoding='utf-8')#写入文件
     fh.setLevel(logging.DEBUG)#写入信息的级别
     fh_format=logging.Formatter('%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')#日志格式
     fh.setFormatter(fh_format)#关联格式
     logger.addHandler(fh)#添加日志输出模式
     logger.warning(info_str)
     return 0

 def user_opert(info_str):#用户操作日志,传入内容
     logger=logging.getLogger('用户操作日志')#设置日志模块
     logger.setLevel(logging.CRITICAL)
     fh=logging.FileHandler(config.USER_OPERT,encoding='utf-8')#写入文件
     fh.setLevel(logging.CRITICAL)#写入信息的级别
     fh_format=logging.Formatter('%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')#日志格式
     fh.setFormatter(fh_format)#关联格式
     logger.addHandler(fh)#添加日志输出模式
     logger.critical(info_str)
     return 0

 def admin_log(info_str):#管理员登陆日志,传入内容
     logger=logging.getLogger('管理员成功登陆日志')#设置日志模块
     logger.setLevel(logging.DEBUG)
     fh=logging.FileHandler(config.ADMIN_LOG,encoding='utf-8')#写入文件
     fh.setLevel(logging.DEBUG)#写入信息的级别
     fh_format=logging.Formatter('%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')#日志格式
     fh.setFormatter(fh_format)#关联格式
     logger.addHandler(fh)#添加日志输出模式
     logger.warning(info_str)
     return 0

 def admin_err(info_str):#管理员错误日志,传入的错误内容
     logger=logging.getLogger('管理员登陆错误日志')#设置日志模块
     logger.setLevel(logging.DEBUG)
     fh=logging.FileHandler(config.ADMIN_ERRO,encoding='utf-8')#写入文件
     fh.setLevel(logging.DEBUG)#写入信息的级别
     fh_format=logging.Formatter('%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')#日志格式
     fh.setFormatter(fh_format)#关联格式
     logger.addHandler(fh)#添加日志输出模式
     logger.warning(info_str)
     return 0

 def admin_opert(info_str):#管理员操作日志,传入内容
     logger=logging.getLogger('管理员操作日志')#设置日志模块
     logger.setLevel(logging.CRITICAL)
     fh=logging.FileHandler(config.ADMIN_OPERT,encoding='utf-8')#写入文件
     fh.setLevel(logging.CRITICAL)#写入信息的级别
     fh_format=logging.Formatter('%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')#日志格式
     fh.setFormatter(fh_format)#关联格式
     logger.addHandler(fh)#添加日志输出模式
     logger.critical(info_str)
     return 0

students_main.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import os ,sys,pickle,time
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量
 from cfg import  config
 from core.class_main import Students
 from core.class_main import Course

 from core.func_main import show_info
 from core.func_main import studnts_class
 from core.func_main import jxf
 from core import log_file

 def stud_log():#学生登陆
     while True:
         print('学生登陆界面'.center(60,'='))
         print('按q/Q退出<<<<\n\n ')
         user=input('用户名:').strip()
         if user=='q' or user=='Q':
             exit()
         pwd=input('密码:').strip()
         data=Students.login(user,pwd)#检测密码
         if data['tag']==True:
             print('\033[32;1m登录成功\033[0m')
             info_str='学员[%s] 登录成功 '%user
             log_file.log_log(info_str)
             file_dir=data['data']#学员对应的文件路径
             while True:
                 #obj=pickle.load(open(file_dir,'rb'))
                 print('''===================
                 请选择你的操作：

                 1、交学费.
                 2、查看个人信息.
                 3、开始上课.
                 4、退出.

                 ==============================
                 ''')
                 foo=input('请选择：')
                 if foo=='':
                     jxf(file_dir,user)
                     # obj=pickle.load(open(file_dir,'rb'))
                     # money=input('请输入学费金额:')
                     # if money.isdigit():#是否为整数
                     #     obj.FEES=obj.FEES+int(money)
                     #     obj.save()#进行保存
                     #     print("交费成功,金额:\033[32;1m%s\033[0m"%money)
                     #     file_dir=os.path.join(config.SCHOOL_DIR,str(obj.SCHOOL_ID.get_id_file().ID))##拼接文件路径
                     #     school_obj=pickle.load(open(file_dir,'rb'))#反序列化,追加到文件
                     #     school_obj.amount+=int(money)
                     #     school_obj.save()#进行保存
                     #     info_str='%s 学员进行交费,金额:[%s]'%(user,money)
                     #     log_file.user_opert(info_str)
                     #     continue
                     # else:
                     #     print('请正确输入整数!')
                     continue
                 elif foo=='':
                     obj_2=pickle.load(open(file_dir,'rb'))
                     show_info(obj_2)
                     info_str='%s 学员进行个人信息查询!'%(user)
                     log_file.user_opert(info_str)
                     continue
                 elif foo=='':
                     obj_3=pickle.load(open(file_dir,'rb'))
                     class_name=obj_3.CLASS_ID.get_id_file().TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME#获取课程名
                     class_obj=studnts_class(class_name)#获取课程对象
                     if int(obj_3.FEES)>=int(class_obj.FEES):#如果交的学费大于课程的费用才能上课
                         print('开始上课....')
                         for i in range(50):#加载动画
                             sys.stdout.write('#')
                             sys.stdout.flush()
                             time.sleep(0.05)
                         print('\n恭喜!您已经完成本次课时.....')
                         info_str='%s 学员上课，完成课时!'%(user)
                         log_file.user_opert(info_str)
                         continue
                     else:
                         print('您的学费不够,请先交学费')
                         continue
                 elif foo=='':
                     print('您已经成功退出!')
                     info_str='学员[%s] 成功退出 '%user
                     log_file.log_log(info_str)
                     exit()
                 else:
                     print('选择有误，请重新选择！')
                     continue
         else:
             print('用户名或密码错误请重输入')
             info_str='%s登陆错误！'%user
             log_file.log_err(info_str)
             continue

teacher_main.py

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 #上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
 import os ,sys,pickle,time
 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 sys.path.append(BASE_DIR)#增加环境变量
 from core.class_main import Teacher
 from core.func_main import teacher_char_l
 from core.func_main import teacher_char_class
 from core.func_main import teacher_char_class_students
 from core.func_main import show_teach_info
 from cfg import config
 from core import log_file
 def teach_log():#讲师运行函数
     while True:
         print('讲师界面'.center(60,'='))
         print('按q/Q退出<<<<\n\n ')
         user=input('用户名:').strip()
         if user=='q' or user=='Q':
             exit()
         pwd=input('密码:').strip()
         data=Teacher.login(user,pwd)#检测密码
         if data['tag']==True:
             print('\033[32;1m登录成功\033[0m')
             info_str='讲师[%s] 登录成功 '%user
             log_file.log_log(info_str)
             file_dir=data['data']#讲师对应的文件路径
             while True:
                 obj_teach=pickle.load(open(file_dir,'rb'))
                 print('''===================
                 请选择你的操作：

                 1、查看班级学员列表.
                 2、选择班级上课.
                 3、管理的学员的成绩.
                 4、查看讲师个人信息.
                 5、退出.

                 ==============================
                 ''')
                 foo=input('请选择你的操作：')
                 list_l=teacher_char_l(obj_teach)#讲师的班级列表
                 if foo=='':
                     print('\033[35;1m尊敬讲师:[%s],您所教授的班级如下:\033[0m'.center(60,'=')%obj_teach.NAME)
                     teacher_char_class(list_l)#
                     info_str='%s 讲师在查看了学员列表'%user
                     log_file.user_opert(info_str)
                     continue
                 elif foo=='':
                     while True:
                         if len(list_l):
                             print('\033[35;1m尊敬讲师:[%s],您所教授的班级如下:\033[0m'.center(60,'=')%obj_teach.NAME)
                         for k,obj in enumerate(list_l):
                             print('\033[32;1m班级编号:%s 班级名称:[%s]\033[0m'%(k,obj))
                         try:
                             sart_class=int(input('请选择您要上课班级编号:'))
                             sart_class_obj=list_l[sart_class]#用数字选定班级
                             print('\033[46;1m您开始进入:[%s] 上课....\033[0m'.center(60,'-')%sart_class_obj.NAME)
                             for i in range(50):#加载动画
                                 sys.stdout.write('#')
                                 sys.stdout.flush()
                                 time.sleep(0.05)
                             obj_teach.amount+=(config.AMOUNT+int(obj_teach.LEVE)/10*config.AMOUNT)
                             obj_teach.save()
                             info_str='%s 讲师在 %s 班级上课'%(obj.NAME,sart_class_obj.NAME)
                             log_file.user_opert(info_str)
                             print('\n课程结束，您的收入增加完成.....')

                             break

                         except Exception as e:
                            print('选择有误,请重新选择')
                     else:
                         print('\033[31;1m对不起,您还没有分配班级与课程,请与校方联系!\033[0m')

                 elif foo=='':
                     students_list=teacher_char_class_students(list_l)
                     for k,obj in enumerate(students_list):
                         print('\033[34;1m学员编号:%s  学号:[%s] 姓名:[%s],\033[0m'%(k,obj.NUM,obj.NAME))
                     try:
                         students_name=int(input('请选择您要管理的学员编号:'))
                         students_obj=students_list[students_name]#将选中的学员对象赋值给变量
                         for i in students_obj.SCORE.score_dict:
                             print('课程：【%s】 分数：【%s】'%(i,students_obj.SCORE.score_dict[i]))
                         print('开始为学员打分:\033[46;1m 请为学员[%s] 的 [%s]的课程打分!\033[0m'%(students_obj.NAME,students_obj.CLASS_ID.get_id_file().TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME))
                         scores=int(input('请输入分数：'))
                         students_obj.SCORE.set(students_obj.CLASS_ID.get_id_file().TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME,scores)
                         for i in students_obj.SCORE.score_dict:
                             print('课程：【%s】 分数：【%s】'%(i,students_obj.SCORE.score_dict[i]))
                         students_obj.save()#进行保存
                         info_str='%s 讲师为学员[%s]的[%s]课程评分!'%(obj.NAME,students_obj.NAME,students_obj.CLASS_ID.get_id_file().TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME)
                         log_file.user_opert(info_str)
                         continue
                     except Exception as e:
                            print('输入有误,请重新选择')
                 elif foo=='':
                     show_teach_info(obj_teach)
                     continue
                 elif foo=='':
                     exit()
                 else:
                     print("选择有误，请重新选择！")
                     continue
         else:
             print('用户名或密码错误请重输入')
             info_str='%s登陆错误！'%user
             log_file.log_err(info_str)
             continue