本文共 30220 字，大约阅读时间需要 100 分钟。

这也是一个python基础必做项目，拿来练手+1，这个选课系统里主要是运用面向对象的思想进行设计。

这个主要是锻炼除面向对象以外全部python基础（函数+模块+文件）的一个练手项目。

一、项目需求

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

要求:

1. 创建滨海、河西、小黑屋 3 所学校 —> 管理员创建学校
2. 创建前端、后端、算法、AI 4个课程 ，AI在滨海开，后端在河西开，前端和算法在小黑屋开
3. 课程包含，周期，价格，通过学校创建课程
4. 创建讲师
5. 创建学员时，选择学校，关联班级
6. 创建讲师
7. 提供三个角色接口
   7.1 学员视图， 可以注册，选择课程（等同于选择班级）
   7.2 讲师视图， 讲师可管理自己的课程， 上课时选择班级，
   查看班级学员列表 ， 修改所管理的学员的成绩
   7.3 管理视图，创建讲师， 创建班级，创建课程
8. 上面的操作产生的数据都通过pickle序列化保存到文件里
   - pickle 可以帮我们保存对象

二、需求分析以及创建工程

1.一个项目怎么从无到有

1.客户提出需求，公司派人（一般一个前端、一个后端）和用户商谈，确定项目功能、开发周期、价格等

2.公司内部开会，得到一个开发文档，进行架构设计。

3.交给不同岗位的程序员开发

4.测试

5.上线

• 不同的岗位：
  • UI界面设计:

    • 设计软件的布局，会分局软件的外观切成一张张图片。

  • 前端:

    • 拿到UI交给他的图片，然后去搭建网页面。
    • 设计一些页面中，哪些位置需要接收数据，需要进行数据交互。

  • 后端:

    • 直接核心的业务逻辑，调度数据库进行数据的增删查改。

  • 测试:

    • 会给代码进行全面测试，比如压力测试，界面测试（CF卡箱子）。

  • 运维:

    • 部署项目。

2.需求分析

• 管理视图
  - 1.注册
  - 2.登录
  - 3.创建学校
  - 4.创建课程(先选择学校)
  - 5.创建讲师

• 学员视图
  - 1.注册
  - 2.登录功能
  - 3.选择校区
  - 4.选择课程（先选择校区，再选择校区中的某一门课程）
  - 学生选择课程，课程也选择学生
  - 5.查看分数

• 讲师视图
  - 1.登录
  - 2.查看教授课程
  - 3.选择教授课程
  - 4.查看课程下学生
  - 5.修改学生分数

3.架构设计-MVC三层架构

• 用户视图层
  - 用于与用户进行交互的
  - 小的逻辑判断,比如注册功能中两次密码是否一致的校验

• 逻辑接口层
  - 核心业务逻辑的处理

• 数据处理层
  - 做数据的处理，比如数据的 增、删、查、改

4.软件开发目录

start.py：项目执行文件

README.txt：项目需求以及如何用等文本信息

core：项目的核心模块，内有src.py实现核心逻辑，对应着视图层

conf：项目的配置信息模块，内有settings.py存储项目配置信息

db：项目的数据处理模块，内有db_handler.py对数据进行增删改查，对应着数据处理层

lib：项目的公共模块，内有common.py，功能供项目任何地方使用（在ATM+购物车中有记录流水这一功能，详情请看本文文首）

interface：项目的接口模块，内有各种接口，对应着接口层

5.核心逻辑实现及各视图层搭建

核心逻辑分析

搭建各个视图有点像重复做一件事

一点小细节：

导入模块分为相对导入和绝对导入，相对导入仅限于包内模块互相导入，绝对导入通用性更大

但绝对导入是以执行文件的sys.path为基准进行搜索的，鉴于此，我将start.py移动到bin目录下，更好的理解这个点。

conf下的setting.py增加：

import os#文件根路径BASE_PATH = os.path.dirname(os.path.dirname(__file__))

bin下start.py

import sysfrom conf import settingssys.path.append(settings.BASE_PATH)from core import  srcif __name__ == '__main__':        src.run()

1.主视图

