文章目录

  • 1. 创建型模式
    • 1.1. 工厂模式
    • 1.2. 抽象工厂模式
    • 1.3. 建造者模式
    • 1.4. 原型模式
  • 2. 结构型模式
    • 2.1. 外观模式
    • 2.2. 装饰器模式
    • 2.3. 代理模式
    • 2.4. 控制器模式
    • 2.5. 享元模式
    • 2.6. 适配器模式
  • 3. 行为型模式
    • 3.1. 观察者模式
    • 3.2. 命令模式
    • 3.3. 解释器模式
    • 3.4. 责任链模式
    • 3.5. 状态(机)模式
    • 3.6. 策略模式
    • 3.7. 模板模式

1. 创建型模式

1.1. 工厂模式

  • 解释：

    • 工厂方法(Factory Method)，它是一个方法(或以地道的Python术语来说，是一个函数)，对不同的输入参数返回不同的对象
    • 如果因为应用创建对象的代码分布在多个不同的地方，而不是仅在一个函数/方法中，你发 现没法跟踪这些对象，那么应该考虑使用工厂方法模式。工厂方法集中地在一个地方创建对象，使对象跟踪变得更容易。
    • 有工厂函数决定到底使用哪个类
  • 例子： 
    import xml.etree.ElementTree as etree
import json# JSONConnector类解析JSON文件，通过parsed_data()方法以一个字典(dict)的形式 返回数据。
# 修饰器property使parsed_data()显得更像一个常规的变量，而不是一个方法
class JSONConnector:def __init__(self, filepath):self.data = dict()with open(filepath, mode='r', encoding='utf-8') as f:self.data = json.load(f)@propertydef parsed_data(self):return self.data# XMLConnector类解析xml数据
class XMLConnector:def __init__(self, filepath):self.tree = etree.parse(filepath)@propertydef parsed_data(self):return self.tree# 函数connection_factory是一个工厂方法，
# 基于输入文件路径的扩展名返回一个JSONConnector或XMLConnector的实例
def connection_factory(filepath):if filepath.endswith('json'):connector = JSONConnectorelif filepath.endswith('xml'):connector = XMLConnectorelse:raise ValueError('Cannot connect to {}'.format(filepath))return connector(filepath)# 函数connect_to()对connection_factory()进行包装，添加了异常处理
def connect_to(filepath):factory = Nonetry:factory = connection_factory(filepath)except ValueError as ve:print(ve)return factory# 注意，虽然JSONConnector和XMLConnector拥有相同的接口，
# 但是对于parsed_data() 返回的数据并不是以统一的方式进行处理。
# 对于每个连接器，需使用不同的Python代码来处理。
def main():sqlite_factory = connect_to('data/person.sq3')print()xml_factory = connect_to('data/person.xml')xml_data = xml_factory.parsed_dataliars = xml_data.findall(".//{}[{}='{}']".format('person','lastName', 'Liar'))print('found: {} persons'.format(len(liars)))for liar in liars:print('first name: {}'.format(liar.find('firstName').text))print('last name: {}'.format(liar.find('lastName').text))[print('phone number ({})'.format(p.attrib['type']),p.text) for p in liar.find('phoneNumbers')]print()json_factory = connect_to('data/donut.json')json_data = json_factory.parsed_dataprint('found: {} donuts'.format(len(json_data)))for donut in json_data:print('name: {}'.format(donut['name']))print('price: ${}'.format(donut['ppu']))[print('topping: {} {}'.format(t['id'], t['type'])) for t in donut['topping']]if __name__ == '__main__':main()

1.2. 抽象工厂模式

  • 解释：

    • 一个抽象工厂是(逻辑上的)一组工厂方法，其中的每个工厂方法负责产生不同种类的对象
    • 通常一开始时使用工厂方法，因为它更简单。如果后来发现应用需要许多工厂方法，那么将创建 一系列对象的过程合并在一起更合理，从而最终引入抽象工厂。
    • 抽象出一个工厂类来处理所有后端类，由一个入口，决定是使用后端的哪个类
  • 例子： 
    # Frog青蛙碰到Bug虫子，就吃掉它
class Frog:def __init__(self, name):self.name = namedef __str__(self):return self.name# 这里模拟Frog和Bug类之间的交互def interact_with(self, obstacle):print('{} the Frog encounters {} and {}!'.format(self,obstacle, obstacle.action()))class Bug:def __str__(self):return 'a bug'def action(self):return 'eats it'# 类FrogWorld是一个抽象工厂，其主要职责是创建游戏的主人公和障碍物。
# 区分创建方法并使其名字通用(比如，make_character()和make_obstacle())，
# 这让我们可以动态改变当前激活的工厂(也因此改变了当前激活的游戏)，而无需进行任何代码变更。
class FrogWorld:def __init__(self, name):print(self)self.player_name = namedef __str__(self):return '\n\n\t------ Frog World ———'def make_character(self):return Frog(self.player_name)def make_obstacle(self):return Bug()# 男巫类Wizard
class Wizard:def __init__(self, name):self.name = namedef __str__(self):return self.name# 男巫类Wizard和怪兽类Ork两者之间的交互def interact_with(self, obstacle):print('{} the Wizard battles against {} and {}!'.format(self, obstacle, obstacle.action()))# 怪兽类Ork
class Ork:def __str__(self):return 'an evil ork'def action(self):return 'kills it'# 抽象工厂，生成实例
class WizardWorld:def __init__(self, name):print(self)self.player_name = namedef __str__(self):return '\n\n\t------ Wizard World ———'def make_character(self):return Wizard(self.player_name)def make_obstacle(self):return Ork()# 类GameEnvironment是我们游戏的主入口。它接受factory作为输入，
# 用其创建游戏的世界。方法play()则会启动hero和obstacle之间的交互
class GameEnvironment:def __init__(self, factory):self.hero = factory.make_character()self.obstacle = factory.make_obstacle()def play(self):self.hero.interact_with(self.obstacle)# 函数validate_age()提示用户提供一个有效的年龄。如果年龄无效，则会返回一个元组， 其第一个元素设置为False。
# 如果年龄没问题，元素的第一个元素则设置为True，但我们真正关 心的是元素的第二个元素，也就是用户提供的年龄，
def validate_age(name):try:age = input('Welcome {}. How old are you? '.format(name))age = int(age)except ValueError as err:print("Age {} is invalid, please try \again…".format(age))return (False, age)return (True, age)# 该函数请求用户的姓名和年龄，并根据用户的年龄决定该玩 哪个游戏
def main():name = input("Hello. What's your name? ")valid_input = Falsewhile not valid_input:valid_input, age = validate_age(name)game = FrogWorld if age < 18 else WizardWorldenvironment = GameEnvironment(game(name))environment.play()if __name__ == '__main__':main()

