Se você já estudou Python, provavelmente chegou naquele momento em que os exemplos isolados começam a fazer sentido, mas surge uma pergunta importante:

“Como transformar tudo o que aprendi em Python em um projeto de verdade?”

Ilustração de um projeto de sistema de cadastro em Python, mostrando código no VS Code, dados de usuários sendo armazenados em um arquivo JSON e a execução do cadastro no terminal.

Foi exatamente essa transição que tornou meu aprendizado mais desafiador.

Entender uma lista separadamente é uma coisa. Entender um dicionário também. Criar uma função parece simples quando o exemplo tem poucas linhas. Mas, quando precisamos juntar esses conceitos para construir alguma coisa, a dificuldade aumenta.

E um dos pontos que mais me chamou atenção foi o JSON.

Eu conseguia criar dados dentro do programa, mas ainda precisava entender uma coisa fundamental: como fazer esses dados continuarem existindo depois que o programa fosse encerrado?

Neste projeto vamos resolver justamente esse problema.

Vamos criar um sistema de cadastro em Python, executado pelo terminal, capaz de cadastrar uma pessoa com:

  • nome;

  • idade;

  • e-mail.

Os dados serão organizados em uma lista de dicionários e salvos em um arquivo chamado cadastros.json.

O objetivo não é criar um sistema enorme. É entender como os conceitos básicos de Python começam a trabalhar juntos em um projeto real.

O que vamos criar?

Ao final do tutorial, teremos uma estrutura semelhante a esta:

sistema-cadastro/
├── cadastro.py
└── cadastros.json

O arquivo cadastro.py conterá nosso programa.

Já o cadastros.json será responsável por armazenar os dados.

O fluxo será basicamente:

Usuário
   ↓
Programa Python
   ↓
Lista de dicionários
   ↓
Arquivo JSON

Por exemplo, quando cadastrarmos:

Nome: Maria
Idade: 25
E-mail: maria@email.com

O Python poderá armazenar essas informações em uma estrutura semelhante a:

{
    "nome": "Maria",
    "idade": 25,
    "email": "maria@email.com"
}

E posteriormente salvar essa informação no arquivo JSON.

Antes de começar

Para acompanhar o projeto, você precisa ter:

  • Python 3.12 instalado;

  • VS Code instalado;

  • conhecimento básico de if, for, listas e funções;

  • noções básicas de variáveis e entrada de dados com input().

Se você ainda estiver construindo sua base em Python, vale revisar primeiro o conteúdo sobre programação em Python.

Também recomendo consultar o artigo sobre o que é Python caso queira revisar os conceitos fundamentais da linguagem.

Não precisamos instalar nenhuma biblioteca externa para este projeto.

O módulo json utilizado aqui faz parte da biblioteca padrão do Python.

Criando a estrutura do projeto

Crie uma pasta chamada:

sistema-cadastro

Depois abra essa pasta no VS Code.

Dentro dela, crie o arquivo:

cadastro.py

O arquivo cadastros.json será criado pelo próprio programa quando salvarmos o primeiro cadastro.

Por enquanto, nossa estrutura será:

sistema-cadastro/
└── cadastro.py

Primeiro conceito: onde os cadastros serão armazenados?

Infográfico mostrando como armazenar cadastros em Python, com um dicionário representando uma pessoa e uma lista contendo vários dicionários de pessoas.

Antes de pensar no JSON, precisamos entender como os dados serão organizados dentro do Python.

Imagine que queremos cadastrar várias pessoas.

Uma pessoa pode ser representada por um dicionário:

pessoa = {
    "nome": "Maria",
    "idade": 25,
    "email": "maria@email.com"
}

Aqui temos três informações relacionadas à mesma pessoa.

O nome "nome" identifica o dado.

O valor "Maria" é o conteúdo desse dado.

O mesmo acontece com:

"idade": 25

e:

"email": "maria@email.com"

Então o dicionário é uma boa estrutura para representar uma pessoa.

E se tivermos várias pessoas?

É aí que entra a lista.

Podemos criar uma lista contendo vários dicionários:

cadastros = [
    {
        "nome": "Maria",
        "idade": 25,
        "email": "maria@email.com"
    },
    {
        "nome": "João",
        "idade": 31,
        "email": "joao@email.com"
    }
]

Perceba a estrutura:

lista
 ├── dicionário da Maria
 └── dicionário do João

Essa combinação é muito importante para o nosso projeto:

uma lista de dicionários.

