Discussion :

[RowanMayfair]

Bonjour,

Encore moi

J'essaie de faire une matrice carrée avec des listes.
le résultat doit ressemble à ça, avec n = 8 :

m1 :
[2, 4, 6, 8, 10, 12, 14, 16]
[18, 20, 22, 24, 26, 28, 30, 32]
[34, 36, 38, 40, 42, 44, 46, 48]
[50, 52, 54, 56, 58, 60, 62, 64]
[66, 68, 70, 72, 74, 76, 78, 80]
[82, 84, 86, 88, 90, 92, 94, 96]
[98, 100, 102, 104, 106, 108, 110, 112]
[114, 116, 118, 120, 122, 124, 126, 128]

Donc avec n=8, je doit avoir 8 lignes de chacune 8 nombres, 2 par 2.

J'en suis là avec mon code :

Code :

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

m1 = [nbre for nbre in range(2,n*n*2+1,2)]

et là j'obtiens donc tous les nombres nécessaires, mais dans une seule liste.

Et je ne sais pas comment découper cette liste en n nombres.

Là en gros ça fait une heure que j'essaie de faire du slicing dans une boucle, sans succés je doit pas faire ce qu'il faut.

Des idées ?
Peut-être c'est mal fait au départ, il était peut-être possible de créer, dès le début, une liste de liste avec n termes. Mais je n'ai pas su faire non plus.

[wiztricks]

Salut,

J'en suis là avec mon code :

Code :

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

m1 = [nbre for nbre in range(2,n*n*2+1,2)]

et là j'obtiens donc tous les nombres nécessaires, mais dans une seule liste.

Il faudrait construire des listes dans la liste... Ce qui vous a été déjà présenté ici dans une discussion assez récente.

- W

[RowanMayfair]

oui, construire une liste dans une liste, OK.
Mais n listes de n caractères ?
Je ne m'en sors pas.
Je me retrouve avec des "sous-listes" de la totalité de ce que je veux....pas seulement les n premiers termes.

Bref. je suis fatiguée de ma journée, je reprendrais ça demain matin, je serai peut-être plus inspirée

[wiztricks]

Salut,
Il faut y aller doucement.
Une liste simple:

Code :

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

1
2
3
>>> n = 4
>>> [ i for i in range(n) ]
[0, 1, 2, 3]

Une liste de listes simples:

Code :

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

1
2
>>> [[ i for i in range(n) ] for j in range(n) ]
[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]

Puis on ajoute le nombre de lignes à i:

Code :

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

1
2
3
>>> [[ n*j + i for i in range(n) ] for j in range(n) ]
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]]
>>>

que l'on peut multiplier par 2:

Code :

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

1
2
3
>>> [[ 2*(n*j + i) for i in range(n) ] for j in range(n) ]
[[0, 2, 4, 6], [8, 10, 12, 14], [16, 18, 20, 22], [24, 26, 28, 30]]
>>>

- W

[tyrtamos]

Bonjour,

Avant de tout faire en une seule ligne, je suggère de faire avec des boucles "normales":

Code :

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

1
2
3
4
5
6
mat = []
n = 8
for ligne in range(0, n):
    mat.append([]) # nouvelle ligne
    for colonne in range(0, n):
        mat[ligne].append(colonne + n*ligne) # nouvelle colonne de la ligne

Ca qui donne comme résultat:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
for ligne in range(0, n):
    print(mat[ligne]) # affichage de chaque ligne
print()
 
[0, 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]
[40, 41, 42, 43, 44, 45, 46, 47]
[48, 49, 50, 51, 52, 53, 54, 55]
[56, 57, 58, 59, 60, 61, 62, 63]

Une fois qu'on a bien compris ça, on peut tout faire en une seule ligne:

Code :

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

mat = [[colonne+n*ligne for colonne in range(0, n)] for ligne in range(0, n)]

Ce qui donne, bien sûr, le même résultat.

[RowanMayfair]

