Discussion :

[manaliac]

Bonjour,

Je dois comparer deux listes L1 et L2 sur un critère d'égalité de certaines de leurs valeurs puis d'ajouter L2 à L1 quand la condition est verifiée !!

exemple :

L1 = [ [a,b, x,[n,f,gt],[lo,k,l,m]] , [rt,f, y,[nd,f,gt],[lo,k,l,m]] ]
L2 = [ [x,[g,e,o,m,e,t,r,i,e],i,n,f,o,s1] , [y,[g1,e,o,m,e,t,r,i,e22],i,n,f,o,s2] ]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for blk in L1:    
        for clk in L2:
            if blk[2] == clk[0] : # les deux indices correspondent
               blk_nnspl1= copy.copy(blk) # on copie le domaine et ses caractéristiques
               cl = copy.copy(clk)
	       cl.pop(0) # on enleve le numero d'identification car on n'en a plus besoin
               clk1.append(cl)
               blk_nnspl1.append(clk1)
               blk_nnspla.append(blk_nnspl1)
               aku = p_nnspl.index(clk)
               p_nnspl.pop(aku)
	       #print " enfin mon premier block ", blk_nnspl1
            else:
               continue

et je voudrais obtenir la chose suivante :

blk_nnspl1 = [ [a,b, x,[n,f,gt],[lo,k,l,m] , [[g,e,o,m,e,t,r,i,e],i,n,f,o,s1] ], [rt,f, y,[nd,f,gt],[lo,k,l,m],[[g1,e,o,m,e,t,r,i,e22],i,n,f,o,s2] ] ]

Or cela ne marche pas !!

Auriez vous une autre idée de comment trier?

M.

[eyquem]

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
L1 = [ ['a','b', 'x',['n','f','gt'],['lo','k','l','m']] ,
       ['rt','f', 'y',['nd','f','gt'],['lo','k','l','m']] ]
L2 = [ ['x',['g','e','o','m','e','t','r','i','e'],'i','n','f','o','s1'] ,
       ['y',['g1','e','o','m','e','t','r','i','e22'],'i','n','f','o','s2'] ]
 
 
print 'L1 =\n','\n'.join(repr(y) for y in L1)
print
print '\nL2 =\n','\n'.join(repr(y) for y in L2)
print
 
deek2 = dict( (clk[0] , clk[1:]) for clk in L2 )
print 'deek2 =\n','\n'.join( repr(z)+' : '+repr(deek2[z]) for z in deek2)
print
 
for blk in L1:
    for i,x in enumerate(blk):
        if type(x)==type([]):
            if blk[i-1] in deek2.keys():
                blk.append(deek2[blk[i-1]])
                break
 
print 'L1 apres complementation =\n','\n\n'.join(map(repr,L1))

Dans ce code, le dernier élément de blk à ne pas être une liste peut avoir n’importe quelle position.

Dans ton cas où il est toujours en position 2, on peut écrire:

Code :

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

1
2
3
for blk in L1:
    if blk[2] in deek2.keys():
        blk.append(deek2[blk[2]])

----------

Au lieu de mettre dans le dictionnaire deek2 les morceaux de liste qui vont être ajoutés dans L1, on peut simplement y mettre l’indice de la sous-liste concernée dans L2:

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
L1 = [ ['a','b', 'x',['n','f','gt'],['lo','k','l','m']] ,
       ['rt','f', 'y',['nd','f','gt'],['lo','k','l','m']] ]
L2 = [ ['x',['g','e','o','m','e','t','r','i','e'],'i','n','f','o','s1'] ,
       ['y',['g1','e','o','m','e','t','r','i','e22'],'i','n','f','o','s2'] ]
 
 
print 'L1 =\n','\n'.join(repr(y) for y in L1)
print
print '\nL2 =\n','\n'.join(repr(y) for y in L2)
print
 
deek2 = dict( (clk[0] , i) for i,clk in enumerate(L2) )
print 'deek2 =\n','\n'.join( repr(z)+' : '+repr(deek2[z]) for z in deek2)
print
 
for blk in L1:
    if blk[2] in deek2.keys():
        blk.append(L2[deek2[blk[2]]][1:])
 
 
print 'L1 apres complementation =\n','\n\n'.join(map(repr,L1))

----------------------------------------------------

Dans ton code:
il y a clk1.append(cl) : il faut que clk1 existe avant cette instruction


----------------------------------------

Il y a de l’idée dans ton code,
mais tu peux remplacer

Code :

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

1
2
cl = copy.copy(clk)
cl.pop(0)

par

Code :

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

cl = clk[1:]

Ce qui suit :

Code :

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

1
2
3
4
5
clk = [1,34,25,467,389,23]
print id(clk),clk
cl = clk[1:]
print id(clk),clk
print id(cl),cl

Code :

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

1
2
3
17541160 [1, 34, 25, 467, 389, 23]
17541160 [1, 34, 25, 467, 389, 23]
17541520 [34, 25, 467, 389, 23]

montre que ça ne pertube pas clk

--------------------------------------------------

Je n’ai pas regardé la suite.




N’hésite pas à poser d’autres questions.

[wiztricks]

Salut
Un reproducteur serait "mieux".
Pourquoi est ce plus compliqué que:

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
def xyz(L1, L2):
    for item in L1:
        for x in L2:
            if x[0] == item[2]:
                item.append(x[1:])
    return L1
 
if __name__ == '__main__':
    L1 = [ ['a','b', 'x',
                ['n','f','gt'],
                ['lo','k','l','m']
                ] ,
            ['rt','f', 'y',
                    ['nd','f','gt'],
                    ['lo','k','l','m']
                    ]
          ]
    L2 = [ ['x',
            ['g','e','o','m','e','t','r','i','e'],
                'i','n','f','o','s1'] ,
           ['y',
            ['g1','e','o','m','e','t','r','i','e22'],
                'i','n','f','o','s2']
        ]
    print xyz(L1, L2)

- W

[eyquem]

Un reproducteur serait "mieux".
C’est quoi ?



Pourquoi est ce plus compliqué que:
Quoi donc ?

Code :

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

1
2
3
 
for item in L1:
        for x in L2:

pour chaque item de L1, une boucle d’examen de L2 est réalisée. C’est du travail inutile. Si les listes sont longues, ça va peser sur la vitesse.
Avec la constitution d’un dictionnaire en un seul passage, on évite cette longueur.

[wiztricks]

Salut,

Un reproducteur serait "mieux".
C’est quoi ?

Un code qu'on peut exécuter reproduisant le problème rencontré.

Pourquoi est ce plus compliqué que:
Quoi donc ?

La méthode xyz que j'ai posté qui commence comme celle de l'auteur mais qui est beaucoup plus courte ensuite.

pour chaque item de L1, une boucle d’examen de L2 est réalisée. C’est du travail inutile. Si les listes sont longues, ça va peser sur la vitesse.
Avec la constitution d’un dictionnaire en un seul passage, on évite cette longueur.

D'abord on essaie de savoir ce qu'on veut puis on réalise du code qui essaie de le faire et si on a le temps on optimise.
Pour l'instant, nous n'en sommes qu'à l'étape 1...
- W