Python随学随记（5）

面向对象高级编程

用MethodType动态的给实例绑定一个方法：

>>> class Student(object):...     pass...>>> s = Student()>>> s.name = 'Michael' # 动态给实例绑定一个属性>>> print s.nameMichael>>> def set_age(self, age): # 定义一个函数作为实例方法...     self.age = age...>>> from types import MethodType>>> s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法>>> s.set_age(25) # 调用实例方法>>> s.age # 测试结果25

语法：MethodType（function， instance， class）

但是，给一个实例绑定的方法，对另一个实例是不起作用的， 为了给所有实例都绑定方法，可以给class绑定方法：

>>> s2 = Student() # 创建新的实例>>> s2.set_age(25) # 尝试调用方法Traceback (most recent call last):  File "<stdin>", line 1, in <module>AttributeError: 'Student' object has no attribute 'set_age'>>> def set_score(self, score):...     self.score = score...>>> Student.set_score = MethodType(set_score, None, Student)

给class绑定方法后，所有实例均可调用：

>>> s.set_score(100)>>> s.score100>>> s2.set_score(99)>>> s2.score99

通常情况下，上面的set_score方法可以直接定义在class中，但动态绑定允许我们在程序运行的过程中动态给class加上功能

__slots__：

为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class能添加的属性：

>>> class Student(object):...     __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称...>>> s = Student() # 创建新的实例>>> s.name = 'Michael' # 绑定属性'name'>>> s.age = 25 # 绑定属性'age'>>> s.score = 99 # 绑定属性'score'Traceback (most recent call last):  File "<stdin>", line 1, in <module>AttributeError: 'Student' object has no attribute 'score'

由于'score'没有被放到__slots__中，所以不能绑定score属性，试图绑定score将得到AttributeError的错误。
使用__slots__要注意，__slots__定义的属性仅对当前类起作用，对继承的子类是不起作用的：

>>> class GraduateStudent(Student):...     pass...>>> g = GraduateStudent()>>> g.score = 9999

如果在子类中也定义__slots__，子类允许定义的属性就是自身的__slots__加上父类的__slots__

@property：
在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改， 这显然不合逻辑
为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

s = Student()s.score = 9999class Student(object):    def get_score(self):        return self._score    def set_score(self, value):        if not isinstance(value, int):            raise ValueError('score must be an integer!')        if value < 0 or value > 100:            raise ValueError('score must between 0 ~ 100!')        self._score = value

现在，对任意的Student实例进行操作，就不能随心所欲地设置score了：

>>> s = Student()>>> s.set_score(60) # ok!>>> s.get_score()60>>> s.set_score(9999)Traceback (most recent call last):  ...ValueError: score must between 0 ~ 100!

但是略显复杂， 有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢：
python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object):    @property    def score(self):        return self._score    @score.setter    def score(self, value):        if not isinstance(value, int):            raise ValueError('score must be an integer!)        if value < 0 or value > 100:            raise ValueError(‘score must between 0 ~ 100')        self._score = value

把一个getter方法变成属性，只需要加上@property就可以，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是我们就拥有一个可控的属性操作：

>>> s = Student()>>> s.score = 60 # OK，实际转化为s.set_score(60)>>> s.score # OK，实际转化为s.get_score()60>>> s.score = 9999Traceback (most recent call last):  ...ValueError: score must between 0 ~ 100!

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的

还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object):    @property    def birth(self):        return self._birth    @birth.setter    def birth(self, value):        self._birth = value    @property    def age(self):        return 2014 - self._birth

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来

多重继承

假设我们要实现以下4种动物

• Dog - 狗狗
• Bat - 蝙蝠
• Parrot - 鹦鹉
• Ostrich - 鸵鸟

主要的类层次按照哺乳类和鸟类设计：

class Animal(object):    pass# 大类:class Mammal(Animal):    passclass Bird(Animal):    pass# 各种动物:class Dog(Mammal):    passclass Bat(Mammal):    passclass Parrot(Bird):    passclass Ostrich(Bird):    pass

现在，我们要给动物再加上Runnable和Flyable的功能，只需要先定义好Runnable和Flyable的类：

class Runnable(object):    def run(self):        print('Running...')class Flyable(object):    def fly(self):        print('Flying...')

