Version imprimable
Bonjour,
je me trouve avec un bout de code comme ceci :
J'ai besoin d'écrire m fois des boucles imbriquées, m étant variable.Code:
2
3
4
5
Il faut donc que je trouve comment écrire "une boucle de boucles".
Mais je sèche pour l'instant.
Une idée ?
Je ne vois pas comment faire autrement que de créer une fonction renvoyant une liste de sous listes qui donnent les indices variant progressivement:
Avantage: pas de limitation sur le nombre de boucles imbriquées, contrairement à python lui-même:Code:
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
http://bugs.python.org/issue2688
Une boucle de boucle peut parfois être avantageusement remplacé par une fonction récursive (tout dépend ce qu'il y a dans ta boucle aussi).
Bonjour,
Voilà une solution possible.
Comme tu ne sais pas d'avance la quantité de boucle, je mets les conditions de boucle dans une liste.
Par exemple, si j'avais:
Alors, j'ai:Code:
2
3
4
5
Avec une telle structure, tu mets autant de boucles que tu veux, et tu les détermines au cours du programme!Code:
2
Le 3ème nombre de chaque boucle (comme dans [0,5,0]), est tout simplement le compteur de boucle, qui commence à 0 et qui finira à 4 (la borne finale est exclue comme dans les boucles "for" python).
La structure du code proposé est: j'ai une boucle while globale, et j'ai une boucle while située à la fin, dont le but est d'incrémenter les compteurs en commençant par le dernier et en remontant, et ceci jusqu'à ce que les conditions de sortie soit atteintes.
Voilà le code complet:
La "partie utile" est la partie où tu mets le code qui doit se trouver à l'intérieur de toutes les boucles. J'y ai placé l'affichage de B pour montrer que ça marche. Voilà ce que ça affiche:Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
On voit bien que toutes les situations de boucle sont présentes, et que le dernier est correct: tous les compteurs sont bien à la borne maxi.Code:
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
A l'intérieur de la partie utile de la grande boucle while, la valeur de chaque compteur (qui remplace les i,j,k,...) est récupérée par B[i][2], i étant l'indice de la boucle (de 0 à len(B)-1).
Seule particularité par rapport aux boucles "for" habituelles, la boucle while principale fait au moins un tour, parce que la condition de sortie est à la fin.
Le principe de l'incrémentation des compteurs (la 2ème boucle while ) est simple:
- Je commence par incrémenter le dernier compteur (x=n). S'il ne "déborde pas, j'arrête la boucle. S'il "déborde", je le remet à zéro, et je passe au compteur précédent x=x-1
- je fais la même chose pour le compteur précédent
- etc...
- et j'arrête cette boucle while d'incrémentation des compteurs quand j'ai trouvé à incrémenter un compteur sans débordement.
Ceci jusqu'à ce que j'essaye d'incrémenter le compteur 0 alors qu'il a déjà atteint sa borne maxi. Auquel cas, la boucle finale doit aussi s'arrêter! Ce qui est fait avec la condition "boucle = False"
On s'amuse bien avec des problèmes comme ça :D
Tyrtamos
Une question à se poser serait de savoir si tu ne peux pas te passer de toutes ces boucles. Peux-tu décrire succintement à quoi vont servir ces boucles de boucles ?
Merci pour ces explications très claires.
Je vais mettre en pratique ce soir chez moi.
En fait, voici les données de départ.Citation:
Envoyé par Guigui_
Je dispose de la matrice E :
On peut symboliser E = append(E0,E1,E2,...)Code:
2
3
4
5
6
7
8
Le but est de générer toutes les combinaisons possibles :
append(E0[colonne0], E1[colonne0])
append(E0[colonne0], E1[colonne1])
append(E0[colonne1], E1[colonne0])
....
Le nombre de boucles variable étant dû au nombre de constituant de E.
J'ai poursuivi mon idée, et je propose un code plus complet sous forme de classe. Une fois la classe initialisée (elle peut être dans un module), l'utilisation devient extrêmement simple.
Voilà la classe:
Et l'utilisation dans un programme:Code:
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
Ce qui affiche (on affiche ici uniquement l'évolution des compteurs de boucle):Code:
2
3
4
5
6
7
8
9
10
11
On voit qu'on peut introduire des conditions de bouclage plus complexes:Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[0,5,2] => complet, avec borne inférieure, borne supérieure et pas=2
[3] => seulement borne supérieure -> ce sera complété automatiquement par une borne inf (=0) et un pas (=1)
[2,4] => borne inférieure et borne supérieure seulement -> pas=1
Le test de boucle démarre maintenant au début de la boucle while
Petite particularité: comme on se met uniquement à la partie la plus interne des boucles imbriquées, il suffit qu'un seul des compteurs ait une borne inf >= à la borne sup, pour qu'aucune boucle ne tourne (c'est le cas dans les boucles imbriquées python).
Tyrtamos
Une autre solution:
J'ai travaillé avec des chaînes (pour facilité de traitement)
l représente la liste des listes de indices des boucles.
Sauf bêtise, ca doit donner le bon résultat (après, si le nombre de données est très important, ca peut faire exploser la RAM)
Résultat:Code:
2
3
4
5
6
7
8
9
10
Citation:
('0', '2', '5')
('1', '2', '5')
('0', '3', '5')
('1', '3', '5')
('0', '4', '5')
('1', '4', '5')
('0', '2', '6')
('1', '2', '6')
('0', '3', '6')
('1', '3', '6')
('0', '4', '6')
('1', '4', '6')
('0', '2', '7')
('1', '2', '7')
('0', '3', '7')
('1', '3', '7')
('0', '4', '7')
('1', '4', '7')
('0', '2', '8')
('1', '2', '8')
('0', '3', '8')
('1', '3', '8')
('0', '4', '8')
('1', '4', '8')
Dans le même genre, voici un générateur dans le style du module itertools qui retourne un itérateur sur toutes les combinaisons possibles obtenues en choisissant un élément de chaque itérateur:
Résultat:Code:
2
3
4
5
6
7
8
9
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Bonne question de rambc, je trouve.
Mais je ne comprends pas la réponse de senacle.
E = append(E0,E1,E2,...) c'est une notation pour les matrices ?
Que sont E0,E1,E2....?
Guigui et dividee, vos codes sont bien mais que se passe-t-il si l'un des indices doit aller au delà de 9 ?
D'autre part, est-ce que vos codes permettent de n'avoir à fournir que les valeurs max des indices avec un nombre d'indices quelconque , sans avoir à réécrire les codes ?
Je dirais aussi que ça peut être intéressant de faire varier un indice de 5 à 8, mais d'une part c'est étendre le problème, d'autre part ce n'est rien d'autre que de faire varier 5 + i de i==0 à i==3.
Je reviens dans 3 semaines après avoir potassé les yield, coroutines et generator. ;)
Juste une question, dividee, à quoi sert l'étoile * devant *iterators ?
En fait, il faut réadapter les codes pour les utiliser sur des listes contenant les valeurs des indices pour que cela soit généralCitation:
Envoyé par eyquem
Waou !!!!
J'ai que l'embarras du choix :D
J'ai bien peur que non.Citation:
Envoyé par rambc
Je précise donc.Citation:
Envoyé par rambc
Au départ, je dispose de m matrices D.
Je veux générer toutes les combinaisons possibles entre les colonnes des matrices D :Code:
2
3
4
5
6
7
8
9
10
11
D0[col0] D1[col0]...Dm[col0]
D0[col0] D1[col0]...Dm[coli]
.......
D0[colj] D1[colk]...Dm[coli]
Le nombre de lignes est connu et constant.
Le nombre de matrices D et le nombre de colonnes de chaque matrice Di sont variables.
Une précision, mais qui ne me semble pas vraiment nécessaire pour le problème : le nombre de colonnes de chaque matrice Di est au maximum égal au nombre de lignes
J'avais commencé à scinder chaque matrice Di en matrices Ei contenant elles-mêmes les colonnes de Di.
Par exemple E1 :
Une des matrices résultantes est donc de la forme :Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
E0[i]E1[j]E2[k].....Em[z]
Et c'est là qu'il me faut donc m boucles :
Code:
2
3
4
5
Si j'ai bien compris, en fait tu veux itérer sur un produit cartésien d'ensembles d'entiers ? Si c'est ça, voilà un générateur que j'avais fait un jour :
Dans ton cas, tu peux passer soit les [x]ranges d'indices, soit carrément la liste des matrices.Code:
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
@eyquem:
Le code de Guigui et le mien sont génériques; celui de Guigui travaille sur une séquence de séquences; le mien sur une séquence d'itérateurs.Citation:
Envoyé par eyquem
Cela peut être n'importe quels itérateurs; s'il faut simplement des entiers entre 0 et n, le mieux est de passer des xrange(n) à la fonction. Ce n'est pas tout à fait la même chose que n'avoir à fournir que les valeurs max, mais c'est quand-même très proche.
L'étoile sert à regrouper tous les arguments positionnels (restants, s'il y a d'autres arguments devant, mais ici ce n'est pas le cas) en un tuple. Cela permet de créer des fonctions avec un nombre d'arguments variables. J'aurais pu ne pas mettre l'étoile; dans ce cas l'appel aurait du être effectué en passant une liste ou un tuple d'itérateurs (comme, par exemple, avec str.join), mais j'ai voulu rester dans le style du module itertools, qui utilise l'étoile.Citation:
Juste une question, dividee, à quoi sert l'étoile * devant *iterators ?
On peut aussi utiliser * lors de l'appel de la fonction; dans ce cas c'est l'inverse qui se produit: cela décompacte un tuple de taille n en n arguments positionnels.
@oiffrig:
Merci d'avoir rappelé qu'il s'agissait d'un produit cartésien. Avec ton code, cela fait maintenant 3 méthodes différentes pour générer un produit cartésien :D
Pour l'occasion j'ai renommé ma fonction "icartesian_product".
@senacle;
Maintenant que tu as mieux expliqué le problème d'origine, voici un moyen pour générer ce que tu veux sans devoir passer par des indices de colonnes. On peut directement traiter les colonnes elles-mêmes:
zip(*D) est un idiome python pour transposer une matrice.Code:
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
Le principe est:
- transposer les matrices afin de transformer les colonnes en lignes
- calculer le produit cartésien des lignes des matrices
- transposer à nouveau les matrices résultants pour restransformer les lignes en colonnes
Résultat:
Code:
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
Mes cours de mat commencent à être un peu loin, et je n'avais pas songé au produit cartésien...
Une erreur dans D2 je pense, qui doit être :Citation:
Envoyé par dividee
D2 = [ [ 1. , 2. ],
[ 3. , 4. ],
[ 5. , 6. ]
[ 7. , 8. ] ]
Transposer à deux reprises ne pénalise-t-il pas le temps de traitement ?Citation:
Envoyé par dividee
Pour les matrices, j'utilise numpy.
Pour l'instant, j'ai essayé la première méthode de tyrtamos et ça marche impeccable.
Je vais faire différents tests avec vos différentes méthodes pour voir quelle est la plus rapide.
Oui effectivement.Citation:
Envoyé par senacle
Peut être si les matrices sont très grosses. C'est difficile à dire comme ça, il faudrait profiler.Citation:
Transposer à deux reprises ne pénalise-t-il pas le temps de traitement ?
Bonjour,
J'ai un peu affiné les 2 méthodes que j'ai présentées, et tant qu'à faire, j'en ai fait un tuto:
http://python.jpvweb.com/mesrecettes...les_imbriquees
Tyrtamos
Dans mon premier code, je ne sais pourquoi , j'ai fixé une condition initiale li = [1,1,1,....1,1,0] alors que ce devrait être li = [0,0,0,...0,0].
Par miracle ce code marchait avec li = [1,1,1,....1,1,0] mais si on remplace par li = [0,0,0,...0,0], ça ne marche plus.
Le voici donc corrigé et amélioré.
Il suffit d'entrer les bornes supérieures des indices (elles correspondent aux n,o,p... du premier message de senacle), en nombre quelconque.
Le programme calcule le nombre n de tours à faire en incrémentant un indice av à chaque valeur duquel on va modifier la sous-liste des indices qui vont en augmentant de façon "imbriquée".
C'est à peu de choses près le même principe que le code de tyrtamos.
Ça se résume à : on fait soit li[i] = li[i]+1 soit li[i] = 0.
Mais chaque sous-liste est composée d'indices et non pas de triplets comme dans le code de tyrtamos. Je ne saisis pas la justification d'une telle complication.
Si on veut faire varier un indice H non pas de 0 à 27 mais de 8 à 27 il suffit de poser H = 8 + H0 et de faire varier H0 de 0 à 19.
Code:
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
J'ai aussi essayé de trouver un programme qui n'aurait recours à aucune liste et calculerait les indices avec les seules opérateurs % et //.
C'est possible, mais je me suis aperçu que l'ennui est qu'on recalcule plusieurs fois un même indice quand il ne change pas.
Je suis donc revenu un peu en arrière et il y a dans le code suivant deux listes comme dans le précédent code + des instructions avec % et // au lieu de comparaisons d'éléments de listes. Peut être est-ce plus rapide, peut être que ça n'a aucun intérêt.
Il me semble que ce code est un peu ardu à comprendre, il y a un peu de mathématique dedans. Maintenant qu'il est fait, j'avoue que je m'y perds un peu moi même.....
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Bonjour,
Dès le début, j'avais dans l'idée que chaque boucle pouvait avoir des caractéristiques générales: (borne_inférieure, borne_supérieure, pas), d'où l'idée du triplet. C'est ce que j'ai fait dans les dernières versions des 2 méthodes (voir le tuto dont j'ai donné l'adresse).Citation:
Envoyé par eyquem
Dans ces dernières versions, d'ailleurs, on peut donner le triplet sous forme incomplète, et le programme ajoute ce qui manque. Par exemple, "B = [[1,5,2],3,[1,4]]" est traduit: "B = [[1,5,2],[0,3,1],[1,4,1]]".
Si les boucles sont très simples (borne inférieure=0 et pas=1), on peut même les donner sous forme: "B = [5,3,4]", et faire les corrections suivantes pour reconstruire le triplet complet et se retrouver donc dans le cas général:
En fait, on imite ici ce que python fait déjà, quand range(10) est traduit en range(0,10,1). L'intérêt de tout ça est de simplifier l'introduction des données pour l'utilisateur, tout en permettant, si nécessaire, de traiter les cas généraux.Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
Tyrtamos
tytamos, j'ai lu de façon plus approfondie ton tuto après avoir écrit mes messages un peu rapidement cette nuit. Y a pas à dire, il est complet et bien fait.
Mais il y a quelque chose qui me chiffone dans tout ce perfectionnement.
Je ne suis pas sûr qu'un progamme qui crée une imbrication de boucles en s'attachant à prévoir tous les cas possible comme entrées soit absolument utile. En effet, un tel programme est nécessairement destiné à servir au sein d'un programme qui l'englobe à titre de module. Si j'en avais le besoin, je préfèrerais personnellement fignoler une insertion d'un tel "module" dans un programme en l'adaptant exactement à mon programme englobant, et dans ce cas le formalisme des entrées et soties du module ne me conviendrait peut ètre pas exctement.
Ainsi pour utiliser un tel programme, si on veut par exemple utiliser le deuxième indice à s'incrémenter, il faudra extraire par x = boucles.C[-2] puis utiliser cette valeur dans le programme englobant. Je préfèrerais dans ce cas personnellement aller mettre les instructions du programme général au sein même des instructions de boucles(), en les entrelardant en quelque sorte. Ça permet de mettre un peu de mathématique dans l'algorithme, au lieu de se reposer entièrement sur les capacités de Python pour faire des tâches. C'est pour ça que j'écris "programme général" et non plus "programme englobant" dans mon optique.
Ceci dit, avec les programmes tels que je les donne il faut aussi préléver tel ou tel indice de la même manière que je viens de dire. Je crois.....
Je ne suis pas sûr que tout ce que je viens de raconter soit très clair ni même pertinent. Il faudrait que je vois ce qui se passe en prenant un cas concret au lieu de blablater.
En contraste à ces considérations peut être un peu fumeuses, j'ai réécrit mon dernier programme dans le sens d'un dépouillement à la japonaise:
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
En fait, quand je commence à travailler sur un sujet qui me semble de portée générale, j'essaie de le développer pour pouvoir m'en resservir plus tard. Et les tutos que je fais sont d'abord pour moi: c'est une mémoire de solutions qui marchent! De ce fait, je reconnais que j'en ai fait plus que ce qui était strictement nécessaire pour répondre au problème posé.
Ce faisant, dans les 2 solutions que j'ai données, c'est la seconde qui a ma préférence: celle qui est basée sur une classe. Car une fois cette classe mise au point, et insérée dans un module "Boucles" par exemple, l'utilisation en devient extrêmement simple:
Une fois qu'on a compris comment incrémenter rapidement ces compteurs hiérarchisés, on pense à d'autres utilisations.Code:
2
3
4
5
6
7
8
Ainsi, comme on peut fixer le nombre de boucles pendant le déroulement du programme, on peut aussi, par exemple, s'en servir pour compter en binaire sur un nombre quelconque de digits. Par exemple avec 4 digits:
Ce qui affiche:Code:
2
3
4
5
6
Et avec B = [8,8,8,8], donc sur 4 digits aussi, on peut compter en octal:Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
TyrtamosCode:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Bon, puisque personne n'a osé proposer la solution suivante, je vais quand même la donner au moins pour mémoire:
la chaine "ch" construite est:Code:
2
3
4
5
6
7
8
Et le résultat de son exécution par exec(ch) donne bien:Code:
2
3
4
5
Il faut, bien entendu, remplacer le print par les instructions voulues.Code:
2
3
4
5
6
7
8
9
10
11
Ce n'est pas une solution terrible, et elle a plein de défauts, mais... c'est probablement la plus courte, et peut-être même la plus rapide :D
Tyrtamos
Tiens, c'est drôle, cette nuit j'me suis repenché sur un vieux module que je voulais améliorer (et qui au vu de vos code, peux encore être largement raccourcis...), m'enfin plus on est de fou , plus on rit comme on dit :lefou:
Code:
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
64
65
66
67
68
69
70
71
72
73
74
75
Je sais que le post commence à se faire vieux, mais je me suis encore repenché sur ce problème...
La dernière soluce de tyrtamos est sans égale en termes de vitesse, (et même en terme d'utilisation mémoire à partir de python 2.6 ou 3.0 (les range produisant des generators)). Ceci dit, je trouve pas hyper élégant de devoir taper les instructions de la dernières boucle dans du texte, m'enfin, c'est du pure chipotage, les résultats sont là...
voici un generator de generators qui nous retourne une liste d'index, un paramètre étant une liste de longueurs est passé a ce generator de generator lors de sa création:
code de test:Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
et le resultat:Code:
2
3
Voilà, elle ne vaut toujours pas celle de Tyrtamos, mais je la trouvais assez sympa en terme de consomation mémoire pour être postée...Code:
2
3
4
5
6
7
8
9
10
11