day6(老男孩-Python3.5-S14期全栈开发)

作者：赵俊            发布日期：2020/09/15

二、面向对象介绍

面向对象编程

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

三、面向对象特性介绍

面向对象的几个核心特性如下

Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

Object 对象
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

自我认为，不同实例调用类方法执行结果不同就是多态的体现

对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

四、实例演示面向对象编程好处

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

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

面向过程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改

class Role(object):
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
 
    def shot(self):
        print("shooting...")
 
    def got_shot(self):
        print("ah...,I got shot...")
 
    def buy_gun(self,gun_name):
        print("just bought %s" %gun_name)
 
r1 = Role('Alex','police','AK47’) #生成一个角色
r2 = Role('Jack','terrorist','B22’)  #生成一个角色

 

把一个类变成具体对象的过程叫做实例化

实例化时__init__函数默认执行，并且接收实例时所传递的参数

__init__是构造函数，在实例化时做一些类的初始化工作

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 

class dog:
    def __init__(self, name):
        self.name = name
        print("self的内存地址：%s"%self)
    def jiao(self):
        print("%s在叫，汪汪汪" % self.name)

d1 = dog("三炮")
print("d1  的内存地址：%s"% d1)

输出：

self的内存地址：<__main__.dog object at 0x00000000027B9648>
d1  的内存地址：<__main__.dog object at 0x00000000027B9648>

d1的内存地址和self的内存地址一样，说明在实例化时，把d1传递给了所有方法的self

把self换成其他名字也可以

class dog:
    def __init__(aaa, name):
        aaa.name = name
        print("aaa的内存地址：%s"%aaa)
    def jiao(bbb):
        print("bbb的内存地址：%s"%bbb)
        # print("%s在叫，汪汪汪" % bbb.name)
    def say(ccc):
        print("ccc的内存地址：%s"%ccc)

d1 = dog("三炮")
print("d1 的内存地址：%s"% d1)
d1.jiao()
d1.say()

输出：
aaa的内存地址：<__main__.dog object at 0x00000000021C9908>
d1 的内存地址：<__main__.dog object at 0x00000000021C9908>
bbb的内存地址：<__main__.dog object at 0x00000000021C9908>
ccc的内存地址：<__main__.dog object at 0x00000000021C9908>

五、实例变量与类变量

 实例变量：就是self.aa的的变量，实例变量作用域是实例本身

类变量：是在类里但在类方法外变量，共用的属性（节省开销）

类变量和类方法在没有实例的情况下，就已经写入内存

引用时先找实例中的变量，实例中没有，则在类里找该变量

实例改不了类变量，只会在实例里增加一个和类变量同名的实例变量

如果类里面是个列表，在类方法里没有同名列表的情况下，在实例里对列表进行操作，影响所有实例；如果有同名的，只改变该实例的列表

类里面有同名列表：

class dog:
    n = []
    name = "我是类里的name"
    def __init__(aaa):
        aaa.n = []
d1 = dog()
d2 = dog()
d1.n.append("from d1")
print("d1.n：%s"% d1.n)
print("d2.n：%s"% d2.n)

输出
d1.n：['from d1']
d2.n：[]

类里面没有同名列表：

class dog:
    n = []
    name = "我是类里的name"
    def __init__(aaa):
       pass
d1 = dog()
d2 = dog()
d1.n.append("from d1")
print("d1.n：%s"% d1.n)
print("d2.n：%s"% d2.n)

输出
d1.n：['from d1']
d2.n：['from d1']

六、析构函数，私有属性和方法

 在实例释放或销毁的时候自动执行，通常用于以下收尾工作，例如，关闭一些数据库链接，关闭打开的临时文件

语法：

def __del__(self):
    print("收尾")
----------------------------------------------------------------------------------------

私有属性和方法 

　　在属性和方法名前面添加两个下划线(__name,__say())

　　私有方法和属性在类外面无法访问

　　但是如果需要访问属性怎么办，可以在类里添加一个显示属性的方法，这个方法在类里是可以访问私有属性的，然后在类外面执行此方法就可以

七、类的继承

 继承后，自己没有的方法和属性会在父类里面寻找

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

    def eat(self):
        print("%s正在吃饭" % self.name)

    def sleep(self):
        print("%s正在睡觉" % self.name)


class Man(People):
    def work(self):
        print("%s正在工作" % self.name)

    def eat(self):
        print("我修改了父类的方法")
        
    def sleep(self):
        People.sleep(self)
        print("我给父类方法增加的新功能")
m1 = Man("孙悟空", 23)
m1.eat()
m1.sleep()
m1.work()

八、类的继承2

 如果在子类中要增加一个属性，必须重构父类的属性，如下：

class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("父类的初始化")
class Man(People):
    def __init__(self, name, age, money):  # 要给子类增加新属性必须重构父类属性，不然报错
        People.__init__(self, name, age)  # 执行了父类的构造函数
        self.money = money
        print("子类的初始化")
    def eat(self):
        print("我修改了父类的方法")
class Women(People):
    def eat(self):
        print("吃饭了")
m1 = Man("白骨精", 23,123)
w1 = Women("嫦娥", 19)
print(m1.name)
print(w1.name)

super使用参考https://blog.csdn.net/dxk_093812/article/details/87553937

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（菱形继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

People.__init__(self, name, age) 和 super(Man, self).__init__(name, age)是等价的，都是调用父类的构造函数
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx
使用super的优势：
　　　　　　　　1、在某天父类名字更改时，使用super不受影响
　　　　　　　　2、在有多个父类时，不用每个都写，用super会按顺序执行父类的__init__方法一次

九、经典类和新式类的继承顺序

在py2上，经典类时按深度优先继承的，新式类是按广度优先继承的

在py3上，经典类和新式类都按广度优先继承的

 

十、继承实例讲解

class School(object):
    def __init__(self, name, addr):
        self.name = name
        self.addr = addr
        self.students = []
        self.staffs = []

    def enroll(self,stu_obj):
        print("为学院%s办理入学手续" % stu_obj.name)
        self.students.append(stu_obj)

    def hire(self,staff_obj):
        print("雇佣新员工%s" % staff_obj.name)
        self.staffs.append(staff_obj)
class SchoolMember(object):
    def tell(self):
        pass

class Teacher(SchoolMember):
    def __init__(self, name, age, sex, salary, course):
        self.name = name
        self.age = age
        self.sex = sex
        self.salary = salary
        self.course = course
    def tell(self):
        print("""
        ---info of teacher %s---
        name:%s
        age:%s
        sex:%s
        salary:%s
        course:%s
        """ % (self.name, self.name, self.age, self.sex, self.salary, self.course))
    def teach(self):
        print("%s老师教授%s课程"%(self.name,self.course))
class Student(SchoolMember):
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


    def tell(self):
        print("""
        ---info of teacher %s---
        name:%s
        age:%s
        sex:%s
        """ % (self.name, self.name, self.age, self.sex))

    def pay_tution(self,amount):
        print("%s缴纳学费 %s 元" % (self.name, amount))


sch1 = School("西游记", "丝绸之路")

t1 = Teacher("孙悟空", 23, "男", 15000, "三字经")
sch1.hire(t1)
t1.tell()
s1 = Student("白骨精", 19,"女" )
sch1.enroll(s1)
s1.pay_tution(1200)

十一、多态实例讲解

 一种接口多种实现

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        # raise NotImplementedError("Subclass must implement abstract method")


class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)


class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)


