UltraJSON is an ultra fast JSON encoder and decoder written in pure C with bindings for Python 2.5+ and 3.

For a more painless day to day C/C++ JSON decoder experience please checkout ujson4c, based on UltraJSON.

To install it just run Pip as usual:

$ pip install ujson

May be used as a drop in replacement for most other JSON parsers for Python:

>>> import ujson
>>> ujson.dumps([{"key": "value"}, 81, True])
'[{"key":"value"},81,true]'
>>> ujson.loads("""[{"key": "value"}, 81, true]""")
[{u'key': u'value'}, 81, True]

Used to enable special encoding of "unsafe" HTML characters into safer Unicode sequences. Default is false:

>>> ujson.dumps("<script>John&Doe", encode_html_chars=True)
'"\\u003cscript\\u003eJohn\\u0026Doe"'

Limits output to ASCII and escapes all extended characters above 127. Default is true. If your end format supports UTF-8 setting this option to false is highly recommended to save space:

>>> ujson.dumps(u"\xe5\xe4\xf6")
'"\\u00e5\\u00e4\\u00f6"'
>>> ujson.dumps(u"\xe5\xe4\xf6", ensure_ascii=False)
'"\xc3\xa5\xc3\xa4\xc3\xb6"'

Controls how many decimals to encode for double or decimal values. Default is 9:

>>> ujson.dumps(math.pi)
'3.1415926536'
>>> ujson.dumps(math.pi, double_precision=1)
'3.1'
>>> ujson.dumps(math.pi, double_precision=0)
'3'
>>> ujson.dumps(math.pi, double_precision=4)
'3.1416'

Controls whether forward slashes (/) are escaped. Default is True:

>>> ujson.dumps("http://esn.me")
'"http:\/\/esn.me"'
>>> ujson.dumps("http://esn.me", escape_forward_slashes=False)
'"http://esn.me"'

Controls whether indention ("pretty output") is enabled. Default is 0 (disabled):

>>> ujson.dumps({"foo": "bar"})
'{"foo":"bar"}'
>>> ujson.dumps({"foo": "bar"}, indent=4)
{
    "foo":"bar"
}

Allows to provide a custom function which is called for every encoded Python object.

The hook function semantics is similar to the standard JSONEncoder.default() method, but the pre_encode_hook() is called before any other serialization attempts, while the default() is called when all other options didn't work.

That allows to override already exsiting behavior and define custom serialization formats for things like dates. For example:

# Default behavior: datetime is converted to timestamp
>>> ujson.dumps({"a": "foo", "b": datetime.now()})
'{"a":"foo","b":1454523657}'

# Hook is involved: the datetime object is replaced with the .isoformat() string
>>> def hook(obj):
        return obj.isoformat() if hasattr(obj, 'isoformat') else obj

>>> ujson.dumps({"a": "foo", "b": datetime.now()}, pre_encode_hook=hook)
'{"a":"foo","b":"2016-02-03T18:21:55.351081"}'

The hook may be used to replace any object with any other arbitrary object before encoding it. However, it doesn't cancel all further encoding transformations. For example, if you return a datetime object from the hook instead of a string, it will be transformed to a timestamp.

pre_encode_primitive ---------------The boolean flag that indicates that pre_encode_hook() should also be called for Python objects that serialized to primitive JSON types (Number, String, Boolean, null).

Usually you don't need to define any special serialization format for these types, so the flag is false by default.

Enabling this flag may produce huge amount of pre_encode_hook() calls (the hook will be called for every single JSON value) and thus affect the performance.

Set to enable usage of higher precision (strtod) function when decoding string to double values. Default is to use fast but less precise builtin functionality:

>>> ujson.loads("4.56")
4.5600000000000005
>>> ujson.loads("4.56", precise_float=True)
4.5599999999999996

A custom Python function which is called after a JSON object is decoded.

The hook semantics is similar to the standard JSONDecoder.object_hook() behavior. You may use it to transform a dictionary (the decoded JSON object) into a more specific object.

For example:

>>> def hook(obj):
        if '__complex__' in obj:
            return complex(obj['real'], obj['imag'])
        return obj

>>> ujson.loads('{"__complex__": true, "real": 1, "imag": 2}', object_hook=hook)
(1+2j)

Similar to object_hook, but called for every decoded string.

Useful for deserializing objects like dates from their textual representations, e.g.:

>>> def hook(s):
        if s.startswith('__DATE'):
            return datetime.strptime(s, '__DATE: %Y-%m-%d')
        return s

>>> ujson.loads('{"a": "foo", "b": "__DATE: 2016-01-01"}', string_hook=hook)
{'a': 'foo', 'b': datetime.datetime(2016, 1, 1, 0, 0)}

Linux 3.13.0-66-generic x86_64 #108-Ubuntu SMP Wed Oct 7 15:20:27 UTC 2015

• CPython 2.7.6 (default, Jun 22 2015, 17:58:13) [GCC 4.8.2]
• blist : 1.3.6
• simplejson: 3.8.1
• ujson : 1.34 (0c52200eb4e2d97e548a765d5f089858c41967b0)
• yajl : 0.3.5

• CPython 3.4.3 (default, Oct 14 2015, 20:28:29) [GCC 4.8.4]
• blist : 1.3.6
• simplejson: 3.8.1
• ujson : 1.34 (0c52200eb4e2d97e548a765d5f089858c41967b0)
• yajl : 0.3.5