'''主视图层'''from core import adminfrom core import studentfrom core import teacher#功能字典func_dic = {
       '0':['退出',None],    '1':['学生功能',student.stu_view],    '2':['管理功能',admin.admin_view],    '3':['教师功能',teacher.tea_view],}def run():    while True:        #1.打印主视图功能        print('Welcome to my CourseSystem!'.center(50,'='))        for k,v in func_dic.items():            print(k,v[0])        print('THE END'.center(50, '='))        #2.接受用户输入，选择身份        choice = input('请输入您想要的功能:').strip()        #3.若用户输入0，退出系统        if choice == '0':            break        #4.检验用户输入的合法性        if choice not in ['0','1','2','3']:            print('请输入0-3数字！')            continue        else:            func_dic[choice][1]()

2.学生视图

'''学生视图层''''''学员视图- 1.注册- 2.登录功能- 3.选择校区- 4.选择课程（先选择校区，再选择校区中的某一门课程）- 学生选择课程，课程也选择学生- 5.查看分数'''#1.注册def register():    ...#2.登录功能def login():    ...#3.选择校区def choose_school():    ...#4.选择课程（先选择校区，再选择校区中的某一门课程）def choose_course():    ...#学生选择课程，课程也选择学生#5.查看分数'''def check_score():    ...#学生功能字典func_dic = {
       '0':['退出',None],    '1':['注册',register],    '2':['登录',login],    '3':['选择校区',choose_school],    '4':['选择课程',choose_course],    '5':['查看分数',check_score],}#学生视图def stu_view():    while True:        print('View of student'.center(50,'='))        for k,v in func_dic.items():            print(k,v[0])        print('THE END'.center(50, '='))        #2.接受用户输入，选择身份        choice = input('请输入您想要的功能:').strip()        #3.若用户输入0，退出系统        if choice == '0':            break        #4.检验用户输入的合法性        if choice not in ['0','1','2','3','4','5']:            print('请输入0-3数字！')            continue        else:            func_dic[choice][1]()

3.管理员视图

'''管理视图层''''''管理视图- 1.注册- 2.登录- 3.创建学校- 4.创建课程(先选择学校)- 5.创建讲师'''# - 1.注册def register():    ...# - 2.登录def login():    ...# - 3.创建学校def creat_school():    ...# - 4.创建课程(先选择学校)def creat_course():    ...# - 5.创建讲师def creat_teacher():    ...#管理员功能字典func_dic = {
       '0':['退出',None],    '1':['注册',register],    '2':['登录',login],    '3':['创建学校',creat_school],    '4':['创建课程',creat_course],    '5':['创建教师',creat_teacher]}#学生视图def admin_view():    while True:        print('View of administer'.center(50,'='))        for k,v in func_dic.items():            print(k,v[0])        print('THE END'.center(50, '='))        #2.接受用户输入，选择身份        choice = input('请输入您想要的功能:').strip()        #3.若用户输入0，退出系统        if choice == '0':            break        #4.检验用户输入的合法性        if choice not in ['0','1','2','3','4','5']:            print('请输入0-3数字！')            continue        else:            func_dic[choice][1]()

4.教师视图

'''教师视图层''''''讲师视图- 1.登录- 2.查看教授课程- 3.选择教授课程- 4.查看课程下学生- 5.修改学生分数'''# - 1.登录def login():    ...# - 2.查看教授课程def check_course():    ...# - 3.选择教授课程def choose_course():    ...# - 4.查看课程下学生def check_student():    ...# - 5.修改学生分数def change_sorce():    ...#教师功能字典func_dic = {
       '0':['退出',None],    '1':['登录',login],    '2':['查看教授课程',login],    '3':['选择教授课程',choose_course],    '4':['查看课程下学生',check_course],    '5':['修改学生分数',change_sorce],}#学生视图def tea_view():    while True:        print('View of teacher'.center(50,'='))        for k,v in func_dic.items():            print(k,v[0])        print('THE END'.center(50, '='))        #2.接受用户输入，选择身份        choice = input('请输入您想要的功能:').strip()        #3.若用户输入0，退出系统        if choice == '0':            break        #4.检验用户输入的合法性        if choice not in ['0','1','2','3','4','5']:            print('请输入0-3数字！')            continue        else:            func_dic[choice][1]()

三、各个功能实现

1.学生功能

