方法链（method chaining）是面向对象的编程语言中的一种常见语法，可以让开发者在只引用对象一次的情况下，对同一个对象进行多次方法调用。举个例子：
假设我们有一个foo类，其中包含有两个方法——bar和baz。
我们创建一个foo类的实例：
foo = foo()
如果不使用方法链，要想连续调用对象foo的bar和baz方法的话，我们得这样做：
foo.bar() # call method bar() on object foo.
foo.baz() # call method baz() on object foo.
如果使用方法链的话，我们就能这样实现： foo.bar().baz()
方法链的一个好处，是可以减少你使用对象名的次数。调用的方法越多，能够减少的次数就越多。因此，这个方法也能一定程度上减少需要阅读、测试、调试、维护的代码数量。这个好处不大，但也是有用的。
请注意，方法链的一个限制是，只能用在不需要返回其他值的方法上，因为你需要返回self对象。即使python支持用一个return语句返回多个值，也可能无法解决这个问题。
下面是在python中实现方法链的一个示例：
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，支持方法链。
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()
下面是这个程序的运行结果：
$ 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中使用方法链？相信大家都有了一个大概的思路，希望本文所述对大家学习有所帮助。