__init__我们很熟悉了, 它在对象初始化的时候调用, 我们一般将它理解为 "构造函数".

实际上, 当我们调用x = SomeClass()的时候调用,__init__并不是第一个执行的, __new__才是。所以准确来说, 是__new__和__init__共同构成了 "构造函数".

__new__是用来创建类并返回这个类的实例, 而__init__只是将传入的参数来初始化该实例.

__new__在创建一个实例的过程中必定会被调用, 但__init__就不一定，比如通过pickle.load的方式反序列化一个实例时就不会调用__init__。

__new__方法总是需要返回该类的一个实例，而__init__不能返回除了 None 的任何值。比如下面例子:

classFoo(object):
def__init__(self):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'foo __init__'</span>
    <span class="hljs-keyword">return</span> <span class="hljs-literal">None</span>  <span class="hljs-comment"># 必须返回None,否则抛TypeError</span>

def__del__(self):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'foo __del__'</span></code></pre>

实际中, 你很少会用到__new__，除非你希望能够控制类的创建。
如果要讲解__new__，往往需要牵扯到metaclass(元类) 的介绍。
对于__new__的重载，Python 文档中也有了详细的介绍。
在对象的生命周期结束时, __del__会被调用, 可以将__del__理解为 "析构函数".
__del__定义的是当一个对象进行垃圾回收时候的行为。
有一点容易被人误解, 实际上，x.__del__() 并不是对于del x的实现, 但是往往执行del x时会调用x.__del__().
怎么来理解这句话呢? 继续用上面的 Foo 类的代码为例:
foo = Foo()
foo.__del__()
print foo
del foo
print foo  # NameError, foo is not defined
如果调用了foo.__del__()，对象本身仍然存在. 但是调用了del foo, 就再也没有 foo 这个对象了.
请注意，如果解释器退出的时候对象还存在，就不能保证 __del__ 被确切的执行了。所以__del__并不能替代良好的编程习惯。
比如，在处理 socket 时，及时关闭结束的连接。
回到顶部
属性访问控制
总有人要吐槽 Python 缺少对于类的封装, 比如希望 Python 能够定义私有属性，然后提供公共可访问的 getter 和 setter。Python 其实可以通过魔术方法来实现封装。
__getattr__(self, name)
该方法定义了你试图访问一个不存在的属性时的行为。因此，重载该方法可以实现捕获错误拼写然后进行重定向, 或者对一些废弃的属性进行警告。
__setattr__(self, name, value)
__setattr__ 是实现封装的解决方案，它定义了你对属性进行赋值和修改操作时的行为。
不管对象的某个属性是否存在, 它都允许你为该属性进行赋值, 因此你可以为属性的值进行自定义操作。有一点需要注意，实现__setattr__时要避免 "无限递归" 的错误，下面的代码示例中会提到。
__delattr__(self, name)
__delattr__与__setattr__很像，只是它定义的是你删除属性时的行为。实现__delattr__是同时要避免 "无限递归" 的错误。
__getattribute__(self, name)
__getattribute__定义了你的属性被访问时的行为，相比较，__getattr__只有该属性不存在时才会起作用。
因此，在支持__getattribute__的 Python 版本, 调用__getattr__前必定会调用 __getattribute__。__getattribute__同样要避免 "无限递归" 的错误。
需要提醒的是，最好不要尝试去实现__getattribute__, 因为很少见到这种做法，而且很容易出 bug。
例子说明__setattr__的无限递归错误:
def__setattr__(self, name, value):
    self.name = value
    # 每一次属性赋值时, __setattr__ 都会被调用，因此不断调用自身导致无限递归了。
因此正确的写法应该是:
def__setattr__(self, name, value):
    self.__dict__[name] = value
__delattr__如果在其实现中出现del self.name 这样的代码也会出现 "无限递归" 错误，这是一样的原因。
下面的例子很好的说明了上面介绍的 4 个魔术方法的调用情况:
classAccess(object):
def__getattr__(self, name):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'__getattr__'</span>
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">super</span>(Access, self).__getattr__(name)

def__setattr__(self, name, value):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'__setattr__'</span>
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">super</span>(Access, self).__setattr__(name, value)

def__delattr__(self, name):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'__delattr__'</span>
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">super</span>(Access, self).__delattr__(name)

def__getattribute__(self, name):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'__getattribute__'</span>
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">super</span>(Access, self).__getattribute__(name)

access = Access()
access.attr1 = True  # setattr__ 调用
access.attr1  # 属性存在, 只有 __getattribute__ 调用
try:
access.attr2  # 属性不存在, 先调用 __getattribute, 后调用__getattr__
except AttributeError:
pass
del access.attr1  # __delattr__ 调用

回到顶部
描述器对象
我们从一个例子来入手, 介绍什么是描述符, 并介绍__get__, __set__, __delete__ 的使用。(放在这里介绍是为了跟上一小节介绍的魔术方法作对比)
我们知道，距离既可以用单位 "米" 表示, 也可以用单位 "英尺" 表示。
现在我们定义一个类来表示距离, 它有两个属性: 米和英尺。
classMeter(object):
    '''Descriptor for a meter.'''
    def__init__(self, value=0.0):
        self.value = float(value)
    def__get__(self, instance, owner):
        return self.value
    def__set__(self, instance, value):
        self.value = float(value)
classFoot(object):
'''Descriptor for a foot.'''
def__get__(self, instance, owner):
return instance.meter * 3.2808
def__set__(self, instance, value):
instance.meter = float(value) / 3.2808
classDistance(object):
meter = Meter()
foot = Foot()
d = Distance()
print d.meter, d.foot  # 0.0, 0.0
d.meter = 1
print d.meter, d.foot  # 1.0 3.2808
d.meter = 2
print d.meter, d.foot  # 2.0 6.5616

在上面例子中, 在还没有对 Distance 的实例赋值前, 我们认为 meter 和 foot 应该是各自类的实例对象, 但是输出却是数值。这是因为__get__发挥了作用.
我们只是修改了 meter, 并且将其赋值成为 int，但 foot 也修改了。这是__set__发挥了作用.
描述器对象 (Meter、Foot) 不能独立存在, 它需要被另一个所有者类 (Distance) 所持有。
描述器对象可以访问到其拥有者实例的属性，比如例子中 Foot 的instance.meter。
在面向对象编程时，如果一个类的属性有相互依赖的关系时，使用描述器来编写代码可以很巧妙的组织逻辑。
在 Django 的 ORM 中, models.Model 中的 IntegerField 等, 就是通过描述器来实现功能的。
一个类要成为描述器，必须实现__get__, __set__, __delete__ 中的至少一个方法。下面简单介绍下:
__get__(self, instance, owner)
参数 instance 是拥有者类的实例。参数 owner 是拥有者类本身。__get__在其拥有者对其读值的时候调用。
__set__(self, instance, value)
__set__在其拥有者对其进行修改值的时候调用。
__delete__(self, instance)
__delete__在其拥有者对其进行删除的时候调用。
回到顶部
构造自定义容器 (Container)
在 Python 中，常见的容器类型有: dict, tuple, list, string。
其中 tuple, string 是不可变容器，dict, list 是可变容器。
可变容器和不可变容器的区别在于，不可变容器一旦赋值后，不可对其中的某个元素进行修改。
比如定义了l = [1, 2, 3]和t = (1, 2, 3)后, 执行l[0] = 0是可以的，但执行t[0] = 0则会报错。
如果我们要自定义一些数据结构，使之能够跟以上的容器类型表现一样，那就需要去实现某些协议。
这里的协议跟其他语言中所谓的 "接口" 概念很像，一样的需要你去实现才行，只不过没那么正式而已。
如果要自定义不可变容器类型，只需要定义__len__ 和 __getitem__方法;
如果要自定义可变容器类型，还需要在不可变容器类型的基础上增加定义__setitem__ 和 __delitem__。
如果你希望你的自定义数据结构还支持 "可迭代", 那就还需要定义__iter__。
__len__(self)
需要返回数值类型，以表示容器的长度。该方法在可变容器和不可变容器中必须实现。
__getitem__(self, key)
当你执行self[key]的时候，调用的就是该方法。该方法在可变容器和不可变容器中也都必须实现。
调用的时候, 如果 key 的类型错误，该方法应该抛出 TypeError；
如果没法返回 key 对应的数值时, 该方法应该抛出 ValueError。
__setitem__(self, key, value)
当你执行self[key] = value时，调用的是该方法。
__delitem__(self, key)
当你执行del self[key]的时候，调用的是该方法。
__iter__(self)
该方法需要返回一个迭代器 (iterator)。当你执行for x in container: 或者使用iter(container)时，该方法被调用。
__reversed__(self)
如果想要该数据结构被內建函数reversed()支持, 就还需要实现该方法。
__contains__(self, item)
如果定义了该方法，那么在执行item in container 或者 item not in container时该方法就会被调用。
如果没有定义，那么 Python 会迭代容器中的元素来一个一个比较，从而决定返回 True 或者 False。
__missing__(self, key)
dict字典类型会有该方法，它定义了 key 如果在容器中找不到时触发的行为。
比如d = {'a': 1}, 当你执行d[notexist]时，d.__missing__('notexist')就会被调用。
下面举例，使用上面讲的魔术方法来实现 Haskell 语言中的一个数据结构。
# -*- coding: utf-8 -*-
classFunctionalList:
    ''' 实现了内置类型 list 的功能, 并丰富了一些其他方法: head, tail, init, last, drop, take'''
