A collection of design patterns and idioms in Python.

Current Patterns

Creational Patterns:

abstract_factoryuse a generic function with specific factories
borga singleton with shared-state among instances
builderinstead of using multiple constructors, builder object receives parameters and returns constructed objects
factory_methoddelegate a specialized function/method to create instances
lazy_evaluationlazily-evaluated property pattern in Python
poolpreinstantiate and maintain a group of instances of the same type
prototypeuse a factory and clones of a prototype for new instances (if instantiation is expensive)

Structural Patterns:

3-tierdata<->business logic<->presentation separation (strict relationships)
adapteradapt one interface to another using a white-list
bridgea client-provider middleman to soften interface changes
compositelets clients treat individual objects and compositions uniformly
decoratorwrap functionality with other functionality in order to affect outputs
facadeuse one class as an API to a number of others
flyweighttransparently reuse existing instances of objects with similar/identical state
front_controllersingle handler requests coming to the application
mvcmodel<->view<->controller (non-strict relationships)
proxyan object funnels operations to something else

Behavioral Patterns:

chainapply a chain of successive handlers to try and process the data
cataloggeneral methods will call different specialized methods based on construction parameter
chaining_methodcontinue callback next object method
commandbundle a command and arguments to call later
iteratortraverse a container and access the container’s elements
mediatoran object that knows how to connect other objects and act as a proxy
mementogenerate an opaque token that can be used to go back to a previous state
observerprovide a callback for notification of events/changes to data
publish_subscribea source syndicates events/data to 0+ registered listeners
registrykeep track of all subclasses of a given class
specificationbusiness rules can be recombined by chaining the business rules together using boolean logic
statelogic is organized into a discrete number of potential states and the next state that can be transitioned to
strategyselectable operations over the same data
templatean object imposes a structure but takes pluggable components
visitorinvoke a callback for all items of a collection

Design for Testability Patterns:

setter_injectionthe client provides the depended-on object to the SUT via the setter injection (implementation variant of dependency injection)

Fundamental Patterns:

delegation_patternan object handles a request by delegating to a second object (the delegate)


blackboardarchitectural model, assemble different sub-system knowledge to build a solution, AI approach - non gang of four pattern
graph_searchgraphing algorithms - non gang of four pattern
hsmhierarchical state machine - non gang of four pattern


When an implementation is added or modified, please review the following guidelines:


All files with example patterns have ### OUTPUT ### section at the bottom.

Run (e.g. ./ to generate/update it.


Add module level description in form of a docstring with links to corresponding references or other useful information. has a good example of detailed description, but sometimes the shorter one as in would suffice.

In some cases class-level docstring with doctest would also help (see

Python2/3 compatibility

Try to keep it (discussion is held in issue #208)

  • use new style classes (inherit from object)
  • use from future import print

When everything else is done - update corresponding part of README.