python选课系统 

python选课系统
程序的架构设计
            
    - 选课系统  
        - 三层架构
            - 视图层: 与用户交互的
            - 接口层: 核心的业务逻辑
            - 数据层: 处理数据的，增删改查
                - pickle格式的数据
                    - bytes类型数据
                
                - Python
                    - 对象: ---> object
需求分析
    - 管理员功能
        - 管理员注册
        - 管理员登录
        - 创建学校
        - 创建班级（先选择校区）
            - 班级名称
            - 班级绑定的校区
        - 创建课程（课程绑定给班级，先选择班级）
            - 课程周期
            - 课程价格
        - 创建老师
            - 老师名称
            - 老师密码
    - 学生的功能
        - 注册
        - 登录
        - 交学费
        - 选择校区
        - 选择课程
        - 查看分数
    - 老师的功能
        - 登录
        - 查看授课课程
        - 选择授课课程
        - 查看课程下学生
        - 修改学生分数



用户视图层
  1 src：
  2 from core import admin
  3 from core import student
  4 from core import teacher
  5 
  6 
  7 new_dic={
  8     '1':admin.run,
  9     '2':student.run,
 10     '3':teacher.run,
 11 }
 12 
 13 def run():
 14     while True:
 15         print('''
 16         1 管理员
 17         2 学生选课
 18         3 老师
 19         ''')
 20         choice=input('请输入选择的功能').strip()
 21 
 22         if choice=='q':
 23             break
 24         if choice not in new_dic:
 25             print('输入错误请再次输入')
 26             continue
 27 
 28         new_dic[choice]()
 29 
 30 
 31 
 32 admin：
 33 from interface import admin_interface
 34 from interface import common_interface
 35 from lib import common
 36 
 37 admin_user={'user':None}
 38 
 39 def admin_regist():
 40     while True:
 41         user=input('请输入账户').strip()
 42         pwd=input('请输入密码').strip()
 43         repwd=input('请再次输入密码').strip()
 44 
 45         if pwd==repwd:
 46 
 47             flag,msg=admin_interface.check_user(
 48                 user,pwd
 49             )
 50             if flag:
 51                 print(msg)
 52                 break
 53             else:
 54                 print(msg)
 55 
 56         else:
 57             print('两次密码不一致')
 58 
 59 
 60 def admin_log():
 61     while True:
 62         user = input('请输入账户').strip()
 63         pwd = input('请输入密码').strip()
 64         if user and pwd:
 65             flag,msg=common_interface.all_user_log(user,pwd,role='admin')
 66             if flag:
 67                 admin_user['user'] = user
 68                 print(msg)
 69                 break
 70             else:
 71                 print(msg)
 72                 continue
 73         else:
 74             print('请输入账户密码')
 75 
 76 
 77 @common.decorator_name('admin')
 78 def create_school():
 79     while True:
 80         school_name=input('请输入学校名称').strip()
 81         school_addr=input('请输入学校地址').strip()
 82         #调用接口保存学校
 83         flag,msg=admin_interface.create_school_interface(
 84                                       #由谁创建的学校  获取登录的管理员
 85             school_name,school_addr,admin_user.get('user')
 86         )
 87         if flag:
 88             print(msg)
 89             break
 90         else:
 91             print(msg)
 92 
 93 
 94 
 95 @common.decorator_name('admin')
 96 def create_class():
 97     pass
 98 @common.decorator_name('admin')
 99 def create_course():
