面向对象的应用：学生选课系统

Posted 2020-07-21 wangheng #这里是用户名

一、要求： 选课系统

管理员：
创建老师：姓名、性别、年龄、资产
创建课程：课程名称、上课时间、课时费、关联老师
使用pickle保存在文件

学生：
学生：用户名、密码、性别、年龄、选课列表[]、上课记录{课程1：【di,a,】}
1、列举所有课程
2、选择课程
3、学生上课，
4、ret = 课程.work() 获取课程的返回; 资产+=课时费

二、代码思路

2.1 管理员系统

a、定义了Teacher类，name,age,gender,property，其中property为私有成员，用对象调用普通方法可修改和提取self.__property
b、定义了Course类，course_name,course_time,coure_cost,teacher_obj
c、创建了3个老师、3个课程
d、最后把三个课程对象放入列表，然后将列表直接pickle.dump进course_list文件（存入的每一个元素是课程对象）

2.2学生端（导入pickle和管理员文件）

a、定义了Student类，name,pwd,gender,age,l2,w，其中：l2是选课列表，w是上课次数字典，key为课程名，value为上课次数
选课方法、删除课程方法、上课方法

b、通过load course_list文件，获取课程对象，打印所有课程名（有哪些课程可以选择）
c、选课：
首先通过load提取学生文件内容，打印上一次已经选择的课程
输入要选的课程，如果该课程已经选择则提示选课重复，如果不重复，再append进选课列表
选完再打印一次截止目前，已经选择的所有课程

d、删除课程：
打印可以删除的课程（已经选择的课程）
输入要删除的课程，判断课程是否存在，存在则删除，不存在则显示不存在

e、上课：
通过load提取学生文件内容，打印上一次已经选择的课程和已经上过的课程
输入要上的课程，如果课程是已经选择的课程，则以课程名为key对应的value值加1，否则创建该键值对
如果不是已经选择的课程，则提示课程不存在
return 该上课次数字典
注：整体上课过程，只有上课字典的键值对发生改变

f、学生用户名和密码
保存进字典，dump进文件，再load进来，再进行判断，如果一致，则允许进入系统

g、老师课时费计算：
创建老师课时费字典{}
将所有学生的上课次数字典合并为一个字典
循环课程对象，当课程名==学生上过的课程名，则对应课程的 老师课时费=每个课程课时费*上课次数
h、老师总资产计算
创建老师总资产字典
循环课程对象，当课程对象的老师已经存在于课时费字典里，则 老师总资产=老师总课时费+初始资产
当课程对象的老师不存在于课时费字典里，即该老师没上课，其总资产就是初始资产

注：老师私有资产是通过 对象调用普通方法实现调用私有成员

三、文件概述

本程序一共6个文件： Administrator.py 是管理员文件
student.py 是学生端文件
course_list 是课程对象文件
name_pwd 是两个学生小明和小红的用户名和密码文件
小明 是小明的选课记录和上课次数文件
小红 是小红的选课记录和上课次数文件

四、代码实现

4.1管理员文件

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

import pickle

class Teacher:
    def __init__(self,name,age,gender,property):
        self.name=name
        self.age=age
        self.gender=gender
        self.__property=property
    def __str__(self):
        print(self.name)

    def property_check(self):
        return self.__property


class Course:
    def __init__(self,course_name,course_time,coure_cost,teacher_obj):
        self.course_name=course_name
        self.coure_cost=coure_cost
        self.course_time=course_time
        self.teacher_obj=teacher_obj


t1=Teacher(‘alex‘,18,‘man‘,300)
t2=Teacher(‘eric‘,19,‘woman‘,200)
t3=Teacher(‘oldboy‘,19,‘man‘,300)

c1=Course(‘生物‘,10,300,t1)
c2=Course(‘数学‘,10,500,t2)
c3=Course(‘美术‘,10,800,t3)

l1=[c1,c2,c3]
pickle.dump(l1,open(‘course_list‘,‘wb‘))

4.2学生端

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

import pickle
import Administrator

