开发一套选课系统

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

要求:

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.（完整）整体代码逻辑很清晰、角色划分清楚、不同角色的主要功能都实现了

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

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

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

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

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

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

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

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

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

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

作者: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，想法比较简单，希望能学习更好的用类写出来的选课系统，自己再研究研究

# _*_ 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()

# _*_ 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‘,
}

# _*_ 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()

# _*_ 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")

# _*_ 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

# _*_ 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

# _*_ 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

# _*_ 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()

# _*_ 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)

# _*_ 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)

# _*_ 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)

# _*_ 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)

# _*_ 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)

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