面象对象编程（选课系统）

选课系统

conf包下
/settings.py/

import os

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

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

core包下

/src.py/

from core import admin
from core import student
from core import teacher

# 主视图字典
main_dict = {
    '1': admin.admin_view,
    '2': student.student_view,
    '3': teacher.teacher_view,
}


# 执行函数
def run():
    while True:
        print('''
        =========主视图===========
        1.管理员视图
        2.学生视图       
        3.老师视图
        q1:退出程序，程序终止
        请选择您要选择的视图前的编号！
        ''')
        choice = input('请输入编号：').strip()
        if choice == 'q1':
            break
        if choice not in main_dict:
            print('请输入正确编号！')

        # 调用函数方法
        main_dict[choice]()
        
/admin.py/

from interface import admin_interface
from interface import common_interface
from lib import common

admin_info = {
    'user': None
}


# 注册功能
def register():
    while True:
        username = input('请输入用户名：').strip()
        if username == 'q':
            break
        password = input('请输入密码：').strip()
        if password == 'q':
            break
        re_password = input('请确认密码：').strip()
        if re_password == 'q':
            break
        if password == re_password:
            flag, msg = admin_interface.register_interface(username, password)
            if flag:
                print(msg)
                break
            elif flag == 0:
                print(msg)
            else:
                print(msg)
        else:
            print('两次密码输入不一致！')


# 登录功能
def login():
    while True:
        username = input('请输入用户名：').strip()
        if username == 'q':
            break
        password = input('请输入密码：').strip()
        if username == 'q':
            break
        flag, msg = common_interface.common_login_interface(username, password, 'admin')
        if flag:
            print(msg)
            admin_info['user'] = username
            break
        else:
            print(msg)


# 创建学校
@common.login_auth('admin')
def create_school():
    while True:
        school_name = input('请输入学校名称：').strip()
        if school_name == 'q':
            break
        school_addr = input('请输入学校地址:').strip()
        if school_addr == 'q':
            break
        flag, msg = admin_interface.create_school_interface(admin_info['user'], school_name, school_addr)
        if flag:
            print(msg)
            break
        elif flag == 0:
            print(msg)
        else:
            print(msg)


# 创建老师
@common.login_auth('admin')
def create_teacher():
    while True:
        teacher_name = input('请输入老师的名字：').strip()
        if teacher_name == 'q':
            break
        flag, msg = admin_interface.create_teacher_interface(admin_info['user'], teacher_name, '123')
        if flag:
            print(msg)
            break
        elif flag == 0:
            print(msg)
        else:
            print(msg)


# 创建课程
@common.login_auth('admin')
def create_course():
    global school_name
    while True:
        school_list = common_interface.check_all_school_interface()
        if not school_list:
            print('学校为空，无法创建！')
        else:
            for num, school_name in enumerate(school_list):
                print(f'''
                    编号：{num}
                    学校：{school_name}
                    ''')
            choice = input('请输入编号：').strip()
            if choice == 'q':
                break
            if choice.isdigit():
                choice1 = int(choice)
                if 0 <= choice1 < len(school_list):
                    school_name = school_list[choice1]
                else:
                    print('请输入有效编号')
                    continue

            else:
                print('请输入数字')
                continue
            course_name = input('请输入课程名:').strip()
            if course_name == 'q':
                break
            flag, msg = admin_interface.create_course_interface(admin_info['user'], school_name, course_name)
            if flag:
                print(msg)
                break
            elif flag == 0:
                print(msg)
            else:
                print(msg)


admin_dict = {
    '1': register,
    '2': login,
    '3': create_school,
    '4': create_teacher,
    '5': create_course,
}


# 管理员视图
def admin_view():
    while True:
        print('''
        ===========管理员视图============
         1、注册
         2、登录
         3、创建学校
         4、创建老师
         5、创建课程
         q：任意输入界面返回至学生视图
         qq：退回到主视图
        ''')
        choice = input('请输入选择：').strip()
        if choice == 'qq':
            break
        if choice not in admin_dict:
            print('输入不合法！')
            continue
        admin_dict[choice]()

        
/student.py/

from interface import common_interface
from interface import student_interface
from lib import common

