"json" --- JSON エンコーダーとデコーダー
****************************************

**ソースコード:** Lib/json/__init__.py

======================================================================

JSON (JavaScript Object Notation) は、 **RFC 7159** (**RFC 4627** を
obsolete) と ECMA-404 によって定義された軽量のデータ交換用のフォーマッ
トです。 JavaScript のオブジェクトリテラル記法に由来しています
(JavaScript の厳密なサブセットではありませんが [1])。

注釈:

  Python で JSON を処理する文脈では、「オブジェクト」という用語は曖昧
  になることがあります。 Python ではすべての値がオブジェクトです。
  JSON では、Python の辞書に似た、波括弧で囲まれたデータをオブジェクト
  と呼びます。

警告:

  信頼されていないソースからの JSON データをパースするときは十分注意し
  てください。悪意を持った JSON 文字列はデコーダに著しい量の CPU とメ
  モリリソースを消費させる可能性があります。パースするデータ量を制限す
  ることを推奨します。

このモジュールの API は標準ライブラリの "marshal" や "pickle" のユーザ
に馴染み深いものです。

基本的な Python オブジェクト階層のエンコーディング:

   >>> import 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('\u1234'))
   "\u1234"
   >>> print(json.dumps('\\'))
   "\\"
   >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
   {"a": 0, "b": 0, "c": 0}
   >>> from io import StringIO
   >>> io = StringIO()
   >>> json.dump(['streaming API'], io)
   >>> io.getvalue()
   '["streaming API"]'

コンパクトなエンコーディング:

   >>> import json
   >>> json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':'))
   '[1,2,3,{"4":5,"6":7}]'

見やすい表示:

   >>> import json
   >>> print(json.dumps({'6': 7, '4': 5}, sort_keys=True, indent=4))
   {
       "4": 5,
       "6": 7
   }

JSON オブジェクトのエンコーディング方法をカスタマイズする:

   >>> import json
   >>> def custom_json(obj):
   ...     if isinstance(obj, complex):
   ...         return {'__complex__': True, 'real': obj.real, 'imag': obj.imag}
   ...     raise TypeError(f'Cannot serialize object of {type(obj)}')
   ...
   >>> json.dumps(1 + 2j, default=custom_json)
   '{"__complex__": true, "real": 1.0, "imag": 2.0}'

JSON のデコーディング:

   >>> import json
   >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
   ['foo', {'bar': ['baz', None, 1.0, 2]}]
   >>> json.loads('"\\"foo\\bar"')
   '"foo\x08ar'
   >>> from io import StringIO
   >>> io = StringIO('["streaming API"]')
   >>> json.load(io)
   ['streaming API']

JSON オブジェクトのデコーディング方法をカスタマイズする:

   >>> import 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)
   >>> import decimal
   >>> json.loads('1.1', parse_float=decimal.Decimal)
   Decimal('1.1')
   >>> json.loads('{"name": "point", "coords": [[1, 2], [3, 4]]}',
   ...     array_hook=tuple)
   {'name': 'point', 'coords': ((1, 2), (3, 4))}
   >>> json.loads('{"name": "point", "coords": [1, 2]}',
   ...     object_pairs_hook=frozendict, array_hook=tuple)
   frozendict({'name': 'point', 'coords': (1, 2)})

"JSONEncoder" の拡張:

   >>> import json
   >>> class ComplexEncoder(json.JSONEncoder):
   ...     def default(self, obj):
   ...         if isinstance(obj, complex):
   ...             return [obj.real, obj.imag]
   ...         # 基底クラスの default メソッドで TypeError を送出する
   ...         return super().default(obj)
   ...
   >>> json.dumps(2 + 1j, cls=ComplexEncoder)
   '[2.0, 1.0]'
   >>> ComplexEncoder().encode(2 + 1j)
   '[2.0, 1.0]'
   >>> list(ComplexEncoder().iterencode(2 + 1j))
   ['[2.0', ', 1.0', ']']

