Convenciones de nombres de Python para atributos y métodos destinados a ser sobrescritos

Question

Tengo algún código orientado a objetos en Python, donde algunas clases deben extenderse para proporcionar los bits de código personalizados faltantes (a la Patrón de método de plantilla, pero también con variables), que solo serán utilizadas por la súper clase, no por el código del cliente que las usa.

¿Hay convenciones de estilo para tal? resumen (o aburrido, porque su implementación en la súper clase sería pass o criar un NonImplemented excepción) métodos y atributos?

He estado navegando por el PEP-0008 y solo se menciona sobre la preparación de un subrayado para privado Los miembros no pretenden ser utilizados por subclases.

Answer 1

En primer lugar, creo que estás equivocado cuando dices eso:

Acerca de la preparación del subrayado a los miembros privados que no pretenden ser utilizados por subclases.

En realidad, la preparación de un método/atributo por bajo es una convención de Python que significa que no se debe acceder a este método/atributo fuera de la clase (y su subclase) y creo que olvidó leer sobre el doble bajo que se usa para hacer un método /atributo no es posible anular.

class Foo(object):
    def __foo(self):
        print "foo"
    def main(self):
        self.__foo()


class Bar(Foo):
    def __foo(self):
        print "bar"


bar = Bar()
bar.main()
# This will print "foo" and not "bar".

---

Hay otra forma de declarar el método de stub por cierto que está utilizando abc.abcmeta y abc.abstractmethod.

Answer 2

Normalmente uso un solo subrayador, por ejemplo, _myvar Para métodos/atributos protegidos (como en C ++), que pueden ser utilizados por clases derivadas y usar doble subrayamiento, por ejemplo __var cuando no debe ser utilizado por nadie más, y como los nombres de doble órdenes en el nivel de definición de clase son maltratado, por lo que no pueden ser anulados en la clase derivada, por ejemplo

class A(object):
    def result1(self): # public method
        return self._calc1()

    def result2(self): # public method
        return self.__calc2()

    def _calc1(self): # protected method, can be overridden in derived class
        return 'a1'

    def __calc2(self): # private can't be overridden
        return 'a2'


class B(A):
    def _calc1(self):
        return 'b1'

    def __calc2(self):
        return 'b2'

a = A()
print a.result1(),a.result2()
b = B()
print b.result1(),b.result2()

Aquí parece una clase derivada B está anulando ambos _calc1 y __calc2 pero __calc2 no se anula porque su nombre ya está destrozado con el nombre de la clase y, por lo tanto, la salida es

a1 a2
b1 a2

en vez de

a1 a2
b1 b2

Pero en última instancia, elija cualquier convención y documente, también en el caso anterior, no es que la clase base no pueda anular privada, aquí hay una manera :)

class B(A):
    def _calc1(self):
        return 'b1'

    def _A__calc2(self):
        return 'b2'

Answer 3

Realmente no hay una convención de nombres para estos métodos porque tendrán el mismo nombre cuando sean anulados. ¡De lo contrario, no serían anulados! Creo que tener el método para ser anulado hace algo trivial y documentarlo en consecuencia, es lo suficientemente bueno:

class MyClass:

  def aMethod():
    '''Will be overridden in MyDerivedClass'''
    pass

El nombre de Mangling, que usted menciona en su pregunta, es útil si tiene un método no trivial que se anulará, pero aún desea poder acceder a la versión base. Ver la documentación Para más información y un ejemplo.