'''学生视图'''from lib import commonfrom interface import student_interfacefrom interface import common_interfacestudent_info = {
   'user': None}# 学生注册def register():    while True:        username = input('请输入用户名: ').strip()        password = input('请输入密码: ').strip()        re_password = input('请确认密码: ').strip()        # 小的逻辑判断        if password == re_password:            # 调用接口层，学生注册接口            flag, msg = student_interface.student_register_interface(                username, password            )            if flag:                print(msg)                break            else:                print(msg)        else:            print('两次密码不一致，请重新输入')# 学生登录def login():    while True:        username = input('请输入用户名: ').strip()        password = input('请输入密码: ').strip()        # 1.调用管理员登录接口        flag, msg = common_interface.login_interface(            username, password, user_type='student'        )        if flag:            print(msg)            # 记录当前用户登录状态            # 可变类型不需要global            student_info['user'] = username            break        else:            print(msg)# 学生选择学校@common.auth('student')def choice_school():    while True:        # 1、获取所有学校，让学生选择        flag, school_list = common_interface.get_all_school_interface()        if not flag:            print(school_list)            break        for index, school_name in enumerate(school_list):            print(f'编号: {index}   学校名: {school_name}')        # 2、让学生输入学校编号        choice = input('请输入选择的学校编号: ').strip()        if not choice.isdigit():            print('输入有误')            continue        choice = int(choice)        if choice not in range(len(school_list)):            print('输入编号有误!')            continue        school_name = school_list[choice]        # 3、开始调用学生选择学校接口        flag, msg = student_interface.add_school_interface(            school_name, student_info.get('user'))        if flag:            print(msg)            break        else:            print(msg)            break# 学生选择课程@common.auth('student')def choice_course():    while True:        # 1、先获取 "当前学生" 所在学校的课程列表        flag, course_list = student_interface.get_course_list_interface(            student_info.get('user')        )        if not flag:            print(course_list)            break        # 2、打印课程列表，并让用户选择课程        for index, school_name in enumerate(course_list):            print(f'编号: {index}   学校名: {school_name}')        # 2、让学生输入学校编号        choice = input('请输入选择的学校编号: ').strip()        if not choice.isdigit():            print('输入有误')            continue        choice = int(choice)        if choice not in range(len(course_list)):            print('输入编号有误!')            continue        # 3、获取选择的课程名称        course_name = course_list[choice]        # 4、调用学生选择课程接口        flag, msg = student_interface.add_course_interface(            course_name, student_info.get('user')        )        if flag:            print(msg)            break        else:            print(msg)# 学生查看课程分数@common.auth('student')def check_score():    # 1、直接调用查看分数接口    score_dict = student_interface.check_score_interface(        student_info.get('user')    )    if not score_dict:        print('没有选择课程!')    print(score_dict)func_dict = {
       '1': register,    '2': login,    '3': choice_school,    '4': choice_course,    '5': check_score,}def student_view():    while True:        print('''        - 1.注册        - 2.登录功能        - 3.选择校区        - 4.选择课程        - 5.查看分数        ''')        choice = input('请输入功能编号: ').strip()        if choice == 'q':            break        if choice not in func_dict:            print('输入有误，请重新输入!')            continue        func_dict.get(choice)()

学生接口

'''学生接口层'''from db import models# 学生注册接口def student_register_interface(user, pwd):    # 1.判断用户是否存在    # 调用Student类中的，select方法，    # 由该方法去调用db_handler中的select_data功能获取对象    student_obj = models.Student.select(user)    # 1.1) 若存在不允许注册，返回用户已存在给视图层    if student_obj:        return False, '学生用户已存在!'    # 1.2) 若不存在则允许注册，调用类实例化得到对象并保存    student_obj = models.Student(user, pwd)    # 对象调用save() 会将 admin_obj传给save方法    student_obj.save()    return True, '注册成功!'# 学生登录接口'''def student_login_interface(user, pwd):    # 1.判断用户是否存在    student_obj = models.Student.select(user)    # 2.若不存在，则证明用户不存在并返回给视图层    if not student_obj:        return False, '用户名不存在!'    # 3.若用户存在，则校验密码    if pwd == student_obj.pwd:        return True, '登录成功! '    else:        return False, '密码错误!''''# 学生选择学校接口def add_school_interface(school_name, student_name):    # 1、判断当前学生是否存在学校    student_obj = models.Student.select(student_name)    if student_obj.school:        return False, '当前学生已经选择过学校了!'    # 2、若不存在学校，则给调用学生对象中选择学校的方法，实现学生添加学校    student_obj.add_school(school_name)    return True, '选择学校成功!'# 获取学生所在学校所有课程接口def get_course_list_interface(student_name):    # 1、获取当前学生对象    student_obj = models.Student.select(student_name)    school_name = student_obj.school    # 2、判断当前学生是有学校，若没有则返回False    if not school_name:        return False, '没有学校，请先选择学校'    # 3、开始获取学校对象中的课程列表    school_obj = models.School.select(school_name)    # 3.1、判断当前学校中是否有课程，若没有，则联系管理员    course_list = school_obj.course_list    if not course_list:        return False, '没有课程，请先联系管理员创建'    # 3.2、若有则，返回课程列表    return True, course_list# 学生选择课程接口def add_course_interface(course_name, student_name):    # 1、先判断当前课程是否已经存在学生课程列表中    student_obj = models.Student.select(student_name)    if course_name in student_obj.course_list:        return False, '该课程已经选择过了!'    # 2、调用学生对象中添加课程的方法    student_obj.add_course(course_name)    return True, f'[{course_name}] -- 课程添加成功!'# 学生会查看分数接口def check_score_interface(student_name):    student_obj = models.Student.select(student_name)    if student_obj.score_dict:        return student_obj.score_dict