Se você ainda tem dificuldade para visualizar esse tipo de estrutura, não se preocupe. Esse é justamente um daqueles conceitos que ficam muito mais claros quando aparecem dentro de um projeto.

Criando a função de cadastro

Agora vamos transformar o processo de cadastro em uma função.

Começamos assim:

def cadastrar():
    nome = input("Nome: ")
    idade = input("Idade: ")
    email = input("E-mail: ")

Temos três entradas.

O usuário informa:

  1. nome;

  2. idade;

  3. e-mail.

Mas ainda precisamos transformar essas informações em um dicionário.

Podemos fazer isso:

def cadastrar():
    nome = input("Nome: ")
    idade = input("Idade: ")
    email = input("E-mail: ")

    pessoa = {
        "nome": nome,
        "idade": idade,
        "email": email
    }

Agora a variável pessoa representa o cadastro realizado.

Por que usar uma função?

Essa é uma dúvida importante para quem está começando.

Poderíamos simplesmente colocar tudo diretamente no programa:

nome = input("Nome: ")
idade = input("Idade: ")
email = input("E-mail: ")

Mas nosso código começaria a ficar difícil de organizar conforme o projeto crescesse.

A função cria uma responsabilidade específica:

def cadastrar():

Ela representa a ação de cadastrar uma pessoa.

Se quiser revisar esse conceito com mais calma, confira o conteúdo sobre funções em Python.

A ideia aqui não é criar funções apenas porque “é uma boa prática”.

É perceber que uma função pode representar uma ação do nosso programa.

Neste caso:

cadastrar()

significa:

Execute o processo responsável por cadastrar uma pessoa.

Transformando o cadastro em uma lista

Agora temos uma pessoa:

pessoa = {
    "nome": nome,
    "idade": idade,
    "email": email
}

Mas queremos armazenar vários cadastros.

Então precisamos de uma lista:

cadastros = []

Depois podemos adicionar a pessoa:

cadastros.append(pessoa)

Nossa função passa a ficar:

def cadastrar():
    nome = input("Nome: ")
    idade = input("Idade: ")
    email = input("E-mail: ")

    pessoa = {
        "nome": nome,
        "idade": idade,
        "email": email
    }

    cadastros.append(pessoa)

Agora existe um detalhe importante.

A variável cadastros precisa estar disponível para a função.

Podemos começar nosso programa assim:

cadastros = []


def cadastrar():
    nome = input("Nome: ")
    idade = input("Idade: ")
    email = input("E-mail: ")

    pessoa = {
        "nome": nome,
        "idade": idade,
        "email": email
    }

    cadastros.append(pessoa)

Mas temos um problema...

Até aqui, tudo funciona enquanto o programa está executando.

Imagine que você execute:

python cadastro.py

Cadastre Maria:

Nome: Maria
Idade: 25
E-mail: maria@email.com

O cadastro estará dentro da lista:

cadastros

Mas o que acontece quando você fecha o programa?

Os dados desaparecem.

Esse é um dos conceitos que mais vale a pena entender neste projeto.

Dados na memória não são a mesma coisa que dados salvos

Quando fazemos:

cadastros = []

essa lista existe na memória do programa.

Enquanto o Python está executando, podemos adicionar informações:

cadastros.append(pessoa)

Porém, quando o programa termina, aquela estrutura deixa de existir.

É como escrever alguma coisa em um quadro branco.

Enquanto você está olhando, a informação está ali.

Mas se apagar o quadro, ela desaparece.

Precisamos então encontrar uma forma de persistir os dados.

É aqui que entra o JSON.

O que é JSON?

JSON é um formato utilizado para representar e armazenar dados de maneira estruturada.

A sigla vem de:

JavaScript Object Notation.

Apesar do nome estar relacionado ao JavaScript, JSON é utilizado em diversas linguagens, incluindo Python.

Um objeto JSON pode ser representado assim:

{
    "nome": "Maria",
    "idade": 25,
    "email": "maria@email.com"
}

Observe como isso se parece bastante com nosso dicionário Python:

{
    "nome": "Maria",
    "idade": 25,
    "email": "maria@email.com"
}

Essa semelhança torna o JSON bastante interessante para nosso projeto.

Python e JSON: qual é a relação?

Uma maneira simples de visualizar é:

Python
↓
lista
↓
dicionários
↓
JSON
↓
arquivo

Nosso programa trabalha com estruturas Python.