student_info = {
    'user': None
}


# 学生注册功能
def register():
    while True:
        username = input('请输入用户名：').strip()
        if username == 'q':
            break
        password = input('请输入密码：').strip()
        if password == 'q':
            break
        re_password = input('请确认密码：').strip()
        if re_password == 'q':
            break
        if password == re_password:
            flag, msg = student_interface.register_interface(username, password)
            if flag:
                print(msg)
                break
            elif flag == 0:
                print(msg)
            else:
                print(msg)
        else:
            print('两次密码输入不一致！')


# 学生登录功能
def login():
    while True:
        username = input('请输入用户名：').strip()
        if username == 'q':
            break
        password = input('请输入密码：').strip()
        if password == 'q':
            break
        flag, msg = common_interface.common_login_interface(username, password, 'student')
        if flag:
            print(msg)
            student_info['user'] = username
            break
        else:
            print(msg)


# 学生选择校区
@common.login_auth('student')
def choose_school():
    global school_name
    while True:
        school_list = common_interface.check_all_school_interface()
        if not school_list:
            print('学校为空，无法创建！')
        else:
            for num, school_name in enumerate(school_list):
                print(f'''
                编号：{num}
                学校：{school_name}
                ''')
        choice = input('请输入编号：').strip()
        if choice == 'q':
            break
        if choice.isdigit():
            choice1 = int(choice)
            if 0 <= choice1 < len(school_list):
                school_name = school_list[choice1]
            else:
                print('请输入有效编号')
                continue

        else:
            print('请输入数字')
            continue
        flag, msg = student_interface.choose_school_interface(student_info['user'], school_name)
        if flag:
            print(msg)
            break
        else:
            print(msg)
            break

# 学生选择课程
@common.login_auth('student')
def choose_course():
    while True:
        # 1.获取当前对象的 学校中 所有的课程
        flag, msg = student_interface.get_course_list_interface(
            student_info.get('user'))
        if not flag:
            print(msg)
            break

        # 2.打印课程，选择课程名称
        for index, course_name in enumerate(msg):
            print(index, course_name)

        choice = input('请输入选择的课程编号: ').strip()

        if choice == 'q':
            break

        if not choice.isdigit():
            continue
        choice = int(choice)

        if choice not in range(len(msg)):
            continue
        course_name = msg[choice]

        # 3.调用学生选择课程接口
        flag, msg = student_interface.choose_course_interface(
            student_info.get('user'), course_name
        )

        if flag:
            print(msg)
            break

        else:
            print(msg)


# 学生查看成绩
@common.login_auth('student')
def check_score():
    score_dict = student_interface.check_score_interface(student_info['user'])
    print(score_dict)


# 学生功能字典
student_dict = {
    '1': register,
    '2': login,
    '3': choose_school,
    '4': choose_course,
    '5': check_score,
}


# 学生视图
def student_view():
    while True:
        print('''
        ===========学生视图============
         1、注册
         2、登录
         3、选择校区
         4、选择课程
         5、查看成绩
         q：任意输入界面返回至学生视图
         qq：退回到主视图
        ''')
        choice = input('请输入选择：').strip()
        if choice == 'qq':
            break
        if choice not in student_dict:
            print('输入不合法！')
            continue
        student_dict[choice]()

        
/teacher.py/

from interface import common_interface
from lib import common
from interface import teacher_interface

teacher_info = {
    'user': None
}


# 登录功能
def login():
    while True:
        username = input('请输入用户名：').strip()
        if username == 'q':
            break
        password = input('请输入密码：').strip()
        if password == 'q':
            break
        flag, msg = common_interface.common_login_interface(username, password, 'teacher')
        if flag:
            print(msg)
            teacher_info['user'] = username
            break
        else:
            print(msg)


# 查看教授的课程
@common.login_auth('teacher')
def check_teach_course():
    while True:
        flag, course_list_or_msg = teacher_interface.check_teach_course_interface(
            teacher_info['user']
        )

        if flag:
            print(course_list_or_msg)
            break
        else:
            print(course_list_or_msg)
            break


