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 »

本站

博客链接

最近发表