Python的神奇方法指南1

原文作者：Rafe Kettler

简介

有关Python内编写类的各种技巧和方法(构建和初始化、重载操作符、类描述、属性访问控制、自定义序列、反射机制、可调用对象、上下文管理、构建描述符对象、Pickling)。你可以把它当作一个教程，进阶，或者使用参考；我希望它能够成为一份针对Python方法的用户友好指南。  

1.介绍

这份指南是几个月内最有价值的Blog投稿精华。它的主题是向大家讲述Python中的神奇方法。
何为神奇方法呢？它们是面向Python中的一切，是一些特殊的方法允许在自己的定义类中定义增加“神奇”的功能。它们总是使用双下划线（比如__init__或__lt__），但它们的文档没有很好地把它们表现出来。所有这些神奇方法都出现在Python的官方文档中，但内容相对分散，组织结构也显得松散。还有你会难以发现一个实例（虽然他们被设计很棒，在语言参考中被详细描述，可之后就会伴随着枯燥的语法描述等）。
所以，为了解决我认为在Python文档中的一大败笔，我打算用更多纯英语，实例驱动的文档来说明Python的神奇方法。然后我就开始花了几周的时间来写blog，而现在我已经完成了它们，并将它们合订成一份指南。
我希望你喜欢它。把它当作一个教程，进阶，或者使用参考；我希望它能够成为一份针对Python方法的用户友好指南。


2.构建和初始化
相信大家都熟悉这个最基础的神奇方法__init__。它令你能自定义一个对象的初始化行为。而当我调用x=SomeClass()时，__init__并不是最先被调用的。实际上有一个叫做__new__的方法，事实上是它创建了实例，它传递任何参数给初始化程序来达到创建的目的。在对象生命周期结束时，调用__del__。让我们更近地观察下这3个神奇方法吧：

__new__(cls,[...)

一个对象的实例化时__new__是第一个被调用的方法。在类中传递其他任何参数到__init__。__new__很少被使用，这样做确实有其目的，特别是当一个子类继承一个不可改变的类型(一个元组或一个字符串)时。我不打算再继续深入追求__new__的细节了，因为这不会产生多大用处，因为在Python Docs内已经涵盖了一份巨详细的说明了。

__init__(self,[...)
类的初始化。它会获得初始构建调用传过来的任何东西（举例来说就是，当我们调用x=SomeClass(10,'foo'),__init__就会把传过来的10和'foo'作为参数。__init__在Python的类定义中几乎普遍被使用）

__del__(self)
如果__new__和__init__是对象的构造器，那么__del__就是析构器。它不实现声明为del x(这样的代码不会解释成x.__del__())的行为。相反，它定义为当一个对象被垃圾回收时的行为。这可能对可能需要额外清理的对象相当有用，比如sockets或文件对象。但要小心，如果对象仍处于存活状态而当被解释退出时，__del__没有保证就会被执行，因此这样的__del__不能作为良好的编码规范的替代。（就像当你完成操作总是要关闭一次连接。但事实上，__del__几乎永远不会执行，就因为它处于不安全情况被调用了。使用时保持警惕！）

把上述这些内容合在一起，就成了一份__init__和__del__的实际使用用例：

1

2

3

4

5

6

7

8

9

10

11

from os.path import join

class FileObject:

    '''对文件对象的包装，确保文件在关闭时得到删除'''

                                                     

    def __init__(self, filepath='~', filename='sample.txt'):

        # 按filepath，读写模式打开名为filename的文件

        self.file=open(join(filepath,filename), 'r+')

                                                         

    def __del__(self):

        self.file.close()

        del self.file

 3.使操作符在自定义类内工作

使用Python神奇方法的优势之一就是它提供了一种简单的方式能让对象的行为像内建类型。这意味着你可以避免用丑陋，反直觉和非标准方法执行基本运算。在某些语言中，通常会这样做：

1

2

if instance.equals(other_instance):

    # do something

 你也应该在Python确实会这样做，但同时它会增加用户的疑惑以及不必要的冗长。不同的库可能会对相同的运算采用不同的命名，这使得用户比平常干了更多的事。依靠神奇方法的力量，你可以定义一个方法(比如__eq__),然后带代替我们真实的意图：

1

2

if instance == other_instance:

    # do something

现在你看到的是神奇方法力量的一部分。绝大多数都允许我们定义为运算符本身的意义，当用在我们自己定义的类上就像它们是内建类型。
3.1 神奇方法——比较
Python有一整套神奇方法被设计用来通过操作符实现对象间直观的比较，而非别扭的方法调用。它们同样提供了一套覆盖Python对象比较的默认行为(通过引用)。以下是这些方法的列表以及做法：

__cmp__(self, other)
__cmp__是神奇方法中最基础的一个。实际上它实现所有比较操作符行为(<,==,!=,等)，但它有可能不按你想要的方法工作(例如，一个实例是否等于另一个这取决于比较的准则，以及一个实例是否大于其他的这也取决于其他的准则)。如果self < other，那__cmp__应当返回一个负整数；如果self == other，则返回0；如果self > other，则返回正整数。它通常是最好的定义，而不需要你一次就全定义好它们，但当你需要用类似的准则进行所有的比较时，__cmp__会是一个很好的方式，帮你节省重复性和提高明确度。
__eq__(self, other)
定义了相等操作符，==的行为。
__ne__(self, other)
定义了不相等操作符，!=的行为。
__lt__(self, other)
定义了小于操作符，<的行为。
__gt__(self, other)
定义了大于操作符，>的行为。
__le__(self, other)
定义了小于等于操作符，<=的行为。
__ge__(self, other)
定义了大于等于操作符，>=的行为。
举一个例子，设想对单词进行类定义。我们可能希望能够按内部对string的默认比较行为，即字典序(通过字母)来比较单词，也希望能够基于某些其他的准则，像是长度或音节数。在本例中，我们通过单词长度排序，以下给出实现：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

class Word(str):

    '''单词类，比较定义是基于单词长度的'''

                                            

    def __new__(cls, word):

        # 注意，我们使用了__new__,这是因为str是一个不可变类型，

        # 所以我们必须更早地初始化它（在创建时）

        if ' ' in word:

            print "单词内含有空格，截断到第一部分"

            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)

 

现在，我们可以创建2个单词（通过Word('foo')和Word('bar'))并基于它们的长度进行比较了。注意，我们没有定义__eq__和 __ne__。这是因为这可能导致某些怪异的行为（特别是当比较Word('foo') == Word('bar')将会得到True的结果）。基于单词长度的相等比较会令人摸不清头脑，因此我们就沿用了str本身的相等比较的实现。


