III.结构模式
1.代理模式
-
代理模式，一个类代表另一个类功能，在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
class SensitiveInfo: def __init__(self): self.users = ["nick","tom","ben","mike"] def read(self): print("the username is {}".format(' '.join(self.users))) def add(self,user): self.users.append(user) print("add user {}".format(user)) class Info: def __init__(self): self.protected = SensitiveInfo() self.secret = "123456" 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.外观模式
- 隐藏系统复杂性，向客户端提供一个客户端可以访问系统接口。向现有系统添加一个接口，来隐藏系统复杂性。这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。
class A:
def run(self):
print('A run')
def jump(self):
print('A jump')
class B:
def run(self):
print('B run')
def jump(self):
print('B jump')
class C:
def run(self):
print('C run')
def jump(self):
print('C jump')
class Facade:
def __init__(self):
self.a = A()
self.b = B()
self.c = C()
def run(self):
for item in ("a","b","c"):
obj = getattr(self,item)
obj.run()
def jump(self):
for item in ("a","b","c"):
getattr(self,item).jump()
if __name__ == '__main__':
facade = Facade()
facade.run()
facade.jump()
3.桥接模式
- 在python程序设计中，桥接指的是抽象部分和实体部分的连接，简单来说是类和类实例化过程中链接。
class A:
def run(self,name):
print("my name is {}".format(name))
class B:
def run(self, name):
print("我的名字是：{}".format(name))
class Bridge:
def __init__(self, ager, classname):
self.ager = ager
self.classname = classname
def bridge_run(self):
self.classname.run(self.ager)
if __name__ == '__main__':
test = Bridge('Tom', A())
test.bridge_run()
4.组合模式
- 用于把一组相似对象当作一个单一的对象，组合模式依据树形结构来组合对象。您想表示对象的部分-整体层次结构（树形结构）。 2、您希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
class Company:
name = ''
def __init__(self, name):
self.name = name
def add(self, company):
pass
def remove(self, company):
pass
def display(self, depth):
pass
def line_of_duty(self): # 履行职责
pass
# Composite：公司类
class ConcreteCompany(Company):
childrenCompany = None
def __init__(self, name):
Company.__init__(self, name)
self.childrenCompany = []
def add(self, company):
self.childrenCompany.append(company)
def remove(self, company):
self.childrenCompany.remove(company)
def display(self, depth):
print('-' * depth + self.name)
for component in self.childrenCompany:
component.display(depth + 2)
def line_of_duty(self): # 履行职责
for component in self.childrenCompany:
component.line_of_duty()
# Leaf：具体职能部门
class HRDepartment(Company):
def __init__(self, name):
Company.__init__(self, name)
def display(self, depth):
print('-' * depth + self.name)
def line_of_duty(self): # 履行职责
print('%s 员工招聘培训管理' % self.name)
# Leaf：具体职能部门
class FinanceDepartment(Company):
def __init__(self, name):
Company.__init__(self, name)
def display(self, depth):
print('-' * depth + self.name)
def line_of_duty(self): # 履行职责
print('%s 公司财务收支管理' % self.name)
if __name__ == '__main__':
root = ConcreteCompany('北京总公司')
root.add(HRDepartment('总公司人力资源部'))
root.add(FinanceDepartment('总公司财务部'))
comp = ConcreteCompany('华东分公司')
comp.add(HRDepartment('华东分公司人力资源部'))
comp.add(FinanceDepartment('华东分公司财务部'))
root.add(comp)
comp1 = ConcreteCompany('南京办事处')
comp1.add(HRDepartment('南京办事处人力资源部'))
comp1.add(FinanceDepartment('南京办事处财务部'))
comp.add(comp1)
comp2 = ConcreteCompany('杭州办事处')
comp2.add(HRDepartment('杭州办事处人力资源部'))
comp2.add(FinanceDepartment('杭州办事处财务部'))
comp.add(comp2)
print('-------公司结构图-------')
root.display(1)
print('
-------职责-------')
root.line_of_duty()
5.装饰者模式--函数装饰器
import time
from functools import wraps
def timethis(func):
'''
Decorator that reports the execution time.
'''
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(func.__name__, end - start)
return result
return wrapper
@timethis
def fun():
time.sleep(3)
return 1
if __name__ == '__main__':
fun()
6.装饰者模式--类装饰器
class Spam:
@profiled
def bar(self,x)
print(self,x)
- 我们想给一个对象添加额外功能，可以通过装饰器，继承或是组合方式，相比继承，它会使代码更难去复用，继承关系是静态的。
# 修饰器装饰
class Foo:
def f1(self):
print("original f1")
def f2(self):
print("original f2")
class Foo_decorator:
def __init__(self, decoratee):
self._decoratee = decoratee
def f1(self):
print("before run f1")
self._decoratee.f1()
print("after run f1")
def __getattr__(self, name):
return getattr(self._decoratee, name)
if __name__ == '__main__':
u = Foo()
v = Foo_decorator(u)
v.f1()
v.f2()
7.适配器模式
- 做为两个接口是否兼容的桥梁，这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。
class Dog:
def __init__(self, name):
self.name = name
def wangwang(self):
print('my name is' + self.name + '。。。汪汪汪。。。')
def dog_run(self):
print(f'{self.name} is running')
class Cat:
def __init__(self, name):
self.name = name
def miaomiao(self):
print('my name is' + self.name + '。。。喵喵喵。。。')
def cat_run(self):
print(f'{self.name} is running')
class Sheep:
def __init__(self, name):
self.name = name
def miemie(self):
print('my name is' + self.name + '。。。咩咩。。。')
def sheet_run(self):
print(f'{self.name} is running')
class Adapter:
def __init__(self, adapted_methods):
self.__dict__.update(adapted_methods)
def speak(self):
pass
def run(self):
pass
def main():
animals = []
dog = Dog('旺财')
cat = Cat('大脸猫')
sheep = Sheep('喜洋洋')
animals.append(Adapter({'speak': dog.wangwang, 'run': dog.dog_run}))
animals.append(Adapter({'speak': cat.miaomiao, 'run': cat.cat_run}))
animals.append(Adapter({'speak': sheep.miemie, 'run': sheep.sheet_run}))
for a in animals:
a.speak()
a.run()
if __name__ == '__main__':
main()