python第六十八天--第十二周作业

主题：

需求：

用户角色，讲师＼学员， 用户登陆后根据角色不同，能做的事情不同，分别如下
讲师视图
　　管理班级，可创建班级，根据学员qq号把学员加入班级
　　可创建指定班级的上课纪录，注意一节上课纪录对应多条学员的上课纪录， 即每节课都有整班学员上， 为了纪录每位学员的学习成绩，需在创建每节上课纪录是，同时 为这个班的每位学员创建一条上课纪录
　　为学员批改成绩， 一条一条的手动修改成绩
学员视图
提交作业
查看作业成绩
一个学员可以同时属于多个班级，就像报了Linux的同时也可以报名Python一样， 所以提交作业时需先选择班级，再选择具体上课的节数
附加：学员可以查看自己的班级成绩排名

 

学员管理系统

实现功能:
1、系统初始化
2、管理员视图
    功能：创建讲师、查看讲师、创建班级、查看班级、关联讲师与班级、创建学员、查看学员、班级关联学员
3、讲师视图
    功能：管理班级、创建班级（自动与自己关联）、班级增加学员、增加新课节、
          指定班级上课，选择上课课节（自动创建课程记录，同时为这个班的每位学员创建一条上课纪录）
          批改成绩（先选择一个班级、再选择学员）
4、学员视图
    功能：提交作业
          查看作业成绩
          查看班级中的总成绩排名


stude_mag_sys/#程序目录
|- - -__init__.py
|- - -bin/#启动目录
|      |- - -__init__.py
|      |- - -admin_start.py#管理员视图启动
|      |- - -mag_init.py#系统初始化
|      |- - -student.py#学员视图启动
|      |- - -teach_start.py#讲师视图启动
|
|- - -cfg/#配置目录
|      |- - -__init__.py
|      |- - -config.py#配置文件
|
|- - -core/#主逻辑目录
|      |- - -__init__.py
|      |- - -admain_class.py#主要逻辑 类
|      |- - -admin_log.py#管理员逻辑 类
|      |- - -student_class.py#学员逻辑 类
|      |- - -teach_class.py#讲师逻辑 类
|
|- - -REDMAE

 

 

先上一个表结构图   

 

 

流程美图来一张:

 

stude_mag_sys/#程序目录
|- - -__init__.py
|- - -bin/#启动目录
|      |- - -__init__.py
|      |- - -admin_start.py#管理员视图启动
 1 import os ,sys
 2 from sqlalchemy import create_engine
 3 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 4 sys.path.append(BASE_DIR)#增加环境变量
 5 from core import admin_class
 6 from core import admin_log
 7 from cfg import config
 8 if __name__ == '__main__':
 9     #                      用户 密码  主机             库
10     #engine = create_engine(config.HOSTS,)#连接
11     #admin_class.Base.metadata.create_all(admin_class.engine)#创建表结构
12     while True:
13         admin=admin_log.Admin_Mag()
14         admin.user_log()
View Code
|      |- - -mag_init.py#系统初始化
 1 import os ,sys
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.orm import sessionmaker, relationship
 4 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 5 sys.path.append(BASE_DIR)#增加环境变量
 6 from core import admin_class
 7 from core import admin_log
 8 from cfg import config
 9 if __name__ == '__main__':
10     #                      用户 密码  主机             库
11     #engine = create_engine(config.HOSTS,)#连接
12 
13     admin_class.Base.metadata.create_all(admin_class.engine)#创建表结构
14     A1 = admin_class.Admin_user(name=config.USER,pwd=config.PWD)#初始化
15     Session_class=sessionmaker(bind=admin_class.engine)#创建与数据库的会话 类
16     Session=Session_class()#生成实例
17     Session.add(A1)
18     Session.commit()
View Code
|      |- - -student.py#学员视图启动
1 import os ,sys
2 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
3 sys.path.append(BASE_DIR)#增加环境变量
4 from core.student_class import Stu_Mag
5 from cfg import config
6 if __name__ == '__main__':
7     while True:
8         stu=Stu_Mag()
9         stu.user_log()
View Code
|      |- - -teach_start.py#讲师视图启动
1 import os ,sys
2 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
3 sys.path.append(BASE_DIR)#增加环境变量
4 from core.teach_class import Teach_Mag
5 from cfg import config
6 if __name__ == '__main__':
7     while True:
8         teach=Teach_Mag()
9         teach.user_log()
View Code

 

|- - -cfg/#配置目录
|      |- - -__init__.py
|      |- - -config.py#配置文件
 1 import os ,sys
 2 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
 3 sys.path.append(BASE_DIR)#增加环境变量
 4 
 5 BAES='test_student_mag'#库名
 6 HOSTS="mysql+pymysql://root:root@127.0.0.1:3306/"+BAES+"?charset=utf8"#连接
 7 USER='admin'
 8 PWD='admin'
 9 