对于需要Runnable功能的动物，就多继承一个Runnable，例如Dog：

class Dog(Mammal, Runnable):    pass

通过多重继承，一个子类就可以同时获得多个父类的所有功能

Mixin

在设计类的继承关系时，通常，主线都是单一继承下来的
例如，Ostrich继承自Bird，但是，如果需要“混入”额外的功能，通过多重继承就可以实现，比如，让Ostrich除了继承自Bird外，再同时继承Runnable，这种设计通常称之为Mixin

为了更好地看出继承关系，我们把Runnable和Flyable改为RunnableMixin和FlyableMixin
类似的，你还可以定义出肉食动物CarnivorousMixin和植食动物HerbivoresMixin，让某个动物同时拥有好几个Mixin：

class Dog(Mammal, RunnableMixin, CarnivorousMixin):    pass

Mixin的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个Mixin的功能，而不是设计多层次的复杂的继承关系

Python自带的很多库也使用了Mixin
举个例子，Python自带了TCPServer和UDPServer这两类网络服务，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由ForkingMixin和ThreadingMixin提供，通过组合我们就可以创造出合适的服务来

比如，编写一个多进程模式的TCP服务，定义如下：

class MyTCPServer(TCPServer, ForkingMixin):    pass

编写一个多线程模式的UDP服务，定义如下：

class MyUDPServer(UDPServer, ThreadingMixin):    pass

如果你打算搞一个更先进的协程模型，可以编写一个CoroutineMixin：

class MyTCPServer(TCPServer, CoroutineMixin):    pass

这样一来，我们不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类

由于Python允许使用多重继承，因此，Mixin就是一种常见的设计
只允许单一继承的语言（如Java）不能使用Mixin的设计

定制类

__str__：
我们先定义一个Student类，打印一个实例：

>>> class Student(object):...     def __init__(self, name):...         self.name = name...>>> print Student('Michael')<__main__.Student object at 0x109afb190>

打印出一堆<__main__.Student object at 0x109afb190>，不好看
怎么才能打印得好看呢？只需要定义好__str__()方法，返回一个好看的字符串就可以了：

>>> class Student(object):...     def __init__(self, name):...         self.name = name...     def __str__(self):...         return 'Student object (name: %s)' % self.name...>>> print Student('Michael')Student object (name: Michael)

直接敲变量不用print，打印出来的实例还是不好看：

>>> s = Student('Michael')>>> s<__main__.Student object at 0x109afb310>

这是因为直接显示变量调用的不是__str__()，而是__repr__()，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的

解决办法是再定义一个__repr__()
但是通常__str__()和__repr__()代码都是一样的，所以，有个偷懒的写法：

class Student(object):    def __init__(self, name):        self.name = name    def __str__(self):        return 'Student object (name=%s)' % self.name    __repr__ = __str__

__iter__:

如果一个类想被用于for ... in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的next()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环

我们以斐波那契数列为例，写一个Fib类，可以作用于for循环：

class Fib(object):    def __init__(self):        self.a, self.b = 0, 1 # 初始化两个计数器a，b    def __iter__(self):        return self # 实例本身就是迭代对象，故返回自己    def next(self):        self.a, self.b = self.b, self.a + self.b # 计算下一个值        if self.a > 100000: # 退出循环的条件            raise StopIteration();        return self.a # 返回下一个值>>> for n in Fib():...     print n...11235

__getitem__：

Fib实例虽然能作用于for循环，看起来和list有点像，但是把它当成list来使用还是不行
比如，取第5个元素：

>>> Fib()[5]Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: 'Fib' object does not support indexing

表现得像list那样按照下标取出元素，需要实现__getitem__()方法：

class Fib(object):    def __getitem__(self, n):        a, b = 1, 1        for x in range(n):            a, b = b, a + b        return a

就可以按下标访问数列的任意一项了：

>>> f = Fib()>>> f[0]1>>> f[1]1>>> f[100]573147844013817084101

但是list的切片方法对于fib却报错，因为__getitem__()传入的参数可能是一个int，也可能是一个切片对象slice，所以要做判断：

