Python: erstellen Sie eine Liste generator JSON serialisierbar

Wie kann ich mit concat eine Liste von JSON-Dateien in eine riesige JSON-array? Ich habe 5000 Dateien und 550 000 Einträge.

Meine Faust versuchen zu nutzen, um die jq, aber es sieht aus wie jq -s ist nicht optimiert für einen großen Eingang.

jq -s -r '[.[][]]' *.js

Dieser Befehl funktioniert, aber es dauert viel zu lange, um abzuschließen, und ich möchte wirklich, diese zu lösen mit Python.

Hier ist mein Derzeitiger code:

def concatFiles(outName, inFileNames):
    def listGenerator():
        for inName in inFileNames:
            with open(inName, 'r') as f:
                for item in json.load(f):
                    yield item

    with open(outName, 'w') as f:
        json.dump(listGenerator(), f)

Ich bin immer:

TypeError: <generator object listGenerator at 0x7f94dc2eb3c0> is not JSON serializable

Jeder Versuch, laden Sie alle Dateien in den ram ausgelöst wird der OOM-killer von Linux. Haben Sie irgendwelche Ideen?

Wie sieht es genau inhaltlich in der Verknüpfung der Dokumente, das einfügen von Kommata zwischen?
Sie müssen entfernen Sie das äußere array die einzelnen Dateien. Entfernen Sie die Faust und letzten Zeichen jeder Datei sollte funktionieren, aber ich würde gerne Steuern (und entfernen) die json-Einzug.
wie groß sind die Dateien eigentlich? könnte es sein, dass die Durchführung der kompletten serialisierten Daten ist größer als Ihr Gedächtnis ?
Ja, das ist der Grund, warum Anrufliste(..) ist nicht zur Arbeit gehen.
Sie müssen auch Validierung der JSON-vor der Verarbeitung? Wenn nicht, gibt es keine Notwendigkeit, zu konvertieren string -> JSON -> Zeichenfolge. Setzen Sie einfach Kommas zwischen den einzelnen filestream-und surround mit [].

InformationsquelleAutor Sebastian Wagner | 2014-02-09

16

Sollten Sie stammen aus list und überschreiben __iter__ Methode.
```
import json

def gen():
    yield 20
    yield 30
    yield 40

class StreamArray(list):
    def __iter__(self):
        return gen()

    # according to the comment below
    def __len__(self):
        return 1

a = [1,2,3]
b = StreamArray()

print(json.dumps([1,a,b]))
```
Ergebnis ist [1, [1, 2, 3], [20, 30, 40]].

Mit Python 2.7.8, die StreamArray - Klasse hat auch das überschreiben der __len__ - Methode und liefert einen Wert größer als 0 (1 zum Beispiel). Ansonsten ist die json-encoder nicht selbst nennen sich die __iter__ Methode
Bitte beachten Sie, dass diese Lösung schafft ungültige JSON verwendet werden, wenn mit Einzug - parameter und die iterierbar ist "leer". json.dumps({"products": StreamArray()}, indent=2) # {"products": ]}
Ich glaube, wir sollten nicht return 1 für die Länge, wenn die iterierbar ist "leer".
das ist toll - prost

InformationsquelleAutor Vadim Pushtaev
19

