小白学python系列————【Day50】选课系统项目

今日内容概要

选课系统项目分析
选课系统架构设计
项目源码展示

选课系统项目分析

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

2.选课系统功能分析
管理功能（最核心）

注册功能
登录功能
创建讲师
创建学校
创建课程

讲师功能

登录功能
查看教授课程
选择教授课程
查看课程学生
评判学生分数

学生功能

注册功能
登录功能
选择学校
选择课程
查看分数

系统架构设计

1.三层架构
功能展示层

src.py
admin_view.py
teacher_view.py
student_view.py

核心逻辑层

admin_interface.py
teacher_interface.py
student_interface.py

数据处理层

db_hanlder.py
model.py

项目源码展示

start.py文件

import sys
import os


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

if __name__ == '__main__':
    from core import src
    src.run()
1
2
3
4
5
6
7
8
9
10

conf文件夹下settings.py文件

import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
DB_DIR = os.path.join(BASE_DIR,'db')
1
2
3

lib文件夹下common.py文件

# 三个部分都要调用该装饰器，所以使用有参装饰器
def login_auth(user_type):
    def outer(func_name):
        def inner(*args, **kwargs):
            from core import admin_view, teacher_view, student_view
            module_dict = {
                'admin': admin_view,
                'teacher': teacher_view,
                'student': student_view
            }
            module_name = module_dict.get(user_type)
            if module_name.login_state.get('name'):
                res = func_name(*args, **kwargs)
                return res
            else:
                print("%s暂无登录，请先登录" % user_type)
                module_name.login()

        return inner

    return outer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

core文件夹下src.py文件

from core import admin_view, teacher_view, student_view

module_dict = {
    '1': admin_view,
    '2': teacher_view,
    '3': student_view
}


def run():
    while True:
        print(f"""
        {'=' * 15}选课系统{'=' * 15}
        1.管理员视图
        2.讲师视图
        3.学生视图
        {'=' * 37}
        """)
        choice = input('请输入您想要执行的视图编号>>>:').strip()
        if choice in module_dict:
            module_name = module_dict.get(choice)
            module_name.run()
        else:
            print('暂无该视图编号')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

core文件夹下admin.view.py文件

from interface import admin_interface
from lib import common

login_state = {
    'name': None
}


def register():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    real_pwd = input('real_pwd>>>:').strip()
    if password != real_pwd:
        return
    flag, msg = admin_interface.register_interface(username, password)
    print(msg)


def login():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    flag, msg = admin_interface.login_interface(username, password)
    if flag:
        login_state['name'] = username
    print(msg)

@common.login_auth('admin')
def creat_teacher():
    # 获取讲师信息
    teacher_name = input('teacher_name>>>:').strip()
    # 调用接口
    flag,msg = admin_interface.creat_teacher_interface(teacher_name,login_state.get('name'))
    print(msg)

@common.login_auth('admin')
def creat_school():
    # 获取学校信息
    school_name = input('school_name>>>:').strip()
    school_addr = input('school_addr>>>:').strip()
    # 调用接口创建
    '''只要有管理员才可以创建学校，所以应该把管理员姓名形参传进去，日志需要'''
    flag,msg = admin_interface.creat_school_interface(school_name,school_addr,login_state.get('name'))
    print(msg)

# @common.login_auth('admin')
# def creat_course():
#     # 直接调用接口
#     flag,msg = admin_interface.creat_course_interface(login_state.get('name'))
#     print(msg)

@common.login_auth('admin')
def creat_course():
    flag, msg_or_school_list = admin_interface.get_all_school_interface()
    if not flag:
        print(msg_or_school_list)
    # 选择学校
    while True:
        # 枚举，循环打印学校名称
        for school_id, school_name in enumerate(msg_or_school_list, start=1):
            print(f'学校编号{school_id}     学校名称{school_name}')
        # 选择某个学校
        target_id = input('请输入创建课程的学校编号>>>:').strip()
        if target_id == 'q':
            break
        if not target_id.isdigit():
            print('编号必须是数字')
            continue
        target_id = int(target_id)
        if target_id not in range(1, len(msg_or_school_list) + 1):
            print('编号超出范围')
            continue
        school_name = msg_or_school_list[target_id - 1]
        # 获取课程数据
        course_name = input('请输入课程名称>>>:').strip()
        course_price = input('请输入课程价格>>>:').strip()
        course_period = input('请输入课程周期时间>>>:').strip()
        flag, msg = admin_interface.creat_course_interface(school_name,course_name,course_price,course_period, login_state.get('name'))
        print(msg)


func_dict = {
    '1': register,
    '2': login,
    '3': creat_teacher,
    '4': creat_school,
    '5': creat_course
}


def run():
    while True:
        print(f"""
        {'=' * 15}选课系统{'=' * 15}
        1.注册功能
        2.登录功能
        3.创建讲师
        4.创建学校
        5.创建课程
        {'=' * 37}
        """)
        choice = input('请输入您想要执行的功能编号>>>:').strip()
        if choice == 'q':
            return
        if choice in func_dict:
            func_name = func_dict.get(choice)
            func_name()
        else:
            print('暂无该编号')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

core文件夹下student.view.py文件

from interface import admin_interface
from lib import common

login_state = {
    'name': None
}


def register():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    real_pwd = input('real_pwd>>>:').strip()
    if password != real_pwd:
        return
    flag, msg = admin_interface.register_interface(username, password)
    print(msg)


def login():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    flag, msg = admin_interface.login_interface(username, password)
    if flag:
        login_state['name'] = username
    print(msg)

@common.login_auth('admin')
def creat_teacher():
    # 获取讲师信息
    teacher_name = input('teacher_name>>>:').strip()
    # 调用接口
    flag,msg = admin_interface.creat_teacher_interface(teacher_name,login_state.get('name'))
    print(msg)

@common.login_auth('admin')
def creat_school():
    # 获取学校信息
    school_name = input('school_name>>>:').strip()
    school_addr = input('school_addr>>>:').strip()
    # 调用接口创建
    '''只要有管理员才可以创建学校，所以应该把管理员姓名形参传进去，日志需要'''
    flag,msg = admin_interface.creat_school_interface(school_name,school_addr,login_state.get('name'))
    print(msg)

# @common.login_auth('admin')
# def creat_course():
#     # 直接调用接口
#     flag,msg = admin_interface.creat_course_interface(login_state.get('name'))
#     print(msg)

@common.login_auth('admin')
def creat_course():
    flag, msg_or_school_list = admin_interface.get_all_school_interface()
    if not flag:
        print(msg_or_school_list)
    # 选择学校
    while True:
        # 枚举，循环打印学校名称
        for school_id, school_name in enumerate(msg_or_school_list, start=1):
            print(f'学校编号{school_id}     学校名称{school_name}')
        # 选择某个学校
        target_id = input('请输入创建课程的学校编号>>>:').strip()
        if target_id == 'q':
            break
        if not target_id.isdigit():
            print('编号必须是数字')
            continue
        target_id = int(target_id)
        if target_id not in range(1, len(msg_or_school_list) + 1):
            print('编号超出范围')
            continue
        school_name = msg_or_school_list[target_id - 1]
        # 获取课程数据
        course_name = input('请输入课程名称>>>:').strip()
        course_price = input('请输入课程价格>>>:').strip()
        course_period = input('请输入课程周期时间>>>:').strip()
        flag, msg = admin_interface.creat_course_interface(school_name,course_name,course_price,course_period, login_state.get('name'))
        print(msg)


func_dict = {
    '1': register,
    '2': login,
    '3': creat_teacher,
    '4': creat_school,
    '5': creat_course
}


def run():
    while True:
        print(f"""
        {'=' * 15}选课系统{'=' * 15}
        1.注册功能
        2.登录功能
        3.创建讲师
        4.创建学校
        5.创建课程
        {'=' * 37}
        """)
        choice = input('请输入您想要执行的功能编号>>>:').strip()
        if choice == 'q':
            return
        if choice in func_dict:
            func_name = func_dict.get(choice)
            func_name()
        else:
            print('暂无该编号')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

core文件夹下teacher.view.py文件

from lib import common
from db import models

from interface import teacher_interface
login_state = {
    'name': None
}

