学生选课系统

待我称王封你为后i 2023-08-17 15:25 81阅读 0赞

#### 题目要求 ####

利用规范化目录结构完成一个学生选课系统。  
**角色：**学生、管理员。  
功能分析：  
用户登录之后就可以直接判断用户身份，是学生还是管理员。  
学生登录之后有以下几个功能：  
查看所有课程。  
选择课程。  
查看所选课程。  
退出程序。  
管理员登录之后有以下几个功能：  
创建课程(需要记录日志)。  
创建学生账号(需要记录日志)。  
查看所有课程。  
查看所有学生。  
查看所有学生的选课情况。  
退出程序。  
课程属性：课程名，价格，周期，老师。  
学生属性：姓名，所选课程。  
管理员属性：姓名。

##### start #####

import os  
import sys  
BATH\_DIR = os.path.dirname(os.path.dirname(**file**))  
sys.path.append(BATH\_DIR)

# 添加搜索路径 确定当前工程的搜索路径 定位到 老师版本学生选课系统,可千万不能变成每周大作业了 为了查找具体的路径 #

from core import src  
from core.src import Course  
from core.src import Student  
if **name** == '**main**':  
src.main()

##### src #####

import sys  
import os  
import pickle  
from lib import common  
from conf import settings

class Base: \#

def show_courses(self):
        with open(settings.COURSE_PATH, mode='rb') as f:
            num = 0
            while 1:
                try:
                    num += 1
                    obj = pickle.load(f)   #  # obj获取每行的课程 每行课程是一个对象
                    print(f'{num}: {obj.name} {obj.price} {obj.period}')# 打印对应的课程以及序列号
                    '''
                        1: Python周末班 12000 6个月
                        2: python脱产班 23000 6个月
                        3: 大数据 13000 4个月
                        4: java 12000 5个月
                        5: 测试 12000 6个月
                        6: 算法工程师 36000 6个月
                        7: 前端 12000 4个月
                        8: 平面设计 2345 六个月
                    '''
                except EOFError:  # 读完之后直接停止,防止循环读内容报错
                    break
    
    def exit(self):  # 使用这个函数退出,并且打印退出提示信息
        sys.exit(f'\033[0;32m感谢{self.name}使用选课系统！\033[0m')
        # sys.exit所用是退出并且打印内容,是sys模块里面的一个功能

class Student(Base):  
operate\_lst = \[('查看可选课程', 'show\_courses'),  
('选择课程', 'select\_course'),  
('查看所选课程', 'show\_selected\_course'),  
('退出', 'exit')\] \# 静态属性

def __init__(self, name):
        self.name = name       #  定义两个属性
        self.courses = []      #  空列表,为了后面添加课程
    
    def select_course(self):
        """选择课程"""
        self.show_courses()# 先把课程打印出来 调用父类方法
        try:
            choice_num = input('\033[0;32m请输入要选择的课程序号：\033[0m').strip()
            # 输入要添加的课程序号
            with open(settings.COURSE_PATH, mode='rb') as f:
                for i in range(int(choice_num)):
                    # 根据输入的序号确定循环次数最终锁定选择的课程对象
                    #  比如 range(5)  循环 5 次
                    obj = pickle.load(f)  ##  拿出最后一个  最后被覆盖  # load读出来 用obj接收所选的课程对象
                self.courses.append(obj)   #  将课程添加到里面
            print(f'\033[0;32m您已经成功添加了{obj.name}课程\033[0m')
            # 把所选的课程添加到学生对象所对应的课程列表中
        
        except Exception:
            print('输入有误....')
    
    def show_selected_course(self):
        """查看所选课程"""
        print(f'\033[0;32m您已报名如下课程\033[0m')
        for obj_course in self.courses:
            # 循环此学生对象的列表,然后把所有课程的打印,每个课程也是一个对象
            print(f'\033[0;32m课程名：{obj_course.name}，课程价格：{obj_course.price} 课程周期：{obj_course.period}\033[0m')
    
    def exit(self):
        """退出之前要将学生选择的课程添加上"""
        with open(settings.STUDENT_PATH, mode='rb') as f1, \
                open(f'{settings.STUDENT_PATH}_bak', mode='wb') as f2:
            '''打开两个文件,读旧文件,写新文件'''
            while 1:   # 循环读内容
                try:
                    obj = pickle.load(f1)
                    pickle.dump(self if obj.name == self.name else obj, f2)
                    ''' 把相应的对象名修改成现在的,其他的对象名直接写入
                    
                    '''
                except EOFError:
                    break
        os.remove(settings.STUDENT_PATH)
        os.rename(f'{settings.STUDENT_PATH}_bak', settings.STUDENT_PATH)   #  改名字
        super().exit()
    
    @classmethod
    def get_obj(cls, username):
        """此方法是区别学生与管理员登录，学生登录就会去文件中取对象，管理员登录则直接userinfo获取管理员用户名密码"""
        with open(settings.STUDENT_PATH, mode='rb') as f1:
            while 1:
                try:
                    obj = pickle.load(f1)
                    print(obj)
                    if username == obj.name:
                        return obj
                except EOFError:
                    break

