Python开发【项目】：选课系统

程序名称: 选课系统

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

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

开始搞：

写程序的第一步就会遇到问题，因为alex给出的要求确实太乱了，这么多关联关系根本理不清，首先先把要求换成自己能懂得话，把逻辑关系重新屡一下

先来个框架：

　　三个视图：学员视图 讲师视图 管理视图  三个视图即为三个管理接口

　　五个角色：学校、学员、课程、讲师、班级　　五个角色即需要定义5个类

把要求对应成自己看懂的话：

　　① 创建北京、上海 2 所学校　　　 分析：定义学校类，通过类去创建学校实例
　　② 创建linux , python , go 3个课程 ，linux\py 在北京开，go 在上海开　　分析：定义课程类，通过课程类去创建课程实例

　  ③ 课程包含，周期，价格，通过学校创建课程 　　分析：课程类里要包含周期、价格  课程实例通过学校类去创建

　　④ 班级关联课程、班级关联讲师　　分析：可以创建班级的时候需输入关联的课程，创建讲师的时候需输入关联的班级；一个班级对应一个课程 一个班级对应一个讲师

　　⑤ 通过学校创建班级， 班级关联课程、讲师   分析：跟④一样

　　⑥ 创建学员时，选择学校，关联班级　　分析：定义学员类，创建时选择学校，选择班级，通过学校类创建学员实例，班级类里面要有包含学员的信息的字典

　　⑦ 创建讲师角色时要关联学校　　分析：之前一样，依然通过学校类去创建讲师实例

　　⑧ 学员视图 可以注册， 交学费， 选择班级  　　分析：看⑥ 学员选择班级后，通过班级关联的课程，打印课程的学费

　　⑨ 讲师视图， 讲师可以.....bala....bala    　　分析：讲师视图登录需要讲师名，通过讲师名可以找到对应的班级实例，班级实例里包含班级名，课程名，学员信息等

　　注：一个班级对应一个课程 一个班级对应一个讲师

　　　　一个课程可有多个班级

　　　　一个讲师可教授多个班级

　　　　一个学员可学习多个班级的课

分析下管理视图：

　　　　　　　　管理视图具有的功能创建讲师， 创建班级，创建课程，这些都是通过学校创建（即通过学校类的方法调用），除了创建以外我们还需要增加查询讲师、班级、课程的功能（查看相应的信息），管理视图要有6个功能

分析下讲师视图：

　　　　　　　 讲师视图可查看所授课的班级，班级学生信息  讲师视图具有2个功能

分析下学生视图：

　　　　　　　学生视图，要选择学校，选择班级（显示班级的名称，课程，价钱），添加到对应的班级内

咋做数据库呢？！

　　　　　　　 看看注里面的内容就知道对应关系比较多，对应关系比较多就意味着，一个数据改了所有跟它有关系的数据都有变动，比如班级s14关联讲师alex，学生eric报名后，讲师alex自己的班级学生信息里就要能查到eric的个人信息；当然如果用数据库去做的话，非常简单；but 咱还没学数据库呢，只能用文件的方式存在本地，如果存多个文件的话，一个文件修改另一个文件也跟着修改（互相关联），所以为了简便，就只定义一个伪数据库；通过shelve模块，存储类型{“北京”：北京实例，“上海”：上海实例}

看我怎么做的类定义（只看__init__）：

内容最小的学员类：只包含姓名，年龄，可扩展其他信息，关联信息不再这存

1 2 3 4 5

class  Student( object ):      '''学生类，包含姓名，年龄'''      def  __init__( self ,student_name,student_age):          self .student_name  =  student_name          self .student_age  =  student_age

都跟它有关系，但是他是被关系的课程类：只包含周期，价格，名称，可扩展其他信息，被关联，啥关联信息都不用存

1 2 3 4 5 6

class  Course():      '''定义课程类，包含名称，价格，周期'''      def  __init__( self ,course_name,course_price,course_time):          self .course_name  =  course_name          self .course_price  =  course_price          self .course_time  =  course_time

跟三个都有关系，还一一对应（课程、讲师）的班级类：看④⑥  包含班级名，课程对应课程类（对应关系在本类里保存），班级学生成员字典，存放学生类，与讲师关联信息不再本类存

1 2 3 4 5 6

class  Class( object ):      '''班级类，包含名称，课程，学生'''      def  __init__( self ,class_name,course_obj):          self .class_name  =  class_name          self .class_courese  =  course_obj          self .class_student  =  {}          #学生字典 {学生名：学生实例}