def login():
    username = input('username>>>:').strip()
    password = input('password>>>:').strip()
    flag, msg = teacher_interface.login_interface(username, password)
    if flag:
        login_state['name'] = username
    print(msg)


@common.login_auth('teacher')
def check_teach_course():
    flag,msg = teacher_interface.check_teach_course_interface(login_state.get('name'))
    print(msg)


@common.login_auth('teacher')
def select_teach_course():
    # 首先获取所有学校供讲师选择
    flag, msg_or_school_list = teacher_interface.get_all_school_interface()
    if not flag:
        print(msg_or_school_list)
        return
    # 选择学校
    while True:
        # 枚举，循环打印学校名称
        for school_id, school_name in enumerate(msg_or_school_list, start=1):
            print(f'学校编号{school_id}     学校名称{school_name}')
        # 选择某个学校
        target_id = input('请输入创建课程的学校编号>>>:').strip()
        if target_id == 'q':
            break
        if not target_id.isdigit():
            print('编号必须是数字')
            continue
        target_id = int(target_id)
        if target_id not in range(1, len(msg_or_school_list) + 1):
            print('编号超出范围')
            continue
        school_name = msg_or_school_list[target_id - 1]
        # 获取某个学校下课程供老师选择
        flag, msg_or_course_list = teacher_interface.get_all_course_interface(school_name)
        # 循环打印
        while True:
            for course_id,course_name in enumerate(msg_or_course_list,start=1):
                print(f'课程编号{course_id}    课程{course_name}')
            # 选择某个学校
            target_id = input('请输入选择教授的课程编号>>>:').strip()
            if target_id == 'q':
                break
            if not target_id.isdigit():
                print('编号必须是数字')
                continue
            target_id = int(target_id)
            if target_id not in range(1, len(msg_or_course_list) + 1):
                print('编号超出范围')
                continue
            course_name = msg_or_course_list[target_id - 1]
            flag,msg = teacher_interface.select_teach_course_interface(course_name,login_state.get('name'))
            print(msg)


@common.login_auth('teacher')
def check_course_student():
    # 直接展示所有课程，然后展示课程下的学生
    flag,course_name_list = teacher_interface.get_all_course_name_interface()
    if not flag:
        print(course_name_list)
    # 循环打印课程供讲师选择
    while True:
        for course_id,course_name in enumerate(course_name_list,start=1):
            print(f'课程编号{course_id}    课程{course_name}')
        # 选择某个学校
        target_id = input('请输入选择教授的课程编号>>>:').strip()
        if target_id == 'q':
            break
        if not target_id.isdigit():
            print('编号必须是数字')
            continue
        target_id = int(target_id)
        if target_id not in range(1, len(course_name_list) + 1):
            print('编号超出范围')
            continue
        course_name = course_name_list[target_id - 1]
        flag,msg = teacher_interface.check_course_student_interface(course_name)
        print(msg)



@common.login_auth('teacher')
def update_course_score():
    """直接展示所有数据，然后展示课程下的学生，最后选择学生，修改分数"""
    flag,course_name_list = teacher_interface.get_all_course_name_interface()
    if not flag:
        print(course_name_list)
    # 循环打印
    while True:
        # 循环打印所有的学校名称供管理员选择
        for course_id, course_name in enumerate(course_name_list, start=1):
            print("课程编号:%s 课程名称:%s" % (course_id, course_name))
        # 选择学校
        target_id = input('请输入想要查看的课程编号>>>(q):').strip()
        if target_id == 'q':
            return
        if not target_id.isdigit():
            print('编号必须是纯数字')
            continue
        target_id = int(target_id)
        if target_id not in range(1, len(course_name_list) + 1):
            print('编号超出了范围')
            continue
        course_name = course_name_list[target_id - 1]
        flag, student_name_list = teacher_interface.check_course_student_interface(course_name)
        # 循环打印学生姓名
        while True:
            # 循环打印
            for course_id, student_name in enumerate(student_name_list, start=1):
                print("学生编号:%s 学生名称:%s" % (course_id, student_name))
            target_id = input('请输入想要修改分数的学生编号>>>(q):').strip()
            if target_id == 'q':
                return
            if not target_id.isdigit():
                print('编号必须是纯数字')
                continue
            target_id = int(target_id)
            if target_id not in range(1, len(student_name_list) + 1):
                print('编号超出了范围')
                continue
            student_name = student_name_list[target_id - 1]
            score = input('请输入该学生的分数>>>:').strip()
            flag,msg = teacher_interface.update_course_score_interface(student_name,course_name,score,login_state.get('name'))
            print(msg)