现在可能是一个好时机来提醒你一下，你不必重载每一个比较相关的神奇方法来获得各种比较。标准库已经友好地为我们在模板functools中提供了一个装饰(decorator)类，定义了所有比较方法。你可以只重载__eq__和一个其他的方法（比如__gt__,__lt__，等）。这个特性只在Python2.7(后?)适用，但当你有机会的话应该尝试一下，它会为你省下大量的时间和麻烦。你可以通过在你自己的重载方法在加上@total_ordering来使用。
3.2 神奇方法——数字
就像你可以通过重载比较操作符的途径来创建你自己的类实例，你同样可以重载数字操作符。系好你们的安全带，朋友们，还有很多呢。处于本文组织的需要，我会把数字的神奇方法分割成5块：一元操作符，常规算术操作符，反射算术操作符，增量赋值，类型转换。
一元操作符
一元运算和函数仅有一个操作数，比如负数，绝对值等
__pos__(self)
实现一元正数的行为(如：+some_object)
__neg__(self)
实现负数的行为(如: -some_object)
__abs__(self)
实现内建abs()函数的行为
__invert__(self)
实现用~操作符进行的取反行为。你可以参考Wiki:bitwise operations来解释这个运算符究竟会干什么
常规算术操作符
现在我们涵盖了基本的二元运算符:+，-，*等等。其中大部分都是不言自明的。
__add__(self, other)
实现加法
__sub__(self, other)
实现减法
__mul__(self, other)
实现乘法
__floordiv__(self, other)
实现地板除法，使用//操作符
__div__(self, other)
实现传统除法，使用/操作符
__truediv__(self, other)
实现真正除法。注意，只有当你from __future__ import division时才会有效
__mod__(self, other)
实现求模，使用%操作符
__divmod__(self, other)
实现内建函数divmod()的行为
__pow__(self, other)
实现乘方，使用**操作符
__lshift__(self, other)
实现左按位位移，使用<<操作符
__rshift__(self, other)
实现右按位位移，使用>>操作符
__and__(self, other)
实现按位与，使用&操作符
__or__(self, other)
实现按位或，使用|操作符
__xor__(self, other)
实现按位异或，使用^操作符
反射算术操作符
你知道我会如何解释反射算术操作符？你们中的有些人或许会觉得它很大，很可怕，是国外的概念。但它实际上很简单，下面给一个例子：

some_object + other

这是“常规的”加法。而反射其实相当于一回事，除了操作数改变了改变下位置：

other + some_object

