开发一套选课系统

时间:2022-03-31 12:02:59

一:项目题目:开发一套选课系统

二:项目需求:

角色:学校、学员、课程、讲师

要求:

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

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

  

三:注意事项

1.(简单)实现70%+功能,充分使用类
2.(一般)类的设计比较清晰、合理
3.(完整)整体代码逻辑很清晰、角色划分清楚、不同角色的主要功能都实现了

  

四,项目思路

 1,先分析题目,,也就是找关键词,从上面可以看出有三个视图,分别是管理员视图,讲师视图,学员视图

对角色进行分类:学校,老师,学生,课堂,班级,管理者

三个视图,也就是三个管理接口,分别是学员视图,讲师视图,管理视图

五个角色,也就是定义五个类,分别是学校,学员,课程,讲师,班级

  

2,分析管理员创建什么东西,老师创建什么东西,学生创建什么东西

一个讲师可以教多个班
一个学员可以学多个班级的课
一个课程可以有多个班级
一个班级对应一个课程
一个班级对应一个讲师

学生视图:要选择学校,选择班级,其中班级显示其名称,课程,价钱,添加到对应的班级里面
讲师视图:可以查看所教授的课程的班级,班级学生的信息
管理员视图:可以创建讲师,创建班级,创建课程,查询讲师,班级,课程的功能

  

3,具体进行分析

    具体分析学生视图,学生视图进去可以注册学生(包括选择所在学校,选择所在班级,选择所学课程),
查看学生的成绩,查看学生的到课情况

具体分析讲师视图,讲师视图进去可以注册讲师(包括选择所在学校,选择所教班级,选择所教课程),
创建学生的成绩,创建学生的到课情况(管理班级)

具体分析管理视图,管理视图进去可以创建学生,创建讲师,创建课程,创建学校,创建班级,创建课程等等

对于管理系统,我附加了登陆认证,我认为管理不是随便就可以进去的,管理者账号admin,密码root,
认证成功后才可以进行一系列操作

  

4,写出大致的伪代码,并实现其功能,如下:

伪代码:
学校视图:
    选择学校
        1,创建班级
        2,创建讲师
        3,创建课程
     4,查询讲师
     5,查询班级
     6,查询课程

讲师视图
    1,查看班级
    2,查看班级学员列表
学员视图
    1,注册
    2,报名缴费
    3,选择班级

 

5,填充代码

 

五,项目流程图

 开发一套选课系统

 六,README文件

作者:zhanzhengrecheng

程序介绍:

    实现选课系统 常用功能

    功能全部用python的基础知识实现,用到了os\sys\pickle\函数\模块\类知识

概述

本次作业文件夹一共包含了以下6个文件:

流程图: Select Course思路流程图

程序结构图:整个Select Course的程序文件结构

程序结构文件:整个Select Course的程序文件结构

程序文件: Select Course

程序说明文件:README.md


程序要求


    创建北京、上海 2 所学校

    创建linux , python , go 3个课程 , linux\py 在北京开, go 在上海开

    课程包含,周期,价格,通过学校创建课程

    通过学校创建班级, 班级关联课程、讲师
    
    创建学员时,选择学校,关联班级

    创建讲师角色时要关联学校,
    
    提供两个角色接口

    学员视图, 可以注册, 交学费, 选择班级,

    讲师视图, 讲师可管理自己的班级, 上课时选择班级, 查看班级学员列表 , 修改所管理的学员的成绩

    管理视图,创建讲师, 创建班级,创建课程  

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


 本程序思路是写了一个Select Course的程序



    先分析题目,,也就是找关键词,从上面可以看出有三个视图,分别是管理员视图,讲师视图,学员视图

    对角色进行分类:学校,老师,学生,课堂,班级,管理者

    分析管理员创建什么东西,老师创建什么东西,学生创建什么东西

    具体分析学生视图,学生视图进去可以注册学生(包括选择所在学校,选择所在班级,选择所学课程),
    查看学生的成绩,查看学生的到课情况

    具体分析讲师视图,讲师视图进去可以注册讲师(包括选择所在学校,选择所教班级,选择所教课程),
    创建学生的成绩,创建学生的到课情况(管理班级)

    具体分析管理视图,管理视图进去可以创建学生,创建讲师,创建课程,创建学校,创建班级,创建课程等等

    对于管理系统,我附加了登陆认证,我认为管理不是随便就可以进去的,管理者账号admin,密码root,
    认证成功后才可以进行一系列操作

    写出伪代码,然后填充

