"json" --- Codificador e decodificador JSON
*******************************************

**Código-fonte:** Lib/json/__init__.py

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

JSON (JavaScript Object Notation), especificado pelo **RFC 7159** (que
tornou o **RFC 4627** obsoleta) e pelo ECMA-404, é um formato leve de
troca de dados inspirado pela sintaxe de objeto JavaScript (embora não
seja um subconjunto estrito de JavaScript [1]).

Nota:

  O termo "objeto" no contexto do processamento JSON em Python pode
  ser ambíguo. Todos os valores em Python são objetos. Em JSON, um
  objeto se refere a qualquer dado entre chaves, semelhante a um
  dicionário Python.

Aviso:

  Tenha cuidado quando estiver analisando dados JSON de fontes não-
  confiáveis. Uma string JSON maliciosa pode fazer o decodificador
  consumir recursos consideráveis de CPU e memória. É recomendado
  limitar o tamanho do dado a ser analisado.

Este módulo expõe uma API familiar para pessoas usuárias dos módulos
"marshal" e "pickle" da biblioteca padrão.

Codificação de hierarquias básicas de objetos 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"]'

Codificação compacta:

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

Saída bonita:

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

Personalizando em codificação de objeto 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}'

Decodificando 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']

Personalizando em decodificação de objeto 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')

Estendendo "JSONEncoder":

   >>> import json
   >>> class ComplexEncoder(json.JSONEncoder):
   ...     def default(self, obj):
   ...         if isinstance(obj, complex):
   ...             return [obj.real, obj.imag]
   ...         # Let the base class default method raise the 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', ']']

Usando "json" para validar a partir do console e exibir formatado:

   $ 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)

Veja Interface de linha de comando para a documentação detalhada.

Nota:

  JSON é um subconjunto do YAML 1.2. O JSON gerado pelas definições
  padrões desse módulo (particularmente, o valor padrão dos
  *separadores*) é também um subconjunto do YAML 1.0 e 1.1. Esse
  módulo pode, portanto, também ser usado como serializador YAML.

Nota:

  O codificador e o decodificador do módulo preservam a ordem de
  entrada e saída por padrão. A ordem só é perdida se os contêineres
  subjacentes estão desordenados.


