Interfacce Python: scegli i protocolli su ABC

Feb 05 2023

Diversi motivi pratici per preferire nuovi protocolli lucidi Ho usato una libreria Python standard abc per definire le interfacce negli ultimi 10 anni della mia carriera. Ma di recente, ho scoperto che i protocolli Python relativamente nuovi sono molto più carini.

Diversi motivi pratici per preferire nuovi protocolli luccicanti

Le belle interfacce ripagheranno in futuro — Ringraziamo John Barkiple su Unsplash

Ho usato una libreria Python standard abcper definire le interfacce negli ultimi 10 anni della mia carriera. Ma di recente, ho scoperto che i protocolli Python relativamente nuovi sono molto più carini. Le persone trovano usi per entrambe le tecnologie. Ma voglio convincerti a abbandonare completamente le navi e iniziare a usarle al posto delle tecniche più tradizionali.

Interfacce Python: cosa puoi usare?

Python è in qualche modo diverso da altri linguaggi popolari poiché non ci sono interfacce a livello di linguaggio. Ma ci sono diverse implementazioni di librerie. Il abcpacchetto è probabilmente il più popolare:

from abc import ABC, abstractmethod

class Animal(ABC):
   @abstractmethod
   def eat(self, food) -> float:
       pass
   @abstractmethod
   def sleep(self, hours) -> float:
       pass

from zope.interface import Interface

class Animal(Interface):
   def eat(self, food) -> float:
       pass
   def sleep(self, hours) -> float:
       pass

Infine, ci sono protocolli:

from typing import Protocol

class Animal(Protocol):
   def eat(self, food) -> float:
       ...
   def sleep(self, hours) -> float:
       ...

Cosa dovresti usare?

Dovresti sapere che un sistema di interfaccia non sarà localizzato in una piccola parte della tua base di codice. Dopo aver scelto di sceglierne uno, lo vedrai ovunque e sarà difficile cambiare in futuro. Quindi eliminerei immediatamente qualsiasi implementazione personalizzata o Zope. È una dipendenza extra con cui devi fare i conti per sempre: installazione, versioni, supporto e così via. Ad esempio, devi installare un plug-in Mypy per supportare un zope.interfacepozzo. Inoltre, un nuovo sviluppatore del team potrebbe non conoscere questo pacchetto personalizzato e dovrai spiegare cos'è e perché l'hai scelto.

La battaglia principale avverrà tra abce Protocols. Ma se vuoi davvero una battaglia zopevs Protocols, leggi questa analisi dettagliata .

Controllo statico prima

Il grande presupposto che sto per fare è che sei già convinto che il controllo statico sia un must : non eseguirai il codice che fallisce pylint/mypy. Entrambe le pedine supportano abce Protocolsugualmente bene. Inoltre, sappi solo che entrambi abce Protocolsconsenti il controllo del runtime, nel caso ne avessi bisogno.

Entrambi supportano la sintassi esplicita

Innanzitutto, tieni presente che puoi ancora ereditare esplicitamente da an abc e a Protocol. Molti argomenti in un ottimo video (e commenti) di Arjan ruotano attorno all'idea sbagliata che non si possa fare con i protocolli. Puoi assolutamente:

class Giraffe(Animal):
   ...

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)

abcsupportano anche interfacce implicite attraverso il concetto di “ sottoclassi virtuali ”. Ma devi chiamare registerper ogni implementazione:

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

I protocolli consentono di definire un'interfaccia per una funzione (non solo una classe) — vedi protocolli di callback . È una funzionalità molto interessante che merita un post separato.

Entrambi supportano i metodi predefiniti (purtroppo)

C'è un grosso svantaggio in entrambi abce Protocols. Nel mondo reale, molte persone lavorano in un'unica base di codice. Le classi di base astratte a volte tendono ad acquisire implementazioni di metodi predefiniti. Ecco come potrebbe apparire:

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.

I protocolli sono più brevi

Ultimo ma non meno importante, puoi contare il numero di righe di codice necessarie per definire un'interfaccia. Con abc, devi avere un abstractmethoddecoratore per ogni metodo. Ma con i protocolli senza controllo di runtime, non è necessario utilizzare alcun decoratore. Quindi qui, i protocolli vincono a mani basse.

Conclusione

Sommiamo i punteggi:

Spero di non perdere nulla di enorme in questa analisi. Guardando i risultati, vince il team "Protocolli" e probabilmente dovresti iniziare a usarlo!