如何比較Python中的兩個字典列表？

Question

如何比較dict的兩個列表？結果應該是奇數的了，從字典B.名單

例子：

ldA = [{'user':"nameA", 'a':7.6, 'b':100.0, 'c':45.5, 'd':48.9}, 
     {'user':"nameB", 'a':46.7, 'b':67.3, 'c':0.0, 'd':5.5}] 


ldB =[{'user':"nameA", 'a':7.6, 'b':99.9, 'c':45.5, 'd':43.7}, 
     {'user':"nameB", 'a':67.7, 'b':67.3, 'c':1.1, 'd':5.5}, 
     {'user':"nameC", 'a':89.9, 'b':77.3, 'c':2.2, 'd':6.5}] 

在這裏，我想和1dB的比較LDA。它應該打印下面的輸出。

ldB -> {user:"nameA", b:99.9, d:43.7} 
ldB -> {user:"nameB", a:67.7, c:1.1 } 
ldb -> {user:"nameC", a:89.9, b:77.3, c:2.2, d:6.5} 

我已經通過了下面的鏈接，但它只返回名稱，但我想要名稱和值如上。

List of Dicts comparision to match between lists and detect value changes in Python

Answer 1

對於一般的解決方案，請考慮以下內容。即使用戶在列表中出現故障，它也會適當地進行區分。

def dict_diff (merge, lhs, rhs): 
    """Generic dictionary difference.""" 
    diff = {} 
    for key in lhs.keys(): 
      # auto-merge for missing key on right-hand-side. 
     if (not rhs.has_key(key)): 
      diff[key] = lhs[key] 
      # on collision, invoke custom merge function. 
     elif (lhs[key] != rhs[key]): 
      diff[key] = merge(lhs[key], rhs[key]) 
    for key in rhs.keys(): 
      # auto-merge for missing key on left-hand-side. 
     if (not lhs.has_key(key)): 
      diff[key] = rhs[key] 
    return diff 

def user_diff (lhs, rhs): 
    """Merge dictionaries using value from right-hand-side on conflict.""" 
    merge = lambda l,r: r 
    return dict_diff(merge, lhs, rhs) 

import copy 

def push (x, k, v): 
    """Returns copy of dict `x` with key `k` set to `v`.""" 
    x = copy.copy(x); x[k] = v; return x 

def pop (x, k): 
    """Returns copy of dict `x` without key `k`.""" 
    x = copy.copy(x); del x[k]; return x 

def special_diff (lhs, rhs, k): 
     # transform list of dicts into 2 levels of dicts, 1st level index by k. 
    lhs = dict([(D[k],pop(D,k)) for D in lhs]) 
    rhs = dict([(D[k],pop(D,k)) for D in rhs]) 
     # diff at the 1st level. 
    c = dict_diff(user_diff, lhs, rhs) 
     # transform to back to initial format. 
    return [push(D,k,K) for (K,D) in c.items()] 

然後，您可以檢查的解決方案：

ldA = [{'user':"nameA", 'a':7.6, 'b':100.0, 'c':45.5, 'd':48.9}, 
     {'user':"nameB", 'a':46.7, 'b':67.3, 'c':0.0, 'd':5.5}] 
ldB =[{'user':"nameA", 'a':7.6, 'b':99.9, 'c':45.5, 'd':43.7}, 
     {'user':"nameB", 'a':67.7, 'b':67.3, 'c':1.1, 'd':5.5}, 
     {'user':"nameC", 'a':89.9, 'b':77.3, 'c':2.2, 'd':6.5}] 
import pprint 
if __name__ == '__main__': 
    pprint.pprint(special_diff(ldA, ldB, 'user')) 

Answer 2

我會假設相應dict s爲在這兩個列表的順序相同。

根據這一假設，您可以使用下面的代碼：

