Python redéfinition de Méthode, ne la signature de la matière?

Permet de dire que j'ai

class Super():
  def method1():
    pass

class Sub(Super):
  def method1(param1, param2, param3):
      stuff

Est-ce correct? Aura des appels à method1 toujours aller à la sous-classe? Mon plan est de 2 sous classes de chaque remplacement method1 avec différents paramètres

InformationsquelleAutor asdasasdsa | 2011-05-17

33

Python permettra à cela, mais si method1() est destiné à être exécuté à partir d'un code externe, alors vous pouvez vouloir reconsidérer cette, car elle viole LSP et donc ne fonctionne pas toujours correctement.
- Est la violation de LSP sur le fait que des Sous.method1 prend 3 arguments tout Super.method1 prend aucun rendant en fait différentes interfaces?
- Correct. Ceci peut être résolu par le fait d'avoir les arguments de la sous-classe de la méthode de toutes les valeurs par défaut, mais vous trouvez alors dans les qui par défaut serait approprié.
- Je vois. Mais alors juste pour clarifier. Si le parent method1 a été définie comme Super.method1(param1=None, param2=None, param3=None) il serait encore violer LSP si sur les sous-classes il est défini comme Sub.method1(param1, param2, param3) droit? En tant qu'attributs sont obligatoires dans un cas mais pas dans l'autre. Donc à ma connaissance, sans modification de la sous-classe de l'interface, la seule façon de ne pas enfreindre LSP serait d'avoir les paramètres sans valeurs par défaut sur le parent. Suis-je correct sur ce ou de sur-interpréter le LSP?
- Aussi correcte. Avoir le contrat deviennent de moins en moins restrictive dans la sous-classe viole LSP.
InformationsquelleAutor Ignacio Vazquez-Abrams
8

Python permet de "substitution" des méthodes avec des signatures différentes, mais vous ne pouvez jamais avoir deux méthodes avec le même nom dans la même classe, même si leurs signatures sont différentes (pas de surcharge de la méthode). Dans le cas de la méthode de remplacement, si vous appelez les méthodes avec le mauvais nombre de paramètres définis pour l'objet, vous obtiendrez une erreur. Rappelez-vous, Python méthodes sont juste des paires clé-valeur dans dictionnaire attaché à l'objet, et "substitution de" d'un montant de simplement remplacer la valeur dans le dictionnaire copié d'abord à partir de la classe de base dictionnaire pour la même clé.

Il y a souvent des scénarios où vous souhaitez méthode de la classe dérivée ont supplémentaires paramètres de la classe de base. Pour ce faire en Python tout en préservant LSP, vous pouvez utiliser la technique suivante:
```
class Base:
    def hello(self, name, *kargs, **kwargs):
        print("Hello", name)

class Derived(Base):
      def hello(self, name, age=None, *kargs, **kwargs):
          super(Derived, self).hello(name, age, *kargs, **kwargs) 
          print('Your age is ', age)

b = Base()
d = Derived()

b.hello('Alice')
b.hello('Bob', age=24)
d.hello('Rick')
d.hello('John', age=30)
```
Ci-dessus affichera:
```
Hello Alice
Hello Bob
Hello Rick
Your age is  None
Hello John
Your age is  30
```
Jouer avec ce code

InformationsquelleAutor Shital Shah
1

En python, toutes les méthodes de la classe sont "virtuels" (en termes de C++). Ainsi, dans le cas de votre code, si vous souhaitez appeler method1() dans la super-classe, il faut:
```
class Super():
    def method1(self):
        pass

class Sub(Super):
    def method1(self, param1, param2, param3):
       super(Sub, self).method1() # a proxy object, see http://docs.python.org/library/functions.html#super
       pass
```
Et la signature de la méthode a de l'importance. Vous ne pouvez pas appeler une méthode comme ceci:
```
sub = Sub()
sub.method1() 
```
InformationsquelleAutor Zaur Nasibov

Cela fonctionne:

>>> class Foo(object):
...   def Bar(self):
...     print 'Foo'
...   def Baz(self):
...     self.Bar()
... 
>>> class Foo2(Foo):
...   def Bar(self):
...     print 'Foo2'
... 
>>> foo = Foo()
>>> foo.Baz()
Foo
>>> 
>>> foo2 = Foo2()
>>> foo2.Baz()
Foo2

Cependant, ce n'est généralement pas recommandé. Jetez un oeil à S. Lott's réponse: Méthodes avec le même nom et les différents arguments sont d'une odeur de code.

InformationsquelleAutor quasistoic

Vous pourriez faire quelque chose comme ceci si c'est ok pour utiliser la valeur par défaut arguments:

>>> class Super():
...   def method1(self):
...     print("Super")
...
>>> class Sub(Super):
...   def method1(self, param1="X"):
...     super(Sub, self).method1()
...     print("Sub" + param1)
...
>>> sup = Super()
>>> sub = Sub()
>>> sup.method1()
Super
>>> sub.method1()
Super
SubX

InformationsquelleAutor Zitrax

-2

Oui. Les appels à "method1" la volonté de toujours aller à la sous-classe. Signature de la méthode en Python uniquement composé du nom et de ne pas la liste d'arguments.
- Réponse fausse. Signature de la méthode toujours des questions, car il n'y a pas de surcharge de fonctions, comme il arrive en C/C++.
- Ce que je veux dire, est-Python ne pas envisager de la liste d'arguments pour déterminer la méthode à appeler, mais je suppose que vous avez raison lorsque vous cherchez à partir de que angle!
InformationsquelleAutor Elektito

Vous devez vous connecter pour publier un commentaire.