Als der simplejson 3.8.0, können Sie die iterable_as_array - option, um jede iterierbar serializable in ein array
```
# Since simplejson is backwards compatible, you should feel free to import
# it as `json`
import simplejson as json
json.dumps((i*i for i in range(10)), iterable_as_array=True)
```
Ergebnis ist [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

InformationsquelleAutor Nick Babcock

Einen kompletten einfacher lesbar-Lösung, die die Serialisierung einen generator, der aus einer normalen oder leer iterierbar arbeiten kann .encode() oder .iterencode(). Schriftliche Prüfungen. Getestet mit Python 2.7, 3.0, 3.3, 3.6

import itertools

class SerializableGenerator(list):
    """Generator that is serializable by JSON

    It is useful for serializing huge data by JSON
    >>> json.dumps(SerializableGenerator(iter([1, 2])))
    "[1, 2]"
    >>> json.dumps(SerializableGenerator(iter([])))
    "[]"

    It can be used in a generator of json chunks used e.g. for a stream
    >>> iter_json = ison.JSONEncoder().iterencode(SerializableGenerator(iter([])))
    >>> tuple(iter_json)
    ('[1', ']')
    # >>> for chunk in iter_json:
    # ...     stream.write(chunk)
    # >>> SerializableGenerator((x for x in range(3)))
    # [<generator object <genexpr> at 0x7f858b5180f8>]
    """

    def __init__(self, iterable):
        tmp_body = iter(iterable)
        try:
            self._head = iter([next(tmp_body)])
            self.append(tmp_body)
        except StopIteration:
            self._head = []

    def __iter__(self):
        return itertools.chain(self._head, *self[:1])


# -- test --

import unittest
import json


class Test(unittest.TestCase):

    def combined_dump_assert(self, iterable, expect):
        self.assertEqual(json.dumps(SerializableGenerator(iter(iterable))), expect)

    def combined_iterencode_assert(self, iterable, expect):
        encoder = json.JSONEncoder().iterencode
        self.assertEqual(tuple(encoder(SerializableGenerator(iter(iterable)))), expect)

    def test_dump_data(self):
        self.combined_dump_assert(iter([1, "a"]), '[1, "a"]')

    def test_dump_empty(self):
        self.combined_dump_assert(iter([]), '[]')

    def test_iterencode_data(self):
        self.combined_iterencode_assert(iter([1, "a"]), ('[1', ', "a"', ']'))

    def test_iterencode_empty(self):
        self.combined_iterencode_assert(iter([]), ('[]',))

    def test_that_all_data_are_consumed(self):
        gen = SerializableGenerator(iter([1, 2]))
        list(gen)
        self.assertEqual(list(gen), [])

Verwendete Lösungen: Vadim Pushtaev (unvollständig), user1158559 (unnötig kompliziert) und Claude (in einer anderen Frage, die auch kompliziert).

Nützliche Vereinfachung sind:

Es ist nicht notwendig, um zu bewerten das erste Element träge und es kann sein, es geschieht in __init__ weil wir erwarten können, dass die SerializableGenerator können sofort abgerufen werden, bevor json.dumps. (gegen user1158559 Lösung)
Ist es nicht notwendig, neu zu schreiben, viele der Methoden, die von NotImplementedError, weil nicht alle Methoden wie __repr__. Es ist besser, zu speichern, den generator auch auf die Liste, um aussagekräftige Ergebnisse wie [<generator object ...>]. (gegen Claude). Standard-Methoden __len__ und __bool__ funktioniert nun richtig zu erkennen, eine leere und nicht leere Objekt.

Vorteil dieser Lösung ist, dass ein standard-JSON-serializer verwendet werden können, ohne Parameter. Wenn geschachtelte Generatoren unterstützt werden sollte oder wenn die Kapselung von SerializableGenerator(iterator) unerwünscht ist, dann empfehle ich IterEncoder Antwort.

Schön gemacht, und +1 für die tests!

InformationsquelleAutor hynekcer

Basierend auf der akzeptierten Antwort, hier ist die StreamArray ich ging schließlich für. Es enthält zwei Lügen:

Der Vorschlag, dass self.__tail__ möglicherweise unveränderlich
len(StreamArray(some_gen)) ist entweder 0 oder 1

class StreamArray(list):

    def __init__(self, gen):
        self.gen = gen

    def destructure(self):
        try:
            return self.__head__, self.__tail__, self.__len__
        except AttributeError:
            try:
                self.__head__ = self.gen.__next__()
                self.__tail__ = self.gen
                self.__len__ = 1 # A lie
            except StopIteration:
                self.__head__ = None
                self.__tail__ = []
                self.__len__ = 0
            return self.__head__, self.__tail__, self.__len__

    def rebuilt_gen(self):
        def rebuilt_gen_inner():
            head, tail, len_ = self.destructure()
            if len_ > 0:
                yield head
            for elem in tail:
                yield elem
        try:
            return self.__rebuilt_gen__
        except AttributeError:
            self.__rebuilt_gen__ = rebuilt_gen_inner()
            return self.__rebuilt_gen__

    def __iter__(self):
        return self.rebuilt_gen()

    def __next__(self):
        return self.rebuilt_gen()

    def __len__(self):
        return self.destructure()[2]

Nur einmal verwenden!

+1: Deine Lösung funktioniert, aber es ist zu kompliziert. Ich denke, dass ich implementiert die gleiche einfacher. Bei mir Aussehen, wenn Sie einen Nachteil gegenüber mir.
Deins sieht gut aus! Für meinen use-case, träge Bewertung das erste Element ist ein feature. Im Nachhinein könnte es eine Vereinfachung dadurch erreicht werden itertools. Sehr froh zu wissen, dass das funktioniert.

InformationsquelleAutor user1158559

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.