Quando precisamos salvar essas estruturas, podemos convertê-las para JSON.

Por exemplo:

cadastros = [
    {
        "nome": "Maria",
        "idade": 25,
        "email": "maria@email.com"
    }
]

Pode ser representado no arquivo:

[
    {
        "nome": "Maria",
        "idade": 25,
        "email": "maria@email.com"
    }
]

A grande vantagem é que o arquivo continua existindo mesmo depois que o programa é encerrado.

Salvando dados com json.dump()

Para trabalhar com JSON, vamos importar o módulo:

import json

Depois podemos abrir um arquivo:

with open("cadastros.json", "w") as arquivo:

O "w" significa que estamos abrindo o arquivo para escrita.

Dentro dele podemos utilizar:

json.dump(cadastros, arquivo, indent=4)

O código completo para salvar os dados será:

with open("cadastros.json", "w") as arquivo:
    json.dump(cadastros, arquivo, indent=4)

Vamos entender cada parte.

open()

open("cadastros.json", "w")

Abre o arquivo.

"w"

Indica que queremos escrever no arquivo.

json.dump()

json.dump(cadastros, arquivo, indent=4)

Pega os dados Python e grava esses dados no arquivo em formato JSON.

indent=4

Organiza o conteúdo para facilitar a leitura.

Sem essa opção, o JSON poderia aparecer todo concentrado em uma única linha.

Com:

indent=4

fica muito mais fácil visualizar o arquivo.

Criando uma função para salvar

Infográfico mostrando como criar uma função salvar_dados() em Python para gravar uma lista de cadastros em um arquivo JSON usando open() e json.dump().

 

Em vez de colocar a lógica diretamente dentro do cadastro, podemos criar outra função:

def salvar_dados():
    with open("cadastros.json", "w") as arquivo:
        json.dump(cadastros, arquivo, indent=4)

Agora temos duas responsabilidades:

cadastrar()
    ↓
cria o cadastro

salvar_dados()
    ↓
salva os cadastros

Isso deixa o programa mais organizado.

Atualizando a função de cadastro

Depois de adicionar uma pessoa à lista, podemos salvar os dados:

def cadastrar():
    nome = input("Nome: ")
    idade = input("Idade: ")
    email = input("E-mail: ")

    pessoa = {
        "nome": nome,
        "idade": idade,
        "email": email
    }

    cadastros.append(pessoa)
    salvar_dados()

Agora o fluxo é:

Usuário informa os dados
        ↓
Python cria o dicionário
        ↓
Dicionário entra na lista
        ↓
Lista é salva no JSON

E se o arquivo JSON ainda não existir?

Esse é outro ponto importante.

Na primeira execução, talvez não exista:

cadastros.json

Quando usamos:

open("cadastros.json", "w")

o Python pode criar o arquivo para nós.

Portanto, não precisamos criar manualmente o JSON antes de executar o programa.

Carregando os dados do JSON

Agora chegamos à outra metade do problema.

Conseguimos salvar.

Mas, se fecharmos o programa e depois abrirmos novamente, precisamos recuperar os dados.

Para isso usamos:

json.load()

Podemos criar uma função:

def carregar_dados():
    with open("cadastros.json", "r") as arquivo:
        return json.load(arquivo)

Aqui aparece o "r".

Enquanto:

"w" → write → escrever
"r" → read → ler

Então:

open("cadastros.json", "r")

abre o arquivo para leitura.

E:

json.load(arquivo)

lê os dados JSON e transforma o conteúdo novamente em estruturas que podemos utilizar no Python.

O ciclo completo

Agora temos duas operações:

Salvar

json.dump()

Carregar

json.load()

Podemos visualizar assim:

Python
  ↓
json.dump()
  ↓
cadastros.json
  ↓
json.load()
  ↓
Python

Essa foi uma das partes que mais fez sentido para mim quando comecei a entender JSON.

O arquivo não substitui a lista ou o dicionário.

Ele funciona como uma forma de persistir os dados.

O programa pode carregar os dados do arquivo, trabalhar com eles e depois salvar novamente.

Criando o carregamento inicial

Existe, porém, outro problema.

Se o programa for executado pela primeira vez, o arquivo ainda não existirá.

Podemos tratar essa situação utilizando os.path.exists().

Primeiro:

import os

Depois:

def carregar_dados():
    if os.path.exists("cadastros.json"):
        with open("cadastros.json", "r") as arquivo:
            return json.load(arquivo)

    return []

Agora o raciocínio é:

