Commit 8eebf7c

The facade pattern is used to make one object with a simple interface represent a complicated system. The problem often occurs in programming where you have a series of interconnected classes where the functions must be called in a certain order or have complicated interdependencies.

This pattern is to give a standard interface to such a system, so you don't have to rely on reading how you call the system in one of the files or look at example usage.

This shows that the pattern is just one class which groups together a lot of other objects and uses them in some way.

This post will be about the Iterator pattern which is a behavioural pattern.

###The Purpose###

The idea behind this pattern is to have an object which you can loop over without needing to know the internal representation of the data. While in python nothing is private so you can find out the internals of the class, the iterator pattern gives you a standard interface.

I think the best example of an iterator in python is using a list. As I'm sure you know this is how you would iterate over a list in python.

list = ["one", "two", "three"]

The goal of this pattern in python is to be able to do that with a user defined class.

This is quite a small pattern so I will focus more on the implementation detail than the design.

I'm going to briefly talk about the protocols for mutable and immutable containers, and iterators.

An immutable container is one where you cannot change the individual items. For this you only need to be able to get the length of it and access individual items.

The python magic methods for an immutable container are.

Again the exceptions mentioned in __getitem__ are convention, but it's important for writing idiomatic python.

As you might expect a mutable container has the same methods for accessing items as an immutable container, but adds ways of setting or adding them.

Here are the magic methods.

There are other functions you can add such as __reversed__(self) and __contains__(self, item) but they are not needed for core functionality. They are very well described <a href="http://www.rafekettler.com/magicmethods.html#sequence" target="_blank">here</a>.

The protocol for an iterator is very simple.

The code for this implementation is found in <a href="https://github.com/davidcorne/Design-Patterns-In-Python/blob/master/Behavioural/Strategy_old.py" target="_blank">this file</a>.

The previous example is more how you would implement this pattern in a statically typed language such as C++ or C#. This is a more pythonic approach which will take some advise I heard in a talk; classes with only a __init__ function and one other function are functions in disguise. As functions are first class objects in python there is a lot we can do with them and I believe this gives a more pythonic variant of the strategy pattern.