如何从一个文件中提取多个 JSON 对象？

问题描述：

我对 Json 文件非常陌生。如果我有一个包含多个 json 对象的 json 文件，例如：

{"ID":"12345","Timestamp":"20140101", "Usefulness":"Yes",
 "Code":[{"event1":"A","result":"1"},…]}
{"ID":"1A35B","Timestamp":"20140102", "Usefulness":"No",
 "Code":[{"event1":"B","result":"1"},…]}
{"ID":"AA356","Timestamp":"20140103", "Usefulness":"No",
 "Code":[{"event1":"B","result":"0"},…]}
…

我想将所有“时间戳”和“有用性”提取到数据框中：

    Timestamp    Usefulness
 0   20140101      Yes
 1   20140102      No
 2   20140103      No
 …

有人知道处理此类问题的通用方法吗？

解决方案 1：

更新：我写了一个不需要一次性读取整个文件的解决方案。它对于 stackoverflow 答案来说太大了，但可以在这里找到jsonstream。

您可以使用它json.JSONDecoder.raw_decode来解码任意大的“堆叠” JSON 字符串（只要它们可以装入内存）。raw_decode一旦它有一个有效的对象，它就会停止，并返回最后一个不属于解析对象的位置。它没有记录，但您可以将这个位置传回raw_decode，然后它从该位置重新开始解析。不幸的是，Pythonjson模块不接受带有前缀空格的字符串。所以我们需要搜索以找到文档中的第一个非空格部分。

from json import JSONDecoder, JSONDecodeError
import re

NOT_WHITESPACE = re.compile(r'S')

def decode_stacked(document, pos=0, decoder=JSONDecoder()):
    while True:
        match = NOT_WHITESPACE.search(document, pos)
        if not match:
            return
        pos = match.start()
        
        try:
            obj, pos = decoder.raw_decode(document, pos)
        except JSONDecodeError:
            # do something sensible if there's some error
            raise
        yield obj

s = """

{"a": 1}  


   [
1
,   
2
]


"""

for obj in decode_stacked(s):
    print(obj)

印刷：

{'a': 1}
[1, 2]

解决方案 2：

使用 json 数组，格式为：

[
{"ID":"12345","Timestamp":"20140101", "Usefulness":"Yes",
  "Code":[{"event1":"A","result":"1"},…]},
{"ID":"1A35B","Timestamp":"20140102", "Usefulness":"No",
  "Code":[{"event1":"B","result":"1"},…]},
{"ID":"AA356","Timestamp":"20140103", "Usefulness":"No",
  "Code":[{"event1":"B","result":"0"},…]},
...
]

然后将其导入到你的 Python 代码中

import json

with open('file.json') as json_file:

    data = json.load(json_file)

现在数据的内容是一个数组，其中的字典代表每个元素。

您可以轻松访问它，即：

data[0]["ID"]

解决方案 3：

因此，正如一些评论中提到的那样，将数据包含在数组中更简单，但随着数据集大小的增加，该解决方案在效率方面不能很好地扩展。当您想要访问数组中的随机项时，您确实应该只使用可迭代对象，否则，生成器才是最佳选择。下面我制作了一个读取器函数的原型，它分别读取每个 json 对象并返回一个生成器。

基本思想是向读者发出信号，让他们在回车符处进行拆分`"
"（"
"对于 Windows 来说）。Python 可以使用file.readline()`函数来实现这一点。

import json
def json_reader(filename):
    with open(filename) as f:
        for line in f:
            yield json.loads(line)

但是，这种方法只有在文件按原样写入时才有效——每个对象都用换行符分隔。下面我编写了一个编写器示例，它将 json 对象数组分隔开，并将每个对象保存在新行上。

def json_writer(file, json_objects):
    with open(file, "w") as f:
        for jsonobj in json_objects:
            jsonstr = json.dumps(jsonobj)
            f.write(jsonstr + "
")

file.writelines()您还可以使用列表推导执行相同的操作：

...
    json_strs = [json.dumps(j) + "
" for j in json_objects]
    f.writelines(json_strs)
...

如果您想要附加数据而不是写入新文件，只需更改open(file, "w")为open(file, "a")。

最后，我发现这不仅在我尝试在文本编辑器中打开 json 文件时提高了可读性，而且在更有效地利用内存方面也有很大帮助。

就这一点而言，如果你在某个时候改变主意，想要从阅读器中得到一个列表，Python 允许你将生成器函数放在列表中并自动填充列表。换句话说，只需编写

lst = list(json_reader(file))

解决方案 4：

根据@dunes的回答添加了流媒体支持：

import re
from json import JSONDecoder, JSONDecodeError

NOT_WHITESPACE = re.compile(r"[^s]")


def stream_json(file_obj, buf_size=1024, decoder=JSONDecoder()):
    buf = ""
    ex = None
    while True:
        block = file_obj.read(buf_size)
        if not block:
            break
        buf += block
        pos = 0
        while True:
            match = NOT_WHITESPACE.search(buf, pos)
            if not match:
                break
            pos = match.start()
            try:
                obj, pos = decoder.raw_decode(buf, pos)
            except JSONDecodeError as e:
                ex = e
                break
            else:
                ex = None
                yield obj
        buf = buf[pos:]
    if ex is not None:
        raise ex

解决方案 5：

这是我所做的。它假定每个对象之间都会有一个换行符，但允许每个对象跨越多行。

import json
def json_reader(filename):
    with open(filename) as f:
        text = ""
        error = None
        for line in f:
            text += line
            try:
               yield json.loads(text)
               text = ""
               e = None
            except e:
               error = e
        if error is not None:
            raise error

它不是超级高效的，因为它尝试多次解析部分 json 文本，但它通常比将整个文件加载到内存中更好，并且避免添加另一个依赖项。

解决方案 6：

JSONDecoder 中抛出了异常，因此也许我们可以重用它。

def json_iter(text: str):
    whitespace = re.compile(r'[     

]*', re.VERBOSE | re.MULTILINE | re.DOTALL).match
    decoder = json.JSONDecoder()
    end = -1
    while True:
        end = whitespace(text, end).end()
        if end == len(text):
            return
        pos = end
        obj, end = decoder.raw_decode(text, idx=pos)
        yield obj


for idx, obj in enumerate(json_iter("[1][2][3][true][false]true false 1 2 3 4 5 6 7 8 9 10 {}")):
    sys.stdout.write(f"[{idx}] => {obj}
")

[0] => [1]
[1] => [2]
[2] => [3]
[3] => [True]
[4] => [False]
[5] => True
[6] => False
[7] => 1
[8] => 2
[9] => 3
[10] => 4
[11] => 5
[12] => 6
[13] => 7
[14] => 8
[15] => 9
[16] => 10
[17] => {}