Bonsoir à tous,
Mon problème est simple, je suis à la recherche depuis quelques heure la façon dont je peux créer des boucles for imbriquées en fonction du nombres de listes que je récupère. Les boucles devront pouvoir parcourir les listes. J'ai réussi à le faire mais manuellement. Voici le code que j'ai réalisé : http://pastebin.com/G0g3PmHp. Si vous voulez plus de précision sur mon programme, il n'y aura pas de soucis.
Merci d'avance et passé un bonne soirée

Tu as supprimé ton pastebin mais si j'ai bien compris ton problème tu n'as besoins que d'une boucle imbriquée :

for l in lists:
    for i in range (0, len(arr)):

Mon premier for doit être modifié en fonction de la façon dont tu récupère tes listes, mais l'ésprit y est (je connais que très peu python et je ne sais pas comment tu récupère tes boucles)

Il faut juste enlever le point à la fin de l'url pour voir son pastebin.

Rebonsoir, voici un nouveau lien : http://pastebin.com/YBF4pLwj
Je ne vois pas ce que c'est dans la deuxième boucle les(arr). C'est quoi arr ?

C'était len(l) désolé, j'avais changé de version en cours de route. Je viens de voir ton code ma solution ne convient pas pour ce que tu fais en effet. Par contre (encore un fois je connais très mal python), Tu peux surement faire une liste de listes ou un tableau de listes et te dépatouiller avec mon code.

D'accord je vois un peu l'idée, je vais voir. Si d'autres personnes ont une autres solutions. Merci

Je t'explique. Dans ma fonction je lui donne en paramètre une chaine de caractère par exemple "La lampe est noir". Je dois chercher tout les anagrammes des mots de la phrase (la fonction est réalisée), ce qui me donne :
La = ['la', 'là']
lampe = ['ample', 'lampe', 'palme', 'palmé']
est = ['est', 'set', 'tes']
noir = ['noir']
Selon, la méthode employée, on appellera liste1, liste2, etc.. ou alors faire une liste de liste [[liste1],[liste2]]. Et avec ça, créer différentes phrases en gardant l'ordre des mots mais avec toutes les combinaisons possibles du genre : "la palme set noir", "là ample tes noir", "la lampe set noir". Même si la phrase ne veut rien dire c'est pas grave. Et comme je l'ai dit plus haut la phrase peut contenir plus ou moins de mots c'est pourquoi je chercher une méthode pour imbriqués des boucle for selon le nombres de listes. Voilà j'espère que ça vous à éclairé.

Ce dont tu as besoin, c'est itertools.product() : https://docs.python.org/3/library/itertools.html#itertools.product

Cela peut s'utiliser quand on a besoin de créer un certain nombre de boucles for imbriquées défini dynamiquement.

Donc ton code devrait ressembler à quelque chose comme ça :

# Une liste contenant les listes des anagrammes pour chacun de tes mots
anagrams_lists = generate_anagrams(sentence) 

for words in itertools.product(*anagrams_lists):  # '*' c'est pour l'unpacking
    # 1ère itération : words == ('la', 'ample', 'est', 'noir')
    # 2ème itération : words == ('la', 'ample', 'set', 'noir')
    # 3ème itération : words == ('la', 'ample', 'tes', 'noir')
    # ...

    print(*words)  # "la ample est noir"

A ta place je pense que je ferais une liste d'entier représentant les indices des listes de mots, puis j'augmenterais la valeur de l'entier de l'indice 0 de 1 jusqu'à qu'il soit égale à la taille de la 1re liste de mot, puis après j'augmenterais l'entier de l'indice 1 tout en repassant l'indice 0 à 0, et je recommencerais etc etc.

En gros, t'as qu'une seule boucle, qui se charge d'incrémenter des indices, en imaginant que t'as 3 listes des 3 mots chacune, tes indices feront ça :

Tour 1 : 0 0 0
Tour 2 : 1 0 0
Tour 3 : 2 0 0
Tour 4 : 0 1 0
Tour 6 : 1 1 0
Tour 7 : 2 1 0
...

Puis à chaque tours, t'affiches les mots qui correspondent à l'indice de la liste des indices.

EDIT: Ah bah visiblement il y a plus simple.