# 选择教授的课程
@common.login_auth('teacher')
def choose_teach_course():
    while True:
        # 1.先获取所有学校，选择学校
        school_list = common_interface.check_all_school_interface()
        if not school_list:
            print('没有学校可以选择!')
            break

        for index, school_name in enumerate(school_list):
            print(index, school_name)

        choice = input('请输入学校编号: ').strip()
        if choice == 'q':
            break
        if not choice.isdigit():
            continue

        choice = int(choice)

        if choice not in range(len(school_list)):
            continue

        school_name = school_list[choice]

        # 2.通过学校获取所有课程，再选择教授课程
        flag, course_list_or_msg = common_interface.check_course_from_school_interface(school_name)

        # 3.打印所有的课程，让老师选择课程编号
        if not flag:
            print(course_list_or_msg)
            break

        for index, course_name in enumerate(course_list_or_msg):
            print(index, course_name)

        choice = input('请输入课程编号: ').strip()
        if choice == 'q':
            break
        if not choice.isdigit():
            continue

        choice = int(choice)

        if choice not in range(len(course_list_or_msg)):
            continue

        course_name = course_list_or_msg[choice]

        # 4.调用选择教授课程接口
        flag, msg = teacher_interface.choose_teach_course_interface(
             teacher_info.get('user'), course_name)

        if flag:
            print(msg)
            break
        else:
            print(msg)


# 查看课程下的学生
@common.login_auth('teacher')
def check_course_student():
    while True:
        # 1.获取老师中所有的课程，并选择
        flag, course_list_or_msg = teacher_interface.check_teach_course_interface(
            teacher_info.get('user'))

        if not flag:
            print(course_list_or_msg)
            break

        # 2.通过课程查看课程中所有的学生
        for index, course_name in enumerate(course_list_or_msg):
            print(index, course_name)

        choice = input('请输入课程编号: ').strip()
        if choice == 'q':
            break
        if not choice.isdigit():
            continue

        choice = int(choice)

        if choice not in range(len(course_list_or_msg)):
            continue

        course_name = course_list_or_msg[choice]

        # 3.调用查看课程中所有学生接口
        flag, student_list_or_msg = teacher_interface.check_course_student_interface(
            teacher_info['user'], course_name
        )

        if flag:
            print(student_list_or_msg)
            break

        else:
            print(student_list_or_msg)


# 修改学生成绩
@common.login_auth('teacher')
def change_student_score():
    while True:
        # 1.获取老师中所有的课程，并选择
        flag, course_list_or_msg = teacher_interface.check_teach_course_interface(
            teacher_info.get('user'))

        if not flag:
            print(course_list_or_msg)
            break

        # 2.通过课程查看课程中所有的学生
        for index, course_name in enumerate(course_list_or_msg):
            print(index, course_name)

        choice = input('请输入课程编号: ').strip()
        if choice == 'q':
            break
        if not choice.isdigit():
            continue

        choice = int(choice)

        if choice not in range(len(course_list_or_msg)):
            continue

        course_name = course_list_or_msg[choice]

        # 3.调用查看课程中所有学生接口
        flag, student_list_or_msg = teacher_interface.check_course_student_interface(
             teacher_info.get('user'), course_name,
        )

        if not flag:
            print(student_list_or_msg)
            break

        # 4.先循环打印所有的学生，并选择学生编号，获取学生名字
        for index, student_name in enumerate(student_list_or_msg):
            print(index, student_name)

        choice2 = input('请输入学生编号: ').strip()
        if choice == 'q':
            break
        if not choice2.isdigit():
            continue

        choice2 = int(choice2)

        if choice2 not in range(len(student_list_or_msg)):
            continue

        # 获取学生名字
        student_name = student_list_or_msg[choice2]

        # 让老师输入修改课程的分数
        score = input('请输入修改的分数: ').strip()
        if choice == 'q':
            break
        if score.isdigit():

            score = int(score)

            if 0 <= score <= 100:

                # 5.调用修改学生分数接口
                flag, msg = teacher_interface.change_student_score_interface(
                    teacher_info['user'], student_name, course_name, score
                )

                if flag:
                    print(msg)
                    break
            else:
                print('请输入有效的分数！')
                continue
        else:
            print('请输入数字！')


