Several practical reasons to prefer new shiny Protocols I used a standard Python library to define interfaces for the last 10 years of my career. But recently, I found that relatively new Python Protocols are way nicer. abc People find uses for both technologies. But I want to convince you to completely jump ships and start using them instead of more traditional techniques. Python interfaces: what can you use? Python is somewhat different from other popular languages since there are no interfaces on a language level. However, there are several library implementations: abc typing.Protocols third-party implementations like Zope custom implementations (e.g. ) via metaclasses package is probably the most popular: abc from abc import ABC, abstractmethod
 
class Animal(ABC):
   @abstractmethod
   def eat(self, food) -> float:
       pass
 
   @abstractmethod
   def sleep(self, hours) -> float:
       pass Next, the most frequently mentioned package seems to be : Zope from zope.interface import Interface
 
class Animal(Interface):
   def eat(self, food) -> float:
       pass
 
   def sleep(self, hours) -> float:
       pass Zope is a web-related library, and its interfaces have a lot of advanced features. Also, there are more custom packages and tutorials on the web on how to make an interface system yourself ( ). see example Finally, there are protocols: from typing import Protocol
 
class Animal(Protocol):
   def eat(self, food) -> float:
       ...
 
   def sleep(self, hours) -> float:
       ... A protocol is a formalization of Python's ideology. There are many great articles on structural typing in Python
( , , and some ). “duck-typing” this that discussion Maybe protocols and interfaces are theoretically different beasts, but a protocol does the job.
I had great success replacing with without any downsides. abc Protocols What should you use? You should know that an interface system will not be localized to a small part of your codebase.
After you choose to go with one, you’ll see it everywhere, and it's going to be hard to change in the future. So I would immediately dismiss any custom implementations or . Zope It’s an extra dependency you have to deal with forever: installation, versions, support, and so on. For example, you have to install a to support a well. Additionally, a new developer in the team might not know this custom package, and you'll have to explain what it is and why you chose it. The main battle will happen between and . Mypy plugin zope.interface abc Protocols But if you really want a vs battle, please (it has a detailed analysis of the runtime benefits of ). zope Protocols read this zope Static checking first The big assumption I’m going to make is that you’re already convinced that static checking is a : must you are not going to run the code that fails .
Both checkers support and equally well.
Also, just know that both and allow runtime checking, in case you need it. pylint/mypy abc Protocols abc Protocols Both support explicit syntax First, note that you still can explicitly inherit from an a . Many arguments in
a (and comments) from revolve around the misconception
that you can’t do that with protocols. abc and Protocol very good video Arjan You totally can: class Giraffe(Animal):
   ... So in that regard, and could be used the same way.However, Protocols give you an extra degree of design freedom by default. abc protocols You can avoid explicit inheritance but still enjoy full interface checking: class Giraffe:  # no base class needed!
   def eat(self, food) -> float:
       return 0.
 
   def sleep(self, hours) -> float:
       return 1.

def feed_animal(animal: Animal):
    ... 

giraffe = Giraffe()
feed_animal(giraffe) This allows you to make an interface for the code you don’t control and loosen the dependencies between modules in your codebase. Whether to choose an implicit or explicit option is a subtle choice decided on a case-by-case basis. A good example in favor of explicit "opt-in" for an interface is described . here Protocols do not you to opt-in, but you can establish a company-wide rule to explicitly inherit from any protocol. force also support implicit interfaces through the concept of .
But you have to call for every implementation: abc "virtual subclasses" register class Giraffe:  # no base class needed!
   def eat(self, food) -> float:
       return 0.

class Animal(ABC):
    ...

Animal.register(Giraffe)  # achieves the same as implicit Protocol supports implicit and explicit variants without extra syntax and works with .
Also, does not support as of the end of 2022. Procotol mypy mypy register I'm not sure if we can fully count that in favor of . abc Protocols allow you to define an interface for a (not only a class). function It is a very cool feature that is worthy of a separate post. Both support default methods :( Unfortunately, there is a big downside to both and . In the real world, many people work in a single codebase. Abstract base classes sometimes tend to acquire default method implementations. abc Protocols This is what it might look like: class Animal(Protocol):  # the same holds for Animal(ABC):
   def eat(self, food) -> float:
       ...  # this is still abstract
 
   def sleep(self, hours) -> float:
       return 3. In that case, they stop being “abstract” and become just base classes. Python and static checkers do not catch that. A software design with inheritance is not really the same as a design with interfaces. I would love Python to separate them on a language level, but it is unlikely to happen. Implicit protocols have an advantage here. They allow you to avoid messy inheritance altogether. Protocols are shorter Last but not least, you can count the number of lines of code you need to define an interface.
With , you must have an decorator for every method.
But with Protocols without runtime checking, you don't have to use any decorators at all.
So here, Protocols win hands down. abc abstractmethod Conclusion Let’s add up the scores: Capability ABC Protocols Runtime checking 1 1 Static checking 1 1 Explicit interface with inheritance 1 1 Implicit interface without inheritance ( requires ) abc register 0.5 1 Ability to have default method implementation -1 -1 Callback interface 0 1 Number of lines -1 0 Total 1.5 4 Hopefully, I’m not missing anything huge in this analysis. Thank you for reading!
Looking at the results, team wins, and you probably should just start using it! "Protocols" Thank you for reading! You can find me on or . LinkedIn Twitter Originally published here.

Streamlining Python Interfaces: Tips for Concise and Clean Code

Not sure if I mentioned already? Twitter time!

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

Python Interfaces: Abandon ABC and Switch to Protocols

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Negating 'Side Effects' in Python: A Guide (With Pictures!)

0–100 in Django: Starting an app the right way

The Noonification: Reduce Javascript: Master the Basics (1/11/2023)

The Noonification: How to Deal With Flapping or Broken Tests (11/29/2023)

The Noonification: Top 10 CSS Performance Tips (11/14/2022)

Negating 'Side Effects' in Python: A Guide (With Pictures!)

0–100 in Django: Starting an app the right way

The Noonification: Reduce Javascript: Master the Basics (1/11/2023)

The Noonification: How to Deal With Flapping or Broken Tests (11/29/2023)

The Noonification: Top 10 CSS Performance Tips (11/14/2022)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps