if instance.equals(other_instance):

    # do something

if instance == other_instance:

        #do something

用于比较的魔术方法

Python对实现对象的比较，使用魔术方法进行了大的逆转，使他们非常直观而不是笨拙的方法调用。而且还提供了一种方法可以重写Python对对象比较的默认行为(通过引用)。以下是这些方法和他们的作用。

__cmp__(self, other) __cmp__ 是最基本的用于比较的魔术方法。它实际上实现了所有的比较符号(<,==,!=,etc.)，但是它的表现并不会总是如你所愿(比如，当一个实例与另一个实例相等是通过一个规则来判断，而一个实例大于另外一个实例是通过另外一个规则来判断)。如果 self < other 的话 __cmp__ 应该返回一个负数，当 self == o 的时候会返回0 ，而当 self > other 的时候会返回正数。通常最好的一种方式是去分别定义每一个比较符号而不是一次性将他们都定义。但是 __cmp__ 方法是你想要实现所有的比较符号而一个保持清楚明白的一个好的方法。

__eq__(self, other) 定义了等号的行为, == 。

__ne__(self, other) 定义了不等号的行为, != 。

__lt__(self, other) 定义了小于号的行为， < 。

__gt__(self, other) 定义了大于等于号的行为， >= 。

举一个例子，创建一个类来表现一个词语。我们也许会想要比较单词的字典序(通过字母表)，通过默认的字符串比较的方法就可以实现，但是我们也想要通过一些其他的标准来实现，比如单词长度或者音节数量。在这个例子中，我们来比较长度实现。以下是实现代码:

class Word(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):

        return len(self) > len(other)

    def __lt__(self, other):

        return len(self) < len(other)

    def __ge__(self, other):

        return len(self) >= len(other)

    def __le__(self, other):

        return len(self) <= len(other)

现在，我们创建两个 Words 对象(通过使用 Word('foo') 和 Word('bar') 然后通过长度来比较它们。注意，我们没有定义 __eq__ 和 __ne__ 方法。这是因为将会产生一些怪异的结果(比如 Word('foo') == Word('bar') 将会返回true)。这对于测试基于长度的比较不是很有意义。所以我们退回去，用 str 内置来进行比较。

现在你知道你不必定义每一个比较的魔术方法从而进行丰富的比较。标准库中很友好的在 functiontols 中提供给我们一个类的装饰器定义了所有的丰富的比较函数。如果你只是定义 __eq__ 和另外一个(e.g. __gt__, __lt__,etc.)这个特性仅仅在Python 2.7中存在，但是你如果有机会碰到的话，那么将会节省大量的时间和经理。你可以通过在你定义的类前放置 @total_ordering 来使用。

数值处理的魔术方法

如同你在通过比较符来比较类的实例的时候来创建很多方法，你也可以定义一些数值符号的特性。系紧你的安全带，来吧，这里有很多内容。为了组织方便，我将会把数值处理的方法来分成五类:一元操作符，普通算数操作符，反射算数操作符(之后会详细说明),增量赋值，和类型转换。

some_object + other

other + some_object

x = 5

x += 1 # in other words x = x + 1

class AccessCounter:

    '''一个包含计数器的控制权限的类每当值被改变时计数器会加一'''

    def __init__(self, val):

        super(AccessCounter, self).__setattr__('counter', 0)

        super(AccessCounter, self).__setattr__('value', val)

    def __setattr__(self, name, value):

        if name == 'value':

            super(AccessCounter, self).__setattr__('counter', self.counter + 1)

    #如果你不想让其他属性被访问的话，那么可以抛出 AttributeError(name) 异常

        super(AccessCounter, self).__setattr__(name, value)

    def __delattr__(self, name):

        if name == 'value':

            super(AccessCounter, self).__setattr__('counter', self.counter + 1)

        super(AccessCounter, self).__delattr__(name)]

必须条件

现在我们开始讲如何在Python中创建定制的序列，这个时候该讲一讲协议。协议(Protocols)与其他语言中的接口很相似。它给你很多你必须定义的方法。然而在Python中的协议是很不正式的，不需要明确声明实现。事实上，他们更像一种指南。

