Discussion :

[etienne.clopeau]

Bonjour,

j'ai un comportement que je ne comprend pas dans ce petit exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def test(toto = [0.,1.]):
    toto.append(2.)
    print toto
    return toto
 
test1 = test()
print 'test1',test1
 
test2 = test()
print 'test2',test2

Pourquoi les deux appelle à la fonction test ne renvoient pas la même chose !!!
a savoir
[0.,1.,2.]
puis [0.,1.,2.,2.] !

Pour que ca fonctionne je fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def test(toto = None):
    if toto == None : toto = [0.,1.]     
    toto.append(2.)
    print toto
    return toto

On m'avait déjà donné cette astuce dans un autre cas de figure.

Quelqu'un saurait m'expliquer pourquoi la première version n'est pas correct, et pourquoi les concepteurs de python ont souhaité ceci?

Cordialement,

[valAa]

Salut,
C'est très connu, voir ici http://docs.python.org/tutorial/cont...rgument-values le paragraphe "important warning".

Python n'évalue les arguments par défaut qu'une seule fois, lors des appels suivants de la fonction il se contente d'accéder à l'objet instancié la première fois.
Si l'objet en question est mutable (comme une liste), il peut très bien avoir été modifié entretemps (ce qui est le cas dans ton exemple).
Je ne sais pas ce qui a motivé ce fonctionnement, mais je suppose qu'il s'agissait à l'origine plus d'une facilité d'implémentation qu'autre chose.

PS : en tous cas, la méthode que tu utilises pour contourner le problème correspond bien à ce qui est recommandé dans le "python tutorial"

[kango]

bonjour,

en fait l'explication tient en une seule phrase:

les valeurs par défaut des arguments d'une fonction sont crées une seule fois à la déclaration de cette dernière.

donc, en affectant un type muable en valeur par défaut, cette valeur reste la même pendant toute la durée de vie de la fonction.

ce qui explique dans ton cas que la valeur de la liste change au cours du temps et des appels à la fonction.

la solution consiste à ne pas affecter des types muables en valeur par défaut.

ça c'est pour le comment. pour le pourquoi, je ne suis pas dans les petits papiers des développeurs de Python. mais, de mon point de vue il ne s'agit pas d'un choix en tant que tel mais plus de la conséquence d'un autre choix, plus important, fait sur l'architecture générale de Python.

edit: grilled

[wiztricks]

Salut,
La valeur des arguments par défaut n'est évaluée qu'à la definition de la fonction i.e. une fois... Ce qui peut provoquer des surprises lorsqu'il est "mutable" (une "list").

C'est expliqué dans la doc :

Important warning: The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls:

Et aussi dans la description de ce qu'est une "fonction" en Python

Default parameter values are evaluated when the function definition is executed. This means that the expression is evaluated once, when the function is defined, and that that same “pre-computed” value is used for each call. This is especially important to understand when a default parameter is a mutable object, such as a list or a dictionary: if the function modifies the object (e.g. by appending an item to a list), the default value is in effect modified. This is generally not what was intended.

Côté design (pourquoi) la question est comment traiter l'initialisation d'arguments par défaut avec un type "mutable"...
Le choix Python est surprenant pour la première fois qu'on tombe dessus, mais il est assez cohérent avec 'tout est objet' - et les fonctions aussi - et le traitement des "valeurs"/"collections".
Lire aussi effbot qui donne pas mal d'exemples.
- W
PS: Je n'ai pas trouvé de comparatif avec d'autres langages objets sur le traitement des paramètres par défaut: peu le proposent.

[etienne.clopeau]

Merci à tous pour vos réponse très claire !

Je ne trouve pas cela très naturel, mais bon, on peut bien pardonner ceci pour tout le reste !

Merci encore

[Zavonen]

PS: Je n'ai pas trouvé de comparatif avec d'autres langages objets sur le traitement des paramètres par défaut: peu le proposent.

Pour information C++ propose les arguments par défaut depuis sa création en 1983, alors que Python ne devait voir le jour que 7 ans plus tard. En outre le comportement est, de mon point de vue plus naturel. Il me semble que le c'est le choix d'implémentation des ppd en Python qui implique ce comportement somme toute bizarre.

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
 
using namespace std;
int fonc(int n2=0)
{
    n2++;
    return n2;
}
 
int main()
{
   cout<<fonc()<<"\n";
   cout<<fonc();
 
    return 0;
}

Le programme affiche bien
1
1

[wiztricks]

Salut,

Pour information C++ propose les arguments par défaut depuis sa création en 1983, alors que Python ne devait voir le jour que 7 ans plus tard.

foo(p1='toto', p2='tutu') en Python n'a pas la même sémantique qu'en C++. En C++, les paramètres sont positionnels, alors qu'en Python, ils sont aussi "nommés". i.e. foo(p2='x') est possible en Python pas en C++

En outre le comportement est, de mon point de vue plus naturel. Il me semble que le c'est le choix d'implémentation des ppd en Python qui implique ce comportement somme toute bizarre.

Dans l'exemple que vous proposez le type d'un int n'est pas mutable, en Python çà fonctionnerait pareil.

C# et DELPHI proposent aussi cela.
Mais, je n'ai pas trouvé de comparatif sur les détails des subtilités sur 'que se passe-t-il lorsque le paramètre par défaut est 'mutable'.
- W

[dividee]

Cet exemple devrait être plus concluant (mon C++ est un peu rouillé, désolé si c'est une horreur):

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <vector>
 
using namespace std;
 
vector<int> *func(int x, vector<int> *v = new vector<int>)
{
	v->push_back(x);
	return v;
}
 
int main()
{
	vector<int> *V1, *V2;
	V1 = func(1); cout << &V1 << endl;
	V2 = func(2); cout << &V2 << endl;
	for (vector<int>::iterator x=V1->begin(); x < V1->end(); ++x)
		cout << *x << " ";
	return 0;
}

Résultat:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
0030F864
0030F858
1

Les adresses des vecteurs retournés sont différentes, et le premier vecteur n'a pas été modifié après le second appel. Les valeurs par défaut ne sont donc pas évaluées lors de l'initialisation statique mais lors de chaque appel, contrairement à Python.