Discussion :

[rom44]

Bonjour à tous, je débute depuis peu sur Python et j'ai un problème pour traiter des listes et dictionnaires.

Voici le topo:
j'ai un dictionnaire avec 2 clés :

Code :

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

d={'Ei' : des_valeurs , 'id': des_identifiants}

Certains identifiants sont identiques et j'aimerai faire une boucle qui passe tous les éléments de 'id'. Tant que les id sont identiques il faudrait mettre leur valeur (récupérée dans 'Ei' avec l'indice) dans une liste.
Lorsque tous les id identiques sont dans la liste, on fait la moyenne de leur valeur Ei
Une fois ceci fait il faudrait repartir sur une seconde série de id identiques

Un exemple pour être plus clair :p :

Code :

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

d= {'Ei': 1,3,4,4,6 , 'id' : 'r','r','t','t','t'}

Ce que j'aimerai c'est passer id, prendre tous les 'r' et mettre leur valeur Ei dans une liste temporaire v:

Code :

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

v=[1,3]

ensuite je fais un traitement sur v (moyenne) et après on repart sur le reste des id:
tous les 't':

Code :

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

1
2
v=[]
v.append(4,4,6)...

j'ai essayé avec de boucles while ou avec un for mais je n'arrive pas à m'en sortir. Même chose quand j'essaye

Code :

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

while id[i]==id[i+1]

ca m'embarque dans des trcus que je n'arrive pas à finaliser


Merci et j'espère avoir été a peu près clair

[Zavonen]

Avec quelle version de python travailles-tu?
Chez moi (2.6) la ligne:

Code python :

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

d= {'Ei': 1,3,4,4,6 , 'id' : 'r','r','t','t','t'}

ne passe pas.
par contre:

Code python :

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

d= {'Ei': (1,3,4,4,6) , 'id' : ('r','r','t','t','t')}

est admise

[rom44]

Bonjour,

oui oui tu as raison c'est moi qui est oublié les parenthèses ! Sorry
(je suis aussi en 2.6)

Mis à part ça est ce que ce que j'ai raconté est compréhensible ?

merci

[Zavonen]

Code python :

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

1
2
3
4
d= {'Ei': (1,3,4,4,6) , 'id' : ('r','r','t','t','t')}
L=[(d['id'][i],d['Ei'][i]) for i in xrange(0,len(d['Ei']))]
R=[(x,[y[1] for y in L if y[0]==x]) for x in set(d['id']) ]
print R

résultat:
[('r', [1, 3]), ('t', [4, 4, 6])]
Is that what you want ?

[rom44]

whaooooo ... les bras m'en tombent !
C'est beau ca !

Je le teste et je reviens te dire si ca fonctionne avec tout mon jeu de données.

merci en tous cas !

[dahtah]

Une version avec le module itertools:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
from itertools import groupby
 
d = {'Ei': (1,3,4,4,6) , 'id' : ('r','r','t','t','t')}
 
result = []
# Retourne les éléments associés à 'r' et à 't'
for key, group in groupby(zip(d['id'], d['Ei']), lambda x: x[0]):
       # Pour 'r' et 't' on ajoute les éléments retourner par le groupage
       result .append((key, [thing[1] for thing in group]))
 
print result

Pas sur que cette solution apporte grand chose de plus, mias ça m'a fait réviser itertools...

[eyquem]

Zavonen, ta solution présente deux inconvénients:


- perte de l’ordre:

Code :

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

1
2
3
4
5
d= {'Ei': (1,3,22,40,40,60,4000,5000) ,
    'id' : ('r','r','x','t','t','t','a','a')}
L=zip(d['id'],d['Ei'])
R=[(x,[y[1] for y in L if y[0]==x]) for x in set(d['id']) ]
print 'R =',R

Code :

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

R = [('a', [4000, 5000]), ('x', [22]), ('r', [1, 3]), ('t', [40, 40, 60])]

- mélange de toutes les occurences dans d[’id’], même non contigues:

Code :

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

1
2
3
4
5
d= {'Ei': (1,3,40,40,60,700,900,3000) ,
    'id' : ('riz','riz','t','t','t','riz','riz','a')}
L=zip(d['id'],d['Ei'])
R=[(x,[y[1] for y in L if y[0]==x]) for x in set(d['id']) ]
print 'R =',R

Code :

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

R = [('a', [3000]), ('riz', [1, 3, 700, 900]), ('t', [40, 40, 60])]

Mais ça n’a peut être pas d’importance pour l’application de rom44.








