Python Json使用，Json库性能测试

介绍

官网：https://www.json.org/json-zh.html

中文介绍：https://www.json.cn/wiki.html

中文介绍：https://developer.mozilla.org/zh-CN/docs/Learn/JavaScript/Objects/JSON

JavaScript对象表示法（JSON）是用于将结构化数据表示为JavaScript对象的标准格式，通常用于在网站上表示和传输数据（例如从服务器向客户端发送一些数据，因此可以将其显示在网页上）。您会经常遇到它，所以在本文中，我们向您提供使用JavaScript处理JSON的所有工作，包括访问JSON对象中的数据项并编写自己的JSON。

什么是 JSON

JSON是一种按照JavaScript对象语法的数据格式，这是 Douglas Crockford 推广的。虽然它是基于 JavaScript 语法，但它独立于JavaScript，这也是为什么许多程序环境能够读取（解读）和生成 JSON。

JSON可以作为一个对象或者字符串存在，前者用于解读 JSON 中的数据，后者用于通过网络传输 JSON 数据。 这不是一个大事件——JavaScript 提供一个全局的 可访问的 JSON 对象来对这两种数据进行转换。

一个 JSON 对象可以被储存在它自己的文件中，这基本上就是一个文本文件，扩展名为 .json， 还有 MIME type 用于 application/json.

JSON 结构

我们已经可以推测出 JSON 对象就是基于 JavaScript 对象，而且这几乎是正确的。您可以把 JavaScript 对象原原本本的写入 JSON 数据——字符串，数字，数组，布尔还有其它的字面值对象。这允许您构造出一个对象树，如下：

{
  "squadName" : "Super hero squad",
  "homeTown" : "Metro City",
  "formed" : 2016,
  "secretBase" : "Super tower",
  "active" : true,
  "members" : [
    {
      "name" : "Molecule Man",
      "age" : 29,
      "secretIdentity" : "Dan Jukes",
      "powers" : [
        "Radiation resistance",
        "Turning tiny",
        "Radiation blast"
      ]
    },
    {
      "name" : "Madame Uppercut",
      "age" : 39,
      "secretIdentity" : "Jane Wilson",
      "powers" : [
        "Million tonne punch",
        "Damage resistance",
        "Superhuman reflexes"
      ]
    },
    {
      "name" : "Eternal Flame",
      "age" : 1000000,
      "secretIdentity" : "Unknown",
      "powers" : [
        "Immortality",
        "Heat Immunity",
        "Inferno",
        "Teleportation",
        "Interdimensional travel"
      ]
    }
  ]
}

如果我们要加载对象进入 JavaScript 程序，以保存为一个名为 superHeroes 对象为例，我们使用 . 或 [] 访问对象内的数据（关于. 和 []概念，见 对象基础 ）。如：

superHeroes.hometown
superHeroes["active"]

为了访问对象中的对象，您只需简单地链式访问（通过属性名和数组索引）。例如，访问 superHeroes 对象中的 members 数组对象的第二个元素的 powers 数组对象的第三个元素，您可以这样做：

superHeroes["members"][1]["powers"][2]

1. 首先我们有变量名 superHeroes，储存对象 。
2. 在对象中我们想访问 members 属性，所以我们使用 [“members”]。
3. members 包含有对象数组，我们想要访问第二个元素，所以我们使用[1]。
4. 在对象内，我们想访问 powers 属性，所以我们使用 [“powers”]。
5. powers 属性是一个包含英雄技能的数组。我们想要第三个，所以我们使用[2]。

注：我们已经在 JSONText.html 实例中让JSON 对象进入变量中使其可访问（见源代码）。尝试加载它并且在您的浏览器上访问对象数据。

JSON 数组

前面我们已经说过，”我们已经可以推测出 JSON 对象就是基于 JavaScript 对象，而且这几乎是正确的“——我们说几乎正确的原因是数组对象也是一种合法的 JSON 对象，例如：

[
  {
    "name" : "Molecule Man",
    "age" : 29,
    "secretIdentity" : "Dan Jukes",
    "powers" : [
      "Radiation resistance",
      "Turning tiny",
      "Radiation blast"
    ]
  },
  {
    "name" : "Madame Uppercut",
    "age" : 39,
    "secretIdentity" : "Jane Wilson",
    "powers" : [
      "Million tonne punch",
      "Damage resistance",
      "Superhuman reflexes"
    ]
  }
]

上面是完全合法的 JSON。您只需要通过数组索引就可以访问数组元素，如[0][“powers”][0]。

其他注意事项

• JSON 是一种纯数据格式，它只包含属性，没有方法。
• JSON要求在字符串和属性名称周围使用双引号。 单引号无效。
• 甚至一个错位的逗号或分号就可以导致 JSON 文件出错。您应该小心的检查您想使用的数据(虽然计算机生成的 JSON 很少出错，只要生成程序正常工作)。您可以通过像 JSONLint 的应用程序来检验 JSON。
• JSON 可以将任何标准合法的 JSON 数据格式化保存，不只是数组和对象。比如，一个单一的字符串或者数字可以是合法的 JSON 对象。虽然不是特别有用处……
• 与 JavaScript 代码中对象属性可以不加引号不同，JSON 中只有带引号的字符串可以用作属性。

用法

功能	json	simplejson	ujson	orjson	rapidjson
dumps	✔	✔	✔	✔	✔
loads	✔	✔	✔	✔	✔
dump	✔	✔	✔	×	✔
load	✔	✔	✔	×	✔