O arquivo existe?
       ↓
      sim
       ↓
carrega os dados

       não
       ↓
retorna uma lista vazia

Essa é uma aplicação prática de estruturas condicionais.

Se você quiser revisar if, elif e else, confira o artigo sobre estruturas condicionais em Python.

Entendendo o return []

Talvez essa parte pareça estranha no começo:

return []

Mas pense no que estamos dizendo:

“Se ainda não existe um arquivo com cadastros, considere que temos uma lista vazia.”

Assim:

cadastros = carregar_dados()

na primeira execução poderá resultar em:

cadastros = []

Depois que o primeiro cadastro for criado, a lista passará a conter dados.

Nosso programa até aqui

Agora podemos juntar as partes:

import json
import os


def carregar_dados():
    if os.path.exists("cadastros.json"):
        with open("cadastros.json", "r") as arquivo:
            return json.load(arquivo)

    return []


def salvar_dados():
    with open("cadastros.json", "w") as arquivo:
        json.dump(cadastros, arquivo, indent=4)


def cadastrar():
    nome = input("Nome: ")
    idade = input("Idade: ")
    email = input("E-mail: ")

    pessoa = {
        "nome": nome,
        "idade": idade,
        "email": email
    }

    cadastros.append(pessoa)
    salvar_dados()


cadastros = carregar_dados()

cadastrar()

Já temos um sistema funcional.

Mas vale a pena entender exatamente o que está acontecendo.

O que acontece quando executamos o programa?

Quando o Python chega aqui:

cadastros = carregar_dados()

ele chama a função:

carregar_dados()

Se o arquivo não existir:

return []

Então:

cadastros

começa como uma lista vazia.

Depois:

cadastrar()

é executado.

O usuário informa:

Nome: João
Idade: 30
E-mail: joao@email.com

O Python cria:

{
    "nome": "João",
    "idade": "30",
    "email": "joao@email.com"
}

Esse dicionário entra na lista:

cadastros.append(pessoa)

E então:

salvar_dados()

grava a lista no arquivo.

Um detalhe importante sobre a idade

Existe uma pequena questão que merece atenção.

O input() retorna texto.

Portanto:

idade = input("Idade: ")

faz com que idade seja uma string.

Por exemplo:

"30"

e não:

30

Se quisermos armazenar a idade como número, podemos converter:

idade = int(input("Idade: "))

Assim:

idade = 30

será um inteiro.

Nossa função pode ficar:

def cadastrar():
    nome = input("Nome: ")
    idade = int(input("Idade: "))
    email = input("E-mail: ")

    pessoa = {
        "nome": nome,
        "idade": idade,
        "email": email
    }

    cadastros.append(pessoa)
    salvar_dados()

Isso também aparecerá corretamente no JSON:

{
    "nome": "João",
    "idade": 30,
    "email": "joao@email.com"
}

Testando o sistema

Agora execute:

python cadastro.py

Dependendo do seu sistema, o comando também pode ser:

python3 cadastro.py

O programa deverá solicitar:

Nome: João
Idade: 30
E-mail: joao@email.com

Depois da execução, procure pelo arquivo:

cadastros.json

Ele deverá ter sido criado.

Seu projeto ficará assim:

sistema-cadastro/
├── cadastro.py
└── cadastros.json

Ao abrir o JSON, você deverá encontrar algo semelhante a:

[
    {
        "nome": "João",
        "idade": 30,
        "email": "joao@email.com"
    }
]

Mas o que acontece se eu executar novamente?

Essa é a parte interessante.

Imagine que você encerrou o programa.

Depois abriu novamente.

O Python executará:

cadastros = carregar_dados()

A função verificará:

if os.path.exists("cadastros.json"):

Como o arquivo existe, ele será aberto:

with open("cadastros.json", "r") as arquivo:

E seus dados serão carregados:

return json.load(arquivo)

Então a lista volta para a memória do programa.

É justamente aqui que podemos perceber a diferença entre memória e persistência.

Arquivo JSON
     ↓
 json.load()
     ↓
Lista Python
     ↓
Programa

Quando precisamos salvar:

Programa
     ↓
Lista Python
     ↓
 json.dump()
     ↓
Arquivo JSON

Código completo do projeto

Depois de construir cada parte, podemos organizar nosso arquivo cadastro.py assim:

import json
import os


def carregar_dados():
    if os.path.exists("cadastros.json"):
        with open("cadastros.json", "r") as arquivo:
            return json.load(arquivo)

    return []