10 ADMIN_OPEN=[
11     ('创建讲师','add_teach'),
12     ('查看讲师','teach_l'),
13     ('创建班级','add_class'),
14     ('查看班级','class_l'),
15     ('讲师关联班级','assoc'),
16     ('创建学员','add_stu'),
17     ('查看学员','stu_l'),
18     ('班级关联学员','class_student'),
19     ('退出','tech_exit'),
20 ]
21 
22 TEACH_OPEN=[
23     ('查看班级','show_class'),
24     ( '创建新班级','add_class'),
25     ('班级增加学员','add_student'),
26      ('增加新课节','add_lesson'),
27       ('开始上课','add_cla_day'),
28        ('批改成绩','set_results'),
29     ('退出','tech_exit')
30 ]
31 STUED_OPEN=[
32     ('提交作业','up_work'),
33     ( '查看成绩','set_resu'),
34     ('查看班级排行','cla_top'),
35     ('退出','tech_exit')
36 ]
View Code
|- - -core/#主逻辑目录
|      |- - -__init__.py
|      |- - -admain_class.py#主要逻辑 类
 1 #!usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 # Author calmyan 
 4 #python 
 5 #2017/7/7    17:46
 6 #__author__='Administrator'
 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 from sqlalchemy.ext.declarative import declarative_base
