21天学习挑战赛——Python JSON标准库

最新推荐文章于 2024-08-25 02:02:16 发布

花落指尖❀

最新推荐文章于 2024-08-25 02:02:16 发布

阅读量1k

点赞数

分类专栏： Python基础文章标签： python json 爬虫 pip 开发语言

本文链接：https://blog.csdn.net/m0_52162042/article/details/126135588

版权

Python基础专栏收录该内容

16 篇文章 2 订阅

订阅专栏

2.2 Python<—>JSON 数据类型转换

2.3.3 json.dumps 和 json.dump 写入文件的区别

2.3.4 json.loads()

2.3.5 json.load()

2.3.6 json.laods() 和 json.load() 区别

⭐每天的进步，都在悄悄进行，总会有所收获，YQQ对不起，情人节在外地出差不能陪你。我会变得越来越好，越能配得上你。加油！🌈

活动地址：CSDN21天学习挑战赛

1. JSON概述

1.1 JSON概念

JSON(全名：JavaScript Object Notation 对象表示法) 是一种轻量级的文本数据交换格式，JSON的数据格式其实就是 Python 里面的字典格式，里面可以包含方括号的数组，也就是 Python 里面的列表。

1.2 JSON格式

语法格式：{key1:value, key2:value2} 键值对形式（键和值之间用冒号分开），键值对间用逗号连接，最好一个键值对后不再加逗号。

用法举例：

#简单举例：JSON对象
{
    "name":Laowang,
    'age':35
}
#复杂举例：JSON数组
{
    "student":
        [
            {"name":"小明","score":99},
            {"name":"小红","score":60}
        ],
    "classroom":{"class1":"room1","class2":"room2"}
}

1.3 JSON注意事项

JSON 的键值对的键部分，必须用双引号 "" 包括，单引号不行（所以如果在键中出现了关键字，也会被字符化），而 JS(JavaScript) 中对象没有强制要求（所以在键中不允许出现关键字）。
JSON 的键值对的值部分，不允许出现函数function，undefined，NaN，但是可以有null。JS 中对象的值中可以出现。
JSON 数据库结束后，不允许出现没有意义的逗号，如:{"name":"Laowang", "age":35, }，注意看数据结尾35后面的逗号，不允许出现。

2. JSON模块

2.1 JSON作用

使用 JSON字符串生成 Python 对象（load）。
由 Python 对象格式化乘 JSON字符串（dump）。

2.2 Python<—>JSON 数据类型转换

2.2.1 Python——>JSON

将数据从 Python 转换到 JSON 格式，在数据类型上会有所变化，具体如下表所示：

Python ——> JSON
Python	JSON
dict（字典）	object
list（列表），tuple（元组）	array
str	string
int，float，int-& float-derived Enums	number
True	true
False	false
None	null

2.2.2 JSON——>Python

将 JSON格式转化为 Python内置类型，具体如下表所示：

JSON ——> Python
JSON	Python
object	dict
array	list
string	str
number(int)	int
number(real)	float
true	True
false	False
null	None

2.3 json模块常用方法

JSON 常用方法
方法	功能
json.dumps(obj)	将 Python 数据类型转换为 JSON格式的字符串
json.dump(obj, fp)	将 Python 数据类型转换并表春倒 JSON格式的文件内
json.loads(s)	将 JSON格式的字符串转换为 Python 的数据类型
json.load(fp)	从 JSON格式的文件中读取数据并转换为 Python 的数据类型

2.3.1 json.dumps()

将 Python 数据类型转换为 JSON格式的字符串。

函数语法：json.dumps(obj，*，skipkey=False，ensure_ascii=True，check_circular=True，allow_nan=True，cls=None，indent=None，separators=None，default=None，sort_keys=false，**kw)

参数说明：

