Discussion :

[evpasquier]

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 :

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

[papyfouette]

Bonjour,

Est-ce que cela te convient:

Code :

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

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)

[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

[papyfouette]

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 :

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

[__dardanos__]

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

Code :

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

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

[evpasquier]

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 :

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

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

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 :

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

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

[BufferBob]

salut,

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 :

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

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 :

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

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__