def__init__(self, values=<span class="hljs-literal">None</span>):
    <span class="hljs-keyword">if</span> values <span class="hljs-keyword">is</span> <span class="hljs-literal">None</span>:
        self.values = []
    <span class="hljs-keyword">else</span>:
        self.values = values

def__len__(self):
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">len</span>(self.values)

def__getitem__(self, key):
    <span class="hljs-keyword">return</span> self.values[key]

def__setitem__(self, key, value):
    self.values[key] = value

def__delitem__(self, key):
    <span class="hljs-keyword">del</span> self.values[key]

def__iter__(self):
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">iter</span>(self.values)

def__reversed__(self):
    <span class="hljs-keyword">return</span> FunctionalList(<span class="hljs-built_in">reversed</span>(self.values))

defappend(self, value):
    self.values.append(value)
defhead(self):
    <span class="hljs-comment"># 获取第一个元素</span>
    <span class="hljs-keyword">return</span> self.values[<span class="hljs-number">0</span>]
deftail(self):
    <span class="hljs-comment"># 获取第一个元素之后的所有元素</span>
    <span class="hljs-keyword">return</span> self.values[<span class="hljs-number">1</span>:]
definit(self):
    <span class="hljs-comment"># 获取最后一个元素之前的所有元素</span>
    <span class="hljs-keyword">return</span> self.values[:-<span class="hljs-number">1</span>]
deflast(self):
    <span class="hljs-comment"># 获取最后一个元素</span>
    <span class="hljs-keyword">return</span> self.values[-<span class="hljs-number">1</span>]
defdrop(self, n):
    <span class="hljs-comment"># 获取所有元素，除了前N个</span>
    <span class="hljs-keyword">return</span> self.values[n:]
deftake(self, n):
    <span class="hljs-comment"># 获取前N个元素</span>
    <span class="hljs-keyword">return</span> self.values[:n]</code></pre>

我们再举个例子，实现 Perl 语言的 AutoVivification, 它会在你每次引用一个值未定义的属性时为你自动创建数组或者字典。
classAutoVivification(dict):
    """Implementation of perl's autovivification feature."""
    def__missing__(self, key):
        value = self[key] = type(self)()
        return value
weather = AutoVivification()
weather['china']['guangdong'][<span class="hljs-string">'shenzhen'</span>] = 'sunny'
weather['china']['hubei'][<span class="hljs-string">'wuhan'</span>] = 'windy'
weather['USA']['California'][<span class="hljs-string">'Los Angeles'</span>] = 'sunny'
print weather
# 结果输出:{'china': {'hubei': {'wuhan': 'windy'}, 'guangdong': {'shenzhen': 'sunny'}}, 'USA':    {'California': {'Los Angeles': 'sunny'}}}

在 Python 中，关于自定义容器的实现还有更多实用的例子，但只有很少一部分能够集成在 Python 标准库中，比如Counter, OrderedDict 等
回到顶部
上下文管理
with声明是从 Python2.5 开始引进的关键词。你应该遇过这样子的代码:
with open('foo.txt') as bar:
    # do something with bar
在 with 声明的代码段中，我们可以做一些对象的开始操作和清除操作, 还能对异常进行处理。
这需要实现两个魔术方法: __enter__ 和 __exit__。
__enter__(self)
__enter__会返回一个值，并赋值给as关键词之后的变量。在这里，你可以定义代码段开始的一些操作。
__exit__(self, exception_type, exception_value, traceback)
__exit__定义了代码段结束后的一些操作，可以这里执行一些清除操作，或者做一些代码段结束后需要立即执行的命令，比如文件的关闭，socket 断开等。如果代码段成功结束，那么 exception_type, exception_value, traceback 三个参数传进来时都将为 None。如果代码段抛出异常，那么传进来的三个参数将分别为: 异常的类型，异常的值，异常的追踪栈。
如果__exit__返回 True, 那么 with 声明下的代码段的一切异常将会被屏蔽。
如果__exit__返回 None, 那么如果有异常，异常将正常抛出，这时候 with 的作用将不会显现出来。
举例说明：
这该示例中，IndexError 始终会被隐藏，而 TypeError 始终会抛出。
classDemoManager(object):
def__enter__(self):
    <span class="hljs-keyword">pass</span>

def__exit__(self, ex_type, ex_value, ex_tb):
    <span class="hljs-keyword">if</span> ex_type <span class="hljs-keyword">is</span> IndexError:
        <span class="hljs-built_in">print</span> ex_value.__class__
        <span class="hljs-keyword">return</span> <span class="hljs-literal">True</span>
    <span class="hljs-keyword">if</span> ex_type <span class="hljs-keyword">is</span> TypeError:
        <span class="hljs-built_in">print</span> ex_value.__class__
        <span class="hljs-keyword">return</span>  <span class="hljs-comment"># return None</span>

with DemoManager() as nothing:
data = [1, 2, 3]
data[4]  # raise IndexError, 该异常被 __exit__ 处理了
with DemoManager() as nothing:
data = [1, 2, 3]
data['a']  # raise TypeError, 该异常没有被 __exit__ 处理
'''
输出:
<type 'exceptions.IndexError'>
<type 'exceptions.TypeError'>
Traceback (most recent call last):
...
'''

回到顶部
对象的序列化
Python 对象的序列化操作是 pickling 进行的。pickling 非常的重要，以至于 Python 对此有单独的模块pickle，还有一些相关的魔术方法。使用 pickling, 你可以将数据存储在文件中，之后又从文件中进行恢复。
下面举例来描述 pickle 的操作。从该例子中也可以看出, 如果通过 pickle.load 初始化一个对象, 并不会调用__init__方法。
# -*- coding: utf-8 -*-
from datetime import datetime
import pickle
classDistance(object):
def__init__(self, meter):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'distance __init__'</span>
    self.meter = meter

