【项目】：选课系统

本节作业: 选课系统

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

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

程序为B+,做个标记，后期对程序做调整

已经对程序重新做了一遍，查看请移步-》》http://www.cnblogs.com/lianzhilei/p/5985333.html

程序：

1、最最重要的readme：

### 作者介绍：
* author：lzl
### 博客地址：
* http://www.cnblogs.com/lianzhilei/p/5813986.html

### 功能实现
    1. 创建北京、上海 2 所学校
    2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
    3. 课程包含，周期，价格，通过学校创建课程
    4. 通过学校创建班级， 班级关联课程、讲师
    5. 创建学员时，选择学校，关联班级
    5. 创建讲师角色时要关联学校，
    6. 提供两个角色接口
    6.1 学员视图， 可以注册， 交学费， 选择班级，
    6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
    6.3 管理视图，创建讲师， 创建班级，创建课程
    7. 上面的操作产生的数据都通过pickle序列化保存到文件里
    （所有功能均实现）

###程序需知
    1. 当前数据库已建立好信息，可以直接进行查看增加
        北京  课程：Python   讲师：金角大王     班级:S14      学员：我要学python
              课程：Linux    讲师：银角大王     班级:L01      学员：我要学Linux
        上海  课程：Go       讲师：天棚元帅     班级:G01      学员：我要学GO
    2. 也可以把database下的两个数据库文件删除掉，数据清空，执行程序，数据库进行初始化，初始化只生成北京、上海学校名
    3. 数据库结构main_dict 储存主要的逻辑结构：
        {学校名：{课程名1：{"teacher":讲师，"grade"：班级}，课程名2：{"teacher":讲师2，"grade"：班级2}}，
        学校名：{课程名3：{"teacher":讲师3，"grade"：班级3}，课程名4：{"teacher":讲师4，"grade"：班级4}}}
        存储的数据类型都为实例对象
       数据库结构teacher_dict 存储讲师与班级的对应关系，用于方便讲师登录系统认证，结构为
        {讲师：{grade：班级}
        两个数据库文件均可扩展
    4. 程序实现了以下严格限制：
       ①一个学校里面不能出现同名的课程
       ②一个课程只能有一个讲师
       ③讲师被聘用后，不能再进行聘用，一个讲师也只能教一门课程(教python，就不能再教linux了)
       ④班级只能对应一门课程，班级名只能出现一次，不能重复(python班级s14，linux的班级就不能再出现s14班级了）

###后期扩展
     程序没有定义学生类，后期可定义类，添加学生属性（年龄，成绩），对可学生成绩信息进行修改，把功能添加到教师中心，很显然
     我没时间了。。。。。
     程序按功能分出不同的模块，可以更简洁

2、程序目录结构：

3、数据库：

main_dict和teacher_dict两个数据库文件可不创建，运行程序自动生成

�}q (c__main__
School
q
)�q}q(X   nameqX   北京qX   addrqX       北京市qub}q(c__main__
Course
q    )�q
}q(X   priceqX   9900q
hX   PythonqX   timeqX
   7qub}q(X   teacherqc__main__
Teacher
q)�q}q(X   roleqX   讲师qX   schoolqhhX   金角大王qX   ageqX   33qX   courseqX   PythonqubX   gradeqc__main__
Grade
q)�q }q!(hhX   studentq"cbuiltins
set
q#]q$�q%Rq&hX   Pythonq'hX   S14q(ubuh    )�q)}q*(hX   9000q+hX   Linuxq,hX
   8q-ub}q.(hh)�q/}q0(hhhhhX   银角大王q1hX   25q2hX   Linuxq3ubhh)�q4}q5(hh1h"h#]q6�q7Rq8hX   Linuxq9hX   L01q:ubuuh
)�q;}q<(hX   上海q=hX       上海市q>ub}q?h    )�q@}qA(hX   8000qBhX   GoqChX
   9qDub}qE(X   teacherqFh)�qG}qH(hX   讲师qIhh=hX   天蓬元帅qJhX   25qKhX   GoqLubX   gradeqMh)�qN}qO(hhJh"h#]qP�qQRqRhX   GoqShX   S01qTubusu.

�}q (c__main__
Teacher
q
)�q}q(X   roleqX   讲师qX   schoolqX   北京qX   nameqX   金角大王q    X   ageq
X   33qX   courseqX   Pythonq
ub}qX   gradeqc__main__
Grade
q)�q}q(X   teacherqh    X   studentqcbuiltins
set
q]qX   我要学pythonqa�qRqhX   PythonqhX   S14qubsh
)�q}q(hX   讲师qhX   北京qhX   银角大王q h
X   25q!hX   Linuxq"ub}q#X   gradeq$h)�q%}q&(hh hh]q'X   我要学linuxq(a�q)Rq*hX   Linuxq+hX   L01q,ubsh
)�q-}q.(hX   讲师q/hX   上海q0hX   天蓬元帅q1h
X   25q2hX   Goq3ub}q4X   gradeq5h)�q6}q7(hh1hh]q8X   我要学go语言q9a�q:Rq;hX   Goq<hX   S01q=ubsu.

