python练习---校园管理系统

python练习---校园管理系统
⾓⾊：
学校、学员、课程、讲师
要求：
1、创建北京、上海2所学校（已完成）
2、创建linux、python、go3个课程，linux/python在北京开，go在上海开（已完成）
3、课程包含周期、价格（已完成）
4、班级关联课程、讲师（已完成）
5、创建学员时，选择学校，关联班级（已完成）
6、提供三个⾓⾊视图
6.1：学员视图，登录，查看课程，查看班级（已完成）
6.2：讲师视图，讲师可以查看⾃⼰教学的班级，课程（已完成）
进阶需求：可管理⾃⼰的班级，查看班级学员列表，修改所管理的成绩（未完成）
6.3：管理视图，创建讲师，创建班级，创建课程（已完成）
7、上⾯的操作产⽣的数据通过pickle、序列化保持到⽂件中（已完成）
下⾯是具体的实现代码：
代码⽬录主要有：
实现功能：
1、根据登录⽤户进⾏判断，如果是学⽣就进⼊学⽣视图，是⽼师就进⼊⽼师视图，是管理员就进⼊管理员视图
课程中关联学校、讲师等属性；
班级中关联课程、讲师等属性
学⽣对象关联了学校、班级等属性；
2、学⽣视图：
a：查看课程
b：查看学校
c：查看班级
3、⽼师视图：
a：查看学校
b：查看讲师
c：查看班级
d：查看课程
4、管理员视图：
a：创建学校
b：创建课程
c：创建班级
d：创建学员
e：创建讲师
f：查看学校
g：查看讲师
h：查看班级
i：查看课程
j：给课程关联讲师
k：给学员指定班级
⽬录结构：
bin ---> 程序执⾏的总⼊⼝，直接在pycharm或者其他编辑器中执⾏start.py
conf ---> 配置⽂件⽬录，settings.py⽂件中都是⼀些⽂件路径信息
core ---> 程序核⼼⽬录，⾥⾯分别包含了'学校类'，'⽼师类'，'学⽣类'，'班级类'，'课程类'，'管理员类'；其中Main.py(程序主要逻辑判断⽂件)⽂件中主要是实现登录验证、根据不同登录⽤户反射到对应的类中 db ---> 信息存储⽬录，主要记录'学校'、'⽼师'、'学⽣'、'班级'、'课程'、'⽤户账号密码'等信息
log ---> 程序运⾏中产⽣的⽇志信息，主要是记录对程序执⾏的所有信息
管理员账号密码：admin 123
⽼师账号密码：goddess 123
学⽣账号密码：jack 123
README.me
#! /bin/env python
# coding: utf-8
import os
import sys
#将项⽬需要导⼊的包路径导⼊到环境变量中
# sys.path.append(os.path.dirname(os.getcwd()))
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
# print(os.path.dirname(__file__))
from core import Main
if__name__ == '__main__':
print('\033[1;36m欢迎进⼊校园管理系统!\033[0m')
Main.main()
bin/start.py
#! /bin/env python
# coding=utf-8
import os
path = os.path.dirname(os.path.dirname(__file__))
userinfo = r'%s/db/userinfo' % path
schoolinfo = r'%s/db/school_info' % path
teacherinfo = r'%s/db/teacher_info' % path
classinfo = r'%s/db/class_info' % path
studentinfo = r'%s/db/student_info' % path
courseinfo = r'%s/db/course_info' % path
log = r'%s/log/test.log' % path
conf/settings.py
#! /bin/env python
# coding: utf-8
class Class(object):
def__init__(self,name):
self.class_name = name
def__repr__(self): #内置的⽅法，让打印的对象丰富起来
show_str = ''
for key in self.__dict__:
show_str +='%s : %s ' % (key, self.__dict__[key])
return show_str
core/Class.py
#! /bin/env python
# coding=utf-8
class Course(object):
def__init__(self,name,time,price):
self.course_name = name
self.course_time = time
self.course_price = price
def__repr__(self): #内置的⽅法，让打印的对象丰富起来
show_str = ''
for key in self.__dict__:
show_str +='%s : %s ' % (key, self.__dict__[key])
return show_str
core/Course.py
#! /usr/bin/env python
# coding: utf-8
import logging
import sys
from conf import settings
class Log:
def__init__(self):
pass
def record(self,s):
logging.basicConfig(format='%(asctime)s %(levelname)s %(filename)s[line:%(lineno)d] %(message)s', filename=settings.log, level=)
(s)
core/Log.py
#! /bin/env python
# coding: utf-8
import sys
import hashlib
from collections import OrderedDict
from core.Manager import Manager
from core.Student import Student
from core.Teacher import Teacher
from conf import settings
status_dic = {
'username': None,
'status': False,
'identity': None
}
# 登录认证
def login():
# if status_dic['status'] == False:
user = input('username>>').strip()
pwd = input('password>>').strip()
hash_obj = hashlib.md5(user.encode('utf-8')) #md5前需要先转成base64
hash_obj.update(pwd.encode('utf-8'))
md5_pwd = hash_obj.hexdigest()
with open(erinfo) as f:
for line in f:
username, password, identity = line.strip().split('|')
if username == user and password == md5_pwd and identity == 'Manager':
print('\033[1;32m欢迎%s管理员⽤户登录\033[0m'.center(50,'*') % user)
return {'username': user, 'identity': identity}
elif username == user and password == md5_pwd and identity == 'Teacher':
print('\033[1;32m欢迎%s⽼师⽤户登录\033[0m'.center(50,'*') % user)
return {'username': user, 'identity': identity}
elif username == user and password == md5_pwd and identity == 'Student':
print('\033[1;32m欢迎%s学⽣⽤户登录\033[0m'.center(50,'*') % user)
return {'username': user, 'identity': identity}
def main():
ret = login()
if ret:
if hasattr(sys.modules[__name__],ret['identity']):
Role_Cls = getattr(sys.modules[__name__],ret['identity'])
role_obj = Role_Cls(ret['username'])
while True:
d = {}
for num,key in enumerate(role_obj.dic,1):
print(num,key)
d[str(num)]=key
try:
num = input('\033[1;32m请输⼊您要做的操作序号 :\033[0m')
func_name = role_obj.dic[d[num]]
if hasattr(role_obj, func_name):
getattr(role_obj, func_name)() #根据⽤户的选择去执⾏具体的⽅法except Exception:
pass
if__name__ == '__main__':
# hash_obj = hashlib.md5('alex'.encode('utf-8'))
# hash_obj.update('123'.encode('utf-8'))
# md5_pwd = hash_obj.hexdigest()
# print(md5_pwd)
pass
core/Main.py
#! /bin/env python
# coding: utf-8
import pickle
import hashlib
import logging
from collections import OrderedDict
from core.Mypickle import Mypickle
from core.Teacher import Teacher
from core.Class import Class
from core.Course import Course
from core.Student import Student
from core.School import School
from core import Log
from conf import settings
class Manager:
dic = OrderedDict([ ('创建学校','create_school'),
('创建学员', 'create_student'),
('创建讲师', 'create_teacher'),
('创建课程', 'create_course'),
('创建班级', 'create_class'),
('查看学校', 'show_school'),
('查看讲师', 'show_teacher'),
('查看班级', 'show_class'),
('查看课程', 'show_course'),
('退出', 'quit')])
def__init__(self, name):
= name
self.school_pickle = Mypickle(settings.schoolinfo)
self.teacher_pickle = Mypickle(settings.teacherinfo)
self.class_pickle = Mypickle(settings.classinfo)
self.student_pickle = Mypickle(settings.studentinfo)
self.course_pickle = Mypickle(settings.courseinfo)
self.obj = Log.Log()
# 创建学校
def create_school(self):
school_name = input('school name>').strip()
school_addr = input('school addr>').strip()
school_obj = School(school_name, school_addr)
self.school_pickle.dump(school_obj)
a = 'Create a school'
self.obj.record(a)
print('\033[1;31m学校创建成功!\033[0m')
#创建课程
def create_course(self):
course_name = input('course name>').strip()
course_time = input('course time>').strip()
course_price = input('course price>').strip()
#选择学校
self.show_school()
school_num = input('请输⼊课程所开设的校区序号:').strip()
school_obj = self.school_pickle.get_item(int(school_num)) #创建⼀个属于课程的新对象
course_obj = Course(course_name,course_time,course_price) #将课程与学校绑定到⼀起
course_obj.school = school_obj
#将课程对象dump写⼊courseinfo⽂件中
course_pickle = Mypickle(settings.courseinfo)
course_pickle.dump(course_obj)
print('\033[1;31m课程创建成功!\033[0m')
a = 'Create a course'
self.obj.record(a)
#创建班级
def create_class(self):
class_name = input('class name>').strip()
#关联课程
self.show_course()
course_num = input('请输⼊班级关联的课程序号:').strip()
course_obj = self.course_pickle.get_item(int(course_num)) #关联讲师
self.show_teacher()
teacher_num = input('请输⼊班级关联的讲师序号:').strip()
teacher_obj = self.teacher_pickle.get_item(int(teacher_num)) # 创建⼀个属于班级的对象
class_obj = Class(class_name)
class_obj.course = course_obj
class_obj.teacher = teacher_obj
class_pickle = Mypickle(settings.classinfo)
class_pickle.dump(class_obj)
print('\033[1;31m班级创建成功!\033[0m')
a = 'Create a class'
self.obj.record(a)
#创建学员账号
def create_student(self):
student_name = input('student name>').strip()
student_pwd = input('student password>').strip()
md5_obj = hashlib.md5(student_name.encode('utf-8'))
md5_obj.update(student_pwd.encode('utf-8'))
md5_passwd = md5_obj.hexdigest()
user = '%s|%s|%s\n' % (student_name,md5_passwd,'Student') with open(erinfo,'a',encoding='utf-8') as f:
f.write(user)
#给学员选择学校
self.show_school()
school_num = input('请输⼊学⽣所在的校区序号:').strip()
school_obj = self.school_pickle.get_item(int(school_num)) #创建⼀个属于学⽣的新对象
student_obj = Student(student_name)
student_obj.school = school_obj
student_pickle = Mypickle(settings.studentinfo)
student_pickle.dump((student_obj))
print('\033[1;31m学⽣创建成功!\033[0m')
a = 'Create a student'
self.obj.record(a)
#创建讲师账号
def create_teacher(self):
teacher_name = input('teacher name>').strip()
teacher_pwd = input('teacher password>').strip()
md5_obj = hashlib.md5(teacher_name.encode('utf-8'))
md5_obj.update(teacher_pwd.encode('utf-8'))
md5_passwd = md5_obj.hexdigest()
user = '%s|%s|%s\n' % (teacher_name,md5_passwd,'Teacher') with open(erinfo,'a',encoding='utf-8') as f:
f.write(user)
#给⽼师选择⼀个校区
self.show_school()
school_num = input('请输⼊⽼师所在的校区序号:').strip()
school_obj = self.school_pickle.get_item(int(school_num)) #创建⼀个属于⽼师的新对象
teacher_obj = Teacher(teacher_name)
#将⽼师选择的校区和⽼师对象绑定在⼀起
teacher_obj.school = school_obj
#将⽼师对象dump进⼊teacherinfo⽂件
teacher_pickle = Mypickle(settings.teacherinfo)
teacher_pickle.dump(teacher_obj)
print('\033[1;31m⽼师创建成功!\033[0m')
a = 'Create a teacher'
self.obj.record(a)
# 查看学校
def show_school(self):
for num,school_obj in enumerate(self.school_pickle.load(),1):
print(num,school_obj)
print('')
a = 'View school information'
self.obj.record(a)
#查看讲师
def show_teacher(self):
for num,teacher_obj in enumerate(self.teacher_pickle.load(),1):
print(num,teacher_obj)
a = 'View instructor information'
self.obj.record(a)
#查看学⽣
def show_student(self):
for num,student_obj in enumerate(self.student_pickle.load(),1):
print(num,student_obj)
a = 'View student information'
self.obj.record(a)
#查看班级
def show_class(self):
for num,class_obj in enumerate(self.class_pickle.load(),1):
print(num,class_obj)
a = 'View class information'
self.obj.record(a)
#查看课程
def show_course(self):
for num,course_obj in enumerate(self.course_pickle.load(),1):
print(num,course_obj)
a = 'View course information'
self.obj.record(a)
def quit(self):
print('\033[1;31m再见啦\033[0m')
a = 'Program exits'
self.obj.record(a)
exit()
core/Manger.py
#! /bin/env python
# coding: utf-8
import pickle
class Mypickle:
def__init__(self,filepath):
self.filepath = filepath
def dump(self,school_obj):
with open(self.filepath, 'ab') as f:
pickle.dump(school_obj, f)
f.flush()
def load(self):
with open(self.filepath,'rb') as f:
while True:
try:
schoole_obj = pickle.load(f)
yield schoole_obj
# print(schoole)
except Exception:
break
def get_item(self,num):
with open(self.filepath, 'rb') as f:
while num > 0:
try:
schoole_obj = pickle.load(f)
except Exception:
break
num -= 1
return schoole_obj
core/Mypickle.py
#! /bin/env python
# coding=utf-8
class School:
def__init__(self, name, addr):
self.school_name = name
self.school_addr = addr
def__repr__(self): #内置的⽅法，让打印的对象丰富起来
show_str = ''
for key in self.__dict__:
show_str +='%s:%s ' % (key, self.__dict__[key]) return show_str
core/School.py
#! /bin/env python
# coding=utf-8
from collections import OrderedDict
from core import Manager
class Student:
dic = OrderedDict([('查看学校', 'show_school'),
('查看班级', 'show_class'),
('查看课程', 'show_course'),
('退出', 'quit')])
def__init__(self,name):
self.student_name = name
self.obj = Manager.Manager(name)
def__repr__(self): #内置的⽅法，让打印的对象丰富起来 show_str = ''
for key in self.__dict__:
if key == 'obj':continue
show_str +='%s:%s ' % (key, self.__dict__[key]) return show_str
def show_school(self):
self.obj.show_school()
def show_class(self):
self.obj.show_class()
def show_course(self):
self.obj.show_course()
def quit(self):
self.obj.quit()
core/Student.py
#! /bin/env python
# coding=utf-8
from collections import OrderedDict
from core import Manager
class Teacher:
dic = OrderedDict([('查看学校', 'show_school'),
('查看讲师', 'show_teacher'),
('查看班级', 'show_class'),
('查看课程', 'show_course'),
('退出', 'quit')])
def__init__(self,name):
self.teacher_name = name
self.obj = Manager.Manager(name)
def__repr__(self): #内置的⽅法，让打印的对象丰富起来 show_str = ''
for key in self.__dict__:
if key == 'obj':continue
show_str +='%s:%s ' % (key, self.__dict__[key]) return show_str
def show_school(self):
self.obj.show_school()
def show_teacher(self):
self.obj.show_teacher()
def show_class(self):
self.obj.show_class()
def show_course(self):
self.obj.show_course()
def quit(self):
self.obj.quit()
core/Teacher.py。