Salvando e carregando do arquivo

O formato do arquivo: simples de gravar, simples de ler

Antes de gravar qualquer coisa, precisamos combinar um formato: como uma tarefa, que dentro do programa é um dicionário, vira uma linha de texto dentro do arquivo? A resposta escolhida é a mais simples que funciona: cada linha carrega o status e o texto, separados por ponto e vírgula. O status é um caractere só, 0 para pendente e 1 para concluída. Um arquivo com duas tarefas fica assim:

0;Comprar pão
1;Pagar conta de luz

O conteúdo do tarefas.txt: Comprar pão está pendente (0) e Pagar conta de luz está concluída (1).

Por que o status vem antes do texto, e não depois? Porque o status tem tamanho fixo (um caractere) e o texto tem tamanho livre. Com o campo fixo na frente, o split(";", 1) corta a linha na primeira ocorrência do separador e pronto: tudo que vier depois, inclusive outros pontos e vírgulas que o usuário tenha digitado na tarefa, permanece intacto no texto. Se o texto viesse primeiro, um ponto e vírgula digitado no meio da tarefa embaralharia a leitura. Formato de arquivo é decisão de projeto, e essa ordem esperta evita uma classe inteira de defeitos.

Outra decisão: a estratégia de gravação. Em vez de tentar editar linhas específicas do arquivo, o salvar_tarefas reescreve o arquivo do zero a cada chamada, com o modo w do módulo 15. Para uma lista pessoal de tarefas, reescrever tudo custa menos de um piscar de olhos e simplifica o código de forma brutal: uma única função de gravação serve para adicionar, concluir e remover.

Implementando salvar_tarefas e carregar_tarefas

Duas mudanças no gerenciador.py. Primeiro, logo no topo do arquivo, antes das funções, crie a constante com o nome do arquivo, para ele morar num lugar só. Depois, substitua o pass de salvar_tarefas e o return [] de carregar_tarefas pelas versões de verdade:

ARQUIVO = "tarefas.txt"

def salvar_tarefas(tarefas):
    with open(ARQUIVO, "w", encoding="utf-8") as arquivo:
        for tarefa in tarefas:
            if tarefa["concluida"]:
                status = "1"
            else:
                status = "0"
            arquivo.write(status + ";" + tarefa["texto"] + "\n")

salvar_tarefas: abre no modo w (reescreve), percorre a lista e grava status;texto com quebra de linha no final de cada tarefa.

O with garante o fechamento do arquivo mesmo se algo der errado no meio, como o módulo 15 ensinou, e o encoding utf-8 garante que Almoçar com a vovó seja gravado e lido com os acentos no lugar, em qualquer sistema. O if traduz o True/False do dicionário para o 1/0 do arquivo, e o \n no final de cada write é o que separa as tarefas em linhas. Agora o caminho de volta, que é a leitura na abertura:

def carregar_tarefas():
    tarefas = []
    try:
        with open(ARQUIVO, "r", encoding="utf-8") as arquivo:
            for linha in arquivo:
                linha = linha.strip()
                if linha == "":
                    continue
                status, texto = linha.split(";", 1)
                tarefas.append({"texto": texto, "concluida": status == "1"})
    except FileNotFoundError:
        pass
    return tarefas

carregar_tarefas: lê linha a linha, limpa a quebra com strip, pula linhas vazias e reconstrói cada dicionário com split.

Dois pontos finos merecem lupa. O primeiro é o status == "1" dentro do append: essa comparação já resulta em True ou False, então ela reconstrói o campo concluida direto, sem precisar de if. É a tradução inversa da gravação: o 1/0 do arquivo virando o True/False do dicionário. O segundo é o except FileNotFoundError com pass: na primeira vez que alguém roda o programa, o tarefas.txt ainda não existe, e o open no modo r levantaria erro. O except captura essa situação específica e deixa a função seguir para o return tarefas, devolvendo a lista vazia criada no começo. Primeira execução sem arquivo não é erro, é só um usuário novo.

Ligando tudo no loop principal

As funções existem, mas ninguém as chama ainda. Faltam as duas costuras no programa principal: carregar na abertura e salvar após cada mudança. A primeira é trocar a linha tarefas = [] por tarefas = carregar_tarefas(). A segunda é chamar salvar_tarefas logo depois de cada ação que altera a lista, ou seja, nas opções 1, 3 e 4. A opção 2 só lê, então não precisa gravar nada. O programa principal fica assim:

tarefas = carregar_tarefas()

while True:
    mostrar_menu()
    opcao = input("Escolha uma opção: ")
    if opcao == "1":
        adicionar_tarefa(tarefas)
        salvar_tarefas(tarefas)
    elif opcao == "2":
        listar_tarefas(tarefas)
    elif opcao == "3":
        concluir_tarefa(tarefas)
        salvar_tarefas(tarefas)
    elif opcao == "4":
        remover_tarefa(tarefas)
        salvar_tarefas(tarefas)
    elif opcao == "5":
        print("Até logo!")
        break
    else:
        print("Opção inválida. Digite um número de 1 a 5.")

O loop com as costuras: carregar_tarefas na abertura e salvar_tarefas após adicionar, concluir e remover.

Por que salvar após cada mudança, em vez de uma vez só na saída? Porque a vida real derruba programas: acabou a luz, fechou o terminal sem querer, o computador reiniciou. Salvando a cada alteração, o pior cenário perde só a digitação em andamento, nunca a lista. É o mesmo princípio do salvamento automático dos editores de texto modernos, e custa uma linha por opção.

Agora o teste que muda tudo: adicione duas tarefas, conclua uma, saia com a opção 5 e RODE O PROGRAMA DE NOVO. Escolha listar. As tarefas estão lá, com o status certinho. Se estiver rodando no seu computador, abra o tarefas.txt na pasta do projeto e veja as linhas 0;texto e 1;texto com os próprios olhos. Esse momento, em que o seu programa lembra do passado, é a fronteira entre script de estudo e ferramenta de verdade.