12 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,Table,DATE
13 from sqlalchemy.orm import sessionmaker, relationship
14 from sqlalchemy import create_engine
15 from sqlalchemy import func #统计
16 from  cfg import config
17 Base = declarative_base()#生成orm 基类
18 
19 #创建班级关联学员表,自动维护
20 class_name_m2m_student = Table('class_name_m2m_student', Base.metadata,
21                         Column('class_name_id',Integer,ForeignKey('class_name.id')),#关联外键,班级id
22                         Column('student_id',Integer,ForeignKey('student.id')),#关联外键,学员id
23                         )
24 #创建班级关联老师表,自动维护
25 teacher_name_m2m_class = Table('teacher_name_m2m_class', Base.metadata,
26                         Column('teacher_id',Integer,ForeignKey('teacher.id')),#关联外键,老师id
27                         Column('class_name_id',Integer,ForeignKey('class_name.id')),#关联外键,班级id
28                         )
29 #班级表
30 class Class_name(Base):#班级表
31     __tablename__ = 'class_name'
32     id = Column(Integer,primary_key=True)
33     name = Column(String(64),unique=True)
34     students = relationship('Student',secondary=class_name_m2m_student,backref='class_name')#关联学员,班级
35     #teachers = relationship('Teacher',secondary=class_name_m2m_teacher,backref='class_name')#关联老师,班级
36     def __repr__(self):
37         return self.name
38 
39 #老师表
40 class Teacher(Base):#老师表
41     __tablename__ = 'teacher'
42     id = Column(Integer, primary_key=True)
43     name = Column(String(32))
44     user = Column(String(32),unique=True)
45     pwd = Column(String(32))
46     class_n = relationship('Class_name',secondary=teacher_name_m2m_class,backref='teach_name')#关联老师,班级
47     def __repr__(self):
48         return self.name
49 
50 #学员表
51 class Student(Base):#学员表
52     __tablename__ = 'student'
53     id = Column(Integer, primary_key=True)
54     name = Column(String(32))
55     pwd = Column(String(64))
56     qq = Column(Integer,nullable=False,unique=True)
57     def __repr__(self):
58         return self.id
59 
60 #进度  课节表
61 class Lesson(Base):
62     __tablename__='lesson'
63     id = Column(Integer, primary_key=True)
64     name=Column(String(32),unique=True)#唯一课节名
65     def __repr__(self):
66         return self.name
67 
68 #课程表
69 class Class_Day(Base):#课程表
70     __tablename__='class_day'
71     id=Column(Integer,primary_key=True)
72     class_id=Column(Integer,ForeignKey("class_name.id"),nullable=False)#外键 班级
73     lesson_id= Column(Integer,ForeignKey("lesson.id"),nullable=False)#课程进度
74     class_n=relationship("Class_name",foreign_keys=[class_id],backref="m_class_day")#自定义关联反查 班级Class_name通过m_class_day 查Class_day
75     lesson_n=relationship("Lesson",foreign_keys=[lesson_id],backref="m_lesson_day")#自定义关联反查 课节Lesson通过m_lesson_day 查Class_day
76     def __repr__(self):
77         return self.id#课程名ID
78 
79 class Student_work(Base):#  作业 上 课记录
80     __tablename__='student_work'
81     id=Column(Integer,primary_key=True)
82     students_id=Column(Integer,ForeignKey("student.id"))#外键 学员ID
83     class_id= Column(Integer,ForeignKey('class_day.id'))#班级课程 日期 ID
84     status= Column(String(32),nullable=False)#作业提交 状态
85     results= Column(String(64))#成绩
86     students_w=relationship("Student",foreign_keys=[students_id],backref="m_study_class")#自定义关联反查 学员类Student通过m_study_class 查student_work
87     stu_class=relationship("Class_Day",foreign_keys=[class_id],backref="class_stu_work")#自定义关联反查 班级Class_name通过m_class_study 查Student_work
88 
89 class Admin_user(Base):
90     __tablename__='admin_user'
91     id=Column(Integer,primary_key=True)
92     name=Column(String(32),nullable=False,unique=True)
93     pwd=Column(String(64),nullable=False)
94 
95 #                      用户 密码  主机             库
96 engine = create_engine(config.HOSTS,)#连接
97 Base.metadata.create_all(engine)#创建表结构
View Code
|      |- - -admin_log.py#管理员逻辑 类
  1 #!usr/bin/env python
  2 #-*-coding:utf-8-*-
  3 # Author calmyan 
  4 #python 
  5 #2017/7/9    23:12
  6 #__author__='Administrator'
  7 import os ,sys
  8 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
  9 sys.path.append(BASE_DIR)#增加环境变量
 10 from sqlalchemy.orm import sessionmaker, relationship
 11 from core import admin_class
 12 from cfg import config
 13 #管理登陆
 14 class Admin_Mag(object):
 15     def __init__(self):
 16         self.Session_class=sessionmaker(bind=admin_class.engine)#创建与数据库的会话 类
 17         self.Session=self.Session_class()#生成实例
 18     #开始相关操作
 19     def openatin(self):#开始相关操作
 20         while True:
 21             print('\033[35;1m管理员界面\033[0m'.center(60,'='))
 22             for index,i in enumerate(config.ADMIN_OPEN):
 23                 print(index,':',i[0])
 24             id=input('请选择>>:')
 25             if id.isdigit():
 26                 if int(id)>=len(config.ADMIN_OPEN):continue
 27                 s=config.ADMIN_OPEN[int(id)][1]
 28             else:
 29                 continue
 30             if hasattr(self,s):#是反射否存在
 31                 func=getattr(self,s)#调用
 32                 func()#执行
 33 
 34     #关联讲师班级
 35     def assoc(self):
 36         t_id=self.tech_cher()
 37         cla_id=self.class_cher()
 38         #讲师表对象
 39         t=self.Session.query(admin_class.Teacher).filter(admin_class.Teacher.id==t_id).first()
 40         #获取班级对象
 41         c=self.Session.query(admin_class.Class_name).filter(admin_class.Class_name.id==cla_id).first()
 42         t.class_n.append(c)
 43         self.Session.commit()
 44         print('讲师:',t.name,'班级:',c.name)
 45         print('关联完成!')
 46 
 47     #讲师表对象
 48     def tech_cher(self):
 49         #t=self.Session.query(admin_class.Teacher).all()#讲师表对象
 50         t=self.teach_l()
 51         #for i in t :
 52             #print('编号',i.id,'>>:',i.name)
 53         t_id=input('请按编号选择讲师>>:').strip()
 54         if  t_id.isdigit() :#判断是否是整数
 55             for i in t:#
 56                 if int(t_id)==i.id:
 57                     return int(t_id)#返回班级ID
 58             else:
 59                 pass
 60         else:
 61             print('选择讲师有误!')
 62             return None
 63     #创建班级
 64     def add_class(self):
 65         print('\033[35;1m创建班级界面\033[0m'.center(60,'='))
 66         self.class_l()
 67         attr=input("输入班级名>>:").strip()
 68         self.class_list=self.Session.query(admin_class.Class_name).all()#获取班级名列表
 69         if attr in self.class_list:#如果存在
 70             return print('班级名重复!')
 71         c=admin_class.Class_name(name=attr)#创建新班级
 72         self.add_all(c)
 73 
 74     #查看讲师
 75     def teach_l(self):
 76         t=self.Session.query(admin_class.Teacher).all()
 77         for i in t:
 78             print('编号:',i.id,'讲师姓名:',i.name,'用户名:',i.user,'密码',i.pwd,' 管理班级:',i.class_n)
 79         return t
 80 
 81 
 82     #查看班级
 83     def class_l(self):
 84         c=self.Session.query(admin_class.Class_name).all()#班级对象
 85         print("全部班级信息".center(50,'-'))
 86         for i in c:
 87             print('编号',i.id,'>>:',i.name)
 88         return c
 89 
 90     #查看班级选择
 91     def class_cher(self):#查看班级
 92         c=self.class_l()
 93         class_id=input('请按编号选择班级>>:').strip()
 94         if  class_id.isdigit() :#判断是否是整数
 95             for i in c:#
 96                 if int(class_id)==i.id:
 97                     return int(class_id)#返回班级ID
 98             else:
 99                 pass
100         else:
101             print('选择班级有误!')
102             return None
103     #创建讲师
104     def add_teach(self):#创建讲师
105         while True:
106             name =input('输入讲师姓名>>:').strip()
107             user =input('输入讲师用户名>>:').strip()
108             pwd =input('输入讲师密码>>:').strip()
109             t1 = admin_class.Teacher(name=name,user=user,pwd=pwd)
110             self.add_all(t1)
111             e=input('是否继续 Y/y 继续! 其他返回').upper().strip()
112             if e=='Y':continue
113             break
114     #学员添加
115     def add_stu(self):#学员添加
116         while True:
117             name =input('输入学员姓名>>:').strip()
118             pwd =input('输入学员密码>>:').strip()
119             qq =input('输入学员QQ>>:').strip()
120             if not qq.isdigit():
121                 print('QQ必需是数字')
122                 continue
123             s=admin_class.Student(name=name,pwd=pwd,qq=int(qq))
124             self.add_all(s)
125             e=input('是否继续 Y/y 继续! 其他返回').upper().strip()
126             if e=='Y':continue
127             break
128 
129     #查看学员
130     def stu_l(self):
131         student_l=self.Session.query(admin_class.Student).all()
132         for i in student_l:
133             print('ID:',i.id,'学员姓名:',i.name,'QQ:',i.qq,'培训班级:',i.class_name)
134         return student_l
135 
136     #学员选择
137     def stu_cher(self):
138         student_l=self.stu_l()
139         stu_id=input('请按ID选择学员>>:').strip()
140         if  stu_id.isdigit() :#判断是否是整数
141             for i in student_l:#
142                 if int(stu_id)==i.id:
143                     return int(stu_id)#返回班级ID
144             else:
145                 pass
146         else:
147             print('选择学员有误!')
148             return None
149 
150     #班级关联学员
151     def class_student(self):#班级增加学员
152         print('\033[35;1m班级关联学员界面\033[0m'.center(60,'='))
153         cla_id=self.class_cher()#调用查看班级
154         if not cla_id:return None
155         #获取班级对象
156         c=self.Session.query(admin_class.Class_name).filter(admin_class.Class_name.id==cla_id).first()
157         if not c:return None
158         stu_id=self.stu_cher()
159         #student_qq=input('请输入学生QQ号码>>:').strip()
160         s_qq=self.Session.query(admin_class.Student).filter(admin_class.Student.id==stu_id).first()#学员qq对象
161         if s_qq:#如果有这个qq
162             c.students.append(s_qq)#加入班级
163             self.Session.commit()
164             print('加入班级成功！')
165         else:
166             return print('对应的学员不存在')
167 
168     #增加函数
169     def add_all(self,lists):#增加函数
170         self.Session.add_all([lists])
171         confirm=input('请进行确认: 按\033[31;1mN\033[0m回滚操作,其他键确认!' ).upper().strip()
172         if confirm=="N":
173             self.Session.rollback()#
174             return False
175         try:
176             self.Session.commit()
177             print('操作成功')
178             return
179         except Exception as e:
180             self.Session.rollback()#
181             print('操作失败!,可能该信息已经存在!')
182             print(e)
183             return
184     #退出
185     def tech_exit(self):
186         return  exit()
187 
188      #登陆
189     #登陆
190     def user_log(self):#登陆
191         user_n=input('请输入管理员用户名>>:').strip()
192         aut_obj=self.Session.query(admin_class.Admin_user).filter(admin_class.Admin_user.name==user_n).first()
193         if aut_obj:
194             #print(self.aut_obj_1.pwd)#用户对应密码
195             pwds=input('请输入密码>>:').strip()
196             if pwds == aut_obj.pwd:
197 
198                 self.openatin()
199             else:
200                 print('密码有误')
201                 return
202         else:
203             print('输入的用户名不存')
204             return
View Code
|      |- - -student_class.py#学员逻辑 类
  1 #!usr/bin/env python
  2 #-*-coding:utf-8-*-
  3 # Author calmyan 
  4 #python 
  5 #2017/7/8    12:29
  6 #__author__='Administrator'
  7 import os ,sys
  8 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
  9 sys.path.append(BASE_DIR)#增加环境变量
 10 from sqlalchemy.ext.declarative import declarative_base
 11 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 12 from sqlalchemy.orm import sessionmaker, relationship
 13 from sqlalchemy import create_engine
 14 from sqlalchemy import func #统计
 15 from  core import admin_class
 16 from  cfg import config
 17 #学员类
 18 class Stu_Mag(object):
 19 
 20     def __init__(self):
 21         self.Session_class=sessionmaker(bind=admin_class.engine)#创建与数据库的会话 类
 22         self.Session=self.Session_class()#生成实例
 23         self.stu_name=''#学员姓名
 24 
 25     #开始相关操作
 26     def openatin(self):#开始相关操作
 27         while True:
 28             print('\033[32;1m学员界面\033[0m'.center(60,'='))
 29             print(('\033[36;1m[%s]\033[0m'%self.stu_name).center(60,'='))
 30 
 31             for index,i in enumerate(config.STUED_OPEN):
 32                 print(index,':',i[0])
 33             id=input('请选择>>:')
 34             if id.isdigit():
 35                 if int(id)>=len(config.STUED_OPEN):continue
 36                 s=config.STUED_OPEN[int(id)][1]
 37             else:
 38                 continue
 39             if hasattr(self,s):#是反射否存在
 40                 func=getattr(self,s)#调用
 41                 func()#执行
 42 
 43     #提交作业
 44     def up_work(self):
 45         class_id=self.class_l()
 46         if not class_id:
 47             return None#班级ID
 48         les_id=self.lessn_obj(class_id)#课节表ID\
 49         if not les_id:return None
 50         cl_dayid=self.class_less(class_id,les_id)#课程表ID
 51         if cl_dayid:
 52             stu_id=self.stu_obj.id#学员ID
 53             stu_work=self.Session.query(admin_class.Student_work).filter_by(students_id=stu_id,class_id=cl_dayid.id).first()
 54             if stu_work:
 55                 if stu_work.status=='yes':
 56                     print('\033[31;1m作业已经提交,不能重复提交!\033[0m')
 57                     return None
 58                 #对应的课程表
 59                 les_n=self.Session.query(admin_class.Class_Day).filter_by(class_id=class_id,lesson_id=les_id).first()
 60                 print('姓名:',self.stu_name,'班级:',les_n.class_n,'课节:',les_n.lesson_n,'作业提交状态:',stu_work.status,'成绩:',stu_work.results)
 61                 chend=input('提交作业>>>: Y/y 确认!').upper().strip()
 62                 if chend=='Y':
 63                     self.Session.query(admin_class.Student_work).filter_by(students_id=stu_id,class_id=cl_dayid.id).update({"status":"yes"})
 64                     print('提交完成!')
 65                     self.Session.commit()
 66                     return
 67                 else:
 68                     return None
 69             else:
 70                 print('\033[31;1m您可能没有上本节课!无法提交\033[0m')
 71                 return None
 72         else:
 73             print('\033[31;1m本节课可能没有开始!\033[0m')
 74             return None
 75 
 76 
 77     #获取课程ID
 78     def class_less(self,cla_id,les_id):
 79         cl_dayid=self.Session.query(admin_class.Class_Day).filter(admin_class.Class_Day.class_id==cla_id).\
 80             filter(admin_class.Class_Day.lesson_id==les_id).first()#获取班级课程表id
 81         if cl_dayid:
 82             return cl_dayid
 83         else:
 84             return None
 85 
 86     #获取课程表 选课节
 87     def lessn_obj(self,cla):
 88         les_l=self.Session.query(admin_class.Class_Day).filter_by(class_id=cla).all()
 89         for i in les_l:
 90             print('编号:',i.lesson_id,'课节:',i.lesson_n)
 91         les_id=input('请按编号选择课节 >>:').strip()
 92         if les_id.isdigit():
 93             for i in les_l:
 94                 if int(les_id)==i.lesson_id:
 95                     return int(les_id)#返回课节ID
 96             else:
 97                 print('选择课节有误!')
 98                 return None
 99         else:
