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

[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]

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

[dividee]

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:

Code :

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

1
2
3
4
5
6
7
8
9
def icombine(*iterators):
    if not iterators:
        yield ()
    else:
        for first in iterators[0]:
            for rest in icombine(*iterators[1:]):
            yield (first,) + rest
 
for i in icombine('01', '234', '5678'): print i

Résultat:

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
('0', '2', '5')
('0', '2', '6')
('0', '2', '7')
('0', '2', '8')
('0', '3', '5')
('0', '3', '6')
('0', '3', '7')
('0', '3', '8')
('0', '4', '5')
('0', '4', '6')
('0', '4', '7')
('0', '4', '8')
('1', '2', '5')
('1', '2', '6')
('1', '2', '7')
('1', '2', '8')
('1', '3', '5')
('1', '3', '6')
('1', '3', '7')
('1', '3', '8')
('1', '4', '5')
('1', '4', '6')
('1', '4', '7')
('1', '4', '8')

[eyquem]

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 ?

[Guigui_]

Guigui et dividee, vos codes sont bien mais que se passe-t-il si l'un des indices doit aller au delà de 9 ?

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éral

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

[dividee]

@eyquem:

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.

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.

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.

Juste une question, dividee, à quoi sert l'étoile * devant *iterators ?

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

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 icartesian_product(*iterators):
    if not iterators:
        yield ()
    else:
        for first in iterators[0]:
            for rest in icartesian_product(*iterators[1:]):
                yield (first,) + rest
 
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. ] ]
 
D2 = [ [ 1. ,  2. ],
       [ 3. ,  4. ],
       [ 5. ,  6. ] ]
 
for mat in icartesian_product(*(zip(*D) for D in (D0,D1,D2))):
    for line in zip(*mat):
        print line
    print

zip(*D) est un idiome python pour transposer une matrice.
Le principe est:

1. transposer les matrices afin de transformer les colonnes en lignes
2. calculer le produit cartésien des lignes des matrices
3. transposer à nouveau les matrices résultants pour restransformer les lignes en colonnes

Résultat:

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
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
(1.5, 3.5, 1.0)
(0.0, 0.0, 3.0)
(0.0, 0.0, 5.0)
(0.0, 0.0, 7.0)
 
(1.5, 3.5, 2.0)
(0.0, 0.0, 4.0)
(0.0, 0.0, 6.0)
(0.0, 0.0, 8.0)
 
(1.5, 0.0, 1.0)
(0.0, 12.0, 3.0)
(0.0, 0.0, 5.0)
(0.0, 0.0, 7.0)
 
(1.5, 0.0, 2.0)
(0.0, 12.0, 4.0)
(0.0, 0.0, 6.0)
(0.0, 0.0, 8.0)
 
(1.5, 0.0, 1.0)
(0.0, 0.0, 3.0)
(0.0, 0.0, 5.0)
(0.0, 40.0, 7.0)
 
(1.5, 0.0, 2.0)
(0.0, 0.0, 4.0)
(0.0, 0.0, 6.0)
(0.0, 40.0, 8.0)
 
(0.0, 3.5, 1.0)
(12.0, 0.0, 3.0)
(0.0, 0.0, 5.0)
(0.0, 0.0, 7.0)
 
(0.0, 3.5, 2.0)
(12.0, 0.0, 4.0)
(0.0, 0.0, 6.0)
(0.0, 0.0, 8.0)
 
(0.0, 0.0, 1.0)
(12.0, 12.0, 3.0)
(0.0, 0.0, 5.0)
(0.0, 0.0, 7.0)
 
(0.0, 0.0, 2.0)
(12.0, 12.0, 4.0)
(0.0, 0.0, 6.0)
(0.0, 0.0, 8.0)
 
(0.0, 0.0, 1.0)
(12.0, 0.0, 3.0)
(0.0, 0.0, 5.0)
(0.0, 40.0, 7.0)
 
(0.0, 0.0, 2.0)
(12.0, 0.0, 4.0)
(0.0, 0.0, 6.0)
(0.0, 40.0, 8.0)
 
(0.0, 3.5, 1.0)
(0.0, 0.0, 3.0)
(14.0, 0.0, 5.0)
(0.0, 0.0, 7.0)
 
(0.0, 3.5, 2.0)
(0.0, 0.0, 4.0)
(14.0, 0.0, 6.0)
(0.0, 0.0, 8.0)
 
(0.0, 0.0, 1.0)
(0.0, 12.0, 3.0)
(14.0, 0.0, 5.0)
(0.0, 0.0, 7.0)
 
(0.0, 0.0, 2.0)
(0.0, 12.0, 4.0)
(14.0, 0.0, 6.0)
(0.0, 0.0, 8.0)
 
