面向对象OO:

在python中一切皆对象。

面向对象的三大特征：

1.封装

2.继承

3.多态

抽象/实现：对实际问题建模，定义属性和方法，并现实化。

封装/接口：对数据进行隐藏，对数据提供属性和访问函数。

类/基类/子类：对属性和方法的抽象，描述一组对象的语法结构。

实例/对象：存放类中定义的属性和方法的具体信息，python中一切皆对象。

方法：就是在类中实现功能的函数。

合成/组合：使得多个不同的类合成一个大的类，在类中使用其它类。

派生/继承/继承结构：子类的创建就是派生，子类继承了父类的属性。

泛化/特化：泛化就是子类和祖先类有一样的特点。

多态：对象如何通过共同的属性和动作来操作及访问。

自省/反射：自省就是手工类型检查。

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

使用class来创建一个类：（类名通常用大写字母开头）

classClassName（bases）：

“class documentation string”

class_suite

在类中创建一个方法：

class classname(bases):

    def func(self[, args]):

        func_suite

创建一个实例/对象（实例化）：

objectname= classname（）

创建一个子类：

class parentClass(object):

def __init__(self):

    init_suite

def__del__(self):

    del_suite

def func1(self)

    func_suite

class childClass(parentClass):

def __init__(self):

    parentClass.__init__()

    init_suite

def__del__(self):

    parentClass.__del__(self)

    del_suite

def func2(self)

    func_suite

__new_ _(cls [, args])类构造器：

new方法会返回所构造的的实例，在调用new返回对象时会隐式调用init，new的第一个参数必须是cls类。

__ int _ _(self[, args])实例构造器：

init方法是在类的实例被创建之后调用的，用来初始化新实例。init的第一个参数必须是self实例。

init只能返回None，也就是不要在init中调用return。

__del_ _(self[, args])解构器：

在类的所有实例的引用都使用完后会显示调用这个解构器来做自定义的一些资源释放操作。在子类中要显示调用del。

类相当于一种数据结构类型，实例就是这种类型的变量。

python中的类需要继承一个（单继承）或多个（多重继承）父类bases，object是所有类的父类，如果bases为空，默认就是object。

python把self作为第一个参数传递给方法，self就是指实例本身.

子类继承了基类的属性，如果子类没有定义init构造器会自动调用基类的init构造器，如果子类定义了init构造器，基类的init构造器不会被自动调用，如果需要可以在子类中显示调用。子类不能继承父类的文档字符串。在父类和子类所有的引用都使用完，系统默认垃圾回收之后才显示调用del，需要在子类中显示调用父类的del，才能释放父类和子类的所有资源。

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

类的数据属性和实例的数据属性：

查看有哪些属性和方法：

方法一：dir(ClassName)

方法二：ClassName(__dict__)

类和实例的特殊属性：

__bases__：类的所有父类构成的元祖

__name__：类的类名

__class__：实例对应的类名，类的类型

__class__.__name__：实例的类名，类的类型

__doc__：类或实例的描述字符串

__module__：类或实例所在的模块

__dict__：类或实例的属性

类的数据属性：在类中定义的变量就是类的数据属性，这种变量就是静态变量，static变量，静态变量和类绑定，不依赖与类的实例，static变量用来跟踪与类相关的值。

实例的数据属性：实例的属性是在创建实例之后才拥有的，一般通过构造器init来设置实例属性，init方法应该返回None。

类和实例的数据属性的区别：

类的数据属性和实例无关，类的数据属性是静态的；

类的数据属性可以通过类和实例来访问。

如果通过类访问来修改数据属性的值，类和实例访问到的值都会变化。

如果通过实例访问来修改数据属性的值（不建议这么做），实际上是创建了一个同名的实例的新属性，类访问的属性没有变，实例访问的实际是新创建的同名新的实例属性，如果del这个新的实例属性就可以再访问原来的属性了。

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

普通方法、静态方法和类方法比较：

普通类方法：python中的方法如果有实例，就叫绑定方法，如果没有实例就是非绑定方法；任何普通方法定义的第一个参数都是self，表示调用此方法的实例对象；如果调用绑定方法self是自动传递给这个方法的，如果调用非绑定方法需要给self传参数（很少用）。

一般除了构造器和解构器其它方法的调用都需要绑定。

__builtins__模块的内建函数：

classmethod(function):将类的方法转换成类方法

staticmethod(function):将类的方法转换成静态方法

这两个函数将传入的函数function转换成对应的类型，并返回同名的函数和参数。

普通方法一般只能使用实例调用，静态方法和类方法可以通过类调用。

普通方法的第一个参数是self实例。

静态方法的一次个参数不需要是self实例。

类方法的第一个参数不是self实例而是类，由解释器传给方法，一般叫做cls。

def func([args]):

func_suite

  staticmethod(func)

def func(cls[, args]):

    func_suite

    classmethod(func)

等效于用修饰器：

@staticmethod

def func([args])

func_suite

@classmethod

def func(cls[, args])

  func_suite

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

继承

一个子类可以继承它的基类的任何属性（包括数据属性和方法）。

子类不继承基类的文档字符串__doc__属性。

如果子类中有和基类中同名的方法，那么子类中的方法会隐藏父类中的方法，在子类可以使用super(childclassname,self).parentfunction()调用基类的方法。

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