4、程序main.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian

import pickle,os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
#数据地址
__db_main = BASE_DIR + r"\database\main_dict"
__db_teacher = BASE_DIR + r"\database\teacher_dict"

class School(object):
   #创建学校
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr

    def cat_school(self):
        print("学校名：【%s】\t地址：【%s】"%(self.name,self.addr))

    def hire_teacher(self,dict,course,teacher,file):
        #数据库添加讲师信息
        dict[self][course] = {"teacher":teacher}
        file_oper(file,"wb", dict)

    def create_course(self,dict,course,file):
        # 数据库添加课程资料
        dict[self][course]={}
        file_oper(file,"wb", dict)

    def create_grade(self,dict,teacher_dict,course,grade,teacher,file1,file2):
        #数据库添加班级信息
        dict[self][course]["grade"] = grade
        file_oper(file1, "wb", dict)
        teacher_dict[teacher] = {"grade":grade}
        file_oper(file2, "wb", teacher_dict)

class Course():
    #创建课程
    def __init__(self,name,price,time):
        self.name = name
        self.price = price
        self.time = time

    def cat_course(self):
        #查看课程信息
        print("课程：【%s】\t价格：【￥%s】\t周期：【%s个月】"
              %(self.name,self.price,self.time))

class Grade():
    # 创建班级
    def __init__(self,name,course,teacher):
        student = set([])
        self.name = name
        self.course = course
        self.teacher = teacher
        self.student = student

    def cat_grade(self):
        #查看班级信息
        print("班级：【%s】\t课程：【%s】\t讲师：【%s】"
              %(self.name, self.course, self.teacher))

    def add_student(self,student_name,dict,teacher,file):
        self.student.add(student_name)
        dict[teacher]={"grade":self}
        file_oper(file, "wb", dict)

class People():
    def __init__(self,name,age):
        self.name = name
        self.age = age

class Teacher(People):
    # 创建讲师
    def __init__(self,name,age,school,course,role="讲师"):
        super(Teacher,self).__init__(name,age)
        self.role = role
        self.school = school
        self.course = course

    def cat_teacher(self):
        #查看老师资料和课程
        print('课程【%s】\t讲师【%s】'%(self.course,self.name))


def file_oper(file,mode,*args):
    #数据库写入、读取操作
    if mode == "wb":
        with open(file, mode) as f:
            dict = args[0]
            f.write(pickle.dumps(dict))

    if mode == "rb":
        with open(file, mode) as f:
            dict = pickle.loads(f.read())
            return dict

def information(dict,mode,*args):
    '''通过匹配mode模式，打印相应的输出信息'''
    if args:
        dict_info, set_info = {}, args[0]
    else:
        dict_info,set_info = {},set([])
    if dict:
        for key in dict:
            if mode == "course":
                key.cat_course()
            if mode == "main":
                key.cat_school()
            if mode == "teacher" and key == "teacher":
                dict[key].cat_teacher()
                # dict_info[key] = dict[key]
                set_info.add(dict[key].name)
            if mode == "grade" and key == "grade":
                dict[key].cat_grade()
                set_info.add(dict[key].name)
            if mode == "teacher_center":
                pass
            if type(key) != str:        #key值不是字符串
                dict_info[key.name] = key
    return dict_info,set_info

