python study day06

本节内容：

1. 面向对象编程介绍
2. 为什么要用面向对象进行开发？
3. 面向对象的特性：封装、继承、多态
   类、方法
   类：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
   类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
   数据成员：类变量或者实例变量，用于处理类及其实例对象的相关的数据。
   方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖，也称为方法的重写。
   局部变量：定义在方法中的变量，只作用于当前实例的类。
   实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
   继承：即一个派生类继承基类的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
   实例化：创建一个类的实例，类的具体对象。
   方法：类中定义的函数。
   对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1、面向对象

1.1编程范式

编程是程序员用特定的语法+数据结果+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合。实现一个任务的方式有很多种不同的方式，对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。两种最重要的编程范式分别是面向过程和面向对象编程。

1.2 面向过程编程

面向过程编程依赖procedures，一个procedure包含一组要被进行计算的步骤，面向过程又被称为top-down languages，就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题。基本设计思路就是程序一开始是要解决一个大的问题，然后把一个大问题分解成很多小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以一个小步骤范围内解决。
所以一般认为，如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护的，那还是用面向对象最方便了。

1.3面向对象编程

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

1.3.1 class 类

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

1.3.2 object对象

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

1.3.3 Encapsulation 封装

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

1.3.4 Inheritance继承

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

1.3.5 Polymorphism 多态

多态是面向对象的重要特性，简单点说：“有个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来，再通过这个抽象的事物，与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当做父类的对象使用，某父类型的引用指向其子类型的对象，调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了，而引用所指向的对象可以在运行期间动态绑定。

1.3.6、面向对象编程（object-oriented programming）介绍

OOP的三大特性：继承、封装、多态
无论用什么形式来编程，我们都要明确记住以下原则：
1、写重复代码是非常不好的低级原则
2、你写的代码需要经常变更

1.4函数讲解

1.4.1 init(self)

构造函数
在实例化时做一些初始化操作

初始化对象的过程，即把对象名字也传入，然后实例化的是对象的属性，self就是为了接受对象的名字。
实例化时，函数是没有拷贝的，函数还是类中，当对象调用函数的时候，是类直接调用该函数，并把对象的名字也传入，由self接收对象的名字。
一个类中可以定义多个构造方法，但实例化类时只实例化最后的构造函数，即后面的构造方法会覆盖前面的构造方法，并且需要根据最后一个构造方法的形式进行实例化，，建议一个类中只定义一个构造函数。

实例变量（也称为静态变量）和类变量
类的方法，功能（动态属性）

1.4.2 类变量和实例变量

类变量存在类的内存中，可以通过类的名字直接调用，也可以通过对象来调用，但是如果对象中有该变量，则先找对象中的，如果没有，再找类中的。
对象可以在类外新加一个属性，但是其他的对象没有该属性。
通过对象来改变类变量的值，相当于在对象中新增加了一个属性，和类中的变量没有关系的，即不改变类中变量。但是如果类中变量是列表的话，则都会改变的，因为列表是全局变量。

1.4.3类变量的用途

大家共用的属性，

1是类变量。2是对象变量
类变量可以节省内存开销，对象变量需要占内存

1.4.4 析构函数

在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作，如关闭一些数据库连接、打开的临时文件。
析构函数的 格式
del__del__(self):
pass

在对象执行结束后或代码结束后执行。

1.5 私有方法，私有属性

1.5.1私有属性

即私有变量，外部不能访问，内部可以访问的，即可以定义一个方法，在方法里面访问，变量前加两个下划线，__

1.5.2 私有方法

在方法名字前面加两个下划线，__

1.6 继承

减少代码量。
构造函数重构化：

1处必须这样写，2处也要这样写，可以用super函数

这是python2.x的写法，在python3.x中 可以直接

1.6.1 super函数在python2和python3中的区别

Super函数的作用就是继承父类初始化函数的作用。在子方法中要是继承父类的方法，可以用super的方法，方便更改。
继承的people里面，有变量，则必须在继承处调用父类的初始化函数。\

class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print(" inin in Peopel")
    def fun1(self):
        print("sdf")


class Relation(object):
    def __init__(self):
        print(" inin in Relation")
    def makefriend(self,obj):
        print("%s is making friends wiht %s"%(self.name,obj.name))


class Man(People,Relation):
    def __init__(self,name,age):
        super().__init__(name,age)

1.6. 2新式类相对于经典类有升级

Supre就是新式类的写法。

二者的变化，主要在继承上。

1.6.3多继承：

在多继承的时候，要是在一个父类里继承的有相应的属性，则在另一个父类里面可以不写想关的属性。
继承的顺序是从左到右。（初始化函数的执行顺序），若是第一个父类有初始化函数，则后面父类的初始化函数不会执行的。（首先检查自己的初始化函数，如有，直接执行，父类的初始化函数不执行，要想父类的初始化函数执行，则需要在子类的初始化函数中写父类的初始化函数，用super）

结果：

多继承初始化顺序：
广度优先顺序： 图中红线
深度优先顺序： 图中蓝线
深度优先的效率没有广度优先的效率高
在python2中经典类是按深度优先顺序，新式类（object）是按广度优先来继承的。
在python3中经典类和新式类都是统一按广度优先继承的。

class A:
    def __init__(self):
        print("init A")

class B(A):
    def __init__(self):
        print("init B")

class C(A):
    def __init__(self):
        print("init C")

class D(B,C):
    pass
d = D()

1.6.4 面向对象编程

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承概念的实现方式主要有2类：实现继承、接口继承。
Ø 实现继承是指使用基类的属性和方法而无需额外编码的能力；
Ø 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)；
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法。
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

1.7多态

特性：一种接口，多种实现
多态性是允许你将父类对象设置成为和一个或更多的他的子对象相关的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简答的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
那么，多态的作用是什么，？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了一一代码重用，而多态则是为了实现另一个目的—接口重用，多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

可以使用静态来实现接口的重用：

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")

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


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)


Animal.func(c1)
Animal.func(d1)

作业：选课系统
角色:学校、学员、课程、讲师、 班级
要求:

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