Hướng dẫn python program to compare two dictionaries - chương trình python để so sánh hai từ điển

Nếu bạn muốn biết có bao nhiêu giá trị phù hợp trong cả hai từ điển, bạn nên nói điều đó :]

Có lẽ một cái gì đó như thế này:

shared_items = {k: x[k] for k in x if k in y and x[k] == y[k]}
print[len[shared_items]]

Baxx

3.0674 Huy hiệu vàng24 Huy hiệu bạc56 Huy hiệu Đồng4 gold badges24 silver badges56 bronze badges

Đã trả lời ngày 24 tháng 12 năm 2010 lúc 19:17Dec 24, 2010 at 19:17

8

Những gì bạn muốn làm chỉ đơn giản là

pip install deepdiff

2

Những gì bạn làm không phải là một ý tưởng tốt, bởi vì các mục trong từ điển không được phép có bất kỳ đơn đặt hàng nào. Bạn có thể so sánh

pip install deepdiff

3 với

pip install deepdiff

4 [cùng một từ điển, thứ tự khác nhau].

Ví dụ, xem điều này:

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

Sự khác biệt chỉ là một mục, nhưng thuật toán của bạn sẽ thấy rằng tất cả các mục là khác nhau

Đã trả lời ngày 24 tháng 12 năm 2010 lúc 19:11Dec 24, 2010 at 19:11

Jochen Ritzeljochen RitzelJochen Ritzel

102K30 Huy hiệu vàng196 Huy hiệu bạc192 Huy hiệu Đồng30 gold badges196 silver badges192 bronze badges

8

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

Pfabri

8131 Huy hiệu vàng9 Huy hiệu bạc25 Huy hiệu đồng1 gold badge9 silver badges25 bronze badges

Đã trả lời ngày 17 tháng 9 năm 2013 lúc 22:02Sep 17, 2013 at 22:02

Daniel Myersdaniel MyersDaniel Myers

2.2611 Huy hiệu vàng13 Huy hiệu bạc6 Huy hiệu đồng1 gold badge13 silver badges6 bronze badges

3

pip install deepdiff

5

Từ Python Docs:

Các ví dụ sau đây đều trả về một từ điển bằng

pip install deepdiff

6:all return a dictionary equal to

pip install deepdiff

6:

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

Cung cấp các đối số từ khóa như trong ví dụ đầu tiên chỉ hoạt động cho các khóa là định danh python hợp lệ. Nếu không, bất kỳ khóa hợp lệ nào cũng có thể được sử dụng.

So sánh có giá trị cho

pip install deepdiff

7 và

pip install deepdiff

8.

Đã trả lời ngày 1 tháng 12 năm 2016 lúc 22:03Dec 1, 2016 at 22:03

Pedro lobitopedro lobitoPedro Lobito

89.2K30 Huy hiệu vàng239 Huy hiệu bạc257 Huy hiệu Đồng30 gold badges239 silver badges257 bronze badges

14

Vì dường như không ai đề cập đến

pip install deepdiff

9, tôi sẽ thêm nó ở đây để hoàn thiện. Tôi thấy rất thuận tiện cho việc nhận các đối tượng [lồng nhau] nói chung:

Cài đặt

pip install deepdiff

Mã mẫu

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

Đầu ra

{
    "values_changed": {
        "root['a']": {
            "new_value": 2,
            "old_value": 1
        },
        "root['nested']['b']": {
            "new_value": 2,
            "old_value": 1
        }
    }
}

Lưu ý về việc in đẹp kết quả để kiểm tra: Mã trên hoạt động nếu cả hai dicts đều có cùng các khóa thuộc tính [với các giá trị thuộc tính có thể khác nhau như trong ví dụ]. Tuy nhiên, nếu có một thuộc tính

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

0 có mặt

TypeError: Object of type PrettyOrderedSet is not JSON serializable

Giải pháp: Sử dụng

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

2 và

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

3 /

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

1 để in đẹp:

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    },
    "extra": 3
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[json.loads[diff.to_json[]], indent=4]]  

Output:

{
    "dictionary_item_removed": [
        "root['extra']"
    ],
    "values_changed": {
        "root['a']": {
            "new_value": 2,
            "old_value": 1
        },
        "root['nested']['b']": {
            "new_value": 2,
            "old_value": 1
        }
    }
}

Thay thế: Sử dụng

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

5, dẫn đến một định dạng khác:

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

0

Output:

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

1

SSC