data = {
'foo': [1, 2, 3],
'bar': ('Hello', 'world!'),
'baz': True,
'dt': datetime(2016, 10, 01),
'distance': Distance(1.78),
}
print 'before dump:', data
with open('data.pkl', 'wb') as jar:
pickle.dump(data, jar)  # 将数据存储在文件中
del data
print 'data is deleted!'
with open('data.pkl', 'rb') as jar:
data = pickle.load(jar)  # 从文件中恢复数据
print 'after load:', data

值得一提，从其他文件进行 pickle.load 操作时，需要注意有恶意代码的可能性。另外，Python 的各个版本之间,pickle 文件可能是互不兼容的。
pickling 并不是 Python 的內建类型，它支持所有实现 pickle 协议 (可理解为接口) 的类。pickle 协议有以下几个可选方法来自定义 Python 对象的行为。
__getinitargs__(self)
如果你希望 unpickle 时，__init__方法能够调用，那么就需要定义__getinitargs__, 该方法需要返回一系列参数的元组，这些参数就是传给__init__的参数。
该方法只对old-style class有效。所谓old-style class, 指的是不继承自任何对象的类，往往定义时这样表示: class A:, 而非class A(object):
__getnewargs__(self)
跟__getinitargs__很类似，只不过返回的参数元组将传值给__new__
__getstate__(self)
在调用pickle.dump时，默认是对象的__dict__属性被存储，如果你要修改这种行为，可以在__getstate__方法中返回一个 state。state 将在调用pickle.load时传值给__setstate__
__setstate__(self, state)
一般来说, 定义了__getstate__, 就需要相应地定义__setstate__来对__getstate__返回的 state 进行处理。
__reduce__(self)
如果 pickle 的数据包含了自定义的扩展类（比如使用 C 语言实现的 Python 扩展类）时，就需要通过实现__reduce__方法来控制行为了。由于使用过于生僻，这里就不展开继续讲解了。
令人容易混淆的是，我们知道, reduce()是 Python 的一个內建函数, 需要指出__reduce__并非定义了reduce()的行为，二者没有关系。
__reduce_ex__(self)
__reduce_ex__ 是为了兼容性而存在的, 如果定义了__reduce_ex__, 它将代替__reduce__ 执行。
下面的代码示例很有意思，我们定义了一个类 Slate(中文是板岩的意思)。这个类能够记录历史上每次写入给它的值, 但每次pickle.dump时当前值就会被清空，仅保留了历史。
# -*- coding: utf-8 -*-
import pickle
import time
classSlate:
'''Class to store a string and a changelog, and forget its value when pickled.'''
def__init__(self, value):
self.value = value
self.last_change = time.time()
self.history = []
defchange(self, new_value):
    <span class="hljs-comment"># 修改value, 将上次的valeu记录在history</span>
    self.history.append((self.last_change, self.value))
    self.value = new_value
    self.last_change = time.time()

defprint_changes(self):
    <span class="hljs-built_in">print</span> <span class="hljs-string">'Changelog for Slate object:'</span>
    <span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> self.history:
        <span class="hljs-built_in">print</span> <span class="hljs-string">'%s    %s'</span> % (k, v)

def__getstate__(self):
    <span class="hljs-comment"># 故意不返回self.value和self.last_change,</span>
    <span class="hljs-comment"># 以便每次unpickle时清空当前的状态，仅仅保留history</span>
    <span class="hljs-keyword">return</span> self.history

def__setstate__(self, state):
    self.history = state
    self.value, self.last_change = <span class="hljs-literal">None</span>, <span class="hljs-literal">None</span>

slate = Slate(0)
time.sleep(0.5)
slate.change(100)
time.sleep(0.5)
slate.change(200)
slate.change(300)
slate.print_changes()  # 与下面的输出历史对比
with open('slate.pkl', 'wb') as jar:
pickle.dump(slate, jar)
del slate  # delete it
with open('slate.pkl', 'rb') as jar:
slate = pickle.load(jar)
print 'current value:', slate.value  # None
print slate.print_changes()  # 输出历史记录与上面一致