关联性单一，只跟班级相好的讲师类：看⑨  包含讲师名、薪资；讲师关联班级（对应关系在本类保存）班级成员列表，存放班级名（做判断，不会重复）；通过班级名查看班级类里面的班级信息（包含学生），避免存双份数据

1 2 3 4 5 6 7 8 9

class  Teacher( object ):      '''讲师类，定义teacher_name，teacher_salary，包含teacher_class'''      def  __init__( self , teacher_name, teacher_salary):          self .teacher_name  =  teacher_name          self .teacher_salary  =  teacher_salary          self .teacher_calss  =  []                  #班级列表 [s14,15]        def  teacher_add_class( self ,class_name,class_obj):          self .teacher_calss[class_name]  =  class_obj

内容最大，跟班级、课程、讲师都有关系的学校类：　　包含学校名，学校地址，存放课程实例、班级实例、讲师实例，都是字典形式

1 2 3 4 5 6 7 8 9

class  School( object ):      '''学校类，包含名称，地址，课程，班级，教师'''      def  __init__( self ,school_name,school_addr):          self .school_name  =  school_name          self .school_addr  =  school_addr          self .school_course  =  {}              #学校所有的课程实例    {"课程名“：课程实例}          self .school_class  =  {}                 self .school_teacher  =  {}     #类型与course一致          #self.school_student = {}          #可扩展学生

 

框架有了，类有了，业务逻辑还不so easy？！

直接放目录架构：

 

代码区：

程序入口bin下的start.py:　　注：判断了系统环境，添加了环境变量，调用了主业务区main.py

 1 import os
 2 import sys
 3 import platform
 4 
 5 if platform.system() == "Windows":
 6     BASE_DIR = "\\".join(os.path.abspath(os.path.dirname(__file__)).split("\\")[:-1])
 7 
 8 else:
 9     BASE_DIR = "/".join(os.path.abspath(os.path.dirname(__file__)).split("/")[:-1])
10 
11 sys.path.insert(0,BASE_DIR)
12 #print(sys.path)
13 
14 from core import main
15 from conf import settings
16 
17 if __name__ == '__main__':
18     obj = main.Manage_center()
19     obj.run()

start.py

配置文件conf下的settings.py：　　注：定义了数据库路径

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #-Author-Lian
 4 
 5 import os
 6 import sys
 7 import platform
 8 
 9 if platform.system() == "Windows":
10     BASE_DIR = "\\".join(os.path.abspath(os.path.dirname(__file__)).split("\\")[:-1])
11     database_path = os.path.join(BASE_DIR,"database")
12 
13 else:
14     BASE_DIR = "/".join(os.path.abspath(os.path.dirname(__file__)).split("/")[:-1])
15     database_path = os.path.join(BASE_DIR, "database")
16 
17 school_db_file = os.path.join(database_path,"school")

settings.py

主业务core下的main.py：　　注：定义了4个类，管理中心，学员视图，讲师视图，学校视图

  1 import os
  2 import sys
  3 import shelve
  4 from conf import settings
  5 from modules.school import School
  6 
  7 
  8 class Manage_center(object):
  9     def __init__(self):
 10         pass
 11 
 12     def run(self):
 13         while True:
 14             print("\n欢迎进入CLASS_SYSTEM系统\n"
 15                   "1 学生视图\n"
 16                   "2 教师视图\n"
 17                   "3 学校视图\n"
 18                   "q 退出学员管理系统\n")
 19             user_choice = input("\033[34;0m请输入您要登录的视图:\033[0m")
 20             if user_choice == '1':
 21                 Manage_student()
 22             elif user_choice == '2':
 23                 Manage_teacher()
 24             elif user_choice == '3':
 25                 Manage_school()
 26             elif user_choice == 'q':
 27                 print("\033[34;1m感谢使用学员管理系统,退出\033[0m")
 28                 break
 29             else:
 30                 print("\033[31;1m请输入正确的选项\033[0m")
 31 
 32 class Manage_school(object):
 33     '''学校管理视图'''
 34     def __init__(self):
 35         if os.path.exists(settings.school_db_file+".dat"):      #shelve会生成三个文件，其中有.dat结尾
 36             self.school_db = shelve.open(settings.school_db_file)  #打开学校数据库文件
 37             self.run_manage()       #运行管理视图
 38             self.school_db.close()     #关闭数据库文件
 39         else:
 40             print("\33[31;1m系统信息：初始化数据库\33[0m")
 41             self.initialize_school()    #初始化数据库
 42             self.run_manage()
 43             self.school_db.close()
 44 
 45     def initialize_school(self):
 46         '''实例化两个学校北京/上海'''
 47         self.school_db = shelve.open(settings.school_db_file)
 48         self.school_db['北京'] = School('北京', '中国.北京')
 49         self.school_db['上海'] = School('上海', '中国.上海')
 50 
 51     def run_manage(self):
 52         '''运行学校管理视图 '''
 53         while True:
 54             for key in self.school_db:
 55                 print("学校名称：",key)
 56             choice_school = input("\33[34;0m输入选择管理的学校名:\33[0m").strip()
 57             if choice_school in self.school_db:
 58                 self.choice_school = choice_school
 59                 self.school_obj = self.school_db[choice_school]
 60                 while True:
 61                     print("\n欢迎来到老男孩%s校区\n"
 62                           "添加课程 add_course\n"
 63                           "增加班级 add_class\n"
 64                           "招聘讲师 add_teacher\n"
 65                           "查看课程 check_course\n"
 66                           "查看班级 check_class\n"
 67                           "查看讲师 check_teacher\n"
 68                           "退出程序 exit"% self.school_obj.school_name)
 69                     user_func = input('''\033[34;0m输入要操作的命令：\033[0m''').strip()
 70                     if hasattr(self,user_func):
 71                         getattr(self,user_func)()
 72             else:
 73                 print("\33[31;1m输入错误：请输入正确的学校名\33[0m")
 74 
 75     def add_course(self):
 76         course_name = input('''\033[34;0m输入要添加课程的名称：\033[0m''').strip()
 77         course_price = input('''\033[34;0m输入要添加课程的价格：\033[0m''').strip()
 78         course_time = input('''\033[34;0m输入要添加课程的时长：\033[0m''').strip()
 79         if course_name in self.school_obj.school_course:    #判断课程是否已经添加过
 80             print("\33[32;1m课程存在\33[0m")
 81             self.school_obj.create_course(course_name, course_price, course_time)
 82             print("\33[32;1m课程更新完成\33[0m")
 83         else:
 84             self.school_obj.create_course(course_name,course_price,course_time)
 85             print("\33[32;1m课程添加成功\33[0m")
 86         self.school_db.update({self.choice_school: self.school_obj})    #更新数据库数据
 87 
 88     def add_class(self):
 89         class_name = input('''\033[34;0m输入要添加班级的名称：\033[0m''').strip()
 90         course_name = input('''\033[34;0m输入要关联的课程：\033[0m''').strip()
 91         if class_name not in self.school_obj.school_class:
 92             if course_name in self.school_obj.school_course:
 93                 course_obj = self.school_obj.school_course[course_name]
 94                 self.school_obj.create_class(class_name,course_obj)
 95                 self.school_db.update({self.choice_school: self.school_obj})  # 更新数据库数据
 96                 print("\33[32;1m班级创建成功\33[0m")
 97             else:
 98                 print("\33[31;1m系统错误：关联的课程不存在\33[0m")
 99         else:
100             print("\33[31;1m系统错误：班级已经存在\33[0m")
101 
102     def add_teacher(self):
103         teacher_name = input('''\033[34;0m输入要招聘教师的名称：\033[0m''').strip()
104         teacher_salary = input('''\033[34;0m输入教师的薪资：\033[0m''').strip()
105         teacher_class = input('''\033[34;0m输入要关联的班级：\033[0m''').strip()
106         if teacher_class in self.school_obj.school_class:       #判断班级是否存在
107             class_obj = self.school_obj.school_class[teacher_class]     #获取班级名对应的实例
108             if teacher_name not in self.school_obj.school_teacher:      #判断招聘教师是否存在，不存在创建，存在更新
109                 self.school_obj.create_teacher(teacher_name,teacher_salary,teacher_class,class_obj)
110                 print("\33[32;1m新讲师招聘成功\33[0m")
111             else:
112                 self.school_obj.update_teacher(teacher_name, teacher_class, class_obj)
113                 print("\33[32;1m讲师已经存在，信息更新完成\33[0m")
114 
115             self.school_db.update({self.choice_school: self.school_obj})  # 更新数据库数据
116         else:
117             print("\33[31;1m系统错误：关联的班级不存在\33[0m")
118 
119     def check_course(self):
120         self.school_obj.show_course()
121 
122     def check_class(self):
123         self.school_obj.show_class()
124 
125     def check_teacher(self):
126         self.school_obj.show_teacher()
127 
128     def exit(self):
129         self.school_db.close()
130         sys.exit("\033[32;1m欢迎下次使用学员管理系统\033[0m")
131 
132 class Manage_student(object):
133     '''学生视图'''
134     def __init__(self):
135         if os.path.exists(settings.school_db_file + ".dat"):  # shelve会生成三个文件，其中有.dat结尾
136             self.school_db = shelve.open(settings.school_db_file)  # 打开学校数据库文件
137             self.run_manage()  # 运行管理视图
138             self.school_db.close()  # 关闭数据库文件
139         else:
140             print("\033[31;1m数据库文件不存在，请先创建学校\033[0m")
141             exit()
142 
143     def run_manage(self):
144         print("\n欢迎进入学员视图")
145         for key in self.school_db:
146             print("学校名称：", key)
147         choice_school = input("\33[34;0m输入选择注册的学校名:\33[0m").strip()
148         if choice_school in self.school_db:
149             self.choice_school = choice_school
150             self.school_obj = self.school_db[choice_school]
151             student_name = input('''\033[34;0m输入学生的姓名：\033[0m''').strip()
152             student_age = input('''\033[34;0m输入学生的年龄：\033[0m''').strip()
153             self.school_obj.show_class_course()
154             class_choice = input('''\033[34;0m输入上课的班级：\033[0m''').strip()
155             if class_choice in self.school_obj.school_class:
156                 self.school_obj.create_student(student_name,student_age,class_choice)
157                 self.school_db.update({self.choice_school: self.school_obj})  # 更新数据库数据
158                 print("\33[32;1m学生注册成功\33[0m")
159             else:
160                 print("\33[31;1m系统错误：输入的班级不存在\33[0m")
161         else:
162             print("\33[31;1m系统错误：输入的学校不存在\33[0m")
163 
164 
165 class Manage_teacher(object):
166     '''教师视图'''
167     def __init__(self):
168         if os.path.exists(settings.school_db_file + ".dat"):  # shelve会生成三个文件，其中有.dat结尾
169             self.school_db = shelve.open(settings.school_db_file)  # 打开学校数据库文件
170             self.run_manage()  # 运行管理视图
171             self.school_db.close()  # 关闭数据库文件
172         else:
173             print("\033[31;1m数据库文件不存在，请先创建学校\033[0m")
174             exit()
175 
176     def run_manage(self):
177         for key in self.school_db:
178             print("学校名称：", key)
179         choice_school = input("\33[34;0m输入选择学校名:\33[0m").strip()
180         if choice_school in self.school_db:
181             self.choice_school = choice_school
182             self.school_obj = self.school_db[choice_school]
183             teacher_name = input('''\033[34;0m输入登录讲师的姓名：\033[0m''').strip()
184             while True:
185                 if teacher_name in self.school_obj.school_teacher:
186                     print("\n欢迎来到教师中心\n"
187                           "查看班级 check_class\n"
188                           "退出程序 exit" )
189                     user_func = input('''\033[34;0m输入要操作的命令：\033[0m''').strip()
190                     if hasattr(self, user_func):
191                         getattr(self, user_func)(teacher_name)
192                 else:
193                     print("\033[31;1m讲师不存在\033[0m")
194 
195     def check_class(self,teacher_name):
196         self.school_obj.show_teacher_classinfo(teacher_name)
197 
198     def exit(self,*args):
199         self.school_db.close()
200         sys.exit("\033[32;1m欢迎下次使用学员管理系统\033[0m")

main.py

数据文件database：　　注：不用管，自动初始化生成

1 注：不用管，自动初始化生成

database

模块modules下的school：　

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #-Author-Lian
 4 from modules.course import Course
 5 from modules.classs import Class
 6 from modules.teacher import Teacher
 7 from modules.student import Student
 8 
 9 class School(object):