シェルから "json" を使って検証し、見やすく表示する例:

   $ echo '{"json":"obj"}' | python -m json
   {
       "json": "obj"
   }
   $ echo '{1.2:3.4}' | python -m json
   Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

詳細については コマンドライン・インターフェース を参照してください。

注釈:

  JSON は YAML 1.2 のサブセットです。 このモジュールのデフォルト設定 (
  特に、デフォルトの *separators* 値) で生成される JSON は YAML 1.0 お
  よび 1.1 のサブセットでもあります。 このモジュールは YAML シリアライ
  ザとしても使えます。

注釈:

  このモジュールのエンコーダとデコーダは、デフォルトで入力順と出力順を
  保つようになっています。根底のコンテナに順序がない場合のみ、順序が失
  われます。


基本的な使い方
==============

json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

   この PythonからJSONへの変換表 を使って、 *obj* を JSON 形式の *fp*
   (".write()" がサポートされている *file-like object*) へのストリーム
   として直列化します。

   注釈:

     "pickle" や "marshal" とは異なり JSON はフレーム付きのプロトコル
     ではないので、同じ *fp* に対し繰り返し "dump()" を呼び、複数のオ
     ブジェクトを直列化しようとすると、不正な JSON ファイルが作られて
     しまいます。

   パラメータ:
      * **obj** (*object*) -- 直列化する Python オブジェクト。

      * **fp** (*file-like object*) -- *obj* の直列化結果を書き込むフ
        ァイルライクオブジェクト。 "json" モジュールは常に "bytes" で
        はなく "str" オブジェクトを生成するため、"fp.write()" は "str"
        入力をサポートしていなければなりません。

      * **skipkeys** (*bool*) -- "True" の場合、基本型 ("str"、"int"、
        "float"、"bool"、"None") 以外のキーは、"TypeError" を送出せず
        にスキップします。 デフォルトは "False" です。

      * **ensure_ascii** (*bool*) -- "True" (デフォルト) の場合、入力
        に含まれる非 ASCII 文字と表示不可能な文字はすべてエスケープし
        て出力されます。 "False" の場合、エスケープが必須の文字 (引用
        符、バックスラッシュ、U+0000 から U+001F の制御文字) を除き、
        すべての文字をそのまま出力します。

      * **check_circular** (*bool*) -- "False" の場合、コンテナ型の循
        環参照の検査を省略します。 循環参照があると "RecursionError" (
        またはそれ以上に悪い結果) を引き起こします。 デフォルトは
        "True" です。

      * **allow_nan** (*bool*) -- "False" の場合、JSON の仕様に厳密に
        従い、範囲外の "float" 値 ("nan"、"inf"、"-inf") を直列化する
        と "ValueError" を送出します。 "True" (デフォルト) の場合、対
        応する JavaScript の値 ("NaN"、"Infinity"、"-Infinity") を使用
        します。

      * **cls** (a "JSONEncoder" subclass) -- If set, a custom JSON
        encoder with the "default()" method overridden, for
        serializing into custom datatypes. If "None" (the default),
        "JSONEncoder" is used.

      * **indent** (*int** | **str** | **None*) -- 正の整数または文字
        列を指定すると、そのインデントで JSON の配列要素とオブジェクト
        のメンバーを見やすく表示します。 正の整数の場合は、各階層をそ
        の数のスペースでインデントします。 文字列 (""\t"" など) の場合
        は、その文字列で各階層をインデントします。 0、負の値、または
        """" (空文字列) の場合は、改行のみを挿入します。 "None" (デフ
        ォルト) の場合、改行は挿入しません。

      * **separators** (*tuple** | **None*) -- "(item_separator,
        key_separator)" という 2 要素のタプル。 "None" (デフォルト) の
        場合、*separators* には、*indent* が "None" なら "(', ', ':
        ')"、それ以外なら "(',', ': ')" を使用します。 最もコンパクト
        な JSON にするには、"(',', ':')" を指定して空白を除いてくださ
        い。

      * **default** (*callable* | None) -- そのままでは直列化できない
        オブジェクトに対して呼び出される関数。 オブジェクトを JSON で
        エンコード可能な形で返すか、"TypeError" を送出する必要がありま
        す。 "None" (デフォルト) の場合、"TypeError" を送出します。

      * **sort_keys** (*bool*) -- "True" の場合、辞書をキーでソートし
        て出力します。 デフォルトは "False" です。

   注釈:

     JSON のキーと値のペアでは、キーの型は常に "str" です。 辞書を
     JSON に変換すると、すべてのキーが文字列に変換されます。 そのため
     、辞書を JSON に変換してから辞書に戻すと、元の辞書と等しくならな
     い場合があります。 つまり、"x" に文字列以外のキーが含まれる場合、
     "loads(dumps(x)) != x" となります。 *sort_keys* は文字列への変換
     前にキーをソートするため、数値のキーは文字列表現ではなく値の順に
     並びます。

   バージョン 3.2 で変更: 整数に加えて、文字列が *indent* に使用できる
   ようになりました。

   バージョン 3.4 で変更: *indent* が "None" でなければ "(',', ': ')"
   がデフォルトで使われます。

   バージョン 3.6 で変更: すべてのオプション引数は、 キーワード専用 に
   なりました。

json.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)

   この 変換表 を使って、*obj* を JSON 形式の "str" オブジェクトに直列
   化します。引数は "dump()" と同じ意味です。

json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, array_hook=None, **kw)

   JSON から Python への変換表 に従って、*fp* を Python オブジェクトに
   脱直列化します。

   パラメータ:
      * **fp** (*file-like object*) -- 脱直列化する JSON ドキュメント
        を含み、".read()" をサポートする *テキストファイル* または *バ
        イナリファイル*。

      * **cls** (a "JSONDecoder" subclass) -- 指定する場合は、カスタム
        の JSON デコーダ。 "load()" に渡された追加のキーワード引数は、
        *cls* のコンストラクタに渡されます。 "None" (デフォルト) の場
        合、"JSONDecoder" を使用します。

      * **object_hook** (*callable* | None) -- 指定する場合は、JSON オ
        ブジェクトリテラルのデコード結果 ("dict") ごとに、その結果を引
        数として呼び出される関数。 "dict" の代わりに、この関数の戻り値
        を使用します。 この機能で、例えば JSON-RPC のクラスヒントなど
        、カスタムのデコーダを実装できます。 デフォルトは "None" です
        。

      * **object_pairs_hook** (*callable* | None) -- 指定する場合は、
        JSON オブジェクトリテラルをデコードした、ペアの順序付きリスト
        を引数として呼び出される関数。 "dict" の代わりに、この関数の戻
        り値を使用します。 この機能でカスタムのデコーダを実装できます
        。 *object_hook* も指定されている場合は、*object_pairs_hook*
        が優先されます。 デフォルトは "None" です。

      * **array_hook** (*callable* | None) -- 指定する場合は、JSON 配
        列リテラルを Python のリストにデコードした結果を引数として呼び
        出される関数。 "list" の代わりに、この関数の戻り値を使用します
        。 この機能でカスタムのデコーダを実装できます。 デフォルトは
        "None" です。

      * **parse_float** (*callable* | None) -- 指定する場合は、デコー
        ドする JSON の浮動小数点数ごとに、その文字列を引数として呼び出
        される関数。 "None" (デフォルト) の場合、"float(num_str)" と同
        等です。 この機能で、JSON の浮動小数点数を "decimal.Decimal"
        などのカスタムデータ型に変換できます。

      * **parse_int** (*callable* | None) -- 指定する場合は、デコード
        する JSON の整数ごとに、その文字列を引数として呼び出される関数
        。 "None" (デフォルト) の場合、"int(num_str)" と同等です。 こ
        の機能で、JSON の整数を "float" などのカスタムデータ型に変換で
        きます。

      * **parse_constant** (*callable* | None) -- 指定する場合は、
        "'-Infinity'"、"'Infinity'"、"'NaN'" のいずれかの文字列を引数
        として呼び出される関数。 JSON として無効な数値が現れた場合に例
        外を送出するために使用できます。 デフォルトは "None" です。

   例外:
      * **JSONDecodeError** -- 脱直列化するデータが有効な JSON ドキュ
        メントでない場合。

      * **UnicodeDecodeError** -- 脱直列化するデータが UTF-8、UTF-16、
        UTF-32 のいずれでもエンコードされていない場合。

   バージョン 3.1 で変更:

   * 省略可能な *object_pairs_hook* 引数を追加しました。

   * 'null', 'true', 'false' に対して *parse_constant* は呼びされませ
     ん。

   バージョン 3.6 で変更:

   * すべてのオプション引数は、 キーワード専用 になりました。

   * *fp* には *binary file* 型も使えるようになりました。入力のエンコ
     ーディングは UTF-8, UTF-16, UTF-32 のいずれかでなければなりません
     。

   バージョン 3.11 で変更: デフォルトの *parse_int* である "int()" は
   、インタープリタの integer string conversion length limitation によ
   り整数文字列の最大長を制限するようになり、サービス拒否攻撃の回避に
   役立てます。

   バージョン 3.15 で変更: 省略可能な *array_hook* 引数を追加しました
   。

json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, array_hook=None, **kw)

   "load()" と同じですが、ファイルライクオブジェクトの代わりに、JSON
   ドキュメントを含む "str"、"bytes"、または "bytearray" のインスタン
   スである *s* を、変換表 に従って Python オブジェクトに脱直列化しま
   す。

   バージョン 3.6 で変更: *s* には "bytes"  型と "bytearray" 型も使え
   るようになりました。 入力エンコーディングは UTF-8, UTF-16, UTF-32
   のいずれかでなければなりません。

   バージョン 3.9 で変更: キーワード引数 *encoding* が削除されました。


エンコーダとデコーダ
====================

class json.JSONDecoder(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None, array_hook=None)

   単純な JSON デコーダ。

   デフォルトではデコーディングの際、以下の変換を行います:

   +-----------------+---------------------+
   | JSON            | Python              |
   |=================|=====================|
   | object          | dict                |
   +-----------------+---------------------+
   | array           | list                |
   +-----------------+---------------------+
   | string          | str                 |
   +-----------------+---------------------+
   | number (int)    | int                 |
   +-----------------+---------------------+
   | number (real)   | 浮動小数点数        |
   +-----------------+---------------------+
   | true            | True                |
   +-----------------+---------------------+
   | false           | False               |
   +-----------------+---------------------+
   | null            | None                |
   +-----------------+---------------------+

   また、このデコーダは "NaN", "Infinity", "-Infinity" を対応する
   "float" の値として、JSON の仕様からは外れますが、理解します。

   *object_hook* は省略可能な関数で、各 JSON オブジェクトのデコード結
   果を引数として呼び出されます。 元の "dict" の代わりに、その戻り値を
   使用します。 カスタムの脱直列化 (例えば JSON-RPC のクラスヒントのサ
   ポート) を提供するために使用できます。

   *object_pairs_hook* は省略可能な関数で、各 JSON オブジェクトをデコ
   ードした、ペアの順序付きリストを引数として呼び出されます。 "dict"
   の代わりに、*object_pairs_hook* の戻り値を使用します。 この機能でカ
   スタムのデコーダを実装できます。 *object_hook* も定義されている場合
   は、*object_pairs_hook* が優先されます。

   バージョン 3.1 で変更: *object_pairs_hook* のサポートが追加されまし
   た。

   *array_hook* は省略可能な関数で、各 JSON 配列をリストにデコードした
   結果を引数として呼び出されます。 "list" の代わりに、*array_hook* の
   戻り値を使用します。 この機能でカスタムのデコーダを実装できます。

   バージョン 3.15 で変更: *array_hook* のサポートを追加しました。

   *parse_float* は省略可能な関数で、デコードする JSON の浮動小数点数
   ごとに、その文字列を引数として呼び出されます。 デフォルトでは
   "float(num_str)" と同等です。 この機能で、JSON の浮動小数点数に別の
   データ型やパーサー (例えば "decimal.Decimal") を使用できます。

   *parse_int* は省略可能な関数で、デコードする JSON の整数ごとに、そ
   の文字列を引数として呼び出されます。 デフォルトでは "int(num_str)"
   と同等です。 この機能で、JSON の整数に別のデータ型やパーサー (例え
   ば "float") を使用できます。

   *parse_constant* は省略可能な関数で、"'-Infinity'"、"'Infinity'"、
   "'NaN'" のいずれかの文字列を引数として呼び出されます。 JSON として
   無効な数値が現れた場合に例外を送出するために使用できます。

   *strict* が false (デフォルトは "True") の場合、制御文字を文字列に
   含めることができます。ここで言う制御文字とは、"'\t'" (タブ)、"'\n'"
   、"'\r'"、"'\0'" を含む 0-31 の範囲のコードを持つ文字のことです。

   脱直列化しようとしているデータが不正な JSON ドキュメントだった場合
   、 "JSONDecodeError" が送出されます。

   バージョン 3.6 で変更: すべての引数は、 キーワード専用 になりました
   。

   decode(s)

      *s* ("str" インスタンスで JSON 文書を含むもの) の Python 表現を
      返します。

      不正な JSON ドキュメントが与えられた場合、 "JSONDecodeError" が
      送出されます。

   raw_decode(s)

      *s* ("str" インスタンスで JSON 文書で始まるもの) から JSON 文書
      をデコードし、Python 表現と *s* の文書の終わるところのインデック
      スからなる 2 要素のタプルを返します。

      このメソッドは後ろに余分なデータを従えた文字列から JSON 文書をデ
      コードするのに使えます。

class json.JSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

   Python データ構造に対する拡張可能な JSON エンコーダ。

   デフォルトでは以下のオブジェクトと型をサポートします:

   +------------------------------------------+-----------------+
   | Python                                   | JSON            |
   |==========================================|=================|
   | dict, frozendict                         | object          |
   +------------------------------------------+-----------------+
   | list, tuple                              | array           |
   +------------------------------------------+-----------------+
   | str                                      | string          |
   +------------------------------------------+-----------------+
   | int、float と int や float の派生列挙型  | number          |
   +------------------------------------------+-----------------+
   | True                                     | true            |
   +------------------------------------------+-----------------+
   | False                                    | false           |
   +------------------------------------------+-----------------+
   | None                                     | null            |
   +------------------------------------------+-----------------+

   バージョン 3.4 で変更: int と float の派生列挙型クラスの対応が追加
   されました。

   バージョン 3.15 で変更: "frozendict" のサポートを追加しました。

   他のオブジェクトも認識するように拡張するには、サブクラスを作って
   "default()" メソッドをオーバーライドします。 可能であれば "o" に対
   応する直列化可能なオブジェクトを返し、そうでなければスーパークラス
   の実装を呼び出して "TypeError" を送出します。

   *skipkeys* が偽 (デフォルト) の場合、"str"、"int"、"float"、"bool"
   、"None" 以外のキーをエンコードしようとすると "TypeError" を送出し
   ます。 *skipkeys* が真の場合、そのような項目は単にスキップします。

   *ensure_ascii* が真 (デフォルト) の場合、入力に含まれる非 ASCII 文
   字と表示不可能な文字はすべてエスケープして出力されます。
   *ensure_ascii* が偽の場合、エスケープが必須の文字 (引用符、バックス
   ラッシュ、U+0000 から U+001F の制御文字) を除き、すべての文字をその
   まま出力します。

   *check_circular* が true (デフォルト) ならば、リスト、辞書および自
   作でエンコードしたオブジェクトは循環参照がないかエンコード中にチェ
   ックされ、無限再帰 (これは "RecursionError" を引き起こします) を防
   止します。 "True" でない場合は、そういったチェックは施されません。

   *allow_nan* が true (デフォルト) ならば、 "NaN", "Infinity",
   "-Infinity" はそのままエンコードされます。この振る舞いは JSON 仕様
   に従っていませんが、大半の JavaScript ベースのエンコーダ、デコーダ
   と矛盾しません。 "True" でない場合は、そのような浮動小数点数をエン
   コードすると "ValueError" が送出されます。

   *sort_keys* が true (デフォルトは "False") ならば、辞書の出力がキー
   でソートされます。これは JSON の直列化がいつでも比較できるようにな
   るので回帰試験の際に便利です。

   *indent* が非負の整数または文字列であれば、JSON の配列要素とオブジ
   ェクトメンバはそのインデントレベルで見やすく表示されます。インデン
   トレベルが 0 か負数または """" であれば 改行だけが挿入されます。
   "None" (デフォルト) では最もコンパクトな表現が選択されます。正の数
   のindentはレベル毎に、指定した数のスペースでインデントします。もし
   *indent* が文字列 (""\t"" のような) であれば、その文字列が個々のレ
   ベルのインデントに使用されます。

   バージョン 3.2 で変更: 整数に加えて、文字列が *indent* に使用できる
   ようになりました。

   *separators* はもし指定するなら "(item_separator, key_separator)"
   というタプルでなければなりません。デフォルトは *indent* が "None"
   のとき "(', ', ': ')" で、そうでなければ "(',', ': ')" です。最もコ
   ンパクトな JSON の表現を得たければ空白を削った "(',', ':')" を指定
   すればいいでしょう。

   バージョン 3.4 で変更: *indent* が "None" でなければ "(',', ': ')"
   がデフォルトで使われます。

   *default* を指定する場合は関数を指定して、この関数はそれ以外では直
   列化できないオブジェクトに対して呼び出されます。 その関数は、オブジ
   ェクトを JSON でエンコードできるバージョンにして返すか、さもなけれ
   ば "TypeError" を送出しなければなりません。 指定しない場合は、
   "TypeError" が送出されます。

   バージョン 3.6 で変更: すべての引数は、 キーワード専用 になりました
   。

   default(o)

      このメソッドをサブクラスで実装する際には *o* に対して直列化可能
      なオブジェクトを返すか、基底クラスの実装を ("TypeError" を送出す
      るために) 呼び出すかします。

      例えば、任意のイテレータをサポートする場合、 "default()" をこの
      ように実装できます

         def default(self, o):
            try:
                iterable = iter(o)
            except TypeError:
                pass
            else:
                return list(iterable)
            # 基底クラスの default メソッドで TypeError を送出する
            return super().default(o)

   encode(o)

      Python データ構造 *o* の JSON 文字列表現を返します。たとえば:

         >>> json.JSONEncoder().encode({"foo": ["bar", "baz"]})
         '{"foo": ["bar", "baz"]}'

   iterencode(o)

      与えられたオブジェクト *o* をエンコードし、得られた文字列表現ご
      とに yield します。たとえば:

         for chunk in json.JSONEncoder().iterencode(bigobject):
             mysocket.write(chunk)


