面向对象

import sys
sys.path.append('..')
import pickle
from conf import setting
import os
com_path = setting.DATABASE
CC = setting.CLASSROOM_COURSE

class teacher():
    def __init__(self,name,age,favor,school,path):
        self.name = name
        self.age = age
        self.favor = favor
        self.school = school
        self.asset = 0
        self.classroom = []
        self.path = path
    def new_class(self,classromm_name):
        self.classroom.append(classromm_name)
        print('%s您有一个新班级%s'%(self.name,classromm_name))

    def earn(self):
        self.asset += 2
        print('您上课幸苦了，奖励2美金')

    def absent(self):
        self.asset -= 1
        print('很抱歉，因为您的缺勤，惩罚1美金,您现在还剩有%d'%self.asset)

class classroom():
    def __init__(self,name,obj_teacher,obj_courses,school,path):
        self.name = name
        self.obj_teacher = obj_teacher
        self.obj_courses = obj_courses
        self.school = school
        self.obj_students = []
        self.path = path
    def new_student(self,new_student):
        self.obj_students.append(new_student)


class courses():
    def __init__(self,name,time,fee,school):
        self.name = name
        self.time = time
        self.fee = fee
        self.school = school
    def belearn(self):
        print('今天是第一天，欢迎来到计算机的编程世界。在上课之前，我们先来了解一下计算机编程语言的起源...')

class school():
        def __init__(self,name,addr,level):
            self.name = name
            self.addr = addr
            self.level = level
            self.obj_class = []
            self.path = '%s\%s\%s.txt'%(com_path['path'],com_path['school'],name)
        def creat_course(self):
            try:
                courses_name,courses_time,courses_fee = input('请按以下格式输入：课程名字-时长-费用：').strip().split('-')
                c1 = courses(courses_name,courses_time,courses_fee,self.name)
                course_path = '%s\%s\%s.txt'%(com_path['path'],com_path['course'],c1.name)
                ret = generator_file(course_path,c1)
                if ret:
                    print('课程创建成功 %s-%s-%s-%s'%(c1.name,c1.time,c1.fee,self.name))
            except AttributeError:
                print('对应班级的课程不存在')
        def creat_classroom(self):
            classroom_name, classroom_teacher = input('请输入班级名称-老师名字').strip().split('-')
            #取到老师的对象
            obj1 = get_obj('teacher',classroom_teacher)
            #取到课程对象,班级和课程的对应关系在setting中定义
            classroom_courses = CC[classroom_name]
            obj2 =get_obj('course',classroom_courses)
            class_path = '%s\%s\%s.txt'%(com_path['path'],com_path['class'],classroom_name)
            #创建班级的对象
            c3 = classroom(classroom_name,obj1,obj2,self.name,class_path)
            ret = generator_file(class_path,c3)
            if ret:
                print('班级创建成功 %s-%s-%s-%s'%(c3.name,c3.obj_teacher.name,c3.obj_courses.name,self.name))
                #更新老师对象中的classroom列表
                obj1.new_class(classroom_name)
                update_file(obj1.path,obj1)
            return c3
        #学校增加新班级
        def new_class(self,new_class):
            self.obj_class.append(new_class)
        #学校更新班级
        def update_class(self,obj_update_class):
            for item in self.obj_class:
                if item.name == obj_update_class.name:
                    self.obj_class[self.obj_class.index(item)] = obj_update_class
                    print('班级信息更新成功')

def generator_file(path,obj):
    if os.path.isfile(path):
        print('33[31;0m此名字的对象已经存在，请使用其他名字33[1m')
        return False
    else:
        with open(path,'wb') as f:
            pickle.dump(obj,f)
        return True

def update_file(path,obj):
    with open(path,'wb') as f:
        pickle.dump(obj,f)
    return True

def get_obj(class_name,name):
    path = '%s\%s\%s.txt'%(com_path['path'],com_path[class_name],name)
    if os.path.isfile(path):
        with open(path,'rb') as f:
            obj = pickle.load(f)
        return obj
    else:
        print('33[31;0m对象不存在33[1m')


def run():
    exit_flag = False
    while not exit_flag:
        #学校是独立的
        inp = input('33[34;0m0:创建学校，1：创建课程，2：创建老师，3：创建班级33[1m').strip()
        if inp == '0':
            school_name,school_addr,school_level = input('请输入：学校名称-地址-等级').strip().split('-')
            s1 = school(school_name,school_addr,school_level)
            school_path = '%s\%s\%s.txt'%(com_path['path'],com_path['school'],s1.name)
            generator_file(school_path,s1)
        #通过学校创建课程
        if inp == '1':
            temp = input('请输入学校的名字：').strip()
            school_obj = get_obj('school',temp)
            school_obj.creat_course()
        #创建老师，关联学校
        elif inp == '2':
            teacher_name, teacher_age, teacher_favor,teacher_school = input('请输入：老师名字-年龄-爱好-学校').strip().split('-')
            teacher_path = '%s\%s\%s.txt'%(com_path['path'],com_path['teacher'],teacher_name)
            c2 = teacher(teacher_name,teacher_age,teacher_favor,teacher_school,teacher_path)
            ret = generator_file(teacher_path,c2)
            if ret:
                print('老师创建成功 %s-%s-%s-%s'%(c2.name,c2.age,c2.favor,c2.school))
        #通过学校创建班级,关联老师和课程
        elif inp == '3':
            temp = input('请输入学校的名字：').strip()
            school_obj = get_obj('school',temp)
            new_class = school_obj.creat_classroom()
            school_obj.new_class(new_class)
            #班级创建成功后，学校的班级列表信息更新，所以需要更新学校信息
            school_path = '%s\%s\%s.txt'%(com_path['path'],com_path['school'],temp)
            update_file(school_path,school_obj)
        elif inp == 'b':
            exit_flag = True

