Commit 6203973

In C++ you have to ensure that a new instance of the singleton cannot be made. This is typically done by protecting the constructors and making a static Instance() function which returns the current instance, or makes a new one if it is appropriate.

This is another easy pattern to implement in Python. It is a case of overriding the \_\_new()\_\_ function. This is a static method for all classes which is called on construction. This function is called with an argument of the class type requested and returns a new instance of that class. So to implement the singleton pattern it is a case of making sure that the \_\_new()\_\_ method returns the global instance. This can be done with the following code:

\begin{lstlisting}

def __new__(new_singleton):

"""Override the __new__ method so that it is a singleton."""

if not new_singleton.instance:

new_singleton.instance = super(Singleton, new_singleton).__new__(new_singleton)

print("An actual new instance of Singleton made.")

print("")

return new_singleton.instance

\end{lstlisting}

Here the class name is Singleton and instance is a member variable initialised to None.

This is a pattern which falls into the catagory of included in Python already. This is because anything which can be iterated over is able to be. This goes for built in classes but if you want to make an iterable class you need to supply two methods; \_\_iter\_\_() and next().