例外
====

exception json.JSONDecodeError(msg, doc, pos)

   "ValueError" のサブクラスで、以下の追加の属性を持ちます:

   msg

      フォーマットされていないエラーメッセージです。

   doc

      パース対象 JSON ドキュメントです。

   pos

      *doc* の、解析に失敗した開始インデクスです。

   lineno

      *pos* に対応する行です。

   colno

      *pos* に対応する列です。

   Added in version 3.5.


標準への準拠と互換性
====================

JSON 形式は **RFC 7159** と ECMA-404 で定義されています。 この節では、
このモジュールが RFC にどの程度準拠しているかを詳しく説明します。 話を
単純にするため、"JSONEncoder" と "JSONDecoder" のサブクラスや、明示的
に言及していない引数は考慮しません。

このモジュールは、JavaScript では正しいが JSON では不正ないくつかの拡
張が実装されているため、厳密な意味では RFC に準拠していません。特に:

* 無限および NaN の数値を受け付け、また出力します;

* あるオブジェクト内での同じ名前の繰り返しを受け付け、最後の名前と値の
  ペアの値のみを使用します。

この RFC は、RFC 準拠のパーサが RFC 準拠でない入力テキストを受け付ける
ことを許容しているので、このモジュールの脱直列化は技術的に言えば、デフ
ォルトの設定では RFC に準拠しています。


文字エンコーディング
--------------------

RFC は、UTF-8、UTF-16、UTF-32のいずれかでJSONを表現するように要求して
おり、UTF-8 が最大の互換性を確保するために推奨されるデフォルトです。

RFC では必須ではないものの許可されているとおり、このモジュールのシリア
ライザはデフォルトで *ensure_ascii=True* を設定し、結果の文字列に表示
可能な ASCII 文字しか含まれないように出力をエスケープします。

*ensure_ascii* パラメータ以外は、このモジュールは Python オブジェクト
と "Unicode 文字列" の間の変換において厳密に定義されていて、それ以外の
パラメータで文字エンコーディングに直接的に関わるものはありません。

RFC は JSON テキストの最初にバイトオーダマーク(BOM)を追加することを禁
止していますので、このモジュールはその出力に BOM を追加しません。RFC
は JSON デシリアライザが入力の一番最初の BOM を無視することを、許容は
しますが求めてはいません。このモジュールのデシリアライザは一番最初の
BOM を見つけると "ValueError" を送出します。

RFC は、有効な Unicode 文字に対応しないバイト列 (例えば対になっていな
い UTF-16 サロゲート) を JSON 文字列に含めることを明示的には禁止してい
ませんが、相互運用性の問題を引き起こす可能性があると指摘しています。
デフォルトでは、このモジュールはそのようなコードポイントを受け付け、元
の "str" に含まれていれば出力します。


無限および NaN の数値
---------------------

RFC は、無限もしくは NaN の数値の表現は許可していません。それにも関わ
らずデフォルトでは、このモジュールは "Infinity"、"-Infinity"、"NaN" を
正しい JSON の数値リテラルの値であるかのように受け付け、出力します:

   >>> # どちらの呼び出しも例外を送出しないが、結果は有効な JSON ではない
   >>> json.dumps(float('-inf'))
   '-Infinity'
   >>> json.dumps(float('nan'))
   'NaN'
   >>> # 脱直列化する場合も同じ
   >>> json.loads('-Infinity')
   -inf
   >>> json.loads('NaN')
   nan

シリアライザでは、この振る舞いを変更するのに *allow_nan* パラメータが
使えます。デシリアライザでは、この振る舞いを変更するのに
*parse_constant* パラメータが使えます。


オブジェクト中に重複した名前の扱い
----------------------------------

RFC は JSON オブジェクト中の名前はユニークでなければならないと規定して
いますが、JSONオブジェクトで名前が繰り返された場合の扱いについて指定し
ていません。 デフォルトでは、このモジュールは例外を送出せず、かわりに
重複した名前のうち、最後に出現した名前と値のペア以外を無視します。

   >>> weird_json = '{"x": 1, "x": 2, "x": 3}'
   >>> json.loads(weird_json)
   {'x': 3}

*object_pairs_hook* パラメータでこの動作を変更できます。


トップレベルの非オブジェクト、非配列の値の扱い
----------------------------------------------

廃止された **RFC 4627** によって規定された古いバージョンの JSON では、
JSON テキストのトップレベルの値は JSON オブジェクトか配列(Python での
"dict" か "list")であることを要求していて、JSON の null, boolean,
number, string であることは許されていませんでしたが、この制限は **RFC
7159** により取り払われました。このモジュールはこの制限を持っていませ
んし、シリアライザでもデシリアライズでも、一度としてこの制限で実装され
たことはありません。

それにも関わらず、相互運用可能性を最大化したいならば、あなた自身の手で
自発的にその制約に忠実に従いたいと思うでしょう。


実装の制限
----------

いくつかの JSON デシリアライザの実装は、以下の制限を設定することがあり
ます。

* 受け入れられる JSON テキストのサイズ

* JSON オブジェクトと配列のネストの最大の深さ

* JSON 数値の範囲と精度

* JSON 文字列の内容と最大の長さ

このモジュールは関連する Python データ型や Python インタプリタ自身の制
約の世界を超えたそのような制約を強要はしません。

JSON に直列化する際は、その JSON を読み込むアプリケーションが持つこれ
らの制限に注意してください。 特に、JSON の数値は IEEE 754 倍精度浮動小
数点数に復元されることが多く、その表現の値の範囲と精度の制限を受けます
。 これは、絶対値が極めて大きい Python の "int" 値や、
"decimal.Decimal" のような特殊な数値型のインスタンスを直列化する場合に
特に関係します。


