# factory patternMINI14 = '1.4GHz Mac mini'class AppleFactory:    class MacMini14:        def __init__(self):            self.memory = 4  # in gigabytes            self.hdd = 500  # in gigabytes            self.gpu = 'Intel HD Graphics 5000'        def __str__(self):            info = ('Model: {}'.format(MINI14),                    'Memory: {}GB'.format(self.memory),                    'Hard Disk: {}GB'.format(self.hdd),                    'Graphics Card: {}'.format(self.gpu))            return '\n'.join(info)    def build_computer(self, model):        if model == MINI14:            return self.MacMini14()        else:            print("I don't know how to build {}".format(model))# 使用工厂afac = AppleFactory()mac_mini = afac.build_computer(MINI14)print(mac_mini)# builder模式class Computer:    def __init__(self, serial_number):        self.serial = serial_number        self.memory = None      # in gigabytes        self.hdd = None         # in gigabytes        self.gpu = None    def __str__(self):        info = ('Memory: {}GB'.format(self.memory),                'Hard Disk: {}GB'.format(self.hdd),                'Graphics Card: {}'.format(self.gpu))        return '\n'.join(info)class ComputerBuilder:    def __init__(self):        self.computer = Computer('AG23385193')    def configure_memory(self, amount):        self.computer.memory = amount    def configure_hdd(self, amount):        self.computer.hdd = amount    def configure_gpu(self, gpu_model):        self.computer.gpu = gpu_modelclass HardwareEngineer:    def __init__(self):        self.builder = None    def construct_computer(self, memory, hdd, gpu):        self.builder = ComputerBuilder()        [step for step in (self.builder.configure_memory(memory),                        self.builder.configure_hdd(hdd),                        self.builder.configure_gpu(gpu))]    @property    def computer(self):        return self.builder.computer# 使用buidler，可以创建多个builder类实现不同的组装方式engineer = HardwareEngineer()engineer.construct_computer(hdd=500, memory=8, gpu='GeForce GTX 650 Ti')computer = engineer.computerprint(computer)

import copyfrom collections import OrderedDictclass Book:    def __init__(self, name, authors, price, **rest):        '''Examples of rest: publisher, length, tags, publication        date'''        self.name = name        self.authors = authors        self.price = price      # in US dollars        self.__dict__.update(rest)    def __str__(self):        mylist = []        ordered = OrderedDict(sorted(self.__dict__.items()))        for i in ordered.keys():            mylist.append('{}: {}'.format(i, ordered[i]))            if i == 'price':                mylist.append('$')            mylist.append('\n')        return ''.join(mylist)class Prototype:    def __init__(self):        self.objects = {}    def register(self, identifier, obj):        self.objects[identifier] = obj    def unregister(self, identifier):        del self.objects[identifier]    def clone(self, identifier, **attr):        """ 实现对象拷贝 """        found = self.objects.get(identifier)        if not found:            raise ValueError('Incorrect object identifier: {}'.format(identifier))        obj = copy.deepcopy(found)        obj.__dict__.update(attr)    # 实现拷贝时自定义更新        return objdef main():    b1 = Book('The C Programming Language', ('Brian W. Kernighan', 'Dennis M.Ritchie'),            price=118, publisher='Prentice Hall', length=228, publication_date='1978-02-22',            tags=('C', 'programming', 'algorithms', 'data structures'))    prototype = Prototype()    cid = 'k&r-first'    prototype.register(cid, b1)    b2 = prototype.clone(cid, name='The C Programming Language (ANSI)', price=48.99, length=274,                        publication_date='1988-04-01', edition=2)    for i in (b1, b2):        print(i)        print("ID b1 : {} != ID b2 : {}".format(id(b1), id(b2)))