Uso básico
==========

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)

   Serializa um *obj* como um stream JSON formatado para *fp* (um
   *objeto arquivo ou similar* com suporte a ".write()") usando essa
   tabela de conversão de Python para JSON.

   Nota:

     Diferente de "pickle" e "marshal", JSON não é um protocolo com
     datagrama, assim tentar serializar múltiplos objetos com chamadas
     repetidas para "dump()" usando o mesmo *fp* resultará em um
     arquivo JSON inválido.

   Parâmetros:
      * **obj** (*object*) -- O objeto Python a ser serializado.

      * **fp** (*file-like object*) -- O objeto arquivo ou similar
        *obj* para o qual será serializado. O módulo "json" sempre
        produz objetos "str", e não objetos "bytes". Dessa forma,
        "fp.write()" precisa ter suporte para entradas "str".

      * **skipkeys** (*bool*) -- Se "True", as chaves que não forem de
        um tipo básico ("str", "int", "float", "bool", "None") serão
        ignoradas ao invés de levantar uma exceção "TypeError". Padrão
        "False".

      * **ensure_ascii** (*bool*) -- Se "True" (o padrão), será
        garantido que a saída terá todos os caracteres não ASCII que
        chegam escapados. Se "False", esses caracteres serão emitidos
        como estão.

      * **check_circular** (*bool*) -- Se "False", a verificação de
        referência circular for de tipos contêineres é ignorada e uma
        referência circular resultará em uma exceção "RecursionError"
        (ou pior). Padrão "True".

      * **allow_nan** (*bool*) -- Se "False", serialização de valores
        "float" fora de intervalo ("nan", "inf", "-inf") vai resultar
        em um "ValueError" em estrita conformidade com a
        especificação. Se "True" (o padrão), seus equivalentes
        JavaScript ("NaN", "Infinity", "-Infinity") serão usados.

      * **cls** (a "JSONEncoder" subclass) -- Se definido, um
        codificador JSON personalizado com o método "default()"
        substituído, para serializar em tipos de dados personalizados.
        Se "None" (o padrão), "JSONEncoder" é usado.

      * **indent** (*int** | **str** | **None*) -- Se for um inteiro
        positivo ou uma string, os elementos da vetores JSON e os
        membros do objeto serão impressos de forma bonita com esse
        nível de indentação. Um inteiro positivo recua essa quantidade
        de espaços por nível; uma string (como ""\t"") é usada para
        indentar cada nível. Se for zero, negativo ou """" (a string
        vazia), somente novas linhas serão inseridas. Se for "None" (o
        padrão), a representação mais compacta será usada.

      * **separators** (*tuple** | **None*) -- Uma tupla dupla:
        "(item_separator, key_separator)". Se "None" (o padrão),
        *separators* assume como padrão "(', ', ': ')" se *indent* for
        "None", e "(',', ': ')" caso contrário. Para o JSON mais
        compacto, especifique "(',', ':')" para eliminar espaços em
        branco.

      * **default** (*callable* | None) -- Uma função que é chamada
        para objetos que não podem ser serializados de outra forma.
        Ela deve retornar uma versão JSON codificável do objeto ou
        gerar um "TypeError". Se "None" (o padrão), "TypeError" é
        levantada.

      * **sort_keys** (*bool*) -- Se "True", os dicionários serão
        emitidos classificados por chave. Padrão "False".

   Alterado na versão 3.2: Permite strings para *indent*, além de
   inteiros.

   Alterado na versão 3.4: Usa "(',', ': ')" como padrão se *indent*
   não for "None".

   Alterado na versão 3.6: Todos os parâmetros opcionais agora são
   somente-nomeados.

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)

   Serializa *obj* para uma "str" com formato JSON usando essa tabela
   de conversão. Os argumentos têm o mesmo significado que na função
   "dump()".

   Nota:

     Chaves nos pares chave/valor de JSON são sempre do tipo "str".
     Quando um dicionário é convertido para JSON, todas as chaves são
     convertidas para strings. Como resultado disso, se um dicionário
     é convertido para JSON e depois de volta para um dicionário, o
     dicionário pode não ser igual ao original. Isto é,
     "loads(dumps(x)) != x" se x tem chaves não strings.

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

   Desserializa *fp* para um objeto Python usando a tabela de
   conversão JSON para Python.

   Parâmetros:
      * **fp** (*file-like object*) -- Um *arquivo texto* ou *arquivo
        binário* com suporte a ".read()" contendo o documento JSON a
        ser desserializado.

      * **cls** (a "JSONDecoder" subclass) -- Se definido, um
        decodificador JSON personalizado. Argumentos nomeados
        adicionais para "load()" serão passados para o construtor de
        *cls*. Se "None" (o padrão), "JSONDecoder" é usado.

      * **object_hook** (*callable* | None) -- Se definido, uma função
        que é chamada com o resultado de qualquer literal de objeto
        JSON decodificado (um "dict"). O valor de retorno desta função
        será usado em vez do "dict". Este recurso pode ser usado para
        implementar decodificadores personalizados, por exemplo dica
        de classes JSON-RPC. O padrão é "None".

      * **object_pairs_hook** (*callable* | None) -- Se definido, uma
        função que é chamada com o resultado de qualquer literal de
        objeto JSON decodificado com uma lista ordenada de pares. O
        valor de retorno desta função será usado em vez de "dict".
        Este recurso pode ser usado para implementar decodificadores
        personalizados. Se *object_hook* também for definido,
        *object_pairs_hook* terá prioridade. O padrão é "None".

      * **parse_float** (*callable* | None) -- Se definido, uma função
        que é chamada com a string de cada ponto flutuante JSON a ser
        decodificada. Se "None" (o padrão), é equivalente a
        "float(num_str)". Isso pode ser usado para analisar pontos
        flutuantes JSON em tipos de dados personalizados, por exemplo
        "decimal.Decimal".

      * **parse_int** (*callable* | None) -- Se definido, uma função
        que é chamada com a string de cada int JSON a ser
        decodificado. Se "None" (o padrão), é equivalente a
        "int(num_str)". Isso pode ser usado para analisar inteiros
        JSON em tipos de dados personalizados, por exemplo "float".

      * **parse_constant** (*callable* | None) -- Se definido, uma
        função que é chamada com uma das seguintes strings:
        "'-Infinity'", "'Infinity'" ou "'NaN'". Isso pode ser usado
        para levantar uma exceção se números JSON inválidos forem
        encontrados. Padrão "None".

   Levanta:
      * **JSONDecodeError** -- Quando os dados a serem desserializados
        não forem um documento JSON válido.

      * **UnicodeDecodeError** -- Quando os dados que estão sendo
        desserializados não contêm dados codificados em UTF-8, UTF-16
        ou UTF-32.

   Alterado na versão 3.1:

   * Adicionado o parâmetro opcional *object_pairs_hook*.

   * *parse_constant* não é mais chamada para 'null', 'true', 'false'.

   Alterado na versão 3.6:

   * Todos os parâmetros opcionais agora são somente-nomeados.

   * *fp* agora pode ser um *arquivo binário*. A entrada deve estar
     codificada como UTF-8, UTF-16 ou UTF-32.

   Alterado na versão 3.11: O *parse_int* padrão para  "int()" agora
   limita o tamanho máximo da string de inteiro via limitação de
   comprimento de string na conversão para inteiro do interpretador
   para ajudar a evitar ataques por negação de serviço.

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

   Idêntico a "load()", mas em vez de um objeto arquivo ou similar,
   desserializa *s* (uma instância de "str", "bytes" ou "bytearray"
   contendo um documento JSON) para um objeto Python usando essa
   tabela de conversão.

   Alterado na versão 3.6: *s* agora pode ser um do tipo "bytes" ou
   "bytearray". A entrada deve estar codificado como UTF-8, UTF-16 ou
   UTF-32.

   Alterado na versão 3.9: O argumento nomeado *encoding* foi
   removido.


Codificadores e decodificadores
===============================

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

   Decodificador JSON simples.

   Executa as seguintes traduções na decodificação por padrão:

   +-----------------+---------------------+
   | JSON            | Python              |
   |=================|=====================|
   | objeto          | dicionário          |
   +-----------------+---------------------+
   | array           | lista               |
   +-----------------+---------------------+
   | string          | str                 |
   +-----------------+---------------------+
   | número          | int                 |
   | (inteiro)       |                     |
   +-----------------+---------------------+
   | número (real)   | float               |
   +-----------------+---------------------+
   | verdadeiro      | True                |
   +-----------------+---------------------+
   | falso           | False               |
   +-----------------+---------------------+
   | nulo            | None                |
   +-----------------+---------------------+

   Ele também entende "NaN", "Infinity" e "-Infinity" como seus
   valores "float" correspondentes, que estão fora da especificação
   JSON.

   *object_hook* é uma função opcional que será chamada com o
   resultado de cada objeto JSON decodificado e seu valor de retorno
   será usado no lugar do dado "dict". Isso pode ser usado para
   fornecer desserializações personalizadas (por exemplo, para
   oferecer suporte a dicas de classe JSON-RPC)

   *object_pairs_hook* é uma função opcional que será chamada com o
   resultado de todo objeto JSON decodificado com uma lista ordenada
   de pares. O valor de retorno de *object_pairs_hook* será usado no
   lugar do "dict". Este recurso pode ser usado para implementar
   decodificadores personalizados. Se *object_pairs_hook* também for
   definido, o *object_pairs_hook* terá prioridade.

   Alterado na versão 3.1: Adicionado suporte para
   *object_pairs_hook*.

   *parse_float* é uma função opcional que será chamada com a string
   de cada ponto flutuante JSON para ser decodificado. Por padrão,
   equivale a "float(num_str)". Pode ser usado para qualquer outro
   tipo de dado ou analisador de pontos flutuante JSON (por exemplo,
   "decimal.Decimal").

   *parse_int* é uma função opcional que será chamada com a string de
   cada inteiro JSON para ser decodificado. Por padrão, equivale a
   "int(num_str)". Pode ser usado para qualquer outro tipo de dado ou
   analisador de inteiros JSON (por exemplo, "float").

   *parse_constant* é uma função opcional que será chamada para cada
   um das seguintes strings: "'-Infinity'", "'Infinity'", "'NaN'".
   Isso pode ser usado para levantar uma exceção se forem encontrados
   números JSON inválidos.

   Se *strict* for falso ("True" é o padrão), os caracteres de
   controle serão permitidos dentro das strings. Os caracteres de
   controle neste contexto são aqueles com códigos de caracteres no
   intervalo 0--31, incluindo "'\t'" (tab), "'\n'", "'\r'" e "'\0'".

   Se os dados a serem desserializados não forem um documento JSON
   válido, será levantada uma exceção "JSONDecodeError".

   Alterado na versão 3.6: Todos os parâmetros agora são somente-
   nomeado.

   decode(s)

      Retorna a representação Python de *s* (uma instância "str"
      contendo um documento JSON).

      Uma exceção "JSONDecodeError" será levantada se o documento JSON
      fornecido não for válido.

   raw_decode(s)

      Decodifica um documento JSON a partir de *s* (uma "str"
      iniciando com um documento JSON) e retornando uma tupla de 2
      elementos, a representação Python e o índice em *s* onde o
      documento finaliza.

      Isso pode ser usado para decodificar um documento JSON a partir
      de uma string que possa ter dados extras ao final.

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

   Codificador JSON extensível para estruturas de dados Python.

   Por padrão, possui suporte para os seguintes objetos e tipos:

   +------------------------------------------+-----------------+
   | Python                                   | JSON            |
   |==========================================|=================|
   | dicionário                               | objeto          |
   +------------------------------------------+-----------------+
   | list, tuple                              | array           |
   +------------------------------------------+-----------------+
   | str                                      | string          |
   +------------------------------------------+-----------------+
   | int, float e Enums derivados de int e    | number          |
   | float                                    |                 |
   +------------------------------------------+-----------------+
   | True                                     | verdadeiro      |
   +------------------------------------------+-----------------+
   | False                                    | falso           |
   +------------------------------------------+-----------------+
   | None                                     | nulo            |
   +------------------------------------------+-----------------+

   Alterado na versão 3.4: Adicionado suporte para classes Enum
   derivadas de int e float.

   Para estender isso para reconhecer outros objetos, crie uma
   subclasse e implemente o método "default()" com outro método que
   retorne um objeto serializável para "o" se possível, caso contrário
   deveria chamar a implementação da superclasse (para levantar
   "TypeError").

   Se *skipkeys* é falso (o padrão), então sluma "TypeError" será
   levantada ao tentar codificar as chaves que não são "str", "int",
   "float", "bool" ou "None".  Se *skipkeys* é verdadeiro, esses itens
   são simplesmente pulados.

   Se *ensure_ascii* for verdadeiro (o padrão), será garantido que a
   saída terá todos os caracteres não ASCII que chegam escapados. Se
   *ensure_ascii* for falso, a saída desses caracteres ficará como
   está.

   Se *check_circular* é verdadeiro (o padrão), então listas,
   dicionários e objetos codificados personalizados serão verificados
   por referências circulares durante a codificação para prevenir uma
   recursão infinita (que iria causar uma "RecursionError"). Caso
   contrário, nenhuma verificação será feita.

   Se *allow_nan* for verdadeiro (o padrão), então "NaN", "Infinity",
   e "-Infinity" serão codificados como tal. Esse comportamento não é
   compatível com a especificação do JSON, mas é consistente com a
   maioria dos codificadores e decodificadores baseados em JavaScript.
   Caso contrário, será levantada uma "ValueError" para tais pontos
   flutuantes.

   Se *sort_keys* for verdadeiro (padrão: "False"), então a saída dos
   dicionários serão ordenados pela chave; isto é útil para testes de
   regressão para certificar-se que as serializações de JSON possam
   ser comparadas com uma base no dia a dia.

   Se *indent* for um inteiro não negativo ou uma string, então
   elementos de um vetor JSON e membros de objetos terão uma saída
   formatada com este nível de indentação. Um nível de indentação 0,
   negativo ou """" apenas colocará novas linhas. "None" (o padrão)
   seleciona a representação mais compacta. Usando um inteiro positivo
   a indentação terá alguns espaços por nível. Se *indent* for uma
   string (como ""\t""), essa string será usada para indentar cada
   nível.

   Alterado na versão 3.2: Permite strings para *indent*, além de
   inteiros.

   Se especificado, *separators* deve ser uma tupla "(item_separator,
   key_separator)". O padrão é "(', ', ': ')" se *indent* for "None" e
   "(',', ': ')" caso contrário. Para pegar representação JSON mais
   compacta, você deve especificar "(',', ':')" para eliminar espaços
   em branco.

   Alterado na versão 3.4: Usa "(',', ': ')" como padrão se *indent*
   não for "None".

   Se especificado, *default* deve ser uma função para ser chamada
   para objetos que não podem ser serializados de outra forma. Deve
   retornar uma versão codificável JSON do objeto ou levantar uma
   exceção "TypeError". Se não for especificada, "TypeError" é
   levantada.

   Alterado na versão 3.6: Todos os parâmetros agora são somente-
   nomeado.

   default(o)

      Implemente este método em uma subclasse que retorna um objeto
      serializável para *o* ou que chame a implementação base (para
      levantar uma "TypeError").

      Por exemplo, para suporte a iteradores arbitrários, você poderia
      implementar "default()" dessa forma:

         def default(self, o):
            try:
                iterable = iter(o)
            except TypeError:
                pass
            else:
                return list(iterable)
            # Faz o método padrão de classe base levantar a TypeError
            return super().default(o)

   encode(o)

      Retorna uma string representando um JSON a partir da estrutura
      de dados Python, *o*. Por exemplo:

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

   iterencode(o)

      Codifica o objeto dado, *o*, e produz cada representação em
      string assim que disponível.  Por exemplo:

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


