Classi astratte di Python - come scoraggiare l'istanza?

Question

Provengo da uno sfondo C# in cui la lingua ha alcune funzioni integrate di "protezione dello sviluppatore". Capisco che Python prende l'approccio "siamo tutti adulti qui" e attribuisce la responsabilità allo sviluppatore di codificarlo attentamente e con attenzione.

Detto questo, Python suggerisce convenzioni come un trattino di sottolineatura principale per variabili di istanze private. La mia domanda è, c'è una particolare convenzione per marcare una classe come astratta oltre a specificarla solo nelle docstring? Non ho visto nulla in particolare nella guida di stile Python che menzioni le convenzioni di denominazione per le classi astratte.

posso pensare di 3 opzioni finora, ma non sono sicuro se sono buone idee:

1. specificarlo nella docstring di sopra della classe (potrebbe essere trascurato)
2. Utilizzare un leader sottolineatura nel nome della classe (non sicuro se questo è universalmente compreso)
3. Creare un metodo def __init__(self): nella classe astratta che genera un errore (non è sicuro se questo influisce negativamente sull'ereditarietà, ad esempio se si desidera chiamare un costruttore di base)

Una di queste è una buona opzione o ce n'è una migliore? Voglio solo assicurarmi che gli altri sviluppatori sappiano che è astratto e quindi se tentano di istanziarlo devono accettare la responsabilità di qualsiasi comportamento strano.

Answer 1

Se si utilizza Python 2.6 o versione successiva, è possibile utilizzare il modulo Abstract Base Class dalla libreria standard se si desidera applicare l'astrattezza.Ecco un esempio:

from abc import ABCMeta, abstractmethod 

class SomeAbstractClass(object): 
    __metaclass__ = ABCMeta 

    @abstractmethod 
    def this_method_must_be_overridden(self): 
     return "But it can have an implementation (callable via super)." 

class ConcreteSubclass(SomeAbstractClass): 
    def this_method_must_be_overridden(self): 
     s = super(ConcreteSubclass, self).this_method_must_be_overridden() 
     return s.replace("can", "does").replace(" (callable via super)", "") 

uscita:

>>> a = SomeAbstractClass() 
Traceback (most recent call last): 
    File "<pyshell#13>", line 1, in <module> 
    a = SomeAbstractClass() 
TypeError: Can't instantiate abstract class SomeAbstractClass with abstract 
methods this_method_must_be_overridden 
>>> c = ConcreteSubclass() 
>>> c.this_method_must_be_overridden() 
'But it does have an implementation.' 

Answer 2

Sulla base dell'ultima frase, risponderei alla risposta "documentalo". Chiunque usi una classe in un modo che la documentazione dice di non accettare deve assumersi la responsabilità di qualsiasi comportamento strano.

C'è un meccanismo abstract base class in Python, ma non vedo alcun motivo per usarlo se il tuo unico obiettivo è scoraggiare l'istanza.

Answer 3

Crea la tua classe "astratta" e utilizza return NotImplemented o raise NotImplementedError nei metodi astratti.

Non fermerà le persone che usano la classe, ma con la vera dattilografia, diventerà un problema solo quando si tenta di utilizzare il metodo astratto.

Answer 4

Ho appena chiamato le mie classi astratte con il prefisso 'Abstract'. Per esempio. AbstractDevice, AbstractPacket, ecc.

È facile e al punto che arriva. Se gli altri scelgono di andare avanti e creare un'istanza e/o utilizzare una classe che inizia con la parola "Abstract", allora o sanno cosa stanno facendo o non c'è speranza per loro comunque.

Chiamarlo così, serve anche da promemoria per me stesso di non impazzire con le gerarchie astratte profonde, perché mettere "Abstract" sul fronte di un sacco di classi sembra stupido anche.

Answer 5

Per applicare le cose è possibile, ma piuttosto unpythonic. Quando sono arrivato in Python dopo molti anni di programmazione in C++, ho anche provato a fare lo stesso, suppongo, la maggior parte delle persone prova a farlo se ha un'esperienza in più lingue classiche. I metaclassi farebbero il lavoro, ma in ogni caso Python controlla pochissime cose al momento della compilazione. Il controllo verrà comunque eseguito in fase di runtime. Quindi, l'impossibilità di creare una determinata classe è davvero utile se scoperta solo in fase di runtime? In C++ (e anche in C#) non puoi nemmeno compilare il codice creando una classe astratta, e questo è l'intero punto - per scoprire il problema il prima possibile. Se hai metodi astratti, sollevare un'eccezione NotImplementedError sembra essere abbastanza. NB: rilanciando, non restituendo un codice di errore! In Python gli errori di solito non dovrebbero essere silenziosi a meno che non siano silenziati esplicitamente. Documentare. Denominare una classe in un modo che dice che è astratto. È tutto.

La qualità del codice Python è assicurata principalmente con metodi molto diversi da quelli utilizzati nelle lingue con controllo di tipo avanzato in fase di compilazione. Personalmente ritengo che la differenza più importante tra gli script dinamicamente tipizzati e gli altri. Test unitari, analisi della copertura, ecc. Come risultato, la progettazione del codice è molto diversa: tutto viene fatto per non far rispettare le cose, ma per renderle più semplici possibile.