100     while True:
101         #让管理员选择学校
102         flag,school_list_or_msg=common_interface.get_all_scholl_interface()
103         if not flag:
104             print(school_list_or_msg)
105 
106         #调用接口，获取所有学校的名称并打印
107         for index,school_name in enumerate(school_list_or_msg):
108             print(f'编号：{index} 学校名：{school_name}')
109 
110 
111         choice= input('请输入学校编号').strip()
112         if not choice.isdigit():
113             print('请输入数字')
114             continue
115         choice=int(choice)
116         if choice not in range(len(school_list_or_msg)):            #学校个数长度
117             print('请输入正确编号')
118         school_name=school_list_or_msg[choice]     #school_ilst_or_msge  本身就是列表os。listdir出来的  enumerate本来就是打印给别人看的
119         # 选择学校后，再输入课程名称
120         course_name=input('请输入课程名称').strip()
121 
122         #调用创建课程接口，让管理员去创建课程
123         flag,msg=admin_interface.create_course_interface(
124             school_name,course_name,admin_user.get('user')
125         )
126         if flag:
127             print(msg)
128             break
129         else:
130             print(msg)
131 
132 
133 
134 
135 
136 
137 
138 
139 
140 @common.decorator_name('admin')
141 def create_teacher():
142     while True:
143         # 管理员输入创建老师的名字
144         teacher_name=input('请输入老师的名字').strip()
145 #         调用老师接口创建老师
146         flag,msg=admin_interface.create_teacher_interface(
147             teacher_name,admin_user.get('user')
148         )
149         if flag:
150             print(msg)
151             break
152         else:
153             print(msg)
154 
155 
156 
157 
158 new_dic={
159     '1':admin_regist,
160     '2':admin_log,
161     '3':create_school,
162     '4':create_class,
163     '5':create_course,
164     '6':create_teacher,
165 
166 
167 }
168 
169 def run():
170     while True:
171         print('''
172        1 - 管理员注册
173        2 - 管理员登录
174        3 - 创建学校
175        4 - 创建班级(无效)            
176        5 - 创建课程           
177        6 - 创建老师
178         
179         ''')
180         choice = input('请输入选择的功能').strip()
181         if choice=='q':
182             break
183         if choice not in new_dic:
184             print('输入错误请再次输入')
185             continue
186 
187         new_dic[choice]()
188 
189 
190 student。py
191 from lib import common
192 from interface import student_interface
193 from interface import common_interface
194 
195 
196 student_user={'user':None}
197 def regist():
198     while True:
199         student_name=input('请输入账户输入密码').strip()
200         student_pwd=input('请输入账户输入密码').strip()
201         repwd = input('请再次输入密码').strip()
202 
203         if student_pwd == repwd:
204             #调用接口判断用户是否存在 不存在接口成再创建返回
205             flag, msg = student_interface.student_user(student_name,student_pwd)
206 
207 
208             if flag:
209                 print(msg)
210                 break
211             else:
212                 print(msg)
213 
214         else:
215             print('两次密码不一致')
216 
217 
218 
219 
220 
221 def log():
222     while True:
223         user = input('请输入账户').strip()
224         pwd = input('请输入密码').strip()
225         if user and pwd:
226             flag, msg = common_interface.all_user_log(user,pwd,role='student')
227             if flag:
228                 student_user['user'] = user
229                 print(msg)
230                 break
231             else:
232                 print(msg)
233                 continue
234         else:
235             print('请输入账户密码')
236 @common.decorator_name('student')
237 def repay():
238     while True:
239         students_money=input('是否进行缴费y/n')
240         if students_money=='y':
241             flag,msg=student_interface.student_pay(student_user.get('user'))
242             if flag:
243                 print(msg)
244                 break
245             else:
246                 print(msg)
247                 break
248         else:
249             print('不缴费滚蛋')
250             break
251 
252 
253 
254 @common.decorator_name('student')
255 def choose_school():
256     while True:
257         # 打印课程列表提供选择
258         flag, school_list_or_msg = common_interface.get_all_scholl_interface()
259         if not flag:
260             print(school_list_or_msg)
261         for index, school_name in enumerate(school_list_or_msg):
262             print(f'编号：{index} 学校名：{school_name}')
263 
264         choice = input('请输入课程编号').strip()
265         if not choice.isdigit():
266             print('请输入数字')
267             continue
268         choice = int(choice)
269         if choice not in range(len(school_list_or_msg)):  # 学校个数长度
270             print('请输入正确编号')
271             continue
272         school_name = school_list_or_msg[choice]
273         # 调用接口判断学生是否有校区
274         flag1,msg=student_interface.chack_have_school(school_name,student_user.get('user'))
275         if flag1:
276             print(msg)
277             break
278         else:
279             print(msg)
280             break
281 
282 
283 
284 @common.decorator_name('student')
285 def choose_course():
286     while True:
287         # 打印课程列表提供选择
288         flag,course_list_or_msg = common_interface.get_all_course()
289         if not flag:
290             print(course_list_or_msg)
291             # 调用接口，获取所有学校的名称并打印
292         for index, course_name in enumerate(course_list_or_msg):
293             print(f'编号：{index} 课程名：{course_name}')
294 
295         choice = input('请输入课程编号').strip()
296         if not choice.isdigit():
297             print('请输入数字')
298             continue
299         choice = int(choice)
300         if choice not in range(len(course_list_or_msg)):  # 学校个数长度
301             print('请输入正确编号')
302             continue
303         cousrse_name = course_list_or_msg[choice]  # school_ilst_or_msge  本身就是列表os。listdir出来的  enumerate本来就是打印给别人看的
304         # 调用学生接口为学生类列表中添加课程
305         flag1,msg=student_interface.add_course(cousrse_name,student_user.get('user'))
306         if flag1:
307             print(msg)
308             break
309         else:
310             print(msg)
311             break
312 
313 
314 
315 @common.decorator_name('student')
316 def check_score():
317     flag,msg=student_interface.check_score_interface(student_user.get('user'))
318     if flag:
319         print(msg)
320     else:
321         print(msg)
322 
323 new_dic={
324     '1':regist,
325     '2':log,
326     '3':repay,
327     '4':choose_school,
328     '5':choose_course,
329     '6':check_score,
330     }
331 
332 def run():
333     while True:
334         print('''
335        1 - 注册
336        2 - 登录
337        3 - 交学费
338        4 - 选择校区
339        5 - 选择课程
340        6 - 查看分数
341 
342         ''')
343         choice = input('请输入选择的功能').strip()
344 
345         if choice=="q":
346             break
347         if choice not in new_dic:
348             print('输入错误请再次输入')
349             continue
350 
351         new_dic[choice]()
352 
353 
354 teacher。py
355 from lib import common
356 from interface import common_interface
357 from interface import teacher_interface
358 teacher_user={'user':None}
359 def log():
360     while True:
361         user = input('请输入账户').strip()
362         pwd = input('请输入密码').strip()
363         if user and pwd:
364             flag, msg = common_interface.all_user_log(user, pwd, role='teacher')
365             if flag:
366                 teacher_user['user'] = user
367                 print(msg)
368                 break
369             else:
370                 print(msg)
371                 continue
372         else:
373             print('请输入账户密码')
374 #查看授课课程
375 @common.decorator_name('teacher')
376 def check_coures():
377     flag, msg = teacher_interface.check_course_interface(teacher_user.get('user'))
378     if flag:
379         print(msg)
380     else:
381         print(msg)
382 
383 @common.decorator_name('teacher')
384 def choice_course():
385     while True:
386         flag,course_list_or_msg=common_interface.get_all_course()
387         if not flag:
388             print(course_list_or_msg)
389         for index,course in enumerate(course_list_or_msg):
390             print(f'编号：{index}  课程：{course}')
391         choice=input('请输入编号')
392         choice=int(choice)
393         if choice not in range(len(course_list_or_msg)):
394             print('请输入正确编号')
395         course_name=course_list_or_msg[choice]
396         #获取教师对象添加授课课程
397         flag1,msg=teacher_interface.add_course_interface(course_name,teacher_user.get('user'))
398         if flag1:
399             print(msg)
400             break
401         else:
402             print(msg)
403             break
404 
405 
406 
407 
408 @common.decorator_name('teacher')
409 def check_course_student():
410     while True:
411         flag,course_list_or_msg=teacher_interface.check_course_interface(teacher_user.get('user'))
412         if not flag:
413             print(course_list_or_msg)
414 
415         for index, course in enumerate(course_list_or_msg):
416             print(f'编号：{index}  课程：{course}')
417         choice = input('请输入编号')
418         choice = int(choice)
419         if choice not in range(len(course_list_or_msg)):
420             print('请输入正确编号')
421         course_name = course_list_or_msg[choice]
422         flag,msg=teacher_interface.check_course_from_student(teacher_user.get('user'),course_name)
423         if flag:
424             print(msg)
425             break
426         else:
427             print(msg)
428             break
429 
430 
431 
432 
433 
434 
435 @common.decorator_name('teacher')
436 def change_score():
437     while True:
438         flag, course_list_or_msg = teacher_interface.check_course_interface(teacher_user.get('user'))
439         if not flag:
440             print(course_list_or_msg)
441 
442         for index, course in enumerate(course_list_or_msg):
443             print(f'编号：{index}  课程：{course}')
444         choice = input('请输入编号')
445         choice = int(choice)
446         if choice not in range(len(course_list_or_msg)):
447             print('请输入正确编号')
448         course_name = course_list_or_msg[choice]
449         flag1, students_msg = teacher_interface.check_course_from_student(teacher_user.get('user'), course_name)
450         if flag1:
451             for index, students in enumerate(students_msg):
452                 print(f'编号{index}  选择学生{students}')
453                 choice = input('请输入编号')
454                 choice = int(choice)
455                 if choice not in range(len(students_msg)):
456                     print('请输入正确编号')
457                 student_name = students_msg[choice]
458                 student_score=input('请输入学生分数修改')
459                 #修改分数
460                 flag3,msg=teacher_interface.change_student_score(student_name,course_name,student_score)
461                 if flag3:
462                     print(msg)
463                     break
464         break
465 
466 
467 
468 new_dic={
469     '1':log,
470     '2':check_coures,
471     '3':choice_course,
472     '4':check_course_student,
473     '5':change_score,
474 
475 }
476 
477 def run():
478     while True:
479         print('''
480         1- 登录
481         2- 查看授课课程
482         3- 选择授课课程
483         4- 查看课程下学生
484         5- 修改学生分数
485         ''')
486         choice = input('请输入选择的功能').strip()
487         if choice=='q':
488             break
489         if choice not in new_dic:
490             print('输入错误请再次输入')
491             continue
492 
493         else:
494             new_dic[choice]()

逻辑接口层

  1 admin_interface.py
  2 from db import models
  3 
  4 
  5 def check_user(username,pwd):
  6     # 1查看用户是否存在
  7     obj=models.Admin.chack(username)
  8     if obj:
  9         return False,'用户存在'
 10     # 2或不存在返回注册成功，调用实例化得到对象并保存
 11     admin_obj=models.Admin(username,pwd)
 12     admin_obj.save()
 13     return True,'注册成功'
 14 #管理员登录
 15 def log(user,pwd):
 16     user_obj=models.Admin.chack(user)                       #用类调用会获取类名在类名文件夹中找注册的人进行反序列化返回对象
 17     if user_obj:
 18         if user_obj.user==user and  user_obj.pwd==pwd:   #对象直接点取user,pwd
 19             return True,'登录成功'
 20         else:
 21             return False,'登录失败密码或账户错误'
 22     else:
 23         return False,'无此用户'
 24 
 25 
 26 #管理员创建学校接口
 27 def create_school_interface( school_name,school_addr,admin_user):
 28     #查看当前学校是否已近存在
 29     school_obj=models.School.chack(school_name)
 30     #学校存在返回False告诉用户学校已近存在
 31     if school_obj:
 32         return False,'学校已近存在！'
 33     #若不存在，则创建学校 注意（由管理员创建）
 34     admin_obj=models.Admin.chack(admin_user)
 35     #由管理员来调用创建学校方法，并传入学校的名称和地址
 36     admin_obj.create_school(
 37         school_name,school_addr
 38     )
 39     # 返回创建成功
 40     return True,f'{school_name}学校创建成功'
 41 
 42 #管理员创建课程接口 创建课程关联学校名称
 43 def create_course_interface(school_name,course_name,admin_name):
 44     # 1，查看课程是否存在，
 45     #获取学校对象中的课程列表
 46     school_obj=models.School.chack(school_name)
 47     #查看课程是否重复
 48     if course_name in school_obj.course_list:
 49         return False,'课程已近存在'
 50     #课程不存在则创建 （由管理员创建）
 51     admin_obj=models.Admin.chack(admin_name)
 52     admin_obj.create_course(school_obj,course_name)
 53     return True,f'{course_name}课程创建成功，绑定给{school_name}'
 54 
 55 
 56 def create_teacher_interface(teacher_name,admin_name,teacher_pwd='123'):       # 给老师默认密码123
 57 #     判断老师是否存在
 58     teacher_obj=models.Teacher.chack(teacher_name)
 59 
 60     # 若存在,则不让创建
 61     if teacher_obj:
 62         return False,'老师已近存在'
 63 
 64     #若不存在则创建
 65     admin_obj=models.Admin.chack(admin_name)
 66     admin_obj.create_teacher(teacher_name,teacher_pwd)   #由管理员对象创建老师
 67     return True,f'{teacher_name}老师创建成功'
 68 
 69 
 70 
 71 
 72 student。interface。py
 73 from db import models
 74 #学生用户创建
 75 def student_user(student_name,student_pwd):
 76 
 77     student_obj=models.Student.chack(student_name)
 78     if student_obj:
 79         return False,'用户存在请重新创建'
 80     #用户不存在创建成功返回
 81     student_obj1=models.Student(student_name,student_pwd)
 82     student_obj1.save()
 83     return True,f'{student_name}学生注册成功'
 84 
 85 
 86 #为学生添加课程
 87 def add_course(cousrse_name,student_user):
 88     #调用学生类添加课程
 89     student_obj=models.Student.chack(student_user)
 90     #判断课程是否已近添加过了
 91     if cousrse_name in student_obj.course:
 92         return False,'课程已近添加过了无需重复添加'
 93     student_obj.course.append(cousrse_name)
 94     student_obj.save()
 95     #把学生添加到课程内
 96     cousrse_obj = models.Course.chack(cousrse_name)
 97     cousrse_obj.student.append(student_obj.user)
 98     cousrse_obj.save()
 99     return True,'添加成功'