程序结构

备注(程序结构)

    目前还不会在windows中用树的结构,所以做出程序结构的txt版本,放在文件外面

    对几个实例文件的说明

── admin # 管理者账户数据,只存了一个管理者,账号是admin,密码是root

── c++	# 这是存课程类中其中一个课程的详细信息

── class #这是存班级的文件,比如创建了python全栈1班,。。。

── class_grade # 这是存班级中学生成绩的文件,比如王二:87

── class_record # 这是存班级中学生到课次数的文件,比如王二:8次

── Course # 这是存所有课程的文件,比如目前开的课程有'python', 'linux', 'java',c++,.。。

── java #这是存课程类中其中一个课程的详细信息

── linux # 这是存课程类中其中一个课程的详细信息

── python # 这是存课程类中其中一个课程的详细信息

── school # 这是存所有学校的文件,比如目前只有北京分校,上海分校,。。。


不足及其改进的方面

1,未能熟练的使用类方法,好多类中函数为了方便类与对象都可以调用,写成了普通函数,

2,希望对类有更熟悉的认识之后,重构代码,用class写,不出现很多@staticmethod

3,想法比较简单,希望能学习更好的用类写出来的选课系统,自己再研究研究

  

七,程序结构图

开发一套选课系统

 

八,程序代码

 8.1 bin

bin下run.py

# _*_ coding: utf-8 _*_ 
import os
import sys

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)

from core import main

if __name__ =='__main__':
    main.begin()

  

8.2 conf

conf下settings.py

# _*_ coding: utf-8 _*_
import sys
import os
import logging

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)

DATABASE = {
    'engine':'file_storage', #文件存储,这里可扩展成数据库形式
    'name':'accounts',       #db下的文件名称
    'path':'%s/db'%BASE_DIR
}
LOGIN_LEVEL = logging.INFO     #初始化日志记录级别为INFO,INFO以下的可以直接打印
#日志类型
LOGIN_TYPE = {
    'system':'system.log',
}

  

8.3 core

core下的accounts.py

# _*_ coding: utf-8 _*_ 
#读取数据和保存数据
import os
import sys
import pickle,json
import  logging

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)  #添加环境变量

from core import auth
from core import db_handler
from conf import settings