从标准类型继承：

也就是基类是标准类型：int，float，string，tuple，list，dict，set，frozenset等。

不可变类型的实现需要使用new：

class myclass(standard):

def __new__(cls[, args]):

return standard.__new__(cls[, args/function])

class myclass(standard):

def __new__(cls[, args]):

return super(myclass, cls).__new__(cls[, function/args])

可变类型的实现可以不用init和new。

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

多重继承：

经典类：不用显示表明object这个基类。

新式类：需要显示表明object这个基类。

经典类采用深度优先的方法查找属性，新式类采用广度优先查找属性。

多重继承的方法解释顺序MRO：

多重继承采用广度优先的顺序，先查找同胞兄弟，如果所有直接基类都没有这个属性就查上一级的所有基类，以此类推。

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

类实例对象相关的内建函数：

issubclass（C，B...）:c是b的子类返回True，这里类可以是自身的子类。

isinstance(object,type…):object是type中的类型的对象返回True。type可以是类类型，object是类或子类的实例返回True。

hasattr(object,name)：对象（实例）是否有属性name。

getattr(object,name[, default])：取得对象的属性值，如果属性不存在返回AttributeError，除非设置默认返回值。

setattr(object,name, value)：设置一个已存在的或新添加的对象的属性值。

delattr(object,name)：从一个对象中删除属性。

super(type)：返回type的父类

super(type,obj)：将实例绑定到类上，isinstance(obj,type)。

super(type,type1)：将类和类绑定，issubclass(type1,type)。

vars([object])：没有参数等于locals（）返回局部变量，有参数等于object.__dict__返回实例属性。返回的是一个字典。

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

特殊方法定制类和授权：

如果需要使用内建的函数或操作符需要进行定制。

需要使用内建模块/类型的内建函数和变量需要授权。

基本定制：

def __init__(self[, args])：

  self.args= args

def__new__(cls[, args])：

  cls.__new__(args)

def __del__(self):

  __del__(args)

__str__()：字符串的非正式值，用print可以打印用户可读的实例。

def__str__(self[,args]):

  return“format” % args

__slots__(vals)：只定义某些集合的某些属性，只有指定的属性可用。

__repr__():字符串的默认表现形式，不用print就可以打印用户可读的实例。

__bytes__()：字节数组的非正式值

__format__()：格式化字符串的值

__hash__()：自定义散列值

迭代器定制：

__iter__(self)：遍历序列,返回self。

def __iter(__(self):

  return  self

__next__(self)：从迭代器获取下一个值

def __next__(self):

  ifself.args == 0:

  raise  StopIteration

  self.step-= 1

  return  self.args

__reversed__(self)：逆序创建迭代器

计算属性：

优先级别:

类属性

数据描述符

实例属性

非数据描述符

默认的__getattr__()

__getattr__(self)：获取一个属性,实现这个方法之后可以使用属性的相应的内建函数和变量,当在__dict__中找不到时才会调用__getattr__。

def __getattr__(self, attr):

  return  getattr(self.__args, attr)

__getattribute__(self):无条件获取属性，比getattr优先级高，

__setattr__(self)：设置属性

__delattr__(self)：删除属性

__dir__(self)：列出属性

__get__()：

__set__()：

函数：

__call__(self)：只有定义了这个方法类的实例才是可调用的，也就是instancename(args)进行调用。

def  __call__(self, args):

序列：

__len__(self)：序列长度

__contains__(self)：了解某序列是否包含特定值

字典：

__getitem__(self)：通过键来获取值

__setitem__(self)：通过键来设置值

__delitem__(self)：删除一个键值对

__missing__(self)：为缺失键提供默认值

数值（还有i和r）：

__add__()：加法

def __add__(self, other):

  return  self.args + other.args

__iadd__()：复合运算加法，必须返回self实例。

def __iadd__(self, other):

  self.args+= other.args

  return  self

__sub__(self)：减法

__mul__(self)：乘法

__truediv__(self)：除法（/）

__floordiv__(self)：地板除（//）

__mod__(self)：取余（%）

__divmod__(self)：地板除取模

__pow__(self)：乘幂（**）

__lshift__(self)：左位移（<<）

__rshift__(self)：右位移（>>）

__and__(self)：按位与（and）

__xor__(self)：按位异或（xor）

__or__(self)：按位或（or）

一元数学运算：

__neg__(self)

__pos__(self)

__abs__(self)

__invert__(self)

__complex__(self)

__int__(self)

__float__(self)

__round__(self)

__ceil__(self)

__floor__(self)

__trunc__(self)

可比较的类：
__eq__(self)

__ne__(self)

__lt__(self)

__le__(self)

__gt__(self)

__ge__(self)

__bool__(self)

可序列化的类：

__copy__(self)

__deepcopy__(self)

__getstate__(self)

__reduce__(self)

__reduce_ex__(self)

__getnewargs__(self)

__setstate__(self)

在with中使用：

__enter__(self)

__exit__(self)

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

私有化

python中的属性默认都是公有的，类所在的模块、导入了类所在的模块都可以使用。

使用双下划线__开头来隐藏类的属性和方法，此时属性和方法只能在类中访问，在类外部不能访问。

使用单下划线_开头可以隐藏模块的变量和函数，用frommodule import * 不能加载。

python 面向对象