1.多重继承
继承是面向对象编程的一个重要的方式&＃xff0c;因为通过继承&＃xff0c;子类就可以扩展父类的功能。
回忆一下Animal类层次的设计&＃xff0c;假设我们要实现以下4种动物&＃xff1a;
Dog - 狗狗&＃xff1b;
Bat - 蝙蝠&＃xff1b;
Parrot - 鹦鹉&＃xff1b;
Ostrich - 鸵鸟。
如果按照哺乳动物和鸟类归类&＃xff0c;我们可以设计出这样的类的层次&＃xff1a;
![]()
但是如果按照“能跑”和“能飞”来归类&＃xff0c;我们就应该设计出这样的类的层次&＃xff1a;
![]()
如果要把上面的两种分类都包含进来&＃xff0c;我们就得设计更多的层次&＃xff1a;
哺乳类&＃xff1a;能跑的哺乳类&＃xff0c;能飞的哺乳类&＃xff1b;
鸟类&＃xff1a;能跑的鸟类&＃xff0c;能飞的鸟类。
这么一来&＃xff0c;类的层次就复杂了&＃xff1a;
![]()
如果要再增加“宠物类”和“非宠物类”&＃xff0c;这么搞下去&＃xff0c;类的数量会呈指数增长&＃xff0c;很明显这样设计是不行的。
正确的做法是采用多重继承。首先&＃xff0c;主要的类层次仍按照哺乳类和鸟类设计&＃xff1a;
class Animal(object):
pass
# 大类:
class Mammal(Animal):
pass
class Bird(Animal):
pass
# 各种动物:
class Dog(Mammal):
pass
class Bat(Mammal):
pass
class Parrot(Bird):
pass
class Ostrich(Bird):
pass
现在&＃xff0c;我们要给动物再加上Runnable和Flyable的功能&＃xff0c;只需要先定义好Runnable和Flyable的类&＃xff1a;
class Runnable(object):
def run(self):
print(&＃39;Running...&＃39;)
class Flyable(object):
def fly(self):
print(&＃39;Flying...&＃39;)
对于需要Runnable功能的动物&＃xff0c;就多继承一个Runnable&＃xff0c;例如Dog&＃xff1a;
class Dog(Mammal, Runnable):
pass
对于需要Flyable功能的动物&＃xff0c;就多继承一个Flyable&＃xff0c;例如Bat&＃xff1a;
class Bat(Mammal, Flyable):
pass
通过多重继承&＃xff0c;一个子类就可以同时获得多个父类的所有功能。
MixIn
在设计类的继承关系时&＃xff0c;通常&＃xff0c;主线都是单一继承下来的&＃xff0c;例如&＃xff0c;Ostrich继承自Bird。但是&＃xff0c;如果需要“混入”额外的功能&＃xff0c;通过多重继承就可以实现&＃xff0c;比如&＃xff0c;让Ostrich除了继承自Bird外&＃xff0c;再同时继承Runnable。这种设计通常称之为MixIn。
为了更好地看出继承关系&＃xff0c;我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn。类似的&＃xff0c;你还可以定义出肉食动物CarnivorousMixIn和植食动物HerbivoresMixIn&＃xff0c;让某个动物同时拥有好几个MixIn&＃xff1a;
class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
pass
MixIn的目的就是给一个类增加多个功能&＃xff0c;这样&＃xff0c;在设计类的时候&＃xff0c;我们优先考虑通过多重继承来组合多个MixIn的功能&＃xff0c;而不是设计多层次的复杂的继承关系。
Python自带的很多库也使用了MixIn。举个例子&＃xff0c;Python自带了TCPServer和UDPServer这两类网络服务&＃xff0c;而要同时服务多个用户就必须使用多进程或多线程模型&＃xff0c;这两种模型由ForkingMixIn和ThreadingMixIn提供。通过组合&＃xff0c;我们就可以创造出合适的服务来。
比如&＃xff0c;编写一个多进程模式的TCP服务&＃xff0c;定义如下&＃xff1a;
class MyTCPServer(TCPServer, ForkingMixIn):
pass
编写一个多线程模式的UDP服务&＃xff0c;定义如下&＃xff1a;
class MyUDPServer(UDPServer, ThreadingMixIn):
pass
如果你打算搞一个更先进的协程模型&＃xff0c;可以编写一个CoroutineMixIn&＃xff1a;
class MyTCPServer(TCPServer, CoroutineMixIn):
pass
这样一来&＃xff0c;我们不需要复杂而庞大的继承链&＃xff0c;只要选择组合不同的类的功能&＃xff0c;就可以快速构造出所需的子类。
小结
由于Python允许使用多重继承&＃xff0c;因此&＃xff0c;MixIn就是一种常见的设计。
只允许单一继承的语言(如Java)不能使用MixIn的设计。
2.定制类
看到类似__slots__这种形如__xxx__的变量或者函数名就要注意&＃xff0c;这些在Python中是有特殊用途的。
__slots__我们已经知道怎么用了&＃xff0c;__len__()方法我们也知道是为了能让class作用于len()函数。
除此之外&＃xff0c;Python的class中还有许多这样有特殊用途的函数&＃xff0c;可以帮助我们定制类。
__str__
我们先定义一个Student类&＃xff0c;打印一个实例&＃xff1a;
>>> class Student(object):
... def __init__(self, name):
... self.name &＃61; name
...
>>> print(Student(&＃39;Michael&＃39;))
打印出一堆<__main__.student object at>&＃xff0c;不好看。
怎么才能打印得好看呢&＃xff1f;只需要定义好__str__()方法&＃xff0c;返回一个好看的字符串就可以了&＃xff1a;
>>> class Student(object):
... def __init__(self, name):
... self.name &＃61; name
... def __str__(self):
... return &＃39;Student object (name: %s)&＃39; % self.name
...
>>> print(Student(&＃39;Michael&＃39;))
Student object (name: Michael)
这样打印出来的实例&＃xff0c;不但好看&＃xff0c;而且容易看出实例内部重要的数据。
但是细心的朋友会发现直接敲变量不用print&＃xff0c;打印出来的实例还是不好看&＃xff1a;
>>> s &＃61; Student(&＃39;Michael&＃39;)
>>> s
这是因为直接显示变量调用的不是__str__()&＃xff0c;而是__repr__()&＃xff0c;两者的区别是__str__()返回用户看到的字符串&＃xff0c;而__repr__()返回程序开发者看到的字符串&＃xff0c;也就是说&＃xff0c;__repr__()是为调试服务的。
解决办法是再定义一个__repr__()。但是通常__str__()和__repr__()代码都是一样的&＃xff0c;所以&＃xff0c;有个偷懒的写法&＃xff1a;
class Student(object):
def __init__(self, name):
self.name &＃61; name
def __str__(self):
return &＃39;Student object (name&＃61;%s)&＃39; % self.name
__repr__ &＃61; __str__
__iter__
如果一个类想被用于for ... in循环&＃xff0c;类似list或tuple那样&＃xff0c;就必须实现一个__iter__()方法&＃xff0c;该方法返回一个迭代对象&＃xff0c;然后&＃xff0c;Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值&＃xff0c;直到遇到StopIteration错误时退出循环。
我们以斐波那契数列为例&＃xff0c;写一个Fib类&＃xff0c;可以作用于for循环&＃xff1a;
class Fib(object):
def __init__(self):
self.a, self.b &＃61; 0, 1 # 初始化两个计数器a&＃xff0c;b
def __iter__(self):
return self # 实例本身就是迭代对象&＃xff0c;故返回自己
def __next__(self):
self.a, self.b &＃61; self.b, self.a &＃43; self.b # 计算下一个值
if self.a > 100000: # 退出循环的条件
raise StopIteration()
return self.a # 返回下一个值
现在&＃xff0c;试试把Fib实例作用于for循环&＃xff1a;
>>> for n in Fib():
... print(n)
...
1
1
2
3
5
...
46368
75025
__getitem__
Fib实例虽然能作用于for循环&＃xff0c;看起来和list有点像&＃xff0c;但是&＃xff0c;把它当成list来使用还是不行&＃xff0c;比如&＃xff0c;取第5个元素&＃xff1a;
>>> Fib()[5]
Traceback (most recent call last):
File "", line 1, in
TypeError: &＃39;Fib&＃39; object does not support indexing
要表现得像list那样按照下标取出元素&＃xff0c;需要实现__getitem__()方法&＃xff1a;
class Fib(object):
def __getitem__(self, n):
a, b &＃61; 1, 1
for x in range(n):
a, b &＃61; b, a &＃43; b
return a
现在&＃xff0c;就可以按下标访问数列的任意一项了&＃xff1a;
>>> f &＃61; Fib()
>>> f[0]
1
>>> f[1]
1
>>> f[2]
2
>>> f[3]
3
>>> f[10]
89
>>> f[100]
573147844013817084101
但是list有个神奇的切片方法&＃xff1a;
>>> list(range(100))[5:10]
[5, 6, 7, 8, 9]
对于Fib却报错。原因是__getitem__()传入的参数可能是一个int&＃xff0c;也可能是一个切片对象slice&＃xff0c;所以要做判断&＃xff1a;
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int): # n是索引
a, b &＃61; 1, 1
for x in range(n):
a, b &＃61; b, a &＃43; b
return a
if isinstance(n, slice): # n是切片
start &＃61; n.start
stop &＃61; n.stop
if start is None:
start &＃61; 0
a, b &＃61; 1, 1
L &＃61; []
for x in range(stop):
if x >&＃61; start:
L.append(a)
a, b &＃61; b, a &＃43; b
return L
现在试试Fib的切片&＃xff1a;
>>> f &＃61; Fib()
>>> f[0:5]
[1, 1, 2, 3, 5]
>>> f[:10]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
但是没有对step参数作处理&＃xff1a;
>>> f[:10:2]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
也没有对负数作处理&＃xff0c;所以&＃xff0c;要正确实现一个__getitem__()还是有很多工作要做的。
此外&＃xff0c;如果把对象看成dict&＃xff0c;__getitem__()的参数也可能是一个可以作key的object&＃xff0c;例如str。
与之对应的是__setitem__()方法&＃xff0c;把对象视作list或dict来对集合赋值。最后&＃xff0c;还有一个__delitem__()方法&＃xff0c;用于删除某个元素。
总之&＃xff0c;通过上面的方法&＃xff0c;我们自己定义的类表现得和Python自带的list、tuple、dict没什么区别&＃xff0c;这完全归功于动态语言的“鸭子类型”&＃xff0c;不需要强制继承某个接口。
__getattr__
正常情况下&＃xff0c;当我们调用类的方法或属性时&＃xff0c;如果不存在&＃xff0c;就会报错。比如定义Student类&＃xff1a;
class Student(object):
def __init__(self):
self.name &＃61; &＃39;Michael&＃39;
调用name属性&＃xff0c;没问题&＃xff0c;但是&＃xff0c;调用不存在的score属性&＃xff0c;就有问题了&＃xff1a;
>>> s &＃61; Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
...
AttributeError: &＃39;Student&＃39; object has no attribute &＃39;score&＃39;
错误信息很清楚地告诉我们&＃xff0c;没有找到score这个attribute。
要避免这个错误&＃xff0c;除了可以加上一个score属性外&＃xff0c;Python还有另一个机制&＃xff0c;那就是写一个__getattr__()方法&＃xff0c;动态返回一个属性。修改如下&＃xff1a;
class Student(object):
def __init__(self):
self.name &＃61; &＃39;Michael&＃39;
def __getattr__(self, attr):
if attr&＃61;&＃61;&＃39;score&＃39;:
return 99
当调用不存在的属性时&＃xff0c;比如score&＃xff0c;Python解释器会试图调用__getattr__(self, &＃39;score&＃39;)来尝试获得属性&＃xff0c;这样&＃xff0c;我们就有机会返回score的值&＃xff1a;
>>> s &＃61; Student()
>>> s.name
&＃39;Michael&＃39;
>>> s.score
99
返回函数也是完全可以的&＃xff1a;
class Student(object):
def __getattr__(self, attr):
if attr&＃61;&＃61;&＃39;age&＃39;:
return lambda: 25
只是调用方式要变为&＃xff1a;
>>> s.age()
25
注意&＃xff0c;只有在没有找到属性的情况下&＃xff0c;才调用__getattr__&＃xff0c;已有的属性&＃xff0c;比如name&＃xff0c;不会在__getattr__中查找。
此外&＃xff0c;注意到任意调用如s.abc都会返回None&＃xff0c;这是因为我们定义的__getattr__默认返回就是None。要让class只响应特定的几个属性&＃xff0c;我们就要按照约定&＃xff0c;抛出AttributeError的错误&＃xff1a;
class Student(object):
def __getattr__(self, attr):
if attr&＃61;&＃61;&＃39;age&＃39;:
return lambda: 25
raise AttributeError(&＃39;\&＃39;Student\&＃39; object has no attribute \&＃39;%s\&＃39;&＃39; % attr)
这实际上可以把一个类的所有属性和方法调用全部动态化处理了&＃xff0c;不需要任何特殊手段。
这种完全动态调用的特性有什么实际作用呢&＃xff1f;作用就是&＃xff0c;可以针对完全动态的情况作调用。
举个例子&＃xff1a;
现在很多网站都搞REST API&＃xff0c;比如新浪微博、豆瓣啥的&＃xff0c;调用API的URL类似&＃xff1a;
http://api.server/user/friends
http://api.server/user/timeline/list
如果要写SDK&＃xff0c;给每个URL对应的API都写一个方法&＃xff0c;那得累死&＃xff0c;而且&＃xff0c;API一旦改动&＃xff0c;SDK也要改。
利用完全动态的__getattr__&＃xff0c;我们可以写出一个链式调用&＃xff1a;
class Chain(object):
def __init__(self, path&＃61;&＃39;&＃39;):
self._path &＃61; path
def __getattr__(self, path):
return Chain(&＃39;%s/%s&＃39; % (self._path, path))
def __str__(self):
return self._path
__repr__ &＃61; __str__
试试&＃xff1a;
>>> Chain().status.user.timeline.list
&＃39;/status/user/timeline/list&＃39;
这样&＃xff0c;无论API怎么变&＃xff0c;SDK都可以根据URL实现完全动态的调用&＃xff0c;而且&＃xff0c;不随API的增加而改变&＃xff01;
还有些REST API会把参数放到URL中&＃xff0c;比如GitHub的API&＃xff1a;
GET /users/:user/repos
调用时&＃xff0c;需要把:user替换为实际用户名。如果我们能写出这样的链式调用&＃xff1a;
Chain().users(&＃39;michael&＃39;).repos
就可以非常方便地调用API了。有兴趣的童鞋可以试试写出来。
__call__
一个对象实例可以有自己的属性和方法&＃xff0c;当我们调用实例方法时&＃xff0c;我们用instance.method()来调用。能不能直接在实例本身上调用呢&＃xff1f;在Python中&＃xff0c;答案是肯定的。
任何类&＃xff0c;只需要定义一个__call__()方法&＃xff0c;就可以直接对实例进行调用。请看示例&＃xff1a;
class Student(object):
def __init__(self, name):
self.name &＃61; name
def __call__(self):
print(&＃39;My name is %s.&＃39; % self.name)
调用方式如下&＃xff1a;
>>> s &＃61; Student(&＃39;Michael&＃39;)
>>> s() # self参数不要传入
My name is Michael.
__call__()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样&＃xff0c;所以你完全可以把对象看成函数&＃xff0c;把函数看成对象&＃xff0c;因为这两者之间本来就没啥根本的区别。
如果你把对象看成函数&＃xff0c;那么函数本身其实也可以在运行期动态创建出来&＃xff0c;因为类的实例都是运行期创建出来的&＃xff0c;这么一来&＃xff0c;我们就模糊了对象和函数的界限。
那么&＃xff0c;怎么判断一个变量是对象还是函数呢&＃xff1f;其实&＃xff0c;更多的时候&＃xff0c;我们需要判断一个对象是否能被调用&＃xff0c;能被调用的对象就是一个Callable对象&＃xff0c;比如函数和我们上面定义的带有__call__()的类实例&＃xff1a;
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable(&＃39;str&＃39;)
False
通过callable()函数&＃xff0c;我们就可以判断一个对象是否是“可调用”对象。
小结
Python的class允许定义许多定制方法&＃xff0c;可以让我们非常方便地生成特定的类。
京公网安备 11010802041100号