class Manager(Base):  
operate\_lst = \[('创建课程', 'create\_course'),  
('创建学生', 'create\_student'),  
('查看可选课程', 'show\_courses'),  
('查看所有学生', 'show\_students'),  
('查看所有学生选课情况', 'show\_students\_courses'),  
('退出', 'exit')\]

def __init__(self, name):
        self.name = name
    
    def create_course(self):
        """创建课程"""
        course = getattr(sys.modules[__name__], 'Course')
        name, price, period = input('请依次输入课程名，价格以及课程周期，以|分割').strip().split('|')
        obj = course(name, price, period)
        with open(settings.COURSE_PATH, mode='ab') as f1:
            pickle.dump(obj, f1)
        logger = common.record_logger()
        logger.info(f'成功创建{name}课程')
    
    def create_student(self):
        """创建学生"""
        student_username = input('\033[0;32m 请输入学生姓名：\033[0m').strip()
        student_password = input('\033[0;32m 请输入学生密码：\033[0m').strip()
        student_pwd_md5 = common.hashlib_md5(student_password)
        with open(settings.USERINFO_PATH, encoding='utf-8', mode='a') as f1:
            f1.write(f'\n{student_username}|{student_pwd_md5}|Student')
        with open(settings.STUDENT_PATH, mode='ab') as f:
            obj = getattr(sys.modules[__name__], 'Student')(student_username)
            pickle.dump(obj, f)
        logger = common.record_logger()
        logger.info(f'成功您已成功创建学生账号：{student_username},初始密码：{student_password}')
    
    def show_students(self):
        """查看所有学生"""
        with open(settings.STUDENT_PATH, mode='rb') as f1:
            while 1:
                try:
                    obj = pickle.load(f1)
                    print(obj.name)
                except EOFError:
                    break
    
    def show_students_courses(self):
        """查看所有学生选课情况"""
        with open(settings.STUDENT_PATH, mode='rb') as f1:
            while 1:
                try:
                    obj = pickle.load(f1)
                    print(f'\033[0;32m学生:{obj.name},所选课程：\
                    {["%s-%s-%s" %(course.name,course.price,course.period) for course in obj.courses]}\033[0m')
                except EOFError:
                    break
    
    def exit(self):
        """退出"""
        super().exit()
    
    @classmethod
    def get_obj(cls, username):
        return Manager(username)  #  实例化的过程

class Course:  
def **init**(self, name, price, period):  
self.name = name  
self.price = price  
self.period = period  
self.teacher = None

def login():  
"""登陆逻辑,此处是用了单次登陆验证，你也可以根据自己的需求改成三次登陆失败才返回False"""  
count = 1  
while count < 4:  
username = input('请输入用户名：').strip()  
password = input('请输入密码：').strip()  
pwd\_md5 = common.hashlib\_md5(password) \# 这一步是加密  
with open(settings.USERINFO\_PATH,mode='r', encoding='utf-8') as f1:  
for line in f1: \# 一行一行读取  
if not line.strip(): \# 如果是空字符串,不空就是 True 继续执行  
continue \# 继续走 for  
user, pwd, identify = line.strip().split('|') \#去掉结尾\\n 分割之后是列表  
if user == username and pwd == pwd\_md5:  
return \{'username': user, 'identify': identify, 'auth': True\} \# 成功了 这个状态就是True  
else:  
print('用户名或者密码错误，请重新输入')  
count += 1  
return \{'username': username, 'identify': None, 'auth': False\} \# 失败了就把状态改为 False

