Understanding The Gang of Four (GOF) design patterns using Python — Part 5

This is the 14th post in a series of learning the Python programming language.

Iterator Design Pattern

Iterator Design Pattern is a behavioral design pattern that allows us to traverse a collection of objects and access the elements in a sequential manner without knowing the inner workings of the collection. It is a powerful tool that can be used to simplify the way we access elements in a collection.

In Python, the Iterator Design Pattern is implemented through the use of two interfaces: Iterable and Iterator.

The Iterable interface is used to define objects that can be iterated, while the Iterator interface is used to define the object that performs the actual iteration. The Iterable interface is implemented by defining the __iter__ method, which returns an object that implements the Iterator interface. The Iterator interface is implemented by defining the __next__ method, which returns the next element in the sequence or raises a StopIteration exception when there are no more elements to be returned.

Here is a simple example of the Iterator Design Pattern in Python:

class MyIterator:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.start <= self.end:
            result = self.start
            self.start += 1
            return result
        else:
            raise StopIteration

my_iterator = MyIterator(0, 5)
for i in my_iterator:
    print(i)

Output:

0
1
2
3
4
5

In this example, we define a MyIterator class that implements the Iterable and Iterator interfaces. The __iter__ method returns the object itself, while the __next__ method increments the start attribute and returns it as the next element in the sequence. If there are no more elements to be returned, the __next__ method raises a StopIteration exception.

The Iterator Design Pattern is commonly used in Python to implement the for loop and to allow objects to be used in other Python functions that expect iterators, such as map, filter, and reduce.

Advantages of the Iterator Design Pattern:

1. Encapsulation: The Iterator Design Pattern allows us to encapsulate the implementation details of the collection, making it easier to change the implementation without affecting the client code that uses it.
2. Flexibility: The Iterator Design Pattern provides a flexible way to traverse the elements in a collection, allowing us to implement different iterations for different types of collections.
3. Reusability: The Iterator Design Pattern can be used to implement iterators for any type of collection, making it a reusable solution that can be applied to multiple problems.
4. Composability: The Iterator Design Pattern allows us to easily combine multiple collections into a single iterator, making it easy to traverse multiple collections at once.
5. Performance: The Iterator Design Pattern can be more efficient than other alternatives, such as accessing the elements of a collection directly, because it allows us to control the access to the elements in the collection.

Disadvantages of the Iterator Design Pattern:

1. Complexity: The Iterator Design Pattern can be complex to implement, especially for collections that have complex relationships between their elements.
2. Inflexibility: The Iterator Design Pattern can be inflexible if the collection changes frequently because the iterator needs to be updated each time the collection changes.
3. Limited functionality: The Iterator Design Pattern only provides a way to traverse the elements in a collection, it does not provide any methods for adding or removing elements from the collection.
4. Extra code: The Iterator Design Pattern requires us to write extra code for each iterator, which can lead to code duplication if multiple iterators are needed for the same collection.

The Iterator Design Pattern is a powerful tool for accessing elements in a collection in a sequential manner. It allows us to simplify the way we access elements in a collection and provides a clean and organized way to traverse objects.

Mediator Design Pattern

The Mediator Design Pattern is a behavioral design pattern that allows us to decouple objects from each other by providing a central point of communication. Instead of objects communicating directly with each other, they communicate through a mediator object, which acts as a go-between.

The Mediator Design Pattern is useful in situations where a group of objects needs to interact with each other, but it would be impractical or inefficient to have them communicate directly. By using a mediator object, we can reduce the complexity of the interactions and make it easier to maintain and modify the code.

In Python, the Mediator Design Pattern can be implemented by defining a Mediator class that acts as the central point of communication between objects. The objects that need to interact with each other can then communicate through the mediator by calling methods on it.

Here is a simple example of the Mediator Design Pattern in Python:

class Mediator:
    def __init__(self):
        self.users = []

    def register_user(self, user):
        self.users.append(user)

    def send_message(self, message, sender):
        for user in self.users:
            if user != sender:
                user.receive_message(message, sender)

    def receive_message(self, message, sender):
        print(f"{sender.name} sent message: {message}")
        self.send_message(message, sender)

class User:
    def __init__(self, name, mediator):
        self.name = name
        self.mediator = mediator
        self.mediator.register_user(self)

    def send_message(self, message):
        print(f"{self.name} sending message: {message}")
        self.mediator.receive_message(message, self)

    def receive_message(self, message, sender):
        print(f"{self.name} received message '{message}' from {sender.name}")

mediator = Mediator()

john = User("John", mediator)
jane = User("Jane", mediator)

john.send_message("Hello, Jane!")
jane.send_message("Hello, John!")

Output:

John sending message: Hello, Jane!
John sent message: Hello, Jane!
Jane received message 'Hello, Jane!' from John
Jane sending message: Hello, John!
Jane sent message: Hello, John!
John received message 'Hello, John!' from Jane

In this example, we define a Mediator class that acts as the central point of communication between User objects. The User objects communicate with each other by calling the send_message method on the mediator, passing in a message and a reference to the sender. The mediator then passes the message on to the appropriate recipient by calling the receive_message method.

The Mediator Design Pattern is commonly used in GUI programming to manage communication between widgets and in event-driven systems to manage communication between objects.

Advantages of the Mediator Design Pattern:

1. Decoupling: The Mediator Design Pattern decouples objects from each other, making it easier to change the implementation of one object without affecting the others. This can lead to a more flexible and maintainable codebase.
2. Simplification of interactions: The Mediator Design Pattern simplifies the interactions between objects by providing a central point of communication, making it easier to understand and modify the code.
3. Improved organization: The Mediator Design Pattern can help to improve the organization of the code by separating the responsibilities of different objects and reducing the number of direct interactions between them.
4. Reusability: The Mediator Design Pattern can be reused in different parts of the code, making it a powerful tool for reducing complexity and improving the organization of the code.
5. Improved performance: The Mediator Design Pattern can improve performance in situations where direct interactions between objects would be too slow or complex.

Disadvantages of the Mediator Design Pattern:

1. Increased complexity: The Mediator Design Pattern can add complexity to the code, especially in situations where there are many objects that need to interact with each other.
2. Extra code: The Mediator Design Pattern requires the implementation of a mediator class, which can add extra code and make the codebase larger.
3. Limited functionality: The Mediator Design Pattern is limited to managing communication between objects and does not provide any other functionality.
4. Debugging: Debugging can be more difficult in situations where the Mediator Design Pattern is used because it can be harder to understand the interactions between objects and how they are affecting the code.

The Mediator Design Pattern is a powerful tool for decoupling objects from each other and reducing the complexity of their interactions. By using a central point of communication, we can make it easier to maintain and modify the code and ensure that objects are able to interact with each other in a clean and organized manner.

Memento Design Pattern

Memento Design Pattern is a behavioral design pattern that provides a means to capture and store the internal state of an object so that it can be restored to this state later if needed. The Memento pattern is used to implement undo/redo operations in an application.

The Memento pattern is composed of three objects: the originator, the caretaker, and the memento. The originator is the object whose state needs to be saved. The caretaker is the object responsible for storing the memento. A memento is an object that holds the saved state of the originator.

Here is an example of how the Memento pattern could be implemented in Python:

class Memento:
    def __init__(self, state):
        self._state = state

    def get_state(self):
        return self._state


class Originator:
    def __init__(self, state):
        self._state = state

    def set_state(self, state):
        self._state = state

    def create_memento(self):
        return Memento(self._state)

    def set_memento(self, memento):
        self._state = memento.get_state()

    def show_state(self):
        print("Originator state:", self._state)


class Caretaker:
    def __init__(self):
        self._mementos = []

    def add_memento(self, memento):
        self._mementos.append(memento)

    def get_memento(self, index):
        return self._mementos[index]

In this example, the Originator class represents the object whose state we want to save. The Caretaker class represents the object responsible for storing the state of the originator. The Memento class represents the saved state of the originator.

Here is how we could use the Originator, Caretaker, and Memento classes to implement an undo/redo operation:

originator = Originator("Initial state")
caretaker = Caretaker()

originator.show_state()
memento = originator.create_memento()
caretaker.add_memento(memento)

originator.set_state("State 1")
originator.show_state()
memento = originator.create_memento()
caretaker.add_memento(memento)

originator.set_state("State 2")
originator.show_state()
memento = originator.create_memento()
caretaker.add_memento(memento)

originator.set_state("State 3")
originator.show_state()

originator.set_memento(caretaker.get_memento(1))
originator.show_state()

Output:

Originator state: Initial state
Originator state: State 1
Originator state: State 2
Originator state: State 3
Originator state: State 1

In this example, the originator’s state is first set to “Initial state”. The state is then saved in a memento object and added to the caretaker. The state of the originator is then changed to “State 1” and saved in another memento object. This process is repeated for states “State 2” and “State 3”. Finally, the state of the originator is restored to “State 1” using the memento stored in the caretaker.

It’s important to note that the memento pattern should be used carefully, as it can result in large amounts of memory usage if not used properly. In general, it is best to use the memento pattern when the size of the state to be saved is small, or when the state can be easily serialized and deserialized.

Advantages of Memento Design Pattern:

