如何根據Python中第一個相同的元素求出3個相同大小的排序列表？

Question

我有一個python dictionary，其中包含按鍵'time'，'power'和'usage'中的3 lists。 所有列表都具有相同數量的元素，並且所有列表均已排序。我想要做的是總結列表'權力'和'用法'的所有元素，它們的索引 對應於列表'時間'中的相同值，以便每次只有一個樣本的權力和使用率單元。

例如改造這個字典：

{'time': [1, 2, 2, 3, 4, 4, 5], 
'power': [2, 2, 3, 6, 3, 3, 2], 
'usage': [0, 1, 1, 2, 1, 4, 7]} 

這一個：

{'time': [1, 2, 3, 4, 5], 
'power': [2, 5, 6, 6, 2], 
'usage': [0, 2, 2, 5, 7]} 

已經我寫這段的作品代碼，但我不喜歡 這麼多：

d = {'time':[1,2,2,3,4,4,5], 'power':[0,1,1,2,1,4,7], 'usage':[2,2,3,6,3,3,2]} 
prev = -1 
new_d = {'time':[], 'power': [], 'usage':[]} 
indexes = range(len(d['time'])) 

for i in indexes: 
    if d['time'][i]!=prev: 
    new_d['time'].append(d['time'][i]) 
    new_d['power'].append(d['power'][i]) 
    new_d['usage'].append(d['usage'][i]) 
    else: 
    last_power = len(new_d['power']) - 1 
    last_usage = len(new_d['usage']) - 1 
    new_d['power'][last_power]+=d['power'][i] 
    new_d['usage'][last_usage]+=d['usage'][i] 
    prev=d['time'][i] 

print d 
print new_d 

有沒有蟒蛇的方式來做到這一點更簡單和全面？

Answer 1

>>> from itertools import groupby 
>>> from operator import itemgetter 
>>> d = {'usage': [0, 1, 1, 2, 1, 4, 7], 'power': [2, 2, 3, 6, 3, 3, 2], 'time': [1, 2, 2, 3, 4, 4, 5]} 
>>> groups = groupby(zip(d['time'], d['power'], d['usage']), key=itemgetter(0)) 
>>> lists = zip(*[[k] + map(sum, zip(*g)[1:]) for k, g in groups]) 
>>> dict(zip(('time', 'power', 'usage'), lists)) 
{'usage': (0, 2, 2, 5, 7), 'power': (2, 5, 6, 6, 2), 'time': (1, 2, 3, 4, 5)} 

對於按鍵的數量可變的，我已經添加了keys變量，以避免重寫他們：

>>> from itertools import groupby 
>>> from operator import itemgetter 
>>> keys = ('time', 'power', 'usage') 
>>> groups = groupby(zip(*[d[k] for k in keys]), key=itemgetter(0)) 
>>> lists = zip(*[[k] + map(sum, zip(*g)[1:]) for k, g in groups]) 
>>> dict(zip(keys, lists)) 
{'usage': (0, 2, 2, 5, 7), 'power': (2, 5, 6, 6, 2), 'time': (1, 2, 3, 4, 5)} 

Answer 2

一個強大的解決方案，它可以處理任何數量的額外字段 - 由「時間」字段排序（方法）：

def aggregate(old_d, sort_key='time'): 
    new_d = dict((k, []) for k in old_d) 
    prev = None 
    curr = None 
    for i in range(len(old_d[sort_key])): 
     curr = old_d[sort_key][i] 
     for key, lst in new_d.iteritems(): # .items() in Python 3+ 
      if prev == curr: 
       if key != sort_key:   
        lst[-1] += old_d[key][i] 
      else: 
       lst.append(old_d[key][i]) 
     prev = curr 
    return new_d 

使用你的字典：

d = {'time': [1, 2, 2, 3, 4, 4, 5], 
    'power': [2, 2, 3, 6, 3, 3, 2], 
    'usage': [0, 1, 1, 2, 1, 4, 7]} 

print aggregate(d) 
>>> 
{'usage': [0, 2, 2, 5, 7], 'power': [2, 5, 6, 6, 2], 'time': [1, 2, 3, 4, 5]} 

Answer 3

這是「pythonian way」:)：

d = {'time': [1, 2, 2, 3, 4, 4, 5], 
'power': [2, 2, 3, 6, 3, 3, 2], 
'usage': [0, 1, 1, 2, 1, 4, 7]} 

new_d = {'time' : [], 'power' : [], 'usage' : []} 

for time in set(d['time']): 
    new_d['time'].append(time) 
    new_d['power'].append(sum(value for index, value in enumerate(d['power']) if d['time'][index] == time)) 
    new_d['usage'].append(sum(value for index, value in enumerate(d['usage']) if d['time'][index] == time)) 

print new_d 

Answer 4

您可以對任意數量的額外字段使用以下方法：

from itertools import groupby 
from operator import itemgetter 

dic = {'time': [1, 2, 2, 3, 4, 4, 5], 
'power': [2, 2, 3, 6, 3, 3, 2], 
'usage': [0, 1, 1, 2, 1, 4, 7]} 

aggrigated = {} 
fields = dic.items() 

for field in fields: 
    aggrigated[field[0]] = [sum(y[1] for y in x) 
           for k,x in groupby(
            zip(fields[0][1], field[1]), 
            key=itemgetter(0)) 
          ] 

