# simplejson - pydoc - phpman Help on package simplejson: ## NAME simplejson ## DESCRIPTION JSON (JavaScript Object Notation) <> is a subset of JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data interchange format. :mod:`simplejson` exposes an API familiar to users of the standard library :mod:`marshal` and :mod:`pickle` modules. It is the externally maintained version of the :mod:`json` library contained in Python 2.6, but maintains compatibility back to Python 2.5 and (currently) has significant performance advantages, even without using the optional C extension for speedups. Encoding basic Python object hierarchies:: >>> import simplejson as json >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}]) '["foo", {"bar": ["baz", null, 1.0, 2]}]' >>> print(json.dumps("\"foo\bar")) "\"foo\bar" >>> print(json.dumps(u'\u1234')) "\u1234" >>> print(json.dumps('\\')) "\\" >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) {"a": 0, "b": 0, "c": 0} >>> from simplejson.compat import StringIO >>> io = StringIO() >>> json.dump(['streaming API'], io) >>> io.getvalue() '["streaming API"]' Compact encoding:: >>> import simplejson as json >>> obj = [1,2,3,{'4': 5, '6': 7}] >>> json.dumps(obj, separators=(',',':'), sort_keys=True) '[1,2,3,{"4":5,"6":7}]' Pretty printing:: >>> import simplejson as json >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=' ')) { "4": 5, "6": 7 } Decoding JSON:: >>> import simplejson as json >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}] >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj True >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar' True >>> from simplejson.compat import StringIO >>> io = StringIO('["streaming API"]') >>> json.load(io)[0] == 'streaming API' True Specializing JSON object decoding:: >>> import simplejson as json >>> def as_complex(dct): ... if '__complex__' in dct: ... return complex(dct['real'], dct['imag']) ... return dct ... >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}', ... object_hook=as_complex) (1+2j) >>> from decimal import Decimal >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1') True Specializing JSON object encoding:: >>> import simplejson as json >>> def encode_complex(obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... raise TypeError('Object of type %s is not JSON serializable' % ... obj.__class__.__name__) ... >>> json.dumps(2 + 1j, default=encode_complex) '[2.0, 1.0]' >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j) '[2.0, 1.0]' >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j)) '[2.0, 1.0]' Using simplejson.tool from the shell to validate and pretty-print:: $ echo '{"json":"obj"}' | python -m simplejson.tool { "json": "obj" } $ echo '{ 1.2:3.4}' | python -m simplejson.tool Expecting property name: line 1 column 3 (char 2) Parsing multiple documents serialized as JSON lines (newline-delimited JSON):: >>> import simplejson as json >>> def loads_lines(docs): ... for doc in docs.splitlines(): ... yield json.loads(doc) ... >>> sum(doc["count"] for doc in loads_lines('{"count":1}\n{"count":2}\n{"count":3}\n')) 6 Serializing multiple objects to JSON lines (newline-delimited JSON):: >>> import simplejson as json >>> def dumps_lines(objs): ... for obj in objs: ... yield json.dumps(obj, separators=(',',':')) + '\n' ... >>> ''.join(dumps_lines([{'count': 1}, {'count': 2}, {'count': 3}])) '{"count":1}\n{"count":2}\n{"count":3}\n' ## PACKAGE CONTENTS _speedups compat decoder encoder errors ordered_dict raw_json scanner tests (package) tool ## CLASSES builtins.ValueError(builtins.Exception) simplejson.errors.JSONDecodeError builtins.dict(builtins.object) collections.OrderedDict builtins.object simplejson.decoder.JSONDecoder simplejson.encoder.JSONEncoder simplejson.raw_json.RawJSON ### class JSONDecodeError | JSONDecodeError(msg, doc, pos, end=None) | | Subclass of ValueError with the following additional properties: | | msg: The unformatted error message | doc: The JSON document being parsed | pos: The start index of doc where parsing failed | end: The end index of doc where parsing failed (may be None) | lineno: The line corresponding to pos | colno: The column corresponding to pos | endlineno: The line corresponding to end (may be None) | endcolno: The column corresponding to end (may be None) | | Method resolution order: | JSONDecodeError | builtins.ValueError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, msg, doc, pos, end=None) | Initialize self. See help(type(self)) for accurate signature. | | __reduce__(self) | Helper for pickle. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Static methods inherited from builtins.ValueError: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __getattribute__(self, name, /) | Return getattr(self, name). | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args ### class JSONDecoder | JSONDecoder(encoding=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None) | | Simple JSON <> decoder | | Performs the following translations in decoding by default: | | +---------------+-------------------+ | | JSON | Python | | +===============+===================+ | | object | dict | | +---------------+-------------------+ | | array | list | | +---------------+-------------------+ | | string | str, unicode | | +---------------+-------------------+ | | number (int) | int, long | | +---------------+-------------------+ | | number (real) | float | | +---------------+-------------------+ | | true | True | | +---------------+-------------------+ | | false | False | | +---------------+-------------------+ | | null | None | | +---------------+-------------------+ | | It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as | their corresponding ``float`` values, which is outside the JSON spec. | | Methods defined here: | | __init__(self, encoding=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None) | *encoding* determines the encoding used to interpret any | :class:`str` objects decoded by this instance (``'utf-8'`` by | default). It has no effect when decoding :class:`unicode` objects. | | Note that currently only encodings that are a superset of ASCII work, | strings of other encodings should be passed in as :class:`unicode`. | | *object_hook*, if specified, will be called with the result of every | JSON object decoded and its return value will be used in place of the | given :class:`dict`. This can be used to provide custom | deserializations (e.g. to support JSON-RPC class hinting). | | *object_pairs_hook* is an optional function that will be called with | the result of any object literal decode with an ordered list of pairs. | The return value of *object_pairs_hook* will be used instead of the | :class:`dict`. This feature can be used to implement custom decoders | that rely on the order that the key and value pairs are decoded (for | example, :func:`collections.OrderedDict` will remember the order of | insertion). If *object_hook* is also defined, the *object_pairs_hook* | takes priority. | | *parse_float*, if specified, will be called with the string of every | JSON float to be decoded. By default, this is equivalent to | ``[float(num_str)](https://www.chedong.com/phpMan.php/man/float/numstr/markdown)``. This can be used to use another datatype or parser | for JSON floats (e.g. :class:`decimal.Decimal`). | | *parse_int*, if specified, will be called with the string of every | JSON int to be decoded. By default, this is equivalent to | ``[int(num_str)](https://www.chedong.com/phpMan.php/man/int/numstr/markdown)``. This can be used to use another datatype or parser | for JSON integers (e.g. :class:`float`). | | *parse_constant*, if specified, will be called with one of the | following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This | can be used to raise an exception if invalid JSON numbers are | encountered. | | *strict* controls the parser's behavior when it encounters an | invalid control character in a string. The default setting of | ``True`` means that unescaped control characters are parse errors, if | ``False`` then control characters will be allowed in strings. | | decode(self, s, _w=, _PY3=True) | Return the Python representation of ``s`` (a ``str`` or ``unicode`` | instance containing a JSON document) | | raw_decode(self, s, idx=0, _w=, _PY3=True) | Decode a JSON document from ``s`` (a ``str`` or ``unicode`` | beginning with a JSON document) and return a 2-tuple of the Python | representation and the index in ``s`` where the document ended. | Optionally, ``idx`` can be used to specify an offset in ``s`` where | the JSON document begins. | | This can be used to decode a JSON document from a string that may | have extraneous data at the end. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) ### class JSONEncoder | JSONEncoder(skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, encoding='utf-8', default=None, use_decimal=True, namedtuple_as_object=True, tuple_as_array=True, bigint_as_string=False, item_sort_key=None, for_json=False, ignore_nan=False, int_as_string_bitcount=None, iterable_as_array=False) | | Extensible JSON <> encoder for Python data structures. | | Supports the following objects and types by default: | | +-------------------+---------------+ | | Python | JSON | | +===================+===============+ | | dict, namedtuple | object | | +-------------------+---------------+ | | list, tuple | array | | +-------------------+---------------+ | | str, unicode | string | | +-------------------+---------------+ | | int, long, float | number | | +-------------------+---------------+ | | True | true | | +-------------------+---------------+ | | False | false | | +-------------------+---------------+ | | None | null | | +-------------------+---------------+ | | To extend this to recognize other objects, subclass and implement a | ``.default()`` method with another method that returns a serializable | object for ``o`` if possible, otherwise it should call the superclass | implementation (to raise ``TypeError``). | | Methods defined here: | | __init__(self, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, encoding='utf-8', default=None, use_decimal=True, namedtuple_as_object=True, tuple_as_array=True, bigint_as_string=False, item_sort_key=None, for_json=False, ignore_nan=False, int_as_string_bitcount=None, iterable_as_array=False) | Constructor for JSONEncoder, with sensible defaults. | | If skipkeys is false, then it is a TypeError to attempt | encoding of keys that are not str, int, long, float or None. If | skipkeys is True, such items are simply skipped. | | If ensure_ascii is true, the output is guaranteed to be str | objects with all incoming unicode characters escaped. If | ensure_ascii is false, the output will be unicode object. | | If check_circular is true, then lists, dicts, and custom encoded | objects will be checked for circular references during encoding to | prevent an infinite recursion (which would cause an OverflowError). | Otherwise, no such check takes place. | | If allow_nan is true, then NaN, Infinity, and -Infinity will be | encoded as such. This behavior is not JSON specification compliant, | but is consistent with most JavaScript based encoders and decoders. | Otherwise, it will be a ValueError to encode such floats. | | If sort_keys is true, then the output of dictionaries will be | sorted by key; this is useful for regression tests to ensure | that JSON serializations can be compared on a day-to-day basis. | | If indent is a string, then JSON array elements and object members | will be pretty-printed with a newline followed by that string repeated | for each level of nesting. ``None`` (the default) selects the most compact | representation without any newlines. For backwards compatibility with | versions of simplejson earlier than 2.1.0, an integer is also accepted | and is converted to a string with that many spaces. | | If specified, separators should be an (item_separator, key_separator) | tuple. The default is (', ', ': ') if *indent* is ``None`` and | (',', ': ') otherwise. To get the most compact JSON representation, | you should specify (',', ':') to eliminate whitespace. | | If specified, default is a function that gets called for objects | that can't otherwise be serialized. It should return a JSON encodable | version of the object or raise a ``TypeError``. | | If encoding is not None, then all input strings will be | transformed into unicode using that encoding prior to JSON-encoding. | The default is UTF-8. | | If use_decimal is true (default: ``True``), ``decimal.Decimal`` will | be supported directly by the encoder. For the inverse, decode JSON | with ``parse_float=decimal.Decimal``. | | If namedtuple_as_object is true (the default), objects with | ``_asdict()`` methods will be encoded as JSON objects. | | If tuple_as_array is true (the default), tuple (and subclasses) will | be encoded as JSON arrays. | | If *iterable_as_array* is true (default: ``False``), | any object not in the above table that implements ``__iter__()`` | will be encoded as a JSON array. | | If bigint_as_string is true (not the default), ints 2**53 and higher | or lower than -2**53 will be encoded as strings. This is to avoid the | rounding that happens in Javascript otherwise. | | If int_as_string_bitcount is a positive number (n), then int of size | greater than or equal to 2**n or lower than or equal to -2**n will be | encoded as strings. | | If specified, item_sort_key is a callable used to sort the items in | each dictionary. This is useful if you want to sort items other than | in alphabetical order by key. | | If for_json is true (not the default), objects with a ``for_json()`` | method will use the return value of that method for encoding as JSON | instead of the object. | | If *ignore_nan* is true (default: ``False``), then out of range | :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized | as ``null`` in compliance with the ECMA-262 specification. If true, | this will override *allow_nan*. | | default(self, o) | Implement this method in a subclass such that it returns | a serializable object for ``o``, or calls the base implementation | (to raise a ``TypeError``). | | For example, to support arbitrary iterators, you could | implement default like this:: | | def default(self, o): | try: | iterable = iter(o) | except TypeError: | pass | else: | return list(iterable) | return JSONEncoder.default(self, o) | | encode(self, o) | Return a JSON string representation of a Python data structure. | | >>> from simplejson import JSONEncoder | >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) | '{"foo": ["bar", "baz"]}' | | iterencode(self, o, _one_shot=False) | Encode the given object and yield each string | representation as available. | | For example:: | | for chunk in JSONEncoder().iterencode(bigobject): | mysocket.write(chunk) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | item_separator = ', ' | | key_separator = ': ' ### class OrderedDict | Dictionary that remembers insertion order | | Method resolution order: | OrderedDict | builtins.dict | builtins.object | | Methods defined here: | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __ior__(self, value, /) | Return self|=value. | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self reversed(od) | | __ror__(self, value, /) | Return value|self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __sizeof__(...) | D.__sizeof__() -> size of D in memory, in bytes | | clear(...) | od.clear() -> None. Remove all items from od. | | copy(...) | od.copy() -> a shallow copy of od | | items(...) | D.items() -> a set-like object providing a view on D's items | | keys(...) | D.keys() -> a set-like object providing a view on D's keys | | move_to_end(self, /, key, last=True) | Move an existing element to the end (or beginning if last is false). | | Raise KeyError if the element does not exist. | | pop(...) | od.pop(key[,default]) -> v, remove specified key and return the corresponding value. | | If the key is not found, return the default if given; otherwise, | raise a KeyError. | | popitem(self, /, last=True) | Remove and return a (key, value) pair from the dictionary. | | Pairs are returned in LIFO order if last is true or FIFO order if false. | | setdefault(self, /, key, default=None) | Insert key with a value of default if key is not in the dictionary. | | Return the value for key if key is in the dictionary, else default. | | update(...) | D.update([E, ]**F) -> None. Update D from dict/iterable E and F. | If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] | If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v | In either case, this is followed by: for k in F: D[k] = F[k] | | values(...) | D.values() -> an object providing a view on D's values | | ---------------------------------------------------------------------- | Class methods defined here: | | fromkeys(iterable, value=None) from builtins.type | Create a new ordered dictionary with keys from iterable and values set to value. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None | | ---------------------------------------------------------------------- | Methods inherited from builtins.dict: | | __contains__(self, key, /) | True if the dictionary has the specified key, else False. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __len__(self, /) | Return len(self). | | get(self, key, default=None, /) | Return the value for key if key is in the dictionary, else default. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.dict: | | __class_getitem__(...) from builtins.type | See PEP 585 | | ---------------------------------------------------------------------- | Static methods inherited from builtins.dict: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. ### class RawJSON | RawJSON(encoded_json) | | Wrap an encoded JSON document for direct embedding in the output | | Methods defined here: | | __init__(self, encoded_json) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) ## FUNCTIONS ### dump Serialize ``obj`` as a JSON formatted stream to ``fp`` (a ``.write()``-supporting file-like object). If *skipkeys* is true then ``dict`` keys that are not basic types (``str``, ``int``, ``long``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If *ensure_ascii* is false (default: ``True``), then the output may contain non-ASCII characters, so long as they do not need to be escaped by JSON. When it is true, all non-ASCII characters are escaped. If *allow_nan* is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the original JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). See *ignore_nan* for ECMA-262 compliant behavior. If *indent* is a string, then JSON array elements and object members will be pretty-printed with a newline followed by that string repeated for each level of nesting. ``None`` (the default) selects the most compact representation without any newlines. If specified, *separators* should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. *encoding* is the character encoding for str instances, default is UTF-8. *default(obj)* is a function that should return a serializable version of obj or raise ``TypeError``. The default simply raises ``TypeError``. If *use_decimal* is true (default: ``True``) then decimal.Decimal will be natively serialized to JSON with full precision. If *namedtuple_as_object* is true (default: ``True``), :class:`tuple` subclasses with ``_asdict()`` methods will be encoded as JSON objects. If *tuple_as_array* is true (default: ``True``), :class:`tuple` (and subclasses) will be encoded as JSON arrays. If *iterable_as_array* is true (default: ``False``), any object not in the above table that implements ``__iter__()`` will be encoded as a JSON array. If *bigint_as_string* is true (default: ``False``), ints 2**53 and higher or lower than -2**53 will be encoded as strings. This is to avoid the rounding that happens in Javascript otherwise. Note that this is still a lossy operation that will not round-trip correctly and should be used sparingly. If *int_as_string_bitcount* is a positive number (n), then int of size greater than or equal to 2**n or lower than or equal to -2**n will be encoded as strings. If specified, *item_sort_key* is a callable used to sort the items in each dictionary. This is useful if you want to sort items other than in alphabetical order by key. This option takes precedence over *sort_keys*. If *sort_keys* is true (default: ``False``), the output of dictionaries will be sorted by item. If *for_json* is true (default: ``False``), objects with a ``for_json()`` method will use the return value of that method for encoding as JSON instead of the object. If *ignore_nan* is true (default: ``False``), then out of range :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized as ``null`` in compliance with the ECMA-262 specification. If true, this will override *allow_nan*. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg. NOTE: You should use *default* or *for_json* instead of subclassing whenever possible. ### dumps Serialize ``obj`` to a JSON formatted ``str``. If ``skipkeys`` is false then ``dict`` keys that are not basic types (``str``, ``int``, ``long``, ``float``, ``bool``, ``None``) will be skipped instead of raising a ``TypeError``. If *ensure_ascii* is false (default: ``True``), then the output may contain non-ASCII characters, so long as they do not need to be escaped by JSON. When it is true, all non-ASCII characters are escaped. If ``check_circular`` is false, then the circular reference check for container types will be skipped and a circular reference will result in an ``OverflowError`` (or worse). If ``allow_nan`` is false, then it will be a ``ValueError`` to serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``). If ``indent`` is a string, then JSON array elements and object members will be pretty-printed with a newline followed by that string repeated for each level of nesting. ``None`` (the default) selects the most compact representation without any newlines. For backwards compatibility with versions of simplejson earlier than 2.1.0, an integer is also accepted and is converted to a string with that many spaces. If specified, ``separators`` should be an ``(item_separator, key_separator)`` tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', ': ')`` otherwise. To get the most compact JSON representation, you should specify ``(',', ':')`` to eliminate whitespace. ``encoding`` is the character encoding for bytes instances, default is UTF-8. ``default(obj)`` is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. If *use_decimal* is true (default: ``True``) then decimal.Decimal will be natively serialized to JSON with full precision. If *namedtuple_as_object* is true (default: ``True``), :class:`tuple` subclasses with ``_asdict()`` methods will be encoded as JSON objects. If *tuple_as_array* is true (default: ``True``), :class:`tuple` (and subclasses) will be encoded as JSON arrays. If *iterable_as_array* is true (default: ``False``), any object not in the above table that implements ``__iter__()`` will be encoded as a JSON array. If *bigint_as_string* is true (not the default), ints 2**53 and higher or lower than -2**53 will be encoded as strings. This is to avoid the rounding that happens in Javascript otherwise. If *int_as_string_bitcount* is a positive number (n), then int of size greater than or equal to 2**n or lower than or equal to -2**n will be encoded as strings. If specified, *item_sort_key* is a callable used to sort the items in each dictionary. This is useful if you want to sort items other than in alphabetical order by key. This option takes precedence over *sort_keys*. If *sort_keys* is true (default: ``False``), the output of dictionaries will be sorted by item. If *for_json* is true (default: ``False``), objects with a ``for_json()`` method will use the return value of that method for encoding as JSON instead of the object. If *ignore_nan* is true (default: ``False``), then out of range :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized as ``null`` in compliance with the ECMA-262 specification. If true, this will override *allow_nan*. To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the ``.default()`` method to serialize additional types), specify it with the ``cls`` kwarg. NOTE: You should use *default* instead of subclassing whenever possible. ### load Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document as `str` or `bytes`) to a Python object. *encoding* determines the encoding used to interpret any `bytes` objects decoded by this instance (``'utf-8'`` by default). It has no effect when decoding `str` objects. *object_hook*, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given :class:`dict`. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). *object_pairs_hook* is an optional function that will be called with the result of any object literal decode with an ordered list of pairs. The return value of *object_pairs_hook* will be used instead of the :class:`dict`. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, :func:`collections.OrderedDict` will remember the order of insertion). If *object_hook* is also defined, the *object_pairs_hook* takes priority. *parse_float*, if specified, will be called with the string of every JSON float to be decoded. By default, this is equivalent to ``[float(num_str)](https://www.chedong.com/phpMan.php/man/float/numstr/markdown)``. This can be used to use another datatype or parser for JSON floats (e.g. :class:`decimal.Decimal`). *parse_int*, if specified, will be called with the string of every JSON int to be decoded. By default, this is equivalent to ``[int(num_str)](https://www.chedong.com/phpMan.php/man/int/numstr/markdown)``. This can be used to use another datatype or parser for JSON integers (e.g. :class:`float`). *parse_constant*, if specified, will be called with one of the following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This can be used to raise an exception if invalid JSON numbers are encountered. If *use_decimal* is true (default: ``False``) then it implies parse_float=decimal.Decimal for parity with ``dump``. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg. NOTE: You should use *object_hook* or *object_pairs_hook* instead of subclassing whenever possible. ### loads Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON document) to a Python object. *encoding* determines the encoding used to interpret any :class:`bytes` objects decoded by this instance (``'utf-8'`` by default). It has no effect when decoding :class:`unicode` objects. *object_hook*, if specified, will be called with the result of every JSON object decoded and its return value will be used in place of the given :class:`dict`. This can be used to provide custom deserializations (e.g. to support JSON-RPC class hinting). *object_pairs_hook* is an optional function that will be called with the result of any object literal decode with an ordered list of pairs. The return value of *object_pairs_hook* will be used instead of the :class:`dict`. This feature can be used to implement custom decoders that rely on the order that the key and value pairs are decoded (for example, :func:`collections.OrderedDict` will remember the order of insertion). If *object_hook* is also defined, the *object_pairs_hook* takes priority. *parse_float*, if specified, will be called with the string of every JSON float to be decoded. By default, this is equivalent to ``[float(num_str)](https://www.chedong.com/phpMan.php/man/float/numstr/markdown)``. This can be used to use another datatype or parser for JSON floats (e.g. :class:`decimal.Decimal`). *parse_int*, if specified, will be called with the string of every JSON int to be decoded. By default, this is equivalent to ``[int(num_str)](https://www.chedong.com/phpMan.php/man/int/numstr/markdown)``. This can be used to use another datatype or parser for JSON integers (e.g. :class:`float`). *parse_constant*, if specified, will be called with one of the following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This can be used to raise an exception if invalid JSON numbers are encountered. If *use_decimal* is true (default: ``False``) then it implies parse_float=decimal.Decimal for parity with ``dump``. To use a custom ``JSONDecoder`` subclass, specify it with the ``cls`` kwarg. NOTE: You should use *object_hook* or *object_pairs_hook* instead of subclassing whenever possible. ### simple_first Helper function to pass to item_sort_key to sort simple elements to the top, then container elements. ## DATA __all__ = ['dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecod... ## VERSION 3.17.6 ## AUTHOR Bob Ippolito <> ## FILE /usr/lib/python3/dist-packages/simplejson/__init__.py