100 
101 
102 #查看学生是否已近有学校
103 def chack_have_school(school_name,student_user):
104     student_obj=models.Student.chack(student_user)
105     #如果校区已经选择
106     if student_obj.school:
107         return False,'学校已经存在，学生只能有一个校区多门课程'
108     #如果没有选择校区的添加校区
109     student_obj.school=school_name
110     student_obj.save()
111     return True,f'{school_name}添加成功'
112 
113 #学生缴费
114 def student_pay(student_user):
115     student_obj=models.Student.chack(student_user)
116     if student_obj.course_pay:
117         return False,'无需重复缴费'
118     student_obj.course_pay=True
119     student_obj.save()
120     return True,f'{student_user},缴费成功'
121 
122 #学生查看分数
123 def check_score_interface(student_user):
124     student_obj=models.Student.chack(student_user)
125     if not student_obj.score:
126         return False,f'老师暂未评分,请联系代课老师'
127     else:
128         return True,f'{student_obj.score}'
129 
130 
131 
132 teacher。interface。py
133 from db import models
134 #查看自身授课程
135 def check_course_interface(teacher_user):
136     teacher_obj=models.Teacher.chack(teacher_user)
137     if not teacher_obj.course_list_from_teacher:
138         return False,f'您还未添加授课科目，先去添加吧'
139     else:
140         return True,teacher_obj.course_list_from_teacher
141 # 添加授课课程
142 def add_course_interface(course_name,teacher_user):
143     teacher_obj=models.Teacher.chack(teacher_user)
144     #判断课程是否已近添加过
145     if course_name in teacher_obj.course_list_from_teacher:
146         return False,'课程已近添加过了'
147     teacher_obj.course_list_from_teacher.append(course_name)
148     teacher_obj.save()
149     return True,'课程选择成功，望认真教学'
150 
151 
152 #查看课程下的学生
153 def check_course_from_student(teacher_user,course_name):
154     #调用课程类里的学生信息
155     course_obj=models.Course.chack(course_name)
156 
157     teacher_obj = models.Teacher.chack(teacher_user)
158     if course_name not in teacher_obj.course_list_from_teacher:
159         return False,'您还未教授本门课程请先添加'
160     #无学生添加列表
161     if not course_obj.student:
162         return False,'课程占无学生选择'
163 
164     else:
165         return True,course_obj.student
166 
167 #修改学生分数
168 def change_student_score(student_name,course_name,student_score):
169     student_obj=models.Student.chack(student_name)
170     student_obj.score[course_name]=student_score
171     student_obj.save()
172     return True,f'{student_name}课程评分{student_score}成功'
173 
174 
175 
176 
177 
178 
179 common。interface。py
180 import os
181 from conf import settings
182 from db import models
183 """"""
184 '''公共接口'''
185 
186 #获取所有学校名称接口
187 def get_all_scholl_interface():
188     #获取学校文件夹路劲
189     school_dir=os.path.join(settings.DB_PATH,'School')
190     if not school_dir:
191         return False,'没有学校请先联系管理员'
192     #文件存在  获取文件夹下的学校名字等  os.listdir
193     school_list=os.listdir(school_dir)
194     return True,school_list
195 
196 #所有用户登录
197 def all_user_log(user,pwd,role):
198 
199     if role=='admin':
200         user_obj=models.Admin.chack(user)                       #用类调用会获取类名在类名文件夹中找注册的人进行反序列化返回对象
201 
202     elif role=='student':
203         user_obj=models.Student.chack(user)
204 
205     elif role=='teacher':
206         user_obj=models.Teacher.chack(user)
207     else:
208         return False,'角色登录不存在'
209 
210 
211     if user_obj:
212         if user_obj.user == user and user_obj.pwd == pwd:  # 对象直接点取user,pwd
213             return True, '登录成功'
214         else:
215             return False, '登录失败密码或账户错误'
216     else:
217         return False, '无此用户'
218 
219 #获取所有学校课程
220 def get_all_course():
221     #获取学校文件夹路劲
222     course_dir=os.path.join(settings.DB_PATH,'Course')
223     if not course_dir:
224         return False,'没有课程请先联系管理员，添加课程'
225     #文件存在  获取文件夹下的学校名字等  os.listdir
226     course_list=os.listdir(course_dir)
227     return True,course_list

 