def school_center():
    #学校管理中心
    Flag = True
    while Flag:
        dict_main = file_oper(__db_main,"rb")       #主字典
        res_dict = information(dict_main,"main")[0]    #打印学校信息
        school_name = input("\33[34;0m输入要选择的学校名\33[0m：").strip()
        if school_name in res_dict:
            school = res_dict[school_name]          #匹配选择的学校
            while Flag:
                print("\33[32;1m欢迎进入【%s】学校\33[0m".center(50, "*")%school.name)
                choice = options(list_school)       #打印当前选项
                if choice == "1":
                    while True:
                        print("\33[32;0m学校【%s】目前已经有的班级信息\33[0m".center(40, "-")%school.name)
                        teacher_dict = file_oper(__db_teacher,"rb")
                        res_course = information(dict_main[school], "None")[0]
                        set_info = set([])
                        if res_course:  # 打印课程与讲师对应关系
                            for i in res_course:
                                k = res_course[i]
                                res_grade = information(dict_main[school][k], "grade",set_info)[1]
                        if_cont = input("\n\33[34;0m是否要创建班级 【y】创建 【b】退出\33[0m:")
                        if if_cont == "y":
                            grade_name = input("\33[34;0m输入要创建班级的名称\33[0m:").strip()
                            course_name = input("\33[34;0m输入要班级要上的课程\33[0m:").strip()
                            if course_name in res_course:
                                course = res_course[course_name]
                                if dict_main[school][course]:
                                    teacher = dict_main[school][course]["teacher"]
                                    if grade_name not in res_grade:
                                        grade = Grade(grade_name, course_name, teacher.name)
                                        school.create_grade(dict_main, teacher_dict, course, grade, teacher, __db_main,
                                                        __db_teacher)
                                    else:
                                        print("\33[31;0m错误：当前班级已经存在\33[0m")
                                else:
                                    print("\33[31;0m错误：当前课程还没有讲师\33[0m")
                            else:
                                print("\33[31;0m错误:课程【%s】不存在，请先创建课程\33[0m" % course_name)
                        if if_cont == "b":
                            break

                if choice == "2":
                    #招聘讲师
                    while True:
                        print("\33[32;0m学校【%s】目前已经有的课程与讲师\33[0m".center(40, "-")%school.name)
                        res_course = information(dict_main[school],"None")[0]
                        set_info = set([])
                        if res_course:                  #打印课程与讲师对应关系
                            for i in res_course:
                                k = res_course[i]
                                res_teacher = information(dict_main[school][k], "teacher",set_info)[1]
                                if not res_teacher:
                                    print("课程【%s】\t讲师【None】" %(i))
                        if_cont = input("\n\33[34;0m是否要招聘讲师 【y】招聘 【b】退出\33[0m:")
                        if if_cont == "y":
                            teacher_name = input("\33[34;0m输入要招聘讲师的名字\33[0m:").strip()
                            teacher_age = input("\33[34;0m输入要招聘讲师的年龄\33[0m:").strip()
                            course_name = input("\33[34;0m输入讲师【%s】要授课的课程\33[0m:"%teacher_name).strip()
                            if course_name in res_course:
                                    course = res_course[course_name]        #创建讲师并写入数据库
                                    if teacher_name not in res_teacher:
                                        teacher = Teacher(teacher_name,teacher_age,school.name,course_name)
                                        school.hire_teacher(dict_main, course, teacher, __db_main)
                                    else:
                                        print("\33[31;0m错误:教师【%s】已经被聘用\33[0m" %teacher_name)
                            else:
                                print("\33[31;0m错误:课程【%s】不存在，请先创建课程\33[0m" %course_name)
                        if if_cont == "b":
                            break

                if choice == "3":
                    #创建课程
                    while True:
                        print("\33[32;0m学校【%s】目前已经有的课程\33[0m".center(40,"-")%school.name)
                        res_dict = information(dict_main[school],"course")[0]     #打印课程信息赋值给字典course_dict
                        if_cont = input("\n\33[34;0m是否要创建课程 【y】创建 【b】退出\33[0m:")
                        if if_cont == "y":
                            course_name = input("\33[34;0m输入要创建的课程\33[0m:").strip()
                            if course_name not in res_dict:     #课程不存在，创建
                                price = input("\33[34;0m输入课程 【%s】 的价格\33[0m:" % (course_name))
                                time = input("\33[34;0m输入课程 【%s】 的周期（月）\33[0m:" % (course_name))
                                course = Course(course_name, price, time)   #创建课程course
                                school.create_course(dict_main,course, __db_main)   #关联学校和课程
                            else:                                   #课程存在
                                print("\33[31;0m错误：当前课程 【%s】 已经存在\33[0m" % (course_name))
                        if if_cont == "b":
                            break

                if choice == "4":
                    Flag = False
        if Flag:
            print("\33[31;0m错误：输入的学校 【%s】 不存在\33[0m"%(school_name))


