Python étendre avec l'aide de super() de Python 3 vs Python 2

À l'origine, je voulais vous demander cette question, mais ensuite j'ai trouvé qu'il y avait déjà pensé avant...

Recherche sur google, j'ai trouvé cet exemple de l'extension de configparser. Les œuvres suivantes avec Python 3:

$ python3
Python 3.2.3rc2 (default, Mar 21 2012, 06:59:51) 
[GCC 4.6.3] on linux2
>>> from configparser import  SafeConfigParser
>>> class AmritaConfigParser(SafeConfigParser):
...     def __init_(self):
...         super().__init__()
... 
>>> cfg = AmritaConfigParser()

Mais pas avec Python 2:

>>> class AmritaConfigParser(SafeConfigParser):
...       def __init__(self):
...           super(SafeConfigParser).init()
... 
>>> cfg = AmritaConfigParser()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __init__
TypeError: must be type, not classob

Puis j'ai lu un peu sur le langage Python Nouvelle Classe contre Classe Ancienne styles (par exemple,ici.
Et maintenant je me demande, je peux le faire:

class MyConfigParser(ConfigParser.ConfigParser):
      def Write(self, fp):
          """override the module's original write funcition"""
          ....
      def MyWrite(self, fp):
          """Define new function and inherit all others"""

Mais, je ne devrais pas appeler init? Est-ce en Python 2 l'équivalent:

 class AmritaConfigParser(ConfigParser.SafeConfigParser):
    #def __init__(self):
    #    super().__init__() # Python3 syntax, or rather, new style class syntax ...
    #
    # is this the equivalent of the above ? 
    def __init__(self):
        ConfigParser.SafeConfigParser.__init__(self)

Dans votre exemple, vous n'avez pas besoin de définir un __init__() dans la sous-classe si elle ne fait appel de la super-classe' __init__() (en Python 2 ou 3) -- au lieu de cela, laissez le super est être héritée.
Référence utile: amyboyle.ninja/Python-l'Héritage
Référence utile avec corrigé le lien: amyboyle.ninja/Python-l'Héritage

InformationsquelleAutor Oz123 | 2012-05-07

134
- super() (sans arguments) a été introduit en Python 3 (avec __class__):
```
super() -> same as super(__class__, self)
```
  alors que ce serait le Python 2 équivalent pour les nouvelles classes de style:
```
super(CurrentClass, self)
```
- pour les vieux style de classes, vous pouvez toujours utiliser:
```
 class Classname(OldStyleParent):
    def __init__(self, *args, **kwargs):
        OldStyleParent.__init__(self, *args, **kwargs)
```
- -1. Cette réponse n'a pas de préciser quelque chose pour moi. En Python 2, super(__class__) donne NameError: global name '__class__' is not defined, et super(self.__class__) est erronée ainsi. Vous doit fournir une instance comme deuxième argument, qui pourrait suggérer que vous devez faire super(self.__class__, self), mais c'est mal. Si Class2 hérite de Class1 et Class1 appels super(self.__class__, self).__init__(), Class1's __init__ ensuite appel en lui-même lors de l'instanciation d'une instance de Class2.
- Pour clarifier un point, je reçois TypeError: super() takes at least 1 argument (0 given) lorsque vous essayez d'appeler super(self.__class__) en Python 2. (Qui ne fait pas beaucoup de sens, mais il démontre à quel point l'information est manquante à partir de cette réponse.)
- en python2 vous obtenez cette erreur, parce que vous essayez d'appeler __init__() sans argument sur la unbound super objet (que vous pouvez obtenir en appelant super(self.__class__) avec un seul argument), vous avez besoin d'un bond super objet, alors il devrait fonctionner: super(CurrentClass, self).__init__(). N'utilisez pas de self.__class__ parce que cela va toujours se référer à la même de la classe lors de l'appel d'un parent et donc créer une boucle infinie si le parent fait de même.
- __class__ (membre) existe également dans Python2.
- Ce n'est pas sur la __class__ membre, mais sur le créé implicitement lexicale __class__ de fermeture qui fait toujours référence à la classe en cours de définition, qui n'existe pas dans python2.
InformationsquelleAutor mata
42

Dans un seul héritage cas (lorsque vous sous-classe d'une classe seulement), votre nouvelle classe hérite des méthodes de la classe de base. Cela comprend __init__. Donc, si vous ne définissez pas dans votre classe, vous obtiendrez l'une à partir de la base.

Les choses commencent à être compliqué si vous introduisez de l'héritage multiple (sous-classement plus qu'une seule classe à la fois). C'est parce que si plus d'une classe de base a __init__, votre classe héritera de la première seulement.

Dans de tels cas, vous devriez vraiment utiliser super si vous le pouvez, je vais vous expliquer pourquoi. Mais pas toujours, vous pouvez. Le problème est que tous vos classes de base doit également l'utiliser (et de leurs classes de base ainsi -- l'ensemble de l'arbre).

