Python 如何预打印JSON文件？

我有一个JSON文件，这是一个混乱，我想预打印。在Python中，最简单的方法是什么

---

我知道PrettyPrint需要一个“对象”，我认为它可以是一个文件，但我不知道如何传递文件。仅使用文件名不起作用。

json模块已经使用

缩进

参数实现了一些基本的漂亮打印，该参数指定缩进的空格数：

>>> import json
>>>
>>> your_json = '["foo", {"bar":["baz", null, 1.0, 2]}]'
>>> parsed = json.loads(your_json)
>>> print(json.dumps(parsed, indent=4, sort_keys=True))
[
    "foo", 
    {
        "bar": [
            "baz", 
            null, 
            1.0, 
            2
        ]
    }
]

要解析文件，请使用

json.load（）

：

---

您可以在命令行上执行此操作：

python3 -m json.tool some.json

（正如在问题的评论中已经提到的，感谢@Kai Petzke对python3的建议）

实际上，就命令行上的json处理而言，python不是我最喜欢的工具。对于简单的漂亮打印来说是可以的，但是如果您想要操作json，它可能会变得过于复杂。您很快就需要编写一个单独的脚本文件，最终可能会得到键为u“some key”（python-unicode）的映射，这使得选择字段更加困难，并且不会真正朝着漂亮打印的方向发展

您还可以使用：

您还可以获得颜色作为奖励（并且更易于扩展）

附录：关于一方面使用jq处理大型JSON文件，另一方面使用非常大的jq程序，在评论中有一些混淆。对于由单个大型JSON实体组成的文件，实际限制是RAM。对于由真实数据的单个数组组成的2GB文件，pretty打印所需的“最大驻留集大小”为5GB（无论使用jq 1.5还是1.6）。还请注意，jq可以在

pip install jq

Pygmentize+python json.tool=Pretty Print和语法高亮显示之后从python内部使用 Pygmentize是一个杀手级工具

我将python.json.tool与pygmentize相结合

echo '{"foo": "bar"}' | python -m json.tool | pygmentize -l json

请参阅上面的链接以获取pygmentize安装说明

下图显示了这方面的演示：

---

再次使用此函数，不必费力地记住您的JSON是

str

还是

dict

——只需看看漂亮的打印：

import json

def pp_json(json_thing, sort=True, indents=4):
    if type(json_thing) is str:
        print(json.dumps(json.loads(json_thing), sort_keys=sort, indent=indents))
    else:
        print(json.dumps(json_thing, sort_keys=sort, indent=indents))
    return None

pp_json(your_json_string_or_dict)

---

为了能够从命令行漂亮地打印，并且能够控制缩进等。您可以设置类似于以下内容的别名：

alias jsonpp="python -c 'import sys, json; print json.dumps(json.load(sys.stdin), sort_keys=True, indent=2)'"

然后通过以下方式之一使用别名：

cat myfile.json | jsonpp
jsonpp < myfile.json

cat myfile.json | jsonpp
jsonpp

您可以使用内置模块

如何使用json数据读取文件并将其打印出来

import json
import pprint

json_data = None
with open('file_name.txt', 'r') as f:
    data = f.read()
    json_data = json.loads(data)

print(json_data)
{"firstName": "John", "lastName": "Smith", "isAlive": true, "age": 27, "address": {"streetAddress": "21 2nd Street", "city": "New York", "state": "NY", "postalCode": "10021-3100"}, 'children': []}

pprint.pprint(json_data)
{'address': {'city': 'New York',
             'postalCode': '10021-3100',
             'state': 'NY',
             'streetAddress': '21 2nd Street'},
 'age': 27,
 'children': [],
 'firstName': 'John',
 'isAlive': True,
 'lastName': 'Smith'}

---

下面是一个简单的示例，它使用Python以一种很好的方式将JSON打印到控制台，而不需要将JSON作为本地文件放在您的计算机上：

import pprint
import json 
from urllib.request import urlopen # (Only used to get this example)

# Getting a JSON example for this example 
r = urlopen("https://mdn.github.io/fetch-examples/fetch-json/products.json")
text = r.read() 

# To print it
pprint.pprint(json.loads(text))

使用pprint：

导入pprint
pprint.pprint（json）

print（）

与

pprint.pprint（）