9.1249 Huy hiệu vàng57 Huy hiệu bạc91 Huy hiệu Đồng9 gold badges57 silver badges91 bronze badges

Đã trả lời ngày 18 tháng 6 năm 2018 lúc 14:54Jun 18, 2018 at 14:54

AnubisanubisAnubis

6.59514 Huy hiệu vàng54 Huy hiệu bạc86 Huy hiệu đồng14 gold badges54 silver badges86 bronze badges

0

Tôi mới dùng Python nhưng cuối cùng tôi đã làm điều gì đó tương tự như @Mouad

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

2

Toán tử XOR [

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

6] nên loại bỏ tất cả các yếu tố của dict khi chúng giống nhau trong cả hai dicts.

Đã trả lời ngày 13 tháng 6 năm 2013 lúc 19:04Jun 13, 2013 at 19:04

Philippphilippphilipp

4.0731 Huy hiệu vàng35 Huy hiệu bạc34 Huy hiệu đồng1 gold badge35 silver badges34 bronze badges

1

Chỉ dùng:

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

3

Đã trả lời ngày 29 tháng 4 năm 2015 lúc 0:51Apr 29, 2015 at 0:51

ShiyushiyuShiyu

6016 Huy hiệu bạc10 Huy hiệu đồng6 silver badges10 bronze badges

6

Câu trả lời của @Mouad là tốt đẹp nếu bạn cho rằng cả hai từ điển chỉ chứa các giá trị đơn giản. Tuy nhiên, nếu bạn có từ điển có chứa từ điển, bạn sẽ nhận được một ngoại lệ vì từ điển không thể băm.

Tắt đỉnh đầu của tôi, một cái gì đó như thế này có thể hoạt động:

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

4

Pfabri

8131 Huy hiệu vàng9 Huy hiệu bạc25 Huy hiệu đồng1 gold badge9 silver badges25 bronze badges

Đã trả lời ngày 17 tháng 9 năm 2013 lúc 22:02Oct 25, 2013 at 18:40

Daniel Myersdaniel MyersAlexander

2.2611 Huy hiệu vàng13 Huy hiệu bạc6 Huy hiệu đồng4 gold badges18 silver badges25 bronze badges

3

Từ Python Docs:

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

5

Các ví dụ sau đây đều trả về một từ điển bằng

pip install deepdiff

6:Mar 15, 2015 at 8:11

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

WoJ

Cung cấp các đối số từ khóa như trong ví dụ đầu tiên chỉ hoạt động cho các khóa là định danh python hợp lệ. Nếu không, bất kỳ khóa hợp lệ nào cũng có thể được sử dụng.46 gold badges155 silver badges303 bronze badges

6

So sánh có giá trị cho

pip install deepdiff

7 và

pip install deepdiff

8.

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

6

Đã trả lời ngày 1 tháng 12 năm 2016 lúc 22:03

EDIT:

Pedro lobitopedro lobito

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

7

89.2K30 Huy hiệu vàng239 Huy hiệu bạc257 Huy hiệu ĐồngMay 2, 2018 at 9:30

Vì dường như không ai đề cập đến

pip install deepdiff

9, tôi sẽ thêm nó ở đây để hoàn thiện. Tôi thấy rất thuận tiện cho việc nhận các đối tượng [lồng nhau] nói chung:zwep

Cài đặt11 silver badges26 bronze badges

2

Mã mẫu

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

8

Đầu raJun 25, 2020 at 11:33

1

Lưu ý về việc in đẹp kết quả để kiểm tra: Mã trên hoạt động nếu cả hai dicts đều có cùng các khóa thuộc tính [với các giá trị thuộc tính có thể khác nhau như trong ví dụ]. Tuy nhiên, nếu có một thuộc tính

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

0 có mặt

>>> x = dict[a=2, b=2,c=3, d=4]
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict[b=2,c=3, d=4]
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip[x.iteritems[], y.iteritems[]]
[[['a', 2], ['c', 3]], [['c', 3], ['b', 2]], [['b', 2], ['d', 4]]]

9

Giải pháp: Sử dụng

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

2 và

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

3 /

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

1 để in đẹp:

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

0

Thay thế: Sử dụng

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

5, dẫn đến một định dạng khác:

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

1

SSCSep 3, 2017 at 22:51

9.1249 Huy hiệu vàng57 Huy hiệu bạc91 Huy hiệu Đồng

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

2

Đã trả lời ngày 18 tháng 6 năm 2018 lúc 14:54

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