def diffs(L1, L2): 
    answer = [] 
    for i, d1 in enumerate(L1): 
     d = {} 
     d2 = L2[i] 
     for key in d1: 
      if key not in d1: 
       print key, "is in d1 but not in d2" 
      elif d1[key] != d2[key]: 
       d[key] = d2[key] 
     answer.append(d) 
    return answer 

未經檢驗。請評論是否有錯誤，我會修復它們

Answer 3

我的方法：根據要排除的值的ldA構建查找，然後確定從ldB中排除每個列表中適當值的結果。

lookup = dict((x['user'], dict(x)) for x in ldA) 
# 'dict(x)' is used here to make a copy 
for v in lookup.values(): del v['user'] 

result = [ 
    dict(
     (k, v) 
     for (k, v) in item.items() 
     if item['user'] not in lookup or lookup[item['user']].get(k, v) == v 
    ) 
    for item in ldB 
] 

You should, however, be aware that comparing floating-point values like that can't be relied upon。

Answer 4

這絕對需要從您的示例數據中進行一些假設，主要是ldA中不會有用戶不在ldB中，如果這是一個無效假設，請告訴我。你可以稱之爲dict_diff(ldA, ldB, user)。

def dict_diff(ldA, ldB, key): 
    for i, dA in enumerate(ldA): 
     d = {key: dA[key]} 
     d.update(dict((k, v) for k, v in ldB[i].items() if v != dA[k])) 
     print "ldB -> " + str(d) 
    for dB in ldB[i+1:]: 
     print "ldB -> " + str(dB) 

Answer 5

還有一個解決方案有點怪異（對不起，如果我錯過的東西），但它也可以讓你配置自己的平等檢查（你只需要修改拉姆達的isEqual此），以及給你如何處理的情況下，兩種不同的選擇時，按鍵的不同：

ldA = [{'user':"nameA", 'a':7.6, 'b':100.0, 'c':45.5, 'd':48.9}, 
     {'user':"nameB", 'a':46.7, 'b':67.3, 'c':0.0, 'd':5.5}] 


ldB =[{'user':"nameA", 'a':7.6, 'b':99.9, 'c':45.5, 'd':43.7}, 
     {'user':"nameB", 'a':67.7, 'b':67.3, 'c':1.1, 'd':5.5}, 
     {'user':"nameC", 'a':89.9, 'b':77.3, 'c':2.2, 'd':6.5}] 

ldA.extend((ldB.pop() for i in xrange(len(ldB)))) # get the only one list here 

output = [] 

isEqual = lambda x,y: x != y # add your custom equality check here, for example rounding values before comparison and so on 

while len(ldA) > 0: # iterate through list 
    row = ldA.pop(0) # get the first element in list and remove it from list 
    for i, srow in enumerate(ldA): 
     if row['user'] != srow['user']: 
      continue 
     res = {'user': srow['user']} # 
     # next line will ignore all keys of srow which are not in row 
     res.update(dict((key,val) for key,val in ldA.pop(i).iteritems() if key in row and isEqual(val, row[key]))) 
     # next line will include the srow.key and srow.value into the results even in a case when there is no such pair in a row 
     #res.update(dict(filter(lambda d: isEqual(d[1], row[d[0]]) if d[0] in row else True ,ldA.pop(i).items()))) 
     output.append(res) 
     break 
    else: 
     output.append(row) 

print output 

Answer 6

我寫this tool而回，它目前可以合作pe嵌套列表，字典和集合。爲您提供了一個更簡潔的輸出（在. > i:1 > 'c'的.指頂層和i:1指列表索引1進行比較）：

compare(ldA, ldB) 
. > i:0 > 'b' dict value is different: 
100.0 
99.9 

. > i:0 > 'd' dict value is different: 
48.9 
43.7 

. > i:1 > 'a' dict value is different: 
46.7 
67.7 

. > i:1 > 'c' dict value is different: 
0.0 
1.1 

. lists differed at positions: 2 
['<not present>'] 
[{'c': 2.2, 'd': 6.5, 'a': 89.9, 'user': 'nameC', 'b': 77.3}]