Exceções
========

exception json.JSONDecodeError(msg, doc, pos)

   Subclasse de "ValueError" com os seguintes atributos adicionais:

   msg

      A mensagem de erro não formatada.

   doc

      O documento JSON sendo analisado.

   pos

      O índice inicial de *doc* em que a análise falhou.

   lineno

      A linha correspondente a *pos*.

   colno

      A coluna correspondente a *pos*.

   Adicionado na versão 3.5.


Conformidade e interoperabilidade entre padrões
===============================================

O formato JSON é especificado pela **RFC 7159** e por ECMA-404. Esta
seção detalha o nível de conformidade deste módulo com a RFC. Para
simplificar, as subclasses "JSONEncoder" e "JSONDecoder", e outros
parâmetros além daqueles explicitamente mencionados, não são
considerados.

Este módulo não está em conformidade com a RFC de forma estrita,
implementando algumas extensões que são JavaScript válidas, mas não
JSON válido. Em particular:

* Os valores de números infinitos e NaN são aceitos e produzidos;

* Nomes repetidos em um objeto são aceitos e apenas o valor do último
  par nome-valor é usado.

Uma vez que a RFC permite que os analisadores compatíveis com a RFC
aceitem textos de entrada que não sejam compatíveis com a RFC, o
desserializador deste módulo é tecnicamente compatível com a RFC nas
configurações padrão.