Et juste pour revenir à ce que j'ai proposé (en prenant toujours l'exemple des 3 listes de 3 mots), pour incrémenter les indices correctement à chaque tour de boucle, tu incrémente simplement l'indice 0, puis s'il est supérieur à 2 tu le mets à 0 et tu incrémentes l'indice 1, puis si ce dernier est supérieur à 2 tu refais la même chose etc etc.

Donc au final t'as besoin de 2 boucles et non une seule, la première pouvant être une while qui vérifie si le dernier nombre de la liste des indices n'est pas trop grand, la deuxième (celle qui s'occupe d'incrémenter les indices) serait plutôt une for qui parcoure toute la liste des indices en les incrémentant à chaque fois, puis si la valeur de l'indice est trop grande elle la met à 0, sinon elle fait un break (parce que plus besoin d'incrémenter la suite).

Enfin bref je me rends compte que c'est pas très facile d'expliquer à l'écrit comme ça, puis de toute façon c'est assez compliqué comme solution par rapport à ce que propose Blaff2 donc potentiellement pas très intéressant.

Le problème est que nous somme obligé d'importer itertools. J'ai coder pour essayer et ça fonctionne. Voici le code :
from itertools import product a = [['mange', 'mangé'],['ont', 'ton'],['onagre', 'orange', 'orangé', 'organe', 'rongea']] print(list(product(*a)))

Ça donne : [('mange', 'ont', 'onagre'), ('mange', 'ont', 'orange'), ('mange', 'ont', 'orangé'), ('mange', 'ont', 'organe'), ('mange', 'ont', 'rongea'), ('mange', 'ton', 'onagre'), ('mange', 'ton', 'orange'), ('mange', 'ton', 'orangé'), ('mange', 'ton', 'organe'), ('mange', 'ton', 'rongea'), ('mangé', 'ont', 'onagre'), ('mangé', 'ont', 'orange'), ('mangé', 'ont', 'orangé'), ('mangé', 'ont', 'organe'), ('mangé', 'ont', 'rongea'), ('mangé', 'ton', 'onagre'), ('mangé', 'ton', 'orange'), ('mangé', 'ton', 'orangé'), ('mangé', 'ton', 'organe'), ('mangé', 'ton', 'rongea')]

Dans l'idée c'est ça mais je n'ai rien crée. Ensuite j'ai essayé ce que tu m'as donné Blaff2 mais je n'arrive pas à avoir ce que je veux. Voici le code :
def product(*args, repeat=1): pools = [tuple(pool) for pool in args] * repeat result = [[]] for pool in pools: result = [x+[y] for x in result for y in pool] for prod in result: yield tuple(prod) for i in product(([['mange', 'mangé'],['ont', 'ton'],['onagre', 'orange', 'orangé', 'organe', 'rongea']]), repeat=1): print(i)

Et ça me donne : (['mange', 'mangé'],)
(['ont', 'ton'],)
(['onagre', 'orange', 'orangé', 'organe', 'rongea'],)

En quoi est-ce un problème d'importer itertools ?

Cela fait partie de la librairie standard de Python, c'est fait pour être utilisé, autant coder en C si tu ne veux pas profiter de toutes les riches fonctionnalités du langage.

Ta deuxième version ne fonctionne pas car tu n'as pas "unpacké" la liste avant d’appeler product().

L'idée de la fonction product c'est que tu peux lui donner en entrer autant de paramètres que tu veux : product([1, 2, 3], [4, 5, 6]) (2 paramètres) ou product([1, 2, 3], [4, 5, 6], [7, 8, 9]) (3 paramètres) sont tous deux corrects. Note que les paramètres doivent être des itérables, puisque en fonction de ceux-ci, la fonction va générer toute les "combinaisons" que tu aurais obtenues avec des boucles imbiquées.

Donc si tu "n'unpack" pas ta liste, la fonction product va prendre ça comme un unique argument, et tu n'auras pas le résultat escompté.

De plus, le paramètre repeat est là pour te faciliter la vie si les arguments que tu veux donner sont toujours les mêmes. product([1, 2, 3], repeat=3) est strictement équivalent à product([1, 2, 3], [1, 2, 3], [1, 2, 3]). Donc pas besoin de le préciser si la valeur vaut 1.

Ah oui c'est bon ça fonctionne niquel !
Par contre comment je pourrais faire pour qu'il me renvoie dans cette forme ['mange ton orange', 'mange ton organe'] et non ['mange ton orange'] ['mange ton organe'] ?

C'est bon j'ai réussi, je remercie tout le monde qui m'a aidé 😁👍🏻