def salvar_dados():
    with open("cadastros.json", "w") as arquivo:
        json.dump(cadastros, arquivo, indent=4)


def cadastrar():
    print("\n--- Cadastro de pessoa ---")

    nome = input("Nome: ")
    idade = int(input("Idade: "))
    email = input("E-mail: ")

    pessoa = {
        "nome": nome,
        "idade": idade,
        "email": email
    }

    cadastros.append(pessoa)
    salvar_dados()

    print("\nCadastro realizado com sucesso!")


cadastros = carregar_dados()

cadastrar()

É um projeto pequeno, mas reúne vários conceitos importantes.

O que você aprendeu com este projeto?

O objetivo aqui não era simplesmente copiar um código.

A ideia era entender como diferentes conceitos podem trabalhar juntos.

1. Dicionários

Utilizamos um dicionário para representar uma pessoa:

pessoa = {
    "nome": nome,
    "idade": idade,
    "email": email
}

2. Listas

Utilizamos uma lista para armazenar vários cadastros:

cadastros = []

E adicionamos pessoas com:

cadastros.append(pessoa)

3. Funções

Criamos funções para separar responsabilidades:

carregar_dados()
salvar_dados()
cadastrar()

Cada função possui uma responsabilidade específica.

4. Estruturas condicionais

Usamos:

if os.path.exists("cadastros.json"):

para decidir se o arquivo deveria ser carregado.

5. JSON

Aprendemos que podemos utilizar JSON para representar e persistir nossos dados.

6. json.dump()

Utilizamos:

json.dump(cadastros, arquivo, indent=4)

para salvar os dados.

7. json.load()

Utilizamos:

json.load(arquivo)

para recuperar os dados.

O que eu gostaria que você percebesse aqui

Quando comecei a estudar programação, uma das maiores dificuldades não era necessariamente entender uma linha de código.

Era entender como várias linhas de código se relacionavam.

Por exemplo:

pessoa = {
    "nome": nome,
    "idade": idade,
    "email": email
}

sozinho parece simples.

Depois temos:

cadastros.append(pessoa)

Também parece simples.

Depois:

json.dump(cadastros, arquivo, indent=4)

pode parecer um pouco mais complicado.

Mas quando colocamos tudo em sequência:

entrada do usuário
       ↓
dicionário
       ↓
lista
       ↓
JSON
       ↓
arquivo

o projeto começa a fazer sentido.

Esse foi um dos aprendizados mais importantes para mim: programar não é apenas conhecer comandos; é entender como eles se conectam para resolver um problema.

Como melhorar esse projeto depois?

Nosso sistema é propositalmente simples.

Ele cadastra uma pessoa e salva os dados.

Mas agora que você entende a base, existem vários caminhos para evoluir o projeto.

Por exemplo:

  • listar os cadastros;

  • pesquisar uma pessoa;

  • atualizar informações;

  • excluir um cadastro;

  • criar um menu;

  • validar os dados digitados;

  • impedir e-mails inválidos;

  • tratar erros de entrada;

  • separar o projeto em vários arquivos;

  • posteriormente substituir o JSON por um banco de dados.

O importante é não tentar implementar tudo de uma vez.

Primeiro entenda a base.

Depois aumente a complexidade gradualmente.

Conclusão

Criar um sistema de cadastro em Python pode parecer um projeto simples, mas ele é excelente para consolidar conceitos fundamentais.

Neste projeto, juntamos:

  • listas;

  • dicionários;

  • funções;

  • estruturas condicionais;

  • entrada de dados;

  • arquivos;

  • JSON;

  • json.dump();

  • json.load();

  • persistência de dados.

E, principalmente, entendemos uma diferença que costuma gerar bastante confusão no começo:

os dados que existem na memória durante a execução do programa não são automaticamente persistentes.

Ao utilizar um arquivo JSON, conseguimos transformar esses dados temporários em informações que podem ser recuperadas posteriormente.

Esse é um passo importante na evolução de quem está aprendendo programação.

Você deixa de trabalhar apenas com exemplos isolados e começa a construir pequenos sistemas que resolvem problemas.

Quer continuar aprendendo Python?

Se este projeto ajudou você a entender como os conceitos de Python podem ser combinados na prática, o próximo passo é continuar construindo projetos e aprofundando seus conhecimentos.

Confira os e-books de programação do Entre Bugs e Soluções e continue sua jornada de aprendizado.