方法链（method chaining）是面向对象的编程语言中的一种常见语法，可以让开发者在只引用对象一次的情况下，对同一个对象进行多次方法调用。举个例子：
假设我们有一个Foo类，其中包含有两个方法——bar和baz。
我们创建一个Foo类的实例：
|
1
|
foo = Foo() |
如果不使用方法链，要想连续调用对象foo的bar和baz方法的话，我们得这样做：
|
1
2
|
foo.bar() # Call method bar() on object foo.foo.baz() # Call method baz() on object foo. |
如果使用方法链的话，我们就能这样实现： foo.bar().baz()
方法链的一个好处，是可以减少你使用对象名的次数。调用的方法越多，能够减少的次数就越多。因此，这个方法也能一定程度上减少需要阅读、测试、调试、维护的代码数量。这个好处不大，但也是有用的。
请注意，方法链的一个限制是，只能用在不需要返回其他值的方法上，因为你需要返回self对象。即使Python支持用一个return语句返回多个值，也可能无法解决这个问题。
下面是在Python中实现方法链的一个示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class Person: def name(self, value): self.name = value return self def age(self, value): self.age = value return self def introduce(self): print "Hello, my name is", self.name, "and I am", self.age, "years old."person = Person()person.name("EarlGrey").age(21).introduce()# => Hello, my name is EarlGrey and I am 21 years old. |
上面那种实现可能太简单了。下面我们来看一种更加现实的方法链使用方法：编写一个字符串处理程序string_processor.py，支持方法链。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
import copyclass StringProcessor(object): ''' A class to process strings in various ways. ''' def __init__(self, st): '''Pass a string for st''' self._st = st def lowercase(self): '''Make lowercase''' self._st = self._st.lower() return self def uppercase(self): '''Make uppercase''' self._st = self._st.upper() return self def capitalize(self): '''Make first char capital (if letter); make other letters lower''' self._st = self._st.capitalize() return self def delspace(self): '''Delete spaces''' self._st = self._st.replace(' ', '') return self def rep(self): '''Like Python's repr''' return self._st def dup(self): '''Duplicate the object''' return copy.deepcopy(self)def process_string(s): print sp = StringProcessor(s) print 'Original:', sp.rep() print 'After uppercase:', sp.dup().uppercase().rep() print 'After lowercase:', sp.dup().lowercase().rep() print 'After uppercase then capitalize:', sp.dup().uppercase().\ capitalize().rep() print 'After delspace:', sp.dup().delspace().rep()def main(): print "Demo of method chaining in Python:" # Use extra spaces between words to show effect of delspace. process_string('hOWz It GoInG?') process_string('The QUIck brOWn fOx')main() |
下面是这个程序的运行结果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
$ python string_processor.pyOriginal: hOWz It GoInG?After uppercase: HOWZ IT GOING?After lowercase: howz it going?After uppercase then capitalize: Howz it going?After delspace: hOWzItGoInG?Original: The QUIck brOWn fOxAfter uppercase: THE QUICK BROWN FOXAfter lowercase: the quick brown foxAfter uppercase then capitalize: The quick brown foxAfter delspace: TheQUIckbrOWnfOx |
综上，我们可以发现，方法链有其用处，不过过度使用可能不太好。
如何在Python中使用方法链？相信大家都有了一个大概的思路，希望本文所述对大家学习有所帮助。
