Impedire la funzione ignorare in Python

Question

Esiste un modo per impedire a una classe figlia di eseguire l'override di un metodo nella classe base?

La mia ipotesi è che non ci sia, ma vengo dal mondo .NET, e sto cercando di rendere la mia API più solida possibile, quindi ogni input è molto apprezzato.

class Parent: 
    def do_something(self): 
     '''This is where some seriously important stuff goes on''' 
     pass 

class Child(Parent): 
    def do_something(self): 
     '''This should not be allowed.''' 
     pass 

È possibile far rispettare questo? So che il compilatore non aiuterà, quindi forse per mezzo di alcuni controlli di runtime? O non è solo un modo pitonico di parlare delle cose?

Answer 1

Hai ragione: ciò che stai tentando è contrario alla struttura di Python e alla sua cultura.

Documenta la tua API e istruisci i tuoi utenti su come utilizzarlo. È il loro programma, quindi se vogliono ancora scavalcare la tua funzione, chi sei tu per prevenirli?

Answer 2

Se un'API consente di fornire sottoclassi di una determinata classe e chiama i metodi (legalmente) sovrascritti, ma anche altri metodi API di quella classe con nomi semplici come "aggiungi", sovrascrivendo accidentalmente tali metodi potrebbe portare a -track-down bugs. È meglio avvisare almeno l'utente.

I casi in cui un utente desidera/ha bisogno di eseguire l'override di un metodo che interromperà completamente l'API è praticamente pari a zero. I casi in cui un utente ignora per errore qualcosa che non dovrebbe e ha bisogno di ore per trovare il colpevole sono molto più frequenti. Il debug del comportamento errato causato da questo può essere ingombrante.

Questo è il modo che uso per mettere in guardia o proteggere gli attributi impedire che vengano accidentalmente sovrascritti:

def protect(*protected): 
    """Returns a metaclass that protects all attributes given as strings""" 
    class Protect(type): 
     has_base = False 
     def __new__(meta, name, bases, attrs): 
      if meta.has_base: 
       for attribute in attrs: 
        if attribute in protected: 
         raise AttributeError('Overriding of attribute "%s" not allowed.'%attribute) 
      meta.has_base = True 
      klass = super().__new__(meta, name, bases, attrs) 
      return klass 
    return Protect 

è possibile utilizzarlo in questo modo:

class Parent(metaclass=protect("do_something", "do_something_else")): 
    def do_something(self): 
     '''This is where some seriously important stuff goes on''' 
     pass 

class Child(Parent): 
    def do_something(self): 
     '''This will raise an error during class creation.''' 
     pass 

Answer 3

Uzumaki già fornito una metaclasse come possibile soluzione alla domanda posta sopra, ma qui c'è un altro esempio di utilizzo. Dopo aver tentato di creare una classe Child, viene mostrato un altro modo per rendere difficile l'override dei metodi. Mettendo due underscore prima, ma non dopo un nome di attributo, verrà automaticamente richiamato il nome del mangling. Vedere this answer per un'altra domanda per un modo facile da usare per accedere a questa abilità manualmente.

#! /usr/bin/env python3 
class Access(type): 

    __SENTINEL = object() 

    def __new__(mcs, name, bases, class_dict): 
     private = {key 
        for base in bases 
        for key, value in vars(base).items() 
        if callable(value) and mcs.__is_final(value)} 
     if any(key in private for key in class_dict): 
      raise RuntimeError('certain methods may not be overridden') 
     return super().__new__(mcs, name, bases, class_dict) 

    @classmethod 
    def __is_final(mcs, method): 
     try: 
      return method.__final is mcs.__SENTINEL 
     except AttributeError: 
      return False 

    @classmethod 
    def final(mcs, method): 
     method.__final = mcs.__SENTINEL 
     return method 


class Parent(metaclass=Access): 

    @Access.final 
    def do_something(self): 
     """This is where some seriously important stuff goes on.""" 
     pass 


try: 
    class Child(Parent): 

     def do_something(self): 
      """This should not be allowed.""" 
      pass 
except RuntimeError: 
    print('Child cannot be created.') 


class AnotherParent: 

    def __do_something(self): 
     print('Some seriously important stuff is going on.') 

    def do_parent_thing(self): 
     self.__do_something() 


class AnotherChild(AnotherParent): 

    def __do_something(self): 
     print('This is allowed.') 

    def do_child_thing(self): 
     self.__do_something() 


example = AnotherChild() 
example.do_parent_thing() 
example.do_child_thing()