# Template Method Design Pattern

This is a continuation of the design pattern series.

I had blogged about S[ingleton](https://farhaanbukhsh.wordpress.com/2017/06/06/design-pattern-singleton/) once, when I was using it very frequently. This blog post is about the use of the Template Design Pattern. So let’s discuss the pattern and then we can dive into the code and its implementation and see a couple of use cases.

The Template Method Design Pattern is a actually a pattern to follow when there are a series of steps, which need to be followed in a particular order. Well, the next question that arises is, “Isn’t every program a series of steps that has to be followed in a particular order?”

The answer is Yes!

This pattern diverges when it becomes a series of functions that has to be executed in the given order. As the name suggests it is a Template **Method** Design pattern, with stress on the word method, because that is what makes it a different ball game all together.

Let’s understand this with an example of `Eating in a Buffet`. Most of us have follow a set of similar specific steps, when eating at a `Buffet.` We all go for the starters first, followed by main course and then finally, dessert. (Unless it is Barbeque Nation then it’s starters, starters and starters :))

So this is kind of a template for everyone `Starters --> Main course --> Desserts`.

Keep in mind that content in each category can be different depending on the person but the order doesn’t change which gives a way to have a template in the code. The primary use of any `design pattern` is to reduce duplicate code or solve a specific problem. Here this concept solves the problem of code duplication.

The concept of `Template Method Design Pattern` depends on, or rather  is very tightly coupled with `Abstract Classes.` `Abstract Classes` themselves are a template for `derived classes` to follow but `Template Design Pattern` takes it one notch higher, where you have a template in a template. Here’s an example of a `BuffetHogger` class.

from abc import ABC, abstractmethod

class BuffetHogger(ABC):

    @abstractmethod
    def starter\_hogging(self):
        pass

    @abstractmethod
    def main\_course\_hogging(self):
        pass

    @abstractmethod
    def dessert\_hogging(self):
        pass

    def template\_hogging(self):
        self.starter\_hogging()
        self.main\_course\_hogging()
        self.dessert\_hogging()

So if you see here the `starter_hogging`, `main_course_hogging` and `dessert_hogging` are abstract class that means base class has to implement it while `template_hogging` uses these methods and will be same for all base class.

Let’s have a `Farhaan` class who is a `BuffetHogger` and see how it goes.

class Farhaan(BuffetHogger):
    def starter\_hogging(self):
        print("Eat Chicken Tikka")
        print("Eat Kalmi Kebab")

    def \_\_call\_\_(self):
        self.template\_hogging()

    def main\_course\_hogging(self):
        print("Eat Biryani")

    def dessert\_hogging(self):
        print("Eat Phirni")

Now you can spawn as many  `BuffetHogger`  classes as you want, and they’ll all have the same way of hogging. That’s how we solve the problem of code duplication

Hope this post inspires you to use this pattern in your code too.

Happy Hacking!