python类中的隐藏方法

在python中有些方法名比较特别，在名称的前后各有两个下划线，这样的方法往往具有特殊的意义，一般情况下我们不会直接用到所以称之为“隐藏方法”也有一些人称之为“魔法方法”。下面划分这些隐藏方法，分类解析。

模块属性

1、__name__

当python文件被直接运行时，__name__的值为__main__，而当python文件以模块的形式被导入时，__name__的值为模块名

2、__file__

在python模块中使用__file__来获取脚本所在的路径，但得到的是相对路径，若希望得到绝对路径可使用

os.path.realpath(__file__)

3、__all__

__all__指定的是当包被import * 的时候, 哪些模块会被import进来（不建议使用import *的方式）
eg.

#test1.py
import os, sys
__all__ = [os]

#test2.py
from test1 import *
sys.path

输出：ImportError: No module named sys
可以看出，本来导入test1模块时，os、sys也会被一并导入进来，但是__all__属性限定了只导入os，所以sys并没有被导入进来。

4、__path__

__path__用于指定包的搜索路径，默认情况下只有一个元素, 就是当前包的路径, 修改__path__, 可以修改此包内的搜索路径，修改该属性类似于修改sys.path

5、__module__

__module__ 表示当前操作的对象在属于哪个模块

类和实例属性

1、__doc__

说明性文档和信息，Python自建，无需自定义。

    """ 描述类信息，可被自动收集 """

    def func(self):
        pass

# 打印类的说明文档 
print(Foo.__doc__)

2、__class__

__class__属于实例的属性，直接指向该实例的类对象

class A(object):
	pass

a = A()
a.__class__等同于A

3、__dict__

对象的属性字典，key为属性名，value为该属性的值
注：__dict__若被实例对象引用则列出实例对象的属性，若被类引用则列出类属性
eg.

class A():  
    def __init__(self):  
        self.x=1   #定义一个实例属性  
    y = 2          #定义一个类属性  


a = A()
a.__dict__
{'x': 1}
A.__dict__
{'__doc__': None,
 '__init__': function __main__.__init__
 '__module__': '__main__',
 'y': 2}

4、__init__and __new__

继承自object的新式类拥有__new__隐藏方法
__new__在实例被创建时调用，__init__在实例创建后的初始化时调用，所以先调用__new__，然后调用__init__

class A(object):    
    def __init__(self):
        print init
    def __new__(cls,*args, **kwargs):
        print new %s%cls
        return object.__new__(cls, *args, **kwargs)
 
A()

# 输出
new class '__main__.A'
init

__new__方法返回一个实例对象

5、__slots__

Python作为一种动态语言，可以在类定义完成和实例化后，给类或者对象继续添加随意个数或者任意类型的变量或方法，这是动态语言的特性。例如：

def print_doc(self):
    print("haha")
    
class Foo:
    pass

obj1 = Foo()
obj2 = Foo()
# 动态添加实例变量
obj1.name = "jack"
obj2.age = 18
# 动态的给类添加实例方法
Foo.show = print_doc
obj1.show()
obj2.show()

果我想限制实例可以添加的变量怎么办？可以使用__slots__
__slots__限制类中只能定义某些属性
例如：

    print("haha")

class Foo:
    __slots__ = ("name", "age")
    pass


obj1 = Foo()
obj2 = Foo()
# 动态添加实例变量
obj1.name = "jack"
obj2.age = 18
obj1.sex = "male"       # 这一句会弹出错误
# 但是无法限制给类添加方法
Foo.show = print_doc
obj1.show()
obj2.show()

由于’sex’不在__slots__的列表中，所以不能绑定sex属性，试图绑定sex将得到AttributeError的错误
obj1.sex = "male", AttributeError: 'Foo' object has no attribute 'sex'
注意: __slots__定义的属性仅对当前类的实例起作用，对继承了它的子类是不起作用的，如果子类也被限制，可以在子类中也定义__slots__

7、__del__

析构方法，当对象在内存中被释放时，自动触发此方法。
此方法一般无须自定义，因为Python自带内存分配和释放机制，除非你需要在释放的时候指定做一些动作。析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

8、__call__

如果一个类编写了该方法，那么在该类的实例后面加括号，可会调用这个方法。
注：构造方法的执行是由类加括号执行的，即：对象 = 类名()，而对于__call__() 方法，是由对象后加括号触发的，即：对象() 或者 类()()
eg.

class Foo:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo()     # 执行 __init__
obj()       # 执行 __call__

怎么判断一个对象是否可以被执行呢？能被执行的对象就是一个Callable对象，可以用Python内建的callable()函数进行测试。
eg.

>>> callable(max)
True

操作符类属性

1、__str__

当将一个对象进行格式化字符串时，调用的是对象的__str__方法，如果一个类中定义了__str__()方法，那么在打印对象时，默认输出该方法的返回值。
下面的类，没有定义__str__()方法，打印结果是：<__main__.Foo object at 0x000000000210A358>

class Foo:
    pass

obj = Foo()
print(obj)

定义了__str__()方法后，打印结果是：jack

class Foo:

    def __str__(self):
        return 'jack'

obj = Foo()
print(obj)

2、__repr__

这个方法的作用和__str__()很像，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，repr()是为调试服务的。通常两者代码一样。

3、__len__

在Python中，调用内置的len()函数获取一个对象的长度，在后台其实是去调用该对象的__len__()方法，所以下面的代码是等价的：

>>> len('ABC')
3
>>> 'ABC'.__len__()
3

Python的list、dict、str等内置数据类型都实现了该方法，但是你自定义的类要实现len方法需要自己设计。

4、__iter__

列表、字典、元组之所以可以进行for循环，是因为其内部定义了 __iter__()这个方法。用户也可以在自定类中定义这个方法，在利用for循环遍历对象时就可以调用这个__iter__()方法。
eg.

class Foo:
    def __init__(self):
        pass

    def __iter__(self):
        yield 1
        yield 2
        yield 3

obj = Foo()
for i in obj:
    print(i)

>>> 1
>>> 2
>>> 3

5、__getitem__, __setitem__, __delitem__

Python设计了__getitem__()、__setitem__()、__delitem__()这三个特殊成员，用于执行与中括号有关的动作。它们分别表示取值、赋值、删除数据。

a = 标识符[]　： 　　执行__getitem__方法
标识符[] = a  ： 　　执行__setitem__方法
del 标识符[]　： 　　执行__delitem__方法

eg.

class Foo:

    def __getitem__(self, key):
        print('__getitem__',key)

    def __setitem__(self, key, value):
        print('__setitem__',key,value)

    def __delitem__(self, key):
        print('__delitem__',key)


obj = Foo()

result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'jack'      # 自动触发执行 __setitem__
del obj['k1']             # 自动触发执行 __delitem__

比较相关的方法

以上方法在代码中使用运算符=时调用
__cmp__：在使用cmp()时调用

数学相关的方法

__add__: 加运算，在使用运算符+时调用
__sub__: 减运算，在使用运算符-时调用
__mul__: 乘运算，在使用运算符*时调用
__div__: 除运算，在使用运算符\时调用
__mod__: 求余运算，在使用云端符%时调用
__pow__: 幂运算，在使用运算符**时调用
这些都是算术运算方法。Python支持运算符的重载，所以在自定义类中可以自定义运算代码。有些Python内置数据类型，比如int就带有这些方法。
eg.

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)

   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

>>> Vector (7, 8)