回到顶部
运算符相关的魔术方法
运算符相关的魔术方法实在太多了，也很好理解，不打算多讲。在其他语言里，也有重载运算符的操作，所以我们对这些魔术方法已经很了解了。
比较运算符
__cmp__(self, other)
如果该方法返回负数，说明self < other; 返回正数，说明self > other; 返回 0 说明self == other。
强烈不推荐来定义__cmp__, 取而代之, 最好分别定义__lt__等方法从而实现比较功能。
__cmp__在 Python3 中被废弃了。
__eq__(self, other)
定义了比较操作符==的行为.
__ne__(self, other)
定义了比较操作符!=的行为.
__lt__(self, other)
定义了比较操作符<的行为.
__gt__(self, other)
定义了比较操作符>的行为.
__le__(self, other)
定义了比较操作符<=的行为.
__ge__(self, other)
定义了比较操作符>=的行为.
下面我们定义一种类型 Word, 它会使用单词的长度来进行大小的比较, 而不是采用 str 的比较方式。
但是为了避免 Word('bar') == Word('foo') 这种违背直觉的情况出现, 并没有定义__eq__, 因此 Word 会使用它的父类 (str) 中的__eq__来进行比较。
下面的例子中也可以看出: 在编程语言中, 如果a >=b and a <= b, 并不能推导出a == b这样的结论。
# -*- coding: utf-8 -*-
classWord(str):
    ''' 存储单词的类，定义比较单词的几种方法 '''
    def__new__(cls, word):
        # 注意我们必须要用到 __new__ 方法，因为 str 是不可变类型
        # 所以我们必须在创建的时候将它初始化
        if ' ' in word:
            print "Value contains spaces. Truncating to first space."
            word = word[:word.index(' ')]  # 单词是第一个空格之前的所有字符
        return str.__new__(cls, word)
def__gt__(self, other):
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">len</span>(self) &gt; <span class="hljs-built_in">len</span>(other)
def__lt__(self, other):
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">len</span>(self) &lt; <span class="hljs-built_in">len</span>(other)
def__ge__(self, other):
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">len</span>(self) &gt;= <span class="hljs-built_in">len</span>(other)
def__le__(self, other):
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">len</span>(self) &lt;= <span class="hljs-built_in">len</span>(other)

print 'foo < fool:', Word('foo') < Word('fool')  # True
print 'foolish > fool:', Word('foolish') > Word('fool')  # True
print 'bar >= foo:', Word('bar') >= Word('foo')  # True
print 'bar <= foo:', Word('bar') <= Word('foo')  # True
print 'bar == foo:', Word('bar') == Word('foo')  # False, 用了 str 内置的比较方法来进行比较
print 'bar != foo:', Word('bar') != Word('foo')  # True

一元运算符和函数

__pos__(self)
实现了 '+' 号一元运算符 ( 比如+some_object)
__neg__(self)
实现了 '-' 号一元运算符 ( 比如-some_object)
__invert__(self)
实现了~号 (波浪号) 一元运算符(比如~some_object)
__abs__(self)
实现了abs()內建函数.
__round__(self, n)
实现了round()内建函数. 参数 n 表示四舍五进的精度.
__floor__(self)
实现了math.floor(), 向下取整.
__ceil__(self)
实现了math.ceil(), 向上取整.
__trunc__(self)
实现了math.trunc(), 向 0 取整.
算术运算符
__add__(self, other)
实现了加号运算.
__sub__(self, other)
实现了减号运算.
__mul__(self, other)
实现了乘法运算.
__floordiv__(self, other)
实现了//运算符.
__div__(self, other)
实现了/运算符. 该方法在 Python3 中废弃. 原因是 Python3 中，division 默认就是 true division.
__truediv__(self, other)
实现了 true division. 只有你声明了from __future__ import division该方法才会生效.
__mod__(self, other)
实现了%运算符, 取余运算.
__divmod__(self, other)
实现了divmod()內建函数.
__pow__(self, other)
实现了**操作. N 次方操作.
__lshift__(self, other)
实现了位操作<<.
__rshift__(self, other)
实现了位操作>>.
__and__(self, other)
实现了位操作&.
__or__(self, other)
实现了位操作|
__xor__(self, other)
实现了位操作^
反算术运算符
这里只需要解释一下概念即可。
假设针对 some_object 这个对象:
some_object + other

