比较Python中的字典

2025 年 1 月 5 日 | 12 分钟阅读

在 Python 中，你可以通过多种方式比较字典。以下是一些常用方法：

1. 相等性检查

你可以使用 `==` 运算符来检查两个字典是否相等。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    if dict1 == dict2:
        print("Dictionaries are equal")
    else:
        print("Dictionaries are not equal")

示例输入

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'a': 1, 'b': 2, 'c': 3}

示例输出

Dictionaries are equal

说明

这会检查两个字典是否具有相同的键值对。

2. 身份检查

你可以使用 `is` 运算符来检查两个字典是否是内存中的同一个对象。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    if dict1 is dict2:
        print("Dictionaries are the same object")
    else:
        print("Dictionaries are not the same object")

示例输入

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'a': 1, 'b': 2, 'c': 3}

示例输出

Dictionaries are not the same object

说明

这会检查两个字典是否引用了相同的内存地址。

3. 键比较

你可以检查两个字典是否具有相同的键。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    if set(dict1.keys()) == set(dict2.keys()):
        print("Dictionaries have the same keys")
    else:
        print("Dictionaries have different keys")

示例输入

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'a': 1, 'b': 2, 'c': 3}

示例输出

Dictionaries have the same keys

说明

这只检查键是否相同，而忽略值。

4. 值比较

你可以检查两个字典是否具有相同的值。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    if set(dict1.values()) == set(dict2.values()):
        print("Dictionaries have the same values")
    else:
        print("Dictionaries have different values")

示例输入

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'a': 1, 'b': 2, 'c': 3}

示例输出

Dictionaries have the same values

说明

这只检查值是否相同，而忽略键。

5. 不相等性检查

你可以使用 `!=` 运算符来检查两个字典是否不相等。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    if dict1 != dict2:
        print("Dictionaries are not equal")
    else:
        print("Dictionaries are equal")

输出

Dictionaries are equal

6. 子集检查

你可以使用 `issubset` 方法检查一个字典是否是另一个字典的子集。

Python

    dict1 = {'a': 1, 'b': 2}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    if set(dict1.items()).issubset(dict2.items()):
        print("dict1 is a subset of dict2")
    else:
        print("dict1 is not a subset of dict2")

输出

dict1 is a subset of dict2

7. 超集检查

你可以使用 `issuperset` 方法检查一个字典是否是另一个字典的超集。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2}

    if set(dict1.items()).issuperset(dict2.items()):
        print("dict1 is a superset of dict2")
    else:
        print("dict1 is not a superset of dict2")

输出

dict1 is a superset of dict2

8. 键存在性检查

你可以检查一个特定键是否存在于字典中。

Python

    key_to_check = 'b'
    my_dict = {'a': 1, 'b': 2, 'c': 3}

    if key_to_check in my_dict:
        print(f"The key '{key_to_check}' exists in the dictionary")
    else:
        print(f"The key '{key_to_check}' does not exist in the dictionary")

输出

The key 'b' exists in the dictionary

9. 深度比较

如果你的字典包含嵌套结构，如其他字典或列表，你可能需要执行深度比较。`deepdiff` 库是一个选项。

    bash
    pip install deepdiff

Python

    from deepdiff import DeepDiff

    dict1 = {'a': 1, 'b': {'c': 2, 'd': [3, 4]}}
    dict2 = {'a': 1, 'b': {'c': 2, 'd': [3, 4]}}

    diff = DeepDiff(dict1, dict2)
    if not diff:
        print("Dictionaries are the same")
    else:
        print("Dictionaries are different:", diff)

输出

Dictionaries are the same

`DeepDiff` 类提供了关于两个字典之间差异的详细报告，包括嵌套结构。

10. 忽略项目顺序

如果字典代表项目集合，并且项目顺序无关紧要，你可以将字典转换为集合进行比较。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'c': 3, 'a': 1, 'b': 2}

    if set(dict1.items()) == set(dict2.items()):
        print("Dictionaries are equal, ignoring the order of items")
    else:
        print("Dictionaries are not equal")

输出

Dictionaries are equal, ignoring the order of items

当字典在概念上相同但键顺序不同时，这种方法很有用。