我们为什么现在讨论协议？因为如果要定制容器类型的话需要用到这些协议。首先，实现不变容器的话有一个协议:实现不可变容器，你只能定义 __len__和 __getitem__ (一会会讲更多)。可变容器协议则需要所有不可变容器的所有另外还需要 __setitem__ 和 __delitem__ 。最终，如果你希望你的对象是可迭代的话，你需要定义 __iter__ 会返回一个迭代器。迭代器必须遵循迭代器协议，需要有 __iter__ (返回它本身) 和 next 。

容器后的魔法

这些是容器使用的魔术方法。 __len__(self) 然会容器长度。对于可变不可变容器都需要有的协议的一部分。 __getitem__(self, key) 定义当一个条目被访问时，使用符号 self[key] 。这也是不可变容器和可变容器都要有的协议的一部分。如果键的类型错误和 KeyError 或者没有合适的值。那么应该抛出适当的 TypeError 异常。 __setitem__(self, key, value) 定义当一个条目被赋值时的行为,使用 self[key] = value 。这也是可变容器和不可变容器协议中都要有的一部分。 __delitem__(self, key) 定义当一个条目被删除时的行为(比如 del self[key])。这只是可变容器协议中的一部分。当使用一个无效的键时应该抛出适当的异常。 __iter__(self) 返回一个容器的迭代器。很多情况下会返回迭代器，尤其是当内置的 iter() 方法被调用的时候，或者当使用 for x incontainer 方式循环的时候。迭代器是他们本身的对象，他们必须定义返回 self 的 __iter__ 方法。 __reversed__(self) 实现当 reversed() 被调用时的行为。应该返回列表的反转版本。 __contains__(self, item) 当调用 in 和 not in 来测试成员是否存在时候 __contains__ 被定义。你问为什么这个不是序列协议的一部分？那是因为当 __contains__ 没有被定义的时候，Python会迭代这个序列并且当找到需要的值时会返回 True 。 __concat__(self, other) 最终，你可以通过 __concat__ 来定义当用其他的来连接两个序列时候的行为。当 + 操作符被调用时候会返回一个 self 和 other.__concat__ 被调用后的结果产生的新序列。

一个例子

在我们的例子中，让我们看一看你可能在其他语言中 用到的函数构造语句的实现(比如 Haskell)。

class FunctionalList:

'''一个封装了一些附加魔术方法比如 head, tail, init, last, drop, 和take的列表类。

'''

def __init__(self, values=None):

if values is None:

    self.values = []

else:

    self.values = values

def __len__(self):

    return len(self.values)

def __getitem__(self, key):

    #如果键的类型或者值无效，列表值将会抛出错误

    return self.values[key]

def __setitem__(self, key, value):

    self.values[key] = value

def __delitem__(self, key):

    del self.values[key]

def __iter__(self):

    return iter(self.values)

def __reversed__(self):

    return reversed(self.values)

def append(self, value):

    self.values.append(value)

def head(self):

    return self.values[0]

def tail(self):

    return self.values[1:]

def init(self):

    #返回一直到末尾的所有元素

    return self.values[:-1]

def last(self):

    #返回末尾元素

    return self.values[-1]

def drop(self, n):

    #返回除前n个外的所有元素

    return self.values[n:]

def take(self, n):

    #返回前n个元素

    return self.values[:n]

class Entity:

'''调用实体来改变实体的位置。'''

def __init__(self, size, x, y):

    self.x, self.y = x, y

    self.size = size

def __call__(self, x, y):

    '''改变实体的位置'''

    self.x, self.y = x, y

with open('foo.txt') as bar:

# perform some action with bar

class Closer:

'''通过with语句和一个close方法来关闭一个对象的会话管理器'''

def __init__(self, obj):

    self.obj = obj

def __enter__(self):

    return self.obj # bound to target

def __exit__(self, exception_type, exception_val, trace):

    try:

        self.obj.close()

    except AttributeError: # obj isn't closable

        print 'Not closable.'

        return True # exception handled successfully

class Meter(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)

