Python: Hériter de la superclasse init

J'ai une classe de base avec beaucoup de __init__ arguments:

def BaseClass(object):
    def __init__(self, a, b, c, d, e, f, ...):
        self._a=a+b
        self._b=b if b else a
        ...

Toutes les classes héritant doit s'exécuter __init__ méthode de la classe de base.

Je peux écrire un __init__() méthode dans chacune des classes héritant qui ferait appel de la super-classe __init__, mais ce serait une grave duplication de code:

def A(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

def B(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

def C(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        super(A, self).__init__(a, b, c, d, e, f, ...)

...

Ce qui est le plus Pythonic automatique d'appel de la super-classe __init__?

InformationsquelleAutor Adam Matan | 2011-06-30

48
```
super(SubClass, self).__init__(...)
```
Pensez à utiliser *args et **kw si elle contribue à la résolution de votre variable cauchemar.
- Cela aide, mais est-il un moyen d'éviter complètement les appelant explicitement la super-classe init?
- Aussi en Python 3, super().__init__(...) fonctionne.
- Matan Non, il n'y en a pas. Voir ici pourquoi: Pourquoi ne pas Python superclasse init méthodes invoquée automatiquement?
- Plus Plus correct, mais il nécessite toujours la fâcheuse duplication de code pour chaque classe de base.
- Il y a aucune différence de BaseClass.__init__(self,*args,*kwargs) et super(BaseClass, self).__init__(*args,*kwargs) ?
- oui. Si vous avez appelé BaseClass.__init__ à l'intérieur de BaseClass(): __init__: vous obtenez une récursion infinie. super appelle la classe parent.
- Désolé, j'ai une question très stupide. En Python 3, comment puis-je utiliser les points de suspension pour nourrir le __init__()? J'ai continué de faire des erreurs. Lorsque vous les gars utilisés "...", avez-vous vraiment dire, des points de suspension dans le code ou c'était juste pour vous épargner de la saisie?
- que faire si je veux passer de nouveaux paramètres dans la classe A?
InformationsquelleAutor Andreas Jung
32

Vous devez l'écrire explicitement, mais d'un autre côté, si vous avez beaucoup d'arguments, vous devriez probablement utiliser *args de positionnement args et **kwargs pour le mot-clé args.
```
class SubClass(BaseClass):
    def __init__(self, *args, **kwargs):
        super(SubClass, self).__init__(*args, **kwargs)
        # SubClass initialization code
```
Une autre technique que vous pouvez utiliser est de minimiser le code dans init et puis à la fin de init fonction, appeler une autre fonction personnalisée. Puis, dans la sous-classe, il vous suffit de remplacer la fonction personnalisée
```
class BaseClass(object):
    def __init__(self, *args, **kwargs):
        # initialization code
        self._a = kwargs.get('a')
        ...
        # custom code for subclass to override
        self.load()

    def load():
        pass

class SubClass(BaseClass)
    def load():
        # SubClass initialization code
        ...
```
- C'est une technique que j'ai utilisé, dans certains cas, aller jusqu'à fournir preinit() et postinit() crochets. La valeur de retour de preinit() peut être enregistré dans une variable locale dans __init__ et passé à postinit(), ce qui est pratique parfois.
- Je veux écrire une super-classe qui n'quelques modestes, uniforme membre de la vérification de la sous-classe des instances (viz., que nécessaire membre variables existent et ont sane contenu), dans le cadre de leur __init__ processus. Je pense que ce genre de postinit() crochet devrait fonctionner parfaitement.
- amélioration: kwargs.get('a', defaultvaluehere) au lieu de kwargs.get('a')
InformationsquelleAutor Ryan Ye
18

Si les classes dérivées ne pas mettre en œuvre quelque chose au-delà de ce que la classe de base __init__() déjà fait, omettez simplement les classes dérivées __init__() méthodes de la classe de base __init__() est alors appelé automatiquement.

Si, otoh, que, vos classes dérivées ajouter un peu de travail supplémentaire dans leur __init__(), et vous n'en voulez pas à appeler explicitement leur classe de base __init__(), vous pouvez le faire:
```
class BaseClass(object):
    def __new__(cls, a, b, c, d, e, f, ...):
        new = object.__new__(cls)
        new._a=a+b
        new._b=b if b else a
        ...
        return new

class A(BaseClass):
    ''' no __init__() at all here '''

class B(BaseClass):
    def __init__(self, a, b, c, d, e, f, ...):
        ''' do stuff with init params specific to B objects '''
```
Depuis __new__() est toujours appelé automatiquement, aucun travail supplémentaire n'est nécessaire dans les classes dérivées.
- Fine méthode, utile à savoir. +1. - Par ailleurs, comme dans la question, le code doit être corrigée: classe BaseClass(objet) au lieu de def BaseClass(objet)
- Merci & fait.
InformationsquelleAutor pillmuncher

Sauf si vous faites quelque chose d'utile dans la sous-classe __init__() méthodes, vous n'avez pas à le remplacer.

def BaseClass(object):
    def __init__(self, a, b, c, d, e, f, ...):
        self._a=a+b
        self._b=b if b else a
        ...

def A(BaseClass):
    def some_other_method(self):
        pass

def B(BaseClass):
    pass

InformationsquelleAutor Rob Cowie

4

Peut-être une meilleure mise en œuvre pour que votre affaire est à l'aide de **kwargs combinée avec de nouveaux arguments supplémentaires dans votre classe dérivée comme dans:
```
class Parent:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c


class Child(Parent):
    def __init__(self, d, **kwargs):
        super(Child, self).__init__(**kwargs)
        self.d = d
```
Par cette méthode, vous éviter la duplication de code, mais de préserver l'implicite plus d'arguments dans votre classe dérivée.
- toute solution devrait ressembler à celui-ci.
InformationsquelleAutor avielbl
2

En 2.6 et la version inférieure à hériter d'init de la classe de base, il n'y a pas de super fonction, Vous pouvez hériter ci-dessous moyen:
```
class NewClass():
     def __init__():
         BaseClass.__init__(self, *args)
```
InformationsquelleAutor Aashutosh jha
0

L'ajout d'un Pythonic mise en œuvre. En supposant que vous voulez tous les attributs transmis, vous pouvez utiliser le code ci-dessous. (Peut aussi garder/supprimer des kwargs clés si vous voulez un sous-ensemble).
```
def A(BaseClass):
    def __init__(self, *args, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

base = BaseClass(...)
new = A( **base.__dict__ )
```
InformationsquelleAutor Ben

Vous devez vous connecter pour publier un commentaire.