1. Easy State Management: The Memento pattern makes it easy to save and restore the state of an object, without having to manually track the state of each individual component.
2. Decoupling: The Memento pattern decouples the originator and caretaker objects, making it possible to change the implementation of one object without affecting the other.
3. Improved Flexibility: By providing a convenient means to save and restore object states, the Memento pattern enables flexible and dynamic behavior in applications.
4. Easy to Implement: The Memento pattern is relatively simple to implement, and can be a good starting point for implementing undo/redo operations in an application.

Disadvantages of Memento Design Pattern:

1. Memory Usage: The Memento pattern can result in significant memory usage if not used properly, as it requires saving a separate memento object for each state of the originator.
2. State Bloat: If the state of an originator is very large, saving a separate memento object for each state can result in a large number of mementos, leading to “state bloat.”
3. Limited Reusability: Memento objects are specific to the originator they were created for, and cannot be reused for other originators.
4. Serialization Overhead: If the state of the originator cannot be easily serialized, implementing the Memento pattern can be more complicated and may result in performance overhead.

The Memento Design Pattern is a useful tool for implementing undo/redo operations in an application. By providing a means to save and restore the state of an object, the Memento pattern allows for flexible and convenient management of object state. As with any design pattern, it is important to use the Memento pattern with care and to consider its limitations and best practices.

Observer Design Pattern

The Observer pattern is a behavioral design pattern that allows multiple objects to be notified and updated when the state of another object changes. The pattern is used in situations where one or more objects need to be informed of changes to a particular object, without requiring the objects to be tightly coupled.

In this pattern, there are two types of objects: the subject and the observer. The subject is the object whose state is being monitored, and the observer is the object that is notified when the state of the subject changes.

Let’s take a look at an example of how the Observer pattern can be implemented in Python:

class Subject:
    def __init__(self):
        self.observers = []

    def register_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

    def notify_observers(self, message):
        for observer in self.observers:
            observer.update(message)

class Observer:
    def update(self, message):
        pass

class User(Observer):
    def __init__(self, name):
        self.name = name

    def update(self, message):
        print(f"{self.name} received message: {message}")

subject = Subject()

john = User("John")
jane = User("Jane")

subject.register_observer(john)
subject.register_observer(jane)

subject.notify_observers("Hello, everyone!")

In this example, the Subject class represents the object whose state is being monitored. It maintains a list of observers and provides methods to register and remove observers from the list. The notify_observers method is called whenever the state of the subject changes, and it iterates through the list of observers, calling the update method on each one.

The Observer class is an abstract base class that defines the interface for the observers. In this example, we've implemented a User class that inherits from Observer. Each user has a name and an update method that is called whenever the subject's state changes. In this case, the update method simply prints a message to the console indicating that the user received the message.

To use this pattern, we create a Subject object and register one or more Observer objects with it. Whenever the state of the subject changes, we call the notify_observers method on the subject to inform all registered observers. In this example, we've registered two User objects with the subject and called notify_observers with a "Hello, everyone!" message. When we run the example, the output should look something like this:

John received message: Hello, everyone!
Jane received message: Hello, everyone!

As you can see, both User objects received the message and printed it to the console. This is a simple example of how the Observer pattern can be used to notify multiple objects of changes to a particular object, without requiring tight coupling between the objects.

Advantages of Observer Design Pattern:

1. Decoupling: The Observer pattern decouples the subject and observer objects, allowing them to change independently without affecting each other. This allows for greater flexibility and maintainability of the system.
2. Easy Notification: The Observer pattern provides an easy and efficient mechanism for objects to receive notifications from other objects, making it easy to implement event-driven systems.
3. Dynamic Subscriptions: The Observer pattern allows for dynamic subscriptions, where objects can subscribe and unsubscribe from notifications at runtime.
4. Scalability: The Observer pattern is easily scalable, as new observers can be added or removed without affecting the subject or existing observers.

Disadvantages of Observer Design Pattern:

1. Tight Coupling: The Observer pattern can result in tight coupling between the subject and observer objects, making it difficult to change or reuse the objects in other contexts.
2. Performance Overhead: The Observer pattern can result in performance overhead, as the subject must maintain a list of its observers and notify them of any changes.
3. Complexity: The Observer pattern can result in complex and tightly-coupled systems, particularly if it is used improperly or in combination with other patterns.
4. Update Order: The order in which observers receive updates from the subject can be important, and the Observer pattern does not specify any particular order.

The Observer Design Pattern is a useful tool for implementing event-driven systems in Python, allowing objects to subscribe to receive notifications from other objects. The built-in Observer and Subject classes from the observer module provide a simple and easy-to-use implementation of the Observer pattern, making it easy to implement event-driven systems in Python.

If you like the post, don’t forget to clap. If you’d like to connect, you can find me on LinkedIn.

References:

Book “Design Patterns: Elements of Reusable Object-Oriented Software”