python项目实战（二）：选课系统（采用面向对象思想开发）

下面是小凰凰的简介，看下吧！
人生态度：珍惜时间，渴望学习，热爱音乐，把握命运，享受生活
学习技能：网络 -> 云计算运维 -> python全栈( 当前正在学习中)
后期会不断更新python全栈学习笔记，秉着质量博文为原则，写好每一篇博文。
有相关技能问题的可以私聊，我们一起学习，一起进步，认可我的话，不妨点个关注！

一、项目目录展示

二、项目源码展示

1、readme.md

角色（类）:学校、学员、课程、讲师、管理员
##要求:
    1. 创建北京、上海 2个校区
    2. 创建云计算运维 , python全栈 , go语言开发 3个课程 ， 云计算运维\python全栈 在北京开， go在上海开
    3. 课程（代表了班级）包含，周期，价格，课程需要和学生建联(多对多)，需要和老师建立联系（一个校区的课程是1对1），需要和校区建立联系（多对1）
    4. 创建学校时，顺便指定学校开设的课程（关联课程）
    5. 讲师选择任课校区及校区中的课程,讲师关联课程和校区，一个讲师只能教一个课程，一个课程只能被一个老师教
    5. 学员登录后，可以任意选修学校中的课程 
    6.1 学员视图， 可以选课， 查看课程成绩
    6.2 讲师视图， 选择任教课程，查看任教课程，查看课程中所有学生的成绩，修改指定学生成绩 
    6.3 管理员视图， 创建校区，创建课程
    
    7. 上面的操作产生的数据都通过pickle序列化保存到文件里
本次实验我依旧采用项目开发三层架构，用户视图层、逻辑接口层、数据处理层

##采用python3.7解释器

2、settings.py

'''
配置
'''
import os

# 指定账户数据基目录
BASE_DIR = os.path.join(
    os.path.abspath('.'),'db'
)

# 指定登录密码的盐
SALT = 'fuck'

# 指定加密传输的算法
ENCRIPT_ALGO = 'md5'

# 指定日志文件路径
LOG_PATH = os.path.join(
    os.path.abspath('.'),'log','operation.log'
)

# 配置日志字典
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]''[%(levelname)s][%(message)s]'

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

test_format = '%(asctime)s] %(message)s'

LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
        'test': {
            'format': test_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到文件的日志,收集info及以上的日志
        'file': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件,日志轮转
            'formatter': 'standard',
            'filename': LOG_PATH,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        'operation': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

3、admin_view.py

'''
管理员视图
'''
from interface import admin_interface
# 创建校区
def create_school():
    while True:
        school_name = input('请输入校区的名字:')
        school_course = input('请输入该校区开设的课程名:').strip()
        school_course = school_course.split(',')
        res = admin_interface.create_school(school_name,school_course)
        flag = res[0]
        msg = res[1]
        print(msg)
        if flag:
            break
        else:
            continue

# 创建课程
def create_course():
    while True:
        course_name = input('请输入添加的课程名：').strip()
        course_fee = input('请输入课程费用：').strip()
        course_duration = input('请输入课程时长：').strip()
        re = input('请确认课程信息是否准确无误(yes or no ?):').strip()
        if re != 'yes':
            continue
        res = admin_interface.create_course(course_name,course_fee,course_duration)
        flag = res[0]
        msg = res[1]
        print(msg)
        if flag:
            status = input('是否继续添加课程（yes or no ?）:').strip()
            if status == 'yes':
                continue
            else:
                break
        else:
            continue
def admin():
    admin_func_dir = {
        'exit':['退出后台管理系统',None],
        '1':['创建校区',create_school],
        '2':['创建课程',create_course],
    }
    def printing():
        print('---------- 欢迎进入后台管理系统 ----------')
        for key in admin_func_dir:
            print(key,admin_func_dir[key][0])
        print('----------------- end -----------------')
    printing()
    while True:
        num = input('请输入您要选择的功能编号 >>>').strip()
        if num == 'exit':
            break
        elif num == 'ls':
            printing()
            continue
        elif num == '':
            continue
        elif num in admin_func_dir:
            admin_func_dir[num][1]()
            continue
        else:
            print('功能编号不存在!')
            continue

4、src.py

'''
主视图
'''
from core import admin_view,stu_view,tea_view
from interface import admin_interface,stu_interface,tea_interface
from lib import common
login_user = None
# 下面这三个函数（tea、stu、adm）主要是做登录、注册视图，登录成功则转到相应的子视图
def tea():
    def register():
        while True:
            username = input('请输入您的账户名：').strip()
            password = input('请输入您的密码：').strip()
            re_password = input('请再次确定您的密码：').strip()
            name = input('请输入您的姓名：').strip()
            email = input('请输入您的邮箱地址：').strip()
            if re_password != password:
                print('密码确认错误!')
                continue
            password = common.get_pwd_hash(password)
            res = tea_interface.register_interface(username,password,name,email)
            flag = res[0]
            msg = res[1]
            if flag:
                print(msg)
                break
            else:
                print(msg)
                continue
    def login():
        while True:
            username = input('请输入您的用户名：').strip()
            password = input('请输入您的密码：').strip()
            password = common.get_pwd_hash(password)
            res = tea_interface.login_interface(username,password)
            flag = res[0]
            msg = res[1]
            if flag == 0:
                print(msg)
                break
            elif flag:
                print(msg)
                global login_user
                login_user = username
                tea_view.teacher()
                return True
            else:
                print(msg)
                continue
    func_dir = {
        '1': register,
        '2': login
    }
    def printing():
        print('''
        ------------- 欢迎进入教师登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end -------------------
        ''')
    printing()
    while True:
        num = input('请输入您的选择 >>>').strip()
        if num == 'ls':
            printing()
            continue
        elif num == '':
            continue
        elif num == 'exit':
            break
        elif num in func_dir:
            res = func_dir[num]()
            if res:
                break
            continue
        else:
            print('输入编号不存在!')
            continue
def stu():
    def register():
        while True:
            username = input('请输入您的账户名：').strip()
            password = input('请输入您的密码：').strip()
            re_password = input('请再次确定您的密码：').strip()
            name = input('请输入您的姓名：').strip()
            email = input('请输入您的邮箱地址：').strip()
            if re_password != password:
                print('密码确认错误!')
                continue
            password = common.get_pwd_hash(password)
            res = stu_interface.register_interface(username,password,name,email)
            flag = res[0]
            msg = res[1]
            print(msg)
            if flag:
                break
            else:
                continue
    def login():
        while True:
            username = input('请输入您的用户名：').strip()
            password = input('请输入您的密码：').strip()
            password = common.get_pwd_hash(password)
            res = stu_interface.login_interface(username,password)
            flag = res[0]
            msg = res[1]
            print(msg)
            if flag == 0:
                break
            elif flag:
                global login_user
                login_user = username
                stu_view.student()
                return True
            else:
                continue
    func_dir = {
        '1': register,
        '2': login
    }
    def printing():
        print('''
        ------------- 欢迎进入学生登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end -------------------
        ''')
    printing()
    while True:
        num = input('请输入您的选择 >>>').strip()
        if num == 'ls':
            printing()
            continue
        elif num == '':
            continue
        elif num == 'exit':
            break
        elif num in func_dir:
            res = func_dir[num]()
            if res:
                break
            continue
        else:
            print('输入编号不存在!')
            continue
def adm():
    # 管理员注册
    def register():
        while True:
            username = input('请输入您的用户名：').strip()
            password = input('请输入您的密码：').strip()
            re_password = input('请再次确认您的密码：').strip()
            email = input('请输入您的邮箱：').strip()
            if not password == re_password:
                print('确认密码失败!')
                return
            else:
                password = common.get_pwd_hash(password)
                res = admin_interface.register_interface(username,password,email)
                flag = res[0]
                msg = res[1]
                print(msg)
                if flag:
                    break
                else:
                    continue
    # 管理员登录
    def login():
        while True:
            username = input('请输入您的用户名：').strip()
            password = input('请输入您的密码：').strip()
            password = common.get_pwd_hash(password)
            res = admin_interface.login_interface(username,password)
            flag = res[0]
            msg = res[1]
            print(msg)
            if flag == 0:
                break
            elif flag:
                global login_user
                login_user = username
                admin_view.admin()
                return True
            else:
                continue
    func_dir = {
        '1':register,
        '2':login
    }
    def printing():
        print('''
        ------------- 欢迎进入管理员登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end ---------------------
        ''')
    printing()
    while True:
        num = input('请输入您的选择 >>>').strip()
        if num == 'ls':
            printing()
            continue
        elif num == '':
            continue
        elif num == 'exit':
            break
        elif num in func_dir:
            res = func_dir[num]()
            if res:
                break
            continue
        else:
            print('输入编号不存在!')
            continue
def run():
    func_dic = {
        '0':adm,
        '1':stu,
        '2':tea
    }
    def printing():
        print('''
                ------------- 欢迎进入选课系统 -------------
                                0   后台管理系统
                                1   学生系统
                                2   教师系统
                ------------------ end -------------------
                ''')
    printing()
    while True:
        num = input('请输入您要进入的系统编号 >>>').strip()
        if num == '':
            continue
        elif num == 'ls':
            printing()
            continue
        elif num in func_dic:
            func_dic[num]()
            continue
        else:
            print('输入编号不存在!')
            continue

5、stu_view.py

'''
学生视图
'''
from interface import stu_interface

# 查看校区课程
def check_school_course():
    while True:
        school_name = input('请输入您要查询的校区：').strip()
        res = stu_interface.check_school_course_interface(school_name)
        if isinstance(res,tuple):
            print(res[1])
            continue
        for key in res.keys():
            print(key,'{}¥'.format(res[key][0]),res[key][1])
        break

# 查看课程成绩
def check_course_grade():
    while True:
        school_name = input('请输入查分课程所在的校区：').strip()
        course_name = input('请输入您想要查询分数的课程：').strip()
        res = stu_interface.check_course_grade_interface(school_name,course_name)
        flag = res[0]
        msg = res[1]
        if flag:
            print('您{}的{}课程，成绩为{}分'.format(school_name,course_name,msg))
            break
        else:
            print(msg)
            continue

# 选修课程
def select_course():
    while True:
        school_name = input('请输入您要入学的校区：').strip()
        course_name = input('请输入您要选修的课程名：').strip()
        res = stu_interface.select_course_interface(school_name,course_name)
        flag = res[0]
        msg = res[1]
        print(msg)
        if flag:
            break
        else:
            continue

# 查看选修的课程
def check_select_course():
    res = stu_interface.check_select_course_interface()
    for k in res.keys():
        print(k,res[k])

def student():
    stu_func_dir = {
        'exit':['退出学生选课系统',None],
        '1':['查询校区课程',check_school_course],
        '2':['选课功能',select_course],
        '3':['查看所选课程',check_select_course],
        '4':['查看课程成绩',check_course_grade]
    }
    def printing():
        print('---------- 欢迎进入学生选课系统 ----------')
        for key in stu_func_dir:
            print(key,stu_func_dir[key][0])
        print('----------------- end -----------------')
    printing()
    while True:
        num = input('请输入您要选择的功能编号 >>>').strip()
        if num == 'exit':
            break
        elif num == 'ls':
            printing()
            continue
        elif num == '':
            continue
        elif num in stu_func_dir:
            stu_func_dir[num][1]()
            continue
        else:
            print('功能编号不存在!')
            continue

6、tea_view.py

'''
老师视图
'''
from interface import tea_interface
# 查看可任教课程
def check_teachable_course():
    while True:
        school_name = input('请输入您要查询的校区：').strip()
        res = tea_interface.check_teachable_course_interface(school_name)
        if isinstance(res,tuple):
            print(res[1])
            continue
        for key in res:
            print(key,res[key])
        break

# 查看当前任教课程
def check_teach_course():
    res = tea_interface.check_teach_course_interface()
    print(res)

# 选择任教课程
def select_teach_course():
    while True:
        school_name = input('请输入您想要任教的校区：').strip()
        course_name = input('请输入您想要任教的课程：').strip()
        res = tea_interface.select_teach_course_interface(school_name,course_name)
        flag = res[0]
        msg = res[1]
        print(msg)
        if flag:
            break
        elif flag == 0:
            break
        else:
            continue

# 查看学员成绩
def check_stu_grade():
    res = tea_interface.check_stu_grade_interface()
    if isinstance(res,tuple):
        print(res[1])
        return
    print('学生姓名   成绩')
    print('--------------')
    for k in res:
        print(k,'  ','{}分'.format(res[k]))

# 修改学员成绩
def alter_stu_grade():
    student_name = input('请输入需要修改成绩的学生姓名：').strip()
    grade = input('请输入该学生成绩：').strip()
    tea_interface.alter_stu_grade_interface(student_name,grade)

def teacher():
    tea_func_dir = {
        'exit':['退出教师系统',None],
        '0':['查看可任教课程',check_teachable_course],
        '1':['选择任教课程',select_teach_course],
        '2':['查看当前任教课程',check_teach_course],
        '3':['查看学员成绩',check_stu_grade],
        '4':['修改学员成绩',alter_stu_grade]
    }
    def printing():
        print('---------- 欢迎进入教师操作系统 ----------')
        for key in tea_func_dir:
            print(key,tea_func_dir[key][0])
        print('----------------- end -----------------')
    printing()
    while True:
        num = input('请输入您要选择的功能编号 >>>').strip()
        if num == 'exit':
            break
        elif num == 'ls':
            printing()
            continue
        elif num == '':
            continue
        elif num in tea_func_dir:
            tea_func_dir[num][1]()
            continue
        else:
            print('功能编号不存在!')
            continue

7、db_handler.py

'''
数据处理层
'''
import pickle
import os
from conf import settings

# 存对象
def save_data(obj,data_dir,username):
    data_path = os.path.join(
        settings.BASE_DIR, data_dir, '{}.pkl'.format(username)
    )
    with open(data_path,mode='wb') as write_f:
        pickle.dump(obj,write_f)

# 取对象
def select_data(username,data_dir):
    data_path = os.path.join(
        settings.BASE_DIR, data_dir, '{}.pkl'.format(username)
    )
    try:
        with open(data_path,mode='rb') as read_f:
            res = pickle.load(read_f)
            return res
    except FileNotFoundError:
        return '{}不存在'.format(username)

8、models.py

'''
存放类的区域
'''
from db import db_handler
# 管理员类
class adm:
    def __init__(self,username,password,email_addr):
        self.username = username
        self.password = password
        self.email_addr = email_addr
    def save(self):
        db_handler.save_data(self,'admin_data',self.username)

# 学生类
class stu:
    def __init__(self,username,password,name,email_addr):
        self.username = username
        self.password = password
        self.name = name
        self.email_addr = email_addr
        self.course_dic = {}
    def save(self):
        db_handler.save_data(self,'user_data',self.username)
    def related(self,school_name,course_name):
        self.course_dic[school_name] = course_name

# 教师类
class tea:
    def __init__(self,username,password,name,email_addr):
        self.username = username
        self.password = password
        self.name = name
        self.email_addr = email_addr
        self.teach_course = None
    def save(self):
        db_handler.save_data(self,'teacher_data',self.username)
    def related_course(self,course_name):
        self.teach_course = course_name

# 课程类
class cour:
    def __init__(self,course_name,course_fee,course_duration):
        self.course_name = course_name
        self.course_fee = course_fee
        self.course_duration = course_duration
        self.student_dic = {}
        self.course_teacher = None
    def save(self):
        db_handler.save_data(self,'course_data',self.course_name)
    def related_stu(self,student_name):
        self.student_dic[student_name] = 0
    def related_tea(self,teacher_name):
        self.course_teacher = teacher_name

# 学校类
class scl:
    def __init__(self,school_name):
        self.school_name = school_name
        self.course_dic = {}
    def related(self,course_obj):
        self.course_dic[course_obj.course_name] = [course_obj.course_fee,course_obj.course_duration]
    def save(self):
        db_handler.save_data(self,'school_data',self.school_name)

9、admin_interface.py

'''
管理员接口层
'''
import os
import time
from db import models
from db import db_handler
from lib import common
from core import admin_view
from conf import settings
import logging.config
logging.config.dictConfig(settings.LOGGING_DIC)
logger1=logging.getLogger('operation')
# 注册接口
def register_interface(username,password,email):
    admindata_path = os.path.join(
        settings.BASE_DIR,'admin_data','{}.pkl'.format(username)
    )
    if os.path.exists(admindata_path):
        return False,'管理员{}已存在!'.format(username)
    else:
        admin = models.adm(username,password,email)
        admin.save()
        msg = '管理员{}注册成功!'.format(username)
        logger1.warning(msg)
        return True,msg

# 登录接口
def login_interface(username,password):
    data_path = os.path.join(
        settings.BASE_DIR, 'admin_data', '{}.pkl'.format(username)
    )
    if os.path.exists(data_path):
        obj = db_handler.select_data(username,'admin_data')
        if obj.password == password:
            code = common.make_code(5)
            common.send_mail(obj.email_addr,code)
            viti_code = input('请输入邮箱验证码：').strip()
            if not code == viti_code:
                return False,'邮箱验证码错误,登录失败!'
            else:
                return True,'登录成功!'
        else:
            return False,'密码错误,登录失败!'
    else:
        return 0,'账号不存在!'
# 创建课程接口
def create_course(course_name,course_fee,course_duration):
    flag = os.path.exists(os.path.join(
        settings.BASE_DIR,'course_data','{}.pkl'.format(course_name)
    ))
    if flag:
        return False,'{}课程已存在!'.format(course_name)
    course = models.cour(course_name,course_fee,course_duration)
    course.save()
    msg = '成功创建{}课程!'.format(course_name)
    logger1.warning(msg)
    return True,msg

# 创建校区接口
def create_school(school_name,school_course):
    flag = os.path.exists(os.path.join(
        settings.BASE_DIR, 'school_data', '{}.pkl'.format(school_name)
    ))
    if flag:
        return False,'{}已存在!'.format(school_name)
    school_obj = models.scl(school_name)
    for i in school_course:
        flag = os.path.exists(os.path.join(
            settings.BASE_DIR, 'course_data', '{}.pkl'.format(i)
        ))
        if not flag:
            print('{}课程不存在,正在启动添加课程程序...'.format(i))
            time.sleep(2)
            admin_view.create_course()
        course_obj = db_handler.select_data(i, 'course_data')
        school_obj.related(course_obj)
    school_obj.save()
    msg = '成功创建{}!'.format(school_name)
    logger1.warning(msg)
    return True,msg

10、stu_interface.py

'''
学生接口层
'''
import os
from db import models
from db import db_handler
from lib import common
from core import src
from conf import settings
import logging.config
logging.config.dictConfig(settings.LOGGING_DIC)
logger1=logging.getLogger('operation')
# 注册接口
def register_interface(username,password,name,email):
    userdata_path = os.path.join(
        settings.BASE_DIR,'user_data','{}.pkl'.format(username)
    )
    if os.path.exists(userdata_path):
        return False,'学生{}已存在!'.format(name)
    else:
        student = models.stu(username,password,name,email)
        student.save()
        msg = '{}注册成功!'.format(username)
        logger1.info(msg)
        return True,msg

# 登录接口
def login_interface(username,password):
    data_path = os.path.join(
        settings.BASE_DIR, 'user_data', '{}.pkl'.format(username)
    )
    if os.path.exists(data_path):
        obj = db_handler.select_data(username,'user_data')
        if obj.password == password:
            code = common.make_code(5)
            common.send_mail(obj.email_addr,code)
            viti_code = input('请输入邮箱验证码：').strip()
            if not code == viti_code:
                return False,'邮箱验证码错误,登录失败!'
            else:
                return True,'登录成功!'
        else:
            return False,'密码错误,登录失败!'
    else:
        return 0,'账号不存在!'

# 查询校区课程接口
def check_school_course_interface(school_name):
    flag = os.path.exists(os.path.join(
        settings.BASE_DIR, 'school_data', '{}.pkl'.format(school_name)
    ))
    if not flag:
        return False,'您查询的校区不存在!'
    school_obj = db_handler.select_data(school_name,'school_data')
    course_dic = school_obj.course_dic
    return course_dic

# 选修课程接口
def select_course_interface(school_name,course_name):
    school_obj = db_handler.select_data(school_name, 'school_data')
    if isinstance(school_obj,str):
        return False,'{}不存在!'.format(school_name)
    if course_name not in school_obj.course_dic:
        return False,'{}不存在{}课程'.format(school_name,course_name)
    user_obj = db_handler.select_data(src.login_user,'user_data')
    user_obj.related(school_name,course_name)
    user_obj.save()
    student_name = user_obj.name
    course_obj = db_handler.select_data(course_name,'course_data')
    course_obj.related_stu(student_name)
    course_obj.save()
    msg = '成功选修{}的{}课程!'.format(school_name,course_name)
    logger1.info(msg)
    return True,msg

# 查看已选修课程接口
def check_select_course_interface():
    user_obj = db_handler.select_data(src.login_user,'user_data')
    course_dic = user_obj.course_dic
    return course_dic

# 查询课程分数接口
def check_course_grade_interface(school_name,course_name):
    user_obj = db_handler.select_data(src.login_user,'user_data')
    course_dic = user_obj.course_dic
    if school_name not in course_dic or course_dic[school_name] != course_name:
        return False,'您输入的校区或课程有误,请确认后重新查询!'
    course_obj = db_handler.select_data(course_name,'course_data')
    student_dic = course_obj.student_dic
    return True,student_dic[user_obj.name]

11、tea_interface.py

'''
教师接口层
'''
import os
from db import models
from db import db_handler
from lib import common
from core import src
from interface import stu_interface
from conf import settings
import logging.config
logging.config.dictConfig(settings.LOGGING_DIC)
logger1=logging.getLogger('operation')
# 注册接口
def register_interface(username,password,name,email):
    userdata_path = os.path.join(
        settings.BASE_DIR,'teacher_data','{}.pkl'.format(username)
    )
    if os.path.exists(userdata_path):
        return False,'教师{}已存在!'.format(name)
    else:
        admin_obj = db_handler.select_data('admin','admin_data')
        email_addr = admin_obj.email_addr
        code = common.make_code(5)
        common.send_mail(email_addr,code)
        viti_code = input('请输入讲师授权码：').strip()
        if code != viti_code:
            return False,'讲师账号注册失败，请联系管理员admin获取正确的验证码!'
        teacher = models.tea(username,password,name,email)
        teacher.save()
        msg = '教师{}注册成功!'.format(name)
        logger1.warning(msg)
        return True,msg

# 登录接口
def login_interface(username,password):
    data_path = os.path.join(
        settings.BASE_DIR, 'teacher_data', '{}.pkl'.format(username)
    )
    if os.path.exists(data_path):
        obj = db_handler.select_data(username,'teacher_data')
        if obj.password == password:
            code = common.make_code(5)
            common.send_mail(obj.email_addr,code)
            viti_code = input('请输入邮箱验证码：').strip()
            if not code == viti_code:
                return False,'邮箱验证码错误,登录失败!'
            else:
                return True,'登录成功!'
        else:
            return False,'密码错误,登录失败!'
    else:
        return 0,'账号不存在!'

# 查看校区可任教课程
def check_teachable_course_interface(school_name):
    res = stu_interface.check_school_course_interface(school_name)
    if isinstance(res, tuple):
        return res
    teachable_course_dic = {}
    for key in res:
        course_obj = db_handler.select_data(key,'course_data')
        if course_obj.course_teacher == None:
            teachable_course_dic[key] = res[key][1]
    return teachable_course_dic
# 选择任教课程接口
def select_teach_course_interface(school_name,course_name):
    school_obj = db_handler.select_data(school_name, 'school_data')
    if isinstance(school_obj, str):
        return False, '{}不存在!'.format(school_name)
    if course_name not in school_obj.course_dic:
        return False, '{}不存在{}课程'.format(school_name, course_name)
    course_obj = db_handler.select_data(course_name,'course_data')
    teacher_obj = db_handler.select_data(src.login_user,'teacher_data')
    if course_obj.course_teacher != None:
        return False,'此课程已有老师任教!'
    if teacher_obj.teach_course != None:
        return 0,'您最多只能选择一门课程任教'
    teacher_obj.teach_course = course_name
    course_obj.course_teacher = teacher_obj.name
    teacher_obj.save()
    course_obj.save()
    msg = '尊敬的{}老师您好,恭喜您选择任教课程{}成功!'.format(teacher_obj.name,course_name)
    logger1.warning(msg)
    return True,msg

# 查看学生成绩接口
def check_stu_grade_interface():
    teacher_obj = db_handler.select_data(src.login_user,'teacher_data')
    teach_course = teacher_obj.teach_course
    if teach_course == None:
        return False,'您当前任教任何课程,暂无学生!'
    course_obj = db_handler.select_data(teach_course,'course_data')
    student_dic = course_obj.student_dic
    return student_dic

# 修改学生成绩接口
def alter_stu_grade_interface(student_name,grade):
    teacher_obj = db_handler.select_data(src.login_user, 'teacher_data')
    teach_course = teacher_obj.teach_course
    if teach_course == None:
        return False, '您当前任教任何课程,暂无学生!'
    course_obj = db_handler.select_data(teach_course, 'course_data')
    student_dic = course_obj.student_dic
    if student_name not in student_dic:
        print('暂无此学生!')
        return
    student_dic[student_name] = grade
    msg = '{}老师修改{}的成绩为{}分'.format(teacher_obj.name,student_name,grade)
    logger1.info(msg)
    course_obj.save()

# 查看任教的课程
def check_teach_course_interface():
    teacher_obj = db_handler.select_data(src.login_user,'teacher_data')
    if teacher_obj.teach_course == None:
        return '暂无任教课程!'
    return '您当前的任教课程：{}'.format(teacher_obj.teach_course)

12、common.py

'''
公共方法区
'''
import smtplib
import random
import time
import hashlib
import sys
from email.mime.text import MIMEText
from email.header import Header
from email.utils import formataddr
def get_pwd_hash(password):
    from conf.settings import SALT as salt
    from conf.settings import ENCRIPT_ALGO
    try:
        m = getattr(hashlib,ENCRIPT_ALGO)()
    except AttributeError:
        print('指定的加密算法不存在,程序正在退出...')
        time.sleep(2)
        sys.exit()
    m.update(salt.encode('utf-8'))
    m.update(password.encode('utf-8'))
    return m.hexdigest()

# 生成随机验证码
def make_code(n=6):
    res = ''
    for i in range(n):
        num = str(random.randint(1, 9))  # 生成随机1-9，并强转成字符串格式
        num2 = str(random.randint(1, 9))
        big_char = chr(random.randint(65, 90))  # 生成随机A-Z字母
        small_char = chr(random.randint(97,122)) # 随机生成a-z字母
        get_str = random.choice([num,num2,big_char,small_char])  # 从生成的数字和字母选择一个进行字符串拼接
        res += get_str
    return res

# 传入接收邮件账号和随机验证码，发送邮件
def send_mail(username_recv,code):
    sender = 'za******[email protected]'
    receivers = '{}'.format(username_recv)
    # 三个参数：第一个为邮件正文文本内容，第二个 plain 设置文本格式，第三个 utf-8 设置编码
    message = MIMEText('【 吴晋丞选课系统 】你正在登录吴晋丞选课系统,验证码{}。转发可能导致账号被盗。'.format(code), 'plain', 'utf-8')
    message['From'] = formataddr(["admin", sender])  # 发送者
    message['To'] = formataddr(["吴晋丞选课系统", receivers])  # 接收者

    subject = '来自吴晋丞选课系统的消息'
    message['Subject'] = Header(subject, 'utf-8')  # 邮件的主题

    smtpObj = smtplib.SMTP('smtp.163.com', port=25)
    smtpObj.login(user=sender, password='HYDSGRIJQXNMUGWB')  # password并不是邮箱的密码，而是开启邮箱的授权码
    smtpObj.sendmail(sender, receivers, message.as_string())  # 发送邮件

13、start.py

'''
程序的入口
'''
import core.src as src
src.run()

三、运行效果展示

1、管理员运行效果展示

                ------------- 欢迎进入选课系统 -------------
                                0   后台管理系统
                                1   学生系统
                                2   教师系统
                ------------------ end -------------------
                
请输入您要进入的系统编号 >>>0

        ------------- 欢迎进入管理员登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end ---------------------
        
请输入您的选择 >>>1
请输入您的用户名：admin
请输入您的密码：admin
请再次确认您的密码：admin
请输入您的邮箱：32*****06@qq.com
管理员admin注册成功!
请输入您的选择 >>>ls

        ------------- 欢迎进入管理员登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end ---------------------
        
请输入您的选择 >>>2
请输入您的用户名：admin
请输入您的密码：admin
请输入邮箱验证码：l23E9
登录成功!
---------- 欢迎进入后台管理系统 ----------
exit 退出后台管理系统
1 创建校区
2 创建课程
----------------- end -----------------
请输入您要选择的功能编号 >>>1
请输入校区的名字:北京校区
请输入该校区开设的课程名:云计算运维,python全栈
云计算运维课程不存在,正在启动添加课程程序...
请输入添加的课程名：云计算运维
请输入课程费用：20000
请输入课程时长：8个月
请确认课程信息是否准确无误(yes or no ?):yes
成功创建云计算运维课程!
是否继续添加课程（yes or no ?）:no
python全栈课程不存在,正在启动添加课程程序...
请输入添加的课程名：python全栈
请输入课程费用：25000
请输入课程时长：10个月
请确认课程信息是否准确无误(yes or no ?):yes
成功创建python全栈课程!
是否继续添加课程（yes or no ?）:no
成功创建北京校区!
请输入您要选择的功能编号 >>>ls
---------- 欢迎进入后台管理系统 ----------
exit 退出后台管理系统
1 创建校区
2 创建课程
----------------- end -----------------
请输入您要选择的功能编号 >>>1
请输入校区的名字:上海校区
请输入该校区开设的课程名:go语言开发
go语言开发课程不存在,正在启动添加课程程序...
请输入添加的课程名：go语言开发
请输入课程费用：15000
请输入课程时长：6个月
请确认课程信息是否准确无误(yes or no ?):yes
成功创建go语言开发课程!
是否继续添加课程（yes or no ?）:no
成功创建上海校区!
请输入您要选择的功能编号 >>>exit

2、学生运行效果展示

请输入您要进入的系统编号 >>>ls

                ------------- 欢迎进入选课系统 -------------
                                0   后台管理系统
                                1   学生系统
                                2   教师系统
                ------------------ end -------------------
                
请输入您要进入的系统编号 >>>1

        ------------- 欢迎进入学生登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end -------------------
        
请输入您的选择 >>>1
请输入您的账户名：时间定义青春
请输入您的密码：123
请再次确定您的密码：123
请输入您的姓名：吴晋丞
请输入您的邮箱地址：zab******ept@163.com
时间定义青春注册成功!
请输入您的选择 >>>ls

        ------------- 欢迎进入学生登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end -------------------
        
请输入您的选择 >>>2
请输入您的用户名：时间定义青春
请输入您的密码：123
请输入邮箱验证码：1GmNF
登录成功!
---------- 欢迎进入学生选课系统 ----------
exit 退出学生选课系统
1 查询校区课程
2 选课功能
3 查看所选课程
4 查看课程成绩
----------------- end -----------------
请输入您要选择的功能编号 >>>1
请输入您要查询的校区：北京校区
云计算运维 20000¥ 8个月
python全栈 25000¥ 10个月
请输入您要选择的功能编号 >>>2
请输入您要入学的校区：上海校区
请输入您要选修的课程名：go语言开发
成功选修上海校区的go语言开发课程!
请输入您要选择的功能编号 >>>ls
---------- 欢迎进入学生选课系统 ----------
exit 退出学生选课系统
1 查询校区课程
2 选课功能
3 查看所选课程
4 查看课程成绩
----------------- end -----------------
请输入您要选择的功能编号 >>>3
上海校区 go语言开发
请输入您要选择的功能编号 >>>4
请输入查分课程所在的校区：上海校区
请输入您想要查询分数的课程：go语言开发
您上海校区的go语言开发课程，成绩为0分
请输入您要选择的功能编号 >>>exit

3、教师运行效果展示

请输入您要进入的系统编号 >>>ls

                ------------- 欢迎进入选课系统 -------------
                                0   后台管理系统
                                1   学生系统
                                2   教师系统
                ------------------ end -------------------
                
请输入您要进入的系统编号 >>>
请输入您要进入的系统编号 >>>2

        ------------- 欢迎进入教师登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end -------------------
        
请输入您的选择 >>>1
请输入您的账户名：egon
请输入您的密码：123
请再次确定您的密码：123
请输入您的姓名：林海峰
请输入您的邮箱地址：zab******ept@163.com
请输入讲师授权码：1Rk6e
教师林海峰注册成功!
请输入您的选择 >>>ls

        ------------- 欢迎进入教师登录界面 -------------
                        'exit'  退出登录界面
                        '1'     注册
                        '2'     登录
        --------------------- end -------------------
        
请输入您的选择 >>>2
请输入您的用户名：egon
请输入您的密码：123
请输入邮箱验证码：t59u2
登录成功!
---------- 欢迎进入教师操作系统 ----------
exit 退出教师系统
0 查看可任教课程
1 选择任教课程
2 查看当前任教课程
3 查看学员信息
4 修改学员成绩
----------------- end -----------------
请输入您要选择的功能编号 >>>1
请输入您想要任教的校区：上海校区
请输入您想要任教的课程：go语言开发
尊敬的林海峰老师您好,恭喜您选择任教课程go语言开发成功!
请输入您要选择的功能编号 >>>ls
---------- 欢迎进入教师操作系统 ----------
exit 退出教师系统
0 查看可任教课程
1 选择任教课程
2 查看当前任教课程
3 查看学员信息
4 修改学员成绩
----------------- end -----------------
请输入您要选择的功能编号 >>>3
学生姓名   成绩
--------------
吴晋丞    0分
请输入您要选择的功能编号 >>>4
请输入需要修改成绩的学生姓名：吴晋丞
请输入该学生成绩：90
请输入您要选择的功能编号 >>>ls
---------- 欢迎进入教师操作系统 ----------
exit 退出教师系统
0 查看可任教课程
1 选择任教课程
2 查看当前任教课程
3 查看学员信息
4 修改学员成绩
----------------- end -----------------
请输入您要选择的功能编号 >>>3
学生姓名   成绩
--------------
吴晋丞    90分

4、日志展示