3

AnubisanubisFeb 4, 2017 at 21:12

6.59514 Huy hiệu vàng54 Huy hiệu bạc86 Huy hiệu đồngYas

Tôi mới dùng Python nhưng cuối cùng tôi đã làm điều gì đó tương tự như @Mouad1 gold badge35 silver badges23 bronze badges

Toán tử XOR [

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

6] nên loại bỏ tất cả các yếu tố của dict khi chúng giống nhau trong cả hai dicts.

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

4

Đã trả lời ngày 13 tháng 6 năm 2013 lúc 19:04Dec 12, 2019 at 7:38

PhilippphilippCloudkollektiv

4.0731 Huy hiệu vàng35 Huy hiệu bạc34 Huy hiệu đồng2 gold badges34 silver badges61 bronze badges

Chỉ dùng:

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

5

Nó so sánh Dict, Danh sách và bất kỳ loại nào khác tự thực hiện toán tử "==". Nếu bạn cần so sánh một cái gì đó khác, bạn cần thêm một nhánh mới vào "nếu cây".

Hy vọng điều đó sẽ giúp.

Đã trả lời ngày 21 tháng 1 năm 2019 lúc 18:21Jan 21, 2019 at 18:21

cho Python3:

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

6

Đã trả lời ngày 27 tháng 9 năm 2019 lúc 5:45Sep 27, 2019 at 5:45

BryantbryantBryant

1011 Huy hiệu bạc7 Huy hiệu đồng1 silver badge7 bronze badges

Trong Pyunit có một phương pháp so sánh từ điển rất đẹp. Tôi đã thử nghiệm nó bằng hai từ điển sau đây và nó thực hiện chính xác những gì bạn đang tìm kiếm.

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

7

Tôi không khuyến nghị nhập

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

9 vào mã sản xuất của bạn. Suy nghĩ của tôi là nguồn trong Pyunit có thể được công cụ lại để chạy trong sản xuất. Nó sử dụng

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff[dict_1, dict_2]
print[json.dumps[diff, indent=4]]

5 trong đó "in đẹp" từ điển. Có vẻ khá dễ dàng để điều chỉnh mã này để "sẵn sàng sản xuất".

Đã trả lời ngày 10 tháng 4 năm 2017 lúc 2:53Apr 10, 2017 at 2:53

MikeyemikeyeMikeyE

1.6021 Huy hiệu vàng18 Huy hiệu bạc34 Huy hiệu đồng1 gold badge18 silver badges34 bronze badges

1

Bị trễ trong phản hồi của tôi là tốt hơn không bao giờ!

So sánh not_equal là hiệu quả hơn so với so sánh bằng nhau. Vì hai dicts như vậy không bằng nhau nếu bất kỳ giá trị chính trong một dict không được tìm thấy trong Dict khác. Mã dưới đây xem xét rằng bạn có thể so sánh Dict mặc định và do đó sử dụng GET thay vì getItem [].getitem [].

Sử dụng một loại giá trị ngẫu nhiên như mặc định trong cuộc gọi nhận bằng khóa được truy xuất - chỉ trong trường hợp các dicts không có giá trị trong một dict và khóa đó không tồn tại trong cái khác. Ngoài ra, điều kiện GET!

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

8

Đã trả lời ngày 19 tháng 12 năm 2018 lúc 3:37Dec 19, 2018 at 3:37

Tại sao không chỉ lặp lại thông qua một từ điển và kiểm tra cái kia trong quá trình [giả sử cả hai từ điển đều có cùng một khóa]?

def dict_compare[d1, d2]:
    d1_keys = set[d1.keys[]]
    d2_keys = set[d2.keys[]]
    shared_keys = d1_keys.intersection[d2_keys]
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : [d1[o], d2[o]] for o in shared_keys if d1[o] != d2[o]}
    same = set[o for o in shared_keys if d1[o] == d2[o]]
    return added, removed, modified, same

x = dict[a=1, b=2]
y = dict[a=2, b=2]
added, removed, modified, same = dict_compare[x, y]

9

Output:

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

0

Đã trả lời ngày 13 tháng 6 năm 2020 lúc 7:00Jun 13, 2020 at 7:00

LEVBLEVBLevB

9174 Huy hiệu bạc9 Huy hiệu đồng4 silver badges9 bronze badges

Xem các đối tượng Xem từ điển: //docs.python.org/2/l Library/stdtypes.html#dict

