学生选课系统python编程 python做选课系统

今日内容概要

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

选课系统项目分析

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()

conf文件夹下settings.py文件

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

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

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('暂无该视图编号')

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('暂无该编号')

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('暂无该编号')

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('暂无该编号')

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)  # <db.models.Admin object at 0x000001DCD60AD668>
    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}'

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)  # <db.models.Admin object at 0x000001DCD60AD668>
    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

interface文件夹下teacher_interface.py文件

from db import models


def login_interface(username, password):
    admin_cls = models.Teacher.check_obj(username)  # <db.models.Admin object at 0x000001DCD60AD668>
    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}'

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'))

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()