方法链(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 copy
class 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.py
Original: 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 fOx
After uppercase: THE QUICK BROWN FOX
After lowercase: the quick brown fox
After uppercase then capitalize: The quick brown fox
After delspace: TheQUIckbrOWnfOx
|
综上,我们可以发现,方法链有其用处,不过过度使用可能不太好。
如何在Python中使用方法链?相信大家都有了一个大概的思路,希望本文所述对大家学习有所帮助。