def func(obj):  # 一个接口，多种形态
    obj.talk()


c1 = Cat('小晴')
d1 = Dog('李磊')

func(c1)
func(d1)

python没有专门的语法来支持多态

十二、作业，选课系统开发

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

要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供两个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程
7. 上面的操作产生的数据都通过pickle序列化保存到文件里

参考https://www.cnblogs.com/heaven-xi/p/9703823.html（这个参考里创建学校写入文件了，创建其他的没有写入文件）

遇到的问题：

　　1、使用Pycharm进行Python开发时，在类中定义方法时，若该方法不涉及对属性的操作，那么Pycharm会提示Method xxx may be 'static',因为Pycharm会认为该方法是一个静态方法，而不是类方法，所提提示我们在该方法前添加@staticmethod装饰器进行装饰。

　　2、空列表中加入元素，不能使用p_list[0] = 123（报错），而是使用p_list.append(123)

　　3、shelve序列化时找错误（_pickle.UnpicklingError: pickle data was truncated）找了好久，主要原因是shelve实例打开时使用完立马要关闭（被关闭不一定每次报错，主要还是要看下一次写入数据的复杂度），准备下次的使用

　　4、school_data = shelve.open(BASE_DIR + r"\school_data",writeback=True)，中writeback=True参数没有的话，是写不进去数据的

Github代码：https://github.com/daban2009/selectCourse

# Author:ZHJ

import sys,os
import shelve

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(BASE_DIR)


class MainView(object):
    def __init__(self):
        pass

    def run(self):
        while True:
            info = '''
            ┏****************┓
            ┃欢迎进入选课系统┃
            ┗****************┛
            ┏━━━━━━━━┓
            ┃   1.学员入口   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   2.讲师入口   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   3.管 理 员   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   q.退    出   ┃
            ┗━━━━━━━━┛
             '''
            print('\033[34m{0}\033[0m'.format(info))
            selection = input("\033[1;33m请输入您的选择：\033[0m").strip()
            # print(selection)
            if selection == "1":
                student_view_obj = StudentView()
                student_view_obj.run()
            elif selection == "2":
                teacher_view_obj = TeacherView()
                teacher_view_obj.run()
            elif selection == "3":
                admin_view_obj = AdminView()
                admin_view_obj.run()
            elif selection == "q":
                sys.exit()
            else:
                print("\033[1;31m您的输入不正确。\033[0m")