teacher_dict = {
    '1': login,
    '2': check_teach_course,
    '3': choose_teach_course,
    '4': check_course_student,
    '5': change_student_score,

}


def teacher_view():
    while True:
        print('''
            =============老师视图===============
            1、登录
            2、查看教授课程
            3、选择教授课程
            4、查看课程下学生
            5、修改学生成绩
            q：任意输入界面返回至学生视图
            qq：退回到主视图
            ''')
        choice = input('请输入选择：').strip()
        if choice == 'qq':
            break
        if choice not in teacher_dict:
            print('输入不合法！')
            continue
        teacher_dict[choice]()

db包下

/db_handler.py/

from conf import settings
import os
import pickle
import re


# 保存数据
def db_save(obj):
    # 拼接类绝对路径
    cls_path = os.path.join(settings.DB_PATH, obj.__class__.__name__.lower())
    # 判断类的文件夹是否存在，若不存在，则新建
    if not os.path.exists(cls_path):
        os.mkdir(cls_path)

    # 判断传入的名称是否合法
    if not re.search(u'^[_a-zA-Z0-9u4e00-u9fa5]+$', obj.name):
        return 0
    user_path = os.path.join(cls_path, obj.name)
    # 存储数据
    with open(user_path, 'wb') as f:
        pickle.dump(obj, f)
        f.flush()


# 查看数据
def db_select(cls, name):
    # 拼接绝对路径
    cls_path = os.path.join(settings.DB_PATH, cls.__name__.lower())
    # 判断类的文件是否存在，若不存在，则新建
    if not os.path.exists(cls_path):
        os.mkdir(cls_path)

    # 判断传入的名称是否合法
    if not re.search(u'^[_a-zA-Z0-9u4e00-u9fa5]+$', name):
        return 0
    user_path = os.path.join(cls_path, name)
    if os.path.exists(user_path):
        # 读取数据
        with open(user_path, 'rb') as f:
            obj = pickle.load(f)
            return obj


/models.py/
from db import db_handler


# 父类
class Base:
    # 保存数据
    def save(self):
        db_handler.db_save(self)

    # 读取数据
    @classmethod
    def select_ob_from_name(cls, name):
        obj = db_handler.db_select(cls, name)
        return obj


# 管理员类
class Admin(Base):
    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd
        self.save()

    # 创建学校
    def create_school(self, school_name, school_addr):
        School(school_name, school_addr)

    # 创建老师
    def create_teacher(self, teacher_name, teacher_pwd):
        Teacher(teacher_name, teacher_pwd)

    # 创建课程
    def create_course(self, course_name, school_name):
        Course(course_name)
        school_obj = School.select_ob_from_name(school_name)
        school_obj.course_list.append(course_name)
        school_obj.save()


# 学生类
class Student(Base):
    def __init__(self, student_name, student_pwd, ):
        self.name = student_name
        self.pwd = student_pwd
        self.score = {}
        self.course_list = []
        self.school = None
        self.save()

    # 学生选择课程
    def choose_course(self, course_name):
        self.course_list.append(course_name)
        self.save()
        course_obj = Course.select_ob_from_name(course_name)
        course_obj.course_student_list.append(self.name)
        course_obj.save()

    # 学生选择校区功能
    def choose_school(self, school_name):
        self.school = school_name
        self.save()

    # 学生查看成绩功能
    def check_score(self):
        return self.score


# 老师类
class Teacher(Base):
    def __init__(self, teacher_name, teacher_pwd):
        self.name = teacher_name
        self.pwd = teacher_pwd
        self.teacher_course_list = []
        self.save()

    # 查看教授的课程
    def check_teach_course(self):
        return self.teacher_course_list

    # 选择教授的课程
    def choose_teach_course(self, course_name):
        self.teacher_course_list.append(course_name)
        self.save()

    # 查看课程下的学生
    def check_course_all_student(self, course_name):
        course_obj = Course.select_ob_from_name(course_name)
        return course_obj.course_student_list

    # 修改学生成绩
    def change_score(self, student_name, course_name, score):
        student_obj = Student.select_ob_from_name(student_name)
        student_obj.score[course_name] = score
        student_obj.save()