Je me rends compte qu'en effet, j'ai de grosses lacunes.
J'ai suivi la méthode Swinnen, donc j'ai manipulé des boucles while dans tous les sens.
Par contre les boucles for je les ait découvertes bien plus tard. Donc là imbriquer des boucles for, en créant des listes de listes, tout ça avec range().....ça fait beaucoup.

bref donc ça :

Code :

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

1
2
3
4
for j in range(n) :
    m3.append([])
    for i in range(n) :
        m3[j].append(2*(n*j + i))

c'est ça :

Code :

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

m2 = [[ 2*(n*j + i) for i in range(n) ] for j in range(n) ]

c'est à dire précisément ce que je voulais faire.
Enfin la compréhension là, pour le coup, je vais pas trop me prendre la tête dessus, c'est pas le problème. Quand j'aurai vraiment bien compris le mécanismes de ces 2 boucles, la compréhension c'est pas encore le plus dur.

Je vais essayer de faire la matrice suivante, on va voir si j'y arrive seule

[RowanMayfair]

Donc oui, j'ai réussi à faire ma 2è matrice, pleine de 0 avec des 1 en diagonale :

Code :

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

1
2
3
4
5
6
7
m2 = []
 
for li in range(n) :
    m2.append([])
    for col in range(n) :
        m2[li].append(0)
    m2[li][li] = 1

par contre, est-ce qu'il y avait un moyen de faire plus efficace ?

[tyrtamos]

On pourrais faire comme ça:

Code :

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

1
2
3
4
5
6
m2 = []
n = 8
for li in range(n) :
    m2.append([])
    for col in range(n) :
        m2[li].append(1) if li==col else m2[li].append(0)

Mais je ne sais pas si c'est plus efficace: on remplace une affectation par ligne par une condition sur chaque élément... Peut-être ta solution est-elle la meilleure?

[RowanMayfair]

Ah oui...

En fait moi j'ai rempli de 0 et après j'ai remplacé par des 1 où je voulais.
Et toi tu remplis directement correctement en mettant une condition. Je préfère ta solution Tyrtamos je crois

[RowanMayfair]

J'en avais une 3ème à faire, la différence entre les 2 premières en diagonale.
Bref, donc en fait on pouvait faire du 3 en 1

Code :

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

1
2
3
4
5
6
7
8
9
10
m1,m2,m3 = [],[],[]
 
for lig in range(n) :
    m1.append([])
    m2.append([])
    m3.append([])
    for col in range(n) :
        m1[lig].append(2*(n*lig + col + 1))
        m2[lig].append(1) if lig == col else m2[lig].append(0)
        m3[lig].append(m1[lig][col] - m2[lig][col]) if lig == col else m3[lig].append(0)

