面向对象
封装
继承
多态
程序 = 数据 + 功能
模块可以存放 数据 和 功能
函数是存放 功能 的，不调用不执行。
列表，存储 数据 和 方法（函数名），
把 数据 和 功能 整合起来，分为一类的编程思想就叫面向对象编程
类和对象
类：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