工厂模式是创建型设计模式的一种。核心的思想是，通过传递给类或函数某种产品的信息来创建产品并返回。当我们想得到产品a对象，只需把产品a的名字传递给工厂函数就能得到产品a对象。
1 简单工厂方法模式
简单工厂模式，是最简单的工厂方法模式，其由两部分组成，一是：工厂函数或工厂类，二是：产品类（可以是多个产品类A,B,C………）。
代码如下：
class A(object):
def __init__(self, product_type):
self.product_type = product_type
def __str__(self):
return 'product %s' % self.product_type
class B(object):
def __init__(self, product_type):
self.product_type = product_type
def __str__(self):
return 'product %s' % self.product_type
class Factory(object):
@staticmethod
def yield_product(product_type):
if product_type == 'A':
return A(product_type)
if product_type == 'B':
return B(product_type)
if __name__ == '__main__':
a = Factory.yield_product('A')
b = Factory.yield_product('B')
print(a)
print(b)结果如下
product A
product B上面代码中，实现了两个产品类A,B，一个工厂类Factory，工厂类中实现了一个静态方法，其实，可以用一个工厂函数来代替这个工厂类。静态方法可以通过类名进行调用，而不需把类实例化
2 工厂方法模式
简单工厂模式存在一个问题，当要增加产品时，需要修改工厂类或者工厂方法，这违背了扩展开放，修改封闭的原则，因此是不可取的。工厂方法模式能够实现最小化地修改工厂类或工厂函数。
具体实现：对每一个产品类再进行一次封装，封装成只生产特定产品的工厂类。
代码如下：
import abc
class A(object):
def __init__(self, product_type):
self.product_type = product_type
def __str__(self):
return 'product %s' % self.product_type
class B(object):
def __init__(self, product_type):
self.product_type = product_type
def __str__(self):
return 'product %s' % self.product_type
class Abstract_factory(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def yield_product(self):
pass
class Factory_a(Abstract_factory):
def yield_product(self):
return A('A')
class Factory_b(Abstract_factory):
def yield_product(self):
return B('B')
def factory(product_type):
if product_type == 'A':
return Factory_a()
if product_type == 'B':
return Factory_b()
if __name__ == '__main__':
factory_a = factory('A')
a = factory_a.yield_product()
factory_b = factory('B')
b = factory_b.yield_product()
print(a)
print(b)结果如下
product A
product B上述代码，Factory_a,Factory_b是对类A,B的封装，一个工厂只负责创建一个产品遵从了单一职责原则，有利于代码的扩展和维护。
3 抽象工厂模式
对于复杂的问题，工厂方法模式会实现很多工厂类，不利于代码维护，因此要用到抽象工厂模式
代码如下
import abc
class A(object):
def __init__(self, product_type):
self.product_type = product_type
def __str__(self):
return 'product %s' % self.product_type
class B(object):
def __init__(self, product_type):
self.product_type = product_type
def __str__(self):
return 'product %s' % self.product_type
class Abstract_factory(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def yield_product_a(self):
pass
def yield_product_b(self):
pass
class Factory_1(Abstract_factory):
def yield_product_a(self):
return A('A')
def yield_product_b(self):
return B('B')
class Factory_2(Abstract_factory):
def yield_product_a(self):
return A('A')
def yield_product_b(self):
return B('B')
def factory(product_type):
if product_type == '1':
return Factory_1()
if __name__ == '__main__':
factory_1 = factory('1')
a = factory_1.yield_product_a()
b = factory_1.yield_product_b()
print(a)
print(b)
product A
product B
上述代码，Abstract_factory类实现了两个抽象方法，生产产品a和生产产品b。工厂1负责这两个产品的生产，之所以把两个产品放在同一个工厂中，是因为有些复杂的职责是由两个产品来完成的。
什么时候使用抽象工厂呢，通常刚开始使用工厂方法模式，当发现应用需要很多工厂方法时，可以将创建一系列对象的过程合并到一起，从而引入抽象工厂模式
