1.抽象工厂模式
import random
class PetShop(object):
def __init__(self,animal_factory=None):
# pet 宠物 factory 工厂
self.pet_factory = animal_factory
def show_pet(self):
pet = self.pet_factory.get_pet()
print("this is a lovely", pet)
print("it says",pet.speak())
print("it eats",self.pet_factory.get_food())
class Dog:
def speak(self):
return "Dog"
def __str__(self):
return "this is Dog"
class Cat:
def speak(self):
return "Cat"
def __str__(self):
return "this is Cat"
class CatFactory:
def get_pet(self):
return Cat()
def get_food(self):
return "cat food"
class DogFactory:
def get_pet(self):
return Dog()
def get_food(self):
return "dog food"
def get_factory():
return random.choice([DogFactory,CatFactory])
if __name__ == '__main__':
shop = PetShop() # pet_factory 默认为None，后面延迟加载
shop.pet_factory = get_factory()() # 延迟加载，随机选择一个工厂然后实例出来一个对象给商店
shop.show_pet()
2. 适配器模式
import os
class Dog:
def __init__(self):
self.name ="Dog"
def bark(self): # bark ：叫声
return "woof!" # woof 低吠声
class Cat:
def __init__(self):
self.name = "Cat"
def meow(self): # meow 猫叫声
return "meow" # meow 猫叫声
class Human:
def __init__(self):
self.name = "Human"
def speak(self):
return "hello, python"
class Car:
def __init__(self):
self.name = "Car"
def make_noise(self, noise_level):
return "noise level is {}".format(noise_level)
class Adapter: # adapter 适配器
def __init__(self,obj,adapted_methods): # adpted 适应
self.obj = obj
self.__dict__.update(adapted_methods) # self.__dict__是打印对象所有的属性，结果是一个字典 {"kye":value}
# key对应对象的属性，value对应属性的属性值。这里就相当于把不同类的方法都绑定到Adapter这个类实例化出来的
# 对象的make_noise 属性上面去，该属性的值对应其他类里面的方法。
def __getattr__(self, attr): # 当调用类不存的属性或者方法时，就会触发该魔法方法
return getattr(self.obj, attr) # getattr(object,attr [,default])
def main():
objects = []
dog = Dog()
objects.append(Adapter(dog,dict(make_noise=dog.bark)))
cat = Cat()
objects.append(Adapter(cat,dict(make_noise=cat.meow)))
human = Human()
objects.append(Adapter(human,dict(make_noise=human.speak)))
car = Car()
car_noise = lambda : car.make_noise(3)
objects.append(Adapter(car,dict(make_noise=car_noise)))
for obj in objects:
print("A",obj.name,"goes",obj.make_noise()) # 这里 obj.make_noise 就相当于 dog.bark 这些方法，后面加括号代表执行
print(obj.obj) # 原来的对象被存储到obj属性里面.
if __name__ == '__main__':
# 适配器模式在不改变原有类的基础上,统一了所有的方法,还能够保存原有对象的引用obj属性
main()
3.共享模式
class Borg:
__shared_state = {}
def __init__(self):
self.state = None # 设置默认值防止报错
self.__dict__ = self.__shared_state # 等号，浅拷贝，拷贝引用，
# 后面实例化的对象的__dict__都是这个字典 __shared_state
# 因为__shared_state 是类属性，所以只有一份，所有的实例对象共用
def __str__(self): # 打印对象的时候自动执行的魔法方法
return self.state # self.state动态添加
class YourBorg(Borg):
def hhh(self):
print(self.__shared_state)
pass
if __name__ == '__main__':
rm1 = Borg()
rm2 = Borg()
rm1.state = "Done"
print("rm1.state:", rm1) # rm1.state: Done
print("rm1.state:", rm2) # rm2.state: Done
rm2.state = "Running"
print("rm1.state:", rm1) # rm1.state: Running
print("rm2.state:", rm2) # rm2.state: Running
print("rm1 id:", id(rm1)) # rm1 id: 41601008
print("rm2 id:", id(rm2)) # rm2 id: 41601064
rm3 = YourBorg() # 继承父类的__init__方法，但是私有属性没有继承。初始化的时候调用了父类的初始化方法
# 下面2句注释证明上述观点
# rm3.hhh()
# print(rm3.__shared_state)
print("rm3.state:", rm3) # rm3.state: Running
# 共享模式通过私有一个类属性，然后使用__dict__魔法方法共享所有的属性
# 如果通过类属性共享属性，那么每有一个需要共享的属性就需要新建一个类属性
4.桥接模式
class DrawingAPI1:
def draw_circle(self, x, y, radius):
print("API1.circle at {} : {} ,radius:{}".format(x, y, radius))
class DrawingAPI2:
def draw_circle(self,x,y,radius):
print("API2.cirle at {} : {} ,radius:{}".format(x, y, radius))
class CircleShape:
def __init__(self,x,y,radius,drawing_api):
self._x = x
self._y = y
self._radius = radius
self._drawing_api = drawing_api
def draw(self):
self._drawing_api.draw_circle(self._x,self._y,self._radius)
def scale(self,pct): # scale 规模
self._radius *= pct # pct 百分比
def main():
shapes = (
CircleShape(1,2,3,DrawingAPI1()),
CircleShape(5,7,11,DrawingAPI2()),
) # 提供2个
for shape in shapes:
shape.scale(2.5)
shape.draw()
if __name__ == '__main__':
# 桥接模式就是一个类的属性的值是另一个类的实例对象。然后可以通过这个类的实例对象去调用另外一个类对象的方法
main()
5.建造者模式
class Director: # director 监视
def __init__(self):
self.builder = None # builder建造者
def construct_building(self):
self.builder.new_building()
self.builder.build_floor()
self.builder.build_size()
def get_building(self):
return self.builder.building
class Builder:
def __init__(self):
self.building = None
def new_building(self):
self.building = Building()
class Building:
def __init__(self):
self.floor = None
self.size = None
def __repr__(self): # 和__str__ 魔法方法类似，都是打印对象的时候调用，不过repr更强大
# repr方法在交互式环境下也能起作用，即交互式环境直接输变量名打印的时候
# __str__ 只有在print的时候才会触发
return "Floor:%s | Size: %s" % (self.floor,self.size)
class BuilderHouse(Builder):
def build_floor(self):
self.building.floor = "One"
def build_size(self):
self.building.size = "Big"
class BuilderFlat(Builder): # flat 公寓
def build_floor(self):
self.building.floor = "More than One"
def build_size(self):
self.building.size = "small"
if __name__ == '__main__':
director = Director()
director.builder = BuilderHouse()
director.construct_building()
building = director.get_building()
print(building)
director.builder = BuilderFlat()
director.construct_building()
building = director.get_building()
print(building)
6.职责链模式
class Handler:
def __init__(self):
self.successor = None
def add_successor(self,successor): # successor 后续的事，继承者
self.successor = successor
class ConcreteHandler1(Handler):
def handle(self,request):
if request>0 and request<=10:
print("concreteHandler1 deal %s"%request)
elif self.successor is not None:
self.successor.handle(request)
else:
print("no handler can deal with %s"%request)
class ConcreteHandler2(Handler):
def handle(self,request):
if request>10 and request<=20:
print("ConcreteHandler2 deal %s"%request)
elif self.successor is not None:
self.successor.handle(request)
else:
print("no handler can deal with %s" % request)
class ConcreteHandler3(Handler):
def handle(self,request):
if request>20 and request<=30:
print("ConcreteHandler3 deal %s"%request)
elif self.successor is not None:
self.successor.handle(request)
else:
print("no handler can deal with %s" % request)
if __name__ == '__main__':
h1 = ConcreteHandler1() # 创建处理者1
h2 = ConcreteHandler2() # 创建处理者2
h3 = ConcreteHandler3() # 创建处理者3
h1.add_successor(h2) # 添加h1如果处理不了就让h2去处理
h2.add_successor(h3) # 如果h2处理不了就让h3去处理
requests = [1,3,23,42,34,67,11,22,14,36]
for request in requests:
h1.handle(request)
7.命令模式
import os
class MoveFileCommand(object):
def __init__(self,src,dest):
self.src = src
self.dest = dest
def execute(self):
self() # 直接调用对象本身会执行__call__方法
def __call__(self, *args, **kwargs): # __call__ 魔法方法直接调用对象的时候执行的方法
print("renaming {} to {}".format(self.src,self.dest))
os.rename(self.src,self.dest)
def undo(self):
print("renaming {} to {}".format(self.dest,self.src))
os.rename(self.dest,self.src)
if __name__ == '__main__':
command_stack = []
command_stack.append(MoveFileCommand("foo.txt","bar.txt"))
command_stack.append(MoveFileCommand("bar.txt","foo.txt"))
for cmd in command_stack:
cmd.execute()
for cmd in reversed(command_stack):
cmd.undo()
8.装饰器模式
class foo(object):
def f1(self):
print("func f1")
def f2(self):
print("func f2")
class foo_decorator(object):
def __init__(self,decorator):
self._decorator = decorator
def f1(self):
print("decorator f1")
self._decorator.f1()
def __getattr__(self, item):
# 当得不到想要的属性时,就去自己的装饰里面拿,使用 getattr()内建方法
return getattr(self._decorator,item)
if __name__ == '__main__':
# 主要思想还是使用魔法方法 __getattr__ 方法, 然后把另外一个对象赋值到自身的属性上面.
# 添加一个运行另外一个对象的接口,没有接口时,就去直接调用另一个对象的方法.
u = foo()
d = foo_decorator(u)
d.f1()
d.f2()
9.外观模式
class small_or_piece1:
def __init__(self):
pass
def do_small1(self):
print('do small 1')
class small_or_piece_2:
def __init__(self):
pass
def do_small2(self):
print('do small 2')
class small_or_piece_3:
def __init__(self):
pass
def do_small3(self):
print('do small 3')
class outside:
def __init__(self):
self.__small1 = small_or_piece1()
self.__small2 = small_or_piece_2()
self.__small3 = small_or_piece_3()
def method1(self):
self.__small1.do_small1() ##如果这里调用的不只2两函数，作用就显示出来了，可以把原本复杂的函数调用关系清楚化，统一化
self.__small2.do_small2()
def method2(self):
self.__small2.do_small2()
self.__small3.do_small3()
if __name__ == '__main__':
# 外观模式应用于在很多复杂而小功能需要调用时,并且这些调用还具有一定的相关性,即一调用就是一系列的调用.
osd = outside()
osd.method1()
osd.method2()
10.单例模式
class A(object):
__obj = False
__init = False
def __init__(self, name):
if not A.__init:
self.name = name
A.__init = True
def __new__(cls, *args, **kwargs):
if not A.__obj:
A.__obj = super().__new__(cls)
return A.__obj
if __name__ == '__main__':
# 只初始化一次的单例模式
a = A("nick")
b = A("nick2")
print(a.name) # nick
print(b.name) # nick
print(a == b) # True
print(id(a), id(b)) # 54527760 54527760
11.图搜索模式
class GraphSearch:
def __init__(self, graph):
self.graph = graph
def find_path(self, start, end, path=None):
self.start = start
self.end = end
if not path:
self.path = []
self.path.extend([self.start])
if self.start not in self.graph:
return None # 如果图里面没有这个start这个key,说明这条路不同,返回None
if self.start == self.end:
return self.path
for node in self.graph[self.start]:
if node not in self.path:
newpath = self.find_path(node, self.end, self.path)
if newpath: # newpath不存在的时候说明这条路没有走通,继续循环,走下一条路
return newpath
return None # 如果上面一直没有return,走到这里说明从start没有找到end.返回None
# def find_all_path(self, start, end, path=None, run_num=[]):
# self.start = start
# self.end = end
# if not path:
# self.path = []
# self.path.extend([self.start])
# paths = []
# if self.start not in self.graph:
# return []
# if self.start == self.end:
# if len(run_num) == 0:
# paths.append([self.start])
# else:
# return [self.path]
# for node in self.graph[self.start]:
# if node not in self.path:
# run_num.append(1)
# newpaths = self.find_all_path(node, self.end, self.path)
# for newpath in newpaths:
# paths.append(newpath)
# return paths
def find_all_path(self, start, end, path=None):
self.start = start
self.end = end
if not path:
self.path = []
self.path += [self.start]
if self.start == self.end:
return [self.path]
if self.start not in self.graph:
return []
paths = []
for node in self.graph[self.start]:
if node not in self.path:
newpaths = self.find_all_path(node, self.end, self.path)
for newpath in newpaths:
paths.append(newpath)
return paths
def find_shortest_path(self, start, end, path=None):
self.start = start
self.end = end
if not path:
self.path = []
self.path.extend(self.start)
if self.start not in self.graph:
return None
if self.start == self.end:
return self.path
shortpath = None
for node in self.graph[self.start]:
if node not in self.path:
newpath = self.find_shortest_path(node, self.end, self.path)
if newpath:
if not shortpath or len(newpath) < len(shortpath):
shortpath = newpath
return shortpath
graph = {
"A": ["B", "C"],
'B': ['C', 'D'],
'C': ['D'],
'D': ['A'],
'E': ['F'],
'F': ['C']
}
graph1 = GraphSearch(graph)
print(graph1.find_path("A","D"))
print(graph1.find_all_path("A","A"))
print(graph1.find_all_path("A","D"))
print(graph1.find_shortest_path("A","D"))
