Discussion :

[senacle]

Bonjour,
je me trouve avec un bout de code comme ceci :

Code :

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

1
2
3
4
5
 
for j in range(n) :
	for k in range(o):
		for l in range(p):
			...

J'ai besoin d'écrire m fois des boucles imbriquées, m étant variable.

Il faut donc que je trouve comment écrire "une boucle de boucles".

Mais je sèche pour l'instant.
Une idée ?

[eyquem]

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:

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
def loopings(maxi):
    R = range(len(maxi))
    li = ((len(maxi)-1)*[1])
    li.append(0)
    # li est [1,0] ou [1,1,0] ou [1,1,1,0] etc selon le nombre de boucles imbriquees
 
    indices_de_tour = []
    while 1:
        for i in R[-1::-1]:
            if li[i]<maxi[i]:
                li[i] = li[i]+1
                break
            else:
                li[i] = 1
        lidoubl = li[:]
        indices_de_tour.append(lidoubl)
        if li == maxi:
            break
    return indices_de_tour
 
############################################################
 
maxi = []
while 1:
    v = input('Entrer une borne superieure (0 pour arreter les entrees) : ')-1
    if v==-1:
        break
    maxi.append(v)
 
z = loopings(maxi)
for u in z:
    for sd in u:
        print sd,' ',
    print

Avantage: pas de limitation sur le nombre de boucles imbriquées, contrairement à python lui-même:
http://bugs.python.org/issue2688

[Guigui_]

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).

[senacle]

Merci pour ces explications très claires.
Je vais mettre en pratique ce soir chez moi.

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).

En fait, voici les données de départ.

Je dispose de la matrice E :

Code :

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

1
2
3
4
5
6
7
8
 
[  [1]   [0]   [0]
   [0]   [5]   [0]
   [0]   [0]   [10] ]
[  [1]   [0]
   [0]   [5]
   [0]   [0] ]
...

On peut symboliser E = append(E0,E1,E2,...)

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.

[tyrtamos]

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:

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
 
class Boucle(object):
 
    def __init__(self, B):
        # récupération et stockage des paramètres des boucles
        self.B = B
        lg = len(B)
        self.indmax = lg-1
        # mettre la borne inférieure (=0) de chaque boucle si elle n'est pas donnée
        for i in range(0,lg):
            if len(self.B[i])==1:
                self.B[i].insert(0,0)
        # compléter par le pas (=1) en 3ème paramètre s'il n'est pas donné
        for i in range(0,lg):
            if len(self.B[i])==2:
                self.B[i].append(1)
        # initialiser les compteurs de boucle à la valeur de la borne inférieure       
        self.C = []
        for i in range(0,lg):
            self.C.append(self.B[i][0])
        # vérification qu'aucune borne inférieure n'est >= borne supérieure
        self.stopboucle = False
        for i in range(0,lg):
            if self.B[i][0]>=self.B[i][1]:
                self.stopboucle = True
        # initialiser les redirections pour le test de boucle (=différentier le 1er test des suivants)
        self.encore = self.encore1
 
    def encore1(self):
        """méthode pour faire le 1er test par while"""
        if self.stopboucle:
            # fin de boucle immédiate, car il existe au moins une borne inf >= borne sup
            return False
        else:
            # Au 1er test par while, les compteurs ne doivent pas être incrémentés
            self.encore = self.encore2
            return True
 
    def encore2(self):
        """incrémentation des compteurs et test de poursuite ou de fin de boucle"""
        x = self.indmax
        while True:
            if x==0 and self.C[0]==self.B[0][1]-1:
                return False  # tous les compteurs sont arrivés au bout du comptage
            self.C[x] += self.B[x][2]  # on incrémente du pas
            if self.C[x]>=self.B[x][1]:
                self.C[x] = self.B[x][0]   # le compteur x est arrivé au bout: il faut le réinitialiser
                x -= 1          # et incrémenter le compteur précédent
            else:
                break   # on a pu incrémenter le compteur x sans débordement: la boucle globale peut continuer
        return True  # poursuivre la boucle globale

Et l'utilisation dans un programme:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
B = [[0,5,2],[3],[2,4]]
boucle = Boucle(B)
 
while boucle.encore():
    # ...
    # ... partie utile de la boucle
    # ... valeur du compteur i récupérable par boucle.C[i]
    # ...
    print boucle.C
    # ...