class Computer:    def __init__(self, name):        self.name = name    def __str__(self):        return 'the {} computer'.format(self.name)    def execute(self):        """ call by client code """        return 'execute a program'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 electroinc 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'class Adapter:    def __init__(self, obj, adapted_methods):        """ 不使用继承，使用__dict__属性实现适配器模式 """        self.obj = obj        self.__dict__.update(adapted_methods)    def __str__(self):        return str(self.obj)# 适配器使用示例def main():    objs = [Computer('Asus')]    synth = Synthesizer('moog')    objs.append(Adapter(synth, dict(execute=synth.play)))    human = Human('Wnn')    objs.append(Adapter(human, dict(execute=human.speak)))    for o in objs:        # 用统一的execute适配不同对象的方法，这样在无需修改源对象的情况下就实现了不同对象方法的适配        print('{} {}'.format(str(o), o.execute()))if __name__ == "__main__":    main()

from functools import wrapsdef memoize(fn):    known = dict()    @wraps(fn)    def memoizer(*args):        if args not in known:            known[args] = fn(*args)        return known[args]    return memoizer@memoizedef fibonacci(n):    assert(n >= 0), 'n must be >= 0'    return n if n in (0, 1) else fibonacci(n-1) + fibonacci(n-2)

from abc import ABCMeta, abstractmethodfrom enum import EnumState = Enum('State', 'new running sleeping restart zombie')class Server(metaclass=ABCMeta):    """ 抽象基类 """    @abstractmethod    def __init__(self):        pass    def __str__(self):        return self.name    @abstractmethod    def boot(self):        pass    @abstractmethod    def kill(self, restart=True):        passclass FileServer(Server):    def __init__(self):        '''actions required for initializing the file server'''        self.name = 'FileServer'        self.state = State.new    def boot(self):        print('booting the {}'.format(self))        '''actions required for booting the file server'''        self.state = State.running    def kill(self, restart=True):        print('Killing {}'.format(self))        '''actions required for killing the file server'''        self.state = State.restart if restart else State.zombie    def create_file(self, user, name, permissions):        '''check validity of permissions, user rights, etc.'''        print("trying to create the file '{}' for user '{}' with permissions {}".format(name, user, permissions))class ProcessServer(Server):    def __init__(self):        '''actions required for initializing the process server'''        self.name = 'ProcessServer'        self.state = State.new    def boot(self):        print('booting the {}'.format(self))        '''actions required for booting the process server'''        self.state = State.running    def kill(self, restart=True):        print('Killing {}'.format(self))        '''actions required for killing the process server'''        self.state = State.restart if restart else State.zombie    def create_process(self, user, name):        '''check user rights, generate PID, etc.'''        print("trying to create the process '{}' for user '{}'".format(name, user))class OperatingSystem:    ''' 实现外观模式，外部使用的代码不必知道 FileServer 和 ProcessServer的    内部机制，只需要通过 OperatingSystem类调用'''    def __init__(self):        self.fs = FileServer()        self.ps = ProcessServer()    def start(self):        """ 被客户端代码使用 """        [i.boot() for i in (self.fs, self.ps)]    def create_file(self, user, name, permissions):        return self.fs.create_file(user, name, permissions)    def create_process(self, user, name):        return self.ps.create_process(user, name)def main():    os = OperatingSystem()    os.start()    os.create_file('foo', 'hello', '-rw-r-r')    os.create_process('bar', 'ls /tmp')main()

# 使用对象池技术实现享元模式import randomfrom enum import EnumTreeType = Enum('TreeType', 'apple_tree cherry_tree peach_tree')class Tree:    pool = dict()    def __new__(cls, tree_type):        obj = cls.pool.get(tree_type, None)        if obj is None:            obj = object.__new__(cls)            cls.pool[tree_type] = obj            obj.tree_type = tree_type        return obj    def render(self, age, x, y):        print('render a tree of type {} and age {} at ({}, {})'.format(self.tree_type, age, x, y))def main():    rnd = random.Random()    age_min, age_max = 1, 30    # in years    min_point, max_point = 0, 100    tree_counter = 0    for _ in range(10):        t1 = Tree(TreeType.apple_tree)        t1.render(rnd.randint(age_min, age_max),                rnd.randint(min_point, max_point),                rnd.randint(min_point, max_point))        tree_counter += 1    for _ in range(3):        t2 = Tree(TreeType.cherry_tree)        t2.render(rnd.randint(age_min, age_max),                rnd.randint(min_point, max_point),                rnd.randint(min_point, max_point))        tree_counter += 1    for _ in range(5):        t3 = Tree(TreeType.peach_tree)        t3.render(rnd.randint(age_min, age_max),                rnd.randint(min_point, max_point),                rnd.randint(min_point, max_point))        tree_counter += 1    print('trees rendered: {}'.format(tree_counter))    print('trees actually created: {}'.format(len(Tree.pool)))    t4 = Tree(TreeType.cherry_tree)    t5 = Tree(TreeType.cherry_tree)    t6 = Tree(TreeType.apple_tree)    print('{} == {}? {}'.format(id(t4), id(t5), id(t4) == id(t5)))    print('{} == {}? {}'.format(id(t5), id(t6), id(t5) == id(t6)))if __name__ == '__main__':    main()