func_dic = {
    '1': login,
    '2': check_teach_course,
    '3': select_teach_course,
    '4': check_course_student,
    '5': update_course_score
}

def run():
    while True:
        print(f"""
        {'=' * 15}选课系统{'=' * 15}
        1.登录功能
        2.查看教授课程
        3.选择教授课程
        4.查看课程学生
        5.评判学生分数
        {'=' * 37}
        """)
        choice = input('请输入您想要执行的功能编号>>>:').strip()
        if choice == 'q':
            return
        if choice in func_dic:
            func_name = func_dic.get(choice)
            func_name()
        else:
            print('暂无该编号')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

interface文件夹下admin_interface.py文件

from db import models


def register_interface(username, password):
    # 1.验证用户名是否已存在
    admin_obj = models.Admin.check_obj(username)
    if admin_obj:
        return False, f'{username}已存在'
    # 2.完成注册
    models.Admin(username, password)
    # admin_obj.save_obj()
    return True, f'{username}注册成功'


def login_interface(username, password):
    admin_cls = models.Admin.check_obj(username)  # 
    print(admin_cls)
    if not admin_cls:
        return False, f'{username}不存在'
    if admin_cls.pwd == password:
        return True, f'{username}登录成功'
    return False, f'{username}密码错误'


def creat_teacher_interface(teacher_name, admin_name):
    # 校验老师是否存在
    teacher_obj = models.Teacher.check_obj(teacher_name)
    if teacher_obj:
        return False, f'讲师{teacher_name}已存在'
    # 获取管理员功能
    admin_obj = models.Admin.check_obj(admin_name)
    admin_obj.creat_teacher(teacher_name)
    return True, f'管理员：{admin_name}   创建了老师账户：{teacher_name}'


def creat_school_interface(school_name, school_addr, admin_name):
    # 校验学校是否存在
    school_obj = models.School.check_obj(school_name)
    if school_obj:
        return False, f'学校{school_name}已存在'
    # 获取管理员功能
    admin_obj = models.Admin.check_obj(admin_name)
    admin_obj.creat_school(school_name, school_addr)
    return True, f"管理员{admin_name}       创建了学校{school_name}       地点在{school_addr}"

def get_all_school_interface():
    school_obj_list = models.School.get_all_obj()   # [1,2,3]
    if not school_obj_list:
        return False, '当前没有创建任何学校'
    return True, school_obj_list

def creat_course_interface(school_name, course_name, course_price, course_period, admin_name):
    # 1.查看当前课程是否存在
    """
    如何确保课程名称不冲突 不同学校可以有相同课程
        提议:在课程名的前面拼接学校名称
    """
    course_name = f'{school_name}_{course_name}'
    is_course_obj = models.Course.check_obj(course_name)
    if is_course_obj:
        return False, f'当前课程{course_name}已存在'
    admin_obj = models.Admin.check_obj(admin_name)
    admin_obj.creat_course(course_name, course_price, course_period,school_name)
    school_obj = models.School.check_obj(school_name)
    school_obj.course_list.append(course_name)
    school_obj.save_obj()
    return True, f'管理员:{admin_name}     在学校:{school_name}     创建了课程:{course_name}'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

interface文件夹下student_interface.py文件

from db import models


def register_interface(username, password):
    # 1.验证用户名是否已存在
    admin_obj = models.Student.check_obj(username)
    if admin_obj:
        return False, f'{username}已存在'
    # 2.完成注册
    models.Student(username, password)
    return True, f'{username}注册成功'


def login_interface(username, password):
    admin_cls = models.Student.check_obj(username)  # 
    print(admin_cls)
    if not admin_cls:
        return False, f'{username}不存在'
    if admin_cls.pwd == password:
        return True, f'{username}登录成功'
    return False, f'{username}密码错误'

