0

次のように、辞書を含む2つのリストがあります。

listone = [{'unit1': {'test1': 10}}, 
           {'unit1': {'test2': 45'}, 
           {'unit2': {'test1': 78'}, 
           {'unit2': {'test2': 2'}}]

listtwo = [{'unit1': {'test1': 56}}, 
           {'unit1': {'test2': 34'}, 
           {'unit2': {'test1': 23'}, 
           {'unit2': {'test2': 5'}}]

私はまた、すべてのユニット名とテスト名を別々のリストに持っています:

units = ['unit1', 'unit2']
testnames = ['test1,'test2']

test2各テスト値のデルタ、つまり ( - )の val を見つけるにはどうすればよいtest1ので、最終的に次のようにデータを配置できます。

unit1, test1, delta
unit1, test2, delta
unit2, test1, delta
unit2, test2, delta

これまでのところ、私はこれらを持っています：

def delta(array1, array2):
        temp = []
        temp2 = []
        tmp = []
        tmp2 = []
        delta = []
        for unit in units:
            for mkey in array1:
                for skey in mkey:
                    if skey == unit:
                        temp.append(mkey[skey])
                        floater(temp) #floats all the values
                        for i in testnames:
                            for u in temp:
                                tmp.append(u[i])
                                tmp = filter(None, tmp2)

            for mkey in array2:
                for skey in mkey:
                    if skey == unit:
                        temp.append(mkey[skey])
                        floater(temp2)
                        for i in testnames:
                            for u in temp2:
                                tmp2.append(u[i])
                                tmp2 = filter(None, tmp2)

        delta = [tmp2 - tmp for tmp2, tmp in zip(tmp2, tmp)] 
        print delta

delta(listone,listtwo)

残念ながら、コードはKeyerror. :(助けてください。ありがとう。

4

4 に答える 4

2

おそらく、データを別のより便利なデータ構造に変換してください。たとえば、 の代わりにlistone、次のような単一の dict を使用する方が簡単です。

{('unit1', 'test1'): 10,
 ('unit2', 'test1'): 78,
 ('unit2', 'test2'): 2,
 ('unit1', 'test2'): 45}

ですから、

import itertools
units = ['unit1', 'unit2']
testnames = ['test1','test2']
listone = [{'unit1': {'test1': 10}}, 
           {'unit1': {'test2': 45}}, 
           {'unit2': {'test1': 78}}, 
           {'unit2': {'test2': 2}}]

listtwo = [{'unit1': {'test1': 56}}, 
           {'unit1': {'test2': 34}}, 
           {'unit2': {'test1': 23}}, 
           {'unit2': {'test2': 5}}]

ここでは、listoneandlisttwoを dict のリストに変換します。

dicts=[{},{}]
for i,alist in enumerate([listone,listtwo]):
    for item in alist:
        for unit,testdict in item.iteritems():
            for testname,value in testdict.iteritems():
                dicts[i][unit,testname]=value

を見つけるのdeltasは簡単です：

for unit,testname in itertools.product(units,testnames):
    delta=dicts[1][unit,testname]-dicts[0][unit,testname]
    print('{u}, {t}, {d}'.format(u=unit,t=testname,d=delta))

収量

unit1, test1, 46
unit1, test2, -11
unit2, test1, -55
unit2, test2, 3
于 2011-03-19T14:37:40.287 に答える
1

辞書の辞書を使うほうが簡単だと思います。ここでは、いくつかのテストプロセスから結果を収集していると想定しているため、段階的に定義しますが、1行で行うこともできます。

listOne = {}
listOne['unit1'] = {}
listOne['unit2'] = {}
listOne['unit1']['test1']=10
listOne['unit1']['test2']=45
listOne['unit2']['test1'] = 78
listOne['unit2']['test2'] = 2

listTwo = {}
listTwo['unit1'] = {}
listTwo['unit2'] = {}
listTwo['unit1']['test1']=56
listTwo['unit1']['test2']=34
listTwo['unit2']['test1'] = 23
listTwo['unit2']['test2'] = 5

units = ['unit1', 'unit2']
testnames = ['test1','test2']

deltas = {}

# collect the deltas
for unit in units :
    deltas[unit] = {}
    for test in testnames :
        deltas[unit][test] = listTwo[unit][test] -listOne[unit][test]

# print put the results
for unit in units :
    for test in testnames :
        print unit, ', ', test, ', ', deltas[unit][test]

これにより、

unit1 ,  test1 ,  46
unit1 ,  test2 ,  -11
unit2 ,  test1 ,  -55
unit2 ,  test2 ,  3
于 2011-03-19T15:10:49.577 に答える
1

同様ですが、もう少しカプセル化されています：

from collections import defaultdict

listone = [
    {'unit1': {'test1': 10}},
    {'unit1': {'test2': 45}}, 
    {'unit2': {'test1': 78}}, 
    {'unit2': {'test2': 2}}
]

listtwo = [
    {'unit1': {'test1': 56}},
    {'unit1': {'test2': 34}}, 
    {'unit2': {'test1': 23}}, 
    {'unit2': {'test2': 5}}
]

def dictify(lst):
    res = defaultdict(lambda: defaultdict(int))
    for entry in lst:
        for unit,testentry in entry.iteritems():
            for test,val in testentry.iteritems():
                res[unit][test] = val
    return res
    # returns dict['unitX']['testY'] = val

def genDeltas(dictA, dictB):
    units = dictA.keys()
    units.sort()
    tests = dictA[units[0]].keys()
    tests.sort()
    for unit in units:
        _A = dictA[unit]
        _B = dictB[unit]
        for test in tests:
            yield unit,test,(_B[test]-_A[test])

for unit,test,delta in genDeltas(dictify(listone),dictify(listtwo)):
    print "{0}, {1}, {2}".format(unit,test,delta)

編集：フィールド平均を見つけるには：

class Avg(object):
    def __init__(self, total=0.0, num=0):
        super(Avg,self).__init__()
        self.total = total
        self.num   = num

    def add(self, value):
        self.total += value
        self.num   += 1

    def value(self):
        return self.total / self.num

def avgBy(data, field=0):
    res = defaultdict(Avg)
    for unit,testdict in data.iteritems():
        for test,val in testdict.iteritems():
            res[(unit,test)[field]].add(val)
    return {item:avg.value() for item,avg in res.iteritems()}

dictone = dictify(listone)
avg_by_unit = avgBy(dictone, 0)
print(avg_by_unit)
avg_by_test = avgBy(dictone, 1)
print(avg_by_test)
于 2011-03-19T15:11:06.243 に答える
1

これにより、現在の問題が解決されます。

listone = [{'unit1': {'test1': 10}}, 
    {'unit1': {'test2': 45}}, 
    {'unit2': {'test1': 78}}, 
       {'unit2': {'test2': 2}}]

listtwo = [{'unit1': {'test1': 56}}, 
    {'unit1': {'test2': 34}}, 
    {'unit2': {'test1': 23}}, 
           {'unit2': {'test2': 5}}]

units = ['unit1', 'unit2']
testnames = ['test1', 'test2']


# Iterate over all units
for unit in units:
    # Iterate over all tests
    for test in testnames:
        # Find the rows corresponding to our current unit/test
        list1Row = [i for i,d in enumerate(listone) if d.keys()[0] == unit and d.values()[0].keys()[0] == test]
        list2Row = [i for i,d in enumerate(listtwo) if d.keys()[0] == unit and d.values()[0].keys()[0] == test]

        # Check to make sure there was exactly one match.
        # This is another weakness of your data structure.
        if (len(list1Row) == 1) and (len(list2Row) == 1):
            list1Row = list1Row[0]
            list2Row = list2Row[0]
            delta = listtwo[list2Row].values()[0].values()[0] - listone[list1Row].values()[0].values()[0]
            print unit, test, delta

ただし、前の投稿者が推奨したように、実際には別のデータ構造を検討する必要があります。（ユニット、テスト）キーとリスト値を持つ単一の辞書のようなものをお勧めします。

于 2011-03-19T15:18:19.533 に答える