python 适配器模式

所谓适配器模式是指是一种接口适配技术，它可通过某个类来使用另一个接口与之不兼容的类，运用此模式，两个类的接口都无需改动。
存在一套旧系统，里面包含 Human 和 Synthesizer 类，如下：

class Synthesizer:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return 'the {} synthesizer'.format(self.name)

    def play(self):
        return 'is playing an electronic song'

class Human:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return '{} the human'.format(self.name)

    def speak(self):
        return 'says hello'

现在新增 Computer 类如下：

class Computer:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return 'the {} computer'.format(self.name)

    def execute(self):
        return 'executes a program'

并且对于扩展系统来说，所有动作函数均使用 Obj.execute() 来执行。即对于调用者来说，原系统的 Synthesizer.play() 和 Human.speak() 是不存在的，必须像调用 Computer.execute() 一样使用 Synthesizer.execute() 和 Human.execute() 来调用原系统中对象的执行函数。

这就是我们之前提到的场景，无法修改原系统函数，此时新系统就可以采用适配器模式进行设计。

我们可以创建一个 Adapter 类专门用于统一接口，代码如下。

class Adapter:
    def __init__(self, obj, adapted_methods):
        self.obj = obj
        self.__dict__.update(adapted_methods)

    def __str__(self):
        return str(self.obj)

简单来说，这里是使用了 Python 的一个特殊语法糖 class.dict 属性，即类的内部字典。这个特殊的属性是一个字典，存放了这个类所包含的所有属性，包括方法。所以这里将传入的类进行处理，将需要被适配器处理的方法添加到内部字典中，生成一个属于这个新适配器对象的方法。

接下来，只需要在调用时，对原有系统的类进行封装，即可实现统一使用 execute() 方法执行动作了。代码如下.

def new_main():
    objects = [Computer('Asus')]
    synth = Synthesizer('moog')
    objects.append(Adapter(synth, dict(execute=synth.play)))
    human = Human('Bob')
    objects.append(Adapter(human, dict(execute=human.speak)))

    for i in objects:
        print('{} {}'.format(str(i), i.execute()))
        print('type is {}'.format(type(i)))

执行结果如下：

the Asus computer executes a program
type is <class '__main__.Computer'>
the moog synthesizer is playing an electronic song
type is <class '__main__.Adapter'>
Bob the human says hello
type is <class '__main__.Adapter'>