Codificações de caracteres
--------------------------

A RFC requer que JSON seja representado usando UTF-8, UTF-16 ou
UTF-32, com UTF-8 sendo o padrão recomendado para interoperabilidade
máxima.

Conforme permitido, embora não exigido, pela RFC, o serializador deste
módulo define *ensure_ascii=True* por padrão, escapando a saída para
que as strings resultantes contenham apenas caracteres ASCII.

Além do parâmetro *ensure_ascii*, este módulo é definido estritamente
em termos de conversão entre objetos Python e "strings Unicode" e,
portanto, não aborda diretamente o problema de codificação de
caracteres.

A RFC proíbe adicionar uma marca de ordem de byte (do inglês *byte
order mark* - BOM) ao início de um texto JSON, e o serializador deste
módulo não adiciona um BOM à sua saída. A RFC permite, mas não exige,
que os desserializadores JSON ignorem um BOM inicial em sua entrada. O
desserializador deste módulo levanta uma "ValueError" quando um BOM
inicial está presente.

A RFC não proíbe explicitamente as strings JSON que contêm sequências
de bytes que não correspondem a caracteres Unicode válidos (por
exemplo, substitutos UTF-16 não emparelhados), mas observa que podem
causar problemas de interoperabilidade. Por padrão, este módulo aceita
e produz (quando presente no original "str") pontos de código para
tais sequências.


