IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

nombre variable de boucles


Sujet :

Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé
    Homme Profil pro
    développeur
    Inscrit en
    Octobre 2004
    Messages
    480
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : développeur
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Octobre 2004
    Messages : 480
    Par défaut nombre variable de boucles
    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 ?

  2. #2
    Membre Expert
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    1 418
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 1 418
    Par défaut
    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

  3. #3
    Expert confirmé
    Avatar de Guigui_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2002
    Messages
    1 864
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Saône et Loire (Bourgogne)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Enseignement

    Informations forums :
    Inscription : Août 2002
    Messages : 1 864
    Par défaut
    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).

  4. #4
    Membre éclairé
    Homme Profil pro
    développeur
    Inscrit en
    Octobre 2004
    Messages
    480
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : développeur
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Octobre 2004
    Messages : 480
    Par défaut
    Merci pour ces explications très claires.
    Je vais mettre en pratique ce soir chez moi.


    Citation Envoyé par Guigui_ Voir le message
    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.

  5. #5
    Expert confirmé
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 486
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 486
    Billets dans le blog
    6
    Par défaut
    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

  6. #6
    Expert confirmé
    Avatar de Guigui_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2002
    Messages
    1 864
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Saône et Loire (Bourgogne)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Enseignement

    Informations forums :
    Inscription : Août 2002
    Messages : 1 864
    Par défaut
    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')

  7. #7
    Expert confirmé
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 486
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 486
    Billets dans le blog
    6
    Par défaut
    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

  8. #8
    Membre éprouvé

    Profil pro
    Account Manager
    Inscrit en
    Décembre 2006
    Messages
    2 301
    Détails du profil
    Informations personnelles :
    Localisation : France, Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Account Manager

    Informations forums :
    Inscription : Décembre 2006
    Messages : 2 301
    Par défaut
    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 ?

  9. #9
    Membre éclairé
    Homme Profil pro
    développeur
    Inscrit en
    Octobre 2004
    Messages
    480
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : développeur
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Octobre 2004
    Messages : 480
    Par défaut
    Waou !!!!

    J'ai que l'embarras du choix

    Citation Envoyé par rambc Voir le message
    Une question à se poser serait de savoir si tu ne peux pas te passer de toutes ces boucles.
    J'ai bien peur que non.

    Citation Envoyé par rambc Voir le message
    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):
    			...

  10. #10
    Membre émérite

    Profil pro
    Inscrit en
    Août 2004
    Messages
    723
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2004
    Messages : 723
    Par défaut
    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.

Discussions similaires

  1. Boucles imbriquées de nombre variable
    Par CondensationdeCauchy dans le forum Débuter
    Réponses: 1
    Dernier message: 04/04/2015, 19h46
  2. Boucle While avec nombre variable de conditions
    Par jazzybluesy dans le forum Macros et VBA Excel
    Réponses: 2
    Dernier message: 22/09/2012, 19h05
  3. Pb de Boucles "Pour" (nombre variable)
    Par Isima dans le forum Algorithmes et structures de données
    Réponses: 4
    Dernier message: 28/05/2008, 10h53
  4. Boucles imbriquées en nombre variable
    Par lebelge dans le forum Fortran
    Réponses: 5
    Dernier message: 05/07/2007, 14h58
  5. Procédure avec un nombre variable d'arguments
    Par charly dans le forum Langage
    Réponses: 15
    Dernier message: 21/06/2002, 11h08

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo