工厂方法模式的实质是将对象的创建延迟到其子类实现，即由子类根据当前情况动态决定应该实例化哪一个产品类。从上图可以看出，工厂方法模式涉及到抽象工厂角色、具体工厂角色、抽象产品角色和具体产品角色四个参与者。

抽象工厂角色负责声明工厂方法（factory method），用来"生产"抽象产品，以下是抽象工厂的示例性Python代码：

creator.py
class Creator:
""" 抽象工厂角色 """

 # 创建抽象产品的工厂方法
 def factoryMethod(self):
 pass

具体工厂角色负责创建一个具体产品的实例，并将其返回给调用者。具体工厂是与具体产品相关的，实现时一般常用的做法是为每个具体产品定义一个具体工厂。以下是具体工厂的示例性Python代码：
concretecreator.py
class ConcreteCreator(Creator):
""" 具体工厂角色 """

 # 创建具体产品的工厂方法
 def factoryMethod(self):
 product = ConcreteProduct()
 return product

抽象产品角色的主要目的是为所有的具体产品提供一个共同的接口，通常只需给出相应的声明就可以了，而不用给出具体的实现。以下是抽象产品类的示例性Python代码：
product.py
class Product:
""" 抽象产品角色 """

 # 所有产品类的公共接口
 def interface(self):
 pass

具体产品角色充当最终的创建目标，一般来讲它是抽象产品类的子类，实现了抽象产品类中定义的所有工厂方法，实际应用时通常会具有比较复杂的业务逻辑。以下是具体产品类的示例性Python代码：
concreteproduct.py
class ConcreteProduct(Product):
""" 具体产品角色 """

 # 公共接口的实现
 def interface(self):
 print "Concrete Product Method"

在应用工厂方法模式时，通常还需要再引入一个客户端角色，由它负责创建具体的工厂对象，然后再调用工厂对象中的工厂方法来创建相应的产品对象。以下是客户端的示例性Python代码：
client.py
class Client:
""" 客户端角色 """

def run(self):
 creator = ConcreteCreator()
 product = creator.factoryMethod()
 product.interface()
# 主函数
if (__name__ == "__main__"):
 client = Client()
 client.run()

在这个简单的示意性实现里，充当具体产品和具体工厂角色的类都只有一个，但在真正的实际应用中，通常遇到的都是同时会有多个具体产品类的情况，此时相应地需要提供多个具体工厂类，每个具体工厂都负责生产对应的具体产品。
工厂方法模式的活动序列如下图所示，客户端Client首先创建ConcreteCreator对象，然后调用ConcreteCreator对象的工厂方法factoryMethod()，由它负责"生产"出所需要的ConcreteProduct对象。

下面我们来看一个具体案例：
如果你开一家Pizza店（PizzaStore抽象类）卖各种风味的Pizza（Pizza子类），那么你需要根据客户要求准备相应的Pizza（创建Pizza对象），然后烘烤、切片、包装；
最简单的做法就是在PizzaStore中根据客户要求（类型判断）创建相应的Pizza对象，然后调用Pizza自身（由Pizza抽象类实现）的烘烤、切片和包装方法；
但这样的代码缺乏弹性，因为你让一个抽象类去依赖具体的对象；我们可以创建一个工厂来生产Pizza，根据传入的不同类型值返回不同Pizza对象，即从PizzaStore中将创建对象的代码挪到工厂中。但这只是一个编程技巧，并不算模式。
在工厂方法模式中，我们在PizzaStore中定义一个抽象接口（create_pizza）作为抽象的工厂，而order_pizza是它的客户；将Pizza对象的创建放到PizzaStore子类去解决。
现有Cheese和Clam两款Pizza，以及NY和Chicago两家分店，每家店的同款Pizza的口味不同——为迎合当地口味做了改进，主要差别来自不同的原材料，因此我们实现四个Pizza类型（NYStyleCheesePizza、NYStyleClamPizza、ChicagoStyleCheesePizza和ChicagoStyleClamPizza），每种使用不同的原材料组合，根据客户所在城市和选择款式我们创建不同的对象；根据工厂方法，我们将对象创建的代码放到PizzaStore子类去实现。
代码：