quotes = ('A man is not complete until he is married. Then he is finished.',        'As I said before, I never repeat myself.',        'Behind a successful man is an exhausted woman.',        'Black holes really suck...', 'Facts are stubborn things.')class QuoteModel:    def get_quote(self, n):        try:            return quotes[n]        except IndexError:            return 'Not found'class QuoteTerminalView:    def show(self, quote):        print('And the quote is: "{}"'.format(quote))    def error(self, msg):        print('Error: {}'.format(msg))    def select_quote(self):        return input('Which quote number would you like to see? ')class QuoteTerminalController:    def __init__(self):        self.model = QuoteModel()        self.view = QuoteTerminalView()    def run(self):        valid_input = False        while not valid_input:            n = self.view.select_quote()            try:                n = int(n)            except ValueError:                self.view.error("Incorrect index '{}'".format(n))            else:                valid_input = True                quote = self.model.get_quote(n)                self.view.show(quote)def main():    controller = QuoteTerminalController()    while True:        controller.run()

class LazyProperty:    """ 用描述符实现延迟加载的属性 """    def __init__(self, method):        self.method = method        self.method_name = method.__name__    def __get__(self, obj, cls):        if not obj:            return None        value = self.method(obj)        print('value {}'.format(value))        setattr(obj, self.method_name, value)        return valueclass Test:    def __init__(self):        self.x = 'foo'        self.y = 'bar'        self._resource = None    @LazyProperty    def resource(self):    # 构造函数里没有初始化，第一次访问才会被调用        print('initializing self._resource which is: {}'.format(self._resource))        self._resource = tuple(range(5))    # 模拟一个耗时计算        return self._resourcedef main():    t = Test()    print(t.x)    print(t.y)    # 访问LazyProperty, resource里的print语句只执行一次，实现了延迟加载和一次执行    print(t.resource)    print(t.resource)main()

class SensitiveInfo:    def __init__(self):        self.users = ['nick', 'tom', 'ben', 'mike']    def read(self):        print('There are {} users: {}'.format(len(self.users), ' '.join(self.users)))    def add(self, user):        self.users.append(user)        print('Added user {}'.format(user))class Info:    '''protection proxy to SensitiveInfo'''    def __init__(self):        self.protected = SensitiveInfo()        # 为了方便示例这里直接写死在代码里，为了安全不应该这么做        self.secret = '0xdeadbeef'    def read(self):        self.protected.read()    def add(self, user):        """ 给add操作加上密钥验证，保护add操作"""        sec = input('what is the secret? ')        self.protected.add(user) if sec == self.secret else print("That's wrong!")def main():    info = Info()    while True:        print('1. read list |==| 2. add user |==| 3. quit')        key = input('choose option: ')        if key == '1':            info.read()        elif key == '2':            name = input('choose username: ')            info.add(name)        elif key == '3':            exit()        else:            print('unknown option: {}'.format(key))main()

from abc import ABCMeta, abstractmethodclass SensitiveInfo(metaclass=ABCMeta):    def __init__(self):        self.users = ['nick', 'tom', 'ben', 'mike']    @abstractmethod    def read(self):        pass    @abstractmethod    def add(self, user):        passclass Info(SensitiveInfo):    '''protection proxy to SensitiveInfo'''    def __init__(self):        # self.protected = SensitiveInfo()        super().__init__()        self.secret = '0xdeadbeef'    # 为了方便示例这里直接写死在代码里    def read(self):        print('There are {} users: {}'.format(len(self.users), ' '.join(self.users)))    def add(self, user):        """ 给add操作加上密钥验证，保护add操作"""        sec = input('what is the secret? ')        self.users.append(user) if sec == self.secret else print("That's wrong!")

