Python Language
JSON-Modul

Bemerkungen

# my_json module

import json
from functools import partial

def serialise_object(obj):
    # Do something to produce json-serialisable data
    return dict_obj

dump = partial(json.dump, default=serialise_object)
dumps = partial(json.dumps, default=serialise_object)

# my_json module

import json
from functools import partial

def deserialise_object(dict_obj):
    # Do something custom
    return obj

def deserialise_float(str_obj):
    # Do something custom
    return obj

load = partial(json.load, object_hook=deserialise_object, parse_float=deserialise_float)
loads = partial(json.loads, object_hook=deserialise_object, parse_float=deserialise_float)

# my_json module

import json
from functools import partial

class MyEncoder(json.JSONEncoder):
    # Do something custom

class MyDecoder(json.JSONDecoder):
    # Do something custom

dump = partial(json.dump, cls=MyEncoder)
dumps = partial(json.dumps, cls=MyEncoder)
load = partial(json.load, cls=MyDecoder)
loads = partial(json.loads, cls=MyDecoder)

JSON aus Python-Diktieren erstellen

import json
d = {
    'foo': 'bar',
    'alice': 1,
    'wonderland': [1, 2, 3]
}
json.dumps(d)

Das obige Snippet gibt Folgendes zurück:

'{"wonderland": [1, 2, 3], "foo": "bar", "alice": 1}'

Erstellen von Python-Diktaten aus JSON

import json
s = '{"wonderland": [1, 2, 3], "foo": "bar", "alice": 1}'
json.loads(s)

Das obige Snippet gibt Folgendes zurück:

{u'alice': 1, u'foo': u'bar', u'wonderland': [1, 2, 3]}

Daten in einer Datei speichern

Das folgende Snippet codiert die in d gespeicherten Daten in JSON und speichert sie in einer Datei (ersetzen Sie filename durch den tatsächlichen Dateinamen).

import json

d = {
    'foo': 'bar',
    'alice': 1,
    'wonderland': [1, 2, 3]
}

with open(filename, 'w') as f:
    json.dump(d, f)

Daten aus einer Datei abrufen

Das folgende Snippet öffnet eine JSON-codierte Datei (Ersetzen Sie filename durch den tatsächlichen Dateinamen) und gibt das in der Datei gespeicherte Objekt zurück.

import json

with open(filename, 'r') as f:
    d = json.load(f)

`load` vs.` load`, `dump` vs.` dumps`

Das json Modul enthält Funktionen zum Lesen und Schreiben in und aus Unicode-Zeichenfolgen sowie zum Lesen und Schreiben in und aus Dateien. Diese werden durch nachgestellte s im Funktionsnamen unterschieden. In diesen Beispielen verwenden wir ein StringIO-Objekt, aber für jedes dateiähnliche Objekt gelten dieselben Funktionen.

Hier verwenden wir die String-basierten Funktionen:

import json

data = {u"foo": u"bar", u"baz": []}
json_string = json.dumps(data)
# u'{"foo": "bar", "baz": []}'
json.loads(json_string)
# {u"foo": u"bar", u"baz": []}

Und hier verwenden wir die dateibasierten Funktionen:

import json

from io import StringIO

json_file = StringIO()
data = {u"foo": u"bar", u"baz": []}
json.dump(data, json_file)
json_file.seek(0)  # Seek back to the start of the file before reading
json_file_content = json_file.read()
# u'{"foo": "bar", "baz": []}'
json_file.seek(0)  # Seek back to the start of the file before reading
json.load(json_file)
# {u"foo": u"bar", u"baz": []}

Wie Sie sehen, besteht der Hauptunterschied darin, dass Sie beim Ablegen von Json-Daten das Dateihandle an die Funktion übergeben müssen, anstatt den Rückgabewert zu erfassen. Erwähnenswert ist auch, dass Sie vor dem Lesen oder Schreiben den Anfang der Datei suchen müssen, um eine Beschädigung der Daten zu vermeiden. Wenn Sie eine Datei öffnen, wird der Cursor auf Position 0

import json

json_file_path = './data.json'
data = {u"foo": u"bar", u"baz": []}