#!/usr/bin/python 

class Pizza: 
 name = "" 
 dough = "" 
 sauce = "" 
 toppings = [] 
 
 def prepare(self): 
 print "Preparing %s" % self.name 
 print " dough: %s" % self.dough 
 print " sauce: %s" % self.sauce 
 print " add toppings:" 
 for n in self.toppings: 
 print " %s" % n 
 
 def bake(self): 
 print "Bake for 25 minutes at 350." 
 
 def cut(self): 
 print "Cutting into diagonal slices." 
 
 def box(self): 
 print "Put into official box." 
 
 def get_name(self): 
 return self.name 
 
 
class PizzaStore: 
 def order_pizza(self, pizza_type): 
 self.pizza = self.create_pizza(pizza_type) 
 self.pizza.prepare() 
 self.pizza.bake() 
 self.pizza.cut() 
 self.pizza.box() 
 return self.pizza 
 
 def create_pizza(self, pizza_type): 
 pass 
 
 
class NYStyleCheesePizza(Pizza): 
 def __init__(self): 
 self.name = "NY Style Cheese Pizza" 
 self.dough = "NY Dough" 
 self.sauce = "NY Sauce" 
 self.toppings.append("NY toopping A") 
 self.toppings.append("NY toopping B") 
 
 
class ChicagoStyleCheesePizza(Pizza): 
 def __init__(self): 
 self.name = "Chicago Style Cheese Pizza" 
 self.dough = "Chicago Dough" 
 self.sauce = "Chicago Sauce" 
 sefl.toppings.append("Chicago toopping A") 
 
 def cut(self): 
 print "Cutting into square slices." 
 
 
class NYStyleClamPizza(Pizza): 
 def __init__(self): 
 self.name = "NY Style Clam Pizza" 
 self.dough = "NY Dough" 
 self.sauce = "NY Sauce" 
 self.toppings.append("NY toopping A") 
 self.toppings.append("NY toopping B") 
 
 
class ChicagoStyleClamPizza(Pizza): 
 def __init__(self): 
 self.name = "Chicago Style Clam Pizza" 
 self.dough = "Chicago Dough" 
 self.sauce = "Chicago Sauce" 
 self.toppings.append("Chicago toopping A") 
 
 def cut(self): 
 print "Cutting into square slices." 
 
 
class NYPizzaStore(PizzaStore): 
 def create_pizza(self, pizza_type): 
 if pizza_type == "cheese": 
 return NYStyleCheesePizza() 
 elif pizza_type == "clam": 
 return NYStyleClamPizza() 
 else: 
 return None 
 
 
class ChicagoPizzaStore(PizzaStore): 
 def create_pizza(self, pizza_type): 
 if pizza_type == "cheese": 
 return ChicagoStyleCheesePizza() 
 elif pizza_type == "clam": 
 return ChicagoStyleClamPizza() 
 else: 
 return None 
 
if __name__ == "__main__": 
 ny_store = NYPizzaStore() 
 chicago_store = ChicagoPizzaStore() 
 
 pizza = ny_store.order_pizza("cheese") 
 print "Mike ordered a %s." % pizza.get_name() 
 print 
 
 pizza = chicago_store.order_pizza("clam") 
 print "John ordered a %s." % pizza.get_name() 
 print 

输出：

Preparing NY Style Cheese Pizza 
 dough: NY Dough 
 sauce: NY Sauce 
 add toppings: 
 NY toopping A 
 NY toopping B 
Bake for 25 minutes at 350. 
Cutting into diagonal slices. 
Put into official box. 
Mike ordered a NY Style Cheese Pizza. 
 
Preparing Chicago Style Clam Pizza 
 dough: Chicago Dough 
 sauce: Chicago Sauce 
 add toppings: 
 NY toopping A 
 NY toopping B 
 Chicago toopping A 
Bake for 25 minutes at 350. 
Cutting into square slices. 
Put into official box. 
John ordered a Chicago Style Clam Pizza.