class Foot(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

class Distance(object):

    '''Class to represent distance holding two descriptors for feet and

    meters.'''

    meter = Meter()

    foot = Foot()

Pickling: 简单例子

让我们深入研究 Pickle，比如说你现在需要临时储存一个字典，你可以把它写入到一个文件里，并且要小心翼翼的确保格式正确，之后再用 exec() 或者处理文件输入来恢复数据，实际上这是很不安全的，如果你使用文本存储了一些重要的数据，任何方式的改变都可能会影响到你的程序，轻则程序崩溃，重则被恶意程序利用，所以，让我们用 Pickle 代替这种方式：

import pickle

data = {'foo': [1, 2, 3],

        'bar': ('Hello', 'world!'),

        'baz': True}

jar = open('data.pkl', 'wb')

pickle.dump(data, jar) # write the pickled data to the file jar

jar.close()

嗯，过了几个小时之后，我们需要用到它了，只需把它 unpickle 了就行了：

import pickle

pkl_file = open('data.pkl', 'rb') # connect to the pickled data

data = pickle.load(pkl_file) # load it into a variable

print data

pkl_file.close()

正如你期望的，数据原封不动的回来了！

同时要给你一句忠告： pickle 并不是很完美， Pickle 文件很容易被不小心或者故意损坏， Pickle 文件比纯文本文件要稍微安全一点，但是还是可以被利用运行恶意程序。 Pickle 不是跨版本兼容的（译注：最近刚好在 《Python Cookbook》上看到相关讨论，书中描述的 Pickle 是跨版本兼容的，此点待验证），所以尽量不要去分发 Pickle 过的文本，因为别人并不一定能够打开。不过在做缓存或者其他需要序列化数据的时候， Pickle 还是很有用处的。

序列化你自己的对象

Pickle 并不是只支持内建数据结果，任何遵循 Pickle 协议的类都可以，Pickle 协议为 Python 对象规定了4个可选方法来自定义 Pickle 行为（对于 C 扩展的 cPickle 模块会有一些不同，但是这并不在我们的讨论范围内）：

__getinitargs__(self)

如果你希望在逆序列化的同时调用 __init__ ，你可以定义 __getinitargs__ 方法，这个方法应该返回一系列你想被 __init__ 调用的参数，注意这个方法只对老样式的类起作用。

__getnewargs__(self)

对于新式的类，你可以定义任何在重建对象时候传递到 __new__ 方法中的参数。这个方法也应该返回一系列的被 __new__ 调用的参数。

__getstate__(self)

你可以自定义当对象被序列化时返回的状态，而不是使用 __dict 方法，当逆序列化对象的时候，返回的状态将会被 __setstate__ 方法调用。

__setstate__(self, state)

在对象逆序列化的时候，如果 __setstate__ 定义过的话，对象的状态将被传给它而不是传给 __dict__ 。这个方法是和 __getstate__ 配对的，当这两个方法都被定义的时候，你就可以完全控制整个序列化与逆序列化的过程了。

例子

我们以 Slate 为例，这是一段记录一个值以及这个值是何时被写入的程序，但是，这个 Slate 有一点特殊的地方，当前值不会被保存。

import time

class Slate:

    '''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.asctime()

        self.history = {}

    def change(self, new_value):

        # Change the value. Commit last value to history

        self.history[self.last_change] = self.value

        self.value = new_value

        self.last_change = time.asctime()

    def print_changes(self):

        print 'Changelog for Slate object:'

        for k, v in self.history.items():

            print '%s\t%s' % (k, v)

    def __getstate__(self):

        # Deliberately do not return self.value or self.last_change.

        # We want to have a "blank slate" when we unpickle.

        return self.history

    def __setstate__(self, state):

        # Make self.history = state and last_change and value undefined

        self.history = state

        self.value, self.last_change = None, None

结论

这份指南的希望为所有人都能带来一些知识，即使你是 Python 大牛或者对于精通于面向对象开发。如果你是一个 Python 初学者，阅读这篇文章之后你已经获得了编写丰富，优雅，灵活的类的知识基础了。如果你是一个有一些经验的 Python 程序员，你可能会发现一些能让你写的代码更简洁的方法。如果你是一个 Python 大牛，可能会帮助你想起来一些你已经遗忘的知识，或者一些你还没听说过的新功能。不管你现在有多少经验，我希望这次对于 Python 特殊方法的旅程能够带给你一些帮助（用双关语真的很不错 XD）（译注: 这里的双关在于标题为 Magic Methods 这里是 神奇的旅程 ，不过由于中英语序的问题，直译略显头重脚轻，所以稍微变化了下意思，丢掉了双关的含义）。

附录：如何调用魔术方法

一些魔术方法直接和内建函数相对，在这种情况下，调用他们的方法很简单，但是，如果是另外一种不是特别明显的调用方法，这个附录介绍了很多并不是很明显的魔术方法的调用形式。

希望这个表格对你对于什么时候应该使用什么方法这个问题有所帮助。