Python基础：20类的定制

类中有一些可自定义的特殊方法，它们中的一些有预定义的默认行为，而其它一些则没有，留到需要的时候去实现。这些特殊方法是Python中用来扩充类的强有力的方式。它们可以实现模拟标准类型和重载操作符等。比如__init__()和__del__()就分别充当了构造器和析够器的功能。

这些特殊这些方法都是以双下划线(__)开始及结尾的。下表进行了总结：

基本定制型

C.__init__(self[, arg1, ...])	构造器（带一些可选的参数）
C.__new__(self[, arg1, ...])	构造器（带一些可选的参数）；通常用在设置不变数据类型的子类。
C.__del__(self)	解构器
C.__str__(self)	可打印的字符输出；内建str()及print 语句
C.__repr__(self)	运行时的字符串输出；内建repr() 和``操作符
C.__unicode__(self)	Unicode 字符串输出；内建unicode()
C.__call__(self, *args)	表示可调用的实例
C.__nonzero__(self)	为object 定义False 值；内建bool() （从2.2 版开始）
C.__len__(self)	“长度”（可用于类）；内建len()

对象（值）比较

C.__cmp__(self, obj)	对象比较；内建cmp()
C.__lt__(self, obj) C.__le__(self, obj)	小于/小于或等于；对应<及<=操作符
C.__gt__(self, obj) C.__ge__(self, obj)	大于/大于或等于；对应>及>=操作符
C.__eq__(self, obj) C.__ne__(self, obj)	等于/不等于；对应==,!=及<>操作符

属性

C.__getattr__(self, attr)	获取属性；内建getattr()；仅当属性没有找到时调用
C.__setattr__(self, attr, val)	设置属性
C.__delattr__(self, attr)	删除属性
C.__getattribute__(self, attr)	获取属性；内建getattr()；总是被调用
C.__get__(self, attr)	（描述符）获取属性
C.__set__(self, attr, val)	（描述符）设置属性
C.__delete__(self, attr)	（描述符）删除属性

数值类型：二进制操作符

C.__*add__(self, obj)	加；+操作符
C.__*sub__(self, obj)	减；-操作符
C.__*mul__(self, obj)	乘；*操作符
C.__*div__(self, obj)	除；/操作符
C.__*truediv__(self, obj)	True 除；/操作符
C.__*floordiv__(self, obj)	Floor 除；//操作符
C.__*mod__(self, obj)	取模/取余；%操作符
C.__*divmod__(self, obj)	除和取模；内建divmod()
C.__*pow__(self, obj[, mod])	乘幂；内建pow();**操作符
C.__*lshift__(self, obj)	左移位；<<操作符

数值类型：二进制操作符

C.__*rshift__(self, obj)	右移；>>操作符
C.__*and__(self, obj)	按位与；&操作符
C.__*or__(self, obj)	按位或；|操作符
C.__*xor__(self, obj)	按位与或；^操作符

数值类型：一元操作符

C.__neg__(self)	一元负
C.__pos__(self)	一元正
C.__abs__(self)	绝对值；内建abs()
C.__invert__(self)	按位求反；~操作符

数值类型：数值转换

C.__complex__(self, com)	转为complex(复数);内建complex()
C.__int__(self)	转为int;内建int()
C.__long__(self)	转 .long；内建long()
C.__float__(self)	转为float；内建float()

数值类型：基本表示法（String）

C.__oct__(self)	八进制表示；内建oct()
C.__hex__(self)	十六进制表示；内建hex()
数值类型：数值压缩
C.__coerce__(self, num)	压缩成同样的数值类型；内建coerce()
C.__index__(self)	在有必要时,压缩可选的数值类型为整型（比如：用于切片索引等等）

序列类型

C.__len__(self)	序列中项的数目
C.__getitem__(self, ind)	得到单个序列元素
C.__setitem__(self, ind,val)	设置单个序列元素
C.__delitem__(self, ind)	删除单个序列元素
C.__getslice__(self, ind1,ind2)	得到序列片断
C.__setslice__(self, i1, i2,val)	设置序列片断
C.__delslice__(self, ind1,ind2)	删除序列片断
C.__contains__(self, val)	测试序列成员；内建in 关键字
C.__*add__(self,obj)	串连；+操作符
C.__*mul__(self,obj)	重复；*操作符
C.__iter__(self)	创建迭代类；内建iter()

