Python设计模式——组合模式
组合模式（Composite Pattern）可用来统合类体系中的这两种对象，一种对象能够包含体系中的其他对象，另一种为基本的单元对象，并不能包含其他对象。
（Python中其实很少使用到组合模式，因为采用dict就可以实现相同的功能）
常规方法，我们先可以用两种基类来分别表示这两种类型的组件。
先让我们看看运行的结果：
$0.40 Pencil
$1.60 Ruler
$0.20 Eraser
$2.20 Pencil Set
$0.40 Pencil
$1.60 Ruler
$0.20 Eraser
$3.60 Boxed Pencil Set
$1.00 Box
$2.20 Pencil Set
$0.40 Pencil
$1.60 Ruler
$0.20 Eraser
$0.40 Pencil其中main()函数中:
def main():
pencil = SimpleItem("Pencil", 0.40)
ruler = SimpleItem("Ruler", 1.60)
eraser = SimpleItem("Eraser", 0.20)
pencilSet = CompositeItem("Pencil Set", pencil, ruler, eraser)
box = SimpleItem("Box", 1.00)
boxedPencilSet = CompositeItem("Boxed Pencil Set", box, pencilSet)
boxedPencilSet.add(pencil)
for item in (pencil, ruler, eraser, pencilSet, boxedPencilSet):
item.print()层次结构如图所示
其UML：
AbstractItem要求所有子类的对象明确是不是组合体，同时还要求子类对象必须可迭代。
class AbstractItem(object):
__metaclass__=abc.ABCMeta
@abc.abstractproperty
def composite(self):
pass
def __iter__(self):
return iter([])SimpleItem类用来表示组合单元，也就是非组合体
class SimpleItem(AbstractItem):
def __init__(self, name, price=0.00):
self.name = name
self.price = price
@property
def composite(self):
"""
表明是非组合体
"""
return False
def print(self, indent="", file=sys.stdout):
print("{}${:.2f} {}".format(indent, self.price, self.name),
file=file)AbstractCompositeItem作为CompositeItem的基类，它实现了组合体所需的添加，移除，迭代等功能
class AbstractCompositeItem(AbstractItem):
def __init__(self, *items):
self.children = []
if items:
self.add(*items)
def add(self, first, *items):
self.children.append(first)
if items:
self.children.extend(items)
def remove(self, item):
self.children.remove(item)
def __iter__(self):
return iter(self.children)接下来就是组合体CompositeItem的具体实现:
class CompositeItem(AbstractCompositeItem):
def __init__(self, name, *items):
super().__init__(*items)
self.name = name
@property
def composite(self):
"""
确认是组合体
"""
return True
@property
def price(self):
return sum(item.price for item in self)
def print(self, indent="", file=sys.stdout):
print("{}${:.2f} {}".format(indent, self.price, self.name),
file=file)
for child in self:
child.print(indent + " ")这样就实现分别用两个类来表示组合体与非组合体了。但是这种方法导致我们创建了两个抽象类，两个具体类，接口也没有完全统一，如果我们再能忍受少许的额外开销也许将会更简单。
接下来我们使用一个类来表示组合体与非组合体，这二者接口完全一直，只是非组合体并不能使用某些接口
它的main函数
def main():
pencil = Item.create("Pencil", 0.40)
ruler = Item.create("Ruler", 1.60)
eraser = make_item("Eraser", 0.20)
pencilSet = Item.compose("Pencil Set", pencil, ruler, eraser)
box = Item.create("Box", 1.00)
boxedPencilSet = make_composite("Boxed Pencil Set", box, pencilSet)
boxedPencilSet.add(pencil)
for item in (pencil, ruler, eraser, pencilSet, boxedPencilSet):
item.print()
assert not pencil.composite
pencil.add(eraser, box)
assert pencil.composite
pencil.print()
pencil.remove(eraser)
assert pencil.composite
pencil.remove(box)
assert not pencil.composite
pencil.print()类的代码
class Item:
def __init__(self, name, *items, price=0.00):
"""
将items加入children
可以依据children判断是否是组合体
"""
self.name = name
self.price = price
self.children = []
if items:
self.add(*items)这里定义了两个工厂方法(还记得之前的工厂模式吗？)，其中create创建非组合体,compose创建组合体
@classmethod
def create(Class, name, price):
return Class(name, price=price)
@classmethod
def compose(Class, name, *items):
return Class(name, *items)我们还可以在类外面创建这两个工厂方法来创建非组合体和组合体
def make_item(name, price):
return Item(name, price=price)
def make_composite(name, *items):
return Item(name, *items)composite判断是否是组合体
@property
def composite(self):
return bool(self.children)定义组合体方法
def add(self, first, *items):
self.children.extend(itertools.chain((first,), items))
def remove(self, item):
self.children.remove(item)
def __iter__(self):
return iter(self.children)
打印
@property
def price(self):
return (sum(item.price for item in self) if self.children else
self.__price)
@price.setter
def price(self, price):
self.__price = price
def print(self, indent="", file=sys.stdout):
print("{}${:.2f} {}".format(indent, self.price, self.name),
file=file)
for child in self:
child.print(indent + " ")