# 学校类
class School(Base):
    def __init__(self, school_name, school_addr):
        self.name = school_name
        self.school_addr = school_addr
        self.course_list = []
        self.save()

    # 查看所有课程
    def check_all_course(self):
        return self.course_list


# 课程类
class Course(Base):
    def __init__(self, course_name):
        self.name = course_name
        self.course_student_list = []
        self.save()

    # 添加学生
    def add_student(self, student_name):
        self.course_student_list.append(student_name)
        self.save()

    # 查看所有学生
    def check_all_student(self):
        return self.course_student_list

interface包下

/admin_interface.py/

from db import models


# 注册接口
def register_interface(user, pwd):
    admin_obj = models.Admin.select_ob_from_name(user)
    if admin_obj:
        return False, '该用户已经存在！'
    elif admin_obj == 0:
        return 0, '输入不合法，只能包含汉字，字母，数字，下划线'
    else:
        models.Admin(user, pwd)
        return True, f'{user}用户注册成功！'


# 创建学校接口
def create_school_interface(user, school_name, school_addr):
    school_obj = models.School.select_ob_from_name(school_name)
    if school_obj:
        return False, '该学校已经存在！'
    elif school_obj == 0:
        return 0, '输入不合法，只能包含汉字，字母，数字，下划线'
    else:
        admin_obj = models.Admin.select_ob_from_name(user)
        admin_obj.create_school(school_name, school_addr)
        return True, f'学校{school_name}创建成功！'


# 创建老师接口
def create_teacher_interface(user, teacher_name, teacher_pwd):
    teacher_obj = models.Teacher.select_ob_from_name(teacher_name)
    if teacher_obj:
        return False, '该老师已经存在！'
    elif teacher_obj == 0:
        return 0, '输入不合法，只能包含汉字，字母，数字，下划线'
    else:
        admin_obj = models.Admin.select_ob_from_name(user)
        admin_obj.create_teacher(teacher_name, teacher_pwd)
        return True, f'老师{teacher_name}创建成功！'


# 创建课程接口
def create_course_interface(user, school_name, course_name):
    course_obj = models.Course.select_ob_from_name(course_name)
    if course_obj:
        return False, '该课程已经存在！'
    elif course_obj == 0:
        return 0, '输入不合法，只能包含汉字，字母，数字，下划线'
    else:
        admin_obj = models.Admin.select_ob_from_name(user)
        admin_obj.create_course(course_name, school_name)
        return True, f'课程{course_name}创建成功！'

    
/common_interface.py/

from db import models
import os
from conf import settings


# 公共登录接口
def common_login_interface(user, pwd, role):
    if role == 'admin':
        obj = models.Admin.select_ob_from_name(user)
    elif role == 'student':
        obj = models.Student.select_ob_from_name(user)
    elif role == 'teacher':
        obj = models.Teacher.select_ob_from_name(user)
    else:
        return False, '权限不足！'
    if obj:
        if obj.pwd == pwd:
            return True, f'{user}登录成功！'
        else:
            return False, '密码错误！'
    else:
        return False, '该用户不存在！'


# 查询所有的学校
def check_all_school_interface():
    school_path = os.path.join(settings.DB_PATH, 'school')
    school_list = os.listdir(school_path)
    return school_list


# 查看学校中所有的课程接口
def check_course_from_school_interface(school_name):

    school_obj = models.School.select_ob_from_name(school_name)

    # 有学校对象，调用查看学校中所有课程的方法
    course_list = school_obj.check_all_course()
    if course_list:
        return True, course_list

    return False, '学校中没有课程!'


/student_interface/

from db import models


# 学生注册功能
def register_interface(user, pwd):
    student_obj = models.Student.select_ob_from_name(user)
    if student_obj:
        return False, '该用户已经存在！'
    elif student_obj == 0:
        return 0, '输入不合法，只能包含汉字，字母，数字，下划线'
    else:
        models.Student(user, pwd)
        return True, f'{user}用户注册成功！'


# 学生选课功能
def choose_course_interface(student_name, course_name):
    student_obj = models.Student.select_ob_from_name(student_name)
    if course_name in student_obj.course_list:
        return False, '该课程已存在!'
    student_obj.choose_course(course_name)
    return True, '添加课程成功!'