上面的代码非常正常地实现了 some_object 的__add__方法。那么如果遇到相反的情况呢?
other + some_object

这时候，如果 other 没有定义__add__方法，但是 some_object 定义了__radd__, 那么上面的代码照样可以运行。
这里的__radd__(self, other)就是__add__(self, other)的反算术运算符。
所以，类比的，我们就知道了更多的反算术运算符, 就不一一展开了:

__rsub__(self, other)
__rmul__(self, other)
__rmul__(self, other)
__rfloordiv__(self, other)
__rdiv__(self, other)
__rtruediv__(self, other)
__rmod__(self, other)
__rdivmod__(self, other)
__rpow__(self, other)
__rlshift__(self, other)
__rrshift__(self, other)
__rand__(self, other)
__ror__(self, other)
__rxor__(self, other)

增量赋值
这也是只要理解了概念就容易掌握的运算。举个例子:
x = 5
x += 1  # 这里的 += 就是增量赋值，将 x+1 赋值给了 x

因此对于a += b, __iadd__ 将返回a + b, 并赋值给 a。
所以很容易理解下面的魔术方法了:

__iadd__(self, other)
__isub__(self, other)
__imul__(self, other)
__ifloordiv__(self, other)
__idiv__(self, other)
__itruediv__(self, other)
__imod__(self, other)
__ipow__(self, other)
__ilshift__(self, other)
__irshift__(self, other)
__iand__(self, other)
__ior__(self, other)
__ixor__(self, other)

类型转化
__int__(self)
实现了类型转化为 int 的行为.
__long__(self)
实现了类型转化为 long 的行为.
__float__(self)
实现了类型转化为 float 的行为.
__complex__(self)
实现了类型转化为 complex(复数, 也即 1+2j 这样的虚数) 的行为.
__oct__(self)
实现了类型转化为八进制数的行为.
__hex__(self)
实现了类型转化为十六进制数的行为.
__index__(self)
在切片运算中将对象转化为 int, 因此该方法的返回值必须是 int。用一个例子来解释这个用法。
classThing(object):
    def__index__(self):
        return 1
thing = Thing()
list_ = ['a', 'b', 'c']
print list_[thing]  # 'b'
print list_[thing:thing]  # []

上面例子中, list_[thing]的表现跟list_[1]一致，正是因为 Thing 实现了__index__方法。
可能有的人会想，list_[thing]为什么不是相当于list_[int(thing)]呢? 通过实现 Thing 的__int__方法能否达到这个目的呢?
显然不能。如果真的是这样的话，那么list_[1.1:2.2]这样的写法也应该是通过的。
而实际上，该写法会抛出 TypeError: slice indices must be integers or None or have an __index__ method
下面我们再做个例子, 如果对一个 dict 对象执行dict_[thing]会怎么样呢?
dict_ = {1: 'apple', 2: 'banana', 3: 'cat'}
print dict_[thing]  # raise KeyError
这个时候就不是调用__index__了。虽然list和dict都实现了__getitem__方法, 但是它们的实现方式是不一样的。
如果希望上面例子能够正常执行, 需要实现 Thing 的__hash__ 和 __eq__方法.
classThing(object):
    def__hash__(self):
        return 1
    def__eq__(self, other):
        return hash(self) == hash(other)
