python面向对象思维之选课系统

了解一点面向对象作用：

       对于编程语言的初学者来讲，OOP不是一个很容易理解的编程方式，大家虽然都知道OOP的三大特性是继承、封装、多态，并且大家也都知道了如何定义类、方法等面向对象的常用语法，但是一到真正写程序的时候，还是很多人喜欢用函数式编程来写代码，特别是像我一样的初学者，很容易陷入一个窘境就是“我知道面向对象，我也会写类，但我依然没发现在使用了面向对象后，对我们的程序开发效率或其它方面带来什么好处，因为我使用函数编程就可以减少重复代码并做到程序可扩展了，为啥子还用面向对象？”。 

　　无论用什么形式来编程，我们都要明确记住以下原则：

1. 写重复代码是非常不好的低级行为
2. 你写的代码需要经常变更 

　　开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不同就是，我们的代码总是需要不断的更改，不是修改bug就是添加新功能等，所以为了日后方便程序的修改及扩展，我们写的代码一定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。

 

　　如果你把一段同样的代码复制、粘贴到了程序的多个地方以实现在程序的各个地方调用 这个功能，那日后你再对这个功能进行修改时，就需要把程序里多个地方都改一遍，这种写程序的方式是有问题的，因为如果你不小心漏掉了一个地方没改，那可能会导致整个程序的运行都 出问题。 因此我们知道 在开发中一定要努力避免写重复的代码，否则就相当于给自己再挖坑。

　　所以面向对象的好处就是：使你的代码修改和扩展变的更容易。

python选课系统安排上：

需求：

角色:学校、学员、课程、讲师
要求:

1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
6. 创建讲师角色时要关联学校，
7. 提供三个角色接口
　　7.1 学员视图， 可以注册， 交学费， 选择班级，
　　7.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员 列表 ， 修改所管理的学员的成绩
　　7.3 管理视图，创建讲师， 创建班级，创建课程

解决方法：

解决这个问题之前，我们先来了解一下传说中的-----领域模型

领域模型 

好了，假设你现在会了面向对象的各种语法了，我相信你可能是蒙蔽的， 学会了面向对象的语法，却依然写不出面向对象的程序。

原因是什么呢？原因就是因为你还没掌握一门面向对象设计利器。

答案就是:领域建模。 从领域模型开始,我们就开始了面向对象的分析和设计过程,可以说,领域模型是完成从需求分析到面向 对象设计的一座桥梁。 

 

领域模型,顾名思义,就是需求所涉及的领域的一个建模,更通俗的讲法是业务模型。 参考百度百科(http://baike.baidu.cn/view/757895.htm ),领域模型定义如下: 

从这个定义我们可以看出,领域模型有两个主要的作用:

1. 发掘重要的业务领域概念
2. 建立业务领域概念之间的关系 

领域建模三字经 

领域模型如此重要,很多同学可能会认为领域建模很复杂,需要很高的技巧。然而事实上领域建模非常简 单,简单得有点难以让人相信,领域建模的方法概括一下就是“找名词”! 许多同学看到这个方法后估计都会笑出来:太假了吧,这么简单,找个初中生都会啊,那我们公司那些分 析师和设计师还有什么用哦?

分析师和设计师当然有用,后面我们会看到,即使是简单的找名词这样的操作,也涉及到分析和提炼,而 不是简单的摘取出来就可,这种情况下分析师和设计师的经验和技能就能够派上用场了。但领域模型分析 也确实相对简单,即使没有丰富的经验和高超的技巧,至少也能完成一个能用的领域模型。 

虽然我们说“找名词”很简单,但一个关键的问题还没有说明:从哪里找? 如果你还记得领域模型是“需求到面向对象的桥梁”,那么你肯定一下子就能想到:从需求模型中找,具 体来说就是从用例中找。 

 

归纳一下域建模的方法就是“从用例中找名词”。 当然,找到名词后,为了能够更加符合面向对象的要求和特点,我们还需要对这些名词进一步完善,这就 是接下来的步骤:加属性,连关系! 

 

最后我们总结出领域建模的三字经方法:找名词、加属性、连关系。 

 再看一下需求：

1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
6. 创建讲师角色时要关联学校，
7. 提供三个角色接口
    7.1 学员视图， 可以注册， 交学费， 选择班级，
    7.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员    列表 ， 修改所管理的学员的成绩
    7.3 管理视图，创建讲师， 创建班级，创建课程

1.找名词

who : 学员、讲师、管理员

2.加属性

分析一下：各个角色固有的属性，学员、教师、管理员各要实现哪些功能？这些功能就是属性，通过在类中定义对应的方法来实现。

3.连关系

所谓连关系就是将各属性分门别类，通过其他函数和用户的操作实现不同属性的过程。

此时你需要一个清晰的程序目录结构：

│  README        #程序说明
├─bin
│      main.py          # 启动入口
├─core # 核心代码
│  │  admin_view.py        # 学校\管理视图
│  │  data_deal.py        # 数据的增删改查实现
│  │  edu_class.py        #学校，学生，教师，课程，班级
│  │  student_view.py    # 学生视图
│  │  teacher_view.py    # 老师视图
└─datas
        datas.pk        #日志文件

接下来为你端上每个源程序的代码：

'''
启动程序
'''
import os
import sys

# 导入路径
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)
print(BASE_PATH)
'''从核心代码core中导入三种视图'''
from core import admin_view
from core import student_view
from core import teacher_view


def main():
    print("*"*50)
    choice = input("请输入角色：1 学校\t2 教师\t3 学生\n->")
    print("*" * 50)
    if choice == '1':
        admin_view.run()
    elif choice == '2':
        teacher_view.run()
    elif choice == '3':
        student_view.run()
    elif choice == '0':
        print("已退出程序！")
        return
    else:
        print("输入错误!\n********************")
        main()

if __name__ == "__main__":
    main()

# 作者：周浩强
'''
---------管理员视图---------------
功能：
    将 --->讲师类、班级类、课程类 进行实例化
    即：创建讲师， 创建班级，创建课程
'''
import os
import sys

# 导入路径
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)

from core import edu_class
from core import data_deal


def ch_school():
    print("选择学校：")
    data_deal.print_schools()
    school_name = input("学校名：")
    school = data_deal.get_school(school_name)
    if school == None:
        print("学校选择错误")
        return


def ch_course():
    print("选择课程：")
    data_deal.print_courses()
    course_name = input("课程名：")
    course = data_deal.get_course(course_name)
    if course == None:
        print("课程选择错误")
        return


def ch_teacher():
    print("选择老师：")
    data_deal.print_teachers()
    teacher_name = input("老师姓名：")
    teacher = data_deal.get_teacher(teacher_name)
    if teacher == None:
        print("老师选择错误")
        return


def add_grade():  # 创建班级
    print("请填写班级信息：")
    grade_name = input("名称：")
    ch_school()
    ch_course()
    ch_teacher()
    grade = school.create_grade(grade_name, teacher, course)
    data_deal.update_grade(grade)
    data_deal.update_school(school)


def add_school():  # 创建学校
    print("请填写学校信息：")
    school_name = input("名称：")
    address = input("地址：")
    school = edu_class.School(school_name, address)
    data_deal.update_school(school)


def add_course():  # 创建课程:linux , python , go 3个  linux\py 在北京开， go 在上海开
    print("请填写课程信息：")
    course_name = input("名称：")
    cycle = input("周期：")
    price = input("学费：")
    ch_school()
    course = school.create_course(course_name, cycle, price)
    data_deal.update_course(course)
    data_deal.update_school(school)


def add_teacher():  # 创建老师
    print("请填写教师信息：")
    teacher_name = input("姓名：")
    ch_school()
    teacher = school.create_teacher(teacher_name)
    data_deal.update_teacher(teacher)
    data_deal.update_school(school)
    print("老师 %s 创建成功！" % teacher.name)


def show_schools():
    data_deal.print_schools()


def show_courses():
    data_deal.print_courses()


def show_teachers():
    data_deal.print_teachers()


def show_grades():
    data_deal.print_grades()


def show_teacher():
    ch_teacher()
    teacher.show_info()


def run():
    print("\t学校视图\n","=" * 20)
    while True:
        print("1.增加学校\t2.增加老师\t3.增加课程\t4.增加班级\t"
              "5.查看学校\n6.查看老师\t7.查看课程\t8.查看班级\t"
              "9.查看教师详细\t"
              "0.退出")
        res = input("输入序号：")
        if res == "1":
            add_school()
        elif res == "2":
            add_teacher()
        elif res == "3":
            add_course()
        elif res == "4":
            add_grade()
        elif res == "5":
            show_schools()
        elif res == "6":
            show_teachers()
        elif res == "7":
            show_courses()
        elif res == "8":
            show_grades()
        elif res == "9":
            show_teacher()
        elif res == "0":
            print("退出成功！")
            break
        else:
            print("请选择正确的编号")