# 学生选择校区功能
def choose_school_interface(student_name, school_name):
    student_obj = models.Student.select_ob_from_name(student_name)
    if student_obj.school:
        return False, '已选过学校'
    else:
        student_obj.choose_school(school_name)
        return True, '选择成功！'


# 学生查看成绩功能
def check_score_interface(student_name):
    student_obj = models.Student.select_ob_from_name(student_name)
    score_dict = student_obj.check_score()
    return score_dict


# 获取学生对象中的所有课程
def get_course_list_interface(student_name):
    # 1.获取当前学生对象
    student_obj = models.Student.select_ob_from_name(student_name)
    school_name = student_obj.school

    # 2.判断学生是否 选择了学校
    if not school_name:
        return False, '请先选择学校'

    # 3.获取学校对象，获取学校对象中的课程列表
    school_obj = models.School.select_ob_from_name(school_name)
    course_list = school_obj.course_list
    if course_list:
        return True, course_list
    else:
        return False, '学校中没有课程!'

    
    
/teacher_interface/

from db import models


# 查看教授的课程
def check_teach_course_interface(teacher_name):
    teacher_obj = models.Teacher.select_ob_from_name(teacher_name)
    course_list = teacher_obj.check_teach_course()
    if course_list:
        return True, course_list
    else:
        return False, '老师还没选择课程'


# 选择教授的课程
def choose_teach_course_interface(teacher_name, course_name):
    # 1.获取老师对象
    teacher_obj = models.Teacher.select_ob_from_name(teacher_name)
    teacher_course_list = teacher_obj.teacher_course_list

    # 2.判断该课程是否存在
    if course_name in teacher_course_list:
        return False, '该课程已存在'

    # 3.若不存在，则让老师对象 调用添加课程方法，老师添加课程。
    teacher_obj.choose_teach_course(course_name)

    return True, '添加课程成功！'


# 查看课程下的学生
def check_course_student_interface(teacher_name, course_name):
    teacher_obj = models.Teacher.select_ob_from_name(teacher_name)
    student_list = teacher_obj.check_course_all_student(course_name)
    if student_list:
        return True, student_list
    else:
        return False, '课程下还没有学生！'


# 修改学生成绩
def change_student_score_interface(teacher_name, student_name, course_name, score):

    # 1.获取老师对象
    teacher_obj = models.Teacher.select_ob_from_name(teacher_name)

    # 2.通过老师对象，调用修改分数方法
    teacher_obj.change_score(
        # 学生名字传入，为了获取学生对象，并修改学生中的课程成绩
        student_name, course_name, score,
    )

    return True, f'修改分数成功, 课程[{course_name}]分数为: [{score}]'

lib包下

/common.py/

# 登录认证+权限认证功能
def login_auth(user_type):
    def outer(func):
        def inner(*args, **kwargs):
            if user_type == 'admin':
                from core import admin
                if admin.admin_info['user']:
                    res = func(*args, **kwargs)
                    return res
                else:
                    print('请先进行登录操作！')
                    admin.login()
            elif user_type == 'student':
                from core import student
                if student.student_info['user']:
                    res = func(*args, **kwargs)
                    return res
                else:
                    print('请先进行登录操作！')
                    student.login()
            elif user_type == 'teacher':
                from core import teacher
                if teacher.teacher_info['user']:
                    res = func(*args, **kwargs)
                    return res
                else:
                    print('请先进行登录操作！')
                    teacher.login()
            else:
                print('权限不足！')

        return inner

    return outer

start.py

from core import src
import sys
import os


# 添加环境变量
sys.path.append(
    os.path.dirname(__file__)
)


# 测试运行
if __name__ == '__main__':
    src.run()

readme.txt

1.需求分析

