功能代码实现源地址：https://www.cnblogs.com/lianzhilei/p/5832691.html 如有侵权，立即删除
本文主要是分析 选课系统 实现思路及上面代码的实现过程，感谢python前辈分享出源码。
首先，写出自己的实现思路：
python初学者，自学到面向对象，有以下作业要求需要实现：
角色:学校、学员、课程、讲师 要求: 1. 创建北京、上海 2 所学校 2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开 3. 课程包含，周期，价格，通过学校创建课程 4. 通过学校创建班级， 班级关联课程、讲师 5. 创建学员时，选择学校，关联班级 6. 创建讲师角色时要关联学校， 7. 提供两个角色接口 8. 学员视图， 可以注册， 交学费， 选择班级， 9. 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩 10. 管理视图，创建讲师， 创建班级，创建课程 11. 上面的操作产生的数据都通过pickle序列化保存到文件里
最初拿到这个作业真的是无从下手，只能通过一句一句的返回斟酌，因为是学过了python的面向对象，首先分析上面那些可以作为类：
学校类、课程类、讲师类、学生类 class School: pass class Course: pass class Teacher: pass class Student: pass
1. 创建北京、上海 2 所学校
通过实例化可以创建这两所学校 sh = School(xxx) bj = School(xxx)
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
三个课程，我们可以通过实例化课程类实现 linux = Course(xxx) python = Course(xxx) go = Course(xxx)
linux\py 在北京开， go 在上海开 这就说明 School 类下有course这个属性，因此 School 修改为：
class School: def __init__(name, addr, course): self.name = name # 学校名 self.addr = addr # 学校地址 self.course = course # 学校里的课程 class Course: def __init__(name, price, time): self.name = name self.price = price self.time = time course = Course(name, price, time) # 实例化课程类 school = School(\'上海\', \'上海市\', course) # 类的组合
3. 课程包含，周期，价格，通过学校创建课程
到第三点要求的时候，上面的代码得改写了，如下： class School: def __init__(name, addr, course): self.name = name # 学校名 self.addr = addr # 学校地址 def create_course(self): # 通过学校创建课程 pass class Course: def __init__(name, price, time): self.name = name self.price = price self.time = time
4. 通过学校创建班级， 班级关联课程、讲师
到第四点又多了一个班级的类，这个类里包含哪些属性呢？ 班级名、班级上课的讲师、班级要上的课程、班级里的学生 class School: def __init__(name, addr, course): self.name = name # 学校名 self.addr = addr # 学校地址 def create_course(self): # 通过学校创建课程 pass class Course: def __init__(name, price, time): self.name = name self.price = price self.time = time class Grade: def __init__(name, teacher, course, student): self.name = name self.teacher = teacher self.course = course self.student = student
作为一个初学者，后面的需求就不知道怎么去实现了。于是去参考了下python前辈的代码：
源码地址：功能代码实现源地址：https://www.cnblogs.com/lianzhilei/p/5832691.html 如有侵权，立即删除
撸了N边代码，整理下思路，数据关系结构如下：
{school:{course:{\'teacher\': teacher, \'grade\': grade}}}
{teacher:{\'grade\':grade}}
有了这个数据关系，基本就能明白作者的实现思路。
举个栗子：
main_db = {school:{course:{\'teacher\': teacher, \'grade\': grade}}}
school = School(\'上海\')
上海学院下面的课程信息：
course = main_db[school]
上海学院python课程下面的老师和班级信息：
python = Course(\'python\')
info = main_db[school][python]
不知道通过上面的栗子能不能稍微领悟一点，通读作者代码和上面的作业要求，可以分为三大部分。
学校中心
接下来，不用看代码，试试自己来实现下：
作业要求是通过 pickle 序列化到本地文件
首先有三个视图：
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
先来实现第一个视图：学校中心
第一步，实现三大视图的循环选择
import pickle
def options(li):
for i, k in enumerate(li):
print(i+1, k)
choice = input(\'>>>\').strip()
return choice
def start():
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
if __name__ == \'__main__\':
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
start()
根据流程图， 第二步我们需要选择学校名，而我们并没有任何数据信息，这里就需要先初始化学校信息：
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
start()
通过初始化，已经将数据结构确定下来了。
__db_main = {sh: {}, bj: {}} __db_teacher = {}
可以查看当前程序的目录下，已经生成两个pickle序列化的文件，下一步，我们就可以通过读取本地的文件，将初始化的数据读取出来，进行学校的选择：
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def cat_school(self):
print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr))
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def information(db, mode):
dict_info = {}
if db:
for key in db:
if mode == \'main\':
key.cat_school()
if not isinstance(key, str):
dict_info[key.name] = key
return dict_info
def school_center():
Flag = True
while Flag:
main_db = file_oper(__db_main, \'rb\')
res_school = information(main_db, \'main\')
school_name = input(\'\033[34;1m选择学校名:\033[0m\')
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
school_center()
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
start()
上面的代码中，School 类中增加了一个cat_school 查看学校属性的方法，最主要的是增加了一个 information 函数，这个函数一定要理解：
我们在初始化时：
sh = School(\'上海\', \'上海市\') bj = School(\'北京\', \'北京市\')
通过pickle读取出来的类型如下：
main_db = {sh: {}, bj: {}}
sh、bj 都是School实例化后的对象，这里就需要通过 information 来做转换
def information(db, mode): dict_info = {} if db: for key in db: if mode == \'main\': key.cat_school() if not isinstance(key, str): dict_info[key.name] = key return dict_info
当我们执行：
information(main_db, \'main\')
1. 首先 key 就是school对象，通过对象.方法查看school类的方法cat_school()
2. if not isinstance(key, str): 当 key 不是字符串类型，这里 key 是实例化后的类型，并不是字符串类型，因此返回的是 {\'北京\':bj, \'上海\':sh}
通过上面的步骤，我们已经可以进行选择学校，来到了学校内部，可以 [\'创建课程\', \'招聘讲师\', \'创建班级\']
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def cat_school(self):
print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr))
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def information(db, mode):
dict_info = {}
if db:
for key in db:
if mode == \'main\':
key.cat_school()
if not isinstance(key, str):
dict_info[key.name] = key
return dict_info
def school_center():
Flag = True
while Flag:
main_db = file_oper(__db_main, \'rb\')
res_school = information(main_db, \'main\')
school_name = input(\'\033[34;1m选择学校名:\033[0m\')
if school_name in res_school:
school = res_school[school_name] # 通过学校名获取到了该学校名的类
while Flag:
choice = options(school_list) # 循环打印学校中心下的功能点
if choice == \'1\': # 创建课程
pass
elif choice == \'2\': # 招聘讲师
pass
elif choice == \'3\': # 创建班级
pass
elif choice == \'4\': # 返回
Flag = False # 退出到主界面
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
school_center()
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
school_list = [\'创建课程\', \'招聘讲师\', \'创建班级\', \'返回\']
start()
上面的代码：
1. 通过用户选择的学校名获取到了带学校名属性的类；
2. 使用Flag = True 循环，当要退出时候，直接可以退出到主界面，这里可以揣摩下，这种用法以后肯定会遇到。
接下来，就需要实现创建课程的功能点。
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def cat_school(self):
print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr))
def create_course(self, main_db, course, main_file):
main_db[self][course] = {}
file_oper(main_file, \'wb\', main_db)
class Course(object):
def __init__(self, name, price, time):
self.name = name
self.price = price
self.time = time
def cat_course(self):
print(\'\033[32;1m课程【%s】\t价格【%s元】\t周期【%s个月】\033[0m\' % (self.name, self.price, self.time))
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def information(db, mode):
dict_info = {}
if db:
for key in db:
if mode == \'main\':
key.cat_school()
elif mode == \'course\':
key.cat_course()
if not isinstance(key, str):
dict_info[key.name] = key
return dict_info
def school_center():
Flag = True
while Flag:
main_db = file_oper(__db_main, \'rb\')
res_school = information(main_db, \'main\')
school_name = input(\'\033[34;1m选择学校名:\033[0m\')
if school_name in res_school:
school = res_school[school_name]
while Flag:
choice = options(school_list)
if choice == \'1\': # 创建课程
while True:
print(\'\033[33;1m目前学校【%s】已经存在的课程信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'course\')
print(type(res_course))
if not res_course:
print(\'\033[31;1m目前没有任何课程信息.\033[0m\')
if_cont = input(\'\033[34;1m是否创建课程[y/b]:\').strip()
if if_cont == \'y\':
course_name = input(\'\033[34;1m输入课程名:\').strip()
if course_name not in res_course:
course_price = input(\'\033[34;1m输入课程价格:\').strip()
course_time = input(\'\033[34;1m输入课程周期:\').strip()
course = Course(course_name, course_price, course_time)
school.create_course(main_db, course, __db_main)
else:
print(\'\033[31;1m该课程名已存在.\033[0m\')
elif if_cont == \'b\':
break
elif choice == \'2\': # 招聘讲师
pass
elif choice == \'3\': # 创建班级
pass
elif choice == \'4\': # 返回
Flag = False
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
school_center()
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
school_list = [\'创建课程\', \'招聘讲师\', \'创建班级\', \'返回\']
start()
1. 首先创建课程类和查看课程的方法；
2. 通过information函数执行查看课程的方法并返回{\'课程名\': 课程类}，当没有课程的时候，一定要返回字典类型，因为后面需要做课程名是否存在的判断；
3. 在school类中添加新增课程的方法，因为通过要求得知，课程是通过学校创建的
4. 首先展示已经存在的课程信息，并得到{\'课程名\': 课程类}，再次通过用户输入得到课程信息，通过用户输入信息实例化课程类，最后将实例化对象写入学校类的方法中
到此，新增课程已经完成。接下来是招聘讲师，其实思路和上面大同小异。
首先，通过上面分析过作者的数据类型：
main_db = {school:{course:{\'讲师名\': 讲师类, \'班级名\': 班级类}}}
当用户输入讲师名的时候，需要判断该讲师是否已经存在，因此我们需要得到 {\'讲师名\': 讲师类}
s1 = set() # 这里需要定义一个set类型，因为无论数据存不存在，后续都需要进行判断 for key in main_db[school][course]: main_db[school][course][key].cat_teacher() # 这样就能执行查看讲师的方法 s1.add(key) return s1
通过上面的伪代码，我们执行了查看讲师的方法，并返回了已经存在讲师的名字。
1. 创建讲师类和查看讲师的方法；
2. 通过information函数执行查看讲师的方法并返回，当没有讲师的时候，一定要返回set()类型，因为后面需要做讲师名是否存在的判断；
3. 在school类中添加招聘讲师的方法；
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def cat_school(self):
print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr))
def create_course(self, main_db, course, main_file):
main_db[self][course] = {}
file_oper(main_file, \'wb\', main_db)
def hire_teacher(self, main_db, course, teacher, main_file):
main_db[self][course] = {\'teacher\': teacher}
file_oper(main_file, \'wb\', main_db)
class Course(object):
def __init__(self, name, price, time):
self.name = name
self.price = price
self.time = time
def cat_course(self):
print(\'\033[32;1m课程【%s】\t价格【%s元】\t周期【%s个月】\033[0m\' % (self.name, self.price, self.time))
class Teacher(object):
def __init__(self, name, age, school, course):
self.name = name
self.age = age
self.school = school
self.course = course
def cat_teacher(self):
print(\'\033[32;1m课程【%s】\t讲师【%s】\033[0m\' % (self.course, self.name))
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def information(db, mode):
set_info = set()
dict_info = {}
if db:
for key in db:
if mode == \'main\':
key.cat_school()
elif mode == \'course\':
key.cat_course()
elif mode == \'teacher\':
db[key].cat_teacher()
set_info.add(key)
if not isinstance(key, str):
dict_info[key.name] = key
return dict_info, set_info
def school_center():
Flag = True
while Flag:
main_db = file_oper(__db_main, \'rb\')
res_school = information(main_db, \'main\')[0]
school_name = input(\'\033[34;1m选择学校名:\033[0m\')
if school_name in res_school:
school = res_school[school_name]
while Flag:
choice = options(school_list)
if choice == \'1\': # 创建课程
while True:
print(\'\033[33;1m目前学校【%s】已经存在的课程信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'course\')[0]
print(type(res_course))
if not res_course:
print(\'\033[31;1m目前没有任何课程信息.\033[0m\')
if_cont = input(\'\033[34;1m是否创建课程[y/b]:\033[0m\').strip()
if if_cont == \'y\':
course_name = input(\'\033[34;1m输入课程名:\').strip()
if course_name not in res_course:
course_price = input(\'\033[34;1m输入课程价格:\').strip()
course_time = input(\'\033[34;1m输入课程周期:\').strip()
course = Course(course_name, course_price, course_time)
school.create_course(main_db, course, __db_main)
else:
print(\'\033[31;1m该课程名已存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'2\': # 招聘讲师
while True:
print(\'\033[33;1m目前学校【%s】已经存在的讲师信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'None\')[0]
if res_course:
for i in res_course:
k = res_course[i]
res_teacher = information(main_db[school][k], \'teacher\')[1]
if not res_teacher:
print(\'\033[31;1m课程【%s】\t讲师【None】\033[0m\' % k.name)
if_cont = input(\'\033[34;1m是否招聘讲师[y/b]:\033[0m\').strip()
if if_cont == \'y\':
teacher_name = input(\'\033[34;1m输入讲师名:\').strip()
teacher_age = input(\'\033[34;1m输入讲师年龄:\').strip()
course_name = input(\'\033[34;1m输入课程名:\').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(main_db, course, teacher, __db_main)
else:
print(\'\033[31;1m该讲师名已存在.\033[0m\')
else:
print(\'\033[31;1m该课程名不存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'3\': # 创建班级
pass
elif choice == \'4\': # 返回
Flag = False
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
school_center()
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
school_list = [\'创建课程\', \'招聘讲师\', \'创建班级\', \'返回\']
start()
创建班级功能，和招聘讲师实现思路完全一致。
1. 创建班级类和查看班级的方法；
2. 通过information函数执行查看班级的方法并返回，当没有班级的时候，一定要返回set()类型，因为后面需要做班级名是否存在的判断；
3. 在school类中添加班级的方法；
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def cat_school(self):
print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr))
def create_course(self, main_db, course, main_file):
main_db[self][course] = {}
file_oper(main_file, \'wb\', main_db)
def hire_teacher(self, main_db, course, teacher, main_file):
main_db[self][course] = {\'teacher\': teacher}
file_oper(main_file, \'wb\', main_db)
def create_grade(self, main_db, teacher_db, course, grade, teacher, main_file, teacher_file):
main_db[self][course][\'grade\'] = grade
file_oper(main_file, \'wb\', main_db)
teacher_db[teacher] = {\'grade\': grade}
file_oper(teacher_file, \'wb\', teacher_db)
class Course(object):
def __init__(self, name, price, time):
self.name = name
self.price = price
self.time = time
def cat_course(self):
print(\'\033[32;1m课程【%s】\t价格【%s元】\t周期【%s个月】\033[0m\' % (self.name, self.price, self.time))
class Teacher(object):
def __init__(self, name, age, school, course):
self.name = name
self.age = age
self.school = school
self.course = course
def cat_teacher(self):
print(\'\033[32;1m课程【%s】\t讲师【%s】\033[0m\' % (self.course, self.name))
class Grade(object):
def __init__(self, name, course, teacher):
self.name = name
self.course = course
self.teacher = teacher
def cat_grade(self):
print(\'\033[32;1m课程【%s】\t班级【%s】\033[0m\' % (self.course, self.name))
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def information(db, mode):
set_info = set()
dict_info = {}
if db:
for key in db:
if mode == \'main\':
key.cat_school()
elif mode == \'course\':
key.cat_course()
elif mode == \'teacher\' and key == \'teacher\':
db[key].cat_teacher()
set_info.add(key)
elif mode == \'grade\' and key == \'grade\':
db[key].cat_grade()
set_info.add(key)
if not isinstance(key, str):
dict_info[key.name] = key
return dict_info, set_info
def school_center():
Flag = True
while Flag:
main_db = file_oper(__db_main, \'rb\')
res_school = information(main_db, \'main\')[0]
school_name = input(\'\033[34;1m选择学校名:\033[0m\')
if school_name in res_school:
school = res_school[school_name]
while Flag:
choice = options(school_list)
if choice == \'1\': # 创建课程
while True:
print(\'\033[33;1m目前学校【%s】已经存在的课程信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'course\')[0]
print(type(res_course))
if not res_course:
print(\'\033[31;1m目前没有任何课程信息.\033[0m\')
if_cont = input(\'\033[34;1m是否创建课程[y/b]:\033[0m\').strip()
if if_cont == \'y\':
course_name = input(\'\033[34;1m输入课程名:\').strip()
if course_name not in res_course:
course_price = input(\'\033[34;1m输入课程价格:\').strip()
course_time = input(\'\033[34;1m输入课程周期:\').strip()
course = Course(course_name, course_price, course_time)
school.create_course(main_db, course, __db_main)
else:
print(\'\033[31;1m该课程名已存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'2\': # 招聘讲师
while True:
print(\'\033[33;1m目前学校【%s】已经存在的讲师信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'None\')[0]
if res_course:
for i in res_course:
k = res_course[i]
res_teacher = information(main_db[school][k], \'teacher\')[1]
print(main_db)
if not res_teacher:
print(\'\033[31;1m课程【%s】\t讲师【None】\033[0m\' % k.name)
if_cont = input(\'\033[34;1m是否招聘讲师[y/b]:\033[0m\').strip()
if if_cont == \'y\':
teacher_name = input(\'\033[34;1m输入讲师名:\').strip()
teacher_age = input(\'\033[34;1m输入讲师年龄:\').strip()
course_name = input(\'\033[34;1m输入课程名:\').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(main_db, course, teacher, __db_main)
else:
print(\'\033[31;1m该讲师名已存在.\033[0m\')
else:
print(\'\033[31;1m该课程名不存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'3\': # 创建班级
while True:
teacher_db = file_oper(__db_teacher, \'rb\')
print(\'\033[33;1m目前学校【%s】已经存在的班级信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'None\')[0]
if res_course:
for i in res_course:
k = res_course[i]
print(\'k:\', k)
print(main_db[school][k])
print(\'--------------------------\')
res_grade = information(main_db[school][k], \'grade\')[1]
if not res_grade:
print(\'\033[31;1m目前没有任何班级信息.\033[0m\')
else:
print(\'\033[31;1m目前没有任何课程信息, 请先创建课程.\033[0m\')
if_cont = input(\'\033[34;1m是否创建班级[y/b]:\033[0m\').strip()
if if_cont == \'y\':
grade_name = input(\'\033[34;1m输入班级名:\033[0m\').strip()
course_name = input(\'\033[34;1m输入班级要上的课程:\033[0m\').strip()
if course_name in res_course:
course = res_course[course_name]
if main_db[school][course]:
teacher = main_db[school][course][\'teacher\']
if grade_name not in res_grade:
grade = Grade(grade_name, course_name, teacher.name)
print(\'grade:\', grade)
school.create_grade(main_db, teacher_db, course, grade, teacher,
__db_main, __db_teacher)
else:
print(\'\033[31;1m讲师不存在，请先招聘讲师.\033[0m\')
else:
print(\'\033[31;1m课程名不存在，请重新输入.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'4\': # 返回
Flag = False
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
school_center()
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
school_list = [\'创建课程\', \'招聘讲师\', \'创建班级\', \'返回\']
start()
招聘讲师和创建班级思路是一样的，只是多了下面的步骤：
1. 班级类包含：班级、课程、讲师 信息
2. 这里就引入了第二个存储文件 __db_teacher 一定要知道数据类型的存储格式：
{讲师类:{\'班级名\':班级类}}
3. 必须取得讲师类才能进行第2步的操作
获取讲师信息
res_course = information(main_db[school], \'None\')[0] if res_course: for i in res_course: k = res_course[i] # 这里就拿到了课程类 res_grade = information(main_db[school][k], \'grade\')[1] # 这里就可以拿到已经存在或者为空的班级信息
当该班级的课程名被接收后
course_name = input(\'\033[34;1m输入班级要上的课程:\033[0m\').strip() if course_name in res_course: course = res_course[course_name] if main_db[school][course]: teacher = main_db[school][course][\'teacher\']
上面的代码就能拿到讲师类，数据结构定义下来，代码就很好写了。
到目前为止，根据要求，学校中心的所有功能都已经实现了。
学校中心功能所有代码：
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def cat_school(self):
print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr))
def create_course(self, main_db, course, main_file):
main_db[self][course] = {}
file_oper(main_file, \'wb\', main_db)
def hire_teacher(self, main_db, course, teacher, main_file):
main_db[self][course] = {\'teacher\': teacher}
file_oper(main_file, \'wb\', main_db)
def create_grade(self, main_db, teacher_db, course, grade, teacher, main_file, teacher_file):
main_db[self][course][\'grade\'] = grade
file_oper(main_file, \'wb\', main_db)
teacher_db[teacher] = {\'grade\': grade}
file_oper(teacher_file, \'wb\', teacher_db)
class Course(object):
def __init__(self, name, price, time):
self.name = name
self.price = price
self.time = time
def cat_course(self):
print(\'\033[32;1m课程【%s】\t价格【%s元】\t周期【%s个月】\033[0m\' % (self.name, self.price, self.time))
class Teacher(object):
def __init__(self, name, age, school, course):
self.name = name
self.age = age
self.school = school
self.course = course
def cat_teacher(self):
print(\'\033[32;1m课程【%s】\t讲师【%s】\033[0m\' % (self.course, self.name))
class Grade(object):
def __init__(self, name, course, teacher):
self.name = name
self.course = course
self.teacher = teacher
def cat_grade(self):
print(\'\033[32;1m课程【%s】\t班级【%s】\033[0m\' % (self.course, self.name))
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def information(db, mode):
set_info = set()
dict_info = {}
if db:
for key in db:
if mode == \'main\':
key.cat_school()
elif mode == \'course\':
key.cat_course()
elif mode == \'teacher\' and key == \'teacher\':
db[key].cat_teacher()
set_info.add(key)
elif mode == \'grade\' and key == \'grade\':
db[key].cat_grade()
set_info.add(key)
if not isinstance(key, str):
dict_info[key.name] = key
return dict_info, set_info
def school_center():
Flag = True
while Flag:
main_db = file_oper(__db_main, \'rb\')
res_school = information(main_db, \'main\')[0]
school_name = input(\'\033[34;1m选择学校名:\033[0m\')
if school_name in res_school:
school = res_school[school_name]
while Flag:
choice = options(school_list)
if choice == \'1\': # 创建课程
while True:
print(\'\033[33;1m目前学校【%s】已经存在的课程信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'course\')[0]
print(type(res_course))
if not res_course:
print(\'\033[31;1m目前没有任何课程信息.\033[0m\')
if_cont = input(\'\033[34;1m是否创建课程[y/b]:\033[0m\').strip()
if if_cont == \'y\':
course_name = input(\'\033[34;1m输入课程名:\').strip()
if course_name not in res_course:
course_price = input(\'\033[34;1m输入课程价格:\').strip()
course_time = input(\'\033[34;1m输入课程周期:\').strip()
course = Course(course_name, course_price, course_time)
school.create_course(main_db, course, __db_main)
else:
print(\'\033[31;1m该课程名已存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'2\': # 招聘讲师
while True:
print(\'\033[33;1m目前学校【%s】已经存在的讲师信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'None\')[0]
if res_course:
for i in res_course:
k = res_course[i]
res_teacher = information(main_db[school][k], \'teacher\')[1]
print(main_db)
if not res_teacher:
print(\'\033[31;1m课程【%s】\t讲师【None】\033[0m\' % k.name)
if_cont = input(\'\033[34;1m是否招聘讲师[y/b]:\033[0m\').strip()
if if_cont == \'y\':
teacher_name = input(\'\033[34;1m输入讲师名:\').strip()
teacher_age = input(\'\033[34;1m输入讲师年龄:\').strip()
course_name = input(\'\033[34;1m输入课程名:\').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(main_db, course, teacher, __db_main)
else:
print(\'\033[31;1m该讲师名已存在.\033[0m\')
else:
print(\'\033[31;1m该课程名不存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'3\': # 创建班级
while True:
teacher_db = file_oper(__db_teacher, \'rb\')
print(\'\033[33;1m目前学校【%s】已经存在的班级信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'None\')[0]
if res_course:
for i in res_course:
k = res_course[i]
print(\'k:\', k)
print(main_db[school][k])
print(\'--------------------------\')
res_grade = information(main_db[school][k], \'grade\')[1]
if not res_grade:
print(\'\033[31;1m目前没有任何班级信息.\033[0m\')
else:
print(\'\033[31;1m目前没有任何课程信息, 请先创建课程.\033[0m\')
if_cont = input(\'\033[34;1m是否创建班级[y/b]:\033[0m\').strip()
if if_cont == \'y\':
grade_name = input(\'\033[34;1m输入班级名:\033[0m\').strip()
course_name = input(\'\033[34;1m输入班级要上的课程:\033[0m\').strip()
if course_name in res_course:
course = res_course[course_name]
if main_db[school][course]:
teacher = main_db[school][course][\'teacher\']
if grade_name not in res_grade:
grade = Grade(grade_name, course_name, teacher.name)
print(\'grade:\', grade)
school.create_grade(main_db, teacher_db, course, grade, teacher,
__db_main, __db_teacher)
else:
print(\'\033[31;1m讲师不存在，请先招聘讲师.\033[0m\')
else:
print(\'\033[31;1m课程名不存在，请重新输入.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'4\': # 返回
Flag = False
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
school_center()
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
school_list = [\'创建课程\', \'招聘讲师\', \'创建班级\', \'返回\']
start()
学生中心
功能点：学员注册，返回
学员注册这里，是使用了一个Grade类中的student属性来保存的。
self.student = set([]) # 该属性是一个set集合
在Grade类中实现一个新增学员的方法：
def add_student(self, teacher_db, teacher, student_name, teacher_file): self.student.add(student_name) # 将学员名添加到 self.student属性中 teacher_db[teacher] = {\'grade\': self} # 重新给讲师赋值，所以这里必须要拿到讲师类 file_oper(teacher_file, \'wb\', teacher_db) # 写入文件
以上的操作，就能添加一个新的学员到班级。
新增学员的操作流程：
输入用户名 --> 选择已有学校 --> 选择已有课程 --> 写入文件
import os, pickle
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
__db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件
__db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件
class School(object):
\'\'\'学校类\'\'\'
def __init__(self, name, addr):
self.name = name
self.addr = addr
def cat_school(self):
print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr))
def create_course(self, main_db, course, main_file):
main_db[self][course] = {}
file_oper(main_file, \'wb\', main_db)
def hire_teacher(self, main_db, course, teacher, main_file):
main_db[self][course] = {\'teacher\': teacher}
file_oper(main_file, \'wb\', main_db)
def create_grade(self, main_db, teacher_db, course, grade, teacher, main_file, teacher_file):
main_db[self][course][\'grade\'] = grade
file_oper(main_file, \'wb\', main_db)
teacher_db[teacher] = {\'grade\': grade}
file_oper(teacher_file, \'wb\', teacher_db)
class Course(object):
def __init__(self, name, price, time):
self.name = name
self.price = price
self.time = time
def cat_course(self):
print(\'\033[32;1m课程【%s】\t价格【%s元】\t周期【%s个月】\033[0m\' % (self.name, self.price, self.time))
class Teacher(object):
def __init__(self, name, age, school, course):
self.name = name
self.age = age
self.school = school
self.course = course
def cat_teacher(self):
print(\'\033[32;1m课程【%s】\t讲师【%s】\033[0m\' % (self.course, self.name))
class Grade(object):
def __init__(self, name, course, teacher):
self.name = name
self.course = course
self.teacher = teacher
self.student = set([])
def cat_grade(self):
print(\'\033[32;1m课程【%s】\t班级【%s】\033[0m\' % (self.course, self.name))
def add_student(self, teacher_db, teacher, student_name, teacher_file):
self.student.add(student_name)
teacher_db[teacher] = {\'grade\': self}
file_oper(teacher_file, \'wb\', teacher_db)
def options(li):
\'\'\'序号和标题循环打印，返回选择序号\'\'\'
for i, k in enumerate(li):
print(i + 1, k)
choice = input(\'>>>\').strip()
return choice
def information(db, mode):
set_info = set()
dict_info = {}
if db:
for key in db:
if mode == \'main\':
key.cat_school()
elif mode == \'course\':
key.cat_course()
elif mode == \'teacher\' and key == \'teacher\':
db[key].cat_teacher()
set_info.add(key)
elif mode == \'grade\' and key == \'grade\':
db[key].cat_grade()
set_info.add(key)
if not isinstance(key, str):
dict_info[key.name] = key
return dict_info, set_info
def school_center():
Flag = True
while Flag:
main_db = file_oper(__db_main, \'rb\')
res_school = information(main_db, \'main\')[0]
school_name = input(\'\033[34;1m选择学校名:\033[0m\')
if school_name in res_school:
school = res_school[school_name]
while Flag:
choice = options(school_list)
if choice == \'1\': # 创建课程
while True:
print(\'\033[33;1m目前学校【%s】已经存在的课程信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'course\')[0]
print(type(res_course))
if not res_course:
print(\'\033[31;1m目前没有任何课程信息.\033[0m\')
if_cont = input(\'\033[34;1m是否创建课程[y/b]:\033[0m\').strip()
if if_cont == \'y\':
course_name = input(\'\033[34;1m输入课程名:\').strip()
if course_name not in res_course:
course_price = input(\'\033[34;1m输入课程价格:\').strip()
course_time = input(\'\033[34;1m输入课程周期:\').strip()
course = Course(course_name, course_price, course_time)
school.create_course(main_db, course, __db_main)
else:
print(\'\033[31;1m该课程名已存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'2\': # 招聘讲师
while True:
print(\'\033[33;1m目前学校【%s】已经存在的讲师信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'None\')[0]
if res_course:
for i in res_course:
k = res_course[i]
res_teacher = information(main_db[school][k], \'teacher\')[1]
print(main_db)
if not res_teacher:
print(\'\033[31;1m课程【%s】\t讲师【None】\033[0m\' % k.name)
if_cont = input(\'\033[34;1m是否招聘讲师[y/b]:\033[0m\').strip()
if if_cont == \'y\':
teacher_name = input(\'\033[34;1m输入讲师名:\').strip()
teacher_age = input(\'\033[34;1m输入讲师年龄:\').strip()
course_name = input(\'\033[34;1m输入课程名:\').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(main_db, course, teacher, __db_main)
else:
print(\'\033[31;1m该讲师名已存在.\033[0m\')
else:
print(\'\033[31;1m该课程名不存在.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'3\': # 创建班级
while True:
teacher_db = file_oper(__db_teacher, \'rb\')
print(\'\033[33;1m目前学校【%s】已经存在的班级信息:\033[0m\' % school_name)
res_course = information(main_db[school], \'None\')[0]
if res_course:
for i in res_course:
k = res_course[i]
print(\'k:\', k)
print(main_db[school][k])
print(\'--------------------------\')
res_grade = information(main_db[school][k], \'grade\')[1]
if not res_grade:
print(\'\033[31;1m目前没有任何班级信息.\033[0m\')
else:
print(\'\033[31;1m目前没有任何课程信息, 请先创建课程.\033[0m\')
if_cont = input(\'\033[34;1m是否创建班级[y/b]:\033[0m\').strip()
if if_cont == \'y\':
grade_name = input(\'\033[34;1m输入班级名:\033[0m\').strip()
course_name = input(\'\033[34;1m输入班级要上的课程:\033[0m\').strip()
if course_name in res_course:
course = res_course[course_name]
if main_db[school][course]:
teacher = main_db[school][course][\'teacher\']
if grade_name not in res_grade:
grade = Grade(grade_name, course_name, teacher.name)
print(\'grade:\', grade)
school.create_grade(main_db, teacher_db, course, grade, teacher,
__db_main, __db_teacher)
else:
print(\'\033[31;1m讲师不存在，请先招聘讲师.\033[0m\')
else:
print(\'\033[31;1m课程名不存在，请重新输入.\033[0m\')
elif if_cont == \'b\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
elif choice == \'4\': # 返回
Flag = False
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
def student_center():
while True:
choice = options(student_list)
main_db = file_oper(__db_main, \'rb\')
teacher_db = file_oper(__db_teacher, \'rb\')
if choice == \'1\':
student_name = input(\'\033[34;1m输入学生名:\033[0m\').strip()
res_school = information(main_db, \'main\')[0]
school_name = input(\'\033[34;1m输入学校名:\033[0m\').strip()
if school_name in res_school:
school = res_school[school_name]
res_course = information(main_db[school], \'course\')[0]
course_name = input(\'\033[34;1m输入课程名:\033[0m\').strip()
if course_name in res_course:
course = res_course[course_name]
if main_db[school][course].get(\'grade\'):
for i in teacher_db:
i.name = course.name
teacher = i
grade = teacher_db[teacher].get(\'grade\')
print(\'\033[33;1m课程【%s】的费用为【%s元】\033[0m\' % (course_name, course.price))
if_pay = input(\'\033[34;1m是否支付当前费用(y支付):\033[0m\').strip()
if if_pay == \'y\':
grade.student.add(student_name)
grade.add_student(teacher_db, teacher, student_name, __db_teacher)
print(\'\033[32;1m选课成功！\033[0m\')
any = input(\'输入任意键退出当前:\')
else:
print(\'\033[31;1m讲师不存在，请先招聘讲师.\033[0m\')
else:
print(\'\033[31;1m课程不存在，请重新选择.\033[0m\')
else:
print(\'\033[31;1m学校不存在，请重新选择.\033[0m\')
elif choice == \'2\':
break
else:
print(\'\033[31;1m输入错误，请重新输入.\033[0m\')
def start():
\'\'\'开始程序，根据选择的序号进入不同的视图\'\'\'
while True:
choice = options(main_list)
if not choice: continue
if choice == \'1\':
print(\'\033[33;1m【学校中心】\033[0m\')
school_center()
elif choice == \'2\':
print(\'\033[33;1m【讲师中心】\033[0m\')
elif choice == \'3\':
print(\'\033[33;1m【学生中心】\033[0m\')
student_center()
elif choice == \'4\':
print(\'退出\')
break
def file_oper(file, mode, *args):
\'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\'
if mode == \'wb\':
data = args[0]
with open(file, mode) as f:
pickle.dump(data, f)
elif mode == \'rb\':
with open(file, mode) as f:
data = pickle.load(f)
return data
def init_database():
\'\'\'初始化学校信息\'\'\'
sh = School(\'上海\', \'上海市\')
bj = School(\'北京\', \'北京市\')
if not os.path.exists(__db_main):
data = {sh: {}, bj: {}}
file_oper(__db_main, \'wb\', data)
if not os.path.exists(__db_teacher):
data = {}
file_oper(__db_teacher, \'wb\', data)
if __name__ == \'__main__\':
init_database()
main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\']
school_list = [\'创建课程\', \'招聘讲师\', \'创建班级\', \'返回\']
student_list = [\'学员注册\', \'返回\']
start()
上面代码的难点在通过讲师把两个字典联系起来取值：
main_db = {学校类:{课程类:{\'讲师名\': 讲师类, \'班级名\': 班级类}}}
teacher_db = {讲师类:{\'班级名\': 班级类}}
if main_db[school][course].get(\'grade\'): # 使用get判断班级是否存在，不存在返回None不会报错
for i in teacher_db: # 这里循环取讲师类
i.course = course.name # 当teacher_db中讲师类课程的名字和main_db中课程的名字一致时，讲师和课程就关联起来了
teacher = i # 直接获取讲师类
上面这里是整篇代码最难理解地方，需要从全面代码数据结构去理解。
简单来说，通过学员选择的课程确定课程类，在从课程类确定讲师类，就是这样的关联关系。
目前，学校中心和学员中心都已经实现了，学校中心和学员中心都有查询和写入的操作，所以提前完成，接下就是讲师中心，只有查询的功能
讲师中心
功能点：查看班级信息，查看学员列表信息
实现思路：
每个讲师都有自己的班级信息和学员列表，因此在实现功能点之前需要进行确认讲师身份
查看班级信息中需要：学校和班级
学员列表是保存在Grade类student属性中
import os, pickle BASE_DIR = os.path.dirname(os.path.abspath(__file__)) __db_main = os.path.join(BASE_DIR, \'main_dict\') # 学校内容文件 __db_teacher = os.path.join(BASE_DIR, \'teacher_dict\') # 讲师课程内容文件 class School(object): \'\'\'学校类\'\'\' def __init__(self, name, addr): self.name = name self.addr = addr def cat_school(self): print(\'\033[32;1m学校【%s】\t地址【%s】\033[0m\' % (self.name, self.addr)) def create_course(self, main_db, course, main_file): main_db[self][course] = {} file_oper(main_file, \'wb\', main_db) def hire_teacher(self, main_db, course, teacher, main_file): main_db[self][course] = {\'teacher\': teacher} file_oper(main_file, \'wb\', main_db) def create_grade(self, main_db, teacher_db, course, grade, teacher, main_file, teacher_file): main_db[self][course][\'grade\'] = grade file_oper(main_file, \'wb\', main_db) teacher_db[teacher] = {\'grade\': grade} file_oper(teacher_file, \'wb\', teacher_db) class Course(object): def __init__(self, name, price, time): self.name = name self.price = price self.time = time def cat_course(self): print(\'\033[32;1m课程【%s】\t价格【%s元】\t周期【%s个月】\033[0m\' % (self.name, self.price, self.time)) class Teacher(object): def __init__(self, name, age, school, course): self.name = name self.age = age self.school = school self.course = course def cat_teacher(self): print(\'\033[32;1m课程【%s】\t讲师【%s】\033[0m\' % (self.course, self.name)) class Grade(object): def __init__(self, name, course, teacher): self.name = name self.course = course self.teacher = teacher self.student = set([]) def cat_grade(self): print(\'\033[32;1m课程【%s】\t班级【%s】\033[0m\' % (self.course, self.name)) def add_student(self, teacher_db, teacher, student_name, teacher_file): self.student.add(student_name) teacher_db[teacher] = {\'grade\': self} file_oper(teacher_file, \'wb\', teacher_db) def options(li): \'\'\'序号和标题循环打印，返回选择序号\'\'\' for i, k in enumerate(li): print(i + 1, k) choice = input(\'>>>\').strip() return choice def information(db, mode): set_info = set() dict_info = {} if db: for key in db: if mode == \'main\': key.cat_school() elif mode == \'course\': key.cat_course() elif mode == \'teacher\' and key == \'teacher\': db[key].cat_teacher() set_info.add(key) elif mode == \'grade\' and key == \'grade\': db[key].cat_grade() set_info.add(key) if not isinstance(key, str): dict_info[key.name] = key return dict_info, set_info def school_center(): Flag = True while Flag: main_db = file_oper(__db_main, \'rb\') res_school = information(main_db, \'main\')[0] school_name = input(\'\033[34;1m选择学校名:\033[0m\') if school_name in res_school: school = res_school[school_name] while Flag: choice = options(school_list) if choice == \'1\': # 创建课程 while True: print(\'\033[33;1m目前学校【%s】已经存在的课程信息:\033[0m\' % school_name) res_course = information(main_db[school], \'course\')[0] print(type(res_course)) if not res_course: print(\'\033[31;1m目前没有任何课程信息.\033[0m\') if_cont = input(\'\033[34;1m是否创建课程[y/b]:\033[0m\').strip() if if_cont == \'y\': course_name = input(\'\033[34;1m输入课程名:\').strip() if course_name not in res_course: course_price = input(\'\033[34;1m输入课程价格:\').strip() course_time = input(\'\033[34;1m输入课程周期:\').strip() course = Course(course_name, course_price, course_time) school.create_course(main_db, course, __db_main) else: print(\'\033[31;1m该课程名已存在.\033[0m\') elif if_cont == \'b\': break else: print(\'\033[31;1m输入错误，请重新输入.\033[0m\') elif choice == \'2\': # 招聘讲师 while True: print(\'\033[33;1m目前学校【%s】已经存在的讲师信息:\033[0m\' % school_name) res_course = information(main_db[school], \'None\')[0] if res_course: for i in res_course: k = res_course[i] res_teacher = information(main_db[school][k], \'teacher\')[1] print(main_db) if not res_teacher: print(\'\033[31;1m课程【%s】\t讲师【None】\033[0m\' % k.name) if_cont = input(\'\033[34;1m是否招聘讲师[y/b]:\033[0m\').strip() if if_cont == \'y\': teacher_name = input(\'\033[34;1m输入讲师名:\').strip() teacher_age = input(\'\033[34;1m输入讲师年龄:\').strip() course_name = input(\'\033[34;1m输入课程名:\').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(main_db, course, teacher, __db_main) else: print(\'\033[31;1m该讲师名已存在.\033[0m\') else: print(\'\033[31;1m该课程名不存在.\033[0m\') elif if_cont == \'b\': break else: print(\'\033[31;1m输入错误，请重新输入.\033[0m\') elif choice == \'3\': # 创建班级 while True: teacher_db = file_oper(__db_teacher, \'rb\') print(\'\033[33;1m目前学校【%s】已经存在的班级信息:\033[0m\' % school_name) res_course = information(main_db[school], \'None\')[0] if res_course: for i in res_course: k = res_course[i] print(\'k:\', k) print(main_db[school][k]) print(\'--------------------------\') res_grade = information(main_db[school][k], \'grade\')[1] if not res_grade: print(\'\033[31;1m目前没有任何班级信息.\033[0m\') else: print(\'\033[31;1m目前没有任何课程信息, 请先创建课程.\033[0m\') if_cont = input(\'\033[34;1m是否创建班级[y/b]:\033[0m\').strip() if if_cont == \'y\': grade_name = input(\'\033[34;1m输入班级名:\033[0m\').strip() course_name = input(\'\033[34;1m输入班级要上的课程:\033[0m\').strip() if course_name in res_course: course = res_course[course_name] if main_db[school][course]: teacher = main_db[school][course][\'teacher\'] if grade_name not in res_grade: grade = Grade(grade_name, course_name, teacher.name) print(\'grade:\', grade) school.create_grade(main_db, teacher_db, course, grade, teacher, __db_main, __db_teacher) else: print(\'\033[31;1m讲师不存在，请先招聘讲师.\033[0m\') else: print(\'\033[31;1m课程名不存在，请重新输入.\033[0m\') elif if_cont == \'b\': break else: print(\'\033[31;1m输入错误，请重新输入.\033[0m\') elif choice == \'4\': # 返回 Flag = False else: print(\'\033[31;1m输入错误，请重新输入.\033[0m\') def student_center(): while True: choice = options(student_list) main_db = file_oper(__db_main, \'rb\') teacher_db = file_oper(__db_teacher, \'rb\') if choice == \'1\': student_name = input(\'\033[34;1m输入学生名:\033[0m\').strip() res_school = information(main_db, \'main\')[0] school_name = input(\'\033[34;1m输入学校名:\033[0m\').strip() if school_name in res_school: school = res_school[school_name] res_course = information(main_db[school], \'course\')[0] course_name = input(\'\033[34;1m输入课程名:\033[0m\').strip() if course_name in res_course: course = res_course[course_name] if main_db[school][course].get(\'grade\'): for i in teacher_db: i.course = course.name teacher = i grade = teacher_db[teacher].get(\'grade\') print(\'\033[33;1m课程【%s】的费用为【%s元】\033[0m\' % (course_name, course.price)) if_pay = input(\'\033[34;1m是否支付当前费用(y支付):\033[0m\').strip() if if_pay == \'y\': grade.student.add(student_name) grade.add_student(teacher_db, teacher, student_name, __db_teacher) print(\'\033[32;1m选课成功！\033[0m\') any = input(\'输入任意键退出当前:\') else: print(\'\033[31;1m讲师不存在，请先招聘讲师.\033[0m\') else: print(\'\033[31;1m课程不存在，请重新选择.\033[0m\') else: print(\'\033[31;1m学校不存在，请重新选择.\033[0m\') elif choice == \'2\': break else: print(\'\033[31;1m输入错误，请重新输入.\033[0m\') def teacher_center(): teacher_db = file_oper(__db_teacher, \'rb\') teacher_name = input(\'\033[34;1m输入讲师名:\033[0m\').strip() res_teacher = information(teacher_db, \'None\')[0] if res_teacher: if teacher_name in res_teacher: teacher = res_teacher[teacher_name] grade = teacher_db[teacher].get(\'grade\') print(\'\033[33;1m欢迎进入讲师【%s】的管理中心\033[0m\' % teacher_name) while True: choice = options(teacher_list) if choice == \'1\': print(\'\033[32;1m学校【%s】\t班级【%s】\033[0m\' % (teacher.school, grade.name)) any = input(\'输入任意键退出当前:\') elif choice == \'2\': print(\'\033[32;1m班级【%s】\t学员【%s】\033[0m\' % (grade.name, grade.student)) any = input(\'输入任意键退出当前:\') elif choice == \'3\': break else: print(\'\033[31;1m输入错误，请重新输入.\033[0m\') else: print(\'\033[31;1m讲师信息不存在，请重新输入.\033[0m\') def start(): \'\'\'开始程序，根据选择的序号进入不同的视图\'\'\' while True: choice = options(main_list) if not choice: continue if choice == \'1\': print(\'\033[33;1m【学校中心】\033[0m\') school_center() elif choice == \'2\': print(\'\033[33;1m【讲师中心】\033[0m\') teacher_center() elif choice == \'3\': print(\'\033[33;1m【学生中心】\033[0m\') student_center() elif choice == \'4\': print(\'退出\') break def file_oper(file, mode, *args): \'\'\'根据文件的读或者写，做不同的操作，读返回文件内容信息\'\'\' if mode == \'wb\': data = args[0] with open(file, mode) as f: pickle.dump(data, f) elif mode == \'rb\': with open(file, mode) as f: data = pickle.load(f) return data def init_database(): \'\'\'初始化学校信息\'\'\' sh = School(\'上海\', \'上海市\') bj = School(\'北京\', \'北京市\') if not os.path.exists(__db_main): data = {sh: {}, bj: {}} file_oper(__db_main, \'wb\', data) if not os.path.exists(__db_teacher): data = {} file_oper(__db_teacher, \'wb\', data) if __name__ == \'__main__\': init_database() main_list = [\'学校中心\', \'讲师中心\', \'学生中心\', \'退出\'] school_list = [\'创建课程\', \'招聘讲师\', \'创建班级\', \'返回\'] student_list = [\'学员注册\', \'返回\'] teacher_list = [\'查看班级信息\', \'查看学员列表信息\', \'返回\'] start()
以上代码实现了讲师中心的两个查询功能，流程：
1. 认证讲师名信息
2. 通过讲师名获取讲师类，通过讲师类得到班级类
到此，程序代码完成，需要注意的是，在学员注册的时候，为 Grade类新增了student属性，需要删除本地 main_dict, teacher_dict 再次执行，否则报错。
总结：
成长就是一个不断模仿和学习的过程，对于刚学习python，拿到需求，首先要经过自己分析，确实搞不定了，可以查看一些优秀的代码过来学习总结，
从而转化为自己的能力。对于写程序，实现逻辑思路是很重要的。