映射类型

C.__len__(self)	mapping 中的项的数目
C.__hash__(self)	散列(hash)函数值
C.__getitem__(self,key)	得到给定键(key)的值
C.__setitem__(self,key,val)	设置给定键(key)的值
C.__delitem__(self,key)	删除给定键(key)的值
C.__missing__(self,key)	给定键如果不存在字典中，则提供一个默认值

一：简单定制

class  RoundFloatManual(object):
        def  __init__(self,  val):
                assert  isinstance(val,  float),  "Value must be a float!"
                self.value = round(val, 2)

>>> rfm =RoundFloatManual(42)
Traceback (mostrecent call last):
File"<stdin>", line 1, in ?
File"roundFloat2.py", line 5, in __init__
assertisinstance(val, float), \ AssertionError: Value must be a float!

>>> rfm =RoundFloatManual(4.2)
>>> rfm
<roundFloat2.RoundFloatManualobject at 0x63030>

>>> print  rfm
<roundFloat2.RoundFloatManualobject at 0x63030>

它因输入非法而异常，但如果输入正确时，就没有任何输出了。在解释器中，我们得到一些信息，却不是我们想要的。print（使用str()）和真正的字符串对象表示（使用repr()）都没能显示更多有关我们对象的信息。这就需要实现__str__()和__repr__()二者之一，或者两者都实现。加入下面的方法：

def  __str__(self):
        return  str(self.value)

现在我们得到下面的：

>>> rfm  =  RoundFloatManual(5.590464)
>>> rfm
<roundFloat2.RoundFloatManual  object  at  0x5eff0>

>>> print  rfm
5.59

>>> rfm  =  RoundFloatManual(5.5964)
>>> print rfm
5.6

但是在解释器中转储(dump)对象时，仍然显示的是默认对象符号，要修复它，只需要覆盖__repr__()。可以让__repr__()和__str__()具有相同的代码，但最好的方案是：__repr__ = __str__

在带参数5.5964的第二个例子中，我们看到它舍入值刚好为5.6，但我们还是想显示带两位小数的数。可以这样修改：

def  __str__(self):
        return  '%.2f' % self.value

这里就同时具备str()和repr()的输出了：

>>> rfm =RoundFloatManual(5.5964)
>>> rfm
5.60

>>> printrfm
5.60

所有代码如下：

class  RoundFloatManual(object):
        def  __init__(self,val):
                assert isinstance(val, float), "Valuemust be a float!"
                self.value = round(val,  2)

         def  __str__(self):

                return  '%.2f' % self.value

         __repr__ = __str__

二：数值定制

定义一个Time60，其中，将整数的小时和分钟作为输入传给构造器：

class  Time60(object):
        def  __init__(self, hr,  min):
                self.hr = hr
                self.min = min

1：显示

需要在显示实例的时候，得到一个有意义的输出，那么就要覆盖__str__()(如果有必要的话,__repr__()也要覆盖)：

def  __str__(self):
        return  '%d:%d'  %  (self.hr,  self.min)

比如：

>>> mon =Time60(10, 30)
>>> tue =Time60(11, 15)
>>>
>>> print mon, tue
10:30  11:15

2：加法

Python中的重载操作符很简单。像加号(+)，只需要重载__add__()方法，如果合适，还可以用__radd__()及__iadd__()。注意，实现__add__()的时候，必须认识到它返回另一个Time60对象，而不修改原mon或tue：

def  __add__(self,  other):
        return  self.__class__(self.hr + other.hr,  self.min + other.min) 

在类中，一般不直接调用类名， 而是使用self 的__class__属性，即实例化self 的那个类，并调用它。 调用self.__class__()与调用Time60()是一回事。但self.__class__()的方式更好。

>>> mon  =  Time60(10, 30)
>>> tue  =  Time60(11, 15)
>>> mon +tue
<time60.Time60object at 0x62190>

>>> print  mon + tue
21:45

