All articles

  1. python设计模式之观察者模式

    观察者模式

    当我们希望一个对象的状态发生变化,那么依赖与它的所有对象都能相应变化(获得通知),那么就可以用到Observer模式, 其中的这些依赖对象就是观察者的对象,那个要发生变化的对象就是所谓’观察者’

    python的例子

    # 这个是观察者基类
    class Subject(object):
        def __init__(self):
            self._observers = []
    
        # 添加依赖的对象
        def attach(self, observer):
            if not observer in self._observers:
                self._observers.append(observer)
    
        # 取消添加
        def detach(self, observer):
            try:
                self._observers.remove(observer)
            except ValueError:
                pass
    
        # 这里只是通知上面注册的依赖对象新的变化
        def notify(self ...
  2. python设计模式之访问者模式

    访问者模式

    我觉得Visitor模式是在补修改已有程序结构前提下,通过添加额外的访问者完成对代码功能的拓展 为什么这样用?当你的类层次较多,在某层结构中增加新的方法,要是在基类上面添加或者变更,可能破坏原来的设计, 有兼容问题,所以只在需要的类上面动态添加

    python的例子

    这里是个构建车的例子,每个部件都有一个accept的方法接受我上面说的所谓’访问者’,而这个访问者 以参数的方式传进来,但是其实他是一个含有一些功能的类的实例,它拥有很多个visit开头的方法对应不同的部件。 这样就不需要修改这些部件,而只是修改我们的访问者类的相关部分

    # 轮子,引擎, 车身这些定义好了都不需要变动
    class Wheel:
        def __init__(self, name):
            self.name = name
        def accept(self, visitor):
            # 每个visitor是同样的,但是其中的方法是不一样的,比如这里是visitWheel,
            # 然后传入了self,想想?他其实想做什么就能做什么
            visitor.visitWheel(self)
    
    class Engine:
        def accept(self ...
  3. python设计模式之备忘录模式

    Memento模式

    备忘录模式一个最好想象的例子:undo! 它对对象的一个状态进行了’快照’, 在你需要的时候恢复原貌。做前端会有一个场景:你设计一个表单,当点击提交会对表单内容 验证,这个时候你就要对用户填写的数据复制下来,当用户填写的不正确或者格式不对等问题, 就可以使用快照数据恢复用户已经填好的,而不是让用户重新来一遍,不是嘛?

    python的例子

    这里实现了一个事务提交的例子

    import copy
    
    def Memento(obj, deep=False):
    
        # 对你要做快照的对象做快照
        state = (copy.copy if deep else copy.deepcopy)(obj.__dict__)
        def Restore():
            obj.__dict__ = state
        return Restore
    
    class Transaction:
    
        deep = False
        def __init__(self, *targets ...
  4. python设计模式之对象池模式

    对象池模式

    在开发中,我们总是用到一些和’池’相关的东西,比如 内存池,连接池,对象池,线程池.. 这里说的对象池其实也就是一定数量已经创建好的对象的集合。为什么要用对象池? 创建对象是要付出代价的(我暂时还没有研究过底层,只说我工作中体会的), 比如pymongo就自带线程池,这样用完就放回到池里再被重用,岂不是节省了创建的花费?

    python的例子

    我这里实现了个线程安全的简单的对象池

    import Queue
    import types
    import threading
    from contextlib import contextmanager
    
    class ObjectPool(object):
    
        def __init__(self, fn_cls, *args, **kwargs):
            super(ObjectPool, self).__init__()
            self.fn_cls = fn_cls
            self._myinit(*args, **kwargs ...
  5. python设计模式之代理模式

    代理模式

    Proxy模式是一种常用的设计模式,它主要用来通过一个对象(比如B)给一个对象(比如A) 提供’代理’的方式方式访问。比如一个对象不方便直接引用,代理就在这个对象和访问者之间做了中介

    python的例子

    你先设想:一个对象提供rgb三种颜色值,我想获得一个对象的rgb三种颜色,但是我不想让你获得蓝色属性,怎么办?

    class Proxy(object):
        def __init__(self, subject):
            self.__subject = subject
        # 代理其实本质上就是属性的委托
        def __getattr__(self, name):
            return getattr(self.__subject, name)
    
    class RGB:
        def __init__(self, red, green, blue):
            self.__red = red
            self.__green ...
  6. python设计模式之模板方法模式

    模板方法模式

    不知道你有没有注意过,我们实现某个业务功能,在不同的对象会有不同的细节实现, 以前说过策略模式, 策略模式是将逻辑封装在一个类(提到的文章中的Duck)中,然后使用委托的方式解决。 模板方法模式的角度是:把不变的框架抽象出来,定义好要传入的细节的接口. 各产品类的公共的行为 会被提出到公共父类,可变的都在这些产品子类中

    python的例子

    '''http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/'''
    
    # 整个例子我们要根据不同需求处理的内容
    ingredients = "spam eggs apple"
    line = '-' * 10
    
    # 这是被模板方法调用的基础函数
    def iter_elements(getter, action):
        """循环处理的骨架"""
        # getter是要迭代的数据,action是要执行的函数
        for element in getter():
            action(element)
            print(line)
    
    def rev_elements ...
  7. python设计模式之Null模式

    Null模式

    我想每个人都有一种经历,为了获取某属性,但是有时候属性是None,那么需要你做异常处理, 而假如你想节省这样的条件过滤的代码,可以使用Null模式以减少对象是否为None的判断

    python的例子

    我举个不是很通用的例子,只是为了让大家理解这个模式:我有很多类, 但是不是每个类都有类方法test,所以我调用类方法就要做个异常处理,类似这样

    class A(object):
        pass
    
    class B(object):
        b = 1
        @classmethod
        def test(cls):
            print cls.b
    
    def get_test(x):
        try:
            return x.test
        except AttributeError: 
            return None
    
    # 我这里只写了2个类,但是其实有很多类
    for i in [A, B]:
        test = get_test ...
  8. python设计模式之桥接模式

    桥接模式

    这个模式其实就是把产品类的实现和抽象类分离,能够灵活的变化,假如你记得状态模式,它是修改内部属性, 而桥接模式是指定好内部属性,每个产品类指定这个属性被桥接模式类调用,适用于产品类可能经常调整变化,这样还能减少了产品类之间的耦合

    python的例子

    这里实现一个打印操作系统名字的功能

    class Bridge(object):
    
        def __init__(self):
            self.__implementation = None
    
        def someFunctionality(self):
            raise NotImplemented()
    
    class UseCase1(Bridge):
        # 根据初始化参数传入实现的产品类
        def __init__(self, implementation):
            self.__implementation = implementation
        # 根据传入的产品类的属性打印结果
        def someFunctionality(self):
            print "UseCase1: ",
            self.__implementation.anotherFunctionality()
    
    
    class UseCase2(Bridge):
        def ...

Page 1 / 3 »

博客链接