dict_ = {1: 'apple', 2: 'banana', 3: 'cat'}
print dict_[thing]  # apple

__coerce__(self, other)
实现了混合模式运算。
要了解这个方法, 需要先了解coerce()内建函数: 官方文档上的解释是, coerce(x, y) 返回一组数字类型的参数, 它们被转化为同一种类型，以便它们可以使用相同的算术运算符进行操作。如果过程中转化失败，抛出 TypeError。
比如对于coerce(10, 10.1), 因为 10 和 10.1 在进行算术运算时，会先将 10 转为 10.0 再来运算。因此coerce(10, 10.1)返回值是 (10.0, 10.1).
__coerce__在 Python3 中废弃了。
回到顶部
其他魔术方法
还没讲到的魔术方法还有很多，但有些我觉得很简单，或者很少见，就不再累赘展开说明了。
__str__(self)
对实例使用str()时调用。
__repr__(self)
对实例使用repr()时调用。str()和repr()都是返回一个代表该实例的字符串，
主要区别在于: str()的返回值要方便人来看, 而 repr() 的返回值要方便计算机看。
__unicode__(self)
对实例使用unicode()时调用。unicode()与str()的区别在于: 前者返回值是 unicode, 后者返回值是 str。unicode 和 str 都是basestring的子类。
当你对一个类只定义了__str__但没定义__unicode__时,__unicode__会根据__str__的返回值自动实现, 即return unicode(self.__str__());
但返回来则不成立。
classStrDemo2:
    def__str__(self):
        return 'StrDemo2'
classStrDemo3:
def__unicode__(self):
return u'StrDemo3'
demo2 = StrDemo2()
print str(demo2)  # StrDemo2
print unicode(demo2)  # StrDemo2
demo3 = StrDemo3()
print str(demo3)  # <main.StrDemo3 instance>
print unicode(demo3)  # StrDemo3

__format__(self, formatstr)
"Hello, {0:abc}".format(a)等价于format(a, "abc"), 等价于a.__format__("abc")。
这在需要格式化展示对象的时候非常有用，比如格式化时间对象。
__hash__(self)
对实例使用hash()时调用, 返回值是数值类型。
__nonzero__(self)
对实例使用bool()时调用, 返回 True 或者 False。
你可能会问, 为什么不是命名为__bool__? 我也不知道。
我只知道该方法在 Python3 中改名为__bool__了。
__dir__(self)
对实例使用dir()时调用。通常实现该方法是没必要的。
__sizeof__(self)
对实例使用sys.getsizeof()时调用。返回对象的大小，单位是 bytes。
__instancecheck__(self, instance)
对实例调用isinstance(instance, class)时调用。 返回值是布尔值。它会判断 instance 是否是该类的实例。
__subclasscheck__(self, subclass)
对实例使用issubclass(subclass, class)时调用。返回值是布尔值。它会判断 subclass 否是该类的子类。
__copy__(self)
对实例使用copy.copy()时调用。返回 "浅复制" 的对象。
__deepcopy__(self, memodict={})
对实例使用copy.deepcopy()时调用。返回 "深复制" 的对象。
__call__(self, [args...])
该方法允许类的实例跟函数一样表现:
classXClass:
    def__call__(self, a, b):
        return a + b
defadd(a, b):
return a + b
x = XClass()
print 'x(1, 2)', x(1, 2)
print 'callable(x)', callable(x)  # True
print 'add(1, 2)', add(1, 2)
print 'callable(add)', callable(add)  # True

回到顶部
Python3 中的差异

Python3 中，str 与 unicode 的区别被废除了, 因而__unicode__没有了，取而代之地出现了__bytes__.
Python3 中，division 默认就是 true division, 因而__div__废弃.
__coerce__因存在冗余而废弃.
__cmp__因存在冗余而废弃.
__nonzero__改名为__bool__.