class StudentView(object):
    def run(self):
        while True:
            info = '''
            ┏━━━━━━━━┓
            ┃    学    员    ┃
            ┗━━━━━━━━┛
            ┏━━━━━━━━┓
            ┃   1.注    册   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   2.交 学 费   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   r.返上一级   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   q.退    出   ┃
            ┗━━━━━━━━┛
                '''
            print('\033[34m{}\033[0m'.format(info))
            selection = input("\033[1;35m 请输入你的选择：\033[0m").strip()
            if selection == "1":
                self.enroll()
            elif selection == "2":
                self.pay_tuition()
            elif selection == "r":
                break
            elif selection == "q":
                sys.exit()
            else:
                print("\033[1;31m您的输入不正确。\033[0m")
    def enroll(self):
        school_data = shelve.open(BASE_DIR + r"\school_data",writeback=True)
        # print(self.school_data)
        name = input("请输入您的名字：")
        age = input("请输入您的年龄：")
        sex = input("请输入您的性别：")
        print("\033[1;32m可选择的校区：\033[0m")
        for i in school_data:
            print('\033[1;34m           {}\033[0m'.format(i))
        select_school = input("请选择学校")
        if select_school in school_data:
            # print(school_data[select_school].course)
            print("\033[1;32m可选择的班级：\033[0m")
            for i in school_data[select_school].classes:
                print('\033[1;34m           {}\033[0m'.format(i))
            select_classes = input("请选择班级")
            if select_classes in school_data[select_school].classes:
                school_data[select_school].classes[select_classes].add_students(name,age,sex)
                school_data[select_school] = school_data[select_school]
                print("\033[1;31m学员添加成功\033[0m")
            else:
                print("\033[1;31m输入的班级不存在!\033[0m")
        else:
            print("\033[1;31m输入的学校不存在!\033[0m")
        school_data.close()
    def pay_tuition(self):
        pass
class TeacherView(object):
    # def __init__(self):
    #     self.school_data = shelve.open(BASE_DIR + r"\school_data")
    #
    # def __del__(self):
    #     self.school_data.close()

    def run(self):
        while True:
            info = '''
            ┏━━━━━━━━┓
            ┃    讲    师    ┃
            ┗━━━━━━━━┛
            ┏━━━━━━━━┓
            ┃   1.查看学员   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   r.返上一级   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   q.退    出   ┃
            ┗━━━━━━━━┛
                '''
            print('\033[34m{}\033[0m'.format(info))
            selection = input("\033[1;35m 请输入你的选择：\033[0m").strip()
            if selection == "1":
                self.see_stu_list()
            elif selection == "r":
                break
            elif selection == "q":
                sys.exit()
            else:
                print("\033[1;31m您的输入不正确。\033[0m")
    def see_stu_list(self):
        school_data = shelve.open(BASE_DIR + r"\school_data")
        print("\033[1;32m可选择的校区：\033[0m")
        for i in school_data:
            print('\033[1;34m           {}\033[0m'.format(i))
        name = input("请选择学校")
        if name in school_data:
            print("\033[1;32m可选择的班级：\033[0m")
            for i in school_data[name].classes:
                print('\033[1;34m           {}\033[0m'.format(i))
            classes = input("请选择班级")
            # print(school_data[name])
            # print(school_data[name].classes)
            # print(school_data[name].classes[classes])
            if classes in school_data[name].classes:
                print("\033[1;32m学员列表：\033[0m")
                for i in school_data[name].classes[classes].students:
                    print('\033[1;34m           {}\033[0m'.format(i))
            else:
                print("\033[1;31m输入的班级不存在!\033[0m")
        else:
            print("\033[1;31m输入的学校不存在!\033[0m")