编程小白学习面向对象。之前听信息的同学说过，但是一直不理解，现在总算是明白了，对象就是一个盒子，用来封装东西。造盒子需要机器，造对象需要类。所有的对象都是基于类存在的，要是没有类，那就没有对象。

类的主要特点是：继承（python中一个子类（派生类）可以继承多个父类（基类））、封装、多态（在python中不明显）

继承：在不改变类1属性和方法的前提下，给类1添加类2的方法。注意当类2中含有类1不存在的字段，那么类2中含有这样字段的方法就不能被类1继承。分为单继承和多继承。

1. 单继承： Class c1(c2) c1就会继承c2。 继承的本质就是把c2中的方法在c1中再写一遍，注意self = obj 所以找的时候都是从底层开始，要是c1 和c2中的都有同样的方法，那么先执行自己的方法
2. 多继承：Class c1(c2, c3) c1就会继承c2, c3, 先继承左边的， 先不找到最顶层，先将分支找完再找顶层

类的三大成员：字段，方法（函数的在类中的叫法，等同于函数），属性

Class c1() 在类后面加了括号，python就会自动执行class中的__init__对象. __init__(self)。 __init__中可以存放类的普通字段，只有在创建对象的时候，通过对象才能调用；可以放其他对象作为封装对象导入。

• 字段，__init__中的变量(属性，名字，年龄等)，注意需要自己访问自己的字段

1. 普通字段，是在__init__方法中的字段，只有通过对象才能调用。Obj.name
2. 静态字段，是在类中（但是不在方法中）的字段，可以通过类来调用。 CC = “Money”, 可以通过类直接访问，可以保存所有对象的相同的变量

• 方法，类中的函数， 其中的__init__方法称为构造方法 (动作，操作)

1. 普通方法: 方法属于类，但是需要通过对象去调用，obj.show()
2. 静态方法: 去掉self, 可以有多个参数，@staticmethod, 方法属于类，通过类去调用。C1.show()
3. 类方法: 是静态方法的一种形式，至少要有一个参数， @classmethod，通过类去调用。自动传递类名。 cls() #加上括号是创建对象，可以实现单列模式

• 属性，具有方法的表现形式，但是具有字段的访问形式，@property。 可以通过obj.pager = 111, 来给字段赋值，@count_pager.setter。 通过del obj.pager来删除字段或者方法，可以通过@count_pager.deleter
• 属性的另外一种表现形式是： foo = property(fget=f1,fset=f2,fdel=f3)，p.foo执行f1；p.foo=’alex’ 执行f2；del p.foo 执行f3

 下面说说需哦选课系统的感悟吧，说实在我觉得自己真的是不太聪明，写了整整两天，才做完

1.有学校，课程，班级，老师，学生这些名词，所以这些肯定是需要建类的

2.一般生活中是有学校，学校根据市场行情创建课程，然后根据课程找老师，然后建立班级，然后有学生闻声而来，注册，选课，上课，之后老师收钱，学生拿分数之类的。这样理解之后，那大致思路就是学校这个类中，需要能创建课程、创建老师、创建班级的方法。而这些功能只有管理员才能做。

3.老师主要负责上课，给学生打分数，可以请假，就老师上课这个操作，我觉得在面向对象中就不容易，需要在建立班级的时候，需要告诉对应班级的老师，他有哪个班级，需要上什么课。

4.学生，需要注册，交学费，选课，上课。其中在选课上，我卡了很久，因为现实生活中，学生选完课就结束了，但是还需要添加学生名字到班级中（上大学时候很多班级都有变态的人数限制）。又因为班级信息是在学校对象中有保存的（方面查看每个学校有几门课，每门课有几个学生），所以学生选完课之后，自己的课程表要更新（一个学生可以上多门课），然后班级对象中的学生列表要更新，还有学校类表中的班级对象要更新。之后就是各种文件更新，调用路径，还有写了一个upodate_file函数，还学会了在一个py脚本中调用另外一个py脚本的函数，这样才避免了很多重复代码。

总之，主程序我写了3个，admin(管理员界面)，teacher（教师界面），student（学生界面）

贡献一下我的admin的代码吧，作为初学编程2个月的小白，请大家清喷哈。