def get_all_school_interface():
    school_obj_list = models.School.get_all_obj()   # [1,2,3]
    if not school_obj_list:
        return False, '当前没有创建任何学校'
    return True, school_obj_list

def choise_school_interface(student_name):
    student_obj = models.Student.check_obj(student_name)
    if not student_obj.school:
        return True,f'学员{student_name}还没选择学校'
    return False,f'学院{student_name}已选择学校{student_obj.school_name}'

def select_school_interface(school_name,student_name):
    student_obj = models.Student.check_obj(student_name)
    student_obj.school = school_name
    student_obj.save_obj()
    return True,f'学员{student_name}    选择去{school_name}学习'

def get_all_course_interface():
    course_obj_list = models.Course.get_all_obj()   # [1,2,3]
    if not course_obj_list:
        return False, '当前没有创建任何课程'
    return True, course_obj_list

def choise_course_interface(student_name):
    student_obj = models.Student.check_obj(student_name)
    if not student_obj.course_list:
        return True, f'学员{student_name}还没选择课程'
    return False, f'学员{student_name}已选择课程{student_obj.course_list}'

def select_course_interface(course_name,student_name):
    student_obj = models.Student.check_obj(student_name)
    if course_name in student_obj.course_list:
        return False,f'你已经选过该课程'
    student_obj.course_list.append(course_name)
    # 选课后分数默认值是0
    student_obj.score[course_name] = None
    student_obj.save_obj()
    # 编辑课程类中课程列表对象
    course_obj = models.Course.check_obj(course_name)
    course_obj.course_student_list.append(student_name)
    course_obj.save_obj()            # ['上海中医药大学_chinese', '北京大学_math', '山西大学_english']
    return True, f'学员:{student_name},选择了课程:{course_name}'

def check_socore_interface(student_name):
    student_obj = models.Student.check_obj(student_name)
    print(student_obj.score)
    return True,student_obj.score

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

interface文件夹下teacher_interface.py文件

from db import models


def login_interface(username, password):
    admin_cls = models.Teacher.check_obj(username)  # 
    if not admin_cls:
        return False, f'{username}不存在'
    # print(admin_cls.pwd)    # 默认密码为123
    if admin_cls.pwd == int(password):
        return True, f'{username}登录成功'
    return False, f'{username}密码错误'

def check_teach_course_interface(teacher_name):
    teacher_obj = models.Teacher.check_obj(teacher_name)
    if not teacher_obj.teach_course:
        return False,f'讲师{teacher_name}还未选择教授任何一门课程！'
    return True,teacher_obj.teach_course


def get_all_school_interface():
    school_obj_list = models.School.get_all_obj()   # [1,2,3]
    if not school_obj_list:
        return False, '当前没有创建任何学校'
    return True, school_obj_list

def get_all_course_interface(school_name):
    school_obj = models.School.check_obj(school_name)
    return True,school_obj.course_list


def select_teach_course_interface(course_name,teacher_name):
    teacher_obj = models.Teacher.check_obj(teacher_name)
    if course_name in teacher_obj.teach_course:
        return False, f'您已经选择了教授该课程:{course_name}'
    teacher_obj.teach_course.append(course_name)
    teacher_obj.save_obj()
    return True, f'您已经成功选择教授课程:{course_name}'

def get_all_course_name_interface():
    course_obj_list = models.Course.get_all_obj()   # [1,2,3]
    if not course_obj_list:
        return False, '当前没有创建任何学校'
    return True, course_obj_list

def check_course_student_interface(course_name):
    course_obj = models.Course.check_obj(course_name)
    return True,course_obj.course_student_list


def update_course_score_interface(student_name,course_name,score,teacher_name):
    # 添加分数数据到学生对象中
    student_obj = models.Student.check_obj(student_name)
    student_obj.score[course_name] = score
    student_obj.save_obj()
    # 添加学生分数数据到课程对象中
    course_obj = models.Course.check_obj(course_name)
    course_obj.course_score_dict[student_name] = score
    course_obj.save_obj()
    return True,f'讲师{teacher_name}   将课程{course_name}下的学生{student_name}分数修改为{score}'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