1.3. 建造者模式

  • 解释

    • 创建一个由多个部分构成的对象，而且它的构成需要一步接一步地完成。 只有当各个部分都创建好，这个对象才算是完整的。这正是建造者设计模式(Builder design pattern)的用武之地。
    • 建造者模式将一个复杂对象的构造过程与其表现分离，这样，同一个构造 过程可用于创建多个不同的表现
    • 有建造者和指挥者
  • 例1——配置电脑： 
    # coding: utf-8class Computer:def __init__(self, serial_number):self.serial = serial_numberself.memory = None      # 单位为GBself.hdd = None         # 单位为GBself.gpu = Nonedef __str__(self):info = ('Memory: {}GB'.format(self.memory),'Hard Disk: {}GB'.format(self.hdd),'Graphics Card: {}'.format(self.gpu))return '\n'.join(info)# 引入了一个建造者ComputerBuilder、一个指挥者HardwareEngineer
# 以及一步接一步装配一台电脑的过程，这样现在就支持不同的配置了
class ComputerBuilder:def __init__(self):self.computer = Computer('AG23385193')def configure_memory(self, amount):self.computer.memory = amountdef configure_hdd(self, amount):self.computer.hdd = amountdef configure_gpu(self, gpu_model):self.computer.gpu = gpu_modelclass HardwareEngineer:def __init__(self):self.builder = Nonedef 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))]@propertydef computer(self):return self.builder.computerdef main():engineer = HardwareEngineer()engineer.construct_computer(hdd=500, memory=8, gpu='GeForce GTX 650 Ti')computer = engineer.computerprint(computer)if __name__ == '__main__':main()
  • 例2——烤面包： 
    # coding: utf-8from enum import Enum  # 枚举
import timePizzaProgress = Enum('PizzaProgress', 'queued preparation baking ready') # 准备阶段
PizzaDough = Enum('PizzaDough', 'thin thick') # 生面团
PizzaSauce = Enum('PizzaSauce', 'tomato creme_fraiche') # 调味料
PizzaTopping = Enum('PizzaTopping', 'mozzarella double_mozzarella bacon ham mushrooms red_onion oregano') # 配料
STEP_DELAY = 3          # 考虑是示例，单位为秒class Pizza:def __init__(self, name):self.name = nameself.dough = Noneself.sauce = Noneself.topping = []def __str__(self):return self.name# 这个本来不用放在这里的，但是生面团都一样，因此这里提高代码利用率放在这里def prepare_dough(self, dough):self.dough = doughprint('preparing the {} dough of your {}...'.format(self.dough.name, self))time.sleep(STEP_DELAY)print('done with the {} dough'.format(self.dough.name))# 建造者：制作玛格丽特比萨(MargaritaBudiler)，
class MargaritaBuilder:def __init__(self):self.pizza = Pizza('margarita')self.progress = PizzaProgress.queuedself.baking_time = 5        # 考虑是示例，单位为秒def prepare_dough(self):self.progress = PizzaProgress.preparationself.pizza.prepare_dough(PizzaDough.thin)def add_sauce(self):print('adding the tomato sauce to your margarita...')self.pizza.sauce = PizzaSauce.tomatotime.sleep(STEP_DELAY)print('done with the tomato sauce')def add_topping(self):print('adding the topping (double mozzarella, oregano) to your margarita')self.pizza.topping.append([i for i in(PizzaTopping.double_mozzarella, PizzaTopping.oregano)])time.sleep(STEP_DELAY)print('done with the topping (double mozzarrella, oregano)')def bake(self):self.progress = PizzaProgress.bakingprint('baking your margarita for {} seconds'.format(self.baking_time))time.sleep(self.baking_time)self.progress = PizzaProgress.readyprint('your margarita is ready')# 建造者：制作奶油熏肉比萨(CreamyBaconBuilder)。
class CreamyBaconBuilder:def __init__(self):self.pizza = Pizza('creamy bacon')self.progress = PizzaProgress.queuedself.baking_time = 7        # 考虑是示例，单位为秒def prepare_dough(self):self.progress = PizzaProgress.preparationself.pizza.prepare_dough(PizzaDough.thick)def add_sauce(self):print('adding the crème fraîche sauce to your creamy bacon')self.pizza.sauce = PizzaSauce.creme_fraichetime.sleep(STEP_DELAY)print('done with the crème fraîche sauce')def add_topping(self):print('adding the topping (mozzarella, bacon, ham, mushrooms, red onion, oregano) to your creamy bacon')self.pizza.topping.append([t for t in(PizzaTopping.mozzarella, PizzaTopping.bacon,PizzaTopping.ham, PizzaTopping.mushrooms,PizzaTopping.red_onion, PizzaTopping.oregano)])time.sleep(STEP_DELAY)print('done with the topping (mozzarella, bacon, ham, mushrooms, red onion, oregano)')def bake(self):self.progress = PizzaProgress.bakingprint('baking your creamy bacon for {} seconds'.format(self.baking_time))time.sleep(self.baking_time)self.progress = PizzaProgress.readyprint('your creamy bacon is ready')# 指挥者就是服务员。Waiter类的核心是construct_pizza方法，
# 该方法接受一个建造者作为参数，并以正确的顺序执行比萨的所有准备步骤。
class Waiter:def __init__(self):self.builder = Nonedef construct_pizza(self, builder):self.builder = builder[step() for step in (builder.prepare_dough,builder.add_sauce, builder.add_topping, builder.bake)]@propertydef pizza(self):return self.builder.pizza# 函数validate_style()类似于第1章中描述的validate_age()函数，用于确保用户提供有效的输入，
# 当前案例中这个输入是映射到一个比萨建造者的字符;输入字符m表示使用 MargaritaBuilder类，
# 输入字符c则使用CreamyBaconBuilder类。
# 这些映射关系存储在参数 builder中。该函数会返回一个元组，如果输入有效，则元组的第一个元素被设置为True，否则为False，
def validate_style(builders):try:pizza_style = input('What pizza would you like, [m]argarita or [c]reamy bacon? ')builder = builders[pizza_style]()valid_input = Trueexcept KeyError as err:print('Sorry, only margarita (key m) and creamy bacon (key c) are available')return (False, None)return (True, builder)def main():builders = dict(m=MargaritaBuilder, c=CreamyBaconBuilder)valid_input = Falsewhile not valid_input:valid_input, builder = validate_style(builders)print()waiter = Waiter()waiter.construct_pizza(builder)pizza = waiter.pizzaprint()print('Enjoy your {}!'.format(pizza))if __name__ == '__main__':main()
  • 例3——流利的建造者：
    • 建造者模式变体，链式地调用建造者方法，通过将建造者本身定义为内部类并从其每个设置器方法返回自身来实现。方法build()返回最终的对象。这个模式被称为流利的建造者。
    • 代码： 
      # coding: utf-8class Pizza:def __init__(self, builder):self.garlic = builder.garlicself.extra_cheese = builder.extra_cheesedef __str__(self):garlic = 'yes' if self.garlic else 'no'cheese = 'yes' if self.extra_cheese else 'no'info = ('Garlic: {}'.format(garlic), 'Extra cheese: {}'.format(cheese))return '\n'.join(info)class PizzaBuilder:def __init__(self):self.extra_cheese = Falseself.garlic = Falsedef add_garlic(self):self.garlic = Truereturn selfdef add_extra_cheese(self):self.extra_cheese = Truereturn selfdef build(self):return Pizza(self)if __name__ == '__main__':pizza = Pizza.PizzaBuilder().add_garlic().add_extra_cheese().build()print(pizza)

