conventions de nommage Python pour les attributs et les méthodes destinées à ECRASEES

Question

J'ai un code orienté objet en Python, où certaines classes sont destinées à être étendu pour fournir les bits personnalisés manquants de code (à la modèle méthode modèle , mais aussi avec des variables), qui ne seront utilisées que par la super classe, et non par le code client de les utiliser.

Y a-t-il des conventions de style pour cette abstrait (ou terne, parce que leur mise en œuvre dans la super classe serait soit pass ou lever une exception NonImplemented) les méthodes et les attributs?

J'ai naviguer sur le PEP-0008 et il ne mentionne à propos de préfixer un trait de soulignement à privés membres pas destiné à être utilisé par les sous-classes.

Answer 1

Tout d'abord, je pense que vous vous trompez quand vous dites que:

à propos de préfixer underscore aux membres privés ne sont pas destinés à être utilisés par les sous-classes.

préfixer en fait une méthode / attribut par underscore est une convention de python que cela veut dire que cette méthode / attribut ne doit pas être accessible en dehors de la classe (et sa sous-classe) et je pense que vous avez oublié de lire la double underscore qui est utilisé pour faire une méthode / attribut pas possible de passer outre.

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".

---

Il y a une autre façon de déclarer la méthode stub par la voie qui utilise abc .ABCMeta et abc.abstractmethod .

Answer 2

J'utilise habituellement seul trait de soulignement par exemple _myvar pour protégé (comme en C ++) méthodes / attributs, qui peuvent être utilisés par les classes dérivées et utiliser le double trait de soulignement par exemple __var quand il ne doit pas être utilisé par quelqu'un d'autre, et que les noms double underscore au niveau de la définition de la classe sont mutilée , de sorte qu'ils ne peuvent pas être surchargée dans la classe dérivée par exemple

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()

Ici, il semble dérivé B de classe est prépondérant à la fois _calc1 et __calc2 mais __calc2 n'est pas surchargée car son nom est déjà mutilée avec le nom de classe et donc la sortie est

a1 a2
b1 a2

au lieu de

a1 a2
b1 b2

mais finalement choisir une convention et le documenter, même en cas ci-dessus, il est pas que la classe de base ne peut pas passer outre privée, voici une façon:)

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

    def _A__calc2(self):
        return 'b2'

Answer 3

Il n'y a pas vraiment une convention de nommage pour ces méthodes, car ils ont le même nom quand ils sont redéfinie. Sinon, ils ne seraient pas surchargée! Je pense avoir la méthode à faire quelque chose redéfinie trivial et documenter en conséquence, est assez bon:

class MyClass:

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

Nom mutiler, que vous mentionnez dans votre question, est utile si vous avez une méthode non-triviale qui substituera, mais vous voulez toujours être en mesure d'accéder à la version de base. Voir la documentation pour plus d'informations et un exemple.