with open(json_file_path, 'w') as json_file:
    json.dump(data, json_file)

with open(json_file_path) as json_file:
    json_file_content = json_file.read()
    # u'{"foo": "bar", "baz": []}'

with open(json_file_path) as json_file:
    json.load(json_file)
    # {u"foo": u"bar", u"baz": []}

Wenn Sie beide Arten des Umgangs mit json-Daten haben, können Sie idiomatisch und effizient mit auf json pyspark Formaten arbeiten, wie z.

# loading from a file
data = [json.loads(line) for line in open(file_path).splitlines()]

# dumping to a file
with open(file_path, 'w') as json_file:
    for item in data:
        json.dump(item, json_file)
        json_file.write('\n')

Aufruf von "json.tool" von der Befehlszeile aus, um die JSON-Ausgabe zu drucken

Einige JSON-Datei "foo.json" wie:

{"foo": {"bar": {"baz": 1}}}

Wir können das Modul direkt von der Befehlszeile aus aufrufen (den Dateinamen als Argument übergeben), um es hübsch auszudrucken:

$ python -m json.tool foo.json
{
    "foo": {
        "bar": {
            "baz": 1
        }
    }
}

Das Modul wird auch Eingaben von STDOUT entgegennehmen, also könnten wir (in Bash) auch Folgendes tun:

$ cat foo.json | python -m json.tool

JSON-Ausgabe formatieren

Nehmen wir an, wir haben folgende Daten:

>>> data = {"cats": [{"name": "Tubbs", "color": "white"}, {"name": "Pepper", "color": "black"}]}

Wenn Sie dies einfach als JSON-Dumping ausführen, macht das hier nichts Besonderes:

>>> print(json.dumps(data))
{"cats": [{"name": "Tubbs", "color": "white"}, {"name": "Pepper", "color": "black"}]}

Einzug festlegen, um eine schönere Ausgabe zu erhalten

Wenn wir hübsch drucken möchten, können wir eine indent festlegen:

>>> print(json.dumps(data, indent=2))
{
  "cats": [
    {
      "name": "Tubbs",
      "color": "white"
    },
    {
      "name": "Pepper",
      "color": "black"
    }
  ]
}

Schlüssel alphabetisch sortieren, um eine konsistente Ausgabe zu erhalten

Standardmäßig ist die Reihenfolge der Schlüssel in der Ausgabe nicht definiert. Wir können sie in alphabetischer Reihenfolge erhalten, um sicherzustellen, dass wir immer die gleiche Ausgabe erhalten:

>>> print(json.dumps(data, sort_keys=True))
{"cats": [{"color": "white", "name": "Tubbs"}, {"color": "black", "name": "Pepper"}]}

Whitespace entfernen, um kompakte Ausgabe zu erhalten

Wir möchten vielleicht die unnötigen Leerzeichen entfernen, was durch das Setzen von Trennzeichen-Strings von den Standardwerten ', ' und ': '

>>>print(json.dumps(data, separators=(',', ':')))
{"cats":[{"name":"Tubbs","color":"white"},{"name":"Pepper","color":"black"}]}

JSON-Codierung von benutzerdefinierten Objekten

Wenn wir nur folgendes versuchen:

import json
from datetime import datetime
data = {'datetime': datetime(2016, 9, 26, 4, 44, 0)}
print(json.dumps(data))

Wir erhalten eine Fehlermeldung, dass TypeError: datetime.datetime(2016, 9, 26, 4, 44) is not JSON serializable .

Um das datetime-Objekt ordnungsgemäß serialisieren zu können, müssen Sie benutzerdefinierten Code für die Konvertierung schreiben:

class DatetimeJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        try:
            return obj.isoformat()
        except AttributeError:
            # obj has no isoformat method; let the builtin JSON encoder handle it
            return super(DatetimeJSONEncoder, self).default(obj)

und dann diese Encoder-Klasse anstelle von json.dumps :

encoder = DatetimeJSONEncoder()
print(encoder.encode(data))
# prints {"datetime": "2016-09-26T04:44:00"}