class MyPickle:
    def __init__(self):
        pass

    def load_account(account):
        db_path = db_handler.db_handler(settings.DATABASE)
        account_file = '%s/%s' % (db_path, account)
        if os.path.isfile(account_file):  # 如果用户名存在
            with open(account_file, 'rb') as f:
                account_data = pickle.load( f)
                return account_data
        else:
            print("\033[31;1mAccount [%s] does not exist!\033[0m" % account)
            exit()

    def save_account(account_dic):
        db_path = db_handler.db_handler(settings.DATABASE)
        filename = '%s/%s' % (db_path, account_dic['account'])
        with open(filename,'wb') as f:
            acc_data = pickle.dump(account_dic, f)

    def save_course(account_dic):
        db_path = db_handler.db_handler(settings.DATABASE)
        filename = '%s/%s' % (db_path, account_dic['course_name'])
        with open(filename,'wb') as f:
            acc_data = pickle.dump(account_dic, f)

    def load_course(course_name):
        db_path = db_handler.db_handler(settings.DATABASE)
        account_file = '%s/%s' % (db_path, course_name)
        if os.path.isfile(account_file):#如果用户名存在
            with open(account_file, 'rb') as f:
                account_data = pickle.load( f)
                print("\033[34;1m--------这是您查找的课程信息----------\033[0m")
                print('\033[32;1m%s\033[0m'%account_data)
                return account_data
        else:
            print("\033[31;1mCourse [%s] does not exist!\033[0m" % course_name)
            exit()

    def save_class(name,class_name):
        db_path = db_handler.db_handler(settings.DATABASE)
        filename = '%s/%s' % (db_path, name)
        with open(filename, 'a+',encoding='utf-8') as f:
            f.write(class_name)
            f.write(',')

    def load_class(name):
        db_path = db_handler.db_handler(settings.DATABASE)
        account_file = '%s/%s' % (db_path, name)
        if os.path.isfile(account_file):  # 如果用户名存在
            with open(account_file, 'r',encoding='utf-8') as f:
                account_data = f.read()
                print("----------\033[34;1m目前存在的班级\033[0m----------")
                print("\033[31;1m%s\033[0m" % account_data)
                print("-----------------------------------")
                return account_data
        else:
            print("\033[31;1mClass [%s] does not exist!\033[0m" % name)
            exit()

    def save_classrecord(name,classrecord_dict):
        db_path = db_handler.db_handler(settings.DATABASE)
        filename = '%s/%s' % (db_path, name)
        with open(filename, 'a+',encoding='utf-8') as f:
            f.write(classrecord_dict)
            f.write(',')

    def load_classrecord(name):
        db_path = db_handler.db_handler(settings.DATABASE)
        account_file = '%s/%s' % (db_path, name)
        if os.path.isfile(account_file):  # 如果用户名存在
            with open(account_file, 'r',encoding='utf-8') as f:
                account_data = f.read()
                print("-----------------课堂记录-------------------")
                print("\033[31;1m%s\033[0m" % account_data)
                print("-------------------------------------------")
                return account_data
        else:
            print("\033[31;1mClass record does not exist!\033[0m" )
            exit()

    def save_classgrade(name,classgrade_dict):
        db_path = db_handler.db_handler(settings.DATABASE)
        filename = '%s/%s' % (db_path, name)
        with open(filename, 'a+',encoding='utf-8') as f:
            f.write(classgrade_dict)
            f.write(',')

    def load_classgrade(name):
        db_path = db_handler.db_handler(settings.DATABASE)
        account_file = '%s/%s' % (db_path, name)
        if os.path.isfile(account_file):  # 如果用户名存在
            with open(account_file, 'r',encoding='utf-8') as f:
                account_data = f.read()
                print("-----------------学生成绩-------------------")
                print("\033[31;1m%s\033[0m" % account_data)
                print("-------------------------------------------")
                return account_data
        else:
            print("\033[31;1mClass grade does not exist!\033[0m")
            exit()

    def save_school(name, school_name):
        db_path = db_handler.db_handler(settings.DATABASE)
        filename = '%s/%s' % (db_path, name)
        with open(filename, 'a+',encoding='utf-8') as f:
            f.write(school_name)
            f.write(',')

    def load_school(name):
        db_path = db_handler.db_handler(settings.DATABASE)
        account_file = '%s/%s' % (db_path, name)
        if os.path.isfile(account_file):  # 如果用户名存在
            with open(account_file, 'r',encoding='utf-8') as f:
                account_data = f.read()
                print("----------\033[34;1m目前存在的学校\033[0m----------")
                print("\033[31;1m%s\033[0m" % account_data)
                print("-----------------------------------")
                return account_data
        else:
            print("\033[31;1mSchool  does not exist!\033[0m")
            exit()

    def save_coursedata(name, course_name):
        db_path = db_handler.db_handler(settings.DATABASE)
        filename = '%s/%s' % (db_path, name)
        with open(filename,'a+',encoding='utf-8') as f:
            f.write(course_name)
            f.write(',')

    def load_coursedata(name):
        db_path = db_handler.db_handler(settings.DATABASE)
        account_file = '%s/%s' % (db_path, name)
        if os.path.isfile(account_file):  # 如果用户名存在
            with open(account_file, 'r',encoding='utf-8') as f:
                account_data = f.read()
                print("----------\033[34;1m这是已经有的课程\033[0m----------")
                print("\033[31;1m%s\033[0m" % account_data)
                print("----------------------------------------------------")
                return account_data
        else:
            print("\033[31;1mCourse  does not exist!\033[0m")
            exit()

  

