HOWTO · Python

Surcharger un constructeur en Python

Ce tutoriel montre comment surcharger un constructeur en Python

Sur cette page

Python ne choisit pas entre plusieurs méthodes __init__ en faisant correspondre leurs paramètres. Si une classe définit __init__ plusieurs fois, la définition la plus récente remplace la précédente : c’est donc la seule qui est disponible lors de la création d’une instance. Pour proposer plusieurs façons d’initialiser un objet, regroupez les choix dans un seul initialiseur, exposez des méthodes de fabrique nommées ou attribuez des valeurs par défaut pertinentes aux paramètres de l’initialiseur.

Ce que signifie la surcharge de constructeur en Python

Dans les langages qui prennent en charge la surcharge des constructeurs selon leur signature, l’exécution peut choisir un constructeur en fonction du type ou du nombre de ses paramètres. Python ne fait pas cela lorsque plusieurs définitions de __init__ sont présentes. Un seul __init__ peut accepter différents arguments et effectuer un choix explicite, mais il s’agit d’une sélection au sein d’une méthode, et non d’une surcharge native. Décrivez clairement les formes acceptées afin que les appelants sachent quelles valeurs la classe prend en charge.

Utiliser *args pour choisir selon le type ou le nombre d’arguments

Le paramètre *args rassemble les arguments positionnels dans un tuple. Vous pouvez examiner sa longueur ou le type des valeurs, puis initialiser l’instance en conséquence. Vérifiez qu’un argument existe avant de le lire et décidez comment la classe doit réagir lorsqu’une forme d’entrée n’est pas prise en charge. L’exemple exécutable suivant accepte un entier ou une chaîne et affiche la valeur choisie.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

class Greeting:
    def __init__(self, *args):
        if len(args) != 1:
            self.message = "Pass one integer or string"
        else:
            value = args[0]
            if isinstance(value, int):
                self.message = str(value)
            elif isinstance(value, str):
                self.message = "Hello from " + value
            else:
                self.message = "Pass an integer or string"


print(Greeting("Delft").message)

Vérifier le nombre d’arguments avant d’accéder à args[0] permet de traiter sans risque un appel sans argument positionnel. Cette vérification rejette aussi les arguments supplémentaires. En Python, bool est une sous-classe de int : isinstance(True, int) renvoie donc True. Si les booléens ne doivent pas être acceptés comme des entiers, utilisez une vérification exacte du type.

Une sélection fondée sur le nombre d’arguments est utile lorsque chaque nombre d’arguments positionnels a une signification claire. Cet initialiseur accepte exactement zéro, un ou deux arguments : sans argument, il choisit l’intervalle par défaut ; avec un argument, celui-ci indique la borne de fin ; avec deux, ils indiquent les bornes de début et de fin. Tout autre nombre d’arguments donne lieu à un message explicite. Chaque branche vérifie le nombre d’arguments avant de lire args, de sorte que ni le cas sans argument ni celui d’un nombre non pris en charge ne tente d’accéder à une valeur absente.

Exécutez cet exemple :

class RangeSpec:
    def __init__(self, *args):
        if len(args) == 0:
            self.start, self.stop = 0, 10
        elif len(args) == 1:
            self.start, self.stop = 0, args[0]
        elif len(args) == 2:
            self.start, self.stop = args
        else:
            self.start, self.stop = None, None
            self.message = "Pass zero, one, or two values"

    def describe(self):
        if self.start is None:
            return self.message
        return f"Range from {self.start} to {self.stop}"


for spec in (RangeSpec(), RangeSpec(5), RangeSpec(2, 5), RangeSpec(1, 2, 3)):
    print(spec.describe())

Les quatre appels couvrent tous les nombres d’arguments acceptés ainsi qu’un nombre supérieur à la limite. Si vous devez gérer davantage de formes, préférez des paramètres nommés ou des méthodes de fabrique : les appelants n’auront pas à se souvenir de la signification de chaque nombre d’arguments positionnels.

Utiliser les méthodes de fabrique @classmethod comme constructeurs alternatifs

Une méthode @classmethod reçoit la classe comme premier argument, généralement nommé cls. Une méthode de fabrique peut convertir une autre représentation en valeurs requises par l’initialiseur habituel, puis renvoyer cls(...). Elle crée ainsi une instance et fonctionne aussi naturellement avec les sous-classes, car cls désigne la classe depuis laquelle la méthode a été appelée. Les méthodes de fabrique sont des chemins de création nommés ; elles n’ajoutent pas de surcharges à __init__.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @classmethod
    def from_pair(cls, pair):
        return cls(pair[0], pair[1])


point = Point.from_pair((3, 4))
print(point.x, point.y)

Utilisez des méthodes de fabrique distinctes lorsque les formats d’entrée ont des noms évocateurs, par exemple from_file, from_row ou from_coordinates. Validez ou normalisez les données dans la fabrique lorsque cette responsabilité relève de la conversion. Gardez l’initialiseur principal comme unique endroit où établir l’état requis de l’objet.

Utiliser des arguments par défaut pour les initialisations facultatives

Les valeurs par défaut conviennent lorsque les paramètres sont réellement facultatifs et que leur signification reste claire. Elles permettent aux appelants d’omettre des valeurs sans ajouter de logique de sélection. Préférez des valeurs par défaut immuables, comme des nombres, des chaînes ou None ; une valeur mutable telle qu’une liste devrait généralement être créée dans la méthode afin que les instances ne la partagent pas par inadvertance.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

class Profile:
    def __init__(self, name="Guest", score=0):
        self.name = name
        self.score = score


for profile in (Profile(), Profile("Mina"), Profile("Mina", 7)):
    print(profile.name, profile.score)

Ici, les appelants peuvent omettre les deux valeurs facultatives, fournir uniquement un nom ou fournir les deux valeurs. Les valeurs par défaut sont moins adaptées lorsque l’omission peut avoir plusieurs significations, lorsque les paramètres dépendent les uns des autres ou lorsque de nombreuses combinaisons positionnelles deviennent difficiles à retenir. Dans ces cas, des paramètres réservés aux mots-clés ou des méthodes de fabrique nommées peuvent rendre les appels plus clairs.

Choisir le bon modèle de constructeur

Utilisez des valeurs par défaut pour quelques valeurs facultatives courantes. Choisissez une méthode de fabrique lorsque la création commence à partir d’une autre représentation ou lorsque le chemin de création mérite un nom descriptif. N’utilisez la sélection avec *args que si un ensemble réduit et stable de formes positionnelles fait partie de l’API prévue ; vérifiez le nombre et le type des arguments avant d’utiliser les valeurs. Pour les validations complexes, des branches explicites et des messages d’erreur utiles sont plus faciles à maintenir que des astuces de typage ingénieuses.

Ces techniques peuvent être combinées : les fabriques peuvent valider les données puis appeler le même initialiseur, tandis que les valeurs par défaut prennent en charge les champs facultatifs. Choisissez l’interface la plus simple qui rend les appels valides évidents et les appels non pris en charge prévisibles. La règle essentielle est que Python ne conserve qu’une seule définition effective de __init__ par classe ; la souplesse vient de la logique et des solutions de remplacement nommées que vous ajoutez autour.