class Event:    def __init__(self, name):        self.name = name    def __str__(self):        return self.nameclass Widget:    """Docstring for Widget. """    def __init__(self, parent=None):        self.parent = parent    def handle(self, event):        handler = 'handle_{}'.format(event)        if hasattr(self, handler):            method = getattr(self, handler)            method(event)        elif self.parent:            self.parent.handle(event)        elif hasattr(self, 'handle_default'):            self.handle_default(event)class MainWindow(Widget):    def handle_close(self, event):        print('MainWindow: {}'.format(event))    def handle_default(self, event):        print('MainWindow: Default {}'.format(event))class SendDialog(Widget):    def handle_paint(self, event):        print('SendDialog: {}'.format(event))class MsgText(Widget):    def handle_down(self, event):        print('MsgText: {}'.format(event))def main():    mw = MainWindow()    sd = SendDialog(mw)    # parent是mw    msg = MsgText(sd)    for e in ('down', 'paint', 'unhandled', 'close'):        evt = Event(e)        print('\nSending event -{}- to MainWindow'.format(evt))        mw.handle(evt)        print('Sending event -{}- to SendDialog'.format(evt))        sd.handle(evt)        print('Sending event -{}- to MsgText'.format(evt))        msg.handle(evt)if __name__ == "__main__":    main()

import osclass RenameFile:    def __init__(self, path_src, path_dest):        """ 在init里保存一些必要信息，比如undo需要的老的和新的文件名 """        self.src, self.dest = path_src, path_dest    def execute(self, verbose=False):        if verbose:            print("[renaming '{}' to '{}']".format(self.src, self.dest))        os.rename(self.src, self.dest)    def undo(self, verbose=False):        if verbose:            print("[renaming '{}' back to '{}']".format(self.dest, self.src))        os.rename(self.dest, self.src)def delete_file(path, verbose=False):    if verbose:        print("deleting file '{}".format(path))    os.remove(path)class CreateFile:    def __init__(self, path, txt='hello world\n'):        self.path, self.txt = path, txt    def execute(self, verbose=False):        if verbose:            print("[creating file '{}']".format(self.path))        with open(self.path, mode='w', encoding='utf-8') as out_file:            out_file.write(self.txt)    def undo(self):        delete_file(self.path)class ReadFile:    def __init__(self, path):        self.path = path    def execute(self, verbose=False):        if verbose:            print("[reading file '{}']".format(self.path))        with open(self.path, mode='r', encoding='utf-8') as in_file:            print(in_file.read(), end='')def main():    orig_name, new_name = 'file1', 'file2'    commands = []    for cmd in CreateFile(orig_name), ReadFile(orig_name), RenameFile(orig_name, new_name):        commands.append(cmd)    [c.execute() for c in commands]    answer = input('reverse the executed commands? [y/n] ')    if answer not in 'yY':        print("the result is {}".format(new_name))        exit()    for c in reversed(commands):        try:            c.undo()   # 执行undo        except AttributeError:            passmain()

>>> text = '// Look out of the yard? What will we see?'>>> print pp.cppStyleComment.parseString(text)['// Look out of the yard? What will we see?']>>> print pp.cppStyleComment.parseString('/* Author: R. J. Gumby */')['/* Author: R. J. Gumby */']

from pyparsing import cppStyleCommentcode = """/* Hello World program */#include<stdio.h>main(){    printf("Hello World");    // print hello}"""print(cppStyleComment.suppress().transformString(code))

from pyparsing import Word, OneOrMore, Optional, Group, Suppress, alphanumsclass Gate:    def __init__(self):        self.is_open = False    def __str__(self):        return 'open' if self.is_open else 'closed'    def open(self):        print('opening the gate')        self.is_open = True    def close(self):        print('closing the gate')        self.is_open = Falsedef main():    # 首先定义我们的DSL格式，我们这里最简单的控制语法就是   "open -> gate"    word = Word(alphanums)    command = Group(OneOrMore(word))    token = Suppress("->")    device = Group(OneOrMore(word))    argument = Group(OneOrMore(word))    event = command + token + device + Optional(token + argument)    gate = Gate()    cmds = ['open -> gate', 'close -> gate']    # 两个自定义的命令    open_actions = {'gate': gate.open}    close_actions = {'gate': gate.close}    for cmd in cmds:        print(event.parseString(cmd))    # [['open'], ['gate']]        cmd, dev = event.parseString(cmd)        cmd_str, dev_str = ' '.join(cmd), ' '.join(dev)        print(cmd_str, dev_str)        if 'open' in cmd_str:            open_actions[dev_str]()        elif 'close' in cmd_str:            close_actions[dev_str]()if __name__ == "__main__":    main()

class Publisher:    def __init__(self):        self.observers = []    def add(self, observer):        if observer not in self.observers:            self.observers.append(observer)        else:            print('Failed to add : {}').format(observer)    def remove(self, observer):        try:            self.observers.remove(observer)        except ValueError:            print('Failed to remove : {}').format(observer)    def notify(self):        [o.notify_by(self) for o in self.observers]class DefaultFormatter(Publisher):    def __init__(self, name):        super().__init__()        self.name = name        self._data = 0    def __str__(self):        return "{}: '{}' has data = {}".format(            type(self).__name__, self.name, self._data)    @property    def data(self):        return self._data    @data.setter    def data(self, new_value):        try:            self._data = int(new_value)        except ValueError as e:            print('Error: {}'.format(e))        else:            self.notify()    # data 在被合法赋值以后会执行notifyclass HexFormatter:    """ 订阅者 """    def notify_by(self, publisher):        print("{}: '{}' has now hex data = {}".format(            type(self).__name__, publisher.name, hex(publisher.data)))class BinaryFormatter:    """ 订阅者 """    def notify_by(self, publisher):        print("{}: '{}' has now bin data = {}".format(            type(self).__name__, publisher.name, bin(publisher.data)))if __name__ == "__main__":    df = DefaultFormatter('test1')    print(df)    print()    hf = HexFormatter()    df.add(hf)    df.data = 3    print(df)    print()    bf = BinaryFormatter()    df.add(bf)    df.data = 21    print(df)

# 先装下pip3 install state_machinefrom state_machine import (    acts_as_state_machine, State, Event, before, after, InvalidStateTransition)@acts_as_state_machineclass Process:    # 先来定义状态机的状态 states    created = State(initial=True)    # 初始状态    waiting = State()    running = State()    terminated = State()    blocked = State()    swapped_out_waiting = State()    swapped_out_blocked = State()    # 再定义状态机的转移 transitions    wait = Event(from_states=(created, running, blocked,                            swapped_out_waiting), to_state=waiting)    run = Event(from_states=waiting, to_state=running)    terminate = Event(from_states=running, to_state=terminated)    block = Event(from_states=(running, swapped_out_blocked),                to_state=blocked)    swap_wait = Event(from_states=waiting, to_state=swapped_out_waiting)    swap_block = Event(from_states=blocked, to_state=swapped_out_blocked)    def __init__(self, name):        self.name = name    # The state_machine module provides us with the @before and @after    # decorators that can be used to execute actions before or after a    # transition occurs, respectfully.    @after('wait')    def wait_info(self):        print('{} entered waiting mode'.format(self.name))    @after('run')    def run_info(self):        print('{} is running'.format(self.name))    @before('terminate')    def terminate_info(self):        print('{} terminated'.format(self.name))    @after('block')    def block_info(self):        print('{} is blocked'.format(self.name))    @after('swap_wait')    def swap_wait_info(self):        print('{} is swapped out and waiting'.format(self.name))    @after('swap_block')    def swap_block_info(self):        print('{} is swapped out and blocked'.format(self.name))def transition(process, event, event_name):    """    Args:        process (Process obj):        event (Event obj): wait, run, terminate...        event_name (str): name of event    """    try:        event()    except InvalidStateTransition:        print('Error: transition of {} from {} to {} failed'.format(            process.name, process.current_state, event_name))def state_info(process):    """ 当前状态机的状态 """    print('state of {}: {}'.format(process.name, process.current_state))if __name__ == "__main__":    RUNNING = 'running'    WAITING = 'waiting'    BLOCKED = 'blocked'    TERMINATED = 'terminated'    p1, p2 = Process('process1'), Process('process2')    [state_info(p) for p in (p1, p2)]    print()    transition(p1, p1.wait, WAITING)    transition(p2, p2.terminate, TERMINATED)    [state_info(p) for p in (p1, p2)]    print()    transition(p1, p1.run, RUNNING)    transition(p2, p2.wait, WAITING)    [state_info(p) for p in (p1, p2)]    print()    transition(p2, p2.run, RUNNING)    [state_info(p) for p in (p1, p2)]    print()    [transition(p, p.block, BLOCKED) for p in (p1, p2)]    [state_info(p) for p in (p1, p2)]    print()    [transition(p, p.terminate, TERMINATED) for p in (p1, p2)]    [state_info(p) for p in (p1, p2)]

