python練習---校園管理系統

角色：

學校、學員、課程、講師

要求：

1、創建北京、上海2所學校（已完成）

2、創建linux、python、go3個課程，linux/python在北京開，go在上海開（已完成）

3、課程包含周期、價格（已完成）

4、班級關聯課程、講師（已完成）

5、創建學員時，選擇學校，關聯班級（已完成）

6、提供三個角色視圖

　　6.1：學員視圖，登錄，查看課程，查看班級（已完成）

　　6.2：講師視圖，講師可以查看自己教學的班級，課程（已完成）

　　　　進階需求：可管理自己的班級，查看班級學員列表，修改所管理的成績（未完成）

　　6.3：管理視圖，創建講師，創建班級，創建課程（已完成）

7、上面的操作產生的數據通過pickle、序列化保持到文件中（已完成）

 

下面是具體的實現代碼：

代碼目錄主要有：

 

實現功能：
    1、根據登錄用戶進行判斷，如果是學生就進入學生視圖，是老師就進入老師視圖，是管理員就進入管理員視圖
        課程中關聯學校、講師等屬性；
        班級中關聯課程、講師等屬性
        學生對象關聯了學校、班級等屬性；

    2、學生視圖：
        a：查看課程
        b：查看學校
        c：查看班級
    3、老師視圖：
        a：查看學校
        b：查看講師
        c：查看班級
        d：查看課程
    4、管理員視圖：
        a：創建學校
        b：創建課程
        c：創建班級
        d：創建學員
        e：創建講師
        f：查看學校
        g：查看講師
        h：查看班級
        i：查看課程
        j：給課程關聯講師
        k：給學員指定班級

目錄結構：
    bin  --->  程序執行的總入口，直接在pycharm或者其他編輯器中執行start.py
    conf --->  配置文件目錄，settings.py文件中都是一些文件路徑信息
    core --->  程序核心目錄，里面分別包含了'學校類'，'老師類'，'學生類'，'班級類'，'課程類'，'管理員類'；其中Main.py(程序主要邏輯判斷文件)文件中主要是實現登錄驗證、根據不同登錄用戶反射到對應的類中
    db   --->  信息存儲目錄，主要記錄'學校'、'老師'、'學生'、'班級'、'課程'、'用戶賬號密碼'等信息
    log  --->  程序運行中產生的日志信息，主要是記錄對程序執行的所有信息


管理員賬號密碼：admin 123
老師賬號密碼：goddess 123
學生賬號密碼：jack 123

#! /bin/env python
# coding: utf-8
import os
import sys

#將項目需要導入的包路徑導入到環境變量中
# sys.path.append(os.path.dirname(os.getcwd()))
sys.path.append(os.path.dirname(os.path.dirname(__file__)))

# print(os.path.dirname(__file__))
from core import Main


if __name__ == '__main__':
    print('\033[1;36m歡迎進入校園管理系統!\033[0m')
    Main.main()

#! /bin/env python
# coding=utf-8
import os

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

userinfo = r'%s/db/userinfo' % path
schoolinfo = r'%s/db/school_info' % path
teacherinfo = r'%s/db/teacher_info' % path
classinfo = r'%s/db/class_info' % path
studentinfo = r'%s/db/student_info' % path
courseinfo = r'%s/db/course_info' % path

log = r'%s/log/test.log' % path

#! /bin/env python
# coding: utf-8

class Class(object):
    def __init__(self,name):
        self.class_name = name


    def __repr__(self):  #內置的方法，讓打印的對象豐富起來
        show_str = ''
        for key in self.__dict__:
            show_str +='%s : %s ' % (key,  self.__dict__[key])

        return show_str

#! /bin/env python
# coding=utf-8


class Course(object):
    def __init__(self,name,time,price):
        self.course_name = name
        self.course_time = time
        self.course_price = price

    def __repr__(self):  #內置的方法，讓打印的對象豐富起來
        show_str = ''
        for key in self.__dict__:
            show_str +='%s : %s ' % (key,  self.__dict__[key])

        return show_str