10     '''学校类，包含名称，地址，课程，班级，教师'''
11     def __init__(self,school_name,school_addr):
12         self.school_name = school_name
13         self.school_addr = school_addr
14         self.school_course = {}             #学校所有的课程实例
15         self.school_class = {}
16         self.school_teacher = {}
17         #self.school_student = {}
18 
19     def create_course(self,course_name,course_price,course_time):
20         '''创建课程'''
21         course_obj = Course(course_name,course_price,course_time)
22         self.school_course[course_name] = course_obj
23 
24     def show_course(self):
25         '''查看课程信息'''
26         for key in self.school_course:
27             course_obj = self.school_course[key]
28             print("\33[32;1m课程：%s\t价格：%s\t周期：%s月\33[0m"%(course_obj.course_name,course_obj.course_price,
29                                          course_obj.course_time,))
30 
31     def create_class(self,class_name,courese_obj):
32         '''创建班级'''
33         class_obj = Class(class_name,courese_obj)
34         self.school_class[class_name] = class_obj
35 
36     def show_class(self):
37         for key in self.school_class:
38             class_obj = self.school_class[key]
39             print("\33[32;1m班级：%s\t关联课程：%s\33[0m" % (class_obj.class_name, class_obj.class_courese.course_name))
40 
41     def show_class_course(self):
42         for key in self.school_class:
43             class_obj = self.school_class[key]
44             course_obj = class_obj.class_courese
45             print("\33[32;1m班级：%s\t关联课程：%s\t价格：%s\t周期：%s月\33[0m" % (class_obj.class_name, course_obj.course_name,
46                                                                     course_obj.course_price,course_obj.course_time))
47 
48     def create_teacher(self,teacher_name, teacher_salary,class_name,class_obj):
49         '''创建讲师'''
50         teacher_obj = Teacher(teacher_name, teacher_salary)
51         teacher_obj.teacher_add_class(class_name,class_obj)
52         self.school_teacher[teacher_name] = teacher_obj
53 
54     def update_teacher(self,teacher_name,class_name,class_obj):
55         '''更新教师信息'''
56         teacher_obj = self.school_teacher[teacher_name]
57         teacher_obj.teacher_add_class(class_name,class_obj)
58 
59     def show_teacher(self):
60         '''查看讲师信息'''
61         for key in self.school_teacher:
62             teacher_obj = self.school_teacher[key]
63             class_list = []
64             for i in teacher_obj.teacher_calss:
65                 class_list.append(i)
66             print("\33[32;1m讲师：%s\t薪资：%s\t关联班级：%s\33[0m" % (teacher_obj.teacher_name, teacher_obj.teacher_salary,
67                                                           class_list ))
68     def create_student(self,student_name,student_age,class_choice):
69         '''注册学生'''
70         student_obj = Student(student_name,student_age)     #生成学生实例
71         class_obj = self.school_class[class_choice]         #获取学生所注册班级的实例对象
72         class_obj.class_student[student_name]=student_obj   #班级实例里添加学生信息
73         self.school_class[class_choice] = class_obj         #学校班级字典更新
74 
75     def show_teacher_classinfo(self,teacher_name):
76         teacher_obj = self.school_teacher[teacher_name]
77         for i in teacher_obj.teacher_calss:
78             class_obj = self.school_class[i]
79             student_list = []
80             for k in class_obj.class_student:
81                 student_list.append(k)
82             print("\33[32;1m班级：%s\t关联课程：%s\t学员:%s\33[0m" % (class_obj.class_name, class_obj.class_courese.course_name,
83                                                             student_list))

student.py

模块modules下的class：

1 class Class(object):
2     '''班级类，包含名称，课程，学生'''
3     def __init__(self,class_name,course_obj):
4         self.class_name = class_name
5         self.class_courese = course_obj
6         self.class_student = {}         #学生字典

class.py

模块modules下的course：

1 class Course():
2     '''定义课程类，包含名称，价格，周期'''
3     def __init__(self,course_name,course_price,course_time):
4         self.course_name = course_name
5         self.course_price = course_price
6         self.course_time = course_time

course.py

模块modules下的student：

class Student(object):
    '''学生类，包含姓名，年龄'''
    def __init__(self,student_name,student_age):
        self.student_name = student_name
        self.student_age = student_age

student.py

模块modules下的teacher：

1 class Teacher(object):
2     '''讲师类，定义teacher_name，teacher_salary，包含teacher_class'''
3     def __init__(self, teacher_name, teacher_salary):
4         self.teacher_name = teacher_name
5         self.teacher_salary = teacher_salary
6         self.teacher_calss = []                 #班级列表 [s14,15]
7 
8     def teacher_add_class(self,class_name,class_obj):
9         self.teacher_calss[class_name] = class_obj

teacher.py

 

运行示例图：

学校视图：

 

学生视图：

 

讲师视图：

 

 

 

　

 

 

转载于:https://www.cnblogs.com/ms520/p/10075173.html