2.管理员功能

'''管理员视图'''from interface import admin_interfacefrom interface import common_interfacefrom lib import commonadmin_info = {
       'user': None}# 管理员注册def register():    while True:        username = input('请输入用户名: ').strip()        password = input('请输入密码: ').strip()        re_password = input('请确认密码: ').strip()        # 小的逻辑判断        if password == re_password:            # 调用接口层，管理员注册接口            flag, msg = admin_interface.admin_register_interface(                username, password            )            if flag:                print(msg)                break            else:                print(msg)        else:            print('两次密码不一致，请重新输入')# 管理员登录def login():    while True:        username = input('请输入用户名: ').strip()        password = input('请输入密码: ').strip()        # 1.调用管理员登录接口        flag, msg = common_interface.login_interface(            username, password, user_type='admin'        )        if flag:            print(msg)            # 记录当前用户登录状态            # 可变类型不需要global            admin_info['user'] = username            break        else:            print(msg)# 管理员创建学校@common.auth('admin')def create_school():    while True:        # 1.让用户输入学校的名称与地址        school_name = input('请输入学校名称: ').strip()        school_addr = input('请输入学校地址: ').strip()        # 2.调用接口，保存学校        flag, msg = admin_interface.create_school_interface(            # 学校名、学校地址、创建学校的管理员            school_name, school_addr, admin_info.get('user')        )        if flag:            print(msg)            break        else:            print(msg)# 管理员创建课程@common.auth('admin')def create_course():    while True:        # 1.让管理员先选择学校        # 1.1 调用接口，获取所有学校的名称并打印        flag, school_list_or_msg = common_interface.get_all_school_interface()        if not flag:            print(school_list_or_msg)            break        for index, school_name in enumerate(school_list_or_msg):            print(f'编号: {index}    学校名: {school_name}')        choice = input('请输入学校编号: ').strip()        if not choice.isdigit():            print('请输入数字')            continue        choice = int(choice)        if choice not in range(len(school_list_or_msg)):            print('请输入正确编号!')            continue        # 获取选择后的学校名字        school_name = school_list_or_msg[choice]        # 2.选择学校后，再输入课程名称        course_name = input('请输入需要创建的课程名称： ').strip()        # 3.调用创建课程接口，让管理员去创建课程        flag, msg = admin_interface.create_course_interface(            # 传递学校的目的，是为了关联课程            school_name, course_name, admin_info.get('user')        )        if flag:            print(msg)            break        else:            print(msg)# 管理员创建老师@common.auth('admin')def create_teacher():    while True:        # 1.让管理员输入创建的老师名字        teacher_name = input('请输入老师的名字: ').strip()        # 2.调用接口创建老师        flag, msg = admin_interface.create_teacher_interface(            teacher_name, admin_info.get('user'))        if flag:            print(msg)            break        else:            print(msg)func_dict = {
       '1': register,    '2': login,    '3': create_school,    '4': create_course,    '5': create_teacher,}# 管理员视图函数def admin_view():    while True:        print('''        - 1.注册        - 2.登录        - 3.创建学校        - 4.创建课程        - 5.创建讲师        ''')        choice = input('请输入功能编号: ').strip()        if choice == 'q':            admin_info['user'] = None            break        if choice not in func_dict:            print('输入有误，请重新输入!')            continue        func_dict.get(choice)()