if __name__ == "__main__":
    run()

# 作者：周浩强
'''
---------学生视图---------------
功能：
    将----->学生类实例化，交学费，选择班级
'''
import os
import sys

# 导入路径
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)

from core import edu_class
from core import data_deal


# 选择函数集
def ch_school():
    print("选择学校：")
    data_deal.print_schools()
    school_name = input("学校名：")
    school = data_deal.get_school(school_name)
    if school == None:
        print("学校选择错误")
        return


def ch_course():
    print("选择课程：")
    data_deal.print_courses()
    course_name = input("课程名：")
    course = data_deal.get_course(course_name)
    if course == None:
        print("课程选择错误")
        return


def ch_teacher():
    print("选择老师：")
    data_deal.print_teachers()
    teacher_name = input("老师姓名：")
    teacher = data_deal.get_teacher(teacher_name)
    if teacher == None:
        print("老师选择错误")
        return


def ch_grade():
    print("选择班级：")
    data_deal.print_grades()
    grade_name = input("班级名：")
    grade = data_deal.get_grade(grade_name)
    if grade == None:
        print("班级选择错误")
        return


def ch_student():
    print("选择学生：")
    data_deal.print_students()
    student_name = input("学生名：")
    student = data_deal.get_student(student_name)
    if student == None:
        print("学生选择错误")
        return


# 学生视图函数集
def add_student():
    print("请填写学生信息：")
    name = input("姓名：")
    ch_school()
    ch_grade()
    student = edu_class.Student(name, school, grade)
    data_deal.update_student(student)
    data_deal.update_school(school)
    data_deal.update_grade(grade)


def pay_tuition():
    ch_student()
    money = input("请输入学费金额：")
    if not money.isdigit():
        print("输入金额格式不正确")
        return
    student.pay_tuition(int(money))
    data_deal.update_student(student)


def choose_grade():
    ch_student()
    ch_grade()
    student.choose_grade(grade)
    data_deal.update_student(student)
    data_deal.update_grade(grade)


def choose_school():
    ch_student()
    ch_school()
    student.choose_school(school)
    data_deal.update_student(student)
    data_deal.update_school(school)


def show_student():
    ch_student()
    student.show_info()


def show_students():
    data_deal.print_students()


def run():
    print("学生视图：")
    print("=" * 20)
    while True:
        print("1.增加学生\t2.交学费\t3.选择班级\t4.选择学校\t"
              "5.查看学生\t6.查看详细\t"
              "0.退出")
        res = input("输入序号：")
        if res == "1":
            add_student()
        elif res == "2":
            pay_tuition()
        elif res == "3":
            choose_grade()
        elif res == "4":
            choose_school()
        elif res == "5":
            show_students()
        elif res == "6":
            show_student()
        elif res == "0":
            print("退出成功！")
            break
        else:
            print("请选择正确的编号")


if __name__ == "__main__":
    run()

# 作者：周浩强
'''
---------讲师视图---------------
功能：
    讲师可管理自己的班级， 上课时选择班级，
    查看班级学员列表 ， 修改所管理的学员的成绩
    即：调用data_deal模块的功能
'''
import os
import sys

# 导入路径
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)

from core import edu_class
from core import data_deal


# 选择函数集
def ch_school():
    print("选择学校：")
    data_deal.print_schools()
    school_name = input("学校名：")
    school = data_deal.get_school(school_name)
    if school == None:
        print("学校选择错误")
        return


def ch_course():
    print("选择课程：")
    data_deal.print_courses()
    course_name = input("课程名：")
    course = data_deal.get_course(course_name)
    if course == None:
        print("课程选择错误")
        return


def ch_teacher():
    print("选择老师：")
    data_deal.print_teachers()
    teacher_name = input("老师姓名：")
    teacher = data_deal.get_teacher(teacher_name)
    if teacher == None:
        print("老师选择错误")
        return


def ch_grade():
    print("选择班级：")
    data_deal.print_grades()
    grade_name = input("班级名：")
    grade = data_deal.get_grade(grade_name)
    if grade == None:
        print("班级选择错误")
        return


def ch_student():
    print("选择学生：")
    data_deal.print_students()
    student_name = input("学生名：")
    student = data_deal.get_student(student_name)
    if student == None:
        print("学生选择错误")
        return


