开发者

Python对比校验神器deepdiff库使用详解

目录
  • 前言
  • dehttp://www.devze.comepdiff库
    • 安装
    • 说明
  • DeepDiff
    • 对比json
    • 列表校验
    • 忽略字符串类型
    • 忽略大小写
  • DeepSearch
    • DeepHash
      • extract
        • grep

          工作中我们经常要两段代码的区别,或者需要查看接口返回的字段与预期是否一致,如何快速定位出两者的差异?除了一些对比的工具比如Beyond CompareWinMerge等,或者命令工具diff(在linux环境下使用),其实python中也提供了很多实现对比的库,比如deepdiff和difflib,这两个的区别是deepdiff显示的对比效果比较简洁,但是可以设置忽略的字段,difflib显示的对比结果可以是html的,比较详细。今天我们就学习一下快速实现代码和文件对比的库–deepdiff

          前言

          在接口自动化中会遇到想要得出两次响应体(json值)差异,本篇来学习的deepdiff库可以解决这问题

          deepdiff库

          安装

          pip install deepdiff

          说明

          deepdiff模块常用来校验两个对象是否一致,并找出其中差异之处,它提供了:

          deepdiff模块常用来校验两个对象是否一致,并找出其中差异之处,它提供了:

          • DeepDiff:比较两个对象,对象可以是字段、字符串等可迭代的对象
          • DeepSearch:在对象中搜索其他对象
          • DeepHash:根据对象的内容进行哈希处理

          DeepDiff

          • 作用:比较两个对象,对象可以是字段、字符串等可迭代的对象

          说明:

          • type_changes:类型改变的key
          • values_changed:值发生变化的key
          • dictionary_item_added:字典key添加
          • dictionary_item_removed:字段key删除

          对比json

          # -*-coding:utf-8一*-
          # @Time:2023/4/16
          # @Author: DH
          
          from deepdiff import DeepDiff
          
          # json校验
          json_one = {
              'code': 0,
              "message": "失败",
              'data': {
                  'id': 1
              }
          }
          json_two = {
              'code': 1,
              "message": "成功",
              'data': {
                  'id': 1
              }
          }
          print(DeepDiff(json_one, json_two))
          
          # 输出
          """
          {'values_changed': {"root['code']": {'new_value': 1, 'old_value': 0}, "root['message']": {'new_value': '成功', 'old_value': '失败'}}}
          
          root['code'] : 改变值的路径
          new_value : 新值
          old_value :原值
          """
          

          列表校验

          cutoff_distance_for_pairs: (1 >= float > 0,默认值=0.3);通常结合ignore_order=true使用,用于结果中展示差异的深度。值越高,则结果中展示的差异深度越高。

          from deepdiff import DeepDiff
          
          t1 = [[[1.0, 666], 888]]
          t2 = [[[20.0, 666], 999]]
          print(DeepDiff(t1, t2, ignore_order=True, cutoff_distance_for_pairs=0.5))
          print(DeepDiff(t1, t2, ignore_order=True)) # 默认为0.3
          print(DeepDiff(t1, t2, ignore_order=True, cutoff_distance_for_pairs=0.2))
          """
          {'values_changed': {'root[0][0]': {'new_value': [20.0, 666], 'old_value': [1.0, 666]}, 'root[0][1]': {'new_value': 开发者_JAVA999, 'old_value': 888}}}
          
          {'values_changed': {'root[0]': {'new_value': [[20.0, 666], 999], 'old_value': [[1.0, 666], 888]}}}
          
          {'values_changed': {'root[0]': {'new_value': [[20.0, 666], js999], 'old_value': [[1.0, 666], 888]}}}
          """

          忽略字符串类型

          ignore_string_type_changes :忽略校验字符串类型,默认为False

          print(DeepDiff(b'hello', 'hello', ignore_string_type_changes=True))
          print(DeepDiff(b'hello', 'hello'))
          
          """
          输出:
          {}
          {'type_changes': {'root': {'old_type': <class 'bytes'>, 'new_type': <class 'str'>, 'old_value': b'hello', 'new_value': 'hello'}}}
          """

          忽略大小写

          ignore_string_case:忽略大小写,默认为False

          from deepdiff import DeepDiff
          
          print(DeepDiff(t1='Hello', t2='heLLO'))
          print(DeepDiff(t1='Hello', t2='heLLO', ignore_string_case=True))
          
          """
          输出:
          {'values_changed': {'root': {'new_value': 'heLLO', 'old_value': 'Hello'}}}
          {}
          """

          DeepSearch

          编程客栈

          作用:在对象中搜索其他对象 查找字典key/value

          from deepdiff import DeepSearch
          
          json_three = {
              'code': 1,
              "message": "成功",
              'data': {
                  'id': 1
              }
          }
          
          # 查找key
          print(DeepSearch(json_three, "code"))
          print(DeepSearch(json_three, "name"))
          # 查找value
          print(DeepSearch(json_three, 1))
          
          """
          输出:
          {'matched_paths': ["root['code']"]}
          {}
          {'matched_values': ["root['code']", "root['data']['id']"]}
          """
          
          # 正则 use_regexp
          obj = ["long somewhere", "string", 0, "somewhere great!"]
          # 使用正则表达式
          item = "some*"
          ds = DeepSearch(obj, item, use_regexp=True)
          print(ds)
          
          # 强校验 strict_checking 默认True
          item = '0'
          ds = DeepSearch(obj, item, strict_checking=False)
          # ds = DeepSearch(obj, item)  # 默认True
          print(ds)
          
          # 大小写敏感  case_sensitive  默认 False 敏感
          item = 'someWhere'
          ds = DeepSearch(obj, item, case_sensitive=True)
          print(ds)
          
          

          DeepHash

          作用:根据对象的内容进行哈希处理

          from deepdiff import DeepHash
          
          # 对对象进行hash
          json_four = {
              'code': 1,
              "message": "成功",
              'data': {
                  'id': 1
              }
          }
          
          print(DeepHash(json_four))

          extract

          extract : 根据路径查询值

          from deepdiff import extr编程客栈act
          
          # 根据路径查询值
          obj = {1: [{'2': 666}, 3], 2: [4, 5]}
          path = "root[1][0]['2']"
          value = extract(obj, path)
          print(value)
          
          """
          输出:
          666
          """

          grep

          搜索

          from deepdiff import grep
          
          obj = ["long somewhere", "string", 0, "somewhereandroid great!"]
          item = "somewhere"
          ds = obj | grep(item)
          print(ds)
          
          # use_regexp 为True 表示支持正则
          obj = ["something here", {"long": "somewhere", "someone": 2, 0: 0, "somewhere": "around"}]
          ds = obj | grep("some.*", use_regexp=True)
          print(ds)
          
          # 根据值查询路径
          obj = {1: [{'2': 'b'}, 3], 2: [4, 5, 5]}
          result = obj | grep(5)
          print(result)
          
          """
          输出:
          {'matched_values': ['root[2][1]', 'root[2][2]']}
          """

          到此这篇关于Python-对比校验神器-deepdiff库的文章就介绍到这了,更多相关Python对比库deepdiff内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

          0

          上一篇:

          下一篇:

          精彩评论

          暂无评论...
          验证码 换一张
          取 消

          最新开发

          开发排行榜