因此，所有这些神奇的方法会做同样的事等价于常规算术操作符，除了改变操作数的位置关系，比如第一个操作数和自身作为第二个。此外没有其他的操作方式。在大多数情况下，反射算术操作的结果等价于常规算术操作，所以你尽可以在刚重载完__radd__就调用__add__。干脆痛快：
__radd__(self, other)
实现反射加法
__rsub__(self, other)
实现反射减法
__rmul__(self, other)
实现反射乘法
__rfloordiv__(self, other)
实现反射地板除，用//操作符
__rdiv__(self, other)
实现传统除法，用/操作符
__rturediv__(self, other)
实现真实除法，注意，只有当你from __future__ import division时才会有效
__rmod__(self, other)
实现反射求模，用%操作符
__rdivmod__(self, other)
实现内置函数divmod()的长除行为，当调用divmod(other,self)时被调用
__rpow__(self, other)
实现反射乘方，用**操作符
__rlshift__(self, other)
实现反射的左按位位移，使用<<操作符
__rrshift__(self, other)
实现反射的右按位位移，使用>>操作符
__rand__(self, other)
实现反射的按位与，使用&操作符
__ror__(self, other)
实现反射的按位或，使用|操作符
__rxor__(self, other)
实现反射的按位异或，使用^操作符
增量赋值

Python也有各种各样的神奇方法允许用户自定义增量赋值行为。你可能已经熟悉增量赋值，它结合了“常规的”操作符和赋值。如果你仍不明白我在说什么，下面有一个例子：

1

2

x = 5

x += 1 # 等价 x = x + 1

这些方法都不会有返回值，因为赋值在Python中不会有任何返回值。反而它们只是改变类的状态。列表如下：
__iadd__(self, other)
实现加法和赋值
__isub__(self, other)
实现减法和赋值
__imul__(self, other)
实现乘法和赋值
__ifloordiv__(self, other)
实现地板除和赋值，用//=操作符
__idiv__(self, other)
实现传统除法和赋值，用/=操作符
__iturediv__(self, other)
实现真实除法和赋值，注意，只有当你from __future__ import division时才会有效
__imod__(self, other)
实现求模和赋值，用%=操作符
__ipow__(self, other)
实现乘方和赋值，用**=操作符
__ilshift__(self, other)
实现左按位位移和赋值，使用<<=操作符
__irshift__(self, other)
实现右按位位移和赋值，使用>>=操作符
__iand__(self, other)
实现按位与和赋值，使用&=操作符
__ior__(self, other)
实现按位或和赋值，使用|=操作符
__ixor__(self, other)
实现按位异或和赋值，使用^=操作符
类型转换的神奇方法
Python也有一组神奇方法被设计用来实现内置类型转换函数的行为，如float()
__int__(self)
实现到int的类型转换
__long__(self)
实现到long的类型转换
__float__(self)
实现到float的类型转换
__complex__(self)
实现到复数的类型转换
__oct__(self)
实现到8进制的类型转换
__hex__(self)
实现到16进制的类型转换
__index__(self)
实现一个当对象被切片到int的类型转换。如果你自定义了一个数值类型，考虑到它可能被切片，所以你应该重载__index__
__trunc__(self)
当math.trunc(self)被调用时调用。__trunc__应当返回一个整型的截断，(通常是long)
__coerce__(self, other)
该方法用来实现混合模式的算术。如果类型转换不可能那__coerce__应当返回None。否则，它应当返回一对包含self和other（2元组），且调整到具有相同的类型

4.描述你的类

用一个字符串来说明一个类这通常是有用的。在Python中提供了一些方法让你可以在你自己的类中自定义内建函数返回你的类行为的描述。

__str__(self)
当你定义的类中一个实例调用了str()，用于给它定义行为
__repr__(self)
当你定义的类中一个实例调用了repr()，用于给它定义行为。str()和repr()主要的区别在于它的阅读对象。repr()产生的输出主要为计算机可读(在很多情况下，这甚至可能是一些有效的Python代码)，而str()则是为了让人类可读。
__unicode__(self)
当你定义的类中一个实例调用了unicode()，用于给它定义行为。unicode()像是str(),只不过它返回一个unicode字符串。警惕！如果用户用你的类中的一个实例调用了str(),而你仅定义了__unicode__(),那它是不会工作的。以防万一，你应当总是定义好__str__()，哪怕用户不会使用unicode
__hash__(self)
当你定义的类中一个实例调用了hash()，用于给它定义行为。它必须返回一个整型，而且它的结果是用于来在字典中作为快速键比对。
__nonzero__(self)
当你定义的类中一个实例调用了bool()，用于给它定义行为。返回True或False，取决于你是否考虑一个实例是True或False的。
我们已经相当漂亮地干完了神奇方法无聊的部分(无示例)，至此我们已经讨论了一些基础的神奇方法，是时候让我们向高级话题移动了。