# 教师视图函数集
def choose_grade():
    ch_teacher()
    ch_grade()
    teacher.choose_grade(grade)
    data_deal.update_teacher(teacher)


def show_students():
    ch_teacher()
    teacher.show_students()


def modify_score():
    ch_teacher()
    ch_student()
    score = input("请输入分数：")
    if not score.isdigit() or 0 > int(score) or int(score) > 100:
        print("输入分数不正确")
        return

    teacher.modify_score(student, score)
    data_deal.update_teacher(teacher)
    data_deal.update_student(student)
    data_deal.update_grade(teacher.grade)
    print("%s 的成绩修改为: %s" % (student.name, data_deal.get_student(student_name).score))


def show_teacher():
    ch_teacher()
    teacher.show_info()


def run():
    print("教师视图：")
    print("=" * 20)
    while True:
        print("1.选择班级\t2.查看学生\t3.修改成绩\t4.查看教师\t0.退出")
        res = input("输入序号：")

        if res == "1":
            choose_grade()
        elif res == "2":
            show_students()
        elif res == "3":
            modify_score()
        elif res == "4":
            show_teacher()
        elif res == "0":
            print("退出成功！")
            break
        else:
            print("请选择正确的编号")


if __name__ == "__main__":
    run()

# 作者：周浩强

# 处理高层业务逻辑

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

    def show(self):
        pass

    def __str__(self):
        return self.name


class School(Education, object):
    '''学校类'''

    def __init__(self, name, address):
        super(School, self).__init__(name)
        self.address = address
        self.teachers = []
        self.students = []
        self.courses = []
        self.grades = []
        print("school:%s 创建成功" % name)

    def enroll(self, student):  # 学员注册
        self.students.append(student)
        print("%s 注册在 %s" % (student.name, self.name))

    def leave_schol(self, student):  # 学员退学
        self.students.remove(student)
        print("%s 从 %s 退学" % (student.name, self.name))

    def create_course(self, name, cycle, price):  # 创建课程
        '''通过学校创建课程，课程包含：周期、价格'''
        course = Course(name, cycle, price)
        self.courses.append(course)
        print("course: %s 创建成功" % name)
        return course

    def create_teacher(self, name):
        teacher = Teacher(name, self)
        self.teachers.append(teacher)
        print("teacher: %s 创建成功" % name)
        return teacher

    def hire_teacher(self, teacher):
        self.teachers.append(teacher)
        print("teacher: %s 雇佣成功" % teacher.name)

    def fire_teacher(self, teacher):
        self.teachers.remove(teacher)
        print("teacher: %s 从 %s 移除" % (teacher.name, self.name))

    def create_grade(self, name, teacher, course):
        '''学校创建班级，班级关联教师和课程'''
        grade = Grade(name, teacher, course)
        self.grades.append(grade)
        print("grade: %s 创建成功" % name)
        return grade


class Course(Education, object):
    '''创建课程'''

    def __init__(self, name, cycle, price):
        super(Course, self).__init__(name)
        self.cycle = cycle
        self.price = price


class Grade(Education, object):
    '''创建班级'''

    def __init__(self, name, teacher, course):
        super(Grade, self).__init__(name)
        self.teacher = teacher
        self.course = course
        self.students = []

    def enroll(self, student):  # 学员注册
        self.students.append(student)
        print("%s enroll in %s " % (student.name, self.name))

    def leave_grade(self, student):  # 学员离开
        self.students.remove(student)
        print("%s leave grade from %s " % (student.name, self.name))

    def show_info(self):
        print("grade:name: %s\t teacher:%s\t course:%s\t students:%s" %
              (self.name, self.teacher, self.course, self.students))


class Teacher(Education, object):
    '''创建老师'''

    def __init__(self, name, school):
        super(Teacher, self).__init__(name)
        self.school = None  # 为None时表示未选择学校
        self.choose_school(school)
        self.grade = None  # 为None时表示未选择班级

    def choose_school(self, school):
        if self.school != None:
            self.school.fire_teacher(self)
        school.hire_teacher(self)
        self.school = school

    def choose_grade(self, grade):
        self.grade = grade

    def show_students(self):
        if self.grade != None:
            for student in self.grade.students:
                student.show_info()
        else:
            print("请选择班级")

    def modify_score(self, student, score):
        student.score = score

    def show_info(self):
        print("teacher:name:%s\t school:%s\t grade:%s"
              % (self.name, self.school, self.grade))