コマンドライン・インターフェース
================================

**ソースコード:** Lib/json/tool.py

======================================================================

"json" モジュールは、"python -m json" でスクリプトとして実行し、JSON
オブジェクトを検証して見やすく表示できます。 このインターフェースは
"json.tool" サブモジュールが実装しています。

オプション引数の "infile" と "outfile" が指定されない場合、それぞれ
"sys.stdin" と "sys.stdout" が使用されます。

   $ echo '{"json": "obj"}' | python -m json
   {
       "json": "obj"
   }
   $ echo '{1.2:3.4}' | python -m json
   Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

バージョン 3.5 で変更: 出力が、入力と同じ順序になりました。辞書をキー
でアルファベット順に並べ替えた出力が欲しければ、 "--sort-keys" オプシ
ョンを使ってください。

バージョン 3.14 で変更: "json" モジュールを "python -m json" で直接実
行できるようになりました。 後方互換性のため、"python -m json.tool" で
の CLI の実行も引き続きサポートします。


コマンドラインオプション
------------------------

infile

   検証を行う、あるいは整形出力を行う JSON ファイルを指定します:

      $ python -m json mp_films.json
      [
          {
              "title": "And Now for Something Completely Different",
              "year": 1971
          },
          {
              "title": "Monty Python and the Holy Grail",
              "year": 1975
          }
      ]

   *infile* が指定されない場合、 "sys.stdin" から読み込みます。

outfile

   *infile* の出力を *outfile* に書き込みます。そうでない場合、
   "sys.stdout" に書き込みます。

--sort-keys

   辞書の出力を、キーのアルファベット順にソートします。

   Added in version 3.5.

--no-ensure-ascii

   非 ASCII 文字のエスケープを無効化します。より詳しくは
   "json.dumps()" を参照してください。

   Added in version 3.9.

--json-lines

   すべての入力行を個別のJSON オブジェクトとしてパースします。

   Added in version 3.8.

--indent, --tab, --no-indent, --compact

   空白文字の制御のための排他的なオプション。

   Added in version 3.9.

-h, --help

   ヘルプメッセージを出力します

-[ 脚注 ]-

[1] RFC 7159 正誤表 で述べられている通り、JSON は (ECMAScript Edition
    5.1 の) JavaScript とは逆に、 U+2028 (LINE SEPARATOR) と U+2029
    (PARAGRAPH SEPARATOR) が文字列内に含まれることを許容しています。