100             print('选择课节有误!')
101             return None
102 
103     #查看班级选择
104     def class_l(self):#查看班级
105         for i in self.stu_obj.class_name:
106             print('编号',i.id,'>>:',i.name)
107         class_id=input('请按编号选择班级>>:').strip()
108         if  class_id.isdigit() :#判断是否是整数
109             for i in self.stu_obj.class_name:#是否在学员的班级中
110                 if int(class_id)==i.id:
111                     return int(class_id)#返回班级ID
112             else:
113                 print('选择班级有误!')
114                 return None
115         else:
116             print('选择班级有误!')
117             return None
118 
119     #查看课节
120     def lesson_l(self):
121         for i in self.les:
122             print('编号',i.id,'>>:',i)
123         les_id=input('请按编号选择课节 >>:').strip()
124         if les_id.isdigit():
125             for i in self.les:
126                 if int(les_id)==i.id:
127                     return int(les_id)#返回课节ID
128             else:
129                 pass
130         else:
131             print('选择课节有误!')
132             return None
133 
134     #查看成绩
135     def set_resu(self):
136         class_id=self.class_l()#班级ID
137         les_l=self.Session.query(admin_class.Class_Day).filter_by(class_id=class_id).all()#本班所有课节
138         stu_id=self.stu_obj.id#学员ID
139         for i in les_l:
140             stu_work=self.Session.query(admin_class.Student_work).filter_by(students_id=stu_id,class_id=i.id).first()#取对应的课节
141             if stu_work:
142                 cla_day=self.Session.query(admin_class.Class_Day).filter_by(id=stu_work.class_id).first()#课程表对象
143                 if cla_day:
144                     print('姓名:',self.stu_name,'班级：',cla_day.class_n,'课节:',cla_day.lesson_n,' 作业提交状态:',stu_work.status,'成绩:',stu_work.results)
145                 else:
146                     pass
147             else:
148                 pass
149 
150     #查看排名
151     def cla_top(self):
152         class_id=self.class_l()#班级ID
153         les_l=self.Session.query(admin_class.Class_Day).filter_by(class_id=class_id).all()#取当前班级的所有课节
154         stu_id_l=self.Session.query(admin_class.Student).all()#取学生id
155         top_list=[]#分数
156         for i in stu_id_l:
157             resut=0
158             for j in les_l:
159                 stu_work=self.Session.query(admin_class.Student_work).filter_by(students_id=i.id,class_id=j.id).first()
160                 if not stu_work:continue
161                 if stu_work.results:
162                     resut+=int(stu_work.results)
163             else:
164                 top_list.append((resut,i.name))
165         print(top_list)
166         self.sort(top_list)
167         for index,i in enumerate(top_list):
168             print('名次',index+1,'总分数--姓名:',i)
169 
170     #排序
171     def sort(self,ls):
172         for i in range(len(ls)-1):
173             for j in range(len(ls)-i-1):
174                 if ls[j]<ls[j+1]:
175                     ls[j],ls[j+1] =ls[j+1],ls[j]
176         return ls
177 
178 
179 
180     #退出
181     def tech_exit(self):
182         return  exit()
183 
184     #登陆
185     def user_log(self):#登陆
186             user_n=input('请输入用户名(qq)>>:').strip()
187             if not user_n.isdigit():return None
188             aut_obj=self.Session.query(admin_class.Student).filter(admin_class.Student.qq==int(user_n)).first()
189             if aut_obj:
190                 #print(self.aut_obj_1.pwd)#用户对应密码
191                 pwds=input('请输入密码>>:').strip()
192                 if pwds == aut_obj.pwd:
193                     self.stu_name=aut_obj.name
194                     self.qq=aut_obj.qq
195                     self.stu_obj = self.Session.query(admin_class.Student).filter(admin_class.Student.qq==self.qq).first()#取当前学员对象实例
196                     self.openatin()
197                 else:
198                     print('密码有误')
199                     return
200             else:
201                 print('输入的用户名不存')
202                 return
203 
204 
205 
206     #stu.up_work()
View Code
|      |- - -teach_class.py#讲师逻辑 类
  1 #!usr/bin/env python
  2 #-*-coding:utf-8-*-
  3 # Author calmyan 
  4 #python 
  5 #2017/7/7    17:48
  6 #__author__='Administrator'
  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 from sqlalchemy.ext.declarative import declarative_base
 12 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 13 from sqlalchemy.orm import sessionmaker, relationship
 14 from sqlalchemy import create_engine
 15 from sqlalchemy import func #统计
 16 from  core import admin_class
 17 from  cfg import config
 18 
 19 #讲师类
 20 class Teach_Mag(object):
 21 
 22     def __init__(self):
 23         self.Session_class=sessionmaker(bind=admin_class.engine)#创建与数据库的会话 类
 24         self.Session=self.Session_class()#生成实例
 25         self.teach_name=''
 26 
 27     #开始相关操作
 28     def openatin(self):#开始相关操作
 29         while True:
 30             print('\033[35;1m讲师界面\033[0m'.center(60,'='))
 31             for index,i in enumerate(config.TEACH_OPEN):
 32                 print(index,':',i[0])
 33             id=input('请选择>>:')
 34             if id.isdigit():
 35                 if int(id)>=len(config.TEACH_OPEN):continue
 36                 s=config.TEACH_OPEN[int(id)][1]
 37             else:
 38                 continue
 39             if hasattr(self,s):#是反射否存在
 40                 func=getattr(self,s)#调用
 41                 func()#执行
 42 
 43     #查看班级
 44     def show_class(self):#查看班级
 45         print('\033[32;1m查看班级(可管理)\033[0m'.center(60,'='))
 46         #show_class=self.Session.query(admin_class.Class_name).filter(admin_class.Class_name.teach_name==self.teach_name)
 47         print('\033[31;1m全部班级\033[0m'.center(45,'-'))#所有班级
 48         for i in self.class_list:
 49             print(i)
 50         print('\033[35;1m可管理班级\033[0m'.center(45,'-'))
 51         cla_id=self.class_l()#调用查看班级
 52         class_obj=self.Session.query(admin_class.Class_name).filter(admin_class.Class_name.id==cla_id).first()
 53         if class_obj:#获取班级对象成功 有内容
 54             print(class_obj,class_obj.name,class_obj.id)
 55             self.student_l(class_obj.name)#调用查看学员 得到班级对象
 56             # print('[%s] 班 学员列表'.center(60,'=')%c)
 57             # for i in c.students:
 58             #     print(i.id,'姓名:',i.name,'QQ:',i.qq)
 59             # print('end'.center(60,'='))
 60             return
 61         else:
 62             print('选择有误!')
 63             return
 64 
 65     #查看班级选择
 66     def class_l(self):#查看班级
 67         for i in self.teach_obj.class_n:
 68             print('编号',i.id,'班级:',i.name)
 69         class_id=input('请按编号选择班级>>:').strip()
 70         if  class_id.isdigit() :#判断是否是整数
 71             for i in self.teach_obj.class_n:#是否在讲师的班级中
 72                 if int(class_id)==i.id:
 73                     return int(class_id)#返回班级ID
 74             else:
 75                 print('选择班级有误!')
 76                 return None
 77         else:
 78             print('选择班级有误!')
 79             return None
 80 
 81     #查看班级学员
 82     def student_l(self,class_name):#查看班级学员
 83         stu_l=self.Session.query(admin_class.Class_name).filter(admin_class.Class_name.name==str(class_name)).first()#所选班级对象
 84         print('[%s] 班 学员列表'.center(60,'=')%stu_l)
 85         for i in stu_l.students:
 86             print(i.id,'姓名:',i.name,'QQ:',i.qq)
 87         print('end'.center(60,'='))
 88         return stu_l#返回所选班级对象
 89 
 90     #查看课节
 91     def less_cher(self):
 92         les=self.Session.query(admin_class.Lesson).all()#取课节名列表
 93         for i in les:
 94             print('编号',i.id,'课节名>>:',i)
 95         return les
 96     #查看课节 选择
 97     def lesson_l(self):
 98         les=self.less_cher()#取课节名列表
 99         # for i in les:
100         #     print('编号',i.id,'课节名>>:',i)
101         les_id=input('请按编号选择课节 >>:').strip()
102         if les_id.isdigit():
103             for i in les:
104                 if int(les_id)==i.id:
105                     return int(les_id)#返回课节ID
106             else:
107                 print('选择课节有误!')
108                 return None
109         else:
110             print('选择课节有误!')
111             return None
112 
113     #创建班级
114     def add_class(self):#创建班级
115         print('\033[35;1m创建班级界面\033[0m'.center(60,'='))
116         attr=input("输入班级名>>:").strip()
117         if attr in self.class_list:#如果存在
118             return print('班级名重复!')
119         c=admin_class.Class_name(name=attr)#创建新班级
120         self.teach_obj.class_n.append(c)#关联讲师与班级
121         if self.add_all(c):#进行调用添加
122             self.Session.add_all([c])
123             self.Session.commit()
124         return
125 
126     #班级增加学员
127     def add_student(self):#班级增加学员
128         print('\033[35;1m增加学员界面\033[0m'.center(60,'='))
129         cla_id=self.class_l()#调用查看班级
130         if not cla_id:return None
131         #获取班级对象
132         c=self.Session.query(admin_class.Class_name).filter(admin_class.Class_name.id==cla_id).first()
133         if not c:return None
134         stu_l=self.student_l(c.name)#查看班级学员
135         student_qq=input('请输入学生QQ号码>>:').strip()
136         s_qq=self.Session.query(admin_class.Student).filter(admin_class.Student.qq==int(student_qq)).first()#学员qq对象
137         if s_qq:#如果有这个qq
138             c.students.append(s_qq)#加入班级
139             self.Session.commit()
140             print('加入班级成功！')
141         else:
142             return print('QQ对应的学员不存在')
143 
144     #添加课节
145     def add_lesson(self):#添加课节
146         print('现有课节'.center(40,'='))
147         les=self.less_cher()#取课节名列表
148         day_name=input('输入课节名>>:').strip()
149         d1=admin_class.Lesson(name=day_name)
150         self.add_all(d1)
151 
152     #获取课程ID
153     def class_less(self,cla_id,les_id):
154 
155         cl_dayid=self.Session.query(admin_class.Class_Day).filter(admin_class.Class_Day.class_id==cla_id).\
156             filter(admin_class.Class_Day.lesson_id==les_id).first()#获取班级课程表id
157         if cl_dayid:
158             return cl_dayid
159         else:
160             return None
161 
162     #获取班级对象
163     def class_obj(self,cla_id):
164         clas_obj=self.Session.query(admin_class.Class_name).filter(admin_class.Class_name.id==cla_id).first()#获取班级对象
165         return clas_obj
166 
167     #开始上课
168     def add_cla_day(self):#开始上课
169         print('\033[32;1m班级上课\033[0m'.center(60,'='))
170         cla_id=self.class_l()##获取班级id
171         if not cla_id:return None
172         les_id=self.lesson_l()#获取课节id
173         if not les_id:return None
174         clas_obj=self.class_obj(cla_id)#获取班级对象
175         print(clas_obj,clas_obj.id)#班级名,ID
176         cl_dayid=self.class_less(cla_id,les_id)#获取课程表对象
177         if cl_dayid:#如果课程表存在
178             print('当前班级该节课已经上过!')
179             return
180         clas_day=admin_class.Class_Day(class_id=cla_id,lesson_id=les_id)#创建上课课程记录
181         self.Session.add(clas_day)#添加记录
182         cl_day_id=self.class_less(cla_id,les_id)#获取当前班级课程对象
183         c_obj=self.student_l(cl_day_id.class_n)#获取班级   学员对象
184         for i in c_obj.students:
185             stu_work=admin_class.Student_work(students_id=i.id,class_id=cl_day_id.id,status='not')#创建上课记录
186             self.Session.add(stu_work)#添加记录
187         self.Session.commit()
188         return print('上课记录添加完成')
189 
190     #批改作业
191     def set_results(self):#批改作业
192         print('\033[32;1m批改作业\033[0m'.center(60,'='))
193         cla_id=self.class_l()##获取班级id
194         if not cla_id:return None
195         les_id=self.lesson_l()#获取课节id
196         if not les_id:return None
197         cl_day_id=self.class_less(cla_id,les_id)#获取课程表对象
198         if not cl_day_id:print('本节课未上!');return None
199         #获取当前班级中，
200         stude_day=self.Session.query(admin_class.Student_work).filter(admin_class.Student_work.class_id==cl_day_id.id).all()
201         print('\033[36;1m开始批改作业\033[0m'.center(60,'='))
202         print('\033[31;1m作业未提交则不显示\033[0m')
203         for i in stude_day:
204             if i.status=='yes' and not i.results:
205                 print(i.id,'姓名:',i.students_w.name,'成绩:',i.results)
206                 resu=input('请输入成绩>>:').strip()
207                 if resu.isdigit():
208                     self.Session.query(admin_class.Student_work).filter(admin_class.Student_work.id==i.id).update({"results":resu})
209             elif i.status=='yes' and i.results:
210                 print(i.id,'姓名:',i.students_w.name,'成绩:',i.results)
211                 resu=input('是否修改成绩? N/n 跳过,输入新成绩').upper().strip()
212                 if resu=='N':
213                     continue
214                 if resu.isdigit():
215                     self.Session.query(admin_class.Student_work).filter(admin_class.Student_work.id==i.id).update({"results":resu})
216 
217         else:
218             self.Session.commit()
219             print("已提交的作业全部批改完毕!")
220 
221     #增加函数
222     def add_all(self,lists):#增加函数
223         self.Session.add_all([lists])
224         confirm=input('请进行确认: 按\033[31;1mN\033[0m回滚操作,其他键确认!' ).upper().strip()
225         if confirm=="N":
226             self.Session.rollback()#
227             return False
228         try:
229             self.Session.commit()
230             print('操作成功')
231             return lists
232         except Exception as e:
233             self.Session.rollback()#
234             print('操作失败!,可能该信息已经存在!')
235             return
236 
237     #退出
238     def tech_exit(self):
239         return  exit()
240     #登陆
241     def user_log(self):#登陆
242             user_n=input('请输入用户名>>:').strip()
243             aut_obj=self.Session.query(admin_class.Teacher).filter(admin_class.Teacher.user==user_n).first()
244             if aut_obj:
245                 #print(self.aut_obj_1.pwd)#用户对应密码
246                 pwds=input('请输入密码>>:').strip()
247                 if pwds == aut_obj.pwd:
248                     self.teach_name=aut_obj.name
249                     #print(self.teach_name)#当前讲师姓名
250                     self.teach_obj = self.Session.query(admin_class.Teacher).filter(admin_class.Teacher.name==self.teach_name).first()#取当前讲课对象实例
251                     self.class_list=self.Session.query(admin_class.Class_name).all()#获取班级名列表
252                     #self.les=self.Session.query(admin_class.Lesson).all()#取课节名列表
253                     #print(self.s_name_list[2])
254                     self.openatin()
255                 else:
256                     print('密码有误')
257                     return
258             else:
259                 print('输入的用户名不存')
260                 return
261 
262 #Session.query()
263 while True:
264     teach=Teach_Mag()
265     #teach.add_teach()
266     #teach.add_stu()
267 
268     teach.user_log()
View Code

 



 

posted @ 2017-07-09 23:58  莫柔落切  阅读(507)  评论(0)  编辑  收藏  举报