Valores numéricos infinitos e NaN
---------------------------------

A RFC não permite a representação de valores infinitos ou numéricos
NaN. Apesar disso, por padrão, este módulo aceita e produz "Infinity",
"-Infinity" e "NaN" como se fossem valores literais de número JSON
válidos:

   >>> # Nenhuma dessas chamadas levanta uma exceção, mas os resultados não são JSON válidos
   >>> json.dumps(float('-inf'))
   '-Infinity'
   >>> json.dumps(float('nan'))
   'NaN'
   >>> # Same when deserializing
   >>> json.loads('-Infinity')
   -inf
   >>> json.loads('NaN')
   nan

No serializador, o parâmetro *allow_nan* pode ser usado para alterar
esse comportamento. No desserializador, o parâmetro *parse_constant*
pode ser usado para alterar esse comportamento.


Nomes repetidos dentro de um objeto
-----------------------------------

A RFC especifica que os nomes em um objeto JSON devem ser exclusivos,
mas não determina como os nomes repetidos em objetos JSON devem ser
tratados. Por padrão, este módulo não levanta uma exceção; em vez
disso, ele ignora tudo, exceto o último par nome-valor para um
determinado nome:

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

O parâmetro *object_pairs_hook* pode ser usado para alterar este
comportamento.


Valores não objeto e não vetor de nível superior
------------------------------------------------

