如何对文件中的条目进行迭代，生成具有唯一值的字典，并为可能多次出现的每个值计算平均值？

Question

我有一张这样的桌子：

id  value
AGA 0.211
AGA 0.433
AGA 0.123
AGH 0.002
DHI 0.063
DHI 0.193
DHI 0.004
KHI 0.543
KHI 0.064
HID 0.234

对于每个id，有时有不同的值。我想计算每个id有多少个入口，每个id的平均值和值的总和，结果如下：

id      cnt   sum   av
AGA     3     0.76  0.25
AGH     1     0.002 0.002
DHI     3     0.26  0.008
KHI     2     0.607 0.304
HID     1     0.234 0.234 

我认为最好先做一个字典，在那里我计算每个条目，但在那之后就卡住了，不知道是否最好将字典的值作为一个数组（使用cnt、sum和av），然后使用cnt的范围来计算，但想不出方法来做到这一点！这就是我能做到的：

idDict = {}
for line in file:
    line = line.rstrip()
    f = line.split()
    id = f[0]
    idDict[id] = idDict.get(id, 0) + 1

但是如果我已经在这里用cnt创建了字典，我不知道如何迭代每个id来进行求和和和av计算：（

Answer 1

以下是从^{}开始的一种方法：

from collections import defaultdict

mylist=[('AGA' ,0.211), ('AGA' ,0.433), ('AGA' ,0.123), ('AGH' ,0.002), 
        ('DHI', 0.063), ('DHI' ,0.193), ('DHI' ,0.004), ('KHI' ,0.543),
        ('KHI' ,0.064), ('HID' ,0.234)]

mydict = defaultdict(list)
for key, val in mylist:
    mydict[key].append(val)

summary = {}
for key, val in mydict.items():
    summary[key] = len(val), sum(val), sum(val)/len(val)

print summary
#Output:
{'KHI': (2, 0.60699999999999998, 0.30349999999999999), 
 'HID': (1, 0.23400000000000001, 0.23400000000000001), 
 'AGA': (3, 0.76700000000000002, 0.25566666666666665), 
 'DHI': (3, 0.26000000000000001, 0.08666666666666667), 
 'AGH': (1, 0.002, 0.002)}

Answer 2

由于表中的数据似乎是经过排序的，因此实际上不需要首先将所有内容都放在字典中，但这样可能会使事情更清楚。但我猜你的桌子可能会变得很大，所以再次存储所有东西是一个资源杀手。。。你知道吗

def sum_up(id, list):
    counted = len(list)
    summed = sum(list)
    avrg = summed/counted
    # print, insert or do whatever needed with the lines:
    print counted, summed, avrg

last_id = None
current = []
for line in file:
    (id, value) = line.split()
    if last_id != id:
        if last_id is not None:
            # evaluate last id
            sum_up(last_id, current)
            current = []
        # remember id
        last_id = id
    # append to current ids entries
    current.append(value)

# do the last id, if there is any:
if len(current) > 0:
    sum_up(last_id, current)

我没有测试代码，但你应该知道。它看起来有点复杂，但是当您有超过10万行左右的代码时，您应该会感觉到一种不同：首先在内存中加载所有内容，然后再进行处理