(0.0, 0.0, 1.0)
(0.0, 0.0, 3.0)
(14.0, 0.0, 5.0)
(0.0, 40.0, 7.0)
 
(0.0, 0.0, 2.0)
(0.0, 0.0, 4.0)
(14.0, 0.0, 6.0)
(0.0, 40.0, 8.0)
 
(0.0, 3.5, 1.0)
(0.0, 0.0, 3.0)
(0.0, 0.0, 5.0)
(40.0, 0.0, 7.0)
 
(0.0, 3.5, 2.0)
(0.0, 0.0, 4.0)
(0.0, 0.0, 6.0)
(40.0, 0.0, 8.0)
 
(0.0, 0.0, 1.0)
(0.0, 12.0, 3.0)
(0.0, 0.0, 5.0)
(40.0, 0.0, 7.0)
 
(0.0, 0.0, 2.0)
(0.0, 12.0, 4.0)
(0.0, 0.0, 6.0)
(40.0, 0.0, 8.0)
 
(0.0, 0.0, 1.0)
(0.0, 0.0, 3.0)
(0.0, 0.0, 5.0)
(40.0, 40.0, 7.0)
 
(0.0, 0.0, 2.0)
(0.0, 0.0, 4.0)
(0.0, 0.0, 6.0)
(40.0, 40.0, 8.0)

[senacle]

Mes cours de mat commencent à être un peu loin, et je n'avais pas songé au produit cartésien...

D2 = [ [ 1. , 2. ],
[ 3. , 4. ],
[ 5. , 6. ] ]

Une erreur dans D2 je pense, qui doit être :

D2 = [ [ 1. , 2. ],
[ 3. , 4. ],
[ 5. , 6. ]
[ 7. , 8. ] ]

1. transposer les matrices afin de transformer les colonnes en lignes
2. calculer le produit cartésien des lignes des matrices
3. transposer à nouveau les matrices résultants pour restransformer les lignes en colonnes

Transposer à deux reprises ne pénalise-t-il pas le temps de traitement ?


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.

[dividee]

Une erreur dans D2 je pense, qui doit être :

D2 = [ [ 1. , 2. ],
[ 3. , 4. ],
[ 5. , 6. ]
[ 7. , 8. ] ]

Oui effectivement.

Transposer à deux reprises ne pénalise-t-il pas le temps de traitement ?

Peut être si les matrices sont très grosses. C'est difficile à dire comme ça, il faudrait profiler.

[tyrtamos]

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

[eyquem]

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 :

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
def loopings(bornesup):
    n = 1
    for v in bornesup:
        n = n*v
    R = xrange(len(bornesup)-1,-1,-1)
    li = len(bornesup)*[0]
 
    lidoubl = li[:]             # lidouble necessaire sinon le premier element de
    indices_de_tour = [lidoubl] # indices_de_tour variera continuellement avec li
    print
    for av in range(1,n):
        for i in R:
            if bornesup[i]-1-li[i]: # equivalent a bornesup[i]>1+li[i]
                li[i] = li[i]+1
                lidoubl = li[:]
                indices_de_tour.append(lidoubl)
                break
            else:
                li[i] = 0
    return indices_de_tour
 
############################################################
 
bornesup = []
while 1:
    try:
        v = input('Entrer une borne superieure (RIEN pour arreter les entrees) : ')
        bornesup.append(v)
    except:
        break
 
z = loopings(bornesup)
for u in z:
    for uval in u:
        print uval,
    print

[eyquem]

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 :

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
bornesup = []
n = 1
while 1:
    try:
        v = input('Entrer une borne superieure (RIEN pour arreter les entrees) : ')
        bornesup.append(v)
        n = n*v
    except:
        li = len(bornesup)*[0]
        bornesup.append(1)
        break
 
R = xrange(len(bornesup)-1,-1,-1)
print 'bornesup =',bornesup,'n=',n
print 'R =',R
for i in xrange(n):
    x = i
    for k in R:
        x = x//bornesup[k]
        c = x%bornesup[k-1]
        li[k-1]=c
        if c:
            break
    print li

[tyrtamos]

Bonjour,

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.

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

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:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
B = [5,3,4]
 
B = [(type(x)==list and [x] or [[x]])[0] for x in B]
print B
[[5], [3], [4]]
 
B = [(len(x)==1 and [[0] + x] or [x])[0] for x in B]
print B
[[0, 5], [0, 3], [0, 4]]
 
B = [(len(x)==2 and [x + [1]] or [x])[0] for x in B]
print B
[[0, 5, 1], [0, 3, 1], [0, 4, 1]]

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.

Tyrtamos