1.4. 原型模式

  • 解释：

    • 原型设计模式(Prototype design pattern)帮助我们创建对象的克隆，其最简单的形式就是一 个clone()函数，接受一个对象作为输入参数，返回输入对象的一个副本。
    • 在我 们知道对象的某些部分会被变更但又希望保持原有对象不变之时，通常需要对象的一个副本。
  • 例子——书的描述： 
    # coding: utf-8import copy
from collections import OrderedDictclass Book:# 仅有三个形参是固定的:name、authors和price，# v但是使用rest变长列表，调用者 能以关键词的形式(名称=值)传入更多的参数。# self.__dict__.update(rest)一行将rest 的内容添加到Book类的内部字典中，成为它的一部分。def __init__(self, name, authors, price, **rest):'''rest的例子有：出版商，长度，标签，出版日期'''self.name = nameself.authors = authorsself.price = price      # 单位为美元self.__dict__.update(rest)# 我们并不知道所有被添加参数的名称，但又需要访问内部字典将这些参数应用到__str__()中，# 并且字典的内容并不遵循任何特定的顺序，所以使用一个OrderedDict来强制元素有序，# 否则，每次程序执行都会产生不同的输出。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)# Prototype类实现了原型设计模式。Prototype类的核心是clone()方法，该方法使用我们 熟悉的copy.deepcopy()函数来完成真正的克隆工作。
# 但Prototype类在支持克隆之外做了一点更多的事情，它包含了方法register()和unregister()，这两个方法用于在一个字典中追 踪被克隆的对象。
class Prototype:def __init__(self):self.objects = dict()def register(self, identifier, obj):self.objects[identifier] = objdef 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)))if __name__ == '__main__':main()

2. 结构型模式

简便记忆：外观（装饰器）代理（控制器）享元（适配器）

2.1. 外观模式

  • 解释

    • 外观设计模式有助于隐藏 系统的内部复杂性，并通过一个简化的接口向客户端暴露必要的部分
    • 使用外观模式的最常见理由是为一个复杂系统提供单个简单的入口点。引入外观之后，客户端代码通过简单地调用一个方法/函数就能使用一个系统。同时，内部系统并不会丢失任何功能，外观只是封装了内部系统。
  • 例子 
    # coding: utf-8from enum import Enum
from abc import ABCMeta, abstractmethodState = Enum('State', 'new running sleeping restart zombie')class User:passclass Process:passclass File:passclass Server(metaclass=ABCMeta):@abstractmethoddef __init__(self):passdef __str__(self):return self.name@abstractmethoddef boot(self):pass@abstractmethoddef kill(self, restart=True):passclass FileServer(Server):def __init__(self):'''初始化文件服务进程要求的操作'''self.name = 'FileServer'self.state = State.newdef boot(self):print('booting the {}'.format(self))'''启动文件服务进程要求的操作'''self.state = State.runningdef kill(self, restart=True):print('Killing {}'.format(self))'''杀死文件服务进程要求的操作'''self.state = State.restart if restart else State.zombiedef create_file(self, user, name, permissions):'''检查访问权限的有效性、用户权限，等等'''print("trying to create the file '{}' for user '{}' with permissions {}".format(name, user, permissions))class ProcessServer(Server):def __init__(self):'''初始化进程服务进程要求的操作'''self.name = 'ProcessServer'self.state = State.newdef boot(self):print('booting the {}'.format(self))'''启动进程服务进程要求的操作'''self.state = State.runningdef kill(self, restart=True):print('Killing {}'.format(self))'''杀死进程服务进程要求的操作'''self.state = State.restart if restart else State.zombiedef create_process(self, user, name):'''检查用户权限、生成PID，等等'''print("trying to create the process '{}' for user '{}'".format(name, user))class WindowServer:passclass NetworkServer:passclass 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')if __name__ == '__main__':main()

2.2. 装饰器模式

  • 解释

    • 一个Python修饰器就是对Python语 法的一个特定改变，用于扩展一个类、方法或函数的行为，而无需使用继承。
  • 引入： 
    ## 1、直接使用递归，函数执行时间