def main():  
print('\\033\[0;32m欢迎访问选课系统，请先登录\\033\[0m')  
dict\_auth = login()  
print(f"\\033\[0;32m登陆成功，欢迎\{dict\_auth\['username'\]\}，您的身份是\{dict\_auth\['identify'\]\}\\033\[0m")  
if dict\_auth\['auth'\]:  
'''根据不同的身份，进行相应的操作,登录成功状态就改为 True'''  
if hasattr(sys.modules\[**name**\], dict\_auth\['identify'\]): \# 必须找到这个类,才能调用后续的方法  
'''反射到本模块,找到 identify 对应的类 反射 判断对象是否存在,存在就是返回 True 否则 False'''  
cls = getattr(sys.modules\[**name**\], dict\_auth\['identify'\]) \# 得到类名地址  
'''  
如果是管理者登录:  
obj = cls(dict\_auth\['username'\])  
如果是学生登录:  
从Student文件中 读取该学生对象并返回:  
打开文件,读取文件: pickle.load(f) dic\_auth\['username'\] == obj.name  
obj = 文件中读取的学生对象  
'''  
obj = cls.get\_obj(dict\_auth\['username'\]) \# 管理员与学生都定义了此方法，鸭子类型.  
while 1:  
for num, option in enumerate(cls.operate\_lst, 0): \# 类名. 这个万能的点 \# num 将元组解构  
'''  
operate\_lst = \[('创建课程', 'create\_course'),  
('创建学生', 'create\_student'),  
('查看可选课程', 'show\_courses'),  
('查看所有学生', 'show\_students'),  
('查看所有学生选课情况', 'show\_students\_courses'),  
('退出', 'exit')\]  
'''  
print(f'\{num+1\}: \{option\[0\]\}')  
'''  
输出是这个东东  
1: 创建课程  
2: 创建学生  
3: 查看可选课程  
4: 查看所有学生  
5: 查看所有学生选课情况  
6: 退出

num 的作用就是解构,坤坤说这些都是旧的知识点,我的妈呀,难受,竟然都不知道
                '''
            choice_num = int(input('\033[0;32m 请输入选项：\033[0m').strip())
            getattr(obj, cls.operate_lst[choice_num - 1][1])()  # getattr(obj,'create_course')() 已经调用这个函数了
    
    else:
        print('三次验证失败，系统自动退出')
        return False

##### settings #####

import os  
import logging.config  
BATH\_DIR = os.path.dirname(os.path.dirname(**file**))  
USERINFO\_PATH = os.path.join(BATH\_DIR, 'db', 'user\_info')  
COURSE\_PATH = os.path.join(BATH\_DIR, 'db', 'Course')  
STUDENT\_PATH = os.path.join(BATH\_DIR, 'db', 'Student')  
LOGGING\_PATH = os.path.join(BATH\_DIR, 'log', 'admin.log')  
SIMPLE\_FORMAT = '\[%(asctime)s\] %(message)s'

LOGGING\_DIC = \{  
'version': 1,  
'disable\_existing\_loggers': False,

'formatters': {
        
        'simple': {
            'format': SIMPLE_FORMAT,
        },
    },
    'filters': {},
    'handlers': {
        # 打印到终端的日志
        'stream': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        # 打印到文件的日志,收集info及以上的日志
        'file': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'simple',
            'filename': LOGGING_PATH,  # 日志文件
            'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        # logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['stream', 'file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },

##### common #####

import hashlib  
import logging.config  
from conf.settings import LOGGING\_DIC

def hashlib\_md5(password):  
"""密码加密"""  
ret = hashlib.md5()  
ret.update(password.encode('utf-8'))  
return ret.hexdigest()

def record\_logger():  
"""记录日志"""  
logging.config.dictConfig(LOGGING\_DIC) \# 导入上面定义的logging配置  
logger = logging.getLogger() \# 生成一个log实例  
return logger

转载于:https://www.cnblogs.com/hualibokeyuan/p/11372414.html