python-builtin学习
python类中内置方法
深入学习Python黑魔法资料
在python中，创建一个类时我们可以看到有好多我们并没有在类中实现的方法，类似于__new__，__init__这样的方法，
这些方法就是python类中的内置方法，而根据其用法我大体把他们分为三大类
1. 功能性方法，类似于__new__是对类实例化一个对象，__init__是对类实例化一个对象之后的初始化方法，这一类某些功能会用到的，我称之为功能性方法
2. 符号类方法，类似于__add__是在使用实例化的对象与另一个对象用符号"+"相连时调用的方法， 类似的还有(),-,>,<等等
3. 内置函数方法，我们对于一个list使用len(list)方法，可以返回list的长度，而其实质是调用list类实例化的一个对象的内置方法__len__，类似的还包括__str__，__repr__，__abs__等。
下面，我们就对一些常见的具体函数做一些了解和使用上的说明。
功能性内置方法
- __ new __
此内置方法在Python2.X中存在于新式类中，即类显示继承了object，在Python3.X中全部存在
此方法用于实例化一个类对象，在object中作为一个staticmethod存在，直接类名+方法即可调用
class object:
@staticmethod
def __new__(cls, *more):
pass
各类中可以重写此方法，最终会调用object.__new__方法在内存中创建一个对象
在初始化一个类对象时，基本的逻辑是，先通过__new__实例化一个对象，然后return，而__init__方法接收的第一个参数self，就是new返回的此类实例化的对象
第一步会通过new方法来实例化一个对象，如果没有对__new__进行重构的话，那么会调用object初始化一个此类的对象
__new__方法也可以通过重写，来用别的类的方法来实现初始化一个对象，如下：
class A(object):
def __new__(cls, *args, **kwargs):
print("A.__new__")
return object.__new__(cls, *args, **kwargs)
class B(object):
def __new__(cls, *args, **kwargs):
print( "B.__new__" )
return A.__new__(cls, *args, **kwargs)
def __init__(self):
print("my is B")
>>>b = B()
B.__new__
A.__new__
my is B
重点需要主要的是：当__new__方法中返回的不是此类的实例化对象，即使是父类的实例化对象，也不会调用__init__方法，所以此处需要注意
new方法的应用场景
单例模式
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
_instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
setattr(cls, "_instance", _instance)
return getattr(cls, "_instance", _instance)
class Test(Singleton):
def __init__(self, test):
self.test = test
>>>a=Test("123")
>>>print(a, id(a), a.test)
(<__main__.Test object at 0x7f1e524a8b90>, 139768206363536, '123')
>>>b = Test("234")
>>>print(b, id(b), b.test)
(<__main__.Test object at 0x7f1e524a8b90>, 139768206363536, '234')
>>>print(a, id(a), a.test)
(<__main__.Test object at 0x7f1e524a8b90>, 139768206363536, '234')- __ init __
__init__方法接收__new__方法实例化出来的本类的对象，然后可以在此方法中设置一些对象的属性，或者其他方法的调用都可以
- __ enter __/__ exit __
在python中使用关键字with进行上下文管理时，会使用到此方法，举例说明:
class Context(object):
def __init__(self):
print("my is init")
def __enter__(self):
print("my is enter")
def __exit__(self, *args):
print("my is exit")
with Context() as a:
print(a)
my is init
my is enter
None
my is exit
根据上面的例子可以看出来，使用with时会进入到enter函数之内，并且是在init之后，同时enter返回值是作为a来使用，在with作用域结束之后，将会执行__exit__函数
下面再来一个例子，来进一步证明enter的返回值
class Test1(object):
def __init__(self, name):
self.name = name
class Context(object):
def __init__(self, name):
self.name = name
def __enter__(self):
return Test1(self.name)
def __exit__(self, *args):
pass
with Context("123") as a:
print(a.name)
123上面应该就是比较直观的看到了enter返回的对象作为a来使用。
下面是延伸出来的，python内置的上下文管理的类库contextlib
from contextlib import contextmanager
@contextmanager
def make_context():
print( 'enter' )
try:
yield {}
except:
print( "error" )
finally:
print 'exit'
with make_context() as m:
print m
enter
{}
exit 基本上还是和类的原理类似，还是利用了enter和exit,只是在其中加入了生成器的使用，大概原理如下：
使用contextmanager装饰器的函数必须是一个生成器
contextmanager的原理就是返回一个Generate的类
基本步骤也是在走三个函数
__init__函数， 初始化生成器self.gen
__enter__函数， 调用next(self.gen) 这样就会将生成器中yield的值返回
__exit__函数， 捕捉错误异常等信息，调用next，正常应该会返回stop error，如果未返回错误，那就手工返回错误。
符号类内置方法
- __ call __
在初始化类对象之后,使用instance()时调用此内置方法，可以在此内置方法中做一些想做的事情
class A(object):
def __init__(self):
pass
def __call__(self, *args):
print "A.call"
print args
>>>a = A()
>>>a(1) # 在类对象使用()符号时，就会调用__call__方法，
A.call
(1,)
基于此，可以编写相应的类装饰器
class func_decorate(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
self.func(*args, **kwargs)
@func_decorate
def function1(*args, **kwargs):
pass
还有一些其他方面的应用还需要探索，但是要明确此内置方法时在直接执行实例对象()时调用，那应用万变不离其宗。
- __ gt __
像我们对两个对象进行比较时，例如a>b,或者a==b，实质在执行时都是在执行a对象的__gt__类似方法，__gt__表示”>”,举个例子如下
class A(object):
def __init__(self):
pass
def __gt__(self, y):
print "A.gt"
print "123"
>>>a = A()
>>>b = A()
>>>print a>b
A.gt
123
None上述的例子我们可以看到，在进行比较时执行的是__gt__内置方法，而我们自己已经给重写了，但是这里看到最后还输出一个None，以及__gt__除了self之外，还需要另外一个参数y，就是用来比较的参数，同时__gt__也需要一个输出值，而如果没有输出值的话，python默认会输出一个None值。
- __ add __
当我们将两个int值相加时，那么是怎么变成一个新的值呢？其实质是在int类中，根据计算结果，将变量的指针指向内存中的另一个值，所以我们在进行“+”操作时，实质就是执行类中的内置函数add，下面我们写一个例子测试一下。
class A(object):
def __init__(self):
pass
def __add__(self, y):
print "A.add"
print self
print y
>>>a = A()
>>>b = A()
>>>print a>b
A.add
<__main__.A object at 0x7fef0c184e50>
<__main__.A object at 0x7fef0c101ef0>
None- __ or __
当我们将两个对象通过符号“|”连接时，实质会调用内置方法__or__，具体用法与上述的例子基本想吃。
还有一些其他的内置函数不再一一列出，在下表中单独摘出一部分，对应关系如下
| 函数名 | 对应符号 | 描述 |
|---|---|---|
| __getitem__ | x[y] | 获取元素 |
| __setitem__ | x[y]=z | 设置元素 |
| __delitem__ | del x[y] | 删除元素 |
| __delslice__ | del x[a:b] | 切片删除，del x[a:b] 调用x对象 x.__delslice__() |
| __gelslice__ | x[a:b] | 切片获取 |
| __call__ | () | 实例对象执行时的操作，x(*args, **kwargs)<==> x.__call__(*args,**kwargs) |
| __gt__ | > | 实例化对象进行大小比较时，x>y <==> x.__ gt__(y) |
| __ge__ | >= | 实例化对象进行大小比较时，x>=y <==> x.__ ge__(y) |
| __lt__ | < | 实例化对象进行大小比较时，x x.__ lt__(y) |
| __le__ | <= | 实例化对象进行大小比较时，x<=y <==> x.__ le__(y) |
| __eq__ | == | 实例化对象进行大小比较时，x\==y <==> x.__ eq__(y) |
| __ne__ | != | 实例化对象进行大小比较时，x!=y <==> x.__ ne__(y) |
| __add__ | + | 实例化对象进行加法时，x+y <==> x.__add__(y) |
| __mul__ | * | 实例化对象进行乘法法时，x*y <==> x.__mul__(y) |
| __mod__ | % | 取余操作 |
| __div__ | / | 取商操作 |
| __or__ | | | 或比较 |
| __and__ | & | 和比较 |
| __index__ | x[y:z] | 取值 x[y:z] <==> x[y.__index__():z.__index__() |
| __floordiv__ | // | |
| __lshift__ | << |
内置函数类内置方法
Python中部分内置函数或者内置类与类内置函数的对应关系如下表
| 函数名 | 对应内置函数/类 | 描述 |
|---|---|---|
| __getattrbuite__ | getattr(x, “name”) | 获取x对象的name属性，调用x对象的__getattrbuite__(self, name)方法 |
| __setattr__ | setattr(x, name, value) | 给对象设置某属性时，调用__setattr__方法 |
| __delattr__ | delattr(x, name) | 删除某对象某属性时，调用__delattr__方法，del x.name 也会调用 |
| __str__ | str(a) | 使用内置类str，对对象a处理时，调用对象a的内置方法__str__ |
| __len__ | len(a) | 使用内置方法len，对对象a进行len(a)处理时，调用对象a的内置方法__len__ |
| __abs__ | abs(a) | 使用内置方法abs，对对象a进行abs(a)处理时，调用对象a的内置方法__abs__ |
| __hash__ | hash(a) | |
| __int__ | int(a) | |
| __long__ | long(a) | |
| __repr__ | repr(a) |