11. 使用 `DictComparator`

来自 `dictdiffer` 模块的 `DictComparator` 类允许你找出两个字典之间的差异。

Python

    from dictdiffer import diff, patch, swap, revert, DotNotationDotter

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 4}

    differences = list(diff(dict1, dict2))
    if not differences:
        print("Dictionaries are the same")
    else:
        print("Dictionaries are different:", differences)

输出

Dictionaries are different: [('change', 'c', (3, 4))]

这个库提供了字典之间差异的更详细报告。

12. 使用 `all` 和生成器表达式

你可以使用生成器表达式和 `all` 函数来检查一个字典中的所有键值对是否存在于另一个字典中。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    are_equal = all(dict1[key] == dict2[key] for key in dict1)
    
    if are_equal:
        print("Dictionaries are equal")
    else:
        print("Dictionaries are not equal")

输出

Dictionaries are equal

这种方法检查 `dict1` 中的所有键值对是否等于 `dict2` 中的相应键值对。

13. 使用 `collections.Counter`

如果你有兴趣比较字典中元素的频率（键值对），你可以使用 `collections.Counter`。

Python

 
    from collections import Counter

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    counter1 = Counter(dict1)
    counter2 = Counter(dict2)

    if counter1 == counter2:
        print("Dictionaries have the same elements")
    else:
        print("Dictionaries have different elements")

输出

Dictionaries have the same elements

这种方法考虑了字典中每个元素的频率。

14. 使用 `json.dumps`

如果字典包含简单数据类型并且是 JSON 可序列化的，你可以将它们转换为 JSON 字符串并进行比较。

Python

   import json

   dict1 = {'a': 1, 'b': 2, 'c': 3}
   dict2 = {'a': 1, 'b': 2, 'c': 3}

   if json.dumps(dict1, sort_keys=True) == json.dumps(dict2, sort_keys=True):
       print("Dictionaries are equal")
   else:
       print("Dictionaries are not equal")

输出

Dictionaries are equal

对于包含基本数据类型的字典，此方法简单有效。

15. 使用 `pandas` 库

如果你的字典代表表格数据，你可以使用 `pandas` 库将它们转换为数据框（dataframe）然后进行比较。

Python

   import pandas as pd

   dict1 = {'a': [1, 2, 3], 'b': [4, 5, 6]}
   dict2 = {'a': [1, 2, 3], 'b': [4, 5, 6]}

   df1 = pd.DataFrame(dict1)
   df2 = pd.DataFrame(dict2)

   if df1.equals(df2):
       print("Dataframes are equal")
   else:
       print("Dataframes are not equal")

输出

Dataframes are equal

这种方法尤其适用于结构化数据，并且可以处理更复杂的比较。

16. 使用 `difflib` 进行逐行比较

如果你想要逐行比较，类似于 `difflib` 对字符串的工作方式，你可以使用 `difflib` 模块中的 `Differ`。

Python

   from difflib import Differ

   dict1 = {'a': 1, 'b': 2, 'c': 3}
   dict2 = {'a': 1, 'b': 2, 'd': 4}

   differ = Differ()
   diff = list(differ.compare(str(dict1), str(dict2)))

   if not any(line.startswith('-') or line.startswith('+') for line in diff):
       print("Dictionaries are equal")
   else:
       print("Dictionaries are not equal")

输出

Dictionaries are not equal

这种方法在以逐行格式可视化字典之间的差异时很有用。

17. 使用集合的 `对称差集`

两个集合的对称差集包含存在于其中一个集合但不在另一个集合中的元素。你可以利用此属性进行字典比较。

Python

   dict1 = {'a': 1, 'b': 2, 'c': 3}
   dict2 = {'a': 1, 'b': 2, 'd': 4}

   symmetric_diff = set(dict1.items()) ^ set(dict2.items())

   if not symmetric_diff:
       print("Dictionaries are equal")
   else:
       print("Dictionaries are not equal")

输出

Dictionaries are not equal

`^` 运算符是集合的对称差集运算符。

18. 使用 `hash` 函数

如果字典相对简单且仅包含可哈希对象，你可以使用 `hash` 函数创建字典的哈希值，然后比较哈希值。