def fibonacci(n):assert(n >= 0), 'n must be >= 0'return n if n in (0, 1) else fibonacci(n-1) + fibonacci(n-2)if __name__ == '__main__':from timeit import Timert = Timer('fibonacci(8)', 'from __main__ import fibonacci')print(t.timeit())
# 结果16s多## 使用dict缓存计算结果
known = {0:0, 1:1}
def fibonacci(n):assert(n >= 0), 'n must be >= 0'if n in known:return known[n]res = fibonacci(n-1) + fibonacci(n-2)known[n] = resreturn resif __name__ == '__main__':from timeit import Timert = Timer('fibonacci(100)', 'from __main__ import fibonacci')print(t.timeit())
# 结果：0.3s多## 使用装饰器# 函数functools.wraps() 是一个为创建修饰器提供便利的函数;虽不强制，但推荐使用，
# 因为它能保留被修饰函数的文档和签名。这种情况要求参数列表*args，因为被修饰的函数可能有 输入参数。
import functools
def memoize(fn):known = dict()@functools.wraps(fn)def memoizer(*args):if args not in known:known[args] = fn(*args)return known[args]return memoizer
  • 例子： 
    # coding: utf-8import functoolsdef memoize(fn):known = dict()@functools.wraps(fn)def memoizer(*args):if args not in known:known[args] = fn(*args)return known[args]return memoizer@memoize
def nsum(n):'''返回前n个数字的和'''assert(n >= 0), 'n must be >= 0'return 0 if n == 0 else n + nsum(n-1)@memoize
def fibonacci(n):'''返回斐波那契数列的第n个数'''assert(n >= 0), 'n must be >= 0'return n if n in (0, 1) else fibonacci(n-1) + fibonacci(n-2)if __name__ == '__main__':from timeit import Timermeasure = [{'exec': 'fibonacci(100)', 'import': 'fibonacci','func': fibonacci}, {'exec': 'nsum(200)', 'import': 'nsum','func': nsum}]for m in measure:t = Timer('{}'.format(m['exec']), 'from __main__ import \{}'.format(m['import']))print('name: {}, doc: {}, executing: {}, time: \{}'.format(m['func'].__name__, m['func'].__doc__,m['exec'], t.timeit()))

2.3. 代理模式

  • 解释：

    • 远程代理：实际存在于不同地址空间（例如，某个网络服务器）的对象在本地的代理者。
    • 虚拟代理：用于懒初始化，将一个大计算量对象的创建延迟到真正需要的时候进行。
    • 保护/防护代理：控制对敏感对象的访问。
    • 智能（引用）代理：在对象被访问时执行额外的动作。此类代理的例子包括引用计数和
      线程安全检查。
  • 代码一：懒初始化 
    # coding: utf-8"""
LazyProperty类实际上是一个描述符（请参考网页［t.cn/RqrYBND］）。描述符（descriptor）
是Python中重写类属性访问方法（__get__()、__set__()和__delete__()）的默认行为要使
用的一种推荐机制。LazyProperty类仅重写了__set__()，因为这是其需要重写的唯一访问方
法。换句话说，我们无需重写所有访问方法。__get__()方法所访问的特性值，正是下层方法想
要赋的值，并使用setattr()来手动赋值。__get__()实际做的事情非常简单，就是使用值来
替代方法！这意味着不仅特性是惰性加载的，而且仅可以设置一次。
"""class LazyProperty:def __init__(self, method):self.method = methodself.method_name = method.__name__# print('function overriden: {}'.format(self.method))# print("function's name: {}".format(self.method_name))def __get__(self, obj, cls):if not obj:return Nonevalue = self.method(obj) # 获取obj对象的method属性的值么？# 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@LazyPropertydef 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)# 做更多的事情。。。print(t.resource)print(t.resource)if __name__ == '__main__':main()
  • python文件描述器（有些书中是文件描述符）
    • 参考：https://blog.csdn.net/hsc_1/article/details/81027546
class A:def __init__(self, val):self.val = valdef __get__(self, instance, owner):print('self is ', self)print('instance is ', instance)print('owner is ', owner)return self.valclass B:a = A(10)b = B()
print(b.a)# descriptor
#     一个类中定义了__set__, __get__和__delete__中的一个或多个就是descriptor。
#     __get__函数定义的时候需要的参数为三个，分别为self, instance, owner。
#     __set__函数定义的时候需要的参数为三个，分别是self, instance, value。# 理解了下面的一句话就理解了文件描述器的实质：
# self很简单，就是descriptor的实例；
# instance就是descriptor所在类中的实例；
# owner指的是descriptor所在的类。# 还可以看出来的是，打印的b.a不是一个是实例对象，而是通过调用a.__get__()函数返回的值。# 所以我感觉这个descriptor叫做描述器(借鉴于decorator)似乎更合适。。。# 因为这个descriptor似乎是用来描述所在的实例的。。。# 总结：通过实例调用(b.a)这个descriptor对象，返回的并不是这个descriptor(你可以尝试打印一个实例对象，
# 看看返回的是什么)，而是该descriptor调用__get__返回的值，所以这个a像是b的描述器。class LazyProperty(object):def __init__(self, func):self.func = funcdef __get__(self, instance, owner):if instance is None:return selfelse:value = self.func(instance)setattr(instance, self.func.__name__, value)return valueclass A:@LazyPropertydef func(self):time.sleep(1)return 10
  • 代码二：

    # coding: utf-8"""
查看用户列表：这一操作不要求特殊权限。
添加新用户：这一操作要求客户端提供一个特殊的密码。
"""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:'''SensitiveInfo的保护代理'''def __init__(self):self.protected = SensitiveInfo()self.secret = '0xdeadbeef'def read(self):self.protected.read()def add(self, user):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))if __name__ == '__main__':main()

2.4. 控制器模式

  • 全称：模型-视图-控制器模式
  • 解释：
    • 关注点分离（Separation of Concerns，SoC）原则是软件工程相关的设计原则之一。SoC原则背后的思想是将一个应用切分成不同的部分，每个部分解决一个单独的关注点。分层设计中的层次（数据访问层、业务逻辑层和表示层等）即是关注点的例子。
  • 代码 
    """
