Pourquoi la mutabilité des arguments par défaut de Python semble-t-elle violer le principe du moindre étonnement ?

Mutabilité des arguments par défaut et principe du moindre étonnement

La communauté Python est depuis longtemps aux prises avec le principe du «moindre étonnement», qui vise à des fonctionnalités de conception intuitives et conformes aux attentes. Cependant, la mutabilité des arguments par défaut présente un écart déroutant par rapport à ce principe.

Considérez la fonction suivante :

def foo(a=[]):
    a.append(5)
    return a

Les novices en Python pourraient anticiper que l'appel de cette fonction sans paramètres produirait systématiquement une liste avec un seul élément : [5]. Cependant, le comportement réel est bien plus particulier :

>>> foo()
[5]
>>> foo()
[5, 5]
>>> foo()
[5, 5, 5]
>>> foo()
[5, 5, 5, 5]

Ce comportement a suscité des critiques de la part de certains, qui le considèrent comme un « défaut de conception dramatique ». Cependant, il y a une explication logique derrière cela.

Les fonctions en Python sont des objets de première classe, ce qui signifie qu'elles peuvent être manipulées et affectées à des variables comme n'importe quel autre type. Lorsqu'une instruction def est exécutée, un objet fonction est créé. Cet objet contient non seulement le code de la fonction mais aussi ses arguments par défaut, qui sont stockés sous forme d'attributs.

Par défaut, les arguments par défaut sont évalués au moment de la définition de la fonction plutôt qu'au moment de l'appel de la fonction. Cela signifie que l'état des arguments par défaut peut changer tout au long de l'exécution du programme, conduisant au comportement observé dans la fonction foo.

Cette décision de conception découle de la nécessité de maintenir la cohérence. Si les arguments par défaut étaient évalués au moment de l'appel de la fonction, la ligne def deviendrait une instruction hybride, où une partie de la liaison se produirait à la fois lors de la définition et de l'invocation. Cette approche introduirait une complexité supplémentaire et une confusion potentielle.

Comme l'a noté l'effbot, ce comportement n'est pas sans applications pratiques. Par exemple, considérons le code suivant :

def a():
    print("a executed")
    return []

def b(x=a()):
    x.append(5)
    print(x)

a executed
>>> b()
[5]
>>> b()
[5, 5]

Ici, la valeur par défaut de x est évaluée au moment de la définition de la fonction, garantissant que a() n'est appelé qu'une seule fois, quel que soit le nombre de fois où b() est appelé. invoqué.

En conclusion, la mutabilité des arguments par défaut en Python est un choix de conception intentionnel qui donne la priorité à la cohérence et s'aligne sur le principe des fonctions de première classe. Bien que cela puisse sembler contre-intuitif au premier abord, cela offre un plus grand contrôle et une plus grande flexibilité dans la mise en œuvre des fonctions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!