Discussion :

[djbad]

bonjour à tous
voila je bute sur un exo j'en suis pas loin
je dois faire ceci
soit M = [] ;
codez, à partir de M, la construction de la matrice [[1, 2, 3], [4, 5, 6]] ;
généralisez pour n'importe quelle matrice de n lignes par m colonnes

j'ai réussi à faire ce bout de code mais il me deux fois la meme liste

Code :

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

1
2
3
4
5
6
7
8
>>> M = []
>>> for x in range(2) :
...  L = []
...  for y in range (1,4) : L = L + [y] 
...  M += [L]
... 
>>> M
[[1, 2, 3], [1, 2, 3]]

merci de m'aider

[wiztricks]

Salut,
S'il affiche deux fois la même liste, c'est qu'à chaque passage
la construction de la liste: for y in range (1,4) : L = L + [y]
ne prend pas en compte la dernière valeur du passage précédent.

On pourrait donc l'écrire:

for y in range (1,4) : L = L + [y + YP],

ou commencer par YP

for y in range (YP, 4) : L = L + [y]

Il vous reste à définir l'initialisation et la mise à jour de YP.
- W

[Zavonen]

Le mieux est d'utiliser des classes pour représenter les matrices.
Voici un exemple de classe de matrices à coefficients rationnels:
http://gilles.dubois10.free.fr/algeb...e/evaldet.html
Il n'y a pas grand chose à changer pour en faire une classe de matrices à coefficients dans un type prédéfini.

[wiztricks]

Si on doit traiter cela avec de l'artillerie lourde Numpy
Mais comme tu as l'air bien au courant des programmes de math de seconde, tu as sans doute raison.
- W

[eyquem]

Bonsoir,


Quel est le sens de la question ? :
- tu ne comprends pas pourquoi la même liste est enregistrée deux fois dans M ?
- ou bien tu comprends pourquoi, mais ne sais pas trouver l’algorithme correct ?

Je veux éviter de te balancer un code tout fait. Je te propose de regarder ce que donne:

Code :

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

1
2
L = range(1,4)
print L

À moins que tu sois en Python 3.x, auquel cas il faut faire

Code :

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

1
2
L = list(range(1,4))
print L

[djbad]

je comprends pourquoi il me met deux fois la meme liste
c'est la traduction de l'algo qui me pose probleme

soit NBL le nombre de lignes souhaité
soit NBC le nombre de colonnes souhaité
soit M une liste vide
pour x variant de 1 à NBL
soit L une liste vide
pour n variant de 1 à NBC
ajoute un élément E à L
ajoute L à M

la variable E qui me pose probleme qui correspond à YP dit par wiztricks
je dois arriver à exprimer E en fonction du n° du tour
ca doit etre facile mais j'arrive plus

[djbad]

ah oui je suis version 2.6 de python

[eyquem]

soit NBL le nombre de lignes souhaité définition de NBL
soit NBC le nombre de colonnes souhaité définition de NBC
soit M une liste vide définition de M
pour x variant de 1 à NBL définition de x
soit L une liste vide définition de L
pour n variant de 1 à NBC définition de n
ajoute un élément E à L L définie auparavant
.................................E: sortir dans la rue, tendre un chapeau renversé, attendre qu’il tombe quelque chose dedans (recette non garantie)
ajoute L à M L et M définies auparavant



j'arrive plus
C'est grave.



Conseil: un papier, un crayon, et tu joues à l’ordinateur auquel on fournit des variables et des valeurs, et des instructions. Et tu vois si tu arrives à exécuter quelque chose, et jusqu’où.

[djbad]

c'est bon j'ai réussi
en fait j'initialisé pas la E
en dehors de la boucle

Code :

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

1
2
3
4
5
6
7
8
9
>>> M = []
>>> E = 0
>>> for x in range(5) :
...   L = []
...   for y in range (1,4) : L = L + [y+E]
...   E = L[2]
...   M+= [L]
... 
>>> M

merci en tout pour votre aide il ne me reste plus qu'a généraliser
A+

[eyquem]

Code :

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

1
2
for y in range(1,4):
    L = L + [y+E]

est identique à

Code :

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

1
2
for y in range(1+E,4+E):
    L = L + [y]

Dans le premier cas, à chaque tour (chaque valeur de y entre 1 et 4), le programme doit faire une opération supplémentaire: ajouter E à y.
Cela fait 3 opérations supplémentaires pour range(1,4) mais ça en ferait 1000 pour range(1,1001).