用户输入一个数字，然后就能看到与这个数字相关的名人名言。
名人名言存储在一个quotes元组中。这种数据通常是存储在数据库、文件或其他地方，
只有模型能够直接访问它。
"""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:value = quotes[n]except IndexError as err:value = 'Not found!'return valueclass 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 = Falsewhile not valid_input:n = self.view.select_quote()try:n = int(n)except ValueError as err:self.view.error("Incorrect index '{}'".format(n))else:valid_input = Truequote = self.model.get_quote(n)self.view.show(quote)def main():controller = QuoteTerminalController()while True:controller.run()if __name__ == '__main__':main()

2.5. 享元模式

  • 解释：

    • 享元设计模式通过为相似对象引入数据共享来最小化内存使用，提升性能
    • 一个享元（Flyweight）就是一个包含状态独立的不可变（又称固有的）数据的共享对象。依赖状态的可变（又称非固有的）数据不应是享元的一部分，因为每个对象的这种信息都不同，无法共享。如果享元需要非固有的数据，应该由客户端代码显式地提供
    • 比如：假设我们正在设计一个性能关键的游戏，例如第一人称射击（First-Person Shooter，FPS）游戏。在FPS游戏中，玩家（士兵）共享一些状态，如外在表现和行为。例如，在《反恐精英》游戏中，同一团队（反恐精英或恐怖分子）的所有士兵看起来都是一样的（外在表现）。同一个游戏中，（两个团队的）所有士兵都有一些共同的动作，比如，跳起、低头等（行为）。这意味着我们可以创建一个享元来包含所有共同的数据。当然，士兵也有许多因人而异的可变数据，这些数据不是享元的一部分，比如，枪支、健康状况和地理位置等。
  • 条件
    • 应用需要使用大量的对象。
    • 对象太多，存储/渲染它们的代价太大。一旦移除对象中的可变状态（因为在需要之时，应该由客户端代码显式地传递给享元），多组不同的对象可被相对更少的共享对象所替代。
    • 对象ID对于应用不重要。对象共享会造成ID比较的失败，所以不能依赖对象ID（那些在客户端代码看来不同的对象，最终具有相同的ID）。
  • 代码 
    # coding: utf-8
"""
构造一小片水果树的森林，小到能确保在单个终端页面中阅读整个输出。
然而，无论你构造的森林有多大，内存分配都保持相同。
"""import random
from enum import Enum# 枚举
TreeType = Enum('TreeType', 'apple_tree cherry_tree peach_tree')class Tree:# pool是一个类属性（类的所有实例共享的一个变量），（换句话说，是我们的缓存）pool = dict()# 使用特殊方法__new__（这个方法在__init__之前被调用），# 我们把Tree类变换成一个元类，元类支持自引用。这意味着cls引用的是Tree类。# 当客户端要创建Tree的一个实例时，会以tree_type参数传递树的种类。# 树的种类用于检查是否创建过相同种类的树。如果是，则返回之前创建的对象；# 否则，将这个新的树种添加到池中，并返回相应的新对象def __new__(cls, tree_type):obj = cls.pool.get(tree_type, None)if not obj:obj = object.__new__(cls)  # 实例化，对象.方法（类）cls.pool[tree_type] = obj  # 将对象加入类的pool中obj.tree_type = tree_type  # 设置对象的属性return obj# 元类编程中obj是本类实例化的对象# cls是类# 方法render()用于在屏幕上渲染一棵树。注意，享元不知道的所有可变（外部的）信息都需要由客户端代码显式地传递。# 在当前案例中，每棵树都用到一个随机的年龄和一个x, y形式的位置。# 为了让render()更加有用，有必要确保没有树会被渲染到另一个棵之上。def render(self, age, x, y):print('render a tree of type {} and age {} at ({}, {})'.format(self.tree_type, age, x, y))# main()函数展示了我们可以如何使用享元模式。一棵树的年龄是1到30年之间的一个随机值。
# 坐标使用1到100之间的随机值。虽然渲染了18棵树，但仅分配了3棵树的内存。
# 输出的最后一行证明当使用享元时，我们不能依赖对象的ID。函数id()会返回对象的内存地址。
# Python规范并没有要求id()返回对象的内存地址，只是要求id()为每个对象返回一个唯一性ID，
# 不过CPython（Python的官方实现）正好使用对象的内存地址作为对象唯一性ID。
# 在我们的例子中，即使两个对象看起来不相同，但是如果它们属于同一个享元家族（在这里，家族由tree_type定义），那么它们实际上有相同的ID。
# 当然，不同ID的比较仍然可用于不同家族的对象，但这仅在客户端知道实现细节的情况下才可行（通常并非如此）。
def main():rnd = random.Random()age_min, age_max = 1, 30    # 单位为年min_point, max_point = 0, 100tree_counter = 0for _ 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 += 1for _ 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 += 1for _ 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 += 1print('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()

2.6. 适配器模式

  • 解释：

    • 适配器模式(Adapter pattern)是一种结构型设计模式，帮助我们实现两个不兼容接口之间的兼容。
    • 如果我们希望把一个老组件用于一个新系统中， 或者把一个新组件用于一个老系统中，不对代码进行任何修改两者就能够通信的情况很少见。但 又并非总是能修改代码，或因为我们无法访问这些代码(例如，组件以外部库的方式提供)，或 因为修改代码本身就不切实际。在这些情况下，我们可以编写一个额外的代码层，该代码层包含 让两个接口之间能够通信需要进行的所有修改。这个代码层就叫适配器。
  • 例子： 
    # 外部模块：external.py
class Synthesizer:def __init__(self, name):self.name = namedef __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 = namedef __str__(self):return '{} the human'.format(self.name)def speak(self):return 'says hello'# 自己的代码adapter.py
from external import Synthesizer, Humanclass Computer:def __init__(self, name):self.name = namedef __str__(self):return 'the {} computer'.format(self.name)def execute(self):return 'executes a program'# 客户端仅知道如何调用execute()方法，并不知道play() 4 和speak()。
# 在不改变Synthesizer和Human类的前提下，我们该如何做才能让代码有效?适配器是救星!
# 我们创建一个通用的Adapter类，将一些带不同接口的对象适配到一个统一接口中。
# __init__()方法的obj参数是我们想要适配的对象，adapted_methods是一个字典，键值对中的键是客户端要调用的方法，值是应该被调用的方法。
class Adapter:def __init__(self, obj, adapted_methods):self.obj = objself.__dict__.update(adapted_methods)def __str__(self):return str(self.obj)def 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()))if __name__ == "__main__":main()

3. 行为型模式

简便记忆：观察者命令解释器将责任链、状态机做成策略模板

3.1. 观察者模式

  • 说明

    • 观察者模式描述单个对象（发布者，又称为主持者或可观察者）与一个或多个对象（订阅者，又称为观察者）之间的发布—订阅关系。
    • 发布者发生了改变，会通知订阅者
  • 代码 
    # 基类Publisher，包括添加、删除及通知观察者这些公用功能。
# 观察者们保存在列表observers中。add()方法注册一个新的观察者，或者在该观察者已存在时引发一个错误。
# remove()方法注销一个已有观察者，或者在该观察者尚未存在时引发一个错误。
# 最后，notify()方法则在变化发生时通知所有观察者。
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.exec(self) for o in self.observers]# efaultFormatter类继承自Publisher，并添加格式化程序特定的功能。
class DefaultFormatter(Publisher):# __init__()做的第一件事情就是调用基类的__init__()方法# DefaultFormatter实例有自己的名字，这样便于我们跟踪其状态。def __init__(self, name):Publisher.__init__(self)self.name = nameself._data = 0# __str__()方法返回关于发布者名称和_data值的信息。# type(self).__name是一种获取类名的方便技巧，避免硬编码类名。def __str__(self):return "{}: '{}' has data = {}".format(type(self).__name__, self.name, self._data)# @property修饰器来提供_data变量的读访问方式。这样，我们就能使用object.data来替代object.data()。@propertydef data(self):return self._data# @setter该修饰器会在每次使用赋值操作符（=）为_data变量赋新值时被调用。@data.setterdef data(self, new_value):try:self._data = int(new_value)except ValueError as e:print('Error: {}'.format(e))else:self.notify()# 两个观察者：HexFormatter和BinaryFormatter的功能非常相似。
# 唯一的不同在于如何格式化从发布者那获取到的数据值，即分别以十六进制和二进制进行格式化。
class HexFormatter:def exec(self, publisher):print("{}: '{}' has now hex data = {}".format(type(self).__name__,publisher.name, hex(publisher.data)))class BinaryFormatter:def exec(self, publisher):print("{}: '{}' has now bin data = {}".format(type(self).__name__,publisher.name, bin(publisher.data)))def main():df = DefaultFormatter('test1')print(df)print()hf = HexFormatter()df.add(hf)df.data = 3print(df)print()bf = BinaryFormatter()df.add(bf)df.data = 21print(df)print()df.remove(hf)df.data = 40print(df)print()df.remove(hf)df.add(bf)df.data = 'hello'print(df)print()df.data = 15.8print(df)if __name__ == '__main__':main()

3.2. 命令模式

  • 说明

    • 支持撤销操作
  • 代码 
    import osverbose = True# 文件改名
class RenameFile:def __init__(self, path_src, path_dest):self.src, self.dest = path_src, path_destdef execute(self):if verbose:print("[renaming '{}' to '{}']".format(self.src, self.dest))os.rename(self.src, self.dest)def undo(self):if verbose:print("[renaming '{}' back to '{}']".format(self.dest, self.src))os.rename(self.dest, self.src)# 创建文件
class CreateFile:def __init__(self, path, txt='hello world\n'):self.path, self.txt = path, txtdef execute(self):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 = pathdef execute(self):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 delete_file(path):if verbose:print("deleting file '{}'".format(path))os.remove(path)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()except AttributeError as e:passif __name__ == '__main__':main()

3.3. 解释器模式

  • 说明

    • 解释器模式背后的主要思想是让非初级用户和领域专家使用一门简单的语言来表达想法
    • 个人更建议使用yaml格式来解析
  • 代码 
    # coding: utf-8"""