core下auth.py

# _*_ coding: utf-8 _*_ 
import os
import json
from core import accounts
#用户认证

def access_login(user_data,log_obj):
    '''
    登陆函数,当登陆失败超过三次,则退出
    登陆成功之后,查看这个人的身份,来确定进入那个视图
    :return: 如果用户账号密码正确,则返回用户数据的字典
    '''
    retry_count = 0
    while user_data['is_authenticated'] is not True and retry_count <3:
        account = input('\033[34;1mplease input Administrator Acount:\033[0m').strip()
        password = input('\033[34;1mplease input Administrator Password:\033[0m').strip()
        #用户账号密码正确,则返回用户数据的字典
        auth = access_auth(account,password,log_obj)
        if auth:
            user_data['is_authenticated'] = True  #用户认证为True
            user_data['account_id']  = account   #用户账号ID为账号名
            return auth
        retry_count +=1
    else:
        print("Account [%s] try logging too many times..." % account)
        log_obj.error("Account [%s] try logging too many times..." % account)
        exit()

def access_auth(account,password,log_obj):
    '''
    下面access_login调用access_auth方法,用于登陆
    :param account: 用户名
    :param password: 密码
    :param log_obj:
    :return:
    '''
    account_data = accounts.MyPickle.load_account(account)
    if account_data.get('vip_password') is not None:
        if account_data['vip_password'] == password:
            log_obj.info("Account [%s] logging success" % account)
            return account_data
        else:
            log_obj.error(" Password does not correct!")
            print("\033[31;1m Password not correct!\033[0m")
    else:
        log_obj.error("Account or Password does not correct!")
        print("\033[31;1mAccount or Passwordoes not correct!\033[0m")

  

core下db_handler.py

# _*_ coding: utf-8 _*_ 
'''处理与数据之间的交互,如果file_db_storage,返回路径'''
import pickle
import os
from conf import settings

def db_handler(conn_parms):
    if conn_parms['engine'] == 'file_storage':
        return file_db_handle(conn_parms)

def file_db_handle(conn_parms):
    '''
    对文件路劲做语法分析
    :param conn_parms:
    :return:
    '''
    db_path = '%s/%s'%(conn_parms['path'],conn_parms['name'])
    return db_path

  

core下logger.py

# _*_ coding: utf-8 _*_
'''操作所有的日志工作'''
import logging
from conf import settings

def logger(log_type):

    #创建日志
    logger = logging.getLogger(log_type)
    logger.setLevel(settings.LOGIN_LEVEL)

    #创建屏幕对象和设置等级debug
    # ch = logging.StreamHandler()
    # ch.setLevel(settings.LOGIN_LEVEL)

    #创建文件对象,给文件对象设置等级
    log_file = "%s/log/%s"%(settings.BASE_DIR,settings.LOGIN_TYPE[log_type])
    fh = logging.FileHandler(log_file)
    fh.setLevel(settings.LOGIN_LEVEL)
    # 设置输出对象格式
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

    #把格式添加到配置中
    # ch.setFormatter(formatter)
    fh.setFormatter(formatter)

    #把日志打印到指定的handler
    # logger.addHandler(ch)
    logger.addHandler(fh)

    return logger

  

core下main.py

# _*_ coding: utf-8 _*_
from core import Manager
from core import Student
from core import Teacher
from conf import settings
from core import  logger
from core import auth
import sys