class Fib(object):    def __getitem__(self, n):        if isinstance(n, int):            a, b = 1, 1            for x in range(n):                a, b = b, a + b            return a        if isinstance(n, slice):            start = n.start            stop = n.stop            a, b = 1, 1            L = []            for x in range(stop):                if x >= start:                    L.append(a)                a, b = b, a + b            return L

现在试试Fib的切片：

>>> f = Fib()>>> f[0:5][1, 1, 2, 3, 5]>>> f[:10][1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

但是没有对step参数作处理， 也没有对负数作处理:

>>> f[:10:2][1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

所以，要正确实现一个__getitem__()还是有很多工作要做的
此外，如果把对象看成dict，__getitem__()的参数也可能是一个可以作key的object，例如str

与之对应的是__setitem__()方法，把对象视作list或dict来对集合赋值
最后，还有一个__delitem__()方法，用于删除某个元素。

总之，通过上面的方法，我们自己定义的类表现得和Python自带的list、tuple、dict没什么区别，这完全归功于动态语言的“鸭子类型”，不需要强制继承某个接口

__getattr__：
正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错，比如定义Student类：

class Student(object):    def __init__(self):        self.name = 'Michael'# 调用name属性，没问题，但是，调用不存在的score属性，就有问题了：>>> s = Student()>>> print s.nameMichael>>> print s.scoreTraceback (most recent call last):  ...AttributeError: 'Student' object has no attribute 'score'

避免这个错误，除了可以加上一个score属性外，Python还有另一个机制，那就是写一个__getattr__()方法，动态返回一个属性，修改如下：

class Student(object):    def __init__(self):        self.name = 'Michael'    def __getattr__(self, attr):        if attr=='score':            return 99

当调用不存在的属性时，比如score，Python解释器会试图调用__getattr__(self, 'score')来尝试获得属性，这样，我们就有机会返回score的值：

>>> s = Student()>>> s.name'Michael'>>> s.score99# 返回函数也是完全可以的：class Student(object):    def __getattr__(self, attr):        if attr=='age':            return lambda: 25>>> s.age()25

注意，只有在没有找到属性的情况下，才调用__getattr__，已有的属性，比如name，不会在__getattr__中查找

注意到任意调用如s.abc都会返回None，这是因为我们定义的__getattr__默认返回就是None
要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误：

class Student(object):    def __getattr__(self, attr):        if attr=='age':            return lambda: 25        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

这实际上可以把一个类的所有属性和方法调用全部动态化处理了，不需要任何特殊手段
这种完全动态调用的特性的作用就是，可以针对完全动态的情况作调用

举个例子：
现在很多网站都搞REST API，比如新浪微博、豆瓣啥的，调用API的URL类似：

http://api.server/user/friendshttp://api.server/user/timeline/list

如果要写SDK，给每个URL对应的API都写一个方法，那得累死，而且，API一旦改动，SDK也要改
利用完全动态的__getattr__，我们可以写出一个链式调用：

class Chain(object):    def __init__(self, path=''):        self._path = path    def __getattr__(self, path):        return Chain('%s/%s' % (self._path, path))    def __str__(self):        return self._path>>> Chain().status.user.timeline.list'/status/user/timeline/list'

这样，无论API怎么变，SDK都可以根据URL实现完全动态的调用，而且，不随API的增加而改变
还有些REST API会把参数放到URL中，比如GitHub的API：

GET /users/:user/repos

调用时，需要把:user替换为实际用户名，如果我们能写出这样的链式调用：

Chain().users('michael').repos

就可以非常方便地调用API了

__call__：

一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用, 也可以直接在实例本身上调用，类似instance()

任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用

举个栗子：

class Student(object):    def __init__(self, name):        self.name = name    def __call__(self):        print('My name is %s.' % self.name)# 调用方式如下：>>> s = Student('Michael')>>> s()My name is Michael.

__call__()还可以定义参数，对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别

如果你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的，这么一来，我们就模糊了对象和函数的界限

那么，怎么判断一个变量是对象还是函数呢？其实，更多的时候，我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有__call()__的类实例：

>>> callable(Student())True>>> callable(max)True>>> callable([1, 2, 3])False>>> callable(None)False>>> callable('string')False

通过callable()函数，我们就可以判断一个对象是否是“可调用”对象

Python的class允许定义许多定制方法，可以让我们非常方便地生成特定的类