A versão antiga de JSON especificada pela obsoleta **RFC 4627** exige
que o valor de nível superior do texto JSON deve ser do tipo object ou
array ("dict" ou "list" Python), e não poderia ser dos tipos null,
boolean, number ou string. **RFC 7159** removeu essa restrição, e esse
módulo não tem nenhuma implementação que faça essa restrição, seja em
seus serializadores, sejam nos desserializadores.

Independentemente, para máxima interoperabilidade, você pode querer
aderir voluntariamente à restrição.


Limitações de implementação
---------------------------

Algumas implementações de desserializadores JSON podem definir limites
em:

* o tamanho de textos JSON aceitos

* o nível máximo de aninhamento de objetos e vetores JSON

* o intervalo e a precisão de números JSON

* o conteúdo e o tamanho máximo de strings JSON

Esse módulo não impõe nenhum limite além daqueles já colocados pelas
estruturas de dados Python ou pelo interpretador Python em si.

Quando serializando para JSON, tenha cuidado com qualquer limitação
nas aplicações que irão consumir seu JSON. Em particular, é comum para
números JSON serem desserializados com números de precisão dupla
definida em IEEE 754 e, portanto, sujeito a limitações de precisão e
de intervalo da representação. Isso é especialmente relevante quando
serializando valores Python "int" de magnitude extremamente grande, ou
quando  serializando instâncias de tipos numéricos "exóticos" como
"decimal.Decimal".


Interface de linha de comando
=============================

**Código-fonte:** Lib/json/tool.py

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

O módulo "json" pode ser invocado como um script via "python -m json"
para validar e fazer uma impressão bem formatada de objetos JSON. O
submódulo "json.tool" implementa essa interface.

Se os argumentos opcionais "infile" e "outfile" não forem
especificados, "sys.stdin" e "sys.stdout" serão usados
respectivamente:

   $ 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)

Alterado na versão 3.5: A saída agora está na mesma ordem da entrada.
Use a opção "--sort-keys" para ordenar a saída de dicionários
alfabeticamente pela chave.

Alterado na versão 3.14: O módulo "json" agora pode ser executado
diretamente como "python -m json". Para retrocompatibilidade, a
invocação da CLI como "python -m json.tool" continua sendo aceita.


Opções de linha de comando
--------------------------

infile

   O arquivo JSON para ser validado ou saída embelezada:

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

   Se *infile* não é especificado, lê de "sys.stdin".

outfile

   Escreve a saída de *infile* para o *outfile* dado. Caso contrário,
   escreve em "sys.stdout".

--sort-keys

   Ordena a saída de dicionários alfabeticamente pela chave.

   Adicionado na versão 3.5.

--no-ensure-ascii

   Desabilita escape de caracteres não-ascii, veja "json.dumps()" para
   mais informações.

   Adicionado na versão 3.9.

--json-lines

   Analisa cada linha da entrada como um objeto JSON separado.

   Adicionado na versão 3.8.

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

   Opções mutualmente exclusivas para controle de espaços em branco.

   Adicionado na versão 3.9.

-h, --help

   Exibe a mensagem de ajuda.

-[ Notas de rodapé ]-

[1] Como apresentado na errata para RFC 7159, JSON permite os
    caracteres literais U+2028 (SEPARADOR DE LINHA) e U+2029
    (SEPARADOR DE PARÁGRAFO) em strings, enquanto que JavaScript
    (ECMAScript Edition 5.1) não.