class Student(Education, object):
    '''创建学员时，选择学校，关联班级'''

    def __init__(self, name, school, grade, score=0):
        super(Student, self).__init__(name)
        self.score = score
        self.school = None
        self.grade = None
        self.tuition = 0
        self.choose_school(school)
        self.choose_grade(grade)

    def choose_school(self, school):
        if self.school != None:
            self.school.leave_school(self)
        school.enroll(self)
        self.school = school

    def choose_grade(self, grade):
        if self.grade != None:
            self.grade.leave_grade(self)
        grade.enroll(self)
        self.grade = grade

    def pay_tuition(self, money):  # 交学费
        self.tuition += money

    def show_info(self):
        print("student:name: %s\t school:%s\t grade:%s\t score:%s\t tuition:%s"
              % (self.name, self.school, self.grade, self.score, self.tuition))


if __name__ == "__main__":
    school = School("淮南师范学院", "淮南")
    teacher = school.create_teacher("王老师")
    course = school.create_course("通信", "1年", 5000)
    grade = school.create_grade("大三", teacher, course)
    student = Student("Tom", school, grade)
    student.show_info()
    teacher.modify_score(student, 64)
    teacher.show_info()
    student.show_info()

# 作者：周浩强
'''
功能：处理数据存储与提取，数据的增删改查实现
'''

import pickle

path = "../datas/datas.pk"  # 数据路径


def dump(obj):
    f = open(path, "wb")
    pickle.dump(obj, f)
    f.close()


def load():
    f = open(path, "rb")
    infos = pickle.load(f)
    f.close()
    return infos


def print_all_info():  # 打印数据信息
    infos = load()
    print("=" * 50)
    for key in infos:
        print(key, ":")
        for key2 in infos.get(key):
            print("\t", key2, ":", infos.get(key).get(key2))
    print("=" * 50)


def print_infos(key):
    infos = load()
    print(key.center(50, "="))
    # print("\t", "名称", ":", key)
    print("\t", "-" * 30)
    for key2 in infos.get(key):
        print("\t", key, ":", infos.get(key).get(key2))
    print("=" * 50)


def print_schools():
    key = "schools"
    print_infos(key)


def print_courses():
    key = "courses"
    print_infos(key)


def print_grades():
    key = "grades"
    print_infos(key)


def print_teachers():
    key = "teachers"
    print_infos(key)


def print_students():
    key = "students"
    print_infos(key)


# 查询操作
def get_infos(class_name):
    infos = load()
    return infos.get(class_name)


# 查询学校
def get_schools():
    return get_infos("schools")


def get_school(school_name):
    return get_schools().get(school_name)


# 查询班级
def get_grades():
    return get_infos("grades")


def get_grade(grade_name):
    return get_grades().get(grade_name)


# 查询课程
def get_courses():
    return get_infos("courses")


def get_course(course_name):
    return get_courses().get(course_name)


# 查询老师
def get_teachers():
    return get_infos("teachers")


def get_teacher(teacher_name):
    return get_teachers().get(teacher_name)


# 查询学生
def get_students():
    return get_infos("students")


def get_student(student_name):
    return get_students().get(student_name)


# 修改操作
def update(dct):
    obj = load()
    obj.update(dct)
    dump(obj)


def update_school(school):
    infos = load()
    infos["schools"].update({school.name: school})
    dump(infos)


def update_course(course):
    infos = load()
    infos["courses"].update({course.name: course})
    dump(infos)


def update_grade(grade):
    infos = load()
    infos["grades"].update({grade.name: grade})
    dump(infos)


def update_teacher(teacher):
    infos = load()
    infos["teachers"].update({teacher.name: teacher})
    dump(infos)


def update_student(student):
    infos = load()
    infos["students"].update({student.name: student})
    dump(infos)


def init():
    # 存储结构
    infos = {
        "schools": {
            # "school_name": "school_obj"
        },
        "grades": {
            # "grade_name": "grade_obj"
        },
        "courses": {
            # "course_name": "course_obj"
        },
        "teachers": {
            # "teacher_name": "teacher_obj"
        },
        "students": {
            # "student_name": "student_obj"
        },
    }
    # 初始化数据
    res = input("是否初始化数据？[y]:")
    if res == "y":
        dump(infos)
        print("数据初始化成功！")
    else:
        print("数据初始化失败！")


if __name__ == '__main__':
    init()

运行截图