创建一种内部DSL控制一个智能屋
一个事件的形式为command -> receiver -> arguments。参数部分是可选的。
并不是所有事件都要求参数。不要求任何参数的事件例子如下所示。
open -> gate
->符号用于标记事件一个部分的结束，并声明下一个部分的开始。
Pyparsing是python中的一个模块使用巴科斯-诺尔形式（Backus-Naur Form，BNF）表示法来定义语法
event ::= command token receiver token arguments
command ::= word+
word ::= a collection of one or more alphanumeric characters
token ::= ->
receiver ::= word+
arguments ::= word+实际的代码：
word = Word(alphanums)
command = Group(OneOrMore(word))
token = Suppress("->")
device = Group(OneOrMore(word))
argument = Group(OneOrMore(word))
event = command + token + device + Optional(token + argument)
"""from pyparsing import Word, OneOrMore, Optional, Group, Suppress, alphanumsclass Gate:def __init__(self):self.is_open = Falsedef __str__(self):return 'open' if self.is_open else 'closed'def open(self):print('opening the gate')self.is_open = Truedef close(self):print('closing the gate')self.is_open = Falseclass Garage:def __init__(self):self.is_open = Falsedef __str__(self):return 'open' if self.is_open else 'closed'def open(self):print('opening the garage')self.is_open = Truedef close(self):print('closing the garage')self.is_open = Falseclass Aircondition:def __init__(self):self.is_on = Falsedef __str__(self):return 'on' if self.is_on else 'off'def turn_on(self):print('turning on the aircondition')self.is_on = Truedef turn_off(self):print('turning off the aircondition')self.is_on = Falseclass Heating:def __init__(self):self.is_on = Falsedef __str__(self):return 'on' if self.is_on else 'off'def turn_on(self):print('turning on the heating')self.is_on = Truedef turn_off(self):print('turning off the heating')self.is_on = Falseclass Boiler:def __init__(self):self.temperature = 83  # in celsiusdef __str__(self):return 'boiler temperature: {}'.format(self.temperature)def increase_temperature(self, amount):print("increasing the boiler's temperature by {} degrees".format(amount))self.temperature += amountdef decrease_temperature(self, amount):print("decreasing the boiler's temperature by {} degrees".format(amount))self.temperature -= amountclass Fridge:def __init__(self):self.temperature = 2  # 单位为摄氏度def __str__(self):return 'fridge temperature: {}'.format(self.temperature)def increase_temperature(self, amount):print("increasing the fridge's temperature by {} degrees".format(amount))self.temperature += amountdef decrease_temperature(self, amount):print("decreasing the fridge's temperature by {} degrees".format(amount))self.temperature -= amountdef main():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()garage = Garage()airco = Aircondition()heating = Heating()boiler = Boiler()fridge = Fridge()tests = ('open -> gate','close -> garage','turn on -> aircondition','turn off -> heating','increase -> boiler temperature -> 5 degrees','decrease -> fridge temperature -> 2 degrees')open_actions = {'gate': gate.open,'garage': garage.open,'aircondition': airco.turn_on,'heating': heating.turn_on,'boiler temperature': boiler.increase_temperature,'fridge temperature': fridge.increase_temperature}close_actions = {'gate': gate.close,'garage': garage.close,'aircondition': airco.turn_off,'heating': heating.turn_off,'boiler temperature': boiler.decrease_temperature,'fridge temperature': fridge.decrease_temperature}"""获取Pyparsing解析结果的最简单方式是使用parseString()方法，该方法返回的结果是一个ParseResults实例，它实际上是一个可视为嵌套列表的解析树。例如，执行print(event.parseString('increase -> boiler temperature -> 3 degrees'))得到的结果如下所示。[['increase'], ['boiler', 'temperature'], ['3', 'degrees']]"""for t in tests:if len(event.parseString(t)) == 2:  # 没有参数cmd, dev = event.parseString(t)cmd_str, dev_str = ' '.join(cmd), ' '.join(dev)if 'open' in cmd_str or 'turn on' in cmd_str:open_actions[dev_str]()elif 'close' in cmd_str or 'turn off' in cmd_str:close_actions[dev_str]()elif len(event.parseString(t)) == 3:  # 有参数cmd, dev, arg = event.parseString(t)cmd_str, dev_str, arg_str = ' '.join(cmd), ' '.join(dev), ' '.join(arg)num_arg = 0try:num_arg = int(arg_str.split()[0])  # 抽取数值部分except ValueError as err:print("expected number but got: '{}'".format(arg_str[0]))if 'increase' in cmd_str and num_arg > 0:open_actions[dev_str](num_arg)elif 'decrease' in cmd_str and num_arg > 0:close_actions[dev_str](num_arg)if __name__ == '__main__':main()

3.4. 责任链模式

  • 解释

    • (1) 存在一个对象链（链表、树或任何其他便捷的数据结构）。
    • (2) 我们一开始将请求发送给链中的第一个对象。
    • (3) 对象决定其是否要处理该请求。
    • (4) 对象将请求转发给下一个对象。
    • (5) 重复该过程，直到到达链尾。
  • 例子： 
    #!/usr/bin/python
#coding:utf8class Handler:def successor(self, successor):self.successor = successorclass ConcreteHandler1(Handler):def handle(self, request):if request > 0 and request <= 10:print("in handler1")else:self.successor.handle(request)class ConcreteHandler2(Handler):def handle(self, request):if request > 10 and request <= 20:print("in handler2")else:self.successor.handle(request)class ConcreteHandler3(Handler):def handle(self, request):if request > 20 and request <= 30:print("in handler3")else:print('end of chain, no handler for {}'.format(request))class Client:def __init__(self):h1 = ConcreteHandler1()h2 = ConcreteHandler2()h3 = ConcreteHandler3()h1.successor(h2)h2.successor(h3)requests = [2, 5, 14, 22, 18, 3, 35, 27, 20]for request in requests:h1.handle(request)if __name__ == "__main__":client = Client()

3.5. 状态(机)模式

  • 说明

    • 状态
    • 状态转换
    • 进程状态
  • 代码一：使用state_machine模块 
    from state_machine import State, Event, acts_as_state_machine, after, before, InvalidStateTransition@acts_as_state_machine
class Process:created = State(initial=True)waiting = State()running = State()terminated = State()blocked = State()swapped_out_waiting = State()swapped_out_blocked = State()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@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):try:event()except InvalidStateTransition as err: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))def 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)]if __name__ == '__main__':main()
  • 代码二：原生得实现 
    """