改進版借用Ashwini Chaudhary的回答。

Answer 5

使用itertools.groupby，zip和一些列表理解：

In [55]: dic={'time': [1, 2, 2, 3, 4, 4, 5], 
    ....: 'power': [2, 2, 3, 6, 3, 3, 2], 
    ....: 'usage': [0, 1, 1, 2, 1, 4, 7]} 

In [56]: from itertools import groupby 

In [57]: from operator import itemgetter 

In [58]: zip1=zip(dic['time'],dic['power']) #use `itertools.izip` for performance  

In [59]: [sum(x[1] for x in v) for k,v in groupby(zip1,key=itemgetter(0))] 
Out[59]: [2, 5, 6, 6, 2] 

In [60]: zip2=zip(dic['time'],dic['usage']) 

In [61]: [sum(x[1] for x in v) for k,v in groupby(zip2,key=itemgetter(0))] 
Out[61]: [0, 2, 2, 5, 7] 

In [64]: timee=[k for k,v in groupby(dic['time'])] 

In [65]: timee 
Out[65]: [1, 2, 3, 4, 5] 

zip1是[(1, 2), (2, 2), (2, 3), (3, 6), (4, 3), (4, 3), (5, 2)]，現在你可以基於所述第一項目組的元件使用itertools.groupby再取每一個元組的第二個元素的總和的返回組。

In [75]: new_time=[k for k,v in groupby(dic['time'])] 

In [76]: new_power=[sum(x[1] for x in v) for k,v in groupby(zip1,key=itemgetter(0))] 

In [77]: new_usage=[sum(x[1] for x in v) for k,v in groupby(zip2,key=itemgetter(0))] 

In [80]: dict(zip(('time','power','usage'),(new_time,new_power,new_usage))) 
Out[80]: {'power': [2, 5, 6, 6, 2], 'time': [1, 2, 3, 4, 5], 'usage': [0, 2, 2, 5, 7]} 

Answer 6

我會先將這些值組合在一個新的字典中，然後求和。需要多一點空間，但它的方便，快捷：

from collections import defaultdict 
from itertools import groupby 

power = defaultdict(list) 
usage = defaultdict(list) 

for i, time in enumerate(data['time']): 
    power[time].append(data['power'][i]) 
    usage[time].append(data['usage'][i]) 

times = [key for key,group in groupby(data['time'])] 

print { 'time': times, 
      'power' : [sum(power[time]) for time in times], 
      'usage' : [sum(usage[time]) for time in times] 
     } 

Answer 7

from itertools import izip 

def m_(time, power, usage): 

    time_, power_, usage_ = [], [], [] 

    for t, p, u in izip(time, power, usage): 

     if not time_: 
      time_.append(t) 
      power_.append(0) 
      usage_.append(0) 

     if time_[-1] == t: 
      power_[-1] += p 
      usage_[-1] += u 
     else: 
      time_.append(t) 
      power_.append(p) 
      usage_.append(u) 

    time[:], power[:], usage[:] = time_, power_, usage_ 

if __name__ == '__main__': 
    d = {'time':[1,2,2,3,4,4,5], 'power':[0,1,1,2,1,4,7], 'usage':[2,2,3,6,3,3,2]} 
    m_(**d) 
    print d 

Answer 8

這是一個可以處理任意字典的程序....（其中d是您的字典...）

from itertools import groupby, imap 
from operator import itemgetter 

def group_dict_by(mapping, field, agg=sum): 
    grouper = mapping[field] 
    new_grouper = [] 
    accum = {k: [] for k in mapping.viewkeys() - [field]} 
    for key, grp in groupby(enumerate(grouper), itemgetter(1)): 
     new_grouper.append(key) 
     idx = [g[0] for g in grp] 
     for dk, dv in accum.iteritems(): 
      dv.append(agg(imap(mapping[dk].__getitem__, idx))) 

    accum[field] = new_grouper 
    return accum 

print group_dict_by(d, 'time') 
# {'usage': [0, 2, 2, 5, 7], 'power': [2, 5, 6, 6, 2], 'time': [1, 2, 3, 4, 5]} 

Answer 9

下面是我的問題的確切解決方案。我根據jamylak 的答案做出了它，我認爲這是所有給出的最「蟒蛇」和全面的解決方案。我所做的是修改他的代碼以便與多個字段一起工作，即字典中的多個 列表。我已經接受jamylak的答案，這裏是多領域解決 ：

from itertools import groupby    
from operator import itemgetter 

d = {'power': [2, 2, 3, 6, 3, 3, 2], 
    'usage': [0, 1, 1, 2, 1, 4, 7], 
    'time': [1, 2, 2, 3, 4, 4, 5]} 

# construct a list with all the key names (starting from 'time') 
keys = ['time'] + [key for key in d.keys() if key!='time'] 
# construct a list with all the keys' lists (starting from the one of 'time') 
keys_lists = [ d['time'] ] + [d[key] for key in d.keys() if key!='time'] 
groups = groupby(zip(*keys_lists), key=itemgetter(0)) 
lists = zip(*[[k] + map(sum, zip(*g)[1:]) for k, g in groups]) 
new_d = dict(zip((keys), lists)) 
print new_d