Ce qui affiche (on affiche ici uniquement l'évolution des compteurs de boucle):

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

On voit qu'on peut introduire des conditions de bouclage plus complexes:

[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

[Guigui_]

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)

Code :

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

1
2
3
4
5
6
7
8
9
10
l = ['01', '234', '5678']
 
for i in range(1, len(l)):
    leni1 = len(l[i-1])
    for k in range(i):
        l[k] = len(l[i]) * l[k]
    l[i] = ''.join([leni1 * j for j in l[i]])
 
 
for i in zip(*l): print i

Résultat:

('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')

[tyrtamos]

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:

Code :

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

1
2
3
4
5
 
for i in range(0,5):
    for j in range(0,3):
        for k in range(0,4):
...

Alors, j'ai:

Code :

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

1
2
 
B = [[0,5,0],[0,3,0],[0,4,0]]

Avec une telle structure, tu mets autant de boucles que tu veux, et tu les détermines au cours du programme!

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:

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
 
B = [[0,5,0],[0,3,0],[0,4,0]]
n = len(B)-1
 
boucle = True
while boucle:
    # ...
    # ... partie utile de la boucle
    # ...
    print B
    # ...
 
    # incrémentation des compteurs, test de boucle et condition de sortie
    x = n
    while True:
        if x==0 and B[0][2]==B[0][1]-1:
            boucle = False
            break
        B[x][2] += 1
        if B[x][2]>=B[x][1]:
            B[x][2] = 0
        else:
            break
        x -= 1

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 :

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
61
 
[[0, 5, 0], [0, 3, 0], [0, 4, 0]]
[[0, 5, 0], [0, 3, 0], [0, 4, 1]]
[[0, 5, 0], [0, 3, 0], [0, 4, 2]]
[[0, 5, 0], [0, 3, 0], [0, 4, 3]]
[[0, 5, 0], [0, 3, 1], [0, 4, 0]]
[[0, 5, 0], [0, 3, 1], [0, 4, 1]]
[[0, 5, 0], [0, 3, 1], [0, 4, 2]]
[[0, 5, 0], [0, 3, 1], [0, 4, 3]]
[[0, 5, 0], [0, 3, 2], [0, 4, 0]]
[[0, 5, 0], [0, 3, 2], [0, 4, 1]]
[[0, 5, 0], [0, 3, 2], [0, 4, 2]]
[[0, 5, 0], [0, 3, 2], [0, 4, 3]]
[[0, 5, 1], [0, 3, 0], [0, 4, 0]]
[[0, 5, 1], [0, 3, 0], [0, 4, 1]]
[[0, 5, 1], [0, 3, 0], [0, 4, 2]]
[[0, 5, 1], [0, 3, 0], [0, 4, 3]]
[[0, 5, 1], [0, 3, 1], [0, 4, 0]]
[[0, 5, 1], [0, 3, 1], [0, 4, 1]]
[[0, 5, 1], [0, 3, 1], [0, 4, 2]]
[[0, 5, 1], [0, 3, 1], [0, 4, 3]]
[[0, 5, 1], [0, 3, 2], [0, 4, 0]]
[[0, 5, 1], [0, 3, 2], [0, 4, 1]]
[[0, 5, 1], [0, 3, 2], [0, 4, 2]]
[[0, 5, 1], [0, 3, 2], [0, 4, 3]]
[[0, 5, 2], [0, 3, 0], [0, 4, 0]]
[[0, 5, 2], [0, 3, 0], [0, 4, 1]]
[[0, 5, 2], [0, 3, 0], [0, 4, 2]]
[[0, 5, 2], [0, 3, 0], [0, 4, 3]]
[[0, 5, 2], [0, 3, 1], [0, 4, 0]]
[[0, 5, 2], [0, 3, 1], [0, 4, 1]]
[[0, 5, 2], [0, 3, 1], [0, 4, 2]]
[[0, 5, 2], [0, 3, 1], [0, 4, 3]]
[[0, 5, 2], [0, 3, 2], [0, 4, 0]]
[[0, 5, 2], [0, 3, 2], [0, 4, 1]]
[[0, 5, 2], [0, 3, 2], [0, 4, 2]]
[[0, 5, 2], [0, 3, 2], [0, 4, 3]]
[[0, 5, 3], [0, 3, 0], [0, 4, 0]]
[[0, 5, 3], [0, 3, 0], [0, 4, 1]]
[[0, 5, 3], [0, 3, 0], [0, 4, 2]]
[[0, 5, 3], [0, 3, 0], [0, 4, 3]]
[[0, 5, 3], [0, 3, 1], [0, 4, 0]]
[[0, 5, 3], [0, 3, 1], [0, 4, 1]]
[[0, 5, 3], [0, 3, 1], [0, 4, 2]]
[[0, 5, 3], [0, 3, 1], [0, 4, 3]]
[[0, 5, 3], [0, 3, 2], [0, 4, 0]]
[[0, 5, 3], [0, 3, 2], [0, 4, 1]]
[[0, 5, 3], [0, 3, 2], [0, 4, 2]]
[[0, 5, 3], [0, 3, 2], [0, 4, 3]]
[[0, 5, 4], [0, 3, 0], [0, 4, 0]]
[[0, 5, 4], [0, 3, 0], [0, 4, 1]]
[[0, 5, 4], [0, 3, 0], [0, 4, 2]]
[[0, 5, 4], [0, 3, 0], [0, 4, 3]]
[[0, 5, 4], [0, 3, 1], [0, 4, 0]]
[[0, 5, 4], [0, 3, 1], [0, 4, 1]]
[[0, 5, 4], [0, 3, 1], [0, 4, 2]]
[[0, 5, 4], [0, 3, 1], [0, 4, 3]]
[[0, 5, 4], [0, 3, 2], [0, 4, 0]]
[[0, 5, 4], [0, 3, 2], [0, 4, 1]]
[[0, 5, 4], [0, 3, 2], [0, 4, 2]]
[[0, 5, 4], [0, 3, 2], [0, 4, 3]]

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.

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

Tyrtamos

[rambc]

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 ?

[senacle]

Waou !!!!

J'ai que l'embarras du choix

Une question à se poser serait de savoir si tu ne peux pas te passer de toutes ces boucles.

J'ai bien peur que non.

Peux-tu décrire succintement à quoi vont servir ces boucles de boucles ?

Je précise donc.

Au départ, je dispose de m matrices D.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
D0=[  1.5,   0. ,   0. ,   0. ],
        [  0. ,  12. ,   0. ,   0. ],
        [  0. ,   0. ,  14. ,   0. ],
        [  0. ,   0. ,   0. ,  40. ]
 
D1=[  3.5,   0. ,   0. ],
        [  0. ,  12. ,  0. ],
        [  0. ,   0. ,   0. ],
        [  0. ,   0. ,   40. ]
....

Je veux générer toutes les combinaisons possibles entre les colonnes des matrices D :
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 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
matrix([[ 1.5],
        [ 0. ],
        [ 0. ],
        [ 0. ]]), matrix([[  0.],
        [ 12.],
        [  0.],
        [  0.]]), matrix([[  0.],
        [  0.],
        [ 14.],
        [  0.]]), matrix([[  0.],
        [  0.],
        [  0.],
        [ 40.]])

Une des matrices résultantes est donc de la forme :
E0[i]E1[j]E2[k].....Em[z]

Et c'est là qu'il me faut donc m boucles :

Code :

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

1
2
3
4
5
 
for i in range(n) :
	for j in range(o):
		for k in range(p):
			...

[oiffrig]

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 :

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
def list_incr(L, M):
    """Annexe, incrémente les éléments d'une liste
    en respectant les maxima donnés dans M"""
    assert len(L) <= len(M)
    i = len(L) - 1
    while i >= 0:
        x = L[i] + 1
        if x < M[i]:
            L[i] = x
            return
        L[i] = 0
        i -= 1
    if i < 0:
        raise StopIteration
 
def cartesian_product(*sets):
    """Itère sur le produit cartésien des itérables passés en paramètres"""
    assert len(sets) >= 2
    I = []
    L = []
    for s in sets:
        I.append(0)
        L.append(len(s))
    while True:
        yield tuple(sets[i][j] for i, j in enumerate(I))
        list_incr(I, L)

Dans ton cas, tu peux passer soit les [x]ranges d'indices, soit carrément la liste des matrices.