class AdminView(object):
    # def __init__(self):
    #     self.school_data = shelve.open(BASE_DIR+r"\school_data", writeback=True)

    def __del__(self):
        # self.school_data.close()
        print("看看执行么有")
    def run(self):
        while True:
            info = '''
            ┏━━━━━━━━┓
            ┃    管 理 员    ┃
            ┗━━━━━━━━┛
            ┏━━━━━━━━┓
            ┃   1.创建学校   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   2.创建讲师   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   3.创建班级   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   4.创建课程   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   5.删除学校   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   r.返上一级   ┃
            ┣┉┉┉┉┉┉┉┉┫
            ┃   q.退    出   ┃
            ┗━━━━━━━━┛
                '''
            print('\033[34m{}\033[0m'.format(info))
            selection = input("\033[1;35m 请输入你的选择：\033[0m").strip()
            if selection == "1":
                self.add_school()
            elif selection == "2":
                self.add_teacher()
            elif selection == "3":
                self.add_class()
            elif selection == "4":
                self.add_course()
            elif selection == "5":
                self.del_school()
            elif selection == "r":
                break
            elif selection == "q":
                sys.exit()
            else:
                print("\033[1;31m您的输入不正确。\033[0m")
    def add_teacher(self):
        school_data = shelve.open(BASE_DIR + r"\school_data", writeback=True)
        print("\033[1;32m可选择的校区：\033[0m")
        for i in school_data:
            print('\033[1;34m           {}\033[0m'.format(i))
        name = input("请选择学校")
        if name in school_data:
            print(school_data[name].teacher)
            tch_name = input("请输入姓名")
            tch_age = input("请输入年龄")
            tch_sex = input("请输入性别")
            tch_salary = input("请输入收入")

            school_data[name].add_teacher(tch_name,tch_age,tch_sex,tch_salary)
            school_data[name] = school_data[name] #加入了老师的学校写入文件
        else:
            print("\033[1;31m输入的学校不存在!\033[0m")
        school_data.close()
    def add_school(self):
        school_data = shelve.open(BASE_DIR + r"\school_data", writeback=True)
        name = input("请输入学校名")
        school_data[name] = School(name)
        school_data.close()
    def del_school(self):
        school_data = shelve.open(BASE_DIR + r"\school_data", writeback=True)
        print("\033[1;32m可选择的校区：\033[0m")
        for i in school_data:
            print('\033[1;34m           {}\033[0m'.format(i))
        name = input("请输入学校名")
        if name in school_data:
            del school_data[name]
        else:
            print("\033[1;31m输入的学校不存在!\033[0m")
        school_data.close()
    def add_course(self):
        school_data = shelve.open(BASE_DIR + r"\school_data", writeback=True)
        print("\033[1;32m可选择的校区：\033[0m")
        for i in school_data:
            print('\033[1;34m           {}\033[0m'.format(i))
        name = input("请选择学校")
        if name in school_data:
            print(school_data[name].course)
            cour_name = input("请输入名称")
            cour_time = input("请输入学习周期")
            cour_price = input("请输入价格")

            school_data[name].add_course(cour_name, cour_time, cour_price)
            school_data[name] = school_data[name]  # 加入了课程的学校写入文件
        else:
            print("\033[1;31m输入的学校不存在!\033[0m")
        school_data.close()
        #可能是没有正常关闭导致
    def add_class(self):
        school_data = shelve.open(BASE_DIR + r"\school_data", writeback=True)
        print("\033[1;32m可选择的校区：\033[0m")
        for i in school_data:
            print('\033[1;34m           {}\033[0m'.format(i))
        name = input("请选择学校")
        if name in school_data:
            class_name = input("请输入班级名")
            print("\033[1;32m可选择老师：\033[0m")
            for i in school_data[name].teacher:
                print('\033[1;34m           {}\033[0m'.format(i))
            class_teacher = input("请选择老师")
            if class_teacher in school_data[name].teacher:

                print("\033[1;32m可选择课程：\033[0m")
                for i in school_data[name].course:
                    print('\033[1;34m           {}\033[0m'.format(i))
                class_course = input("请选择课程")
                if class_course in school_data[name].course:
                    school_data[name].add_class(class_name, class_teacher, class_course)
                    school_data[name] = school_data[name]  # 加入了课程的学校写入文件
                else:
                    print("\033[1;31m输入的课程不存在\033[0m")
            else:
                print("\033[1;31m输入的老师不存在\033[0m")
        else:
            print("\033[1;31m输入的学校不存在!\033[0m")
        school_data.close()

class School(object):
    def __init__(self, name):
        self.name = name
        self.course = {}
        self.classes = {}
        self.teacher = {}

    def add_class(self, name, teacher, course):
        class_obj = Class(name, teacher, course)
        self.classes[name] = class_obj

    def add_course(self, name, time, price):
        course_obj = Course(name, time, price)
        self.course[name] = course_obj

    def add_teacher(self, name, age, sex, salary):
        teacher_obj = Teachers(name, age, sex, salary)
        self.teacher[name] = teacher_obj


class Class(object):
    def __init__(self, name, teacher, course):
        self.name = name
        self.teacher = teacher
        self.course = course
        self.students = {}

    def add_students(self, name, age, sex):
        students_obj = Students(name, age, sex)
        self.students[name] = students_obj


class Course(object):
    def __init__(self, name, time, price):
        self.name = name
        self.time = time
        self.price = price


class Teachers(object):
    def __init__(self, name, age, sex, salary):
        self.name = name
        self.age = age
        self.sex = sex
        self.salary = salary


class Students(object):
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


m1 = MainView()
m1.run()