函数	说明
dumps	将数据进行json格式编码
loads	将json格式转换为python数据格式
dump	将数据格式化为json写入文件
load	从文件中读取json格式数据转换为python数据格式

json

dumps

s = {"a":1}
print(json.dumps(s), type(json.dumps(s)))

结果

{"a":1} <class 'str'>

loads

s = json.dumps({"a":1})
print(json.loads(s), type(json.loads(s)))

结果

{'a': 1} <class 'dict'>

dump

s = {"a":1}
with open('test.json', 'w') as f:
    json.dump(s,f)

结果

cat test.json
{"a": 1}

load

s = {"a":1}
with open('test.json', 'r') as f:
    print(json.load(f))

结果

{'a': 1}

ujson

dumps

s = [{"key": "value"}, 81, True]
print(ujson.dumps(s), type(ujson.dumps(s)))

结果

[{"key":"value"},81,true] <class 'str'>

loads

s = ujson.dumps([{"key": "value"}, 81, True])
print(ujson.loads(s), type(ujson.loads(s)))

结果

[{'key': 'value'}, 81, True] <class 'list'>

dump

s = [{"key": "value"}, 81, True]

with open('test.json', 'w') as f:
    json.dump(s, f)

结果

# cat test.json
[{"key": "value"}, 81, true]

load

with open('test.json', 'r') as f:
    print(json.load(f))

结果

[{'key': 'value'}, 81, True]

性能测试

Python 3.7.9
orjson 3.4.3
rapidjson 0.9.3
simplejson 3.17.2
ujson 4.0.1

dumps测试代码

# test.py
from time import time
import sys
import string

num = int(sys.argv[1])
libs = ['ujson','rapidjson','orjson','simplejson', 'json']
items = []
for i in range(num):
    items.append({c:c for c in string.ascii_letters})

for lib in libs:
    if lib == 'ujson':
        import ujson
        start = time()
        ujson.dumps(items)
        print("{} {} {}".format(lib, num, time() - start))
        
    elif lib == 'rapidjson':
        import rapidjson
        start = time()
        rapidjson.dumps(items)
        print("{} {} {}".format(lib, num, time() - start))
        
    elif lib == 'orjson':
        import orjson
        start = time()
        orjson.dumps(items)
        print("{} {} {}".format(lib, num, time() - start))
        
    elif lib == 'simplejson':
        import simplejson
        start = time()
        simplejson.dumps(items)
        print("{} {} {}".format(lib, num, time() - start))
        
    else:
        import json
        start = time()
        json.dumps(items)
        print("{} {} {}".format(lib, num, time() - start))

python test.py 100|1000|10000|100000|1000000

字符	100	1000	10000	100000	1000000
ujson	0.0009975433349609375	0.003989219665527344	0.05582284927368164	0.5411512851715088	5.374091625213623
rapidjson	0.0009965896606445312	0.0029935836791992188	0.032944440841674805	0.3864448070526123	3.823469400405884
orjson	0.0	0.0009949207305908203	0.02293705940246582	0.208052396774292	2.0567736625671387
simplejson	0.000997304916381836	0.011995077133178711	0.11170148849487305	1.026904821395874	11.177719116210938
json	0.0010273456573486328	0.012969017028808594	0.126662015914917	1.247314214706421	14.103604078292847

loads测试代码

# test.py
# test.py
from time import time
import sys
import string
import orjson

num = int(sys.argv[1])
libs = ['ujson', 'rapidjson', 'orjson', 'simplejson', 'nujson', 'json']
items = []
for i in range(num):
    items.append({c: c for c in string.ascii_letters})
items = orjson.dumps(items)

for lib in libs:
    if lib == 'ujson':
        import ujson
        start = time()
        ujson.loads(items)
        print("{} {} {}".format(lib, num, time() - start))

    elif lib == 'rapidjson':
        import rapidjson
        start = time()
        rapidjson.loads(items)
        print("{} {} {}".format(lib, num, time() - start))

    elif lib == 'orjson':
        import orjson
        start = time()
        orjson.loads(items)
        print("{} {} {}".format(lib, num, time() - start))

    elif lib == 'simplejson':
        import simplejson
        start = time()
        simplejson.loads(items)
        print("{} {} {}".format(lib, num, time() - start))

    elif lib == 'nujson':
        import nujson
        start = time()
        nujson.loads(items)
        print("{} {} {}".format(lib, num, time() - start))

    else:
        import json
        start = time()
        json.loads(items)
        print("{} {} {}".format(lib, num, time() - start))

python test.py 100|1000|10000|100000|1000000

字符	100	1000	10000	100000	1000000
ujson	0.005414247512817383	0.005414247512817383	0.05385446548461914	0.5455174446105957	5.4679648876190186
rapidjson	0.008005619049072266	0.008005619049072266	0.09873676300048828	0.95245361328125	10.33743929862976
orjson	0.011981725692749023	0.011981725692749023	0.13763117790222168	1.3513810634613037	13.812097549438477
simplejson	0.007015705108642578	0.007015705108642578	0.07981228828430176	0.7661058902740479	8.075462579727173
nujson	0.005961894989013672	0.005961894989013672	0.055831193923950195	0.5405309200286865	5.714277744293213
json	0.006979227066040039	0.006979227066040039	0.08281087875366211	0.7754671573638916	7.8442223072052

小结

• dumps：从速度上来说orjson库最快
• loads：从速度上来说，nujson库最快，其次ujson，然后内置的json库