简介Python设计模式中的代理模式与模板方法模式编程

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 = green
    self.__blue = blue
  def Red(self):
    return self.__red
  def Green(self):
    return self.__green
  def Blue(self):
    return self.__blue

class NoBlueProxy(Proxy):
  # 我在这个子代理类拦截了blue的访问，这样就不会返回被代理的类的Blue属性
  def Blue(self):
    return 0

if __name__ == '__main__':
  rgb = RGB(100, 192, 240)
  print rgb.Red()
  proxy = Proxy(rgb)
  print proxy.Green()
  noblue = NoBlueProxy(rgb)
  print noblue.Green()
  print noblue.Blue()

# 整个例子我们要根据不同需求处理的内容
ingredients = "spam eggs apple"
line = '-' * 10

# 这是被模板方法调用的基础函数
def iter_elements(getter, action):
  """循环处理的骨架"""
  # getter是要迭代的数据，action是要执行的函数
  for element in getter():
    action(element)
    print(line)

def rev_elements(getter, action):
  """反向的"""
  for element in getter()[::-1]:
    action(element)
    print(line)

# 数据经过函数处理就是我们最后传给模板的内容
def get_list():
  return ingredients.split()

# 同上
def get_lists():
  return [list(x) for x in ingredients.split()]

# 对数据的操作
def print_item(item):
  print(item)
#反向处理数据
def reverse_item(item):
  print(item[::-1])

# 模板函数
def make_template(skeleton, getter, action):
  # 它抽象的传入了 骨架，数据，和子类的操作函数
  def template():
    skeleton(getter, action)
  return template

# 列表解析，数据就是前面的2种骨架(定义怎么样迭代)，2个分割数据的函数，正反向打印数据的组合
templates = [make_template(s, g, a)
      for g in (get_list, get_lists)
      for a in (print_item, reverse_item)
      for s in (iter_elements, rev_elements)]

# 执行
for template in templates:
  template()