Distribuer les éléments de n listes un par un

Version imprimable

Bonjour à tous,

Je souhaiterai créer un programme qui permet de grouper/distribuer (je ne connais pas le terme exact) tous les éléments de n listes.
Par exemple pour 2 listes de 2 éléments :

t1 = [[0,1], [2,3]]
t2 = [[4,5],[6,7]]

t3 = [[[0,1],[4,5]],[[0,1],[6,7]],[[2,3],[4,5]],[[2,3],[6,7]]]

J'ai réussi à créer quelques lignes qui permettent de faire ça avec 2, 3 listes par contre je n'arrive pas à généraliser cette procédure pour le faire avec n listes.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 t1 = [[0,1], [2,3]] t2 = [[4,5],[6,7]] dic = {} dic['p0']=t1 dic['p1']=t2 set=[] k=0 n=len(t1) while k < n : i=0 while i < n: set.append([dic['p' + str(0)][k],dic['p' + str(1)][i]]) i+=1 k+=1 print set
J'espère que j'ai expliqué clairement et correctement ce que je souhaite faire.
Je vous remercie par avance pour votre aide.

A bientôt

ev

Bonjour,

Est-ce que cela te convient:

Code:

1
2
3
4
5
6
7
t1 = [[0,1], [2,3]]
t2 = [[4,5],[6,7]]
t3 = []
for i in t1:
    for u in t2:
        t3.append([i,u])
        print(t3)

25/04/2015, 15h24
evpasquier

Bonjour Papyfouette,

Merci pour se code, ça simplifie largement ce que j'avais écrit.
Cependant si j'ajoute une autre liste ou n autres listes, je souhaiterais que ce programme le prenne en compte automatiquement sans que je doivent rajouter de boucles. Je ne sais même pas si cela est possible !

Merci

ev

As-tu un exemple à me donner, car je comprend pas trop ce que tu veux faire du coups.
Quel est le but de ton programme ? Comment s'ajoute les listes, comment sont elle créée si tu ne désires pas faire de boucle ?

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 t1 = [[0,1], [2,3]] t2 = [[4,5],[6,7]] t3 = [] n = [] while 1: ajout = input("ajout1: ") if ajout == "": break ajout2 = int(input("ajout2: ")) ajout =int(ajout) n.append([ajout, ajout2]) for i in t1: for u in t2: for y in n: t3.append([i,u,n]) print(t3)

Là par exemple tu as une liste n = []
- jout et ajout2 pour la compléter et c'est rentré par l'utilisateur via un input.
Je pense pas que se soit ce que tu veux, mais comme c'est toi la programmeuse, il faut vraiment que tu détails ton projet car sinon je ne répondrais pas à tes attentes comme tu le souhaites ;)

Salut,
Le (trop méconnu) module itertools le fait :

Code:

1
2
3
4
5
6
>>> from itertools import product
>>> t1 = [[0,1], [2,3]]
>>> t2 = [[4,5],[6,7]]
>>> list(product(t1, t2))
[([0, 1], [4, 5]), ([0, 1], [6, 7]), ([2, 3], [4, 5]), ([2, 3], [6, 7])]
>>>

salut,

Citation:

Envoyé par evpasquier

Je souhaiterai créer un programme qui permet de grouper/distribuer (je ne connais pas le terme exact) tous les éléments de n listes.

en fait ça s'apparente à un produit (comme pour la multiplication) de n listes à priori
je sais pas si tu tiens expressément à coder la chose par toi même, sinon c'est faisable très facilement grâce au module itertools :
Code:

1 2 3 4 5 >>> import itertools >>> t1 = [[0,1], [2,3]] >>> t2 = [[4,5], [6,7]] >>> list(itertools.product(t1,t2)) [([0, 1], [4, 5]), ([0, 1], [6, 7]), ([2, 3], [4, 5]), ([2, 3], [6, 7])]
...et évidement ça marche avec n listes ^^
Code:

1 2 3 4 5 >>> t1 = [[0, 1], [2, 3]] >>> t2 = [[4, 5], [6, 7]] >>> t3 = [[8, 9], [10, 11]] >>> list(itertools.product(t1, t2, t3)) [([0, 1], [4, 5], [8, 9]), ([0, 1], [4, 5], [10, 11]), ([0, 1], [6, 7], [8, 9]), ([0, 1], [6, 7], [10, 11]), ([2, 3], [4, 5], [8, 9]), ([2, 3], [4, 5], [10, 11]), ([2, 3], [6, 7], [8, 9]), ([2, 3], [6, 7], [10, 11])]
edit: pris de vitesse par __dardanos__ :aie:

Re-bonjour,

Merci beaucoup à vous 3 pour vos réponses. Vos prog sont bien plus performant que le mien. Je cherche à présent à automatiser ces fonctions lorsque je rajoute une liste. Je m'explique :

En fait ce programme est une partie d'un algo de type recherche tabou. Donc au début j'ai (par exemple) 4 points de type :

P7=[25,28], P4=[32,36], P1=[15,11], P3=[8,3]
au début je commence mon algo avec 2 points, par exemple P7 et P4
I0=[P7,P4]
ensuite je recherche les plus proches voisins de ces deux points (+1 et -1 pour chaque coordonnées de chaque points) pour obtenir l'ensemble I :
I=[[25, 28], [24, 28], [25, 27], [26, 28], [25, 29], [32, 36], [31, 36], [32, 35], [33, 36], [32, 37]]
Déjà à ce moment là j'ai un problème d'automatisation car je dois rappeler la valeur de mon point dans mes boucles...
Code:

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 P7=[25,28] P4=[32,36] I0=[P7,P4] i=0 I=[] while i < len(I0): j=0 k=0 I.append(I0[i]) while j < len(I0[0]) : P7=[25,28] P4=[32,36] I0=[P7,P4] I0[i][j] = (I0[i][j])-1 I.append(I0[i]) #; print I0 j+=1 while k < len(I0[0]) : P7=[25,28] P4=[32,36] I0=[P7,P4] I0[i][k] = (I0[i][k])+1 I.append(I0[i]) #;print I0 k+=1 i+=1 print I
Ensuite je divise ces deux listes pour avoir les différents voisins du point initial, pour cela j'utilise un dictionnaire et j'obtiens :
dic {'Ps0': [[25, 28], [24, 28], [25, 27], [26, 28], [25, 29]], 'Ps1': [[32, 36], [31, 36], [32, 35], [33, 36], [32, 37]]}
Code:

1 2 3 4 5 6 n=5 i=0 dic={} for i in range ((len(I))/n) : dic['Ps' + str(i)]=I[(i*n):(n+n*i)] print 'dic', dic
pour finir je fais une série de boucles compliquées afin de générer tous mes couples de 2 coordonnées (pour P0 et P1) possible soit dans cette configuration 5^2 possibilités (la même chose que vos programmes en beaucoup beaucoup moins optimisés :)) :
set [[[25, 28], [32, 36]], [[25, 28], [31, 36]], [[25, 28], [32, 35]], [[25, 28], [33, 36]], [[25, 28], [32, 37]], [[24, 28], [32, 36]], [[24, 28], [31, 36]], [[24, 28], [32, 35]], [[24, 28], [33, 36]], [[24, 28], [32, 37]], [[25, 27], [32, 36]], [[25, 27], [31, 36]], [[25, 27], [32, 35]], [[25, 27], [33, 36]], [[25, 27], [32, 37]], [[26, 28], [32, 36]], [[26, 28], [31, 36]], [[26, 28], [32, 35]], [[26, 28], [33, 36]], [[26, 28], [32, 37]], [[25, 29], [32, 36]], [[25, 29], [31, 36]], [[25, 29], [32, 35]], [[25, 29], [33, 36]], [[25, 29], [32, 37]]]
Code:

1 2 3 4 5 6 7 8 9 10 11 12 set=[] n=5 ; i=1 while i < len(I0): j=0 while j < n: k=0 while k < n: set.append([dic['Ps' + str(0)][j],dic['Ps' + str(i)][k]]) k+=1 j+=1 i+=1 print 'set', set
Après je souhaite faire tourner un modèle pour chaque couple de points et si ma condition n'est pas vérifiée faire un :

I0.append(P1) et mon programme repars à calculer I, dic et set sans que je n'ai rien à faire, pour non plus 2 mais 3 points (P7, P4 et P1 soit 5^3 possibilités).

J'arrive à faire manuellement l'ajout d'un point en ajoutant une boucle (comme il est possible de faire avec vos programmes) par contre je n'arrive pas à automatiser cette procédure.

J'espère que je suis plus claire à présent.

Merci beaucoup pour votre aide.

ev

Citation:

Envoyé par evpasquier

J'espère que je suis plus claire à présent.

c'est un peu dense tout de même :aie: perso j'ai compris que la première partie, et le fait que tu utilises probablement pas les structures de données adéquates pour chaque compartimentation de ton problème

typiquement je sais pas à quoi te sert réellement la liste I, si tu l'utilises pas plus que ça tu peux carrément t'en passer, de la même manière plutôt que d'utiliser un dictionnaire Ps je te propose d'utiliser une liste :
Code:

1 2 3 4 5 6 Ps = [] for (x,y) in IO: l = [] for (ix, iy) in [(0,1),(-1,0),(0,0),(1,0),(0,-1)]: # coordonnees relatives du voisinage de chaque point l.append((x+ix, y+iy)) Ps.append(l)
ce qui plié en quatre dans une compréhension de liste donnera simplement :

Code:

Ps = [[(x+ix,y+iy) for (ix,iy) in [(0,1),(-1,0),(0,0),(1,0),(0,-1)]] for (x,y) in IO]

et le résultat, exploitable non pas par un identifiant du type 'Ps0' mais directement par l'index dans la liste :
Code:

1 2 3 4 5 6 >>> Ps [[(25, 29), (24, 28), (25, 28), (26, 28), (25, 27)], [(32, 37), (31, 36), (32, 36), (33, 36), (32, 35)]] >>> Ps[0] [(25, 29), (24, 28), (25, 28), (26, 28), (25, 27)] >>> Ps[1] [(32, 37), (31, 36), (32, 36), (33, 36), (32, 35)]
Citation:

pour finir je fais une série de boucles compliquées afin de générer tous mes couples de 2 coordonnées (pour P0 et P1) possible soit dans cette configuration 5^2 possibilités (...)

j'avoue qu'à partir de là j'ai plus tout compris, mais à priori tu sembles dire qu'avec les solutions qu'on t'avait donné plus haut tu as moyen de t'en sortir

Salut,

Première chose, divise ton code en fonctions distinctes que tu puisses développer une à une.

De toutes façon si tu veux ajouter des listes de points il faudra inévitablement le faire dans des fonctions.

Pour ton code, si l'ordre des couples de coordonnées n'est pas important, regarde si ceci te donne les résultats attendus.
Code:

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 from itertools import product def add_offset(values): r = range(values[0]-1, values[0]+2) l = [[v, values[1]] for v in r] l.extend([[values[0], values[1]-1], [values[0], values[1]+1]]) return l def distribute(*lists): return list(product(*lists)) P7 = [25, 28] P4 = [32, 36] dist = [] for i in [P7, P4]: dist.append(add_offset(i)) print 'dist', dist d = distribute(*dist) print 'distribution', d # On ajoute un point P6 = [40, 44] dist.append(add_offset(P6)) d = distribute(*dist) print 'distribution', d

25/04/2015, 20h05
evpasquier

Merci à vous tous,

VinsS la solution proposée marche parfaitement. Après je me refuse de l'utiliser sans comprendre... J'ai du travail pour demain.
Merci à tous pour votre aide. Vous êtes vraiment doués et c'était bluffant de voir vos réponses.

A bientôt

ev