Si c'est le cas, alors cela fonctionnera correctement (en Python 3, mais vous pourriez le retravailler en Python 2 -- il a également super):
```
class A:
    def __init__(self):
        print('A')
        super().__init__()

class B:
    def __init__(self):
        print('B')
        super().__init__()

class C(A, B):
    pass

C()
#prints:
#A
#B
```
Notez comment les deux classes de base utilisation super même s'ils ne disposent pas de leurs propres classes de base.

Ce super est la suivante: il appelle la méthode de la classe suivante dans MRO (méthode de résolution de l'ordre). Le MRO pour C est: (C, A, B, object). Vous pouvez imprimer C.__mro__ pour le voir.

Donc, C hérite __init__ de A et super dans A.__init__ appels B.__init__ (B suit A dans MRO).

Donc en ne faisant rien dans C, vous vous retrouvez l'appel à la fois, qui est ce que vous voulez.

Maintenant, si vous n'étiez pas à l'aide de super, vous héritent A.__init__ (comme avant), mais cette fois, il n'y a rien qui mettrait B.__init__ pour vous.
```
class A:
    def __init__(self):
        print('A')

class B:
    def __init__(self):
        print('B')

class C(A, B):
    pass

C()
#prints:
#A
```
Pour corriger cela, vous devez définir C.__init__:
```
class C(A, B):
    def __init__(self):
        A.__init__(self)
        B.__init__(self)
```
Le problème c'est qu'en plus compliqué MI arbres, __init__ méthodes de certaines classes peut être appelé plus d'une fois alors que les super/MRO de garantir qu'elles sont appelé tout à la fois.
- Notice how both base classes use super even though they don't have their own base classes. Ils ont. Dans py3k tous les sous-classes de la classe de l'objet.
InformationsquelleAutor yak
22

En bref, ils sont équivalents.
Nous allons avoir une vue de l'historique:

(1) tout d'abord, la fonction ressemble à ceci.
```
    class MySubClass(MySuperClass):
        def __init__(self):
            MySuperClass.__init__(self)
```
(2) afin de rendre le code plus abstrait (et plus portable). Une méthode courante pour obtenir la Super-Classe est inventé comme:
```
    super(<class>, <instance>)
```
Et de la fonction init peut être:
```
    class MySubClassBetter(MySuperClass):
        def __init__(self):
            super(MySubClassBetter, self).__init__()
```
Toutefois exiger explicitement en passant à la fois de la classe de l'instance et de briser le DRY (Don't Repeat Yourself) règle un peu.

(3) en V3. Il est plus intelligent,
```
    super()
```
est suffisant dans la plupart des cas. Vous pouvez vous référer à http://www.python.org/dev/peps/pep-3135/

InformationsquelleAutor wuliang

Juste pour avoir un simple et complet exemple pour Python 3, la plupart des gens semblent être en utilisant maintenant.

class MySuper(object):
    def __init__(self,a):
        self.a = a

class MySub(MySuper):
    def __init__(self,a,b):
        self.b = b
        super().__init__(a)

my_sub = MySub(42,'chickenman')
print(my_sub.a)
print(my_sub.b)

donne

42
chickenman

InformationsquelleAutor Jonathan Mugan

Un autre python3 de mise en œuvre qui implique l'utilisation de classes Abstraites avec super(). Vous devez vous rappeler que

super().init(nom, 10)

a le même effet que

Personne.init(self, nom, 10)

Rappelez-vous il y a un caché "self" dans super(), de Sorte que le même objet passe à la superclasse méthode init et les attributs sont ajoutés à l'objet qui l'a appelée.
Donc super()se traduit à Person et puis, si vous incluez le moi caché, vous obtenez le code ci-dessus frag.

from abc import ABCMeta, abstractmethod
class Person(metaclass=ABCMeta):
    name = ""
    age = 0

    def __init__(self, personName, personAge):
        self.name = personName
        self.age = personAge

    @abstractmethod
    def showName(self):
        pass

    @abstractmethod
    def showAge(self):
        pass


class Man(Person):

    def __init__(self, name, height):
        self.height = height
        # Person.__init__(self, name, 10)
        super().__init__(name, 10)  # same as Person.__init__(self, name, 10)
        # basically used to call the superclass init . This is used incase you want to call subclass init
        # and then also call superclass's init.
        # Since there's a hidden self in the super's parameters, when it's is called,
        # the superclasses attributes are a part of the same object that was sent out in the super() method

    def showIdentity(self):
        return self.name, self.age, self.height

    def showName(self):
        pass

    def showAge(self):
        pass


a = Man("piyush", "179")
print(a.showIdentity())

InformationsquelleAutor SeasonalShot

Vous devez vous connecter pour publier un commentaire.