Observer Design Pattern explained with a Python sample

Introduction

 

In this article, we will learn about Observer Design Pattern explained with a Python sample.

 

What is an Observer Design Pattern?

 

The Observer Design Pattern is a Behavioral Pattern used to notify all objects that are registered/attached/added to the same type of observer.

 

Why use the Observer Design Pattern?

 

It is useful when there is a requirement of "Single object change in its state/behavior/Value needs to notify all other objects which are observing the same object".

 

Basically, a single object should notify multiple objects of the same observer type. It's the relation of one object to many others.

 

Players in this pattern,

• Subject: Provides a contract to add/remove observers
• ConcreteSubject: Implements a contract defined by Subject
• Observer: Provides a contract for updating objects when there is a change in the subject state/behavior/Value
• ConcreteObserver: Implements a contract defined by Observer 

Problem definition

 

Design a software solution for a wholesale pen seller. This wholesale pen seller will sell pens to shops. When there is a change in pen price per market demand, it should automatically notify the change in pen price to all shops.

 

The players are

• Subject – PenSubject
• ConcreteSubject – Pen
• Observer – ShopObserver
• ConcreteObserver – Shop

Below is the PenSubject abstract class which will define contact for ConcreteSubjects, add the below code in subject.py file

from abc import ABC, abstractmethod

class PenSubject(ABC):

    @abstractmethod
    def add(self, shop):
        pass

    @abstractmethod
    def remove(self, shop):
        pass

    @abstractmethod
    def notify(self):
        pass

Below is the Pen class which implements PenSubject abstract class to add/remove observers and call Notify, which will invoke when there is a change in pen price, add the below code in ConcreteSubject.py file

from subject import PenSubject


class Pen(PenSubject):

    def __init__(self, prize):
        self._penPrize = prize

    shops = []

    def add(self, shop):
        self.shops.append(shop)

    def remove(self, shop):
        self.shops.append(shop)

    def notify(self):
        for shop in self.shops:
            shop.update(self)
        print('---------------------------------------')

    @property
    def penPrize(self):
        return self._penPrize

    @penPrize.setter
    def penPrize(self, prize):
        self._penPrize = prize
        self.notify()

Below is the ShopObserver (Observer) abstract class which defines a contract for ConcreteObserver (i.e. in our case Shop), add the below code in observer.py file

from abc import ABC, abstractmethod


class ShopObserver(ABC):

    @abstractmethod
    def update(self, pen):
        pass

Below is the Shop class which implements ShopObserver to update the Subject object, add the below code in ConcreteObserver.py file

from observer import ShopObserver
from ConcreteSubject import Pen


class Shop(ShopObserver):

    def __init__(self, shopName: str):
        self._shopName = shopName

    def update(self, pen: Pen):
        print("pen prize changed to ", pen.penPrize, ' in ', self._shopName)

We will see the execution and result now. Add code in startup.py file and run

from ConcreteObserver import Shop
from ConcreteSubject import Pen

pen = Pen(10)
pen.add(Shop('Shop1'))
pen.add(Shop('Shop2'))
pen.add(Shop('Shop3'))

pen.penPrize = 15
pen.penPrize = 20
pen.penPrize = 32

Below is the result screenshot. In it, we can see that change in pen price value has notified all shops

 

 

Summary

 

In this article, we learned through a code example what the Observer design pattern is, as well as why and where to use it.