def teacher_center():
    #讲师中心
        print("\33[32;1m欢迎进入讲师中心\33[0m".center(50, "*"))
        teacher_dict = file_oper(__db_teacher, "rb")
        dict_info = information(teacher_dict,"teacher_center")[0]   #验证登录
        teacher_name = input("\n\33[34;0m输入要登录讲师的名字\33[0m:").strip()
        if teacher_name in dict_info:
            while True:
                print("\33[32;1m欢迎进入讲师【%s】的管理中心\33[0m".center(40, "*")%teacher_name)
                choice = options(list_teacher)
                teacher = dict_info[teacher_name]
                grade = teacher_dict[teacher]["grade"]
                if choice == "1":
                    print("\33[32;0m讲师【%s】的班级信息\33[0m".center(40,"-")%teacher.name)
                    print("学校【%s】\t课程【%s】\t班级【%s】\t"%(teacher.school,teacher.course,grade.name))
                    any = input("\n\33[34;0m输入任意键退出当前\33[0m:")
                if choice == "2":
                    print("\33[32;0m讲师【%s】的班级学员列表\33[0m".center(40, "-") % teacher.name)
                    print("班级【%s】\n学员【%s】"%(grade.name,grade.student))
                    any = input("\n\33[34;0m输入任意键退出当前\33[0m:")
                if choice == "3":
                    break
        else:
            print("\33[31;0m错误：讲师【%s】 不存在\33[0m"%(teacher_name))

def student_center():
    #学员中心
    print("\33[32;1m欢迎进入学员中心中心\33[0m".center(50, "*"))
    while True:
        choice = options(list_student)          #打印学生中心选项
        if choice == "1":
            student_name = input("\33[34;0m输入学员的名字\33[0m：")
            dict = file_oper(__db_main, "rb")
            teacher_dict = file_oper(__db_teacher,"rb")
            school_dict = information(dict,"main")[0]   #打印当前可选的学校
            school_name = input("\33[34;0m输入要选择的学校名\33[0m：").strip()
            if school_name in school_dict:
                school = school_dict[school_name]
                if dict[school]:
                    course_dict = information(dict[school],"course")[0]  # 打印当前学校下的课程
                    course_name = input("\33[34;0m输入要选择的课程\33[0m：").strip()
                    if course_name in course_dict:
                        course = course_dict[course_name]
                        if dict[school][course].get("grade"):
                            for i in teacher_dict:
                                if course.name == i.course:
                                    teacher = i
                                    grade = teacher_dict[teacher]["grade"]
                            print("课程【%s】的费用为【%s】"%(course.name,course.price))
                            if_pay = input("\33[34;0m是否支付当前费用 支付【y】\33[0m:")
                            if if_pay == "y":           #上面全部匹配成功，选课成功
                                grade.add_student(student_name,teacher_dict,teacher,__db_teacher)
                                print("\33[31;0m选课成功\33[0m")
                                any = input("\n\33[34;0m输入任意键退出当前\33[0m:")
                        else:
                            print("\33[31;0m错误：课程没有班级\33[0m")
                    else:
                        print("\33[31;0m错误：课程不存在\33[0m")
                else:
                    print("\33[31;0m错误：当前学校没有课程\33[0m")
        if choice == "2":
            break

def options(list):
    #打印可选择的操作模式，并返回选择值
    for i, v in enumerate(list):
        print(i+1, v)
    choice = input("\33[34;0m选择要进入模式\33[0m:")
    return choice

def start():
    '''程序开始'''
    while True:
        print("\33[35;1m欢迎进入选课系统\33[0m".center(50, "#"))
        choice = options(list_main)      #打印选项
        if choice == "1":
            student_center()        #学生中心
        if choice == "2":
            teacher_center()        #教师中心
        if choice == "3":
            school_center()         #学校中心
        if choice == "4":
            break

def init_database():
    '''数据库初始化，不存在则创建，存在跳过'''
    bj = School("北京","北京市")
    sh = School("上海","上海市")
    if not os.path.exists(__db_teacher):
        dict = {bj:{},sh:{}}
        file_oper(__db_main,"wb",dict)
    if not os.path.exists(__db_teacher):
        dict = {}
        file_oper(__db_teacher,"wb",dict)


if __name__ == '__main__':
    init_database()        #初始化数据库
    list_main = ["学生中心", "讲师中心", "学校中心","退出"]
    list_school = ["创建班级", "招聘讲师", "创建课程","返回"]
    list_teacher = ["查看班级", "查看班级学员列表","返回" ]
    list_student = ["学员注册","返回"]
    start()

5、程序运行过程的简略图

*********************学校中心***********************

*********************学生中心***********************

*********************讲师中心***********************