Discussion :

[Bktero]

Bonjour,

Je cherche à comprendre l'affichage produit par ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
def image_print(image):
	for line in image:
		print line
 
# Partie 1
distance = [0]*10 
distance[1] = 7
image_print(distance)
 
# Partie 2
distance = [[0]*10]*10
distance[0][2] = 6
distance[1][2] = 1
image_print(distance)

Soit :

Code :

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
0
7
0
0
0
0
0
0
0
0
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

Dans la partie 1, les éléments de la liste semble indépendants : modifier un élément ne modifie pas les autres.

Dans la partie 2, les éléments semblent dépendants.

Je cherche à comprendre pourquoi et surtout comment construire correctement ma liste de listes pour m'en servir comme une matrice.

Merci d'avance pour vos lumières

[fred1599]

Tu trouveras sans doute ta réponse ici

[plxpy]

Bonjour

Dans la partie 2, [0]*10 est une liste qui est évaluée une seule fois.
[ [0]*10 ]*10 repète 10 fois la même liste, le tout étant mis dans une liste.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> distance = [ [0]*10 ] * 10
>>> for i in range(10):
...     print id(distance[i])
... 
3077631788
3077631788
3077631788
3077631788
3077631788
3077631788
3077631788
3077631788
3077631788
3077631788
>>>

Pour une "vraie" "matrice" 10x10 remplie de 0, je ferais comme ça

Code :

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

distance = map(lambda i:[0]*10, range(10))

[mont29]

Pour une "vraie" "matrice" 10x10 remplie de 0, je ferais comme ça

Code :

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

distance = map(lambda i:[0]*10, range(10))

Il y a plus simple, utiliser une liste comprehension*:

Code :

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

distance = [[0] * 10 for i in range(10)]

[stalacta]

Cela semble être une question de portée des variables. Dans la partie 1, nous avons une liste d'entiers, donc de simples valeurs, en effet, voici un code qui te montrera la différence entre les int et les listes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
a=32
b=a
a*=6
print(b)
>>> 32 #si l'on change a ou b, l'autre variable n'est pas modifiée, ces 2 variables sont de simples valeurs
#alors que :
a=[45,"rien"]
b=a
b.append("ajout")
print(a)
>>> [45,'rien','ajout'] #là, a et b sont 2 variables qui pointent sur le même objet, par conséquent, si l'un est modifié, l'autre aussi
# la solution est de copier explicitement de contenu de a dans b pour avoir des objets indépendants :
b=list(a)

Pour en revenir à notre problème, dans la partie 1, nous avons une liste de 'int', donc des valeurs pures. La modification de l'un ne modifie pas les autres.
En revanche, dans la partie 2, on modifie une liste, c'est la même liste qui est contenue 10 fois dans notre liste de listes. En modifiant l'une des listes qui est en fait un objet, on modifie les autres qui pointent sur le même objet.
La solution est donc d'exprimer explicitement la différence entre les listes, qu'elles aient le même contenu :

Code :

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

1
2
3
ligne=[0]*10
distance=[]
for i in range(10) : distance.append(list(ligne))

ps : je suis encore débutant, vous pouvez m'expliquer le mot clé lambda, je n'ai pas réussi à trouver de tuto avec

[mont29]

lambda est le mot clé pour créer des “fonctions anonymes” en python…

[plxpy]

Pour info et pour les curieux, voici la fonction qui, dans l'interpréteur, réalise la multiplication d'une liste (Python-2.7.5/Objects/listobject.c, lignes 544 à 582).

Ce sont bien des adresses de PyObject qui sont manipulées/(re)copiées.

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
static PyObject *
list_repeat(PyListObject *a, Py_ssize_t n)
{
    Py_ssize_t i, j;
    Py_ssize_t size;
    PyListObject *np;
    PyObject **p, **items;
    PyObject *elem;
    if (n < 0)
        n = 0;
    if (n > 0 && Py_SIZE(a) > PY_SSIZE_T_MAX / n)
        return PyErr_NoMemory();
    size = Py_SIZE(a) * n;
    if (size == 0)
        return PyList_New(0);
    np = (PyListObject *) PyList_New(size);
    if (np == NULL)
        return NULL;
 
    items = np->ob_item;
    if (Py_SIZE(a) == 1) {
        elem = a->ob_item[0];
        for (i = 0; i < n; i++) {
            items[i] = elem;
            Py_INCREF(elem);
        }
        return (PyObject *) np;
    }
    p = np->ob_item;
    items = a->ob_item;
    for (i = 0; i < n; i++) {
        for (j = 0; j < Py_SIZE(a); j++) {
            *p = items[j];
            Py_INCREF(*p);
            p++;
        }
    }
    return (PyObject *) np;
}

[wiztricks]

Salut,

Ce sont bien des adresses de PyObject qui sont manipulées/(re)copiées.

De toutes façons des qu'un objet (liste ou autre) contient d'autres objets, le dupliquer signifie créer un objet de même type contenant des références aux mêmes objets ou de copies de ces objets (de nouvelles instances).
Et a partir de la, la question nouvelle instance ou référence devient récursive: on crée ou pas une nouvelle arborescence d'objets.

Voir les opérations de copy dans la documentation de Python (qui couvre des questions qui ne sont pas spécifiques a Python mais a la structure arborescente des objets composites).

La ou le débutant se fait "avoir", c'est en choisissant une /list/ pour y stocker des types simples comme int, float,...
Une /list/ d'objets de type int ressemble a un tableau d'entiers mais /array/ serait une "boite" plus adaptée pour représenter une suite de valeurs de type simple - entiers, float -.

- W