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

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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

技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 
 5 
 6 #管理视图:创建讲师, 创建班级,创建课程
 7 
 8 import os ,sys
 9 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
10 sys.path.append(BASE_DIR)#增加环境变量
11 #print(BASE_DIR)
12 from core import admin_main #包含目录下的文件脚本
13 if __name__ == __main__:
14     admin_main.loging()
View Code

initalize.py

技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 #初始化系统
 5 import os ,sys
 6 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 7 sys.path.append(BASE_DIR)#增加环境变量
 8 from core import func_main
 9 if __name__ == __main__:
10     func_main.initialize_admin()#初始化管理员
View Code

stud.py

技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 import os ,sys
 5 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 6 sys.path.append(BASE_DIR)#增加环境变量
 7 
 8 from core import students_main
 9 from core.func_main import stud_alize
10 
11 if __name__ == __main__:
12     while True:
13         print(‘‘‘
14             温馨提示:如果未注册可以自助注册
15             1、自助注册
16             2、进入登陆
17             3、退出
18         ‘‘‘)
19         s=input(请选择:)
20         if s==1:
21             stud_alize()
22             continue
23         elif s==2:
24             students_main.stud_log()
25             continue
26         elif s==3:
27             exit()
28         else:
29             print(输入有误,请重输!)
View Code

teacher.py

技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 import os ,sys
 5 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 6 sys.path.append(BASE_DIR)#增加环境变量
 7 
 8 from core.teacher_main import teach_log
 9 
10 if __name__ == __main__:
11     teach_log()
View Code

config.py

技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 import os ,sys
 5 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 6 sys.path.append(BASE_DIR)#增加环境变量
 7 
 8 ADMIN_USER_FILE=BASE_DIR+\\db\\\\admin_user_list#定义管理员列表文件变量
 9 
10 ADMIN_DIR=BASE_DIR+\\db\\\\admin_file\\\\#定义管理员路径变量
11 CLASS_DIR=BASE_DIR+\\db\\\\classes\\\\#定义班级文件路径变量
12 COURSE_DIR=BASE_DIR+\\db\\\\course\\\\#定义学校课程文件路径变量
13 STUD_DIR=BASE_DIR+\\db\\\\students_file\\\\#定义学员文件路径变量
14 TEACH_DIR=BASE_DIR+\\db\\\\teacher_file\\\\#定义讲师文件路径变量
15 SCHOOL_DIR=BASE_DIR+\\db\\\\schools\\\\#定义学校路径变量
16 TEAC_COUR_DIR=BASE_DIR+\\db\\\\teac_to_cour\\\\#定义学校课程文件路径变量
17 
18 AMOUNT=300#每堂课收入基数
19 
20 
21 USER_LOG=BASE_DIR+\\log\\\\user_log.log#用户登陆日志文件
22 USER_ERRO=BASE_DIR+\\log\\\\user_erro.log#用户错误日志文件
23 USER_OPERT=BASE_DIR+\\log\\\\user_operation.log#用户操作日志文件
24 
25 ADMIN_LOG=BASE_DIR+\\log\\\\admin_log.log#管理员登陆日志文件
26 ADMIN_ERRO=BASE_DIR+\\log\\\\admin_erro.log#管理员错误日志文件
27 ADMIN_OPERT=BASE_DIR+\\log\\\\admin_operation.log#管理员操作日志文件
View Code

admin_main.py

技术分享
  1 #!usr/bin/env python
  2 #-*-coding:utf-8-*-
  3 # Author calmyan
  4 import pickle
  5 import os ,sys
  6 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
  7 sys.path.append(BASE_DIR)#增加环境变量
  8 #from core import user_pass
  9 from core import class_main
 10 from core import func_main
 11 from core import log_file
 12 from cfg import config
 13 
 14 
 15 def loging():#运行函数
 16     if func_main.file_char(config.ADMIN_USER_FILE):#检测相关文件是否不存在,进行初始化
 17         print(系统还未进行初始化!)
 18         func_main.initialize_admin()#进行初始化
 19     while True:
 20         print(管理员界面.center(60,=))
 21         print(按q/Q退出<<<<\\n\\n )
 22         user=input(用户名:).strip()
 23         if user==q or user==Q:
 24             exit()
 25         pwd=input(密码:).strip()
 26         data=class_main.Admin.login(user,pwd)#检测密码
 27         info_str=管理员[%s] 登录成功 %user
 28         log_file.admin_log(info_str)
 29         if data[tag]==True:
 30             print(data[data].center(60,=))
 31             while True:
 32                 print(‘‘‘===========================
 33                 温馨提示:创建班级前请先进行课师关联1
 34                 请按提示操作:
 35                 1、创建学校. 2、查看学校.
 36                 3、创建班级. 4、查看班级.
 37                 5、创建讲师. 6、查看讲师.
 38                 7、创建课程. 8、查看课程.
 39                 9、课师关联. 10、查看课师关联.
 40                 11、创建学员. 12、查看学员.
 41                 0、退出.
 42                 ================================
 43                 ‘‘‘)
 44                 foo=input(请选择:)
 45                 if foo==1:
 46                     func_main.car_school()
 47                     info_str=管理员:[%s]进行了创建学校!%user
 48                     log_file.admin_opert(info_str)
 49                     continue
 50                 elif foo==2:
 51                     func_main.show_school()
 52                     info_str=管理员:[%s]进行了查看学校!%user
 53                     log_file.admin_opert(info_str)
 54                     continue
 55                 elif foo==3:
 56                     func_main.car_classes()
 57                     info_str=管理员:[%s]进行了创建班级!%user
 58                     log_file.admin_opert(info_str)
 59                     continue
 60                 elif foo==4:
 61                     func_main.show_classes()
 62                     info_str=管理员:[%s]进行了查看班级!%user
 63                     log_file.admin_opert(info_str)
 64                     continue
 65                 elif foo==5:
 66                     func_main.car_teacher()
 67                     info_str=管理员:[%s]进行了创建讲师.%user
 68                     log_file.admin_opert(info_str)
 69                     continue
 70                 elif foo==6:
 71                     func_main.show_teacher()
 72                     info_str=管理员:[%s]进行了查看讲师!%user
 73                     log_file.admin_opert(info_str)
 74                     continue
 75                 elif foo==7:
 76                     func_main.car_course()
 77                     info_str=管理员:[%s]进行了创建课程!%user
 78                     log_file.admin_opert(info_str)
 79                     continue
 80                 elif foo==8:
 81                     func_main.show_course()
 82                     info_str=管理员:[%s]进行了查看课程!%user
 83                     log_file.admin_opert(info_str)
 84                     continue
 85                 elif foo==9:
 86                     func_main.associated_course()
 87                     info_str=管理员:[%s]进行了课师关联.!%user
 88                     log_file.admin_opert(info_str)
 89                     continue
 90                 elif foo==10:
 91                     func_main.show_teac_to_cour()
 92                     info_str=管理员:[%s]进行了查看课师关联!%user
 93                     log_file.admin_opert(info_str)
 94                     continue
 95                 elif foo==11:
 96                     func_main.car_students()
 97                     info_str=管理员:[%s]进行了创建学员!%user
 98                     log_file.admin_opert(info_str)
 99                     continue