Bằng cách này, bạn có thể trừ DictView2 khỏi DictView1 và nó sẽ trả về một tập hợp các cặp khóa/giá trị khác nhau trong DictView2:

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

1

Bạn có thể giao nhau, liên minh, khác biệt [hiển thị ở trên], sự khác biệt đối xứng các đối tượng xem từ điển này. Tốt hơn? Nhanh hơn? - Không chắc chắn, nhưng là một phần của thư viện tiêu chuẩn - điều này làm cho nó trở thành một điểm cộng lớn cho tính di động
Better? Faster? - not sure, but part of the standard library - which makes it a big plus for portability

Đã trả lời ngày 9 tháng 8 năm 2017 lúc 16:33Aug 9, 2017 at 16:33

Mã dưới đây sẽ giúp bạn so sánh danh sách Dict in Python

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

2

Đã trả lời ngày 4 tháng 12 năm 2018 lúc 12:50Dec 4, 2018 at 12:50

1

Đây là câu trả lời của tôi, sử dụng một cách đệ quy:

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

3

Hy vọng điều đó sẽ giúp!

Đã trả lời ngày 28 tháng 11 năm 2018 lúc 7:26Nov 28, 2018 at 7:26

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

4

Đã trả lời ngày 15 tháng 3 năm 2019 lúc 11:08Mar 15, 2019 at 11:08

Vidivvidivvidiv

595 huy hiệu đồng5 bronze badges

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

5

Đây là một lựa chọn khác:

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

6

Vì vậy, như bạn thấy hai ID là khác nhau. Nhưng các nhà khai thác so sánh phong phú dường như thực hiện thủ thuật:

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

7

Đã trả lời ngày 19 tháng 2 năm 2014 lúc 20:51Feb 19, 2014 at 20:51

Trong Python 3.6, nó có thể được thực hiện như:-

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

8

Biến RET sẽ đúng nếu tất cả các mục của dict_1 hiện tại trong dict_2

Đã trả lời ngày 4 tháng 7 năm 2017 lúc 9:19Jul 4, 2017 at 9:19

Bạn có thể tìm thấy điều đó bằng cách viết chức năng của riêng bạn theo cách sau.

>>> a = dict[one=1, two=2, three=3]
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict[zip[['one', 'two', 'three'], [1, 2, 3]]]
>>> d = dict[[['two', 2], ['one', 1], ['three', 3]]]
>>> e = dict[{'three': 3, 'one': 1, 'two': 2}]
>>> a == b == c == d == e
True

9

Đã trả lời ngày 2 tháng 2 lúc 4:32Feb 2 at 4:32

1

Tôi có một từ điển mặc định/mẫu mà tôi muốn cập nhật các giá trị của nó từ một từ điển đã cho thứ hai. Do đó, bản cập nhật sẽ xảy ra trên các khóa tồn tại trong từ điển mặc định và nếu giá trị liên quan tương thích với loại khóa/giá trị mặc định.

Bằng cách nào đó điều này tương tự như câu hỏi trên.

Tôi đã viết giải pháp này:

MÃ SỐ

pip install deepdiff

0

Đầu ra

Giá trị '1234' cho 'A' không phải là loại dữ liệu tương thích !!!

Key 'A' không tồn tại! Khóa từ điển/giá trị Không có Set !!!

{'A': '', 'b': {'ba': 0, 'bb': 0.0}, 'c': ['xin chào']} Cập nhật thành công !!!

{'BA': 3, 'BB': 0,0} Cập nhật thành công !!!

Giá trị 'sai' cho 'BB' không phải là loại dữ liệu tương thích !!!

Đã cập nhật từ điển mặc định: {'A': '', 'B': {'BA': 3, 'BB': 0.0}, 'C': ['Hello']}

Dharman ♦♦

28.3K21 Huy hiệu vàng75 Huy hiệu bạc127 Huy hiệu đồng21 gold badges75 silver badges127 bronze badges

Đã trả lời ngày 24 tháng 3 lúc 23:39Mar 24 at 23:39

pip install deepdiff

1

Đã trả lời ngày 2 tháng 4 năm 2016 lúc 14:14Apr 2, 2016 at 14:14

1

Làm cách nào để so sánh hai từ điển trong Python?

Bạn có thể sử dụng == trên từ điển trong Python không?

Hàm Python so sánh các mục của hai từ điển là gì?

Việc sử dụng tất cả [] bất kỳ [] cmp [] và sort [] trong từ điển là gì?