The state pattern allows us to change an object's behavior at runtime
— something that Python naturally excels at!
This example has a very simple radio. It has an AM/FM toggle switch,
and a scan button to scan to the next station.
"""class State(object):"""Base state. This is to share functionality"""def scan(self):"""Scan the dial to the next station"""self.pos += 1if self.pos == len(self.stations):self.pos = 0print "Scanning… Station is", self.stations[self.pos], self.nameclass AmState(State):def __init__(self, radio):self.radio = radioself.stations = ["1250", "1380", "1510"]self.pos = 0self.name = "AM"def toggle_amfm(self):print "Switching to FM"self.radio.state = self.radio.fmstateclass FmState(State):def __init__(self, radio):self.radio = radioself.stations = ["81.3", "89.1", "103.9"]self.pos = 0self.name = "FM"def toggle_amfm(self):print "Switching to AM"self.radio.state = self.radio.amstateclass Radio(object):"""A radio.It has a scan button, and an AM/FM toggle switch."""def __init__(self):"""We have an AM state and an FM state"""self.amstate = AmState(self)self.fmstate = FmState(self)self.state = self.amstatedef toggle_amfm(self):self.state.toggle_amfm()def scan(self):self.state.scan()# Test our radio out
radio = Radio()
actions = [radio.scan] * 2 + [radio.toggle_amfm] + [radio.scan] * 2
actions = actions * 2
for action in actions:action()
  • 参考监控系统中底层网路的架构代码

3.6. 策略模式

  • 说明

    • 根据不同的场景、特征或者变量里决定使用哪种策略
  • 代码 
    # coding: utf-8
# 检测一个字符串中所有的字符串是否都是唯一的import time
SLOW = 3  # 单位为秒
LIMIT = 5   # 字符数
WARNING = 'too bad, you picked the slow algorithm :('def pairs(seq):n = len(seq)for i in range(n):yield seq[i], seq[(i + 1) % n]# 方法一：排序，然后判断相邻两个元素是否相等
def allUniqueSort(s):if len(s) > LIMIT:print(WARNING)time.sleep(SLOW)srtStr = sorted(s)for (c1, c2) in pairs(srtStr):if c1 == c2:return Falsereturn True# 方法二：利用python中的集合来处理
def allUniqueSet(s):if len(s) < LIMIT:print(WARNING)time.sleep(SLOW)return True if len(set(s)) == len(s) else Falsedef allUnique(s, strategy):return strategy(s)def main():while True:word = Nonewhile not word:word = input('Insert word (type quit to exit)> ')if word == 'quit':print('bye')returnstrategy_picked = Nonestrategies = {'1': allUniqueSet, '2': allUniqueSort}while strategy_picked not in strategies.keys():strategy_picked = input('Choose strategy: [1] Use a set, [2] Sort and pair> ')try:strategy = strategies[strategy_picked]print('allUnique({}): {}'.format(word, allUnique(word, strategy)))except KeyError as err:print('Incorrect option: {}'.format(strategy_picked))if __name__ == '__main__':main()

3.7. 模板模式

  • 说明

    • 减少代码的冗余性
    • 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
  • 代码 
    """