管理接口

'''''''''管理员接口'''from db import models# 管理员注册接口def admin_register_interface(username, password):    # 1.判断用户是否存在    # 调用Admin类中的，select方法，    # 由该方法去调用db_handler中的select_data功能获取对象    admin_obj = models.Admin.select(username)    # 1.1) 若存在不允许注册，返回用户已存在给视图层    if admin_obj:        return False, '用户已存在!'    # 1.2) 若不存在则允许注册，调用类实例化得到对象并保存    admin_obj = models.Admin(username, password)    # 对象调用save() 会将 admin_obj传给save方法    admin_obj.save()    return True, '注册成功!'# 管理员登录接口'''def admin_login_interface(username, password):    # 1.判断用户是否存在    admin_obj = models.Admin.select(username)    # 2.若不存在，则证明用户不存在并返回给视图层    if not admin_obj:        return False, '用户名不存在!'    # 3.若用户存在，则校验密码    if password == admin_obj.pwd:        return True, '登录成功! '    else:        return False, '密码错误!''''# 管理员创建学校接口def create_school_interface(school_name, school_addr, admin_name):    # 1.查看当前学校是否已存在    # school_obj ---> 对象  or   None    school_obj = models.School.select(school_name)    # 2.若学校存在，则返回False告诉用户学校已存在    if school_obj:        return False, '学校已存在!'    # 3.若不存在，则创建学校， 注意: （由管理员对象来创建）    admin_obj = models.Admin.select(admin_name)    # 由管理员来调用创建学校方法，并传入学校的名字与地址    admin_obj.create_school(        school_name, school_addr    )    # 4.返回创建学校成功给视图层    return True, f'[{school_name}]学校创建成功!'# 管理员创建课程接口def create_course_interface(school_name, course_name, admin_name):    # 1.查看课程是否存在    # 1.1 先获取学校对象中的课程列表    school_obj = models.School.select(school_name)    # 1.2 判断当前课程是否存在课程列表中    if course_name in school_obj.course_list:        return False, '当前课程已存在!'    # 1.2 若课程不存在，则创建课程， 由管理员来创建    admin_obj = models.Admin.select(admin_name)    admin_obj.create_course(        school_obj, course_name    )    return True, f'[{course_name}] 课程创建成功, 绑定给[{school_name}]校区!'# 管理员创建老师接口def create_teacher_interface(teacher_name, admin_name, teacher_pwd='123'):    # 1.判断老师是否存在    teacher_obj = models.Teacher.select(teacher_name)    # 2.若存在，则返回不能创建    if teacher_obj:        return False, '老师已存在!'    # 3.若不存在，则创建老师，让 管理员 来创建    admin_obj = models.Admin.select(admin_name)    admin_obj.create_teacher(teacher_name, teacher_pwd)    return True, f'[{teacher_name}]老师创建成功!'

3.教师功能