ce qui me pose vraiment difficultés en fait, (et que je n'arrivais pas forcément à décrire au début du sujet), c'est que là :

Code :

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

m1[lig].append(2*(n*lig + col + 1))

lig et col sont des chiffres à la fois utilisés comme indices des lignes et des colonnes, mais sont aussi utilisés pour remplir les listes
J'avoue que je trouve le mécanisme un peu complexe, le tout est de s'y habituer certainement

Donc...là j'ai un autre truc à faire aujourd'hui, mais ensuite je me re-ferais quelques matrices carrées.

Au cas où, si vous avez quelques idées pour m'entraîner, n'hésitez pas

En attendant, merci

[wiztricks]

par contre, est-ce qu'il y avait un moyen de faire plus efficace ?

On sait faire une liste de listes n x n pleine de zéros:

Code :

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

1
2
>>> n = 8
>>> L = [ [0,] * n for j in range(n) ]

puis changer la première diagonale:

Code :

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

1
2
3
>>> for i in range(n):
...     L[i][i] = 1
...

C'est plus efficace car on évite n*n appels à .append avec tout ce qu'il y a derrière côté expansion de liste, allocation mémoire.
Après puisqu'on veut modifier la diagonale, peut on créer une liste contenant n - 1 zéros et un 1 à la position j? [0,] * j + [1] + [0,]*(n-(j+1)).
Ce qui donne:

Code :

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

>>> L = [ [0,] * j + [1] + [0,]*(n-(j+1)) for j in range(n) ]

Pour savoir ce qui est le plus efficace, il faut mesurer le temps pris par les différentes solutions - ce qui est une bonne motivation pour écrire du code - et une occasion de jeter un œil à la bibliothèque timeit
Mais préférez toujours la solution que vous comprendrez facilement (i.e. sans avoir à la commenter ou a y passer trop de temps).

- W

[venone]

Bonjour à tous,

Je viens ajouter des exemples qui peuvent peut-être aider.
Je ne viens pas avec " la " solution mais peut-être des pistes.

Bien évidemment c'est à ajuster en fonction du résultat que tu souhaites avoir.

Bonne journée à vous
Venone

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
 
#coding:utf-8
 
def serie_of_values(number_of_values, minimum_value, gap):
 
	"""Fonction ayant pour but de crée un jeu de valeur"""
	"""
        Les valeurs devant être reçues sont :
        
        argument 1 : La valeur maximum souhaitée de la série
        argument 2 : La valeur minimum souhaitée de la série
        argument 3 : L'écart entre les deux premiers arguments
        
        """
 
	list_of_values = []
 
	for i in range(number_of_values, minimum_value -1 , -gap):
		list_of_values.append(i)
 
	list_of_values.reverse()
 
	return list_of_values
 
 
def serie_with_n_values(n, minimum_value, gap):
 
	"""Fonction ayant pour but de crée un jeu de valeur"""
	"""
        Les valeurs devant être reçues sont :
        
        argument 1 : Le nombre de valeur que l'on souhaite
        argument 2 : La valeur minimum souhaitée de la série
        argument 3 : L'écart entre les deux premiers arguments
        """
 
	database = []
	check_value = 0
 
	while check_value != n :
 
		database.append(minimum_value)
		check_value += 1
		minimum_value += gap
 
	return database
 
#Création d'une liste contenant un nombre n de liste
 
my_list = []
 
choix = int(input("Combien de listes voulez vous ajouter à my_list ? "))
 
for i in range(choix):
	#Placer dans l'ajout ci-après a my_list la fonction souhaitée
	#serie_with_n_values ou serie_of_values
	my_list.append(serie_with_n_values(8,0,3))
 
print(my_list)

[Sve@r]

Bonjour

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
 
def serie_of_values(number_of_values, minimum_value, gap):
 
	"""Fonction ayant pour but de crée un jeu de valeur"""
	"""
        Les valeurs devant être reçues sont :
        
        argument 1 : La valeur maximum souhaitée de la série
        argument 2 : La valeur minimum souhaitée de la série
        argument 3 : L'écart entre les deux premiers arguments
        
        """
 
	list_of_values = []
 
	for i in range(number_of_values, minimum_value -1 , -gap):
		list_of_values.append(i)
 
	list_of_values.reverse()
 
	return list_of_values

Cette fonction possède tous les défauts que l'on peut trouver dans un code. Déjà elle fait du append à foison (wiztricks vient justement d'expliquer que c'était la chose à éviter). Ensuite elle commence par créer les nombres dans le sens descendant puis elle inverse le tout (pouvait pas les créer directement dans le sens croissant ???). Et le paramètre "number_of_values" (qu'on traduirait assez intuitivement par "nombre de valeurs") est en réalité la valeur maximale. Il y a quand-même une sacré différence entre "12 entiers commençant à partir de 5" et "entiers compris entre 5 et 12" (ok le commentaire précise en effet que c'est la valeur max mais bon, il est assez courant tout de même de donner un nom de variable correspondant à son rôle). Et t'as même pas pensé à mettre une valeur par défaut au gap.
Donc tout ça pour refaire en moins bien ce que fait déjà range...