Python

   dict1 = {'a': 1, 'b': 2, 'c': 3}
   dict2 = {'a': 1, 'b': 2, 'c': 3}

   hash1 = hash(frozenset(dict1.items()))
   hash2 = hash(frozenset(dict2.items()))

   if hash1 == hash2:
       print("Dictionaries are equal")
   else:
       print("Dictionaries are not equal")

输出

Dictionaries are equal

这种方法很简单，但存在局限性，例如对键顺序敏感。

19. 使用 `operator` 模块进行项比较

你可以使用 `operator` 模块中的 `itemgetter` 函数根据特定键比较字典。

Python

   from operator import itemgetter

   dict1 = {'a': 1, 'b': 2, 'c': 3}
   dict2 = {'a': 1, 'b': 2, 'c': 3}

   keys_to_compare = ['a', 'b']

   items1 = itemgetter(*keys_to_compare)(dict1)
   items2 = itemgetter(*keys_to_compare)(dict2)

   if items1 == items2:
       print("Selected items are equal in both dictionaries")
   else:
       print("Selected items are not equal in both dictionaries")

输出

Selected items are equal in both dictionaries

这允许你根据键的子集来比较字典。

20. 使用 `symmetric_difference` 方法

集合的 `symmetric_difference` 方法返回一个新集合，其中包含存在于其中一个集合但不在两个集合中的元素。你可以将此方法应用于两个字典的项。

Python

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'd': 4}

    symmetric_diff = set(dict1.items()).symmetric_difference(set(dict2.items()))

    if not symmetric_diff:
        print("Dictionaries are equal")
    else:
        print("Dictionaries are not equal")

输出

Dictionaries are not equal

此方法提供了一种简洁的方式来识别两个字典之间的对称差集。

21. 使用 `numpy` 进行值比较

如果你的字典包含数值，并且你想要在一定容差范围内进行比较，你可以使用 `numpy` 库。

Python

    import numpy as np

    dict1 = {'a': 1.0, 'b': 2.0, 'c': 3.0}
    dict2 = {'a': 1.0, 'b': 2.0, 'c': 3.000001}

    # Specify a tolerance for numerical comparison
    tolerance = 1e-6

    are_close = np.allclose(list(dict1.values()), list(dict2.values()), atol=tolerance)

    if are_close:
        print("Dictionaries are numerically close")
    else:
        print("Dictionaries are not numerically close")

输出

Dictionaries are numerically close

当处理浮点数值并且你希望允许一定程度的容差进行比较时，此方法很有用。

22. 使用 `hashlib` 进行哈希比较

如果字典是可哈希的，你可以使用 `hashlib` 库创建哈希值并进行比较。

Python

    import hashlib

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 3}

    hash1 = hashlib.md5(str(dict1).encode()).hexdigest()
    hash2 = hashlib.md5(str(dict2).encode()).hexdigest()

    if hash1 == hash2:
        print("Dictionaries are equal")
    else:
        print("Dictionaries are not equal")

输出

Dictionaries are equal

此方法类似于使用 `hash` 函数，但提供了更可靠的哈希值。

23. 使用 `deepdiff` 进行结构比较

`deepdiff` 库允许你对嵌套字典进行结构比较。它可以识别添加、删除或修改的项。

   bash
    pip install deepdiff

Python

    from deepdiff import DeepDiff

    dict1 = {'a': 1, 'b': {'c': 2, 'd': [3, 4]}}
    dict2 = {'a': 1, 'b': {'c': 2, 'd': [3, 5]}}

    diff = DeepDiff(dict1, dict2, ignore_order=True)
    if not diff:
        print("Dictionaries are structurally equal")
    else:
        print("Dictionaries are structurally different:", diff)

输出

Dictionaries are structurally different: {'values_changed': {"root['b']['d'][1]": {'new_value': 5, 'old_value': 4}}}

当处理嵌套结构和复杂数据时，这种方法特别有用。

24. 使用 `dictdiffer` 进行迭代比较

`dictdiffer` 库允许对字典进行迭代比较，提供一系列操作（添加、删除、更改）将一个字典转换为另一个字典。

    bash
    pip install dictdiffer

Python

    from dictdiffer import diff, patch, swap, revert, DotNotationDotter

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 4}

    differences = list(diff(dict1, dict2))
    if not differences:
        print("Dictionaries are the same")
    else:
        print("Dictionaries are different. Operations to transform dict1 into dict2:", differences)

输出

Dictionaries are different. Operations to transform dict1 into dict2: [('change', 'c', (3, 4))]

这个库提供了对字典之间差异的细粒度视图。

25. 使用 `json` 进行深度比较

如果你的字典包含嵌套结构，并且你想要进行深度比较，你可以使用 `json` 模块将字典转换为 JSON 字符串然后进行比较。

Python

    import json

    dict1 = {'a': 1, 'b': {'c': 2, 'd': [3, 4]}}
    dict2 = {'a': 1, 'b': {'c': 2, 'd': [3, 4]}}

    json_str1 = json.dumps(dict1, sort_keys=True)
    json_str2 = json.dumps(dict2, sort_keys=True)

    if json_str1 == json_str2:
        print("Dictionaries are equal")
    else:
        print("Dictionaries are not equal")

输出

Dictionaries are equal

此方法对于深度比较很有效，并且 `sort_keys=True` 确保键的顺序不会影响比较。

26. 使用 `dataclasses` 进行结构比较

如果你使用的是 Python 3.7 或更高版本，你可以使用 `dataclasses` 模块创建数据类，然后比较这些类的实例以进行结构化相等性检查。

Python

   from dataclasses import dataclass

   @dataclass
   class MyData:
       a: int
       b: str

   dict1 = {'a': 1, 'b': 'hello'}
   dict2 = {'a': 1, 'b': 'hello'}

   obj1 = MyData(**dict1)
   obj2 = MyData(**dict2)

   if obj1 == obj2:
       print("Data objects are equal")
   else:
       print("Data objects are not equal")

输出

Data objects are equal

当你想创建更结构化的数据表示并使用标准的 Python 相等性进行比较时，这种方法特别有用。

27. 使用 `schema` 进行基于模式的比较

`schema` 库允许你为数据定义模式，然后根据这些模式验证字典。这对于确保字典符合特定结构很有用。

    bash
    pip install schema

Python

    import schema

    # Define a schema for the dictionary
    dict_schema = schema.Schema({'a': int, 'b': int, 'c': int})

    dict1 = {'a': 1, 'b': 2, 'c': 3}
    dict2 = {'a': 1, 'b': 2, 'c': 4}

    try:
        dict_schema.validate(dict1)
        dict_schema.validate(dict2)
        print("Dictionaries are valid according to the schema")
    except schema.SchemaError as e:
        print(f"Dictionaries are not valid: {e}")

输出

Dictionaries are valid according to the schema

当你想强制执行字典的特定结构并确保它们满足某些标准时，这种方法很有益。

28. 使用 `python-Levenshtein` 进行字符串相似度比较

如果你的字典包含字符串值，并且你想根据相似度进行比较，你可以使用 `python-Levenshtein` 库，它提供了计算字符串相似度的函数。

    bash
    pip install python-Levenshtein

Python

    import Levenshtein

    dict1 = {'name': 'John Doe', 'city': 'New York'}
    dict2 = {'name': 'John Doe', 'city': 'Newark'}

    similarity_threshold = 0.8

    # Calculate similarity for each pair of values
    similarities = [Levenshtein.ratio(dict1[key], dict2[key]) for key in dict1]

    if all(similarity >= similarity_threshold for similarity in similarities):
        print("Dictionaries are similar")
    else:
        print("Dictionaries are not similar")

输出

Dictionaries are not similar

当你想以特定的相似度阈值比较字符串值时，这种方法很有用。

`python-Levenshtein` 库提供了计算两个字符串之间 Levenshtein 距离的函数。Levenshtein 距离是通过计算将一个字符串转换为另一个字符串所需的最小单字符编辑次数（插入、删除或替换）来衡量的两个字符串之间的相似度。

以下是所提供示例的详细说明：

1. 安装

在使用 `python-Levenshtein` 之前，你需要使用 pip 进行安装。

    bash
    pip install python-Levenshtein

