The factory method pattern allows subclasses to decide which object to instantiate. It defines an interface for creating objects but lets subclasses decide which class to instantiate. There are different types of factories including static, polymorphic, and abstract factories. An abstract factory creates objects through generic interfaces while letting subclasses decide which objects to create.

1. Factory in Python

2. What is that crap
Define an interface for creating an object,
but let the subclasses decide which class to
instantiate.
The Factory method lets a class defer
instantiation to subclasses.

3. A Simple Diagram

4. Different Factory Types
x •Static
x •Polymorphic
x •Abstract

5. Static Factory
• Forces all the creation operations to be
focused in one spot
Static Factory:
Shape
Circle
Square Product

6. class Shape(object):
def factory(type):
if type == "Circle" : return Circle()
if type == "Square" : return Square()
assert 1, "Bad shape creation " + type
factory = staticmethod(factory)
class Circle(Shape):
def draw(self): print "Circle.draw"
def erase(self): print "Circle.erase"
class Square(Shape):
def draw(self): print "Square.draw"
def erase(self): print "Square.erase"
def shape_name_gen(n):
types = Shape.__subclasses__()
for i in range(n):
yield random.choice(types).__name__
shapes = [Shape.factory(i) for i in shape_name_gen(7)]
for shape in shapes:
shape.draw()
shape.erase()

7. Polymorphic Factory
• Make a single superclass version of the method that calls a
Factory Method to handle the instantiation
• The new class can be dynamically added to the factory
• Factory methods are in separate class as virtual function
• Different types of factories can be subclassed from the basic
factory

8. class ShapeFactory:
factories = {}
def add_factory(id, shapefactory):
ShapeFactory.factories.put[id] = shapeFactory
add_factory = staticmethod(add_factory)
def create_shape(id):
if not ShapeFactory.factories.has_key(id):
ShapeFactory.factories[id] = eval(id+'.Factory()')
return ShapeFactory.factories[id].create()
create_shape = staticmethod(create_shape)
class Shape(object): pass
class Circle(Shape): def shape_name_gen(n):
def draw(self): print "Circle.draw" types = Shape.__subclasses__()
def erase(self): print "Circle.erase" for i in range(n):
class Factory: yield random.choice(types).__name__
def create(self): return Circle()
shapes = [ShapeFactory.create_shape(i)
class Square(Shape): for i in shape_name_gen(7)]
def draw(self): print "Square.draw"
def erase(self): print "Square.erase" for shape in shapes:
class Factory: shape.draw()
def create(self): return Square() shape.erase()

9. Abstract Factory
• The client creates a concrete
implementation of the
abstract factory and then
uses the generic interface to
create object
• The idea is that at the point
of creation of the factory
object, you decide how all the
objects created by that
factory will be used.

10. class Obstacle: pass class GameElementFactory: pass
class Player: pass
class JavAndPuzzle(GameElementFactory):
class Jav(Player): def make_player(self): return Jav()
def interact_with(self, obstacle): def make_obstacle(self): return Puzzle()
print("Jav is playing a" )
obstacle.action() class
BenAndWeapon(GameElementFactory):
class Ben(Player): def make_player(self): return Ben()
def interact_with(self, obstacle): def make_obstacle(self): return Weapon()
print("Ben is playing a " ) class GameEnvironment:
obstacle.action() def __init__(self, factory):
self.factory = factory
class Puzzle(Obstacle): self.p = factory.make_player()
def action(self): self.ob = factory.make_obstacle()
print("Puzzle")
def play(self):
class Weapon(Obstacle): self.p.interact_with(self.ob)
def action(self):
print("Weapon") g1 = GameEnvironment(JavAndPuzzle())
g2 = GameEnvironment(BenAndWeapon())
g1.play()
g2.play()

11. Limitations of Factory
• The first limitation is that refactoring an
existing class to use factories breaks existing
clients.