class Student:
    def __init__(self,name,pwd,gender,age,l2,w):
    #l2选课列表        w是上课次数字典，key为课程名，value为上课次数
        self.name=name
        self.pwd=pwd
        self.gender=gender
        self.age=age
        self.l2=l2
        self.w=w
    def selecting_courses(self):
        print(‘%s已选的课程列表为‘ %self.name,self.l2)
        while True:
            print(‘学生%s选课‘ %self.name)
            a=input(‘请输入课程名选择课程，每个课程只能选择一次，输入q退出选课:‘)
            if a==‘q‘:
                break
            if a in self.l2:
                print(‘您输入的课程有重复，请重新选择:‘)
                continue
            self.l2.append(a)
        print(‘%s已选的课程列表为‘ %self.name,self.l2)

    def del_course(self):
        print(‘%s可以删除的课程列表为‘ %self.name,self.l2)
        while True:
            a=input(‘请输入您要删除的课程,输入q退出：‘)
            if a==‘q‘:
                break
            if a not in self.l2:
                print(‘您输入的课程不存在，请重新输入:‘)
                continue
            else:
                del self.l2[self.l2.index(a)]

    def attend_class(self):
        print(‘%s已上过的课程清单为%s,可以上的课程列表为%s‘%(self.name,self.w,self.l2))
        # c={}
        while True:
            a=input(‘请输入要上课的课程名，输入q退出选课:‘)
            if a==‘q‘:
                break
            if a not in self.l2:
                print(‘您选择的课程不存在，请重新输入:‘)
                continue
            else:
                if a in self.w:  #创建上课次数字典
                    self.w[a]+=1
                else:
                    self.w[a]=1

        print(‘%s已上过的课程清单为%s‘%(self.name,self.w))
        return self.w

a=pickle.load(open(‘小明‘, ‘rb‘))  #读取小明上次的选课和上课次数，
                                  # a[0]为小明以前选的所有课程列表，a[1]为小明以前上过的所有课程和上课次数
b=pickle.load(open(‘小红‘, ‘rb‘))


std1=Student(‘小明‘,1,‘man‘,18,a[0],a[1])
std2=Student(‘小红‘,2,‘weman‘,18,b[0],b[1])

s={‘小明‘:1,‘小红‘:2}
pickle.dump(s,open(‘name_pwd‘,‘wb‘))
ss=pickle.load(open(‘name_pwd‘,‘rb‘))

r=pickle.load(open(‘course_list‘,‘rb‘))
ret1=std1.w
ret2=std2.w
# d,e=input(‘请输入%s的用户名和密码，用空格隔开，小明用户名是小明，密码是1:‘%std1.name).split(‘ ‘)
d,e=‘小明‘,‘1‘
if d==‘小明‘ and int(e)==ss[‘小明‘]:
    print(std1.name,‘当前可选的课程为：‘)
    for i in r:
        print(i.course_name)
    print(‘===================================================‘)
    while True:
        a=int(input(‘请输入序号进行选择：1.选课 2.删除课程 3.上课 4.退出‘))
        if a==1:
            std1.selecting_courses()
        elif a==2:
            std1.del_course()
        elif a==3:
            ret1=std1.attend_class()
            a=[std1.l2,std1.w]
            pickle.dump(a,open(‘小明‘,‘wb‘))
        elif a==4:
            break
        else:
            print(‘您的输入有误，请重新输入‘)


d,e=input(‘请输入%s的用户名和密码，用空格隔开，小红用户名是小红，密码是2:‘ %std2.name).split(‘ ‘)
if d==‘小红‘ and int(e)==ss[‘小红‘]:
    print(std2.name,‘当前可选的课程为：‘)
    for i in r:
        print(i.course_name)
    print(‘===================================================‘)
    while True:
        a=int(input(‘请输入序号进行选择：1.选课 2.删除课程 3.上课 4.退出‘))
        if a==1:
            std2.selecting_courses()
        elif a==2:
            std2.del_course()
        elif a==3:
            ret2=std2.attend_class()
            b=[std2.l2,std2.w]
            pickle.dump(b,open(‘小红‘,‘wb‘))
        elif a==4:
            break
        else:
            print(‘您的输入有误，请重新输入‘)

for i in ret2:  #合并学生1和学生2的字典
    if i in ret1:
        ret1[i]+=ret2[i]
    else:
        ret1[i]=ret2[i]
print(‘所有学生已上过的课程总次数字典为%s‘%ret1)
c={} #课时费字典
for i in r:#上完课程，开始计算该学生给所有老师创造的所有课时费,i课程对象
            for k,v in ret1.items(): # ret1两个学生合并后的上课字典
                if i.course_name==k:
                        c[i.teacher_obj]=i.coure_cost*v  #老师总课时费=课时费*上课次数


g={} #总资产字典（防止有老师并没有上课），加上老师的原始资产
for i in r:#i课程对象,根据课程提取老师对象
    if i.teacher_obj in c:
        g[i.teacher_obj]=c[i.teacher_obj]+i.teacher_obj.property_check()#老师总资产=总课时费+初始资产
    else:
        g[i.teacher_obj]=i.teacher_obj.property_check() #如果老师没上课，总资产=初始资产
                                                        #通过普通方法调用私有成员
#打印老师总资产
for i,j in g.items():
    print(‘%s老师的总资产为%s‘%(i.name,j))