# 项目需求如下
'''

对象角色:
    管理员对象、学生对象、老师对象、课程对象、学校对象

    - 至少需要创建5个类.

要求:
    # 管理员模块 ---》 注册、登录、创建学校、创建课程、创建老师
　　1. 创建北京、上海 2 所学校  ---》 创建学校 （学校名称与学校地址）

    学校课程---》 [创建课程1, 创建课程2, ...]
　　2. 创建linux , python13 , go 3个课程 ， linuxpy在北京开，go在上海开 ---> 创建课程（课程名称，绑定学校）

　　3. 管理员创建学校 ，课程  ，老师  ---》 创建老师， （老师名字，老师密码）

　　4. 学校包含学校名称，地址等属性

    # 学生模块 ---》 注册、登录、选择学校、选择课程、查看成绩
　　5. 学生注册登录后，可以选择学校，选择课程，查看成绩

　　6. 学生只能选择一所学校，可以从校区中选择多门课程，课程绑定给学生。
        [创建课程1, 创建课程2, ...]  <----- 学生选择学校中的一门课程， 学生课程列表[课程1, 课程2]

    # 老师模块 ---》 登录、查看教授课程、选择教授课程、查看课程下的学生、修改学生成绩
　　7. 老师登录后，可以查看教授课程，选择想要教授的课程，查看课程下的学生，修改学生成绩等



视图和功能：

    - 总视图: src.py

        让用户先进入总视图，然后再通过选择的编号 进入相应的视图。

        - 学生视图
                1、注册
                2、登录
                3、选择校区
                4、选择课程
                5、查看成绩

        - 老师视图
                1、登录
                2、查看教授课程
                3、选择教授课程
                4、查看课程下学生
                5、修改学生成绩

        - 管理视图，创建讲师， 创建班级，创建课程
                1、注册
                2、登录
                3、创建学校
                4、创建老师
                5、创建课程
'''


2.项目的架构设计
    - 三层架构
        - 用户视图层
            - 接收用户输入的内容
            - 接收接口层返回的数据，并展示给用户

        - 接口层
            - 业务逻辑的处理
            - 将处理完的结果返回的用户视图层 ↑
            - 产生的数据: ↓

        - 数据处理层
            - 数据的存取
            - 存: 拿到接口层产生的数据进行保存
            - 查: 将数据返回给接口层  ↑



3.分任务开发
4.测试
5.上线



注意: 写完所有功能，务必删除所有文件后，重新测试，以免报错!

分析：
'''
存放一个个的类:

管理员对象、学生对象、老师对象、课程对象、学校对象

所有类的父类:
    - Class Base:

    - 技能:
        - 保存数据
        - 查看数据

课程对象(课程类):
    - 特征（属性）:
        - 课程名字
        - 学校
        - 学生列表

    - 技能（方法）
        - 保存数据（课程）
        - 查看数据（课程）

        - 添加学校
            self.学校 = 上海校区

        - 添加学生
            self.学生列表.append(学生)


学生对象（学生类）:
    - class Student(Base):
        - 特征（属性）:
            - 名字
            - 密码
            - 学校
            - 课程列表
            - 分数字典: {'课程名字': 课程分数, '课程名字2': 课程分数,}

        - 技能（方法）
            - 保存数据（注册）:
                - 调用学生类，实例化得到一个学生对象，并将学生对象保存成pickle文件。

            - 查看数据（登录）：
                - 从pickle文件中读出相应的对象。

            - 选择校区
                学校 = oldboy

            - 选择课程
                self.课程列表.append(课程)

            - 查看成绩
                for line in self.分数字典:
                    print(line)


老师对象（老师类）:
    class Teacher(Base):
        - 特征（属性）:
            - 名字
            - 密码
            - 课程列表

        - 技能（方法）

            - 保存数据（老师）

            - 查看数据 (登录)

            - 查看教授课程
                self.课程列表

            - 选择教授课程
                课程列表.append(课程名字)

            - 查看课程下学生
                课程列表.课程---》 获取课程对象.学生列表

            - 修改学生成绩
                课程列表.课程----> 获取课程对象.学生列表.学生 ----> 获取学生对象.分数字典[课程]  = 100


管理员对象（管理员类）:
    - class Admin(Base):
        - 特征（属性）:
            - 名字
            - 密码

        - 技能（方法）
            - 保存数据 (注册)
                - 调用管理员类，实例化得到一个管理员对象，并将管理员对象保存成pickle文件。

            - 查看数据 (登录)

            - 创建学校
                - 调用学校类，实例化得到一个学校对象，并将学校对象保存成pickle文件。

            - 创建老师
                - 调用老师类，实例化得到一个老师对象，并将老师对象保存成pickle文件。

            - 创建课程
                - 调用课程类，实例化得到一个课程对象，并将课程对象保存成pickle文件。


学校对象（学校类）:
    - class School(Base):
        - 特征（属性）:
            - 学校名称
            - 学校地址
            - 课程列表
            -

        - 技能（方法）
            - 查看数据（学校）
            - 保存数据（学校）

            - 添加课程
                self.课程列表.append(课程)

'''
from db import db_handler


