面向对象

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个月的小白,请大家清喷哈。

原文地址:https://www.cnblogs.com/little-hunter/p/6390517.html