#! /usr/bin/env python
# coding: utf-8

import logging
import sys
from conf import settings

class Log:
    def __init__(self):
        pass

    def record(self,s):
        logging.basicConfig(format='%(asctime)s %(levelname)s %(filename)s[line:%(lineno)d] %(message)s',
                            filename=settings.log, level=logging.INFO)
        logging.info(s)

#! /bin/env python
# coding: utf-8
import sys
import hashlib
from collections import OrderedDict
from core.Manager import Manager
from core.Student import Student
from core.Teacher import Teacher

from conf import settings

status_dic = {
    'username': None,
    'status': False,
    'identity': None
}

# 登錄認證
def login():
    # if status_dic['status'] == False:
        user = input('username>>').strip()
        pwd = input('password>>').strip()
        hash_obj = hashlib.md5(user.encode('utf-8'))   #md5前需要先轉成base64
        hash_obj.update(pwd.encode('utf-8'))
        md5_pwd = hash_obj.hexdigest()
        with open(settings.userinfo) as f:
            for line in f:
                username, password, identity = line.strip().split('|')
                if username == user and password == md5_pwd and identity == 'Manager':

                    print('\033[1;32m歡迎%s管理員用戶登錄\033[0m'.center(50,'*') % user)
                    return {'username': user, 'identity': identity}
                elif username == user and password == md5_pwd and identity == 'Teacher':
                    print('\033[1;32m歡迎%s老師用戶登錄\033[0m'.center(50,'*') % user)
                    return {'username': user, 'identity': identity}
                elif username == user and password == md5_pwd and identity == 'Student':
                    print('\033[1;32m歡迎%s學生用戶登錄\033[0m'.center(50,'*') % user)
                    return {'username': user, 'identity': identity}



def main():
    ret = login()
    if ret:
        if hasattr(sys.modules[__name__],ret['identity']):
            Role_Cls = getattr(sys.modules[__name__],ret['identity'])
            role_obj = Role_Cls(ret['username'])
            while True:
                d = {}
                for num,key in enumerate(role_obj.dic,1):
                    print(num,key)
                    d[str(num)]=key
                try:
                    num = input('\033[1;32m請輸入您要做的操作序號 :\033[0m')
                    func_name = role_obj.dic[d[num]]
                    if hasattr(role_obj, func_name):
                        getattr(role_obj, func_name)()   #根據用戶的選擇去執行具體的方法
                except Exception:
                    pass



if __name__ == '__main__':
    # hash_obj = hashlib.md5('alex'.encode('utf-8'))
    # hash_obj.update('123'.encode('utf-8'))
    # md5_pwd = hash_obj.hexdigest()
    # print(md5_pwd)
    pass

#! /bin/env python
# coding: utf-8
import pickle
import hashlib
import logging
from collections import OrderedDict
from core.Mypickle import Mypickle
from core.Teacher import Teacher
from core.Class import Class
from core.Course import Course
from core.Student import Student
from core.School import School
from core import Log
from conf import settings