如果没有定义相对应的特殊方法，但是却使用了该方法对应的运算，则会引起一个TypeError异常：

>>> mon -tue
Traceback (mostrecent call last): File "<stdin>", line 1, in ?
TypeError:unsupported operand type(s) for -: 'Time60' and 'Time60'

3：原位加法

__iadd__()，是用来支持像mon += tue 这样的操作符，并把正确的结果赋给mon。重载一个__i*__()方法的唯一秘密是它必须返回self：

def  __iadd__(self,  other):
        self.hr += other.hr
        self.min += other.min
        return  self

下面是结果输出：

>>> mon  = Time60(10,30)
>>> tue  =  Time60(11,15)
>>> mon
10:30
>>> id(mon)
401872
>>> mon +=tue
>>> id(mon)
401872
>>> mon
21:45

下面是Time60的类的完全定义：

class  Time60(object):
        'Time60 - track hours and minutes'

        def  __init__(self,hr, min):
                'Time60 constructor - takes hours andminutes'
                self.hr = hr
                self.min = min

         def  __str__(self):
                'Time60 - string representation'
                return  '%d:%d' % (self.hr, self.min)

         __repr__ = __str__

         def  __add__(self, other):
                'Time60 - overloading the additionoperator'
                return  self.__class__(self.hr + other.hr,self.min +other.min)

         def  __iadd__(self,other):
                'Time60 - overloading in-place addition'
                self.hr += other.hr
                self.min += other.min
                return  self

4：升华

在这个类中，还有很多需要优化和改良的地方。首先看下面的例子：

>>> wed =Time60(12, 5)
>>> wed
12:5                                                 #正确的显示应该是：“12:05”

>>> thu =Time60(10, 30)
>>> fri =Time60(8, 45)
>>> thu +fri
18:75                                               #正确的显示应该是：19:15

可以做出如下修改：

def  __str__(self):
       return  '%02d:%02d'%(self.hr, self.min)

 __repr__ = __str__   

def  __add__(self,  othertime):
       tmin = self.min + othertime.min
       thr = self.hr + othertime.hr

       return  self.__class__(thr + tmin/60, tmin%60)

 def  __iadd__(self,  othertime):
        self.min += othertime.min
        self.hr += othertime.hr
        self.hr += self.min/60
        self.min %= 60
        return  self

三：迭代器

迭代器对象本身需要支持以下两种方法，它们组合在一起形成迭代器协议：

iterator.__iter__()      返回迭代器对象本身。

iterator.next()          从容器中返回下一个元素。

实现了__iter__()和next()方法的类就是一个迭代器。自定义迭代器的例子如下：

RandSeq（Random Sequence），传入一个初始序列，__init__()方法执行前述的赋值操作。__iter__()仅返回self，这就是如何将一个对象声明为迭代器的方式，最后，调用next()来得到迭代器中连续的值。这个迭代器唯一的亮点是它没有终点。代码如下：

class  RandSeq(object):
       def  __init__(self,  seq):
              self.data= seq

       def  __iter__(self):
              return  self

       def  next(self):
              return  choice(self.data)

运行它，将会看到下面的输出：

>>> from  randseq  import  RandSeq
>>> for  eachItem  in  RandSeq(('rock', 'paper', 'scissors')):
...          print  eachItem
...
scissors
scissors
rock
paper
paper
scissors
......

四：多类型定制

现在创建另一个新类，NumStr，由一个数字-字符对组成，记为n和s，数值类型使用整型（integer）。用[n::s]来表示它，这两个数据元素构成一个整体。NumStr有下面的特征：

初始化： 类应当对数字和字符串进行初始化；如果其中一个（或两）没有初始化，则使用0和空字符串，也就是, n=0 且s=''作为默认。

加法：   定义加法操作符，功能是把数字加起来，把字符连在一起；比如，NumStr1=[n1::s1]且NumStr2＝[n2::s2]。则NumStr1+NumStr2 表示［n1+n2::s1+s2］，其中，＋代表数字相加及字符相连接。

乘法：  类似的， 定义乘法操作符的功能为， 数字相乘，字符累积相连， 也就是，NumStr1*NumStr2=[n1*n::s1*n]。

