Appel d'une méthode surchargée, superclasse une méthode surchargée d'appels

Ce code génère une exception, AttributeError, "wtf!"parce que A.foo() appelle B.foo1()ne devrait-elle pas appel A.foo1()? Comment puis-je le forcer à appeler A.foo1() (et tout appel de méthode à l'intérieur de A.foo() doit appeler A.*)

class A(object):
    def foo(self):
        print self.foo1()

    def foo1(self):
        return "foo"

class B(A):
    def foo1(self):
        raise AttributeError, "wtf!"

    def foo(self):
        raise AttributeError, "wtf!"

    def foo2(self):
        super(B, self).foo()

myB = B()
myB.foo2()

source d'informationauteur Perico de los palotes

En classe au lieu d'appeler self méthodes, vous devez appeler A les méthodes et les passer dans self manuellement.

Ce n'est pas la façon normale de faire les choses, vous devriez avoir un vraiment bonne raison de le faire comme ça.

class A(object):
    def foo(self):
        print A.foo1(self)

    def foo1(self):
        return "foo"

class B(A):
    def foo1(self):
        raise AttributeError, "wtf!"

    def foo(self):
        raise AttributeError, "wtf!"

    def foo2(self):
        super(B, self).foo()

myB = B()
myB.foo2()

6

Il fonctionne comme prévu, que 100% de la programmation des langues de travail. Sous-classe remplace TOUTES les méthodes de la classe parent.

Toutefois, si vous avez vraiment vraiment envie d'appel de l'A. foo1 (), vous pourriez être en mesure de le faire comme cela (je ne peux pas garantir). Et dans tous les cas, vous ne devez pas faire cela puisque c'est contre tous les principes de bonne programmation.
```
 class A(object):

    def foo(self):
        A.foo1(self)
```
3

Dans le code:
```
def foo2(self):
    super(B, self).foo()
```
auto est une instance de B.

Lorsqu'une méthode dérivée de l'Un est appelé par une instance de B, il va commencer à la recherche dans l'espace de noms à partir de B, et seulement si la méthode n'est pas trouvée (par exemple, n'est pas remplacée par B) la mise en œuvre d'Un est utilisé, mais toujours avec l'auto référence à B. À aucun moment, l'auto est une instance de A.
-1

On peut voir ce que Python est en train de faire ici, mais la manière de surcharge est un peu extrême. Prenons par exemple le cas lorsque la classe A définit les 100 attributs et la classe B hérite de ces et ajouter 1 au-delà de l'attribut. Nous voulons être en mesure d'avoir le __init__() pour B appellent le __init__() pour l'Un et laissez-B du code de définir qu'un seul attribut. De même, si nous définissons une méthode reset() dans Une de définir tous les attributs à zéro, alors le correspondant de la méthode reset() pour B devrait être en mesure de simplement appeler la méthode reset() pour l'Un, puis à zéro, le seul B attribut au lieu d'avoir à dupliquer tout d'Un code. Python est difficile ce qui est censé être un des principaux avantages de la programmation orientée objet, qui est, à la réutilisation de code. La meilleure solution ici est d'éviter d'écraser les méthodes que nous avons vraiment envie de les réutiliser. Si vous voulez avoir une idée des complications avec Python ici, essayez ce code:
```
class X(object):
    def __init__ ( self ):
        print "X"
        self.x = 'x'
        self.reset()
        print "back to X"
    def reset ( self ):
        print "reset X"
        self.xx = 'xx'

class Y(X):
    def __init__ ( self ):
        print "Y"
        super(Y,self).__init__()
        self.y = 'y'
        self.reset()
        print "back to Y"
    def reset ( self ):
        print "reset Y"
        super(Y,self).reset()
        print "back to reset Y"
        self.yy = 'yy'

aY = Y()
```
(Pour faire ce travail correctement, retirez-le de l'auto.reset() appel dans __init__() pour la classe Y.)

Vous devez vous connecter pour publier un commentaire.