#初始化账户数据
user_data = {
    'account_id':None,
    'is_authenticated':False,
    'account_data':None
}
#系统日志记录到文件中
access_logger = logger.logger('system')

def interactive(msg,menu_dic):
    exit_flag = False
    while not exit_flag:
        print(msg)
        user_choice = input("please choice >>>>").strip()
        if user_choice in menu_dic:
            menu_dic[user_choice]()
        else:
            print("\033[31;1myou choice doesn't exist\033[0m")

def Student_view():
    msg = '''\033[32;1m-------welcome to student manage view------
            1   注册新学生用户
            2   查看上课记录
            3   查看作业成绩
            4   退出
    \033[0m'''
    menu_dic = {
        "1": Student.Student.resistered,
        "2":Student.Student.find_classrecord,
        "3":Student.Student.find_grade,
        "4":logout,
    }
    interactive(msg,menu_dic)

def  Teacher_view():
    msg = '''\033[32;1m-------welcome to teacher manage view------
            1   创建新讲师
            2   创建学生上课情况
            3   创建学生考试成绩
            4   logout
    \033[0m'''
    menu_dic = {
        "1":Teacher.Teacher.resistered,
        "2":Teacher.Teacher.create_classrecord,
        "3":Teacher.Teacher.create_grade,
        "4":logout,
    }
    interactive(msg, menu_dic)

def Manager_view():
    msg = '''\033[32;1m-------welcome to admin manage view------
            1   创建讲师
            2   创建学生
            3   创建学校
            4   创建课程
            5   查看课程
            6   查看学校
            7   创建班级
            8   查看班级
            9   退出
    \033[0m'''
    menu_dic = {
        "1":Manager.Manager.create_teacher,
        "2":Manager.Manager.create_student,
        "3":Manager.Manager.create_school,
        "4": Manager.Manager.create_course,
        "5": Manager.Manager.show_course,
        "6":Manager.Manager.show_school,
        "7": Manager.Manager.create_class,
        "8": Manager.Manager.show_class,
        "9": logout,
    }
    # login_judge()
    interactive(msg, menu_dic)

#退出,写简单函数即可
def logout():
    '''
    退出登陆
    :return:
    '''
    print("\033[32;1m-------Looking forward to your next visit-------\033[0m")
    exit()

def begin():
    '''
    开始入口
    :return:
    '''
    msg = '''\033[32;1m-------welcome to course selectionn system------
            1   Student_system
            2   Teacher_system
            3   Manager_system
            4   logout
    \033[0m'''
    menu_dic = {
        "1":Student_view,
        "2":Teacher_view,
        "3":Manager_view,
        "4":logout,
    }

    interactive(msg, menu_dic)

def login_judge():
    # 调用认证模块,返回用户文件json.load后的字典,传入access_logger日志对象

    access_data = auth.access_login(user_data,access_logger)
    if user_data['is_authenticated']:       #如果用户认证成功
        user_data["account_data"] = access_data

  

core下Manager.py

# _*_ coding: utf-8 _*_
from core import Teacher
from core import Student
from core import accounts
from lib import Course
from lib import Classes
from lib import School

class Manager:
    def __init__(self):
        pass
    @staticmethod
    def create_student():
        Student.Student.resistered()

    @staticmethod
    def create_teacher():
        Teacher.Teacher.resistered()

    @staticmethod
    def create_course():
        Course.Course.create_course()

    @staticmethod
    def show_course():
        Course.Course.show_course()

    @staticmethod
    def create_class():
        Classes.Classes.create_class()

    @staticmethod
    def show_class():
        Classes.Classes.show_class()

    @staticmethod
    def create_school():
        School.School.create_school()

    @staticmethod
    def show_school():
        School.School.show_school()

  

core下Student.py

# _*_ coding: utf-8 _*_
'''
学员视图,学员创建姓名,年龄,所报的班级,所报的学校等等
'''
from core import main
from core import accounts
from core import Manager
from lib import Course
class Student:
    def __init__(self):
        pass

    #学生注册
    @staticmethod
    def resistered():
        student_dict = {}
        print('\033[32;1m-------welcome to student registered system------\033[0m')
        student_name = input("student_name >>>")
        student_password = input("student_password >>>")
        Manager.Manager.show_school()
        student_school = input("student_school >>>")
        Manager.Manager.show_class()
        student_class = input("student_class >>>")
        accounts.MyPickle.load_coursedata('course')
        student_course = input("student_course >>>")
        student_score = None
        student_identity = 'student'
        student_dict['account'] = student_name
        student_dict['password'] = student_password
        student_dict['school'] = student_school
        student_dict['class'] = student_class
        student_dict['course'] = student_course
        student_dict['score'] = student_score
        student_dict['identity'] = student_identity
        print("\033[32;1m--------这是您登记的信息,请查看----------\033[0m")
        print('\033[31;1m%s\033[0m'%student_dict)
        accounts.MyPickle.save_account(student_dict)

    #查看上课记录
    @staticmethod
    def find_classrecord():
        '''上课记录是老师给的'''
        print('\033[32;1m-------welcome to Student system(find classrecord)------\033[0m')
        name = 'class_record'
        accounts.MyPickle.load_classrecord(name)

    #查看作业成绩
    @staticmethod
    def find_grade():
        '''成绩是老师给的'''
        print('\033[32;1m-------welcome to Student system(find classgrade)------\033[0m')
        name = 'class_grade'
        accounts.MyPickle.load_classgrade(name)

  

core下Teacher.py

# _*_ coding: utf-8 _*_
from core import accounts
from core import Manager

class Teacher:
    def __init__(self):
        pass

    #讲师注册
    @staticmethod
    def resistered():
        teacher_dict = {}
        print('\033[32;1m-------welcome to teacher registered system------\033[0m')
        teacher_name = input("teacher_name >>>")
        teacher_password = input("teacher_password >>>")
        Manager.Manager.show_school()
        teacher_school = input("teacher_school >>>")
        Manager.Manager.show_class()
        teacher_class = input("teacher_class >>>")
        teacher_identity = 'teacher'
        teacher_dict['account'] = teacher_name
        teacher_dict['password'] = teacher_password
        teacher_dict['school'] = teacher_school
        teacher_dict['class'] = teacher_class
        teacher_dict['identity'] = teacher_identity
        print("\033[32;1m--------这是您登记的信息,请查看----------\033[0m")
        print('\033[31;1m%s\033[0m' % teacher_dict)
        accounts.MyPickle.save_account(teacher_dict)

    #创建上课记录,想法是每一个人对应一个记录,比如王某:8次
    @staticmethod
    def create_classrecord():
        classrecord_dict = {}
        print('\033[32;1m-------welcome to teacher  system(create class_record)------\033[0m')
        student_name = input("student_name >>>")
        class_record = input("class_record >>>")
        classrecord_dict[student_name] = class_record
        name = 'class_record'
        classrecord_dict = str(classrecord_dict)
        accounts.MyPickle.save_classrecord(name,classrecord_dict)

    #创建作业成绩,想法是每一个人对应一个记录,比如王某:98
    @staticmethod
    def create_grade():
        classgrade_dict = {}
        print('\033[32;1m-------welcome to teacher  system(create class_grade)------\033[0m')
        student_name = input("student_name >>>")
        class_grade = input("class_grade >>>")
        classgrade_dict[student_name] = class_grade
        name = 'class_grade'
        classgrade_dict = str(classgrade_dict)
        accounts.MyPickle.save_classgrade(name,classgrade_dict)

  

8.4 db

db下accounts

(这是文件,在这里就不一一展示了)

8.5lib

lib下Classes