数据处理层  db

models（类的存放）

 1 models.py
 2 from db import db_handler
 3 
 4 '''用户存放类的'''
 5 # 父类   继承查看数据和保存数据
 6 
 7 class Base:
 8     @classmethod
 9     # 用类的绑定使用检查用户是否存在（存在返回查找的对象）
10     def chack(cls, user):
11         obj = db_handler.chack_data(cls, user)
12         return obj
13 
14     def save(self):
15         db_handler.save(self)
16 
17 #管理员类
18 class Admin(Base):
19     def __init__(self,user,pwd):
20         self.user=user
21         self.pwd=pwd
22 
23 
24         #创建学校
25     def create_school(self,school_name,school_addr):
26         # 实例化(内部调用学校类实例化得到对象，并保存)
27         school_obj=School(school_name,school_addr)
28         #调用学校类里的继承父类函数保存
29         school_obj.save()
30 
31         #创建课程
32     def create_course(self,school_obj,course_name):
33         #调用课程类
34         course_obj=Course(course_name)
35         course_obj.save()
36         #获取当前学校对象，并将课程添加到课程列表中
37         school_obj.course_list.append(course_name)
38         #更新学校数据
39         school_obj.save()
40 
41 
42 
43 
44     def create_teacher(self,teacher_name,teacher_pwd):
45         teacher_obj=Teacher(teacher_name,teacher_pwd)  #实例化得到老师对象并保存
46         teacher_obj.save()  #调用继承保存函数进行  更行添加修改
47 
48 
49 
50 # 学校类
51 class School(Base):
52     def __init__(self,name,addr):
53         #必须user db里的chack——data代码要同意规范
54         self.user=name
55         self.addr=addr
56         #学校关联班级
57         self.course_list=[]
58 
59 
60 
61 # 学生类
62 class Student(Base):
63     def __init__(self,student_name,student_pwd):
64         self.user=student_name
65         self.pwd=student_pwd
66         self.school=None
67         self.course_pay=False
68         self.course=[]
69         self.score={}               #定义空字典等待老师批改后输入分数
70 
71 #课程类
72 class Course(Base):
73     def __init__(self,course_name):
74         self.user=course_name
75         self.student=[]
76 
77 
78 #教师类
79 class Teacher(Base):
80     def __init__(self,user_name,teacher_pwd):
81         self.user=user_name  #需要统一
82         self.pwd=teacher_pwd
83         self.course_list_from_teacher=[]

 