class Manager:
    dic = OrderedDict([ ('創建學校','create_school'),
                        ('創建學員', 'create_student'),
                        ('創建講師', 'create_teacher'),
                        ('創建課程', 'create_course'),
                        ('創建班級', 'create_class'),
                        ('查看學校', 'show_school'),
                        ('查看講師', 'show_teacher'),
                        ('查看班級', 'show_class'),
                        ('查看課程', 'show_course'),
                        ('退出', 'quit')])

    def __init__(self, name):
        self.name = name
        self.school_pickle = Mypickle(settings.schoolinfo)
        self.teacher_pickle = Mypickle(settings.teacherinfo)
        self.class_pickle = Mypickle(settings.classinfo)
        self.student_pickle = Mypickle(settings.studentinfo)
        self.course_pickle = Mypickle(settings.courseinfo)
        self.obj = Log.Log()

    # 創建學校
    def create_school(self):
        school_name = input('school name>').strip()
        school_addr = input('school addr>').strip()
        school_obj = School(school_name, school_addr)
        self.school_pickle.dump(school_obj)
        a = 'Create a school'
        self.obj.record(a)

        print('\033[1;31m學校創建成功!\033[0m')

    #創建課程
    def create_course(self):
        course_name = input('course name>').strip()
        course_time = input('course time>').strip()
        course_price = input('course price>').strip()

        #選擇學校
        self.show_school()

        school_num = input('請輸入課程所開設的校區序號:').strip()
        school_obj = self.school_pickle.get_item(int(school_num))

        #創建一個屬於課程的新對象
        course_obj = Course(course_name,course_time,course_price)
        #將課程與學校綁定到一起
        course_obj.school = school_obj

        #將課程對象dump寫入courseinfo文件中
        course_pickle = Mypickle(settings.courseinfo)
        course_pickle.dump(course_obj)
        print('\033[1;31m課程創建成功!\033[0m')

        a = 'Create a course'
        self.obj.record(a)

    #創建班級
    def create_class(self):
        class_name = input('class name>').strip()

        #關聯課程
        self.show_course()

        course_num = input('請輸入班級關聯的課程序號:').strip()
        course_obj = self.course_pickle.get_item(int(course_num))

        #關聯講師
        self.show_teacher()
        teacher_num = input('請輸入班級關聯的講師序號:').strip()
        teacher_obj = self.teacher_pickle.get_item(int(teacher_num))

        # 創建一個屬於班級的對象
        class_obj = Class(class_name)
        class_obj.course = course_obj
        class_obj.teacher = teacher_obj
        class_pickle = Mypickle(settings.classinfo)
        class_pickle.dump(class_obj)

        print('\033[1;31m班級創建成功!\033[0m')
        a = 'Create a class'
        self.obj.record(a)

    #創建學員賬號
    def create_student(self):
        student_name = input('student name>').strip()
        student_pwd = input('student password>').strip()
        md5_obj = hashlib.md5(student_name.encode('utf-8'))
        md5_obj.update(student_pwd.encode('utf-8'))
        md5_passwd = md5_obj.hexdigest()
        user = '%s|%s|%s\n' % (student_name,md5_passwd,'Student')
        with open(settings.userinfo,'a',encoding='utf-8') as f:
            f.write(user)

        #給學員選擇學校
        self.show_school()
        school_num = input('請輸入學生所在的校區序號:').strip()
        school_obj = self.school_pickle.get_item(int(school_num))
        #創建一個屬於學生的新對象
        student_obj = Student(student_name)
        student_obj.school = school_obj
        student_pickle = Mypickle(settings.studentinfo)
        student_pickle.dump((student_obj))
        print('\033[1;31m學生創建成功!\033[0m')
        a = 'Create a student'
        self.obj.record(a)

    #創建講師賬號
    def create_teacher(self):
        teacher_name = input('teacher name>').strip()
        teacher_pwd = input('teacher password>').strip()
        md5_obj = hashlib.md5(teacher_name.encode('utf-8'))
        md5_obj.update(teacher_pwd.encode('utf-8'))
        md5_passwd = md5_obj.hexdigest()
        user = '%s|%s|%s\n' % (teacher_name,md5_passwd,'Teacher')
        with open(settings.userinfo,'a',encoding='utf-8') as f:
            f.write(user)

        #給老師選擇一個校區
        self.show_school()

        school_num = input('請輸入老師所在的校區序號:').strip()
        school_obj = self.school_pickle.get_item(int(school_num))
        #創建一個屬於老師的新對象
        teacher_obj = Teacher(teacher_name)

        #將老師選擇的校區和老師對象綁定在一起
        teacher_obj.school = school_obj

        #將老師對象dump進入teacherinfo文件
        teacher_pickle = Mypickle(settings.teacherinfo)
        teacher_pickle.dump(teacher_obj)
        print('\033[1;31m老師創建成功!\033[0m')
        a = 'Create a teacher'
        self.obj.record(a)

    # 查看學校
    def show_school(self):
        for num,school_obj in enumerate(self.school_pickle.load(),1):
            print(num,school_obj)
        print('')
        a = 'View school information'
        self.obj.record(a)



    #查看講師
    def show_teacher(self):
        for num,teacher_obj in enumerate(self.teacher_pickle.load(),1):
            print(num,teacher_obj)
        a = 'View instructor information'
        self.obj.record(a)

    #查看學生
    def show_student(self):
        for num,student_obj in enumerate(self.student_pickle.load(),1):
            print(num,student_obj)
        a = 'View student information'
        self.obj.record(a)

    #查看班級
    def show_class(self):
        for num,class_obj in enumerate(self.class_pickle.load(),1):
            print(num,class_obj)
        a = 'View class information'
        self.obj.record(a)

    #查看課程
    def show_course(self):
        for num,course_obj in enumerate(self.course_pickle.load(),1):
            print(num,course_obj)
        a = 'View course information'
        self.obj.record(a)



    def quit(self):
        print('\033[1;31m再見啦！！！\033[0m')
        a = 'Program exits'
        self.obj.record(a)
        exit()

