Python deepdiff 使用方法

下面是 deepdiff 的基本使用方法：

1. 安装deepdiff：

   在命令行中运行以下命令安装 deepdiff：

   pip install deepdiff
   

2. 导入deepdiff：

   在需要使用 deepdiff 的 Python 程序中，导入 deepdiff：

   from deepdiff import DeepDiff
   

3. 创建两个 Python 对象：

   创建需要比较的两个 Python 对象，例如：

   obj1 = {'name': 'John', 'age': 30, 'address': {'city': 'New York', 'state': 'NY'}}
   obj2 = {'name': 'Bob', 'age': 30, 'address': {'city': 'Los Angeles', 'state': 'CA'}}
   

4. 比较两个对象：

   使用 DeepDiff 对象中的 diff 方法，将两个 Python 对象作为参数传递，以比较它们的差异：

   diff = DeepDiff(obj1, obj2)
   print(diff)
   

   输出结果将类似于以下内容：

   {'values_changed': {'root[0]': {'new_value': 'Bob', 'old_value': 'John'},
                       'root[2]["city"]': {'new_value': 'Los Angeles', 'old_value': 'New York'}}}
   

   输出结果表示，obj1 中的 "name" 和 "address["city"]" 属性的值已经被修改。

   如果两个 Python 对象相同，则输出结果将为空字典 {}。

这就是 deepdiff 的基本使用方法。除此之外，deepdiff 还可以通过多种配置选项进行自定义，并提供了其他有用的功能和方法。

除了基本使用方法，deepdiff 还提供了更多高级的用法。

1. 比较集合：

   除了比较字典之外，deepdiff 还可以比较集合对象，例如列表、元组、集合等：

   obj1 = [1, 2, 3]
   obj2 = [1, 3, 4]
   diff = DeepDiff(obj1, obj2)
   print(diff)
   

   输出结果将类似于以下内容：

   {'set_item_removed': {'root[1]': 2},
    'set_item_added': {'root[2]': 4},
    'iterable_item_added': {'root[2]': 4},
    'iterable_item_removed': {'root[1]': 2}}
   

   输出结果表示，集合 obj1 中的 "2" 已被删除，集合 obj2 中的 "4" 已被添加。

2. 忽略某些类型：

   如果您不希望比较某些类型的对象，则可以通过设置 exclude_types 参数来忽略它们，例如：

   obj1 = {'name': 'John', 'age': 30, 'address': {'city': 'New York', 'state': 'NY'}}
   obj2 = {'name': 'Bob', 'age': 30, 'address': {'city': 'Los Angeles', 'state': 'CA'}}
   exclude_types = {"<class 'str'>"}
   diff = DeepDiff(obj1, obj2, exclude_types=exclude_types)
   print(diff)
   

   输出结果将只比较字典中的整数和字典子项：

   {'values_changed': {'root[1]': {'new_value': 30, 'old_value': 30}},
    'dictionary_item_added': {"root['address']['city']": 'Los Angeles',
                              "root['address']['state']": 'CA'},
    'dictionary_item_removed': {"root['address']['city']": 'New York',
                                "root['address']['state']": 'NY'},
    'type_changes': {"root['name']": {'new_type': "<class 'str'>", 'old_type': "<class 'str'>"}}}
   

3. 指定比较方式：

   deepdiff 默认使用深度优先算法递归比较两个 Python 对象。你也可以使用其他算法或比较方法，例如广度优先算法或基于哈希值的比较方法，通过设置相关参数进行调整。例如：

   obj1 = {'name': 'John', 'age': 30, 'address': {'city': 'New York', 'state': 'NY'}}
   obj2 = {'name': 'Bob', 'age': 30, 'address': {'city': 'Los Angeles', 'state': 'CA'}}
   diff = DeepDiff(obj1, obj2, verbose_level=2, view='tree')
   print(diff)
   

   输出结果将显示比较结果的树状结构：

   root: Dictionary(change=False, type_changes=[])
       ├─ name: ValuesDiffered(change=True, old_value='John', new_value='Bob', type_changes=[])
       ├─ age: ValuesAreSame(change=False, type_changes=[])
       └─ address: Dictionary(change=False, type_changes=[])
           ├─ city: ValuesDiffered(change=True, old_value='New York', new_value='Los Angeles', type_changes=[])
           └─ state: ValuesDiffered(change=True, old_value='NY', new_value='CA', type_changes=[])
   

   上面的输出结果显示了每个 Python 对象的节点，包括节点的名称、更改信息和类型更改信息等。

4. 自定义比较方法：

   如果您需要自定义比较方法，可以继承 deepdiff.DeepSearch 类，并重写其 visit 方法。例如：

   from deepdiff import DeepSearch
   
   class MyDeepSearch(DeepSearch):
       def visit(self, node, parents, node_type):
           if node_type == 'dict' and node.get('id') == self.target_id:
               self.found = True
               self.result = parents
           else:
               DeepSearch.visit(self, node, parents, node_type)
   
   # Test the custom method
   data = {
       'users': [
           {'id': 1, 'name': 'John'},
           {'id': 2, 'name': 'Bob'},
           {'id': 3, 'name': 'Alice'}
       ]
   }
   
   finder = MyDeepSearch(data)
   finder.target_id = 2
   finder.run()
   print(finder.found)
   print(finder.result)
   

   输出结果将返回包含目标节点的父亲节点列表：

   True
   [{'id': 2, 'name': 'Bob'}, {'users': [{'id': 1, 'name': 'John'}, {'id': 2, 'name': 'Bob'}, {'id': 3, 'name': 'Alice'}]}]
   

   这就是 deepdiff 的更高级的使用方法。您可以根据具体情况选择适合您的方法，以实现更多的比较和自定义功能。