类和对象

面向对象
封装
继承
多态

程序 = 数据 + 功能
模块可以存放 数据 和 功能
函数是存放 功能 的，不调用不执行。
列表，存储 数据 和 方法（函数名），

把 数据 和 功能 整合起来，分为一类的编程思想就叫面向对象编程

类和对象
类：class

先定义类，再调用类产生对象

定义：定义阶段就运行，产生类的名称空间
__dict__:查看名称空间

class Student:  驼峰体
    ...  数据属性和方法属性

    调用类实例化对象的时候，运行,对对象进行初始化
    必须返回None，不能返回别的值
    def __init__(self,x,y,z):  
        self.x = x

egon = Student(x,y,z)  实例化对象
egon.x = 1
Student.x

产生空对象，调用__init__方法初始化对象，返回初始化的对象
属性或对象先从对象中找，然后再去类中找,去父类，，，
从自身开始查找,逐级往父级查找对应属性或方法,直到根对象Object.prototype,没有返回undefined

类中的公共属性：

直接改类中的属性的值，所有对象的相应的值都改了，
如果改的是对象中的值，那么相当于重新创建了自己的值，不影响类中的值，和其它实例化的值

def __init__(self,x,y,z):
    Student.count += 1

bound method 绑定方法：绑定给谁就操作谁

绑定方法地址里存的是啥？

school_shanghai = School('上海校区','虹桥火车站')
print(School.add_class)
print(school_shanghai.add_class)

<function School.add_class at 0x0000000000D73400>
<bound method School.add_class of <__main__.School object at 0x0000000000D70978>>

底层就是绑定给对象的名称空间，最终还是指向原来类的名称空间中的方法，
相当于给这个对象做了一个标记，它在调用的时候就给它临时绑定一下
是指向类中的函数的，地址不同，因为绑定方法做了进一步的处理，与普通函数不同


内置方法

方法

class Student:
    def choice():
        pass
Student.choice()  可以
stu.choice()  不可以

    def xxx(self):
        pass
Student.xxx(stu)  类调用自己的方法时，要注意对象参数


__dict__ : 名称空间
是个字典，注意字典的属性，没有某个值就进行添加

两个类的关联，一次即可

封装：
把各种有关联的属性，整合为一体，称为封装

将封装的属性隐藏

私有属性：不能外部直接调用，可以内部直接调用
__x
def __func(self):
    pass

类定义阶段：名称空间里的变量加前缀_Foo__x,_Foo__f1,统一变形，所以内部直接调用，如是访问可以
只是名字的变形，只在类定义，检测类体代码的语法的时候发生变形，之后的，不会发生变形

注意：！！！在哪个类里定义的私有属性，那么前缀就是哪个类名，注意类名前面是一个 _ ,
！！！
在遇到类的继承的时候，私有变量的引用，要注意父类的私有属性在子类里，要不通过父类提供的接口使用，要不就 父类._父类名__方法名！！！
不能在子类里直接self.__方法 调用，调用不到，因为名字在父类里已经变形

加强对属性的控制，不能够在类外随便操作，提供接口给外部进行访问；隔离复杂度

__init__ 内置属性：python自带的属性
__x 私有属性：自定义的私有属性

property：是一个装饰器，把函数的调用方式，改成变量的调用方式，得到的值是方法的return值

name = property(get_name,set_name,del_name)

将三个方法定义为最终的名字，然后不同的功能加上不同的装饰器，实现不同的调用方式，类似于一个变量的调用方式

@property
@name.setter
@name.deleter

继承
定义继承类的时候，什么是什么的类，就是有一定语言意义上的继承
创建新类的方式：子类，派生类；父类，基类，超类；
python支持多继承
class Sub(Parents):
    pass

class Sub(Parents,Parents1):
    pass

python2:
新式类：继承object类的子类等子类
经典类：没有继承object类的子类等子类
__bases__:看他的继承object情况
python3：都是新式类

子类没有的东西去父类找
def __init__(self,a,b):
    父类.__init__(self,a)
    self.b = b

菱形继承：
属性查找优先级：D.mro()，看类的顺序，mro列表
object类一定是最后找

非菱形继承：

python3：深度优先

python2 的新式类中有mro()

两个类，都是深度优先

菱形继承：

python3：

新式类：‘广度优先’

python2：

经典类：深度优先（不会重复找最终的类，这个类不是object类），第一次就找最终的类
新式类：‘广度优先’，最后找最终的类

注意：json和pickle不能追加序列化内容！！！

派生：子类产生新东西
子类独有，子类覆盖使用父类的功能，子类在用父类功能的基础上进行拓展

mixins机制：
多继承的正确使用方式：
提升多继承的可读性
mixin加入到混入类的名字后缀，表示将这个类混入加入一些功能
或者able或ible结尾

归属含义的父类只能有一个

Teacher.__init__(self,name,age,sex)

super(Teacher,self).__init__(name,age,sex)
super产生特殊的对象，参照当前类的mro，去第二个mro往后找，
在Python2中super的使用需要完整地写成super(自己的类名,self) ,而在python3中可以简写为super()。
# super(Teacher,self).__init__(name,age,sex)
# super().__init__(name,age,sex) # 调用的是方法，自动传入对象

组合

在一个类中以另外一个类的对象作为数据属性，称为类的组合。

多态

同一种事物有多种形态，就叫多态
多态带来的特性：多态性
不考虑对象具体类型的情况下，使用对象
都是动物类，所以都会叫
不同的类型可以有相同的方法



鸭子类型：推崇鸭子类型，而不是继承
linux 一切皆文件
把调用方式都变成文件的形式，也就是提供读和写的接口来使用

import abc

class Animal(metaclass = abc.ABCMeta):
    @abc.abstractmethod
    def say(self):
        pass

抽象基类：必须有父类Animal这个类的属性，统一所有子类的标准,多可以少不行
不能实例化Animal


绑定方法：
绑定给类：自动传入类参数
绑定给对象：自动传入对象参数

class Mysal:

    # 绑定给对象
    def __init__(self,ip,port):
        pass

    # 绑定给类
    @classmethod  # self 默认传入类
    def func(cls):  # 返回一个实例化的对象，从文件读取的参数，可以多次使用，           return cls(settings.IP,settings.PORt)  # 但是调用起来简单

绑定给类的方法：提供 生成对象的方法的接口，让实例化变简单，因为实例化有些参数是长期固定的，比如从配置文件settings中读取的

所以

mysql = Mysql.func()

    # 非绑定方法，静态方法，不绑定任何参数self，也可以在类里,function
    @staticmethod
    def a():
        pass