json.dumps()：如何用单个反斜杠转义双引号

Question

when I use json.dumps(), I get the following output:

>>> json.dumps("abc")
'"abc"'

This results in unescaped double quotes. Is there a way to always have one backslash, something like:

>>> json.dumps("abc", additional_param=?)
'\"abc\"'

Answer 1

Not sure if this is exactly what you want, but it might be:

import json

print(json.dumps("abc").replace(r'\"', '"').replace('"', r'\"'))

Result:

\"abc\"

Answer 2

It sounds like what you're asking for is double-encoded JSON.

print(json.dumps(json.dumps("abc")))

...results in:

"\"abc\""

---

By contrast, single-encoding (without the REPL's implicit repr() ) looks like:

print(json.dumps("abc"))

...and emits the correctly-encoded JSON document :

"abc"

Note that this is correct JSON exactly as it is; no backslashes are needed.

Answer 3

No direct options are available for the json.dumps function. You have to use some python tricks to do that. Here is the prof, Docstring of json.dumps method.

def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):
    """Serialize ``obj`` to a JSON formatted ``str``.

    If ``skipkeys`` is true then ``dict`` keys that are not basic types
    (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
    instead of raising a ``TypeError``.

    If ``ensure_ascii`` is false, then the return value can contain non-ASCII
    characters if they appear in strings contained in ``obj``. Otherwise, all
    such characters are escaped in JSON strings.

    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 non-negative integer, then JSON array elements and
    object members will be pretty-printed with that indent level. An indent
    level of 0 will only insert newlines. ``None`` is the most compact
    representation.

    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.

    ``default(obj)`` is a function that should return a serializable version
    of obj or raise TypeError. The default simply raises TypeError.

    If *sort_keys* is true (default: ``False``), then the output of
    dictionaries will be sorted by key.

    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
    ``.default()`` method to serialize additional types), specify it with
    the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.

    """

You can get the dcostring by help(json.dumps) or print(json.dumps.__doc__)