100                 elif foo==12:
101                     func_main.show_students()
102                     info_str=管理员:[%s]进行了查看学员!%user
103                     log_file.admin_opert(info_str)
104                     continue
105                 elif foo==0:
106                     print("您已经成功退出!")
107                     info_str=管理员[%s] 成功退出 %user
108                     log_file.admin_log(info_str)
109                     exit()
110                 else:
111                     print("选择有误,请重新选择!")
112                     continue
113 
114         else:
115             print(用户名或密码错误请重输入)
116             info_str=管理员[%s] 登录错误 %user
117             log_file.admin_err(info_str)
118             continue
View Code

class_main.py

技术分享
  1 #!usr/bin/env python
  2 #-*-coding:utf-8-*-
  3 # Author calmyan
  4 import os ,sys,pickle,uuid,time
  5 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
  6 sys.path.append(BASE_DIR)#增加环境变量
  7 
  8 
  9 from cfg import config
 10 
 11 from core import id_classes
 12 
 13 #基础类
 14 class BasisClass(object):#基础类
 15     def save(self):
 16         file_dir=os.path.join(self.file_path,str(self.ID))#拼接文件路径
 17         pickle.dump(self,open(file_dir,wb))#序列化到文件
 18 
 19     @classmethod
 20     def open_file_list(cls):#传入当前类
 21         list_l=[]#定义一个列表
 22         for file in os.listdir(cls.file_path):#循环输出对应目录下的文件
 23             file_dir=os.path.join(cls.file_path,file)##拼接文件路径
 24             list_l.append(pickle.load(open(file_dir,rb)))#反序列化,追加到列表
 25         return list_l#返回列表
 26 
 27 #管理员类
 28 class Admin(BasisClass):
 29     file_path=config.ADMIN_DIR#管理员路经变量
 30     def __init__(self,user,pwd):
 31         self.ID=id_classes.Admin_id(self.file_path)#自动生成唯一ID
 32         self.USER=user
 33         self.PWD=pwd
 34         self.create_time=time.strftime(%Y-%m-%d %H:%M:%S)#创建的时间
 35     @staticmethod
 36     def login(name,pas):
 37         try:
 38             for obj in Admin.open_file_list():
 39                 if obj.USER == name and obj.PWD == pas:
 40                     tag=True
 41                     error=‘‘
 42                     data=\\033[32;1m登录成功\\033[0m
 43                     break
 44             else:
 45                 raise Exception(\\033[41;1m用户名或密码错误\\033[0m %name)
 46         except Exception as e:
 47             tag=False
 48             error=str(e)
 49             data=‘‘
 50         return {tag:tag,error:error,data:data}
 51 
 52 
 53 #学校类
 54 class SchoolName(BasisClass):
 55     file_path=config.SCHOOL_DIR#学校路径变量
 56     def __init__(self,schoo_name,addr):#学校名称 地址
 57         self.NAME=schoo_name#学校的名字
 58         self.ADDR=addr#地址
 59         self.ID=id_classes.Schools_id(self.file_path)#自动生成唯一ID
 60         self.create_time=time.strftime(%Y-%m-%d %H:%M:%S)#创建的时间
 61         self.amount=0#收入
 62     # def get_amount(self):
 63     #     return str(self.__amount)#返回收入
 64     def __str__(self):
 65         return self.NAME
 66 
 67 #班级类
 68 class Class_leven(BasisClass):#续承学校类
 69     ‘‘‘班级类‘‘‘
 70     file_path=config.CLASS_DIR#班级所在目录
 71     number=0#班级数
 72     def __init__(self,school_id,name,teac_to_cour_id):#学校, 班级名,讲师与课程
 73         self.NAME=name
 74         self.ID=id_classes.Class_id(self.file_path)#自动生成唯一ID
 75         self.SCHOOL_ID=school_id#学校名字ID
 76         self.create_time=time.strftime(%Y-%m-%d %H:%M:%S)#创建的时间
 77         self.TEAC_TO_LSIT_ID=teac_to_cour_id#讲师与课程列表
 78         Class_leven.number+=1
 79     def __str__(self):
 80         return self.NAME
 81 
 82 
 83 
 84 #   ‘‘‘老师类‘‘‘
 85 class Teacher(BasisClass):
 86     number=0#老师人数
 87     file_path=config.TEACH_DIR#讲师路经变量
 88     def __init__(self,name,pwd,age,sex,leve,school_id):#名字,密码,年龄,性别,学校名
 89         self.ID=id_classes.Teacher_id(self.file_path)
 90         self.NAME=name
 91         self.PWD=pwd
 92         self.AGE=age
 93         self.SEX=sex
 94         self.LEVE=leve
 95         self.SCHOOL_ID=school_id#关联学校
 96         self.amount=0#收入
 97         self.create_time=time.strftime(%Y-%m-%d %H:%M:%S)#创建的时间
 98         Teacher.number+=1#创建时加1
 99     def __str__(self):
100         return self.NAME
101     @staticmethod
102     def login(name,pas):
103         try:
104             for obj in Teacher.open_file_list():
105                 if obj.NAME == name and obj.PWD == pas:
106                     tag=True
107                     error=‘‘
108                     file_dir=os.path.join(obj.file_path,str(obj.ID))#拼接文件路径
109                     data=file_dir#返回对应的文件
110                     break
111             else:
112                 raise Exception(\\033[41;1m用户名或密码错误\\033[0m %name)
113         except Exception as e:
114             tag=False
115             error=str(e)
116             data=‘‘
117         return {tag:tag,error:error,data:data}
118 
119 #‘‘‘学生类‘‘‘
120 class Students(BasisClass):
121     ‘‘‘学生类‘‘‘
122     file_path=config.STUD_DIR#学生文件路径变量
123     number=0#学生总人数
124     def __init__(self,num,name,pwd,age,sex,school_id,class_leven_id,phone):#学号,名字,年龄,性别,学校,班级,电话,分数,学费
125         self.ID=id_classes.Students_id(self.file_path)
126         self.NUM=num
127         self.NAME=name
128         self.PWD=pwd
129         self.AGE=age
130         self.SEX=sex
131         self.SCHOOL_ID=school_id
132         self.CLASS_ID=class_leven_id
133         self.PHONE=phone
134         self.SCORE=Score(self.NUM)
135         self.create_time=time.strftime(%Y-%m-%d %H:%M:%S)#创建的时间
136         self.FEES=0
137     def __str__(self):
138         return self.NAME
139     @staticmethod
140     def login(name,pas):#登陆检测
141         try:
142             for obj in Students.open_file_list():
143                 if obj.NAME == name and obj.PWD == pas:
144                     tag=True
145                     error=‘‘
146                     file_dir=os.path.join(obj.file_path,str(obj.ID))#拼接文件路径
147                     data=file_dir#返回对应的文件
148                     break
149             else:
150                 raise Exception(\\033[41;1m用户名或密码错误\\033[0m %name)
151         except Exception as e:
152             tag=False
153             error=str(e)
154             data=‘‘
155         return {tag:tag,error:error,data:data}
156 
157 
158 
159 #‘‘‘课程类‘‘‘
160 class Course(BasisClass):
161     file_path=config.COURSE_DIR#课程文件路径变量
162     def __init__(self,name,cycle,fees,school_id,):#传入名字,周期,学费,学校对应的ID
163         self.ID=id_classes.Course_id(self.file_path)#自动生成唯一ID
164         self.NAME=name
165         self.CYCLE=cycle
166         self.FEES=fees
167         self.SCHOOL_ID=school_id
168         self.SCORE=Score(self.ID)#传入自身ID 实例化出来一个分数对象
169         self.CREATE_TIME=time.strftime(%Y-%m-%d %H:%M:%S)#创建的时间
170     def __str__(self):
171         return self.NAME
172 
173 #讲师到课程
174 class Teac_to_cour(BasisClass):
175     ‘‘‘讲师到课程‘‘‘
176     file_path=config.TEAC_COUR_DIR#讲师到课程文件路径变量
177     def __init__(self,course_name,teacher_name,school_id):#课程,讲师
178         self.ID=id_classes.Teac_to_cour_id(self.file_path)#自动生成唯一ID
179         self.NAME=teacher_name+->+course_name
180         self.COURSE_NAME=course_name#课程名称
181         self.TEACHER_NAME=teacher_name#讲师姓名
182         self.SCHOOL_ID=school_id#学校ID
183     def __str__(self):
184         return self.NAME
185 
186 
187 #分数类
188 class Score():
189     def __init__(self,nid):
190         self.ID=nid#学号
191         self.score_dict={}#分数字典
192 
193     def set(self,Teac_to_cour_id,number):
194         self.score_dict[Teac_to_cour_id]=number#课程与讲师合到分数
195 
196     def get(self,Teac_to_cour_id):
197         return self.score_dict[Teac_to_cour_id]#取出分数
View Code

func_main.py

技术分享
  1 #!usr/bin/env python
  2 #-*-coding:utf-8-*-
  3 # Author calmyan
  4 import os ,sys,pickle,uuid,hashlib,time
  5 
  6 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
  7 sys.path.append(BASE_DIR)#增加环境变量
  8 from cfg import config
  9 from core import class_main
 10 from core import log_file
 11 
 12 
 13 #id生成
 14 def id_uu():
 15     return str(uuid.uuid1())
 16 #id生成
 17 def id_md5():
 18     id_i=hashlib.md5()
 19     id_i.update(bytes(str(time.time()),encoding=utf8))
 20     return id_i.hexdigest()#返回用时间创建 的ID
 21 
 22 #初始化检测
 23 def file_char(name):#
 24     if  not os.path.exists(name):#检测相关文件是否不存在
 25         #info={‘北京‘:[],‘上海‘:[]}
 26         #file_pick(name,info)#进行初始化
 27         return True
 28     else:
 29         return False
 30 
 31 #初始化管理员
 32 def initialize_admin():
 33     print(系统正在初始化....)
 34     try:
 35         user = input(请输入初始化用户名:)
 36         pwd = input(请输入初始化密码:)
 37         obj = class_main.Admin(user, pwd)
 38         obj.save()
 39         with open(config.ADMIN_USER_FILE,w) as f:
 40             f.write(yes)#应文件用来确认初始化
 41         return True
 42     except Exception as e:
 43         print(e)
 44 
 45 #创建学校函数
 46 def car_school():
 47     try:
 48         print(提示: B/b 返回上级!)
 49         names=input(请输入您要添加的学校名字:).strip()
 50         if names==b or names==B:
 51             return
 52         addrs=input(请输入学校所在地址:).strip()
 53         if addrs==b or addrs==B:
 54             return
 55         school_name_list=[(obj.NAME,obj.ADDR) for obj in class_main.SchoolName.open_file_list()]#进行学校校区重名检测用,返回列表
 56         if (names,addrs) in school_name_list:
 57             print(\\033[41;1m[%s] [%s]校区 已经存在,不可重复创建\\033[0m %(names,addrs))
 58             return
 59         else:
 60             obj=class_main.SchoolName(names,addrs)#创建学校
 61             obj.save()#pickle序列化保存到文件
 62             print(\\033[32;1m创建[%s] 学校,[%s]校区成功!\\033[0m%(names,addrs))
 63             return
 64     except Exception as e:
 65         print(e)
 66 
 67 #查看学校
 68 def show_school():
 69     for obj in class_main.SchoolName.open_file_list():
 70         #amo=obj.get_amount()
 71         print(\\033[32;1m学校[%s] 地址[%s] 总收入[%s] 创建日期[%s] \\033[0m.center(60,-) %(obj.NAME,obj.ADDR,obj.amount,obj.create_time))
 72 
 73 #创建课程函数
 74 def car_course():
 75     print(\\033[36;1m创建课程\\033[0m.center(60,=))
 76     school_list=class_main.SchoolName.open_file_list()#打开学校列表
 77     try:
 78     #while True:
 79         print(\\033[33;1m提示: B/b 返回上级!\\033[0m)
 80         fon=input(===============其他键确认开始创建课程:)
 81         if fon==b or fon==B:
 82             return
 83         for k,obj in enumerate(school_list):
 84             print(\\033[35;1m学校编号:%s,学校名称:%s,校区:%s\\033[0m%(k,obj,obj.ADDR))
 85         sch_name=int(input(请选择学校: ))
 86         school_obj=school_list[sch_name]#用数字选定学校
 87         # print(school_list[sch_name])
 88         # print(school_obj.ID.ID)
 89         course_name=input(请输入要创建的课程名:).strip()
 90         price=input(请输入课程价格: ).strip()
 91         period=input(请输入课程周期: ).strip()
 92         course_name_list=[(obj.NAME,obj.SCHOOL_ID.ID) for obj in class_main.Course.open_file_list()]#返回所有课程是名字,对应的学校列表
 93         if (course_name,school_obj.ID.ID) in course_name_list:#查课程名,与学校名是否存
 94             print(\\033[43;1m课程[%s] 已经存在,不能重复创建\\033[0m %(course_name))
 95             return
 96         else:
 97             obj=class_main.Course(course_name,period,price,school_obj.ID)
 98             obj.save()
 99             print(\\033[33;1m课程[%s] 价格[%s] 周期[%s]创建成功\\033[0m %(obj.NAME,obj.FEES,obj.CYCLE))
100             return
101     except Exception as e:
102         return print(选择有误,请重新选择)
103 
104 #查看课程
105 def show_course():
106     for obj in class_main.Course.open_file_list():#调用ID类中的方法
107         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))
108 
109 #创建讲师函数
110 def car_teacher():
111     print(\\033[36;1m创建讲师\\33[0m.center(60,=))
112     school_list=class_main.SchoolName.open_file_list()#打开学校列表
113     try:
114     #while True:
115         print(\\033[33;1m提示: B/b 返回上级!\\033[0m)
116         fon=input(===============其他键确认开始创建讲师:)
117         if fon==b or fon==B:
118             return
119         for k,obj in enumerate(school_list):
120             print(\\033[35;1m学校编号:%s,学校名称:%s,校区:%s\\033[0m%(k,obj,obj.ADDR))
121         sch_name=int(input(请选择学校: ))
122         school_obj=school_list[sch_name]#用数字选定学校
123         uname=input(请输入要创建的讲师名字:).strip()
124         upwd=input(请输入讲师登陆密码:).strip()
125         uleve=input(请输入讲师级别:).strip()
126         uage=input(请输入年龄:).strip()
127         usex=input(请输入性别:).strip()
128         uname_list=[(obj.NAME,obj.SCHOOL_ID.ID) for obj in class_main.Teacher.open_file_list()]#返回所有讲师是名字,对应的学校列表
129         if (uname,school_obj.ID.ID) in uname_list:#查讲师名,与学校名是否存
130             print(\\033[43;1m讲师[%s] 已经存在,不能重复创建\\033[0m %(uname))
131             return
132         else:
133             obj=class_main.Teacher(uname,upwd,uage,usex,uleve,school_obj.ID)
134             obj.save()
135             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))
136             return
137     except Exception as e:
138         return print(选择有误,请重新选择)
139 
140 #查看讲师
141 def show_teacher():
142     for obj in class_main.Teacher.open_file_list():#调用ID类中的方法
143         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))
144 
145 #创建班级函数
146 def car_classes():
147     print(\\033[36;1m创建班级\\33[0m.center(60,=))
148     school_list=class_main.SchoolName.open_file_list()#打开学校列表
149     try:
150     #while True:
151         print(\\033[33;1m提示: B/b 返回上级!\\033[0m)
152         fon=input(===============其他键确认开始创建班级:)
153         if fon==b or fon==B:
154             return
155         for k,obj in enumerate(school_list):
156             print(\\033[35;1m学校编号:%s,学校名称:%s,校区:%s\\033[0m%(k,obj,obj.ADDR))
157         sch_name=int(input(请选择学校: ))
158         school_obj=school_list[sch_name]#用数字选定学校
159         uname=input(请输入要创建的班级名:).strip()
160         uname_list=[(obj.NAME,obj.SCHOOL_ID.ID) for obj in class_main.Class_leven.open_file_list()]#返回所有班级是名字,对应的学校列表
161         if (uname,school_obj.ID.ID) in uname_list:#查课程名,与学校名是否存
162             print(\\033[43;1m[%s] [%s]校区 ,[%s]班级 已经存在,不能重复创建\\033[0m %(school_obj.ID.get_id_file().NAME,school_obj.ID.get_id_file().ADDR,uname))
163             return
164         else:
165             teac_to_cour_list=class_main.Teac_to_cour.open_file_list()#打关联列表
166             for k ,obj in enumerate(teac_to_cour_list):
167                 if str(school_obj.ID)==str(obj.SCHOOL_ID.ID):
168                     print(\\033[35;1m课程编号:%s,关联的讲师:%s\\033[0m%(k,obj))
169             coures_name=int(input(请选择讲师与课程))
170             teac_to_cour_obj=teac_to_cour_list[coures_name]
171             obj=class_main.Class_leven(school_obj.ID,uname,teac_to_cour_obj.ID)
172             obj.save()
173             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))
174             return
175     except Exception as e:
176         return print(选择有误,请重新选择)
177 
178 #查看班级
179 def show_classes():
180     for obj in class_main.Class_leven.open_file_list():#调用ID类中的方法  学校ID   老师到课程ID
181         print(\\033[32;1m[%s] [%s]校区 [%s]班 所开课程:[%s]  讲师:[%s]\\033[0m.center(60,-)%(obj.SCHOOL_ID.get_id_file().NAME,182                                                                                       obj.SCHOOL_ID.get_id_file().ADDR,183                                                                                       obj.NAME,184                                                                                       obj.TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME,obj.TEAC_TO_LSIT_ID.get_id_file().TEACHER_NAME))
185 
186 #关联课程
187 def associated_course():
188     try:
189     #while True:
190         school_list=class_main.SchoolName.open_file_list()#打开学校列表
191         print(课程关联.center(60,=))
192         for k,obj in enumerate(school_list):
193                 print(\\033[35;1m学校编号:%s,学校名称:%s,校区:%s\\033[0m%(k,obj,obj.ADDR))
194         sch_name=int(input(请选择学校: ))
195         school_obj=school_list[sch_name]#用数字选定学校
196         course_list=class_main.Course.open_file_list()#打开课程列表
197         for k,obj in enumerate(course_list):
198             if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
199                 print(\\033[35;1m课程编号:%s,课程名称:%s\\033[0m%(k,obj))
200         cou_name=int(input(请选择课程: ))
201         course_obj=course_list[cou_name]#用数字选定课程
202         teacher_list=class_main.Teacher.open_file_list()#打开讲师列表
203         for k,obj in enumerate(teacher_list):
204             if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
205                 print(\\033[35;1m讲师编号:%s,讲师姓名:%s\\033[0m%(k,obj))
206         teach_name=int(input(请选择讲师: ))
207         teach_obj=teacher_list[teach_name]#用数字选定老师
208         uname_list=[(obj.COURSE_NAME,obj.TEACHER_NAME,obj.SCHOOL_ID.ID) for obj in class_main.Teac_to_cour.open_file_list()]#返回所有关联课程列表
209         if (course_obj.NAME,teach_obj.NAME,school_obj.ID.ID) in uname_list:#查课程名,与学校名是否存
210             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))
211             return
212         else:
213             obj=class_main.Teac_to_cour(course_obj.NAME,teach_obj.NAME,school_obj.ID)
214             obj.save()
215             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))
216             return
217     except Exception as e:
218         return print(选择有误,请重新选择)
219 
220 #查看课程关联
221 def show_teac_to_cour():
222     for obj in class_main.Teac_to_cour.open_file_list():
223         print(\\033[32;1m[%s] [%s]校区 课程:[%s]  讲师:[%s]\\033[0m.center(60,=)%(obj.SCHOOL_ID.get_id_file().NAME,224                                                                                       obj.SCHOOL_ID.get_id_file().ADDR,225                                                                               obj.COURSE_NAME,obj.TEACHER_NAME))
226 
227 #学员自动注册
228 def stud_alize():
229     print(\\033[36;1m学员自助注册\\33[0m.center(60,=))
230     school_list=class_main.SchoolName.open_file_list()#打开学校列表
231     try:
232     #while True:
233         print(\\033[33;1m提示: B/b 返回上级!\\033[0m)
234         fon=input(===============其他键确认开始注册:)
235         if fon==b or fon==B:
236             return
237         for k,obj in enumerate(school_list):
238             print(\\033[35;1m学校编号:%s,学校名称:%s,校区:%s\\033[0m%(k,obj,obj.ADDR))
239         sch_name=int(input(请选择您要注册的学校: ))
240         uname_list=[(obj.NUM,obj.PHONE) for obj in class_main.Students.open_file_list()]#返回所有学员的名字,对应的学校,电话号码列表
241         school_obj=school_list[sch_name]#用数字选定学校
242         unum=int(input(请输入您要的学号:).strip())
243         if (unum)in uname_list:#查学号是否存
244             print(\\033[43;1m学号[%s] 已经存在,不能重复创建\\033[0m %(unum))
245             return
246         uname=input(请输入注册名字:).strip()
247         upwd=input(请输入登陆密码:).strip()
248         uphone=input(请输入电话号码:).strip()
249         uage=input(请输入年龄:).strip()
250         usex=input(请输入性别:).strip()
251         if (uphone) in uname_list:#查电话是否存
252             print(\\033[43;1m学员[%s] 电话号码已经存在,不能重复创建\\033[0m %(uname))
253             return
254         else:
255             class_list=class_main.Class_leven.open_file_list()#打开班级
256             for k,obj in enumerate(class_list):
257                 if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
258                     print(\\033[35;1m班级编号:%s, [%s]\\033[0m%(k,obj))
259             uclass_name=int(input(请选择班级:))
260             class_name_obj=class_list[uclass_name]#
261             obj=class_main.Students(unum,uname,upwd,uage,usex,school_obj.ID,class_name_obj.ID,uphone)
262             obj.save()
263             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))
264             return
265     except Exception as e:
266         return print(输入有误,请重新选择)
267 
268 
269 #创建学员
270 def car_students():
271     print(\\033[36;1m创建学员\\33[0m.center(60,=))
272     school_list=class_main.SchoolName.open_file_list()#打开学校列表
273     try:
274     #while True:
275         print(\\033[33;1m提示: B/b 返回上级!\\033[0m)
276         fon=input(===============其他键确认开始创建学员:)
277         if fon==b or fon==B:
278             return
279         for k,obj in enumerate(school_list):
280             print(\\033[35;1m学校编号:%s,学校名称:%s,校区:%s\\033[0m%(k,obj,obj.ADDR))
281         sch_name=int(input(请选择学校: ))
282         uname_list=[(obj.NUM,obj.PHONE) for obj in class_main.Students.open_file_list()]#返回所有学员的名字,对应的学校,电话号码列表
283         school_obj=school_list[sch_name]#用数字选定学校
284         unum=int(input(请输入要创建学员学号:).strip())
285         if (unum)in uname_list:#查学号是否存
286             print(\\033[43;1m学号[%s] 已经存在,不能重复创建\\033[0m %(unum))
287             return
288         uname=input(请输入要创建学员名字:).strip()
289         upwd=input(请输入学员登陆密码:).strip()
290         uphone=input(请输入电话号码:).strip()
291         uage=input(请输入年龄:).strip()
292         usex=input(请输入性别:).strip()
293         if (uphone) in uname_list:#查电话是否存
294             print(\\033[43;1m学员[%s] 电话号码已经存在,不能重复创建\\033[0m %(uname))
295             return
296         else:
297             class_list=class_main.Class_leven.open_file_list()#打开班级
298             for k,obj in enumerate(class_list):
299                 if str(obj.SCHOOL_ID.ID)==str(school_obj.ID):#判断学校名是否相同
300                     print(\\033[35;1m班级编号:%s, [%s]\\033[0m%(k,obj))
301             uclass_name=int(input(请选择班级:))
302             class_name_obj=class_list[uclass_name]#
303             obj=class_main.Students(unum,uname,upwd,uage,usex,school_obj.ID,class_name_obj.ID,uphone)
304             obj.save()
305             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))
306             return
307     except Exception as e:
308         return print(输入有误,请重新选择)
309 
310 #查看学员
311 def show_students():
312     for obj in class_main.Students.open_file_list():
313         print(\\033[32;1m[%s] [%s]校区 学员编号:[%s] 学员姓名:[%s] 年龄:[%s] 性别:[%s] 电话:[%s] 所在班级:[%s]\\033[0m.center(60,=)%(obj.SCHOOL_ID.get_id_file().NAME,314                                                                                   obj.SCHOOL_ID.get_id_file().ADDR,obj.NUM,315                                                                           obj.NAME,obj.AGE,obj.SEX,obj.PHONE,obj.CLASS_ID.get_id_file().NAME))
316 
317 
318 
319 #学员个人信息查看
320 
321 def show_info(obj):
322     info=‘‘‘\\033[34;1m
323         学号:{NUM}\\t\\t\\t姓名:{NAME}\\t\\t\\t年龄:{AGE}\\t\\t\\t性别:{SEX}\\t\\t\\t电话:{PHONE}
324 
325         学校:{SCHOOL}\\t\\t\\t校区:{SCHOOL_}\\t\\t\\t班级:{CLASS}\\t\\t\\t学费:{FEES}\\t\\t\\t分数:{SCORE}
326 
327         \\033[0m‘‘‘.format(NUM=str(obj.NUM),NAME=obj.NAME,AGE=obj.AGE,SEX=obj.SEX,PHONE=obj.PHONE,328                    SCHOOL=obj.SCHOOL_ID.get_id_file().NAME,SCHOOL_=obj.SCHOOL_ID.get_id_file().ADDR,329                    CLASS=obj.CLASS_ID.get_id_file().NAME,FEES=str(obj.FEES),SCORE=obj.SCORE.score_dict)
330 
331     print(info)
332 
333 #讲师个人信息查看
334 
335 def show_teach_info(obj):
336     info=‘‘‘\\033[34;1m
337         姓名:{NAME}\\t\\t\\t年龄:{AGE}\\t\\t\\t性别:{SEX}\\t\\t\\t
338 
339         学校:{SCHOOL}\\t\\t\\t校区:{SCHOOL_}\\t\\t\\t级别:{LEVE}\\t\\t\\t收入:{amount}
340 
341         \\033[0m‘‘‘.format(NAME=obj.NAME,AGE=obj.AGE,SEX=obj.SEX,342                    SCHOOL=obj.SCHOOL_ID.get_id_file().NAME,SCHOOL_=obj.SCHOOL_ID.get_id_file().ADDR,343                    LEVE=obj.LEVE,amount=str(obj.amount))
344 
345     print(info)
346 
347 #讲师操作相关函数
348 def teacher_char_l(obj_teach):
349     class_teach_list=[]#讲师的班级列表
350     for obj in class_main.Class_leven.open_file_list():#打开班级列表
351         if obj_teach.NAME==obj.TEAC_TO_LSIT_ID.get_id_file().TEACHER_NAME:#查询对应的课程老师
352             class_teach_list.append(obj)#加入列表
353     return class_teach_list#讲师的班级列表
354 
355 #讲师操作相关函数查看学生
356 def teacher_char_class(class_teach_list):
357     while True:
358         for k,obj in enumerate(class_teach_list):
359             print(\\033[32;1m班级编号:%s 班级名称:[%s]\\033[0m%(k,obj))
360         try:
361             sart_class=int(input(请选择您要查看的学员班级编号:))
362             sart_class_obj=class_teach_list[sart_class]#用数字选定班级
363             for obj in class_main.Students.open_file_list():#查看学生
364                 if str(obj.CLASS_ID.get_id_file().NAME)==str(sart_class_obj.NAME):#查看对应班级
365                     print(\\033[34;1m学号:[%s] 姓名:[%s]\\033[0m%(obj.NUM,obj.NAME))
366             return
367         except Exception as e:
368            print(选择有误,请重新选择)
369     else:
370         print(\\033[31;1m对不起,您还没有分配班级与课程,请与校方联系!\\033[0m)
371 
372 
373 #讲师操作相关函数学员成绩
374 def teacher_char_class_students(class_teach_list):
375     while True:
376         for k,obj in enumerate(class_teach_list):
377             print(\\033[32;1m班级编号:%s 班级名称:[%s]\\033[0m%(k,obj))
378         try:
379             sart_class=int(input(请选择您要查看的学员班级编号:))
380             sart_class_obj=class_teach_list[sart_class]#用数字选定班级
381             students_list=[]
382             for obj in class_main.Students.open_file_list():#查看学习
383                 if str(obj.CLASS_ID.get_id_file().NAME)==str(sart_class_obj.NAME):#查看对应班级
384                     #print(‘\\033[34;1m学号:[%s] 姓名:[%s]\\033[0m‘%(obj.NUM,obj.NAME))
385                     students_list.append(obj)#返回当前班级学员列表
386             return students_list
387         except Exception as e:
388            print(选择有误,请重新选择)
389     else:
390         print(\\033[31;1m对不起,您还没有分配班级与课程,请与校方联系!\\033[0m)
391 
392 
393 #获取学生上课课程函数
394 def studnts_class(class_name):
395     for obj in class_main.Course.open_file_list():#返回所有课程的名字
396         if class_name==str(obj.NAME):
397             return obj
398 
399 
400 #交学费
401 def jxf(file_dir,user):
402     obj=pickle.load(open(file_dir,rb))
403     money=input(请输入学费金额:)
404     if money.isdigit():#是否为整数
405         obj.FEES=obj.FEES+int(money)
406         obj.save()#进行保存
407         print("交费成功,金额:\\033[32;1m%s\\033[0m"%money)
408         file_dir=os.path.join(config.SCHOOL_DIR,str(obj.SCHOOL_ID.get_id_file().ID))##拼接文件路径
409         school_obj=pickle.load(open(file_dir,rb))#反序列化,追加到文件
410         school_obj.amount+=int(money)
411         school_obj.save()#进行保存
412         info_str=%s 学员进行交费,金额:[%s]%(user,money)
413         log_file.user_opert(info_str)
414     else:
415         print(请正确输入整数!)
View Code
id_classes.py
技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 import pickle,os
 5 from core import func_main
 6 # ID 类
 7 class id_mode(object):#id 基础类
 8     def __init__(self,file_path):
 9         self.ID=func_main.id_uu()##自动生成唯一ID
10         self.File_path=file_path#传入的路径
11     def __str__(self):
12         return self.ID
13     def get_id_file(self):#通过ID找到对应文件
14         for filename in os.listdir(self.File_path):
15             if filename == self.ID:
16                 file_dir=os.path.join(self.File_path,self.ID)#拼接文件路径
17                 return pickle.load(open(file_dir,br))#返回反序列化的文件对象
18         return None
19 
20 class Admin_id(id_mode):#管理员类
21     def __init__(self,file_path):
22         super(Admin_id,self).__init__(file_path)    #
23 
24 class Class_id(id_mode):#班级类
25     def __init__(self,file_path):
26         super(Class_id,self).__init__(file_path)
27 
28 class Course_id(id_mode):#课程类\\
29     def __init__(self,file_path):
30         super(Course_id,self).__init__(file_path)
31 
32 class Schools_id(id_mode):#学校类
33     def __init__(self,file_path):
34         super(Schools_id,self).__init__(file_path)
35 
36 class Students_id(id_mode):#学生类
37      def __init__(self,file_path):
38         super(Students_id,self).__init__(file_path)
39 
40 class Teac_to_cour_id(id_mode):#讲师到课程类
41      def __init__(self,file_path):
42         super(Teac_to_cour_id,self).__init__(file_path)
43 
44 class Teacher_id(id_mode):#讲师类
45      def __init__(self,file_path):
46         super(Teacher_id,self).__init__(file_path)
View Code

log_file.py

技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 #日志记录相关函数
 5 import os,logging,time
 6 from cfg import config
 7 
 8 
 9 def log_err(info_str):#错误日志,传入的错误内容
10     logger=logging.getLogger(用户登陆错误日志)#设置日志模块
11     logger.setLevel(logging.DEBUG)
12     fh=logging.FileHandler(config.USER_ERRO,encoding=utf-8)#写入文件
13     fh.setLevel(logging.DEBUG)#写入信息的级别
14     fh_format=logging.Formatter(%(asctime)s %(message)s,datefmt=%m/%d/%Y %I:%M:%S %p)#日志格式
15     fh.setFormatter(fh_format)#关联格式
16     logger.addHandler(fh)#添加日志输出模式
17     logger.warning(info_str)
18     return 0
19 
20 def log_log(info_str):#登陆日志,传入内容
21     logger=logging.getLogger(用户成功登陆日志)#设置日志模块
22     logger.setLevel(logging.DEBUG)
23     fh=logging.FileHandler(config.USER_LOG,encoding=utf-8)#写入文件
24     fh.setLevel(logging.DEBUG)#写入信息的级别
25     fh_format=logging.Formatter(%(asctime)s %(message)s,datefmt=%m/%d/%Y %I:%M:%S %p)#日志格式
26     fh.setFormatter(fh_format)#关联格式
27     logger.addHandler(fh)#添加日志输出模式
28     logger.warning(info_str)
29     return 0
30 
31 def user_opert(info_str):#用户操作日志,传入内容
32     logger=logging.getLogger(用户操作日志)#设置日志模块
33     logger.setLevel(logging.CRITICAL)
34     fh=logging.FileHandler(config.USER_OPERT,encoding=utf-8)#写入文件
35     fh.setLevel(logging.CRITICAL)#写入信息的级别
36     fh_format=logging.Formatter(%(asctime)s %(message)s,datefmt=%m/%d/%Y %I:%M:%S %p)#日志格式
37     fh.setFormatter(fh_format)#关联格式
38     logger.addHandler(fh)#添加日志输出模式
39     logger.critical(info_str)
40     return 0
41 
42 
43 
44 def admin_log(info_str):#管理员登陆日志,传入内容
45     logger=logging.getLogger(管理员成功登陆日志)#设置日志模块
46     logger.setLevel(logging.DEBUG)
47     fh=logging.FileHandler(config.ADMIN_LOG,encoding=utf-8)#写入文件
48     fh.setLevel(logging.DEBUG)#写入信息的级别
49     fh_format=logging.Formatter(%(asctime)s %(message)s,datefmt=%m/%d/%Y %I:%M:%S %p)#日志格式
50     fh.setFormatter(fh_format)#关联格式
51     logger.addHandler(fh)#添加日志输出模式
52     logger.warning(info_str)
53     return 0
54 
55 def admin_err(info_str):#管理员错误日志,传入的错误内容
56     logger=logging.getLogger(管理员登陆错误日志)#设置日志模块
57     logger.setLevel(logging.DEBUG)
58     fh=logging.FileHandler(config.ADMIN_ERRO,encoding=utf-8)#写入文件
59     fh.setLevel(logging.DEBUG)#写入信息的级别
60     fh_format=logging.Formatter(%(asctime)s %(message)s,datefmt=%m/%d/%Y %I:%M:%S %p)#日志格式
61     fh.setFormatter(fh_format)#关联格式
62     logger.addHandler(fh)#添加日志输出模式
63     logger.warning(info_str)
64     return 0
65 
66 def admin_opert(info_str):#管理员操作日志,传入内容
67     logger=logging.getLogger(管理员操作日志)#设置日志模块
68     logger.setLevel(logging.CRITICAL)
69     fh=logging.FileHandler(config.ADMIN_OPERT,encoding=utf-8)#写入文件
70     fh.setLevel(logging.CRITICAL)#写入信息的级别
71     fh_format=logging.Formatter(%(asctime)s %(message)s,datefmt=%m/%d/%Y %I:%M:%S %p)#日志格式
72     fh.setFormatter(fh_format)#关联格式
73     logger.addHandler(fh)#添加日志输出模式
74     logger.critical(info_str)
75     return 0
View Code

students_main.py

技术分享
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan
 4 import os ,sys,pickle,time
 5 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 6 sys.path.append(BASE_DIR)#增加环境变量
 7 from cfg import  config
 8 from core.class_main import Students
 9 from core.class_main import Course
10 
11 from core.func_main import show_info
12 from core.func_main import studnts_class
13 from core.func_main import jxf
14 from core import log_file
15 
16 
17 
18 def stud_log():#学生登陆
19     while True:
20         print(学生登陆界面.center(60,=))
21         print(按q/Q退出<<<<\\n\\n )
22         user=input(用户名:).strip()
23         if user==q or user==Q:
24             exit()
25         pwd=input(密码:).strip()
26         data=Students.login(user,pwd)#检测密码
27         if data[tag]==True:
28             print(\\033[32;1m登录成功\\033[0m)
29             info_str=学员[%s] 登录成功 %user
30             log_file.log_log(info_str)
31             file_dir=data[data]#学员对应的文件路径
32             while True:
33                 #obj=pickle.load(open(file_dir,‘rb‘))
34                 print(‘‘‘===================
35                 请选择你的操作:
36 
37                 1、交学费.
38                 2、查看个人信息.
39                 3、开始上课.
40                 4、退出.
41 
42                 ==============================
43                 ‘‘‘)
44                 foo=input(请选择:)
45                 if foo==1:
46                     jxf(file_dir,user)
47                     # obj=pickle.load(open(file_dir,‘rb‘))
48                     # money=input(‘请输入学费金额:‘)
49                     # if money.isdigit():#是否为整数
50                     #     obj.FEES=obj.FEES+int(money)
51                     #     obj.save()#进行保存
52                     #     print("交费成功,金额:\\033[32;1m%s\\033[0m"%money)
53                     #     file_dir=os.path.join(config.SCHOOL_DIR,str(obj.SCHOOL_ID.get_id_file().ID))##拼接文件路径
54                     #     school_obj=pickle.load(open(file_dir,‘rb‘))#反序列化,追加到文件
55                     #     school_obj.amount+=int(money)
56                     #     school_obj.save()#进行保存
57                     #     info_str=‘%s 学员进行交费,金额:[%s]‘%(user,money)
58                     #     log_file.user_opert(info_str)
59                     #     continue
60                     # else:
61                     #     print(‘请正确输入整数!‘)
62                     continue
63                 elif foo==2:
64                     obj_2=pickle.load(open(file_dir,rb))
65                     show_info(obj_2)
66                     info_str=%s 学员进行个人信息查询!%(user)
67                     log_file.user_opert(info_str)
68                     continue
69                 elif foo==3:
70                     obj_3=pickle.load(open(file_dir,rb))
71                     class_name=obj_3.CLASS_ID.get_id_file().TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME#获取课程名
72                     class_obj=studnts_class(class_name)#获取课程对象
73                     if int(obj_3.FEES)>=int(class_obj.FEES):#如果交的学费大于课程的费用才能上课
74                         print(开始上课....)
75                         for i in range(50):#加载动画
76                             sys.stdout.write(#)
77                             sys.stdout.flush()
78                             time.sleep(0.05)
79                         print(\\n恭喜!您已经完成本次课时.....)
80                         info_str=%s 学员上课,完成课时!%(user)
81                         log_file.user_opert(info_str)
82                         continue
83                     else:
84                         print(您的学费不够,请先交学费)
85                         continue
86                 elif foo==4:
87                     print(您已经成功退出!)
88                     info_str=学员[%s] 成功退出 %user
89                     log_file.log_log(info_str)
90                     exit()
91                 else:
92                     print(选择有误,请重新选择!)
93                     continue
94         else:
95             print(用户名或密码错误请重输入)
96             info_str=%s登陆错误!%user
97             log_file.log_err(info_str)
98             continue
View Code

teacher_main.py

技术分享
  1 #!usr/bin/env python
  2 #-*-coding:utf-8-*-
  3 # Author calmyan
  4 #上课时选择班级, 查看班级学员列表 , 修改所管理的学员的成绩
  5 import os ,sys,pickle,time
  6 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
  7 sys.path.append(BASE_DIR)#增加环境变量
  8 from core.class_main import Teacher
  9 from core.func_main import teacher_char_l
 10 from core.func_main import teacher_char_class
 11 from core.func_main import teacher_char_class_students
 12 from core.func_main import show_teach_info
 13 from cfg import config
 14 from core import log_file
 15 def teach_log():#讲师运行函数
 16     while True:
 17         print(讲师界面.center(60,=))
 18         print(按q/Q退出<<<<\\n\\n )
 19         user=input(用户名:).strip()
 20         if user==q or user==Q:
 21             exit()
 22         pwd=input(密码:).strip()
 23         data=Teacher.login(user,pwd)#检测密码
 24         if data[tag]==True:
 25             print(\\033[32;1m登录成功\\033[0m)
 26             info_str=讲师[%s] 登录成功 %user
 27             log_file.log_log(info_str)
 28             file_dir=data[data]#讲师对应的文件路径
 29             while True:
 30                 obj_teach=pickle.load(open(file_dir,rb))
 31                 print(‘‘‘===================
 32                 请选择你的操作:
 33 
 34                 1、查看班级学员列表.
 35                 2、选择班级上课.
 36                 3、管理的学员的成绩.
 37                 4、查看讲师个人信息.
 38                 5、退出.
 39 
 40                 ==============================
 41                 ‘‘‘)
 42                 foo=input(请选择你的操作:)
 43                 list_l=teacher_char_l(obj_teach)#讲师的班级列表
 44                 if foo==1:
 45                     print(\\033[35;1m尊敬讲师:[%s],您所教授的班级如下:\\033[0m.center(60,=)%obj_teach.NAME)
 46                     teacher_char_class(list_l)#
 47                     info_str=%s 讲师在查看了学员列表%user
 48                     log_file.user_opert(info_str)
 49                     continue
 50                 elif foo==2:
 51                     while True:
 52                         if len(list_l):
 53                             print(\\033[35;1m尊敬讲师:[%s],您所教授的班级如下:\\033[0m.center(60,=)%obj_teach.NAME)
 54                         for k,obj in enumerate(list_l):
 55                             print(\\033[32;1m班级编号:%s 班级名称:[%s]\\033[0m%(k,obj))
 56                         try:
 57                             sart_class=int(input(请选择您要上课班级编号:))
 58                             sart_class_obj=list_l[sart_class]#用数字选定班级
 59                             print(\\033[46;1m您开始进入:[%s] 上课....\\033[0m.center(60,-)%sart_class_obj.NAME)
 60                             for i in range(50):#加载动画
 61                                 sys.stdout.write(#)
 62                                 sys.stdout.flush()
 63                                 time.sleep(0.05)
 64                             obj_teach.amount+=(config.AMOUNT+int(obj_teach.LEVE)/10*config.AMOUNT)
 65                             obj_teach.save()
 66                             info_str=%s 讲师在 %s 班级上课%(obj.NAME,sart_class_obj.NAME)
 67                             log_file.user_opert(info_str)
 68                             print(\\n课程结束,您的收入增加完成.....)
 69 
 70                             break
 71 
 72                         except Exception as e:
 73                            print(选择有误,请重新选择)
 74                     else:
 75                         print(\\033[31;1m对不起,您还没有分配班级与课程,请与校方联系!\\033[0m)
 76 
 77                 elif foo==3:
 78                     students_list=teacher_char_class_students(list_l)
 79                     for k,obj in enumerate(students_list):
 80                         print(\\033[34;1m学员编号:%s  学号:[%s] 姓名:[%s],\\033[0m%(k,obj.NUM,obj.NAME))
 81                     try:
 82                         students_name=int(input(请选择您要管理的学员编号:))
 83                         students_obj=students_list[students_name]#将选中的学员对象赋值给变量
 84                         for i in students_obj.SCORE.score_dict:
 85                             print(课程:【%s】 分数:【%s】%(i,students_obj.SCORE.score_dict[i]))
 86                         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))
 87                         scores=int(input(请输入分数:))
 88                         students_obj.SCORE.set(students_obj.CLASS_ID.get_id_file().TEAC_TO_LSIT_ID.get_id_file().COURSE_NAME,scores)
 89                         for i in students_obj.SCORE.score_dict:
 90                             print(课程:【%s】 分数:【%s】%(i,students_obj.SCORE.score_dict[i]))
 91                         students_obj.save()#进行保存
 92                         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)
 93                         log_file.user_opert(info_str)
 94                         continue
 95                     except Exception as e:
 96                            print(输入有误,请重新选择)
 97                 elif foo==4:
 98                     show_teach_info(obj_teach)
 99                     continue
100                 elif foo==5:
101                     exit()
102                 else:
103                     print("选择有误,请重新选择!")
104                     continue
105         else:
106             print(用户名或密码错误请重输入)
107             info_str=%s登陆错误!%user
108             log_file.log_err(info_str)
109             continue
View Code

 







































































以上是关于python第三十五天-----作业完成--学校选课系统的主要内容,如果未能解决你的问题,请参考以下文章

第三十五天

爱创课堂每日一题第三十五天- 说说你对闭包的理解?

python 学习三十五天(socket的更多方法)

python学习第三十九天:mysql表相关操作

国庆第五天作业完成程度

青青草原--团队作业6:beta冲刺的第五天