<h4>
 Python has no native implementation of interfaces — but that’s where abstract
 classes and abstract methods come into play.
</h4>
<figure>
 <img
 alt=""
 src="https://cdn-images-1.medium.com/max/1024/0*39A3ujujxJZGu-VT"
 />
 <figcaption>
 Photo by
 <a
 href="https://unsplash.com/@cdr6934?utm_source=medium&amp;utm_medium=referral"
 >Chris Ried</a
 >
 on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
 >Unsplash</a
 >
 </figcaption>
</figure>

 Interfaces are so vital in software engineering, that one of the
 <a
 href="https://www.freecodecamp.org/news/solid-principles-explained-in-plain-english/"
 >SOLID Principles</a
 >
 (the bedrock of quality software design) is solely dedicated to it — <a
 href="https://en.wikipedia.org/wiki/Interface_segregation_principle#:~:text=In%20the%20field%20of%20software,are%20of%20interest%20to%20them."
 >Interface Segregation Principle</a
 >.

<h3>Why Are Interfaces so Vital in Software Engineering?</h3>

 Imagine you have a utility class which has a method which you will use
 seventeen times throughout your application. What happens when you change the
 parameters of a method in the utility class, or the output the method returns?
 You would have to refactor all the seventeen references to fit the new
 signature of the method. But, with an interface, the class itself will become
 invalid once there’s a mismatch with the interface’s contract — the class must
 stick with the interface, and have a different method, if it needs to change
 the signature. This way, all the seventeen references of the class are pretty
 much safe in the way they call the utility method.

Cool, right?

 Now, at some point in time, we Python-istas have needed a way to
 enforce implementations of certain methods in our classes, and you are
 probably reading this article because you have discovered that there are no
 native implementations of interfaces in Python. Well, not quite so.

<h3>How Would Interfaces Be Implemented in Python</h3>

 An interface would be implemented in Python as an
 abstract class.

<h4>What Is an Abstract Class</h4>

 An abstract class is a class which contains one or more abstract methods. An
 abstract method is a method that is declared but has no concrete
 implementation — the implementation is to be done by a derived class.


 The key characteristic of interfaces,
 is that they enforce the implementation of certain methods in
 classes,
 and by definition of abstract classes, this, is catered for.

<h4>Declaring an Abstract Class in Python</h4>

 Python provides an abstract base class module called abc. This module contains
 a helper class called abc.ABC (on which we base our abstract classes), and an
 abc.abstractmethod decorator (with which we mark the methods and properties,
 we want implemented by concrete classes).

We could define an abstract class in any one of two ways:
<pre>from abc import ABC, ABCMeta </pre>
<pre># using the abc.ABCMeta as a metaclass class HumanInterface(metaclass=ABCMeta): pass</pre>
<pre># inheriting the abc.ABC class class HumanInterface(ABC): pass</pre>

 The latter is preferred as a shorthand to declaring an abstract class, as ABC is a class which already has ABCMeta as its metaclass, thus it makes room easier for the developer to
 add another metaclass declaration.

Now, let’s add our first interface methods to our HumanInterface.
<pre>
from abc import ABC, abstractmethod

class HumanInterface(ABC):
 @abstractmethod
 def greet(self):
 pass
</pre>

 We have our interface set in, it is time for a concrete implementation to test
 that our interface method will be enforced.

<pre>
from abc import ABC, abstractmethod


class HumanInterface(ABC):
 @abstractmethod
 def greet(self):
 pass

 
class Hispanic(HumanInterface):
 def sing(self):
 pass
 

if __name__ == '__main__':
 Hispanic();
</pre>

 The Python interpreter throws an error we expect from an interface’s concrete
 implementation.

<pre>
TypeError: Can’t instantiate abstract class Hispanic with abstract methods greet</pre
>

 Let us take a look at what happens when we implement the greet method in our
 Hispanic class.

<pre>
from abc import ABC, abstractmethod


class HumanInterface(ABC):
 @abstractmethod
 def greet(self):
 pass
 
 @abstractmethod
 def exercise(self):
 pass
 
 @abstractmethod
 def introduce_self(self):
 pass
 
 
class Hispanic(HumanInterface):
 def greet(self):
 print("Hola! Como estas?")
 
 def exercise(self):
 print("Comenzando el entrenamiento")
 
 def introduce_self(self):
 print("Me llamo Sam")

 
if __name__ == '__main__':
 Hispanic().greet()
 # Hola! Como estas?
</pre>

 Pretty neat, right?!


 Perhaps, the team behind the Python programming language were well aware of
 the fact that interfaces could be written in Python using abstract classes
 and methods.


 In the next <a href="https://tomisin.dev/blog">article</a>, we will be
 comparing and contrasting abstract class and interfaces.


 If you found this article useful or learnt something in this article, please
 clap, share and subscribe.

<a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a>
<img
 src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=6d3658d248c"
 width="1"
 height="1"
 alt=""
/>

Python has no native implementation of interfaces — but that’s where abstract classes and abstract methods come into play. Photo by Chris Ried on Unsplash Interfaces are so vital in software engineering, that one of the SOLID Principles (the bedrock of quality software design) is solely dedicated to it — Interface Segregation Principle . Why Are Interfaces so Vital in Software Engineering? Imagine you have a utility class which has a method which you will use seventeen times throughout your application. Wha

Contents

How to Implement an Interface in Python

data-science

python

software-development

People also read