# 父类
class Base:
    # 保存 数据(对象) 方法
    def save_obj(self):

        # 调用db_handler中save将对象保存到pickle文件中
        db_handler.save(self)

    # 查看 数据(对象) 方法
    @classmethod
    def select_obj_by_name(cls, name):

        obj = db_handler.select(cls, name)

        return obj


# 管理员类
class Admin(Base):  # admin_obj.save_obj(admin_obj)

    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd

    # 管理员创建学校方法
    def create_school(self, school_name, school_addr):
        # 创建对象方式一:
        # school_obj = School(school_name, school_addr)
        # school_obj.save_obj()

        # 创建对象方式二:
        School(school_name, school_addr)

    # 管理员创建课程方法
    def create_course(self, school_name, course_name):
        # 1.调用课程类 创建课程对象
        Course(school_name, course_name)

        # 2.获取学校对象，为学校对象中的课程列表添加课程
        school_obj = School.select_obj_by_name(school_name)
        school_obj.course_list.append(course_name)
        school_obj.save_obj()

    # 管理员创建老师方法
    def create_teacher(self, teacher_name, teacher_pwd):
        Teacher(teacher_name, teacher_pwd)


# 学校类
class School(Base):
    def __init__(self, school_name, school_addr):
        self.name = school_name
        self.addr = school_addr
        self.course_list = []
        self.save_obj()

    # 学校对象查看所有课程方法
    def check_all_course(self):
        return self.course_list


# 课程类
class Course(Base):
    '''
    - 课程名字
    - 学校
    - 学生列表
    '''
    def __init__(self, school_name, course_name):
        self.name = course_name
        self.school = school_name
        self.student_list = []
        self.save_obj()

    # 课程添加学生方法
    def add_student(self, student_name):
        self.student_list.append(student_name)
        self.save_obj()

    # 课程对象获取所有学生方法
    def check_all_student(self):
        return self.student_list


# 学生类
class Student(Base):
    def __init__(self, student_name, student_pwd):
        self.name = student_name
        self.pwd = student_pwd
        # 一个学生只能选择一所学校
        self.school = None
        self.course_list = []
        self.score = {}
        self.save_obj()

    # 学生添加学校方法
    def add_school(self, school_name):
        self.school = school_name
        self.save_obj()

    # 学生添加课程方法
    def add_course(self, course_name):
        # 1.添加课程
        self.course_list.append(course_name)
        # 2.为新添加的课程设置初始分数
        self.score[course_name] = 0
        self.save_obj()

        # 3.获取课程对象，让课程对象调用添加学生方法
        course_obj = Course.select_obj_by_name(course_name)

        # 调用添加学生方法
        course_obj.add_student(self.name)


# 老师类
class Teacher(Base):

    def __init__(self, teacher_name, teacher_pwd):
        self.name = teacher_name
        self.pwd = teacher_pwd
        self.course_list = []
        self.save_obj()

    # 老师查看所有课程方法
    def check_all_course(self):
        return self.course_list

    # 老师添加课程方法
    def add_course(self, course_name):
        self.course_list.append(course_name)
        self.save_obj()

    # 老师查看教授课程方法
    def check_student_from_course(self, course_name):
        # 1.获取课程对象
        course_obj = Course.select_obj_by_name(course_name)

        # 2.通过课程对象, 获取学生列表
        student_list = course_obj.check_all_student()
        return student_list

    # 老师修改分数方法
    def change_score(self, student_name, course_name, score):
        # 1.获取学生对象
        student_obj = Student.select_obj_by_name(student_name)

        # 2.直接修改学生score属性
        student_obj.score[course_name] = score
        student_obj.save_obj()