Salvar e carregar dados em JSON

{
  "tarefas": [
    {
      "titulo": "Revisar JSON",
      "concluida": false,
      "prioridade": 2
    },
    {
      "titulo": "Enviar relatório",
      "concluida": true,
      "prioridade": 1
    }
  ],
  "proxima_revisao": null
}

import json

colecao = {
    "tarefas": [
        {
            "titulo": "Revisar JSON",
            "concluida": False,
            "prioridade": 4,
        },
        {
            "titulo": "Praticar conversoes",
            "concluida": True,
            "prioridade": 2,
        },
    ]
}

texto_json = json.dumps(colecao)
colecao_recuperada = json.loads(texto_json)

print(type(colecao).__name__)
print(type(texto_json).__name__)
print(type(colecao_recuperada).__name__)
print(colecao_recuperada["tarefas"][0]["titulo"])

import json

original = {
    1: ("estudar", "praticar")
}

texto = json.dumps(original)
recuperado = json.loads(texto)

print(texto)
print(recuperado)
print(type(next(iter(recuperado))))
print(type(recuperado["1"]))

# Saída:
# {"1": ["estudar", "praticar"]}
# {'1': ['estudar', 'praticar']}
# <class 'str'>
# <class 'list'>

import json

etiquetas = {"python", "json"}

try:
    json.dumps(etiquetas)
except TypeError as erro:
    print(f"Não foi possível serializar: {erro}")

# Conversão explícita: adequada somente se uma lista servir ao uso futuro.
texto = json.dumps(list(etiquetas))
recuperado = json.loads(texto)

print(recuperado)
print(type(recuperado))  # <class 'list'>

import json

dados = {
    "titulo": "Revisão de português",
    "concluida": False,
}

print("SEM INDENTAÇÃO")
print(json.dumps(dados))

print("\nINDENTADO COM ESCAPES")
print(json.dumps(dados, indent=2))

print("\nINDENTADO COM ACENTOS VISÍVEIS")
print(json.dumps(dados, indent=2, ensure_ascii=False))

import json

texto_com_escapes = r'{"titulo": "Revis\u00e3o de portugu\u00eas"}'
texto_com_acentos = '{"titulo": "Revisão de português"}'

primeiro = json.loads(texto_com_escapes)
segundo = json.loads(texto_com_acentos)

print(primeiro)
print(segundo)
print(primeiro == segundo)  # True

from pathlib import Path
import json

caminho = Path("tarefas.json")
dados = {
    "tarefas": [
        {"titulo": "Revisar função", "concluida": False, "prioridade": 3},
        {"titulo": "Enviar relatório", "concluida": True, "prioridade": 5},
    ]
}

with caminho.open("w", encoding="utf-8") as arquivo:
    json.dump(dados, arquivo, indent=2, ensure_ascii=False)

with caminho.open("r", encoding="utf-8") as arquivo:
    recuperados = json.load(arquivo)

print(recuperados)
print(recuperados == dados)

from pathlib import Path
import json

caminho = Path("tarefas.json")

# Se houver um valor incompatível, TypeError ocorre aqui.
texto_json = json.dumps(
    dados,
    indent=2,
    ensure_ascii=False,
)

# O destino só é truncado depois da serialização bem-sucedida.
with caminho.open("w", encoding="utf-8") as arquivo:
    arquivo.write(texto_json)

import json
from pathlib import Path


def carregar_json(caminho):
    try:
        texto = Path(caminho).read_text(encoding="utf-8")
    except UnicodeDecodeError as erro:
        print(f"O arquivo não contém texto UTF-8 válido: {erro}")
        raise
    except OSError as erro:
        print(f"Não foi possível acessar o arquivo: {erro}")
        raise

    try:
        return json.loads(texto)
    except json.JSONDecodeError as erro:
        print(f"JSON inválido: {erro.msg}")
        print(f"Localização: linha {erro.lineno}, coluna {erro.colno}")
        raise


dados = carregar_json("tarefas.json")
print(dados)

def validar_colecao(dados):
    if not isinstance(dados, dict):
        raise TypeError("a raiz deve ser um dict")

    if "tarefas" not in dados:
        raise ValueError("a raiz deve conter o campo 'tarefas'")

    tarefas = dados["tarefas"]
    if not isinstance(tarefas, list):
        raise TypeError("o campo 'tarefas' deve ser uma list")

    campos_obrigatorios = ("titulo", "concluida", "prioridade")

    for indice, tarefa in enumerate(tarefas):
        if not isinstance(tarefa, dict):
            raise TypeError(f"tarefa {indice}: o registro deve ser um dict")

        for campo in campos_obrigatorios:
            if campo not in tarefa:
                raise ValueError(
                    f"tarefa {indice}: campo obrigatório ausente: {campo}"
                )

        titulo = tarefa["titulo"]
        if not isinstance(titulo, str):
            raise TypeError(f"tarefa {indice}: 'titulo' deve ser str")
        if not titulo.strip():
            raise ValueError(f"tarefa {indice}: 'titulo' não pode ser vazio")

        concluida = tarefa["concluida"]
        if not isinstance(concluida, bool):
            raise TypeError(f"tarefa {indice}: 'concluida' deve ser bool")

        prioridade = tarefa["prioridade"]
        if isinstance(prioridade, bool) or not isinstance(prioridade, int):
            raise TypeError(
                f"tarefa {indice}: 'prioridade' deve ser int, não bool"
            )
        if not 1 <= prioridade <= 5:
            raise ValueError(
                f"tarefa {indice}: 'prioridade' deve estar entre 1 e 5"
            )