2. 示例用法

现在，让我们考虑两个字典 `dict1` 和 `dict2`，其中每个字典代表一个人，包含姓名和城市。

Python

    import Levenshtein

    dict1 = {'name': 'John Doe', 'city': 'New York'}
    dict2 = {'name': 'John Doe', 'city': 'Newark'}

    similarity_threshold = 0.8

    # Calculate similarity for each pair of values
    similarities = [Levenshtein.ratio(dict1[key], dict2[key]) for key in dict1]

    if all(similarity >= similarity_threshold for similarity in similarities):
        print("Dictionaries are similar")
    else:
        print("Dictionaries are not similar")

输出

Dictionaries are not similar

3. 说明

Levenshtein 比例是一个介于 0 和 1 之间的值，其中 0 表示无相似度，1 表示字符串相同。
代码计算 `dict1` 和 `dict2` 中每对值的 Levenshtein 比例。
`similarity_threshold` 是一个用户定义的阈值，用于确定何时将字典视为相似。
`all` 函数检查所有计算出的相似度是否大于或等于阈值。
如果满足条件，则打印“字典相似”，否则打印“字典不相似”。

4. 用例

当你想以特定的相似度要求比较字符串值时，这种方法很有用。例如，它可用于数据清理场景，你想识别具有相似但不完全相同的字符串值的记录，允许存在变体或拼写错误。

请记住，根据你的具体用例和可接受的相似度级别调整 `similarity_threshold`。

选择最适合你用例的方法，并考虑你字典中的数据类型以及具体的比较标准。

下一主题如何在 Python 中从另一个文件导入类

比较Python中的字典

1. 相等性检查

2. 身份检查

3. 键比较

4. 值比较

5. 不相等性检查

6. 子集检查

7. 超集检查

8. 键存在性检查

9. 深度比较

10. 忽略项目顺序

11. 使用 `DictComparator`

12. 使用 `all` 和生成器表达式

13. 使用 `collections.Counter`

14. 使用 `json.dumps`

15. 使用 `pandas` 库

16. 使用 `difflib` 进行逐行比较

17. 使用集合的 `对称差集`

18. 使用 `hash` 函数

19. 使用 `operator` 模块进行项比较

20. 使用 `symmetric_difference` 方法

21. 使用 `numpy` 进行值比较

22. 使用 `hashlib` 进行哈希比较

23. 使用 `deepdiff` 进行结构比较

24. 使用 `dictdiffer` 进行迭代比较

25. 使用 `json` 进行深度比较

26. 使用 `dataclasses` 进行结构比较

27. 使用 `schema` 进行基于模式的比较

28. 使用 `python-Levenshtein` 进行字符串相似度比较

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

其他

比较Python中的字典

1. 相等性检查

2. 身份检查

3. 键比较

4. 值比较

5. 不相等性检查

6. 子集检查

7. 超集检查

8. 键存在性检查

9. 深度比较

10. 忽略项目顺序

11. 使用 `DictComparator`

12. 使用 `all` 和生成器表达式

13. 使用 `collections.Counter`

14. 使用 `json.dumps`

15. 使用 `pandas` 库

16. 使用 `difflib` 进行逐行比较

17. 使用集合的 `对称差集`

18. 使用 `hash` 函数

19. 使用 `operator` 模块进行项比较

20. 使用 `symmetric_difference` 方法

21. 使用 `numpy` 进行值比较

22. 使用 `hashlib` 进行哈希比较

23. 使用 `deepdiff` 进行结构比较

24. 使用 `dictdiffer` 进行迭代比较

25. 使用 `json` 进行深度比较

26. 使用 `dataclasses` 进行结构比较

27. 使用 `schema` 进行基于模式的比较

28. 使用 `python-Levenshtein` 进行字符串相似度比较

相关帖子

Python中排序Counter的不同方法

列出Python目录中的所有文件

使用OpenCV Python实现背景减除

如何在Python中换行长行

Python中的DoS和DDoS攻击

Python中的候选消除算法

Python中的逻辑运算符及示例

使用Python自动化OSINT

Python中的Kaprekar常数

Python中的AI算法

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器