Passage de paramètre de constructeur de classe de base ou à l'aide de variable d'instance?

Toutes les classes dérivées à partir d'une certaine classe de base ont pour définir un attribut appelé "chemin d'accès". Dans le sens de duck-typing je pouvais compter sur la définition de la sous-classes:

class Base:
    pass # no "path" variable here

def Sub(Base):
    def __init__(self):
        self.path = "something/"

Une autre possibilité serait d'utiliser le constructeur de classe de base:

class Base:
    def __init__(self, path):
        self.path = path

def Sub(Base):
    def __init__(self):
        super().__init__("something/")

J'utilise Python 3.1.

Ce que vous préférez et pourquoi? Est-il un meilleur moyen?

OriginalL'auteur deamon | 2010-04-28

  1. 11

    En Python 3.0+:

    Je voudrais aller avec un paramètre de la classe de base du constructeur que vous avez dans le deuxième exemple. Comme cela force les classes qui dérivent de Base afin de fournir le chemin d'accès à la propriété, qui documente le fait que la classe a une propriété de ce type et que les classes dérivées sont tenus de les fournir. Sans elle, vous seriez compter sur ceci étant dit (et lire) quelque part dans votre classe docstrings, bien qu'il n'est certainement aider à aussi de l'état dans la docstring ce que la propriété en particulier de moyens.

    En Python 2.6+:

    Je voudrais utiliser ni de la ci-dessus; au lieu de cela je voudrais utiliser:

    class Base(object):
    def __init__(self,path):
        self.path=path;

class Sub(Base):
    def __init__(self):
       Base.__init__(self,"something/")

    En d'autres termes, j'aurais besoin d'un tel paramètre dans la base du constructeur de la classe, parce qu'il atteste le fait que tous ces types de/utiliser/besoin de ce paramètre et le paramètre doit être provieded. Cependant, je ne voudrais pas utiliser super ()super est un peu fragile et dangereux en Python, et je voudrais aussi faire la Base d'un new-style classe en héritant de l'objet (ou de quelques autres nouvelles de style) de la classe.

    Il n'y a rien de fragile sur super(). La fragilité est dans le 2.x la syntaxe, qui est fixé à 3.x (que l'OP est en utilisant, comme illustré par la super() appel), et l'héritage multiple en général. Il n'y a pas de raison que ce soit à l'appel de la baseclass méthode directement en Python 3.x, le super().__init(...) syntaxe n'est jamais pire et souvent mieux.
    à en juger par l'utilisation de super, je suppose que le démon est à l'aide de py3k
    Wouters: comment voulez-vous utiliser super si vous avez tous l'héritage multiple et les classes de base avec différents constructeur de signatures ? Le passage de tous les arguments des classes dérivées pour toutes les classes de base ressemble à un gros hack, en s'appuyant sur les paramètres nommés et laissez-les classes de base de trier ce qu'ils ont besoin n'est pas beaucoup plus agréable.

    OriginalL'auteur Michael Aaron Safyan