猴子补丁

  0 猴子补丁 - Monkey Patching

  1 定义,
    猴子补丁（monkey patching）
    　　 在运行时动态修改模块、类或函数，通常是添加功能或修正缺陷。猴子补丁在代码运行时
        （内存中）发挥作用，不会修改源码，因此只对当前运行的程序实例有效。
        因为猴子补丁破坏了封装，而且容易导致程序与补丁代码的实现细节紧密耦合，
        所以被视为临时的变通方案，不是集成代码的推荐方式。

    monkey patching
        Dynamically changing a module, class or function at run time,
        usually to add features or fix bugs. Because it is done in memory
        and not by changing the source code, a monkey patch only affects the
        currently running instance of the program. Monkey patches break
        encapsulation and tend to be tightly coupled to the implementation
        details of the patched code units, so they are seen as temporary
        work-arounds and not a recommended technique for code integration.


    猴子补丁的名声不太好。如果滥用，会导致系统难以理解和维护。补丁通常与目标紧密耦合，
    因此很脆弱。另一个问题是，打了猴子补丁的两个库可能相互牵绊，因为第二个库可能撤销
    了第一个库的补丁。不过猴子补丁也有它的作用，例如可以在运行时让类实现协议。
    适配器设计模式通过实现全新的类解决这种问题。为 Python 打猴子补丁不难，但是有些局限。
    与 Ruby 和 JavaScript 不同， Python 不允许为内置类型打猴子补丁。
    其实这是优点，因为这样可以确保 str 对象的方法始终是那些。
    这一局限能减少外部库打的补丁有冲突的概率。

看例子之前, 回顾一下儿 协议 protocol,
    详见 duck typing 一文,
        http://www.cnblogs.com/zzyzz/p/7723272.html
        在 Python 中创建功能完善的序列类型无需使用继承, 只需实现符合序列协议的方法.
        在面向对象编程中,协议是非正式的接口,只在文档中定义,在代码中不定义.
        例如,Python 的序列协议只需要 __len__ 和 __getitem__ 两个方法.
        任对象/类型(A)只要使用标准的签名和语义实现了这两个方法,就能用在任何期待序列的地方,
        然而A 是不是哪个类的子类无关紧要,只要提供了所需的方法即可.这就是 python 序列协议.
        协议是非正式的,没有强制力,因此如果你知道类的具体使用场景,通常只需要实现一个协议的部分.
        例如,为了支持迭代,只需实现 __getitem__ 方法，没必要提供 __len__方法.

例子,
    注意 '>>>' 表示在交互式控制台 console 的输入
    >>>class ballgame(object):              # 这个class 可以生成一个 ball 的组合集合.
    ...    colors = ['red','green','bule']
    ...    boxs = ['1', '2', '3']

    ...    def __init__(self):
    ...        self.ballsets = [(b, c) for b in self.boxs for c in self.colors]

    ...    def __getitem__(self, position):
    ...        return self.ballsets[position]

    ...    def __len__(self):
    ...        return len(self.ballsets)

        # def __setitem__(self, key, value):
        #     self.ballsets[key] = value
    ...   def pickone(self,position):
    ...        return self.ballsets[position]

    >>>ball = ballgame()
    >>>ball.ballsets
    [('1', 'red'), ('1', 'green'), ('1', 'bule'), ('2', 'red'), ('2', 'green'),
    ('2', 'bule'), ('3', 'red'), ('3', 'green'), ('3', 'bule')]
    >>>ball.pickone(2)
    ('1', 'bule')             # 这里会发现主要取得位置相同, 取出的 ball 组合就不变.
                              # 我们是通过 random 模块重新排序 ball 示例中 ball 组合的顺序.
    >>>import random
    >>>random.shuffle(ball)
    Traceback (most recent call last):
    File "<input>", line 1, in <module>
    File "C:Usersyzzhou8AppDataLocalProgramsPythonPython36-32lib
andom.py", line 274, in shuffle
    x[i], x[j] = x[j], x[i]
    TypeError: 'ballgame' object does not support item assignment

    #发现 random.shuffle 不可行,原因是 ballgame 类中没有实现可变序列协议的 __setitem__ 方法,
    #当然可以通过在类中实现 __setitem__ 特殊方法后,重新初始化实例解决这个问题,
    #现在看看如果通过 monkey patching 解决这个问题.

    >>>def setballset(ballgame,position,ballset):
    ...    ballgame.ballsets[position] = ballset

    >>>ball.__setitem__ = setballset
    >>>random.shuffle(ball)
    >>>ball.ballsets
    [('1', 'bule'), ('1', 'green'), ('2', 'bule'), ('3', 'green'), ('2', 'green'),
    ('2', 'red'), ('1', 'red'), ('3', 'red'), ('3', 'bule')]
    >>>random.shuffle(ball)
    ball.ballsets
    [('1', 'green'), ('3', 'red'), ('3', 'green'), ('1', 'red'), ('2', 'green'),
    ('3', 'bule'), ('2', 'red'), ('2', 'bule'), ('1', 'bule')]

    # 通过 monkey patching 在 ballgame 类的实例 ball 中 实现了 __setitem__ 特殊方法,
    # 使 ball 实例变成一个符合可变序列协议的的实例,进而使我们可以通过 random.shuffle(ball)
    # 来重新排序 ball.ballsets

    >>>ball2 = ballgame()
    >>>random.shuffle(ball2)
    Traceback (most recent call last):
    File "<input>", line 1, in <module>
    File "C:Usersyzzhou8AppDataLocalProgramsPythonPython36-32lib
andom.py", line 274, in shuffle
    x[i], x[j] = x[j], x[i]
    TypeError: 'ballgame' object does not support item assignment

    # Monkey patching 并没有在原来类中起作用.

    summarize, Monkey patching 之所以起作用, 要得益于 duck typing,
        然而, 最终要归功于 python 的 协议protocol 这一架构设计.