将一段文本发送给一个函数，该函数要生成一个包含该文本的横幅。
横幅有多种风格，比如点或虚线围绕文本。横幅生成器有一个默认风格，
但应该能够使用我们自己提供的风格。
"""from cowpy import cowdef dots_style(msg):msg = msg.capitalize()msg = '.' * 10 + msg + '.' * 10return 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()

参考：
《精通python设计模式》
《二十三种设计模式及其python实现》

python常见几种设计模式相关推荐

  1. python实现23种设计模式

    本文源码寄方于github:https://github.com/w392807287/Design_pattern_of_python 参考文献: <大话设计模式>--吴强 <Py ...

  2. Python之23种设计模式

    目录篇: python相关目录篇 点击跳转 目录 设计模式介绍 GoF该书设计了23个设计模式 设计模式(Design Patterns)--可复用面向对象软件的基础 设计模式分类 1 创建型模式 2 ...

  3. 手写JavaScript常见5种设计模式

    想分享的几种设计模式 目前模式:工厂模式,单例模式,适配器模式,装饰者模式,建造者模式 建造者模式 简介:建造者模式(builder pattern)比较简单,它属于创建型模式的一种. 白话:4个部分 ...

  4. PHP常见三种设计模式：单例、工厂、观察者

    1.单例模式 目的:保证一个类仅有一个实例,并提供一个访问它的全局访问点. 应用场景:数据库连接.缓存操作.分布式存储. /*** 设计模式之单例模式* $_instance必须声明为静态的私有变量* ...

  5. 编程的常见28种设计模式（如若不全敬请谅解）

    1 写代码要考虑到如何让代码更加简练,更加容易维护,容易扩展和复用,如果觉得前面的内容太多,可以之间看30总结(最下方). 2 策略模式: 定义了算法家族,分别封装起来,让他们可以互相替换,此模式让算 ...

  6. Python的23种设计模式(完整版带源码实例)

    作者:虚坏叔叔 博客:https://xuhss.com 早餐店不会开到晚上,想吃的人早就来了!

  7. python算法基础设计模式,python常见的设计模式

    Python有设计模式么 Python设计模式主要分为三大类:创建型模式.结构型模式.行为型模式;三 大类中又被细分为23种设计模式,以下这几种是最常见的. 单例模式:是一种常用的软件设计模式,该模式 ...

  8. Python培训常识：Python面试中常被问到的几种设计模式要知道

    学习Python技术大家都是为了日后能够找到适合自己的工作岗位,那么除了要学习好Python技术外,对于面试环节的问题也要有所了解,本期小编为大家介绍的Python培训教程就算关于Python面试中常 ...

  9. 五种常见的PHP设计模式

    2019独角兽企业重金招聘Python工程师标准>>> 五种常见的PHP设计模式 设计模式 一书将设计模式引入软件社区,该书的作者是 Erich Gamma.Richard Helm ...

最新文章

  1. NullPointerException异常的原因及java异常？？
  2. 深入理解SpringBoot之装配条件
  3. antd table设置表格一个单元格的字体颜色_微软Office三件套，各有一个效率神器，全都知道的人不超过1%...
  4. logstash5.x改变
  5. C++中成员初始化列表的使用
  6. Android P (2)---Android 9.0 “Pistachio Ice Cream”新功能和特性
  7. 互联网高并发架构的8种设计模式演化
  8. [原]CentOS 6.5 上安装 MySQL 5.6
  9. phpcms如何做企业站-- 替换首页最初操作
  10. 博客园jquery专题
  11. aix下oracle 12.1.0.2 asmca不能打开的故障
  12. vcs与quartus联合仿真
  13. rust哪家服务器便宜稳定,rust服务器选择
  14. 正态分布c语言算法,正态分布函数的几种近似算法
  15. 各国市场分析（荷兰）
  16. RTMP直播推流（二）音频推流
  17. mysql 删除一条数据sql语句_sql删除语句
  18. Python金融数据分析入门到实战-视频课程
  19. Java Selenium3 WebDriver启动火狐、Chrome、IE，Edge浏览器的方法(一)
  20. 【webrtc】fdk-aac 编解码库cmake和 gn编译

热门文章

  1. U盘制作Ubuntu启动盘后无法格式化解决办法
  2. 【JVM基础】垃圾回收算法详解（引用计数、标记、清除、压缩、复制）
  3. 输入十个国名 要求按字母顺序输出C语言,用C语言编程实现国家名称按序输出，要求键盘输入五个国家的名字，按字母顺序排列打印输出。...
  4. 载录Windows 9X、2000、XP、2003所有注册表设置
  5. Android 连接USB设备（主机模式）
  6. kafka.common.InconsistentClusterIdException: The Cluster ID doesn‘t match stored clusterId Some()
  7. 年轻一代程序员：社牛、不卷、玩开源
  8. 瑞吉外卖第五天（套餐的增删改和手机端登录功能的实现）
  9. 92_特殊方法(魔术方法)和运算符重载
  10. 锥度用计算机怎么算,大小头体积,表面积,锥度,展开圆心角,质量计算公式与在线计算器_三贝计算网_23bei.com...