前言
API 测试时，Request Body 和 Response Body 格式可能是JSON 格式，所以对 JSON 的处理显得非常重要。 关于 JSON 的概念请参考这篇《REST Assured 22 - JSON》
Python 对 JSON 的操作非常方便，主要有下面 4 个方法。
| 方法 | 功能 |
|---|---|
| json.dumps() | 将 Python 对象编码成 JSON 字符串 |
| json.loads() | 将已编码的 JSON 字符串解码为 Python 对象 |
| json.dump() | 将Python内置类型序列化为json对象后写入文件 |
| json.load() | 读取文件中json形式的字符串元素转化为Python类型 |
内容提要：
- json.dumps() 实践
- json.loads() 实践
- json.dump() 实践
- json.loads() 实践
- 如何动态设置 JSON request body
Python 对象编码成 JSON 字符串 json.dumps()
1. 字典 dict 转化成 JSON
import json
d = {
"key1" : "value1", "key2" : "value2"}
json_string = json.dumps(d)
print("dic: {}".format(d))
print("json string: {}".format(json_string))
输出：
dict 中 key/value都是单引号的，json 中的 key/value 是双引号的。
dic: {
'key1': 'value1', 'key2': 'value2'}
json string: {
"key1": "value1", "key2": "value2"}
2. 格式化输出 JSON
控制缩进，key value 之间的连接符
import json
d = {
"key1" : "value1", "key2" : "value2"}
json_string_pretty_1 = json.dumps(d, indent=2, separators=(',', ':'))
json_string_pretty_2 = json.dumps(d, indent=4, separators=(',', '='))
print("json string pretty 1 :\n {}".format(json_string_pretty_1))
print("json string pretty 2 :\n {}".format(json_string_pretty_2))
输出：两种不同的格式
json string pretty 1 :
{
"key1":"value1",
"key2":"value2"
}
json string pretty 2 :
{
"key1"="value1",
"key2"="value2"
}
3. 按 Key 排序输出 JSON 字符串
sort_keys=True 按 key 排序
import json
d_dis_order = {
"name" : "peter", "age": 18, "gender" : "men"}
json_in_order = json.dumps(d_no_order, indent=4, sort_keys=True)
print("dic disorder:\n {}".format(d_dis_order))
print("json string inorder:\n {}".format(json_in_order))
输出：
dic disorder:
{
'name': 'peter', 'age': 18, 'gender': 'man'}
json string inorder:
{
"age": 18,
"gender": "man",
"name": "peter"
}
4. 将类对象转化成 JSON 字符串
自定义对象转化成 JSON 字符串，需要自定义一个 JSONEncoder 子类来覆盖默认的 系列化赋值给 cls 参数。
To use a custom
JSONEncodersubclass (e.g. one that overrides the.default()method to serialize additional types), specify it with theclskwarg; otherwiseJSONEncoderis used.
import json
from json import JSONEncoder
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class PersonEncoder(JSONEncoder):
def default(self, o):
return o.__dict__
peter = Person("Peter", 18, "Men")
json_peter = json.dumps(peter, indent=4, cls=PersonEncoder)
print("peter object:\n{}".format(peter))
print("json peter:\n{}".format(json_peter))
输出：
peter object:
<__main__.Person object at 0x000001FE156C9648>
json peter:
{
"name": "Peter",
"age": 18,
"gender": "Men"
}
JSON 字符串解码为 Python 对象 json.loads()
1. 访问 JSON 中的值
通过 json.loads() 方法将 JSON 字符串转化成 python 的 dict 对象就可以访问其键值了
import json
json_string = '''{"name":"peter", "age":18, "gender":"Men"}'''
data = json.loads(json_string)
print("json string:\n{}".format(json_string))
print("data:\n{}".format(data))
print("age: {}".format(data["age"]))
输出：
json string:
{
"name":"peter", "age":18, "gender":"Men"}
data:
{
'name': 'peter', 'age': 18, 'gender': 'Men'}
age: 18
2. 访问 JSON 嵌套对象
获取 JSON 字符串中 salary 的值
import json
json_string = '''
{
"company": {
"person": {
"name": "peter",
"age": 18,
"gender": "Men",
"pay": {
"salary": 3000,
"bonus": 5000
}
}
}
}
'''
data = json.loads(json_string)
print("json string:\n{}".format(json_string))
print("data:\n{}".format(data))
print("salary: {}".format(data["company"]["person"]["pay"]["salary"]))
输出：
通过 data[“company”][“person”][“pay”][“salary”] 访问到嵌套的值
json string:
{
"company": {
"person": {
"name": "peter",
"age": 18,
"gender": "Men",
"pay": {
"salary": 3000,
"bonus": 5000
}
}
}
}
data:
{
'company': {
'person': {
'name': 'peter', 'age': 18, 'gender': 'Men', 'pay': {
'salary': 3000, 'bonus': 5000}}}}
salary: 3000
3. 将 JSON 字符串转化成类对象
object_hook 用于将 JSON 字符串解码成自定义的类对象， 默认object_hook= None 是解码成 dict. 所以要自定义一个解码方法。
object_hookis an optional function that will be called with the result of any object literal decode (adict). The return value ofobject_hookwill be used instead of thedict. This feature can be used to implement custom decoders (e.g. JSON-RPC class hinting).
import json
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def PersonDecoder(obj):
return Person(obj['name'], obj['age'], obj['gender'])
person_json_string = '''{"name" : "peter", "age": 18, "gender" : "men"}'''
person_object = json.loads(person_json_string, object_hook=PersonDecoder)
print("person json string:\n{}".format(person_json_string))
print("peson object:\n{}".format(person_object))
print("name:{}\nage:{}\ngender:{}".format(person_object.name, person_object.age, person_object.gender))
输出：
person json string:
{
"name" : "peter", "age": 18, "gender" : "men"}
peson object:
<__main__.Person object at 0x000001FFBCF4AA88>
name:peter
age:18
gender:men
4. 判断 JSON 格式是否正确
下面这个 JSON String 少了一个 ’ } '
json_string = '''
{
"company": {
"person": {
"name": "peter",
"age": 18,
"gender": "Men",
"pay": {
"salary": 3000,
"bonus": 5000
}
}
}
'''
def is_valid_JSON(json_data):
try:
json.loads(json_data)
except ValueError as err:
return False
return True
is_valid = is_valid_JSON(json_string)
print("json string is valid: {}".format(is_valid))
输出：
json string is valid: False
5. 获取 JSON 字符串中某个 key 所有的值
获取下面 JSON 字符串中所有 name 的 value
import json
json_string = '''
[
{
"id":1,
"name":"peter",
"hobby":[
"reading",
"movie"
]
},
{
"id":2,
"name":"lina",
"hobby":[
"sleep",
"shopping"
]
}
]
'''
json_data = json.loads(json_string)
name_list = [item.get("name") for item in json_data]
print(name_list)
输出：
['peter', 'lina']
将Python内置类型序列化为json对象后写入文件 json.dump()
1. 字典 dict 转化成 JSON 写入文件
import json
d = {
"name" : "peter", "age": 18, "gender" : "men"}
with open("json.txt", 'w+') as f:
json.dump(d, f, indent=4)
json.txt 内容
2. 自定义类对象转化成 JSON 写入文本
需要自定义一个 JSONEncoder 子类来覆盖默认的 系列化赋值给 cls 参数。
import json
from json import JSONEncoder
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class PersonEncoder(JSONEncoder):
def default(self, o):
return o.__dict__
person = Person("peter", 18, "men")
with open("json.txt", 'w+') as f:
json.dump(d, f, indent=4, cls=PersonEncoder)
json.txt 内容
读取文件中 json 形式的字符串元素转化为Python类型 json.load()
1. 文本中 json 字符串转化成 dict
with open("json.txt", 'r') as f:
data = json.load(f)
print(data)
输出：
{
'name': 'peter', 'age': 18, 'gender': 'men'}
2. 文本中的 json 字符串转化成自定义的类对象
object_hook 用于将 JSON 字符串解码成自定义的类对象， 默认object_hook= None 是解码成 dict. 所以要自定义一个解码方法。
import json
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def PersonDecoder(obj):
return Person(obj['name'], obj['age'], obj['gender'])
with open("json.txt", 'r') as f:
person = json.load(f, object_hook=PersonDecoder)
print("name:{}\nage:{}\ngender:{}".format(person.name, person.age, person.gender))
如何动态设置 JSON request body
有时我们把 json 的 request 放在一个文本文件中，但并不是每次请求都用固定的 json body，需要动态地修改其中的值，最后还得转化成 json 字符串做为request body。
例如：json.txt 文本的内容
需要修改 collection-id 字段的值，将改动后的 json 字符串传入 request 作为 body
注意：json body key 都是双引号的，所以一定要将 python 的对象转化成 json 字符串，才能传入 request。
{
"search": {
"query": {
"collection-id": ["collection"]
}
},
"targets": [
{
"type": "subscription-id",
"value": [
1234
]
}
]
}
import json
with open("json.txt", 'r') as f:
data = json.load(f)
print("data:\n{}".format(data))
data["search"]["query"]["collection-id"] = ["collection_1", "collection_2", "collection_3"]
print("new data:\n{}".format(data))
json_data = json.dumps(data, indent=4)
print("json data:\n{}".format(json_data))
输出：
data:
{
'search': {
'query': {
'collection-id': ['collection']}}, 'targets': [{
'type': 'subscription-id', 'value': [1234]}]}
new data:
{
'search': {
'query': {
'collection-id': ['collection_1', 'collection_2', 'collection_3']}}, 'targets': [{
'type': 'subscription-id', 'value': [1234]}]}
json data:
{
"search": {
"query": {
"collection-id": [
"collection_1",
"collection_2",
"collection_3"
]
}
},
"targets": [
{
"type": "subscription-id",
"value": [
1234
]
}
]
}