Problème comparaison de listes

Version imprimable

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:

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.

Code:

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:

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:

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:

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

par

Code:

cl = clk[1:]

Ce qui suit :

Code:

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:

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.

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

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

23/07/2010, 20h35
eyquem
Un reproducteur serait "mieux".
C’est quoi ?

Pourquoi est ce plus compliqué que:
Quoi donc ?
Code:

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.
23/07/2010, 21h34
wiztricks

Salut,

Citation:

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

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

Citation:

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.

Citation:

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