db_handler(数据处理)

 1 import os
 2 import pickle
 3 from conf import settings
 4 #保存数据对象
 5 def save(obj):
 6     # 获取类命创建文件夹
 7     class_name=obj.__class__.__name__
 8 
 9     #1.文件路劲拼接大文件夹啊
10     PATH=os.path.join(settings.DB_PATH,class_name)
11     # 判断文件夹是否存在
12     if not os.path.exists(PATH):
13         os.mkdir(PATH)
14     #拼接当前用户的pickle文件路劲，以用户名作为文件名
15     user_path=os.path.join(PATH,obj.user)   #这里调用对象的user  所以后面都需要规范user的使用
16     #打开文件储存
17     with open(user_path,mode='wb')as f:
18         pickle.dump(obj,f)
19 
20 # 查看文件数据
21 def chack_data(cls,user):
22     class_name = cls.__name__  #获取类的名字
23 
24     # 1.文件路劲拼接大文件夹啊
25     PATH = os.path.join(settings.DB_PATH, class_name)
26 
27     # 拼接当前用户的pickle文件路劲，以用户名作为文件名
28     user_path = os.path.join(PATH,user)
29     if not os.path.isfile(user_path):
30         return None
31 
32     #判断文件用户文件是否存在
33     if os.path.exists(user_path):
34     # 打开文件储存
35         with open(user_path, mode='rb')as f:
36             obj=pickle.load(f)
37             return obj