# _*_ coding: utf-8 _*_
from lib import Course
from core import accounts
from core import Manager
class Classes:
    def __init__(self):
        pass

    @staticmethod
    def create_class():
        name = 'class'
        print('\033[32;1m-------welcome to manage  system(create class)------\033[0m')
        class_data = accounts.MyPickle.load_class(name)
        class_name = input("class_name >>>")
        accounts.MyPickle.save_class(name,class_name)

    @staticmethod
    def show_class():
        print('\033[32;1m-------welcome to Manager system(find class)------\033[0m')
        name = 'class'
        accounts.MyPickle.load_class(name)

  

lib下Course

# _*_ coding: utf-8 _*_ 
#创建一个课程类,包括课程名称,课程周期,课程价格
from core import accounts
from core import Manager
class Course:
    def __init__(self):
       pass
    @staticmethod
    def create_course():
        name = 'course'
        print('\033[32;1m-------welcome to Manager system(create course)------\033[0m')
        course_data = accounts.MyPickle.load_coursedata(name)
        course_dict = {}
        accounts.MyPickle.load_school('school')
        course_school = input("The school of course:>>>")
        course_name = input("course name:>>>")
        course_period = input("course period:>>>")
        course_prices = input("course prices:>>>")
        course_dict["course_school"] = course_school
        course_dict["course_name"] = course_name
        course_dict["course_period"] = course_period
        course_dict["course_prices"] = course_prices
        print("\033[32;1m--------这是您创建课程的信息,请查看----------\033[0m")
        print('\033[31;1m%s\033[0m' % course_dict)
        accounts.MyPickle.save_course(course_dict)
        accounts.MyPickle.save_coursedata(name, course_name)
    @staticmethod
    def show_course():
        '''
        输入课程信息
        :return:
        '''
        print('\033[32;1m-------welcome to Manager system(find course)------\033[0m')
        name = 'course'
        accounts.MyPickle.load_coursedata(name)
        course_name = input("请输入要查找的课程名:>>>")
        accounts.MyPickle.load_course(course_name)

  

lib下School

# _*_ coding: utf-8 _*_
from lib import Course
from core import accounts
class School:
    def __init__(self):
        pass

    @staticmethod
    def create_school():
        name = 'school'
        school_data = accounts.MyPickle.load_school(name)
        print('\033[32;1m-------welcome to manage  system(create school)------\033[0m')
        school_name = input("school_name >>>")
        accounts.MyPickle.save_school(name,school_name)
    @staticmethod
    def show_school():
        print('\033[32;1m-------welcome to Manager system(find school)------\033[0m')
        name = 'school'
        accounts.MyPickle.load_school(name)

  

8.6log

system.log

2018-04-19 09:15:24,489 - system - ERROR - Account or Password does not correct!
2018-04-19 09:15:36,036 - system - ERROR - Account or Password does not correct!
2018-04-19 09:15:43,911 - system - ERROR - Account or Password does not correct!
2018-04-19 09:15:43,911 - system - ERROR - Account [admin] try logging too many times...
2018-04-19 09:20:48,536 - system - ERROR - Account or Password does not correct!
2018-04-19 09:23:00,911 - system - INFO - Account [admin] logging success
2018-04-19 09:29:27,238 - system - INFO - Account [admin] logging success
2018-04-19 09:40:13,110 - system - INFO - Account [admin] logging success
2018-04-19 10:02:58,567 - system - INFO - Account [admin] logging success
2018-04-19 10:03:16,395 - system - INFO - Account [admin] logging success
2018-04-20 13:57:36,289 - system - ERROR - Account or Password does not correct!
2018-04-20 13:58:19,360 - system - ERROR - Account or Password does not correct!
2018-04-20 13:58:52,241 - system - ERROR - Account or Password does not correct!
2018-04-20 14:00:03,168 - system - INFO - Account [admin] logging success
2018-04-20 14:00:43,360 - system - INFO - Account [admin] logging success
2018-04-20 14:01:50,831 - system - INFO - Account [admin] logging success
2018-04-20 14:02:24,279 - system - INFO - Account [admin] logging success