print（json）
{'feed'：{'title'：'W3Schools Home Page'，'title_detail'：{'type'：'text/plain'，'language'：无，'base'：''，'value'：'W3Schools Home Page'}，'links'：[{'rel'：'alternate'，'type'：'text/html'，'href'：'https://www.w3schools.com“}]，“链接”：”https://www.w3schools.com“，”副标题“：”免费网页建设教程“，”副标题“详细信息”：{'type'：'text/html'，'language'：无，'base'：''，'value'：'Free web building tutorials'}，'entries'：[]，'bozo'：0，'encoding'：'utf-8'，'version'：'rss20'，'namespace':{}
pprint.pprint（json）
{'bozo'：0，
“编码”：“utf-8”，
“条目”：[]，
'提要'：{'链接'：'https://www.w3schools.com',
'links'：[{'href'：'https://www.w3schools.com',
“rel”：“alternate”，
'type'：'text/html'}]，
“字幕”：“免费网络构建教程”，
“subtitle_detail”：{“base”：”，
“语言”：无，
'type'：'text/html'，
“值”：“免费web构建教程”}，
“标题”：“W3Schools主页”，
“title_detail”：{“base”：”，
“语言”：无，
“类型”：“文本/普通”，
“值”：“W3Schools主页”}，
“名称空间”：{}，
'version'：'rss20'}

我认为最好先解析json，以避免错误：

def format_response(response):
    try:
        parsed = json.loads(response.text)
    except JSONDecodeError:
        return response.text
    return json.dumps(parsed, ensure_ascii=True, indent=4)

你可以试试

---

装置

$pip3安装pprintjson

用法 使用pprintjson CLI从文件中漂亮地打印JSON

$pprintjson.“/path/to/file.json”

使用pprintjson CLI从stdin漂亮地打印JSON

$echo'{“a”：1，“b”：“string”，“c”：true}'|pprintjson

使用pprintjson CLI从字符串漂亮地打印JSON

$pprintjson-c'{“a”：1，“b”：“string”，“c”：true}

从缩进为1的字符串漂亮地打印JSON

$pprintjson-c'{“a”：1，“b”：“string”，“c”：true}'-i 1

从字符串漂亮地打印JSON，并将输出保存到文件output.JSON

$pprintjson-c'{“a”：1，“b”：“string”，“c”：true}'-o./output.json

输出

---

它可以显示或保存到一个文件中。

它远不是完美的，但它可以做到这一点

data = data.replace(',"',',\n"')

---

您可以对其进行改进，添加缩进等，但如果您只是想能够读取更清晰的json，这是一个不错的选择。

我也有类似的要求，需要转储json文件的内容以进行日志记录，这是一种快速而简单的方法：

print(json.dumps(json.load(open(os.path.join('<myPath>', '<myjson>'), "r")), indent = 4 ))

---

希望这能帮助其他人

如果出现不可json序列化的错误，上述答案将不起作用。如果您只想保存它以使其可读，则需要递归调用字典中所有非字典元素的字符串。如果您想稍后加载它，则将其保存为pickle文件，然后加载它（例如，

torch.save（obj，f）

工作正常）

这就是我的工作原理：

#%%

def _to_json_dict_with_strings(dictionary):
    """
    Convert dict to dict with leafs only being strings. So it recursively makes keys to strings
    if they are not dictionaries.

    Use case:
        - saving dictionary of tensors (convert the tensors to strins!)
        - saving arguments from script (e.g. argparse) for it to be pretty

    e.g.

    """
    if type(dictionary) != dict:
        return str(dictionary)
    d = {k: _to_json_dict_with_strings(v) for k, v in dictionary.items()}
    return d

def to_json(dic):
    import types
    import argparse

    if type(dic) is dict:
        dic = dict(dic)
    else:
        dic = dic.__dict__
    return _to_json_dict_with_strings(dic)

def save_to_json_pretty(dic, path, mode='w', indent=4, sort_keys=True):
    import json

    with open(path, mode) as f:
        json.dump(to_json(dic), f, indent=indent, sort_keys=sort_keys)

def my_pprint(dic):
    """

    @param dic:
    @return:

    Note: this is not the same as pprint.
    """
    import json

    # make all keys strings recursively with their naitve str function
    dic = to_json(dic)
    # pretty print
    pretty_dic = json.dumps(dic, indent=4, sort_keys=True)
    print(pretty_dic)
    # print(json.dumps(dic, indent=4, sort_keys=True))
    # return pretty_dic

import torch
# import json  # results in non serializabe errors for torch.Tensors
from pprint import pprint

dic = {'x': torch.randn(1, 3), 'rec': {'y': torch.randn(1, 3)}}

my_pprint(dic)
pprint(dic)

输出：

{
    "rec": {
        "y": "tensor([[-0.3137,  0.3138,  1.2894]])"
    },
    "x": "tensor([[-1.5909,  0.0516, -1.5445]])"
}
{'rec': {'y': tensor([[-0.3137,  0.3138,  1.2894]])},
 'x': tensor([[-1.5909,  0.0516, -1.5445]])}

{   'cca': {   'all': {'avg': tensor(0.5132), 'std': tensor(0.1532)},
               'avg': tensor([0.5993, 0.5571, 0.4910, 0.4053]),
               'rep': {'avg': tensor(0.5491), 'std': tensor(0.0743)},
               'std': tensor([0.0316, 0.0368, 0.0910, 0.2490])},
    'cka': {   'all': {'avg': tensor(0.7885), 'std': tensor(0.3449)},
               'avg': tensor([1.0000, 0.9840, 0.9442, 0.2260]),
               'rep': {'avg': tensor(0.9761), 'std': tensor(0.0468)},
               'std': tensor([5.9043e-07, 2.9688e-02, 6.3634e-02, 2.1686e-01])},
    'cosine': {   'all': {'avg': tensor(0.5931), 'std': tensor(0.7158)},
                  'avg': tensor([ 0.9825,  0.9001,  0.7909, -0.3012]),
                  'rep': {'avg': tensor(0.8912), 'std': tensor(0.1571)},
                  'std': tensor([0.0371, 0.1232, 0.1976, 0.9536])},
    'nes': {   'all': {'avg': tensor(0.6771), 'std': tensor(0.2891)},
               'avg': tensor([0.9326, 0.8038, 0.6852, 0.2867]),
               'rep': {'avg': tensor(0.8072), 'std': tensor(0.1596)},
               'std': tensor([0.0695, 0.1266, 0.1578, 0.2339])},
    'nes_output': {   'all': {'avg': None, 'std': None},
                      'avg': tensor(0.2975),
                      'rep': {'avg': None, 'std': None},
                      'std': tensor(0.0945)},
    'query_loss': {   'all': {'avg': None, 'std': None},
                      'avg': tensor(12.3746),
                      'rep': {'avg': None, 'std': None},
                      'std': tensor(13.7910)}}

我不知道为什么返回字符串然后打印它不起作用，但似乎您必须将转储直接放在print语句中。不是

def pp_json_file(path, file):
    print(json.dumps(json.load(open(os.path.join(path, file), "r")), indent = 4))

#%%

def _to_json_dict_with_strings(dictionary):
    """
    Convert dict to dict with leafs only being strings. So it recursively makes keys to strings
    if they are not dictionaries.

    Use case:
        - saving dictionary of tensors (convert the tensors to strins!)
        - saving arguments from script (e.g. argparse) for it to be pretty

    e.g.

    """
    if type(dictionary) != dict:
        return str(dictionary)
    d = {k: _to_json_dict_with_strings(v) for k, v in dictionary.items()}
    return d

def to_json(dic):
    import types
    import argparse

    if type(dic) is dict:
        dic = dict(dic)
    else:
        dic = dic.__dict__
    return _to_json_dict_with_strings(dic)

def save_to_json_pretty(dic, path, mode='w', indent=4, sort_keys=True):
    import json

    with open(path, mode) as f:
        json.dump(to_json(dic), f, indent=indent, sort_keys=sort_keys)

def my_pprint(dic):
    """

    @param dic:
    @return:

    Note: this is not the same as pprint.
    """
    import json

    # make all keys strings recursively with their naitve str function
    dic = to_json(dic)
    # pretty print
    pretty_dic = json.dumps(dic, indent=4, sort_keys=True)
    print(pretty_dic)
    # print(json.dumps(dic, indent=4, sort_keys=True))
    # return pretty_dic

import torch
# import json  # results in non serializabe errors for torch.Tensors
from pprint import pprint

dic = {'x': torch.randn(1, 3), 'rec': {'y': torch.randn(1, 3)}}

my_pprint(dic)
pprint(dic)

{
    "rec": {
        "y": "tensor([[-0.3137,  0.3138,  1.2894]])"
    },
    "x": "tensor([[-1.5909,  0.0516, -1.5445]])"
}
{'rec': {'y': tensor([[-0.3137,  0.3138,  1.2894]])},
 'x': tensor([[-1.5909,  0.0516, -1.5445]])}

TypeError: tensor is not JSON serializable

    pprint(stats, indent=4, sort_dicts=True)

{   'cca': {   'all': {'avg': tensor(0.5132), 'std': tensor(0.1532)},
               'avg': tensor([0.5993, 0.5571, 0.4910, 0.4053]),
               'rep': {'avg': tensor(0.5491), 'std': tensor(0.0743)},
               'std': tensor([0.0316, 0.0368, 0.0910, 0.2490])},
    'cka': {   'all': {'avg': tensor(0.7885), 'std': tensor(0.3449)},
               'avg': tensor([1.0000, 0.9840, 0.9442, 0.2260]),
               'rep': {'avg': tensor(0.9761), 'std': tensor(0.0468)},
               'std': tensor([5.9043e-07, 2.9688e-02, 6.3634e-02, 2.1686e-01])},
    'cosine': {   'all': {'avg': tensor(0.5931), 'std': tensor(0.7158)},
                  'avg': tensor([ 0.9825,  0.9001,  0.7909, -0.3012]),
                  'rep': {'avg': tensor(0.8912), 'std': tensor(0.1571)},
                  'std': tensor([0.0371, 0.1232, 0.1976, 0.9536])},
    'nes': {   'all': {'avg': tensor(0.6771), 'std': tensor(0.2891)},
               'avg': tensor([0.9326, 0.8038, 0.6852, 0.2867]),
               'rep': {'avg': tensor(0.8072), 'std': tensor(0.1596)},
               'std': tensor([0.0695, 0.1266, 0.1578, 0.2339])},
    'nes_output': {   'all': {'avg': None, 'std': None},
                      'avg': tensor(0.2975),
                      'rep': {'avg': None, 'std': None},
                      'std': tensor(0.0945)},
    'query_loss': {   'all': {'avg': None, 'std': None},
                      'avg': tensor(12.3746),
                      'rep': {'avg': None, 'std': None},
                      'std': tensor(13.7910)}}

{
    "cca": {
        "all": {
            "avg": "tensor(0.5144)",
            "std": "tensor(0.1553)"
        },
        "avg": "tensor([0.6023, 0.5612, 0.4874, 0.4066])",
        "rep": {
            "avg": "tensor(0.5503)",
            "std": "tensor(0.0796)"
        },
        "std": "tensor([0.0285, 0.0367, 0.1004, 0.2493])"
    },
    "cka": {
        "all": {
            "avg": "tensor(0.7888)",
            "std": "tensor(0.3444)"
        },
        "avg": "tensor([1.0000, 0.9840, 0.9439, 0.2271])",
        "rep": {
            "avg": "tensor(0.9760)",
            "std": "tensor(0.0468)"
        },
        "std": "tensor([5.7627e-07, 2.9689e-02, 6.3541e-02, 2.1684e-01])"
    },
    "cosine": {
        "all": {
            "avg": "tensor(0.5945)",
            "std": "tensor(0.7146)"
        },
        "avg": "tensor([ 0.9825,  0.9001,  0.7907, -0.2953])",
        "rep": {
            "avg": "tensor(0.8911)",
            "std": "tensor(0.1571)"
        },
        "std": "tensor([0.0371, 0.1231, 0.1975, 0.9554])"
    },
    "nes": {
        "all": {
            "avg": "tensor(0.6773)",
            "std": "tensor(0.2886)"
        },
        "avg": "tensor([0.9326, 0.8037, 0.6849, 0.2881])",
        "rep": {
            "avg": "tensor(0.8070)",
            "std": "tensor(0.1595)"
        },
        "std": "tensor([0.0695, 0.1265, 0.1576, 0.2341])"
    },
    "nes_output": {
        "all": {
            "avg": "None",
            "std": "None"
        },
        "avg": "tensor(0.2976)",
        "rep": {
            "avg": "None",
            "std": "None"
        },
        "std": "tensor(0.0945)"
    },
    "query_loss": {
        "all": {
            "avg": "None",
            "std": "None"
        },
        "avg": "tensor(12.3616)",
        "rep": {
            "avg": "None",
            "std": "None"
        },
        "std": "tensor(13.7976)"
    }
}