#! /bin/env python
# coding: utf-8
import pickle


class Mypickle:
    def __init__(self,filepath):
        self.filepath = filepath


    def dump(self,school_obj):
        with open(self.filepath, 'ab') as f:
            pickle.dump(school_obj, f)
            f.flush()


    def load(self):
        with open(self.filepath,'rb') as f:
            while True:
                try:
                    schoole_obj = pickle.load(f)
                    yield schoole_obj
                    # print(schoole)
                except Exception:
                    break

    def get_item(self,num):
        with open(self.filepath, 'rb') as f:
            while num > 0:
                try:
                    schoole_obj = pickle.load(f)

                except Exception:
                    break
                num -= 1
        return schoole_obj

#! /bin/env python
# coding=utf-8

class School:
    def __init__(self, name, addr):
        self.school_name = name
        self.school_addr = addr

    def __repr__(self):  #內置的方法，讓打印的對象豐富起來
        show_str = ''
        for key in self.__dict__:
            show_str +='%s:%s ' % (key,  self.__dict__[key])

        return show_str

#! /bin/env python
# coding=utf-8
from collections import OrderedDict
from core import Manager

class Student:
    dic = OrderedDict([('查看學校', 'show_school'),
                       ('查看班級', 'show_class'),
                       ('查看課程', 'show_course'),
                       ('退出', 'quit')])
    def __init__(self,name):
        self.student_name = name
        self.obj = Manager.Manager(name)


    def __repr__(self):  #內置的方法，讓打印的對象豐富起來
        show_str = ''
        for key in self.__dict__:
            if key == 'obj':continue
            show_str +='%s:%s ' % (key,  self.__dict__[key])

        return show_str

    def show_school(self):
        self.obj.show_school()


    def show_class(self):
        self.obj.show_class()

    def show_course(self):
        self.obj.show_course()

    def quit(self):
        self.obj.quit()

#! /bin/env python
# coding=utf-8
from collections import OrderedDict
from core import Manager


class Teacher:
    dic = OrderedDict([('查看學校', 'show_school'),
                       ('查看講師', 'show_teacher'),
                       ('查看班級', 'show_class'),
                       ('查看課程', 'show_course'),
                       ('退出', 'quit')])

    def __init__(self,name):
        self.teacher_name = name
        self.obj = Manager.Manager(name)


    def __repr__(self):  #內置的方法，讓打印的對象豐富起來
        show_str = ''
        for key in self.__dict__:
            if key == 'obj':continue
            show_str +='%s:%s ' % (key,  self.__dict__[key])

        return show_str



    def show_school(self):
        self.obj.show_school()

    def show_teacher(self):
        self.obj.show_teacher()

    def show_class(self):
        self.obj.show_class()

    def show_course(self):
        self.obj.show_course()

    def quit(self):
        self.obj.quit()