obj:匹配的正则表达式
*：星号本身不是参数，星号后面的参数都是关键字参数，需要使用关键字传值，否则程序会报错。
skipkeys：默认为False。如果为True，则不是基本对象（包括str、int、float、bool、None）的字典的键会被跳过，否则会引发一个TypeError错误信息。
ensure_ascii:默认为 True，将所有输入的非 ASCII 字符转义输出；如果值为 False，会将输入的非 ASCII 字符原样输出。
check_circular：表示检验循环引用，默认值为True。如果值为False，则容器类型的循环引用会被跳过并引发一个 OverflowError 错误。
allow_nan:默认为True。如果值为False，那么会对 JSON 规范以外的 float 类型值（nan、inf 和 -inf）进行序列化时将会引发一个 ValueError 错误；如果值为，则使用它们的 JavaScript 等价形式（NaN、infinity 和 -infinity）。
cls：默认为None。通过该关键字，可以指定自定义的 JSONEncoder 的子类。
indent：默认为 None。选择最紧凑的表达式。如果 indent 是一个非负整数或者字符串，那么 JSON 数组元素和对象成员会被美化输出为该值指定的缩进等级；如果缩进等级为零、负数或者“”，则只会添加换行符。当 indent 为一个正整数时，会让每一层缩进同样数量的空格；如果 indent 是一个字符串，如换行符（\n）、制表符（\t）等，那么这个字符串会被用于每一层。
separators：默认为None。该参数是一个元组，定义分隔符的类型，其中包含空白字符。如果想得到最近凑的 JSON 表达式，应指定该参数为 (',',':')，不要空白字符。
default：默认为None。如果要指定该参数，则该参数应是一个函数。当某个对象无法被序列化时，它会被调用。返回该对象的一个被 JSON 编码的版本或者引发一个 TypeError（传入参数的类型错误）。如果不指定该参数，则会直接引发 TypeError。
sort_keys：默认为False。如果值为True，那么输出的字典会以键进行排序。
**kw：其他关键字参数，用于字典。

用法举例：

不带关键字参数举例：

import  json #导入json模块

#Python字典
person = {"name":"老王", "age":35, "tel":["88888888","17866666666"], "single":True}
print(person) #输出：{'name': '老王', 'age': 35, 'tel': ['88888888', '17866666666'], 'single': True}
print(type(person)) #输出：<class 'dict'>
#Python字典转换成JSON格式
josnStr = json.dumps(person)
print(josnStr) #输出：{"name": "\u8001\u738b", "age": 35, "tel": ["88888888", "17866666666"], "single": true}
print(type(josnStr)) #输出：<class 'str'>

分析：从上面代码可以看出 JSON 和 Python 格式的区别在于：Python 格式打印输出的是单引号，并且类型是字典（dic）；而 JSON 格式打印输出的是双信号，类型为字符串（str），并且 True 的开头大小写也有区别。

带关键字参数举例：

import  json #导入json模块

person = {"name":"老王", "age":35, "tel":["88888888","17866666666"], "single":True}
print(json.dumps(person, sort_keys=True, indent=4, separators=(',',': ')))
#输出：
# {
#     "age": 35,
#     "name": "\u8001\u738b",
#     "single": true,
#     "tel": [
#         "88888888",
#         "17866666666"
#     ]
# }
print(json.dumps(person, sort_keys=True, indent=4, separators=('！','-'))) #改变分隔符类型
#输出：
# {
#     "age"-35！
#     "name"-"\u8001\u738b"！
#     "single"-true！
#     "tel"-[
#         "88888888"！
#         "17866666666"
#     ]
# }

分析：以上程序中，加入了三个关键字参数，分别是按键进行排序、缩进4个字符、键与值和键值对间的分隔符。

对文件操作举例：

import  json #导入json模块

person = {"name":"老王", "age":35, "tel":["88888888","17866666666"], "single":True}
jsonStr = json.dumps(person)
with open('test.json','w',encoding='utf-8') as f:
    f.write(jsonStr)
#文件test.json中内容：{"name": "\u8001\u738b", "age": 35, "tel": ["88888888", "17866666666"], "single": true}

分析：上段程序将字典形式转换为 JSON 格式，并且生成一个名字为“test.json”的文件，将 JSON格式数据存入文件中，一般生成的文件所在路径和程序所在路径相同。

2.3.2 json.dump()

json.dump() 是将 Python 数据类型转换并保存到 JSON 格式的文件内。

函数语法：json.dump(obj，fp，*，skipkey=False，ensure_ascii=True，check_circular=True，allow_nan=True，cls=None，indent=None，separators=None，default=None，sort_keys=false，**kw)

参数说明：(相比于 dumps，只多了一个必选参数 fp，其他参数类似)

fps ：JSON 格式的文件流

用法举例：

非格式化输出举例：

import  json #导入json模块

person = {"name":"老王", "age":35, "tel":["88888888","17866666666"], "single":True}
json.dump(person, open('data.json','w'))
#生成的data.json文件中内容：{"name": "\u8001\u738b", "age": 35, "tel": ["88888888", "17866666666"], "single": true}

分析：由于上面代码中，未用到关键字参数，生成的文件中，并不会格式化输出。

格式化输出举例：

import  json #导入json模块

person = {"name":"老王","age":35,"tel":["88888888","17866666666"],"single":True}
json.dump(person, open('data.json','w'), sort_keys=True, indent=4, separators=(',',': '))
#生成的data.json文件中内容：
# {
#     "age": 35,
#     "name": "\u8001\u738b",
#     "single": true,
#     "tel": [
#         "88888888",
#         "17866666666"
#     ]
# }