J’ai d’abord pensé aussi à groupby(iterable[, key]) , mais sans utliser key égale à lambda x: x[0] je ne suis arrivé à rien.

J’ai donc écrit une fonction génératrice:

Code :

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

1
2
3
4
5
6
7
8
9
def f_moy(d):
    jprec,idprec = 0,d['id'][0]
    for j,idx in enumerate(d['id']):
        if idx!=idprec:
            y = idprec,sum(d['Ei'][jprec:j])/(j-jprec)
            jprec,idprec = j,idx
            yield y
    j+=1
    yield d['id'][-1],sum(d['Ei'][jprec:j])/(j-jprec)

Cette fonction donne les moyennes, puisque c’est ce que vise rom44.





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



Ta solution est concise, datah, surtout si on l’écrit sous forme de list comprehension.
Mais elle a deux inconvénients:


1) elle est plus lente:

Pour comparer , j’ai réécrit ma fonction pour qu’elle donne les groupes.

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
27
28
29
30
31
32
33
34
35
36
from time import clock
from itertools import groupby
 
d = {'Ei': (1,3,4,4,6,70,80,2000,3000,4000,6000,1111,2222,
            23,13,43,53,63,733,93,83,13,33,65,75,85) ,
     'id' : ('r','r','t','t','t','r','r','b','b','b','b','x','y',
             'a','a','a','a','a','a','a','a','a','a','r','r','r')}
 
t0 = clock()
for x in xrange(10000):
    result = [ (key, [thing[1] for thing in group])
             for key, group in groupby(zip(d['id'], d['Ei']), lambda x: x[0]) ]
dt = clock()-t0
print dt
print result
 
print '\n'
 
 
def f_group(d):
    jprec,idprec = 0,d['id'][0]
    for j,idx in enumerate(d['id']):
        if idx!=idprec:
            y = idprec,d['Ei'][jprec:j]
            jprec,idprec = j,idx
            yield y
    j+=1
    yield d['id'][-1],d['Ei'][jprec:j]
 
 
t0 = clock()
for x in xrange(10000):
    resf = f_group(d)
dt = clock()-t0
print dt
print [u for u in f_group(d)]

Résultat: la version avec groupby() prend 27 fois le temps de la fonction f_group().




2) groupby() renvoit un itérateur qui débite des éléments (k,group) dont group est lui même un itérateur.

Or si on fait sum(group) , on épuise l’itérateur, c’est à dire que len(group) ne donnera ensuite pas de valeur. Ce qui n’est pas pratique pour calculer la moyenne de chaque groupe, qui est le centre d’intérêt de rom44.

Pour pallier à cette insuffisance, il faut enregistrer l’objet list(group) ou tuple(group). De ce fait on ne peut plus utiliser une list comprehension.

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
27
28
29
30
31
32
33
34
35
36
37
38
39
from time import clock
from itertools import groupby
 
d = {'Ei': (1,3,4,4,6,70,80,2000,3000,4000,6000,1111,2222,
            23,13,43,53,63,733,93,83,13,33,65,75,85) ,
     'id' : ('r','r','t','t','t','r','r','b','b','b','b','x','y',
             'a','a','a','a','a','a','a','a','a','a','r','r','r')}
 
to = clock()
for x in xrange(10000):
    result = []
    # Retourne les éléments associés à 'r' et à 't'
    for key, group in groupby(zip(d['id'], d['Ei']), lambda x: x[0]):
           # Pour 'r' et 't' on ajoute les éléments retourner par le groupage
           gr = tuple(group)
           result.append((key, sum(thing[1] for thing in gr)/len(gr)))
dt = clock()-t0
print dt
print result
 
print '\n'
 
 
def f_moy(d):
    jprec,idprec = 0,d['id'][0]
    for j,idx in enumerate(d['id']):
        if idx!=idprec:
            y = idprec,sum(d['Ei'][jprec:j])/(j-jprec)
            jprec,idprec = j,idx
            yield y
    j+=1
    yield d['id'][-1],sum(d['Ei'][jprec:j])/(j-jprec)
 
t0 = clock()
for x in xrange(10000):
    resf = f_moy(d)
dt = clock()-t0
print dt
print [u for u in f_moy(d)]

Ce faisant, le temps d’exécution de la méthode avec groupby() augmente: il est multiplié par 2,5 tandis que la méthode avec la fonction génératrice f_moy() voit son temps augmenter d’à peine 1 ou 2 %.

Ce qui au final fait qe la méthode avec groupby() et renvoi des moyennes met 65 fois plus de temps que la fonction f_moy().