'''老师视图'''from lib import commonfrom interface import common_interfacefrom interface import teacher_interfaceteacher_info = {
   'user': None}# 老师登录def login():    while True:        username = input('请输入用户名: ').strip()        password = input('请输入密码: ').strip()        # 1.调用管理员登录接口        flag, msg = common_interface.login_interface(            username, password, user_type='teacher'        )        if flag:            print(msg)            # 记录当前用户登录状态            # 可变类型不需要global            teacher_info['user'] = username            break        else:            print(msg)# 查看教授课程@common.auth('teacher')def check_course():    flag, course_list = teacher_interface.check_course_interface(        teacher_info.get('user')    )    if flag:        print(course_list)    else:        print(course_list)# 选择教授课程@common.auth('teacher')def choose_course():    while True:        # 1、先打印所有学校，并选择        flag, school_list = common_interface.get_all_school_interface()        if not flag:            print(school_list)            break        for index, school_name in enumerate(school_list):            print(f'编号: {index}   学校名: {school_name}')        choice = input('请输入选择的学校编号: ').strip()        if not choice.isdigit():            print('输入有误')            continue        choice = int(choice)        if choice not in range(len(school_list)):            print('输入编号有误!')            continue        # 获取选择的学校名称        school_name = school_list[choice]        # 2、从选择的学校中获取所有的课程        flag2, course_list = common_interface.get_course_in_school_interface(            school_name        )        if not flag2:            print(course_list)            break        for index2, course_name in enumerate(course_list):            print(f'编号: {index2}   课程名: {course_name}')        choice2 = input('请输入选择的课程编号: ').strip()        if not choice2.isdigit():            print('输入有误')            continue        choice2 = int(choice2)        if choice2 not in range(len(course_list)):            print('输入编号有误!')            continue        # 获取选择的课程名称        course_name = course_list[choice2]        # 3、调用选择教授课程接口，将该课程添加到老师课程列表中        flag3, msg = teacher_interface.add_course_interface(            course_name, teacher_info.get('user')        )        if flag3:            print(msg)            break        else:            print(msg)# 查看课程下学生@common.auth('teacher')def check_stu_from_course():    while True:        # 1、调用获取当前老师下所有的课程接口        flag, course_list = teacher_interface.check_course_interface(            teacher_info.get('user')        )        if not flag:            print(course_list)            break        # 2、打印所有课程，并让老师选择        for index, course_name in enumerate(course_list):            print(f'编号: {index}   课程名: {course_name}')        choice = input('请输入选择的课程编号: ').strip()        if not choice.isdigit():            print('输入有误')            continue        choice = int(choice)        if choice not in range(len(course_list)):            print('输入编号有误!')            continue        # 3、获取选择的课程名称        course_name = course_list[choice]        # 4、利用当前课程名称获取所有学生        flag2, student_list = teacher_interface.get_student_interface(            course_name, teacher_info.get('user')        )        if flag2:            print(student_list)            break        else:            print(student_list)            break# 修改学生分数@common.auth('teacher')def change_score_from_student():    '''    # 1、先获取老师下所有的课程，并选择    # 2、获取选择的课程下所有的学生，并选择修改的学生    # 3、调用修改学生分数接口修改分数    '''    while True:        # 1、调用获取当前老师下所有的课程接口        flag, course_list = teacher_interface.check_course_interface(            teacher_info.get('user')        )        if not flag:            print(course_list)            break        # 2、打印所有课程，并让老师选择        for index, course_name in enumerate(course_list):            print(f'编号: {index}   课程名: {course_name}')        choice = input('请输入选择的课程编号: ').strip()        if not choice.isdigit():            print('输入有误')            continue        choice = int(choice)        if choice not in range(len(course_list)):            print('输入编号有误!')            continue        # 3、获取选择的课程名称        course_name = course_list[choice]        # 4、利用当前课程名称获取所有学生        flag2, student_list = teacher_interface.get_student_interface(            course_name, teacher_info.get('user')        )        if not flag2:            print(student_list)            break        # 5、打印所有学生让老师选择        for index2, student_name in enumerate(student_list):            print(f'编号：{index2}   学生名: {student_name}')        choice2 = input('请输入学生编号： ').strip()        choice2 = int(choice2)        if choice2 not in range(len(student_list)):            print('输入编号有误!')            continue        # 获取选择的课程名称        student_name = student_list[choice2]        # 老师输入需要修改的分数        score = input('请输入需要修改的成绩:').strip()        if not score.isdigit():            continue        score = int(score)        # 6、调用修改学生分数接口修改分数        flag3, msg = teacher_interface.change_score_interface(            course_name, student_name,            score, teacher_info.get('user')        )        if flag3:            print(msg)            breakfunc_dict = {
       '1': login,    '2': check_course,    '3': choose_course,    '4': check_stu_from_course,    '5': change_score_from_student,}def teacher_view():    while True:        print('''        - 1.登录        - 2.查看教授课程        - 3.选择教授课程        - 4.查看课程下学生        - 5.修改学生分数        ''')        choice = input('请输入功能编号: ').strip()        if choice == 'q':            break        if choice not in func_dict:            print('输入有误，请重新输入!')            continue        func_dict.get(choice)()

教师接口