db文件夹下db_handler.py文件

import os
from conf import settings
import pickle


def save_obj(obj):
    # 由于db目录下将来需要存各个角色的文件数据，为了便于管理
    # 类名叫什么文件夹的名字就叫什么
    admin_path = os.path.join(settings.DB_DIR, obj.__class__.__name__)
    if not os.path.exists(admin_path):
        os.mkdir(admin_path)
    # 1.拼接对象文件路径
    obj_file_path = os.path.join(admin_path, obj.name)
    # 2.pickle模块写入
    with open(obj_file_path, 'wb')as f:
        pickle.dump(obj, f)


def select_obj(cls, username):
    admin_path = os.path.join(settings.DB_DIR, cls.__name__)
    if not os.path.exists(admin_path):
        os.mkdir(admin_path)
    # 1.拼接对象文件路径
    obj_file_path = os.path.join(admin_path, username)
    # 如果路径存在，则获取对象，增强方法兼容性
    if os.path.exists(obj_file_path):
        # 2.pickle模块读
        with open(obj_file_path, 'rb')as f:
            data = pickle.load(f)
            return data


def select_all_obj(cls):
    # 1.拼接类对象的文件夹路径
    dir_path = os.path.join(settings.DB_DIR, cls.__name__)
    if not os.path.exists(dir_path):
        os.mkdir(dir_path)
    # 2.获取文件夹路径下所有的文件名称
    return os.listdir(dir_path)




if __name__ == '__main__':
    class MyClass:
        pass
    print(os.listdir(r'D:\pythonProject\day35_ccs\db\School'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

db文件夹下models.py文件

from db import db_handler


# 定义一个父类（所有子类所共有的方法）
class BaseClass(object):
    def save_obj(self):
        db_handler.save_obj(self)

    @classmethod
    def check_obj(cls, username):
        return db_handler.select_obj(cls, username)

    @classmethod
    def get_all_obj(cls):
        return db_handler.select_all_obj(cls)


class Admin(BaseClass):
    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd
        self.save_obj()

    def creat_school(self, school_name, school_addr):
        School(school_name, school_addr)

    def creat_teacher(self, teacher_name,pwd=123):
        Teacher(teacher_name,pwd)

    def creat_course(self, course_name, course_price, course_period, school_name):
        Course(course_name, course_price, course_period, school_name)

class Student(BaseClass):
    def __init__(self,name,pwd):
        self.name = name
        self.pwd = pwd
        self.school = None
        self.score = {}    # {‘课程1’：100，‘课程2’：90}
        self.course_list = []
        self.save_obj()


class School(BaseClass):
    def __init__(self, name, addr):
        self.name = name  # 此处name不可以取值school_name，原因是在db_handler中用到了obj.name
        self.addr = addr
        self.course_list = []
        self.save_obj()




class Teacher(BaseClass):
    def __init__(self, name,  pwd):
        self.name = name
        self.pwd = pwd
        self.teach_course = []
        self.save_obj()

class Course(BaseClass):
    def __init__(self, course_name, course_price, course_period, school_name):
        self.name = course_name
        self.course_price = course_price
        self.course_period = course_period
        self.school = school_name
        self.course_student_list = []
        self.course_score_dict = {}  # {'学生1':分数1, '学生2':分数2}
        self.save_obj()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

相关阅读:
【Java8】对JSONArray 按指定字段排序，升序和倒序，经典
 如何使用Jenkins持续集成构建接口自动化测试--配置邮件通知
 SpringBoot+RabbitMQ集成（自动创建队列）
SQLServer添加Oracle链接服务器
 【优化覆盖】基于matlab果蝇算法求解无线传感器覆盖优化问题【含Matlab源码 2215期】
VS中属性页各种包含目录的区别
 docker-machine常用
 IO流（IO Stream）
数据结构题目收录（二十一）
售价5美元的树莓派 Pico 2推出，搭载RP2350 双核 RISC-V 或 Arm Cortex-M33 微控制器
原文地址：https://blog.csdn.net/DiligentGG/article/details/126144588