使用Python的PEAK来适配协议的教程
如果您正尝试去处理元类，或者正受困于Twisted中的异步编程，或者正在研究由于使用了多分派而使您精疲力尽的面向对象编程，那么您完全错了！PEAK将所有这些中的一些要素组合到了一个组件编程框架中。PEAK还存在一些小问题。类似于Twisted，PEAK的文档--尽量数量巨大--难以看懂。但是尽管如此，关于Python领袖PhillipJ.Eby领导的这一项目还是有一些东西非常值得关注；而且，我觉得，有机会进行极具生产价值的并且层次特别高的应用程序开发。
PEAK包由许多不同用途的子包组成。一些重要的子包是peak.api、peak.binding、peak.config、peak.naming和peak.storage。那些名字大部分是自我解释性的。子包peak.binding用于组件间的灵活连接；peak.config让您可以存储“很少改变的（lazilyimmutable）”数据，这些数据与声明性应用程序（declarativeapplication）编程有关；peak.naming让您可以为（网络的）资源创建全局惟一的标识符；peak.storage顾名思义让您可以管理数据库和持久内容。
不过，对本文来说，我们将关注的是peak.api。特别是PyProtocols包，它可以单独获得并为其他PEAK子包提供一个基础设施。在peak.api.protocols中包括了PyProtocols包的一个版本。不过现在我所感兴趣的是研究一个独立的protocols包。在以后的部分，我将返回来讨论PEAK其他部分的话题。
什么是协议？
抽象地说，协议只是对象同意遵循的一组行为。强类型（Strongly-typed）编程语言--包括Python--都有一个基本类型的集合，每个基本类型都有一组得到保证的行为：Integer知道如何去求它们自己的乘积；list知道如何去遍历它们的内容；dictionary知道如何根据一个关键字找到相应的值；file知道如何去读和写字节；诸如此类。您可以预期的内置类型的行为集合构成了它们实现的一个协议。对协议进行系统化的对象被称为接口（interface）。
对标准的类型而言，将实现的所有行为全部列出并不太困难（尽管不同的Python版本之间会稍有不同；或者，不同的编程语言之间当然会有差别）。但是，在边界--对于属于自定义类的对象来说--难以声明最终是什么构成了“类-dictionary”或“类-file”的行为。大部分情况下，只实现了比如内置的dict类型的方法的一个子集--甚至是相当小的子集--的自定义对象，就足够“类-dictionary”而可以满足当前的要求。不过，能显式地整理出一个对象要用到的函数、模块、类或者框架中需要能够做哪些事情，将是很吸引人的。那就是PyProtocols包所做到的（一部分）。
在具有静态类型声明的编程语言中，为了在新的上下文中使用数据，您通常需要将其自一个类型强制类型转换（cast）或者转换（convert）到另一个类型。在其他语言中，转换根据上下文的需要隐式地进行，这些被称为强迫同型（coercions）。Python中既有强制类型转换也有强迫同型，通常使用更多的是前者（“显式优于隐式”）。您可以将向一个浮点数加到一个整型数，结果得到一个更为通用的浮点数；但是如果您希望将字符串"3.14"转换为一个数字，那么您需要使用显式的构造函数float("3.14")。
PyProtocols具有一个称为“适配（adaptation）”的功能，类似于“部分类型（partialtyping）”这一非正统计算机科学概念。适配还可能被认为是“加速的强制同型”。如果一个接口定义了所需要的一组能力（也就是对象方法），那么要去做“所需要的一切”的对象就要求适配--通过protocols.adapt()函数实现--以提供所需要的能力。显然，如果您有一个显式的转换函数可以将类型X的对象转换为类型Y的对象（在这里Y实现了某个IY接口），那么那个函数要能够让X适配协议IY。不过，PyProtocols中的适配可以做比这多得多的事情。例如，甚至如果您从来没有显式地编写过从类型X到类型Y的转换程序，adapt()通常可以推演出一条让X提供IY所要求的能力的途径（也就是说，找到从X到接口IZ，从IZ到IW，然后再从IW到IY的中间转换）。
声明接口和适配器
在PyProtocols中有很多不同的方法可以创建接口和适配器。PyProtocols文档非常详细地介绍了这些技术--很多不会在本文中涉及。接下来我们将进入一些细节，不过，我觉得，在这里给出实际的PyProtocols代码的一个最简化实例是个有用的方法。
例如，我决定创建一个Python对象的类-Lisp序列化。其描述并不是准确的Lisp语法，我也并不在意这种格式确切的优点和缺点。在这里，我的想法只是创建一个功能，使之可以执行类似repr()函数或pprint模块的工作，不过结果是既与以前串行器（serializers）有明显的不同，又要能更容易地扩展/定制。出于举例说明的目的做出了一个非常不像Lisp的选择：映射（mappings）是一个比列表（list）更为基础的数据结构（Python的元组（tuple）或列表被作为以连续整数为键的映射来处理）。下面是代码：
lispy.pyPyProtocol定义
fromprotocolsimport*
fromcStringIOimportStringIO
#Likeunicode,&evensupportobjectsthatdon'texplicitlysupportILisp
ILisp=protocolForType(unicode,['__repr__'],implicit=True)
#Classforinterface,butnomethodsspecificallyrequired
classISeq(Interface):pass
#Classforinterface,extremelysimplemappinginterface
classIMap(Interface):
defitems():
"Arequirementforamapistohavean.items()method"
#DefinefunctiontocreateanLisplikerepresentationofamapping
defmap2Lisp(map_,prot):
out=StringIO()
fork,vinmap_.items():
out.write("(%s%s)"%(adapt(k,prot),adapt(v,prot)))
return"(MAP%s)"%out.getvalue()
#UsethisfunctoconvertanIMap-supportingobjtoILisp-supportingobj
declareAdapter(map2Lisp,provides=[ILisp],forProtocols=[IMap])
#NotethatadictimplementsanIMapinterfacewithnoconversionneeded
declareAdapter(NO_ADAPTER_NEEDED,provides=[IMap],forTypes=[dict])
#DefineandusefunctoadaptanInstanceTypeobjtotheILispinterface
fromtypesimportInstanceType
definst2Lisp(o,p):
return"(CLASS'(%s)%s)"%(o.__class__.__name__,adapt(o.__dict__,p))
declareAdapter(inst2Lisp,provides=[ILisp],forTypes=[InstanceType])
#DefineaclasstoadaptanISeq-supportingobjtoanIMap-supportingobj
classSeqAsMap(object):
advise(instancesProvide=[IMap],
asAdapterForProtocols=[ISeq])
def__init__(self,seq,prot):
self.seq=seq
self.prot=prot
defitems(self):#ImplementtheIMaprequired.items()method
returnenumerate(self.seq)
#Notethatlist,tupleimplementanISeqinterfacew/oconversionneeded
declareAdapter(NO_ADAPTER_NEEDED,provides=[ISeq],forTypes=[list,tuple])
#Definealambdafunctoadaptstr,unicodetoILispinterface
declareAdapter(lambdas,p:"'(%s)"%s,
provides=[ILisp],forTypes=[str,unicode])
#DefineaclasstoadaptseveralnumerictypestoILispinterface
#Returnastring(ILisp-supporting)directlyfrominstanceconstructor
classNumberAsLisp(object):
advise(instancesProvide=[ILisp],
asAdapterForTypes=[long,float,complex,bool])
def__new__(klass,val,proto):
return"(%s%s)"%(val.__class__.__name__.upper(),val)
在上面的代码中，我已经用一些不同的方法声明了许多适配器。在一些情况中，代码将一个接口转换到另一个接口；在其他情况中，类型本身直接适配到另一个接口。我希望您能注意到关于代码的一些方面：（1）没有创建任何从list或tuple到ILisp接口的适配器；（2）没有为int数字类型显式声明适配器；（3）就此而言，没有声明直接由dict到ILisp的适配器。下面是代码将如何适配（adapt()）各种Python对象：
test_lispy.py对象序列化
fromlispyimport*
fromsysimportstdout,stderr
toLisp=lambdao:adapt(o,ILisp)
classFoo:
def__init__(self):
self.a,self.b,self.c='a','b','c'
tests=[
"foobar",
{17:2,33:4,'biz':'baz'},
["bar",('f','o','o')],
1.23,
(1L,2,3,4+4j),
Foo(),
True,
]
fortestintests:
stdout.write(toLisp(test)+'\n')
运行时，我们得到：
test_lispy.py序列化结果
$python2.3test_lispy.py
'(foobar)
(MAP(172)('(biz)'(baz))(334))
(MAP(0'(bar))(1(MAP(0'(f))(1'(o))(2'(o)))))
(FLOAT1.23)
(MAP(0(LONG1))(12)(23)(3(COMPLEX(4+4j))))
(CLASS'(Foo)(MAP('(a)'(a))('(c)'(c))('(b)'(b))))
(BOOLTrue)
对我们的输出进行一些解释将会有所帮助。第一行比较简单，我们定义了一个直接从字符串到ILisp的适配器，对adapt("foobar",ILisp)的调用只是返回了lambda函数的结果。下一行只是有一点复杂。没有直接从dict到ILisp的适配器；但我们不必使用任何适配器就可以让dict去适配IMap（我们声明了足够多），而且我们有从IMap到ILisp的适配器。类似的，对于后面的列表和元组，我们可以使ILisp适配ISeq，使ISeq适配IMap，并使IMap适配ILisp。PyProtocols会指出要采取的适配路径，所有这些不可思议的过程都在幕后完成。一个旧风格的实例所经历的过程与字符串或者支持IMap的对象相同，我们有一个直接到ILisp的适配。
不过，等一下。在我们的dict和tuple对象中用到的所有的整数是怎么处理的呢？long、complex、float和bool类型的数字有显式的适配器，不过int一个都没有。这里的技巧在于，int对象已经拥有一个.__repr__()方法；通过将隐式支持声明为ILisp接口的一部分，我们可以巧妙地使用对象已有的.__repr__()方法作为对ILisp接口的支持。实际上，作为一个内置的类型，整数用不加任何修饰的阿拉伯数字表示，而不使用大写的类型初始器（比如LONG）。
适配协议
让我们来更明确地看一下protocol.adapt()函数都做了什么事情。在我们的例子中，我们使用“声明API（declarationAPI）”来隐式地为适配设置了一组“工厂（factories）”。这个API有几个层次。声明API的“基本层次（primitives）”是函数：declareAdaptorForType()、declareAdaptorForObject()和declareAdaptorForProtocol()。前面的例子中没有用到这些，而是用到了一些高层次的API，如declareImplementation()、declareAdaptor()、adviceObject()和protocolForType()。在一种情况下，我们看到在一个类体中有“奇妙”的advise()声明。advise()函数支持用于配置那些建议的类的目的和角色的大量关键字参数。您还可以建议（advise()）一个模块对象。
您不需要使用声明API来创建知道如何使对象适配（adapt()）自己的可适配的对象或者接口。让我们来看adapt()的调用标记，然后解释它随后的过程。对adapt()的调用类似这样：
adapt()的调用标记
adapt(component,protocol,[,default[,factory]])
这就表示您希望让对象component去适配接口protocol。如果指定了default，它可以返回为一个包装对象（wrapperobject）或者对component的修改。如果factory被指定为一个关键字参数，那么会使用一个转换工厂来生成包装或者修改。不过让我们先退回一点，来看一下adapt()尝试的完整的动作次序（简化的代码）：
adapt()的假想实现
ifisinstance(component,protocol): returncomponent elifhasattr(component,'__conform__'): returncomponent.__conform__(protocol) elifhasattr(protocol,'__adapt__'): returnprotocol.__adapt__(component) elifdefaultisnotNone: returndefault eliffactoryisnotNone: returnfactory(component,protocol) else: NotImplementedError
对adapt()的调用应该保持一些特性（不过这是对程序员的建议，而不是库的一般强制要求）。对adapt()的调用应该是等幂的。也就是说，对于一个对象x和一个协议P，我们希望：adapt(x,P)==adapt(adapt(x,P),P)。高级地，这样做的目的类似于从.__iter__()方法返回自身（self）的迭代器（iterator）类的目的。您基本上不会希望去重新适配到您已经适配到的相同类型以产生波动的结果。
还值得注意的是，适配可能是有损耗的。为了让一个对象去顺应一个接口，可能不方便或者不可能保持重新初始化这个对象所需要的所有信息。也就是说，通常情况下，对对象x及协议P1和P2而言：adapt(x,P1)!=adapt(adapt(adapt(x,P1),P2),P1)。
在结束之前，让我们来看另一个利用了adapt()的低层次行为的测试脚本：
test_lispy2.py对象序列化
fromlispyimport*
classBar(object):
pass
classBaz(Bar):
def__repr__(self):
return"Representa"+self.__class__.__name__+"object!"
classBat(Baz):
def__conform__(self,prot):
return"Adapt"+self.__class__.__name__+"to"+repr(prot)+"!"
printadapt(Bar(),ILisp)
printadapt(Baz(),ILisp)
printadapt(Bat(),ILisp)
printadapt(adapt(Bat(),ILisp),ILisp)
$python2.3test_lispy2.py
<__main__.Barobjectat0x65250>
RepresentaBazobject!
AdaptBattoWeakSubset(<type'unicode'>,('__repr__',))!
'(AdaptBattoWeakSubset(<type'unicode'>,('__repr__',))!)
结果证明lispy.py的设计不能满足等幂的目标。改进这一设计可能是个不错的练习。不过，像ILisp这样的描述肯定会损耗原始对象中的信息（这是没关系的）。
结束语
感觉上，PyProtocols与本专栏提及的其他“外来”话题有一些共同之处。首先，声明API是声明性的（相对于解释性）。声明性编程并不给出执行一个动作所需要的步骤和开关，而是声明处理特定的内容，由库或编译器来具体指出如何执行。名称“declare*()”和“advice*()”正在来自于这一观点。
不过，我也发现PyProtocols编程有些类似于使用多分派进行编程，具体说就是使用我在另一期文章提到的gnosis.magic.multimethods模块。与PyProtocols的确定适配路径形成对照，我自己的模块执行了一个相对简单的推演，确定要分派的相关祖先类。不过两个库都倾向于在编程中鼓励使用类似的模块化思想--由大量的小函数或类来执行“可插入的”任务，不需要受死板的类层级结构所困。在我看来，这种风格有其优越之处。