lib下的common（公用方法）

 1 #装饰器
 2 def decorator_name(role):
 3     def decorator(func):
 4         from core import admin,student,teacher
 5         def wrapper(*args,**kwargs):
 6             if role=='admin':
 7                 if admin.admin_user['user']:
 8                     res=func(*args,**kwargs)
 9                     return res
10                 else:
11                     print('请先登录')
12                     admin.admin_log()
13             elif role=='student':
14                 if student.student_user['user']:
15                     res=func(*args,**kwargs)
16                     return res
17                 else:
18                     print('请先登录')
19                     student.log()
20             elif role=='teacher':
21                 if teacher.teacher_user['user']:
22                     res=func(*args,**kwargs)
23                     return res
24                 else:
25                     print('请先登录')
26                     teacher.log()
27         return wrapper
28     return decorator

配置conf 下的settings

import os

BASE_PATH=os.path.dirname(os.path.dirname(__file__))

DB_PATH=os.path.join(BASE_PATH,'db')

执行文件头 tart

import os
import sys
from core import src


sys.path.append(os.path.dirname(__file__))


if __name__ == '__main__':
    src.run()

readme说明书

程序的架构设计
            
    - 选课系统  
        - 三层架构
            - 视图层: 与用户交互的
            - 接口层: 核心的业务逻辑
            - 数据层: 处理数据的，增删改查
                - pickle格式的数据
                    - bytes类型数据
                
                - Python
                    - 对象: ---> object
需求分析
    - 管理员功能
        - 管理员注册
        - 管理员登录
        - 创建学校
        - 创建班级（先选择校区）
            - 班级名称
            - 班级绑定的校区
        - 创建课程（课程绑定给班级，先选择班级）
            - 课程周期
            - 课程价格
        - 创建老师
            - 老师名称
            - 老师密码
    - 学生的功能
        - 注册
        - 登录
        - 交学费
        - 选择校区
        - 选择课程
        - 查看分数
    - 老师的功能
        - 登录
        - 查看授课课程
        - 选择授课课程
        - 查看课程下学生
        - 修改学生分数

 

用类名创建文件夹名  用对象名命名数据文件名







posted @ 2021-04-06 16:35  欧阳锦涛  阅读(85)  评论(0)    收藏  举报
TOP 底部