False 值：当数字的数值为 0 且字符串为空时，也就是当NumStr=[0::'']时，这个实体即有一个false值。

比较：  比较一对NumStr对象，比如，[n1::s1] vs. [n2::s2]，有九种不同的组合。对数字和字符串，按照标准的数值和字典顺序的进行比较。

如果obj1< obj2，则cmp(obj1, obj2)的返回值是一个小于0 的整数， 当obj1 > obj2 时，比较的返回值大于0， 当两个对象有相同的值时， 比较的返回值等于0。

我们的类的解决方案是把这些值相加，然后返回结果。为了能够正确的比较对象，我们需要让__cmp__()在 (n1>n2) 且 (s1>s2)时，返回 1，在(n1<n2)且(s1<s2)时，返回-1，而当数值和字符串都一样时，或是两个比较的结果正相反时(即(n1<n2)且(s1>s2),或相反)，返回0. 反之亦然。代码如下：

class  NumStr(object):
       def  __init__(self,  num=0, string=''):
              self.__num  =  num
              self.__string  =  string

       def  __str__(self):
              return  '[%d :: %r]' % (self.__num,  self.__string)

       __repr__ = __str__

       def  __add__(self, other):
              if  isinstance(other,  NumStr):
                       return  self.__class__(self.__num + other.__num, self.__string + other.__string)

              else:
                       raise  TypeError,  'Illegal argument type for built-in operation'

       def  __mul__(self,  num):
              if  isinstance(num, int):
                     return self.__class__(self.__num * num,  self.__string * num)
              else:
                     raise  TypeError, 'Illegal argument type for built-inoperation'

       def  __nonzero__(self):
              return self.__num  or  len(self.__string)

        def  __norm_cval(self, cmpres):
              return  cmp(cmpres, 0)

        def  __cmp__(self, other):
              return  self.__norm_cval(cmp(self.__num, other.__num))+ \
                     self.__norm_cval(cmp(self.__string,other.__string))

执行一些例子：

>>> a =NumStr(3, 'foo')
>>> b =NumStr(3, 'goo')
>>> c =NumStr(2, 'foo')
>>> d =NumStr()
>>> e =NumStr(string='boo')
>>> f =NumStr(1)
>>> a
[3 :: 'foo']
>>> b
[3 :: 'goo']
>>> c
[2 :: 'foo']
>>> d
[0 :: '']
>>> e
[0 :: 'boo']
>>> f
[1 :: '']
>>> a <b
True
>>> b <c
False
>>> a ==a
True
>>> b * 2
[6 :: 'googoo']
>>> a * 3
[9 :: 'foofoofoo']
>>> b + e
[3 :: 'gooboo']
>>> e + b
[3 :: 'boogoo']
>>> if  d:  'not false'
...
>>> if  e:  'not false'
...
'not false'
>>>cmp(a, b)
-1
>>>cmp(a, c)
1
>>>cmp(a, a)
0

如果在__str__中使用“%s”，将导致字符串没有引号：

return  '[%d :: %s]' % (self.__num, self.__string)
>>> print a
[3 :: foo]

第二个元素是一个字符串，如果用户看到由引号标记的字符串时，会更加直观。要做到这点，使用“repr()”表示法对代码进行转换，把“%s”替换成“%r”。这相当于调用repr()或者使用单反引号来给出字符串的可求值版本--可求值版本的确要有引号：

>>> print a
[3 :: 'foo']

__norm_cval()不是一个特殊方法。它是一个帮助我们重载__cmp__()的助手函数：唯一的目的就是把cmp()返回的正值转为1，负值转为-1。cmp()基于比较的结果，通常返回任意的正数或负数(或0)，但为了我们的目的，需要严格规定返回值为-1,0 和1。

对整数调用cmp()及与 0 比较，结果即是我们所需要的，相当于如下代码片断：

def  __norm_cval(self, cmpres):
        if  cmpres< 0:
                return  -1

        elif  cmpres> 0:
                return  1
        else:
                return  0

两个相似对象的实际比较是比较数字，比较字符串，然后返回这两个比较结果的和。