• python中jmespath库用法详解

            JMESPath 是 JSON 查询语言，可以从 JSON 文档中提取和转换元素。在做接口自动化测试项目时，最基础的一步就是从响应中获取各种待验证的字段值，掌握 jmespath 语法，能达到事半功倍的效果。

    官方文档：

    JMESPath — JMESPath

    JMESPath Examples — JMESPath

    安装

    pip install jmespath

    jmespath.py 库提供了两个接口：

    函数说明：

    • compile：与 re 模块类似，使用 compile 函数编译表达式，并使用解析后的表达式执行重复搜索
    • search：接收表达式和数据，返回提取结果

    1、获取键值对

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "name": "张三",
    5.     "age": 26,
    6.     "gender": "男",
    7.     "grade": {
    8.         "Chinese": 96,
    9.         "Math": 99
    10.     },
    11.     "records": [
    12.         {
    13.             "Chinese": 95,
    14.             "Math": 100
    15.         },
    16.         {
    17.             "Chinese": 98,
    18.             "Math": 98
    19.         }
    20.     ]
    21. }
    22.  
    23. # 获取键值对值
    24. search_cond = '{NAME:name, AGE:age, RECORDS:records}'
    25. res = jmespath.search(search_cond, data)
    26. print(res)

    运行结果：

     2、获取对象的值

     示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "name": "张三",
    5.     "age": 26,
    6.     "gender": "男",
    7.     "grade": {
    8.         "Chinese": 96,
    9.         "Math": 99
    10.     },
    11.     "records": [
    12.         {
    13.             "Chinese": 95,
    14.             "Math": 100
    15.         },
    16.         {
    17.             "Chinese": 98,
    18.             "Math": 98
    19.         }
    20.     ]
    21. }
    22.  
    23. # 获取对象值
    24. search_name = 'name'
    25. res_name = jmespath.search(search_name, data)
    26. print(res_name)
    27.  
    28. search_records = 'records'
    29. res_records = jmespath.search(search_records, data)
    30. print(res_records)

    运行结果：

    3、子表达式取值

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "name": "张三",
    5.     "age": 26,
    6.     "gender": "男",
    7.     "grade": {
    8.         "Chinese": 96,
    9.         "Math": 99
    10.     },
    11.     "records": [
    12.         {
    13.             "Chinese": 95,
    14.             "Math": 100
    15.         },
    16.         {
    17.             "Chinese": 98,
    18.             "Math": 98
    19.         }
    20.     ]
    21. }
    22.  
    23. # 使用子表达式获取值，若值不存在返回null
    24. search_sub_value = 'grade.Chinese'
    25. res_sub_value = jmespath.search(search_sub_value, data)
    26. print(res_sub_value)
    27.  
    28.  
    29. search_sub_value1 = 'records[0].Chinese'
    30. res_sub_value1 = jmespath.search(search_sub_value1, data)
    31. print(res_sub_value1)
    32.  
    33. search_sub_value2 = 'records[2].Chinese'
    34. res_sub_value2 = jmespath.search(search_sub_value2, data)
    35. print(res_sub_value2)

    运行结果：

    4、列表取值（对象嵌套列表）

            索引表达式，从 0 开始，索引越界，则返回 null；索引可以为负数，-1 为列表中最后一个元素。

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "name": "张三",
    5.     "age": 26,
    6.     "gender": "男",
    7.     "grade": {
    8.         "Chinese": 96,
    9.         "Math": 99
    10.     },
    11.     "records": [
    12.         {
    13.             "Chinese": 95,
    14.             "Math": 100
    15.         },
    16.         {
    17.             "Chinese": 98,
    18.             "Math": 98
    19.         }
    20.     ]
    21. }
    22.  
    23. # 列表取值,索引从0开始，若是
    24. search_list1 = 'records[1].Chinese'
    25. res_list1 = jmespath.search(search_list1, data)
    26. print(res_list1)
    27.  
    28. search_list2 = 'records[2].Chinese'
    29. res_list2 = jmespath.search(search_list2, data)
    30. print(res_list2)
    31.  
    32. search_list3 = 'records[-1].Chinese'
    33. res_list3 = jmespath.search(search_list3, data)
    34. print(res_list3)

    运行结果：

    5、切片

            与 python 列表切片相同，[start：end：step]，留头掐尾

    示例代码：

    1. import jmespath
    2.  
    3. data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    4.  
    5. ret1 = jmespath.search("[0:5]", data)
    6. print(ret1)
    7.  
    8. ret2 = jmespath.search("[5:10]", data)
    9. print(ret2)
    10.  
    11. ret3 = jmespath.search("[::2]", data)
    12. print(ret3)

    运行结果：

    6、列表投影

            通配符 *，表示返回列表中的全部元素。当单组元素的结果表达式为 null，则该值从收集的 结果集 中忽略。

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "student": [
    5.         {"name": "james", "age": 32},
    6.         {"name": "harden", "age": 18},
    7.         {"name": "curry", "age": 13},
    8.         {"test": "ok"}
    9.     ]
    10. }
    11.  
    12. ret1 = jmespath.search("student[*]", data)
    13. print(ret1)
    14.  
    15. ret2 = jmespath.search("student[*].name", data)
    16. print(ret2)
    17.  
    18. # 切片投影
    19. ret3 = jmespath.search("student[:2].name", data)
    20. print(ret3)

    运行结果：

    7、对象投影

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "test": {
    5.         "funcA": {"num": 1},
    6.         "funcB": {"num": 2},
    7.         "funcC": {"miss": 3},
    8.     }
    9. }
    10.  
    11. ret1 = jmespath.search("test.*", data)
    12. print(ret1)
    13.  
    14. ret2 = jmespath.search("test.*.num", data)
    15. print(ret2)
    16.

    运行结果：

    8、展平投影

            列表/对象投影，在投影中创建投影时会保留原始文档的结构。

            如果只要列表下的所有值，不关心所谓的层级结构，那么就需要通过展平投影来获取结果。

            只需要将 [*] -> [] 就可以扁平化列表。它将子列表展平到父列表，并不是递归的关系

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.   "a": [
    5.     {
    6.       "b": [
    7.         {"name": "a"},
    8.         {"name": "b"}
    9.       ]
    10.     },
    11.     {
    12.       "b": [
    13.         {"name": "c"},
    14.         {"name": "d"}
    15.       ]
    16.     }
    17.   ]
    18. }
    19.  
    20. ret1 = jmespath.search("a[*].b[*].name", data)
    21. print(ret1)
    22.  
    23. ret2 = jmespath.search("a[*].b[].name", data)
    24. print(ret2)
    25.  
    26. ret3 = jmespath.search("a[].b[].name", data)
    27. print(ret3)
    28.  
    29. ret4 = jmespath.search("a[].b[*].name", data)
    30. print(ret4)
    31.  
    32. ret5 = jmespath.search("a[].b[]", data)
    33. print(ret5)

    运行结果：

    9、过滤投影

            过滤器表达式是为数组定义的，一般形式为：

    左侧投影 [? <表达式> <比较器> <表达式>] 右侧投影

    条件表达式支持如下：

    • ==, tests for equality.
    • !=, tests for inequality.
    • <, less than.
    • <=, less than or equal to.
    • >, greater than.
    • >=, greater than or equal to.

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.   "book": [
    5.     {"name": "a1", "author": "aa"},
    6.     {"name": "a2", "author": "aa"},
    7.     {"name": "b", "author": "bb"}
    8.   ]
    9. }
    10.  
    11. ret1 = jmespath.search("book[?author=='aa'].name", data)
    12. print(ret1)

    运行结果：

    10、管道表达式

            管道表达式 | ，表示必须停止投影。将当前节点的结果传递到管道符右侧继续投影。

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.   "book": [
    5.     {"name": "a1", "author": "aa"},
    6.     {"name": "a2", "author": "aa"},
    7.     {"name": "b", "author": "bb"}
    8.   ]
    9. }
    10.  
    11. ret1 = jmespath.search("book[*].name", data)
    12. print(ret1)
    13.  
    14. ret2 = jmespath.search("book[*].name | [1]", data)
    15. print(ret2)

    运行结果：

    11、多选列表

    [name, state.name] 表达式的意思是创建一个包含两个元素的列表：

    • 第一个元素是计算 name 表达式得到的结果
    • 第二个元素是计算 state.name 表达式的结果

            因此，每个列表元素都会创建一个双元素列表，整个表达式的最终结果是一个包含两个元素列表的列表。

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.   "people": [
    5.     {
    6.       "name": "a",
    7.       "state": {"name": "up"}
    8.     },
    9.     {
    10.       "name": "b",
    11.       "state": {"name": "down"}
    12.     },
    13.     {
    14.       "name": "c",
    15.       "state": {"name": "up"}
    16.     }
    17.   ]
    18. }
    19.  
    20. ret = jmespath.search("people[].[name, state.name]", data)
    21. print(ret)

    运行结果：

    12、多选对象

            与多选列表思想相同，创建的是一个散列而不是数组。

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.   "people": [
    5.     {
    6.       "name": "a",
    7.       "state": {"name": "up"}
    8.     },
    9.     {
    10.       "name": "b",
    11.       "state": {"name": "down"}
    12.     },
    13.     {
    14.       "name": "c",
    15.       "state": {"name": "up"}
    16.     }
    17.   ]
    18. }
    19.  
    20. ret = jmespath.search("people[].{name: name, state_name: state.name}", data)
    21. print(ret)

    运行结果：

    13、函数的使用（包含常用的一些内置函数）

    示例代码：

    1. import jmespath
    2.  
    3.  
    4. class TestJmesPath(object):
    5.  
    6.     def __init__(self):
    7.         self.data = {
    8.             "book": [
    9.                 {"name": "平凡的世界", "author": "路遥", "sort": 3},
    10.                 {"name": "围城", "author": "钱钟书", "sort": 2},
    11.                 {"name": "围城", "author": "钱钟书", "sort": 2},
    12.                 {"name": "活着", "author": "余华", "sort": 1},
    13.                 {"name": "麦田里的守望者", "author": "塞林格", "sort": 4},
    14.                 {"name": "挪威的森林", "author": "村上春树", "sort": 5}
    15.             ]
    16.         }
    17.  
    18.     def test_keys(self):
    19.         """提取对象的 key """
    20.         result = jmespath.search("book[0].name", self.data)
    21.         return result
    22.  
    23.     def test_values(self):
    24.         """提取对象的 value，不接受数组"""
    25.         result = jmespath.search("book[0] | values(@)", self.data)
    26.         return result
    27.  
    28.     def test_sort(self):
    29.         """根据 sort 进行排序"""
    30.         result = jmespath.search("book[*].sort | sort(@)", self.data)
    31.         return result
    32.  
    33.     def test_sort2(self):
    34.         result = jmespath.search("book[*].author | sort(@) | [join(', ', @)]", self.data)
    35.         return result
    36.  
    37.     def test_type(self):
    38.         result = jmespath.search("book[*].name | type(@)", self.data)
    39.         return result
    40.  
    41.     def test_type2(self):
    42.         result = jmespath.search("book[0].name | type(@)", self.data)
    43.         return result
    44.  
    45.     def test_to_string(self):
    46.         result = jmespath.search('[].to_string(@)', [1, 2, 3, "number", True])
    47.         return result
    48.  
    49.     def test_to_number(self):
    50.         result = jmespath.search('[].to_number(@)', ["1", "2", "3", "number", True])
    51.         return result
    52.  
    53.     def test_contains(self):
    54.         result = jmespath.search("contains(`foobar`, `foo`)", {})
    55.         return result
    56.  
    57.     def test_contains2(self):
    58.         result = jmespath.search("contains(`foobar`, `f123`)", {})
    59.         return result
    60.  
    61.     def test_join(self):
    62.         # expected one of: ['array-string']
    63.         # @ 为当前节点，得到的结果用逗号加空格分隔，然后放在当前节点下
    64.         result = jmespath.search("join(`, `, @)", ["a", "b"])
    65.         return result
    66.  
    67.     def test_length(self):
    68.         result = jmespath.search("length(@)", ["a", "b"])
    69.         return result
    70.  
    71.     def test_max(self):
    72.         result = jmespath.search("max(@)", [10, 3, 5, 5, 8])
    73.         return result
    74.  
    75.     def test_min(self):
    76.         result = jmespath.search("min(@)", [10, 3, 5, 5, 8])
    77.         return result
    78.  
    79.  
    80. if __name__ == '__main__':
    81.     obj = TestJmesPath()
    82.     print(obj.test_keys())
    83.     print(obj.test_values())
    84.     print(obj.test_sort())
    85.     print(obj.test_sort2())
    86.     print(obj.test_type())
    87.     print(obj.test_type2())
    88.     print(obj.test_to_string())
    89.     print(obj.test_to_number())
    90.     print(obj.test_contains())
    91.     print(obj.test_contains2())
    92.     print(obj.test_join())
    93.     print(obj.test_length())
    94.     print(obj.test_max())
    95.     print(obj.test_min())
    96.

    运行结果：

    14、自定义函数

    示例代码：

    1. from jmespath import search
    2. from jmespath import functions
    3. import jmespath
    4.  
    5.  
    6. class CustomFunctions(functions.Functions):
    7.  
    8.     @functions.signature({'types': ['string', "array"]})
    9.     def _func_uniq(self, arg):
    10.         if isinstance(arg, str):
    11.             # string of unique
    12.             return ''.join(sorted(set(arg)))
    13.         if isinstance(arg, list):
    14.             # array of unique
    15.             return sorted(set(arg))
    16.  
    17.  
    18. options = jmespath.Options(custom_functions=CustomFunctions())
    19.  
    20. aa = search("foo.bar", {'foo': {'bar': 'banana'}})
    21. print(aa)
    22.  
    23. bb = search("foo.bar | uniq(@)", {'foo': {'bar': 'banana'}}, options=options)
    24. print(bb)
    25.  
    26. cc = search("foo.bar", {'foo': {'bar': [5, 5, 2, 1]}})
    27. print(cc)
    28.  
    29. dd = search("foo.bar | uniq(@)", {'foo': {'bar': [5, 5, 2, 1]}}, options=options)
    30. print(dd)

    运行结果：

    15、包含：contains(@, 'foo')，@关联到当前级别的元素值

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "name": ['张三', '李四', '张三丰', '王五']
    5. }
    6.  
    7. ret = jmespath.search("name[?contains(@, '张')]", data)
    8. print(ret)

    运行结果：

    16、排序：sort_by(contents, &Date）

    示例代码：

    1. import jmespath
    2.  
    3. data = {
    4.     "people": [{"name": "张三", 'age': 25}, {"name": "李四", 'age': 26}, {"name": "王五", 'age': 23}]
    5. }
    6.  
    7. ret = jmespath.search("sort_by(people, &age)", data)
    8. print(ret)

    运行结果：

    参考博文：

    JMESPath 基本操作_abee-tester的博客-CSDN博客_jmespath

  • 相关阅读:
    日化用品行业集团采购管理系统改变传统采购模式，降低采购成本
    TypeScript
    Taurus.MVC WebAPI 入门开发教程1：框架下载环境配置与运行（含系列目录）。
    (vue)el-select根据下拉框显示隐藏的visible-change的事件使用
    【计算机网络】网络模型
    简单介绍一下tensorflow与pytorch的相互转换（主要是tensorflow转pytorch）
    《模式识别》教学上机实验报告
    【864. 获取所有钥匙的最短路径】
    用JAVA编写商城的好处
    Git 详细教程之五：SSH 免密登陆 GitHub
  • 原文地址：https://blog.csdn.net/weixin_44799217/article/details/127590589