sommer les elements d'une liste

Version imprimable

05/04/2013, 09h34
pat100

sommer les elements d'une liste

Bonjour

je voudrai sommer les elements correspondant au même nom dans la liste suivante

[(<Material: BN55>, 2.9529087167976291), (<Material: BN55>, 0.925711193568296
23), (<Material: FG77>, 3.1211045110192654), (<Material: FG77>, 3.25548782768039
), (<Material: Al2O3>, 1.1663297283404019), (<Material: Al2O3>, 1.36212370263133
82)]

c'est a dire par exemple pour BN55 sommer 2.9529 et 0.927

me retrouver finalement avec la liste

[(<Material: BN55>, 3.8786199103659253), (<Material: FG77>, 6.3765923386996555),(<Material: Al2O3>, 2.5284534309717399)]
05/04/2013, 11h09
Julien N

Bonjour Pat100.

Cette tâche ne peut-elle pas être directement réalisée lors de la construction de ta liste?

http://www.developpez.net/forums/d13...s/#post7214864

Hors sujet:

Si je comprends bien tu as une liste de matériaux associés à une valeur (surface je crois). Je ne sais pas ce que tu comptes faire de cette liste par la suite, mais j'ai comme l'impression qu'un dictionnaire serait plus adapté.

Ju

j'ai trouvé

Code:

1
2
3
4
5
6
7
8
9
10
for mat100 in M4:
        if j !=0:
            XX=[]
            if M4[j-1][0]==M4[j][0]:
               XX.append(M4[j-1][1])
               XX.append(M4[j][1])
               XX= sum(XX)
               M6.append((M4[jj][0],XX))
        j+=1
        jj+=1

Peut-être...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def process(lst):
    res = dict()
    for key, val in lst:
        #Le second parametre de get est la valeur
        #a retourner au cas ou <key> n'est pas encore
        #contenu dans le dictionnaire
        res[key] = res.get(key, 0) + val
    return res.items()
 
if __name__ == "__main__":
    testList = [("<Material: BN55>", 2.9529087167976291),
                ("<Material: BN55>", 0.92571119356829623),
                ("<Material: FG77>", 3.1211045110192654),
                ("<Material: FG77>", 3.25548782768039),
                ("<Material: Al2O3>", 1.1663297283404019),
                ("<Material: Al2O3>", 1.3621237026313382)]
    print process(testList)

Bonsoir,

Adepte de in je trouve cela plus 'lisible' et plus rapide (Bien sur utile si c'est une grosse liste...) par rapport aux méthodes.

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
28
29
30
31
32
33
34
35
import random
import time
 
 
def process(lst):
    res = dict()
    for key, val in lst:
        res[key] = res.get(key, 0) + val
    return res
 
def process1(lst):
    res = {}
    for key, val in lst:
        if key in res:
            res[key] += val
        else:
            res[key] = val
    return res
 
 
v = (2.9529087167976291, 0.92571119356829623, 3.1211045110192654)
k = ("<Material: BN55>", "<Material: FG77>", "<Material: Al2O3>")
testList = []
for kv in range(500000):
    testList.append((k[random.randint(0, 2)], v[random.randint(0, 2)]))
tps1 = time.clock()
test1 = process(testList)
tps2 = time.clock()
print(tps2 - tps1)
tps1 = time.clock()
test2 = process1(testList)
tps2 = time.clock()
print(tps2 - tps1)
print(test1)
print(test2)

Sinon bon exemple du get()

@+

Sujet du week ? :D

@Pausekawa en cherchant la fiche des performances des méthodes de dict, je suis tomber sur des classes intéressantes du module collections.
D'abord <Counter> théoriquement fait pour cet usage, mais en moyenne 2 fois plus lent que le get. Et puis, <defaultdict> qui a un bien meilleur rendement:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import random
import collections
import time
 
 
def process(lst):
    res = dict()
    for key, val in lst:
        res[key] = res.get(key, 0) + val
    return res
 
def process1(lst):
    res = {}
    for key, val in lst:
        if key in res:
            res[key] += val
        else:
            res[key] = val
    return res
 
def zero():
    return 0
 
def process2(lst):
    res = collections.defaultdict(zero)
    for key, val in lst:
        res[key] += val
    return res
 
 
v = (2.9529087167976291, 0.92571119356829623, 3.1211045110192654)
k = ("<Material: BN55>", "<Material: FG77>", "<Material: Al2O3>")
testList = []
for kv in range(500000):
    testList.append((k[random.randint(0, 2)], v[random.randint(0, 2)]))
tps1 = time.clock()
test1 = process(testList)
tps2 = time.clock()
print(tps2 - tps1)
tps1 = time.clock()
test2 = process1(testList)
tps2 = time.clock()
print(tps2 - tps1)
tps1 = time.clock()
test3 = process2(testList)
tps2 = time.clock()
print(tps2 - tps1)
print(test1)
print(test2)
print(test3)

06/04/2013, 11h40
fred1599

Travaillant sur des éléments, possible que le tuple soit préférable à la liste en ce qui concerne le paramètre de fonction process.
06/04/2013, 12h04
PauseKawa

Bonjour fred1599,

Pas compris :oops:
07/04/2013, 10h09
fred1599

Salut PauseKawa,

lst est du type list ou tuple en paramètre, afranck64 dans son exemple, utilises une liste (testList), seulement pour l'exemple et la comparaison du temps de réponse, utiliser un tuple d'éléments est un meilleur choix me semble-t-il, non?
07/04/2013, 10h59
PauseKawa

Le tuple est 'moins lourd' que la liste mais si la comparaison est sur le même objet qu'importe ?
07/04/2013, 11h50
fred1599

Oui tu as raison, je pense que l'accès est en O(1) pour tuple ou liste, mais je parlais du moment où on unpack, et c'est sur un tuple, donc l'optimisation était faites correctement, autant pour moi.
08/04/2013, 08h27
pat100

merci beaucoup de vos reponses

evidemment, j'avais faux..

j'opte pour la solution de afranck64

merci encore

:D