'''老师接口层'''from db import models# 老师查看课程接口def check_course_interface(teacher_name):    # 1、获取当前老师对象    teacher_obj = models.Teacher.select(teacher_name)    # 2、判断老师对象中课程列表是否有值    # 让老师对象，调用查看教授课程方法，返回课程    # course_list = teacher_obj.course_list_from_tea    course_list = teacher_obj.show_course()    # 3、若有则返回True， 无则返回False    if not course_list:        return False, '老师没有选择课程'    return True, course_list# 老师添加课程接口def add_course_interface(course_name, teacher_name):    # 1、获取当前老师对象    teacher_obj = models.Teacher.select(teacher_name)    # 2、判断当前课程是否在老师的课程列表中    course_list = teacher_obj.course_list_from_tea    if course_name in course_list:        return False, '该课程已存在!'    # 3、若不存在，则添加该课程到老师课程列表中    teacher_obj.add_course(course_name)    return True, '添加课程成功!'# 老师获取课程下学生接口def get_student_interface(course_name, teacher_name):    # 1、获取当前老师对象    teacher_obj = models.Teacher.select(teacher_name)    # 2、让当前老师对象，调用获取课程下所有学生功能    student_list = teacher_obj.get_student(course_name)    # 3、判断课程下是否有学生    if not student_list:        return False, '学生没有选择该课程'    return True, student_list# 老师修改分数接口def change_score_interface(course_name, student_name, score, teacher_name):    # 1、获取老师对象    teacher_obj = models.Teacher.select(teacher_name)    # 2、让老师对象调用修改分数方法    teacher_obj.change_score(course_name, student_name, score)    return True, '修改分数成功！'

4.其他

1.公共接口

'''''''''公共接口'''import osfrom conf import settingsfrom db import models# 获取所有学校名称接口def get_all_school_interface():    # 1.获取学校文件夹路径    school_dir = os.path.join(        settings.DB_PATH, 'School'    )    # 2.判断文件夹是否存在    if not os.path.exists(school_dir):        return False, '没有学校，请先联系管理员'    # 3.文件夹若存在，则获取文件夹中所有文件的名字    school_list = os.listdir(school_dir)    return True, school_list# 公共登录接口def login_interface(user, pwd, user_type):    if user_type == 'admin':        obj = models.Admin.select(user)    elif user_type == 'student':        obj = models.Student.select(user)    elif user_type == 'teacher':        obj = models.Teacher.select(user)    else:        return False, '登录角色不对，请输入角色'    # 1.判断用户是否存在    if obj:        # 2.若用户存在，则校验密码        if pwd == obj.pwd:            return True, '登录成功! '        else:            return False, '密码错误!'    else:        # 3.若不存在，则证明用户不存在并返回给视图层        return False, '用户名不存在!'# 获取学校下所有课程接口def get_course_in_school_interface(school_name):    # 1、获取学校对象    school_obj = models.School.select(school_name)    # 2、获取学校对象下所有课程    course_list = school_obj.course_list    if not course_list:        return False, '该学校没有课程'    return True, course_list

2.公共方法

'''''''''公共方法'''# 多用户登录认证装饰器def auth(role):    '''    :param role: 角色 ---》 管理员、学生、老师    :return:    '''    from core import admin, student, teacher    # 登录认证装饰器    def login_auth(func):        def inner(*args, **kwargs):            if role == 'admin':                if admin.admin_info['user']:                    res = func(*args, **kwargs)                    return res                else:                    admin.login()            elif role == 'student':                if student.student_info['user']:                    res = func(*args, **kwargs)                    return res                else:                    student.login()            elif role == 'teacher':                if teacher.teacher_info['user']:                    res = func(*args, **kwargs)                    return res                else:                    teacher.login()            else:                print('当前视图没有权限')        return inner    return login_auth

3.类的处理

'''用于存放类的学校类、学员类、课程类、讲师类、管理员类'''from db import db_handler# 父类,让所有子类都继承 select 与 save方法class Base:    # 查看数据  ----> 登录、查看数据库    @classmethod    def select(cls, username):  # School, school_name        # obj： 对象   or   None        obj = db_handler.select_data(cls, username)        return obj    # 保存数据 ---> 注册、保存、更新数据    def save(self):        # 让db_handler中的save_data帮我保存对象数据        db_handler.save_data(self)# 管理员类class Admin(Base):    # 调用类的时候触发    # username, password    def __init__(self, user, pwd):        # 给当前对象赋值        self.user = user        self.pwd = pwd    # 创建学校    def create_school(self, school_name, school_addr):        '''该方法内部来调用学校类实例化的得到对象，并保存'''        school_obj = School(school_name, school_addr)        school_obj.save()    # 创建课程    def create_course(self, school_obj, course_name):        # 1.调用课程类，实例化创建课程        course_obj = Course(course_name)        course_obj.save()        # 2.获取当前学校对象，并将课程添加到课程列表中        school_obj.course_list.append(course_name)        # 3.更新学校数据        school_obj.save()    # 创建讲师    def create_teacher(self, teacher_name, teacher_pwd):        # 1.调用老师类，实例化的到老师对象，并保存        teacher_obj = Teacher(teacher_name, teacher_pwd)        teacher_obj.save()# 学校类class School(Base):    def __init__(self, name, addr):        # 必须写: self.user,        # 因为db_handler里面的select_data统一规范        self.user = name        self.addr = addr        # 课程列表: 每所学校都应该有相应的课程        self.course_list = []# 学生类class Student(Base):    def __init__(self, user, pwd):        self.user = user        self.pwd = pwd        # 每个学生只能有一个校区        self.school = None        # 一个学生可以选择多门课程        self.course_list = []        # 学生课程分数        self.score_dict = {
   }  # {"course_name": 0}    # 学生添加学校方法    def add_school(self, school_name):        self.school = school_name        self.save()    # 学生添加课程方法    def add_course(self, course_name):        # 1、学生课程列表添加课程        self.course_list.append(course_name)        # 2、给学生选择的课程设置默认分数        self.score_dict[course_name] = 0        self.save()        # 3、学生选择的课程对象，添加学生        course_obj = Course.select(course_name)        course_obj.student_list.append(            self.user        )        course_obj.save()# 课程类class Course(Base):    def __init__(self, course_name):        self.user = course_name        self.student_list = []# 老师类class Teacher(Base):    def __init__(self, teacher_name, teacher_pwd):        self.user = teacher_name        # self.pwd需要统一        self.pwd = teacher_pwd        self.course_list_from_tea = []    # 老师查看教授课程方法    def show_course(self):        return self.course_list_from_tea    # 老师添加课程方法    def add_course(self, course_name):        self.course_list_from_tea.append(            course_name        )        self.save()    # 老师获取课程下学生方法    def get_student(self, course_name):        course_obj = Course.select(course_name)        return course_obj.student_list    # 老师修改学生分数方法    def change_score(self, course_name, student_name, score):        # 1、获取学生对象        student_obj = Student.select(student_name)        # 2、再给学生对象中的课程修改分数        student_obj.score_dict[course_name] = score        student_obj.save()

4.数据处理

'''''''''用于保存对象与获取对象'''import osimport picklefrom conf import settings# 保存数据def save_data(obj):    '''    1.获取对象的保存文件夹路径    以类名 当做 文件夹的名字    obj.__class__: 获取当前对象的类    obj.__class__.__name__: 获取类的名字    '''    class_name = obj.__class__.__name__    user_dir_path = os.path.join(        settings.DB_PATH, class_name    )    # 2.判断文件夹是否存在，不存在则创建文件夹    if not os.path.exists(user_dir_path):        os.mkdir(user_dir_path)    # 3.拼接当前用户的pickle文件路径,， 以用户名作为文件名    user_path = os.path.join(        user_dir_path, obj.user  # 当前用户名字    )    # 4.打开文件，保存对象, 通过pickle    with open(user_path, 'wb') as f:        pickle.dump(obj, f)# 查看数据def select_data(cls, username):  # 类, username    # 由cls类获取类名    class_name = cls.__name__    user_dir_path = os.path.join(        settings.DB_PATH, class_name    )    # 2.判断文件夹是否存在，不存在则创建文件夹    if not os.path.exists(user_dir_path):        os.mkdir(user_dir_path)    # 3.拼接当前用户的pickle文件路径,， 以用户名作为文件名    user_path = os.path.join(        user_dir_path, username  # 当前用户名字    )    # 4.判断文件如果存在，再打开，并返回，若不存在，则代表用户不存在    if os.path.exists(user_path):        # 5.打开文件，获取对象        with open(user_path, 'rb') as f:            obj = pickle.load(f)            return obj

5.配置信息

import osBASE_PATH = os.path.dirname(    os.path.dirname(__file__))DB_PATH = os.path.join(    BASE_PATH, 'db')

PS：附录

想要完整项目代码私我

转载地址：http://kbxki.baihongyu.com/