def f1(seq):    passdef f2(seq):    passdef f(seq):    if len(seq) >= threshold_value:    # 大于某个阈值        f1(seq)    # 在数量较多时候具有良好的效率    else:        f2(seq)

from cowpy import cowdef dots_style(msg):    msg = msg.capitalize()    msg = '.' * 10 + msg + '.' * 10    return msgdef admire_style(msg):    msg = msg.upper()    return '!'.join(msg)def cow_style(msg):    msg = cow.milk_random_cow(msg)    return msgdef generate_banner(msg, style=dots_style):    print('-- start of banner --')    print(style(msg))    print('-- end of banner --\n\n')def main():    msg = 'happy coding'    [generate_banner(msg, style) for style in (dots_style, admire_style,                                            cow_style)]if __name__ == "__main__":    main()"""-- start of banner --..........Happy coding..........-- end of banner ---- start of banner --H!A!P!P!Y! !C!O!D!I!N!G-- end of banner ---- start of banner --______________< happy coding >--------------    o    o    ^__^         /    (**)\_______/  _________    (__)\       )=(  ____|_ \_____U    ||----w |  \ \     \_____ |        ||     ||   ||           ||-- end of banner --"""

# some module.pyclass SingletonClass:    pass# 在别处我们想用这个实例都直接使用 module.single_instance 这个实例就好。# 这是最简单也是最直观的一种方式,嗯，直接导入这个实例用，而不是导入class，简单粗暴single_instance = SingletonClass()

# http://stackoverflow.com/questions/6760685/creating-a-singleton-in-pythonclass BaseClass:    pass# 装饰器实现def singleton(class_):    instances = {}    def getinstance(*args, **kwargs):        if class_ not in instances:            instances[class_] = class_(*args, **kwargs)        return instances[class_]    return getinstance@singletonclass MyClass(BaseClass):    passclass Singleton(object):    _instance = None    def __new__(class_, *args, **kwargs):        if not isinstance(class_._instance, class_):            class_._instance = object.__new__(class_, *args, **kwargs)        return class_._instanceclass MyClass(Singleton, BaseClass):pass# 元类实现class Singleton(type):    _instances = {}    def __call__(cls, *args, **kwargs):        if cls not in cls._instances:            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)        return cls._instances[cls]# Python2class MyClass(BaseClass):    __metaclass__ = Singleton# Python3class MyClass(BaseClass, metaclass=Singleton):    pass

# 为了实现这两个特性，我们可以这么写class Base:    def foo(self):        raise NotImplementedError()    def bar(self):        raise NotImplementedError()class Concrete(Base):    def foo(self):        return 'foo() called'    # Oh no, we forgot to override bar()...    # def bar(self):    #     return "bar() called"

from abc import ABCMeta, abstractmethodclass Base(metaclass=ABCMeta):    @abstractmethod    def foo(self):        pass    @abstractmethod    def bar(self):        passclass Concrete(Base):    def foo(self):        pass    # We forget to declare bar() again...