Dans le deuxième cas, le programme ne fait que deux opérations supplémentaires: ajouter E à 1, et ajouter E à 4. Ce sera donc plus court à faire, quel que soit le nombre à la place du 4.





D’autre part, sachant que id(obj) donne l’adresse de l’objet obj , compare:

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
21
22
23
24
M,E = [],0
for x in range(2) :
    L = []
    for y in range (1+E,4+E) :
        L = L + [y]
        print y,id(L)
    print
    E = L[2]
    M+= [L]
 
print M
 
print '---------------------'
M,E = [],0
for x in range(2) :
    L = []
    for y in range (1+E,4+E) :
        L.append(y)
        print y,id(L)
    print
    E = L[2]
    M+= [L]
 
print M

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
1 17540120
2 17540080
3 9917144
 
4 17541440
5 17541040
6 17541600
 
[[1, 2, 3], [4, 5, 6]]
---------------------
1 9917144
2 9917144
3 9917144
 
4 17541440
5 17541440
6 17541440
 
[[1, 2, 3], [4, 5, 6]]

Dans le premier code:

- L + [y] crée une nouvelle liste à un autre emplacement dans la mémoire que L;

- il existe alors à ce moment là en mémoire deux objets: la liste L et la nouvelle liste obtenue de L+[y] ;

- pendant un court instant, l’objet obtenu de L+[y] existe sans identifiant. Mais ça fait partie du processus de l’opération L = L+[y] que le programme maintienne en vie cet objet pendant ce court instant , en ayant connaissance de son adresse en mémoire;

- l’affectation déclenchée par
L =
transfert alors le nom L de l’objet L vers le nouvel objet obtenu de L+[y] ;

- l’objet L est laissé à son triste sort: il n’a plus d’identifiant. Or l’existence d’au moins un identifiant attaché à un objet est la condition de la survie d'un objet en mémoire. Quand un objet n’a plus d’identifiant, le gestionnaire d’objets intervient rapidement pour désallouer la place que cet objet occupe en mémoire, c’est à dire la rendre disponible pour accueillir un nouvel objet en fonction des besoins. Ce gestionnaire fonctionne en permanence, sur la base d’un comptage des références, c’est à dire du nombre des identifiants attaché à chaque objet. Il intervient chaque fois qu'il y a rupture de l'attache entre un identifant x et un objet (que ce soit parce que l'identifiant x est détruit par del x , ou parce qu’il est déplacé sur un autre objet).



Dans le deuxième code, L est modifiée “en place“: L est allongée de un élément tout en restant à la même place en mémoire, c’est à dire plus precisément que la tête de la liste reste située au même endoit en mémoire.
Une liste est un objet mutable: une telle extension est possible. D'autres modifications sont possibles aussi: modification d'un élément, élimination d'un élément, remplacement d'une section de la liste, etc...
'Un tuple n’est pas mutable, c’est a dire qu’il n'est pas modifiable. Il est donc inextensible.
C’est moins coûteux pour le programme de faire un append() sur une liste que de créer une nouvelle liste par L+[y]








Enfin, je te suggère de regarder quelles sont les valeurs qu’il faut modifier pour faire des listes de longueurs de ligne variées.
Et d’en conclure quelque chose sur la liaison des valeurs qui changent d’une longueur de ligne à une autre.





Sans oublier enfin, je le répète, qu’après:

Code :

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

1
2
3
li = []
for y in range(1,4):
    li.append(y)

la liste li a la même valeur que range(1,4).

range(1,4) n’est pas un procédé qui débite des valeurs 1,2,3 l’une après l’autre (ça c’est xrange(1,4) , en Python 2.x)
range() est une fonction et range(1,4) EST la liste [1,2,3] c’est à dire ce que tu veux construire en faisant for y in range(1,4)







En outre, pour des calculs un tant soit peu sophistiqués impliquant des tableaux ou des matrices, il faut presque obligatoirement utiliser numpy.

[djbad]

Merci beaucoup pour cette explication

[eyquem]

Merci beaucoup pour cette explication

Bon bon. Mais ce qui serait intéressant, c’est de savoir quelles compréhensions ça a déclenché et à quelles modifications dans le code ça a donné lieu.



Par exemple, le fait que

Code :

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

1
2
3
li = []
for y in range(1,4):
    li.append(y)

donne une liste li qui est identique à range(1,4) , tu en conclus quoi ?


Et ta généralisation à des nombres de lignes et de colonnes quelconques, ça devient quoi ?