分析：上面代码使用到了 JSON 的格式化输出参数。在输出时，即使把原字典格式写得和规范格式相同，输出时如果不添加格式化使出关键字参数，还是会一行输出。

2.3.3 json.dumps 和 json.dump 写入文件的区别

dump() 不需要使用 .write() 方法，只需要写入的字典，文件流即可；而 dumps() 需要使用 .write() 方法写入。
如果需要把字典写到文件里，dump() 好用；而如果不需要操作文件，或者需要把内容存储到数据库 excel 中，则需要使用 dumps() 先把字典转换成字符串，再写入。

2.3.4 json.loads()

将 JSON 格式的字符串转换成 Python的数据类型。

函数语法：json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

参数说明：

s：字符串
cls：用于自定义一个子类 JSONCoder，用于替换 JSONCoder类，可以自定义下面的 parse_xxx 参数。
object_hook:将返回结果字典替换为指定类型，该参数用来实现自定义解码器。
parse_float:该参数被指定时，符合 flaot 类型的字符串被转义成指定类型。
parse_int:该参数被指定时，符合 int 类型的字符串被转义成指定类型。
parse_constant:该参数被指定时，解码 JSON 字符串时，如果出现 -Infinity，Infinity，NaN 会调用从该参数指定方法。
object_pairs_hook:该参数被制定是，将结果以 key-value 列表的形式返回。如果 object_hook 和 object_pairs_hook 同时指定时，优先返回 object_pairs_hook。

普通操作用法举例：

import  json #导入json模块

#Python字典
person = {"name":"老王", "age":35, "tel":["88888888","17866666666"], "single":True}
print(person) #输出：{'name': '老王', 'age': 35, 'tel': ['88888888', '17866666666'], 'single': True}
print(type(person)) #输出：<class 'dict'>
#Python字典转换成JSON格式
josnStr = json.dumps(person)
print(josnStr) #输出：{"name": "\u8001\u738b", "age": 35, "tel": ["88888888", "17866666666"], "single": true}
print(type(josnStr)) #输出：<class 'str'>

#JSON字符串再次转换为Python字典
Python_obj = json.loads(josnStr)
print(Python_obj) #输出：{'name': '老王', 'age': 35, 'tel': ['88888888', '17866666666'], 'single': True}
print(type(Python_obj)) #输出：<class 'dict'>
#打印字典所有的键key
print(Python_obj.keys()) #输出：dict_keys(['name', 'age', 'tel', 'single'])
#打印字典所有的值value
print(Python_obj.values()) #输出：dict_values(['老王', 35, ['88888888', '17866666666'], True])

分析：使用 json.loads() 方法将 JSON 格式的字符串传换成 Python 字典格式后，可正常使用关于字典的操作。

文件操作用法举例：

import  json #导入json模块

f = open('data.json',encoding='utf-8')
content =f.read()  #使用 json.loads() 方法前需要先读取文件
Python_obj = json.loads(content)
print(Python_obj) #输出：{'age': 35, 'name': '老王', 'single': True, 'tel': ['88888888', '17866666666']}

2.3.5 json.load()

从 JSON 格式的文件中读取数据并转换为 Python 的数据类型。

函数语法：json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

参数说明：（其余参数和 json.loads() 方法类似，不再介绍）

fp:文件的数据流

用法举例：

import  json #导入json模块

Python_obj = json.load(open('data.json','r'))
print(Python_obj) #输出：{'age': 35, 'name': '老王', 'single': True, 'tel': ['88888888', '17866666666']}
print(type(Python_obj)) #输出：<class 'dict'>

2.3.6 json.laods() 和 json.load() 区别

load() 传入的参数是 JSON 字符串，而 load() 传入的是文件对象。
使用 loads() 方法时需要先读取文件再使用，而 load() 不用。

2.4总结

不管是 dump 还是 load，后面带 s 的都是和字符串相关的，不带 s 的都是和文件相关的。

3.XML文件和JSON文件相互转换

3.1 安装 xmltodict 模块

使用 Pycharm 安装模块请参考：Pycharm安装第三方模块

cmd 命令控制窗口安装第三方模块：

pip install xmltodict

3.2XML文件转为JSON文件

新建一个 test.xml 文件，里面包含以下代码：

<note date="23/04/2022">
	<to>tom</to>
	<from>mary</from>
	<msg>love</msg>
</note>

用法举例：

import  json #导入json模块
import xmltodict #导入xmltodict模块

def xml_to_json(xml_str):
    """ parse 方法是xml的解析器，参数是xml里的数据
    :param xml_str: xml字符串
    :return: json字符串
    """
    xml_parse = xmltodict.parse(xml_str)
    #json库dumps()是将dict转化成json格式，loads()是将json格式转化成dict格式
    #dumps()方法的ident=1,格式化json
    json_str = json.dumps(xml_parse, indent=1)
    return json_str

XML_PATH = './test.xml'
with open(XML_PATH,'r') as f:
    xmlfile = f.read()
    with open(XML_PATH[:-3]+'json','w') as newfile:
        newfile.write(xml_to_json(xmlfile))

分析：上面程序中函数创建了一个函数 xml_to_json 用以将 XML 格式文件转换成 JSON 格式文件。先用 parse 方法解析 xml 文件，返回的是 collections.OrderedDict 类型的参数，类似于 Python 字典格式，再用 dumps 方法格式化为 JSON 格式。最终结果如下，创建了一个 test.json 文件。

3.3 JSON文件转换为XML文件

在程序相同目录新建一个 test.json文件，里面包含以下代码：

{
  "student": {
    "course": {
      "name": "math",
      "score": "90"
    },
    "info": {
      "sex": "male",
      "name": "Xiaolang"
    },
    "stid": "36969"
  }
}

用法举例：

import  json #导入json模块
import xmltodict #导入xmltodict模块

def json_to_xml(Python_dict):
    """ unparse() 方法将json格式转化为xml
    :param Python_dict:Python的字典对象
    :return: xml字符串
    """
    xml_str = xmltodict.unparse(Python_dict)
    return xml_str

JSON_PATH = './test.json'
with open(JSON_PATH,'r') as f:
    jsonfile = f.read()
    Python_dict = json.loads(jsonfile)
    with open(JSON_PATH[:-4]+'xml','w') as newfile:
        newfile.write(json_to_xml(Python_dict))

分析：上面程序中函数创建了一个函数 json_to_xml 用以将 JSON 格式文件转换成 XML 格式文件。先用 unparse 方法解析 JSON文件，返回的是 str 类型的数据。最终结果如下，创建了一个 test.xml 文件。

4.解析JSON文件

4.1解析JSON字符串

解析 JSON 文件其实就是定位到所需数据的键。

用法举例：

import  json #导入json模块

json_str = '{"name":"XiaoLang","info":{"sex":"male","score":["99","98"]}}'
print(json_str) #输出：{"name":"XiaoLang","info":{"sex":"male","score":["99","98"]}}
print(type(json_str)) #输出：<class 'str'>

#1.JSON文件转换为Python对象
Python_obj = json.loads(json_str)
print(Python_obj) #输出：{'name': 'XiaoLang', 'info': {'sex': 'male', 'score': ['99', '98']}}
print(type(Python_obj)) #输出：<class 'dict'>

#2.具体定位数据节点
print(Python_obj.keys()) #输出：dict_keys(['name', 'info'])
print(Python_obj.values()) #输出：dict_values(['XiaoLang', {'sex': 'male', 'score': ['99', '98']}])
print(Python_obj["name"]) #输出：XiaoLang
print(Python_obj["info"]["sex"]) #输出：male
print(Python_obj["info"]["score"][0]) #输出：99
print(Python_obj["info"]["score"][1]) #输出：98

分析：将 JSON 字符串转换成 Python 的字典数据后，就可运用字典类型的数据对应方法去取值。

4.2解析JSON文件

在程序相同目录新建一个 test.json文件，里面包含以下代码：

{
  "student": {
    "course": {
      "name": "math",
      "score": "90"
    },
    "info": {
      "sex": "male",
      "name": "Xiaolang"
    },
    "stid": "36969"
  }
}

用法举例：

import  json #导入json模块

#1.JSON文件转换为Python对象
Python_obj = json.load(open('test.json','r'))
print(Python_obj) #输出：{'student': {'course': {'name': 'math', 'score': '90'}, 'info': {'sex': 'male', 'name': 'Xiaolang'}, 'stid': '36969'}}
print(type(Python_obj)) #输出：<class 'dict'>

#2.解析JSON文件
#2.1输出course节点下的数据
print(Python_obj['student']['course']['name']) #输出：math
print(Python_obj['student']['course']['score']) #输出：90
#2.2输出info节点下的数据
print(Python_obj['student']['info']['sex']) #输出：male
print(Python_obj['student']['info']['name']) #输出：Xiaolang

花落指尖❀

关注

0
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
0
评论
21天学习挑战赛——Python JSON标准库

1. JSON概述1. JSON概述1.1 JSON概念JSON(全名：JavaScript Object Notation 对象表示法) 是一种轻量级的文本数据交换格式，JSON的数据格式其实就是 Python 里面的字典格式，里面可以包含方括号的数组，也就是 Python 里面的列表。1.2 JSON格式语法格式：键值对形式（键和值之间用冒号分开），键值对间用逗号连接，最好一个键值对后不再加逗号。...
复制链接

扫一扫