import json
from pathlib import Path

caminho = Path("tarefas.json")

try:
    with caminho.open("r", encoding="utf-8") as arquivo:
        dados = json.load(arquivo)
except OSError as erro:
    print(f"Falha ao acessar o arquivo: {erro}")
except UnicodeDecodeError as erro:
    print(f"Falha ao decodificar o texto: {erro}")
except json.JSONDecodeError as erro:
    print(
        f"JSON inválido na linha {erro.lineno}, "
        f"coluna {erro.colno}: {erro.msg}"
    )
else:
    try:
        validar_colecao(dados)
    except (TypeError, ValueError) as erro:
        print(f"Dados incompatíveis com a aplicação: {erro}")
    else:
        print("Coleção válida e pronta para uso.")

{
  "tarefas": [
    {
      "titulo": "Revisar persistência",
      "concluida": false,
      "prioridade": 4
    },
    {
      "titulo": "Conferir relatório",
      "concluida": false,
      "prioridade": 2
    }
  ]
}

import json
from pathlib import Path

CAMINHO = Path("tarefas.json")


def validar_colecao(dados):
    if not isinstance(dados, dict):
        raise TypeError("a raiz deve ser um dict")

    if "tarefas" not in dados:
        raise ValueError("o campo 'tarefas' é obrigatório")

    tarefas = dados["tarefas"]
    if not isinstance(tarefas, list):
        raise TypeError("o campo 'tarefas' deve ser uma list")

    obrigatorios = ("titulo", "concluida", "prioridade")

    for indice, tarefa in enumerate(tarefas):
        referencia = f"tarefas[{indice}]"

        if not isinstance(tarefa, dict):
            raise TypeError(f"{referencia} deve ser um dict")

        for campo in obrigatorios:
            if campo not in tarefa:
                raise ValueError(
                    f"{referencia}: o campo {campo!r} é obrigatório"
                )

        titulo = tarefa["titulo"]
        if not isinstance(titulo, str):
            raise TypeError(f"{referencia}.titulo deve ser str")
        if not titulo.strip():
            raise ValueError(f"{referencia}.titulo não pode ser vazio")

        concluida = tarefa["concluida"]
        if not isinstance(concluida, bool):
            raise TypeError(f"{referencia}.concluida deve ser bool")

        prioridade = tarefa["prioridade"]
        if isinstance(prioridade, bool) or not isinstance(prioridade, int):
            raise TypeError(f"{referencia}.prioridade deve ser int")
        if not 1 <= prioridade <= 5:
            raise ValueError(
                f"{referencia}.prioridade deve estar entre 1 e 5"
            )


def carregar(caminho):
    with caminho.open("r", encoding="utf-8") as arquivo:
        return json.load(arquivo)


def executar(caminho):
    try:
        dados = carregar(caminho)
    except OSError as erro:
        print(f"Falha de acesso: {erro}")
        return
    except UnicodeDecodeError as erro:
        print(f"Falha ao decodificar o arquivo como UTF-8: {erro}")
        return
    except json.JSONDecodeError as erro:
        print(
            "JSON inválido: "
            f"{erro.msg}, linha {erro.lineno}, coluna {erro.colno}"
        )
        return

    try:
        validar_colecao(dados)
    except (TypeError, ValueError) as erro:
        print(f"Dados incompatíveis com a aplicação: {erro}")
        return

    dados["tarefas"][0]["concluida"] = True
    validar_colecao(dados)

    try:
        texto_json = json.dumps(
            dados,
            indent=2,
            ensure_ascii=False,
        )
    except TypeError as erro:
        print(f"Falha de serialização: {erro}")
        return

    try:
        with caminho.open("w", encoding="utf-8") as arquivo:
            arquivo.write(texto_json)
            arquivo.write("\n")
    except OSError as erro:
        print(f"Falha de gravação: {erro}")
        return

    try:
        confirmacao = carregar(caminho)
        validar_colecao(confirmacao)
    except OSError as erro:
        print(f"Falha ao reabrir o arquivo: {erro}")
        return
    except UnicodeDecodeError as erro:
        print(f"Falha ao decodificar a conferência: {erro}")
        return
    except json.JSONDecodeError as erro:
        print(
            "JSON inválido na conferência: "
            f"{erro.msg}, linha {erro.lineno}, coluna {erro.colno}"
        )
        return
    except (TypeError, ValueError) as erro:
        print(f"Dados inválidos na conferência: {erro}")
        return

    primeira = confirmacao["tarefas"][0]
    print(f"Título reaberto: {primeira['titulo']}")
    print(f"Concluída após reabrir: {primeira['concluida']}")


if __name__ == "__main__":
    executar(CAMINHO)

{
  "tarefas": [
    {
      "titulo": "Revisar persistência",
      "concluida": false,
      "prioridade": 4,
    }
  ]
}

{
  "tarefas": [
    {
      "titulo": "Revisar persistência",
      "prioridade": 4
    }
  ]
}