🎯 Objetivos da Aula
Salvar
Escrever em arquivos
Carregar
Ler de arquivos
Persistência
Dados permanentes
Projeto
Diário digital
📚 Conteúdo da Aula
💾 Introdução ao Mundo dos Arquivos
Por que Salvar Informações?
Até agora nossos programas "esqueciam" tudo quando fechávamos! Hora de aprender a criar memórias permanentes!
🤔 O que são Arquivos?
Analogia do Caderno:
Imagine um caderno mágico! Quando você escreve nele, as palavras ficam lá para sempre. Quando abrir novamente, tudo estará exatamente como deixou!
🌟 Benefícios da Persistência:
Memória Permanente
Dados sobrevivem ao fechamento do programa
Histórico Completo
Acumular informações ao longo do tempo
Compartilhamento
Enviar dados para outras pessoas
Backup Seguro
Proteger informações importantes
📁 Tipos de Arquivos que Vamos Usar:
.txt
Texto simples e universal
.csv
Dados em tabelas
.json
Dados estruturados
.log
Registros de atividades
💡 Conceito-chave: Arquivos são como gavetas digitais - você guarda coisas dentro e pode abrir depois para pegar de volta!
📖 Operações Básicas com Arquivos
Os 4 Pilares da Manipulação de Arquivos
Assim como um bibliotecário, precisamos saber: criar, ler, escrever e organizar nossos arquivos!
🔧 Operações Fundamentais:
ESCREVER (Write)
Modo 'w': Substitui tudo (cuidado!)
Modo 'a': Adiciona no final (append)
with open("arquivo.txt", "w") as f:
f.write("Novo conteúdo")
LER (Read)
read(): Lê tudo de uma vez
readline(): Lê linha por linha
with open("arquivo.txt", "r") as f:
conteudo = f.read()
POSICIONAR (Seek)
seek(0): Volta ao início
tell(): Mostra posição atual
with open("arquivo.txt", "r") as f:
f.seek(0) # Início do arquivo
VERIFICAR (Check)
exists(): Arquivo existe?
try/except: Trata erros
import os
if os.path.exists("arquivo.txt"):
print("Arquivo encontrado!")
🛡️ O Comando Mágico: with
❌ Modo Perigoso
# NUNCA faça assim!
arquivo = open("dados.txt", "w")
arquivo.write("texto")
# E se der erro aqui?
# O arquivo pode ficar aberto!
Arquivo pode não fechar corretamente
✅ Modo Seguro
# SEMPRE faça assim!
with open("dados.txt", "w") as arquivo:
arquivo.write("texto")
# Arquivo fecha automaticamente!
Arquivo sempre fecha, mesmo com erro
🧪 Testando Todas as Operações:
# 📁 LABORATÓRIO DE ARQUIVOS 📁
import os
from datetime import datetime
def demonstrar_operacoes():
"""Demonstra todas as operações com arquivos"""
print("🔬 LABORATÓRIO DE MANIPULAÇÃO DE ARQUIVOS")
print("=" * 50)
nome_arquivo = "teste_laboratorio.txt"
# 1. VERIFICAR SE ARQUIVO EXISTE
print("\n1️⃣ Verificando se arquivo existe...")
if os.path.exists(nome_arquivo):
print(f"✅ {nome_arquivo} já existe!")
else:
print(f"❌ {nome_arquivo} não existe ainda")
# 2. CRIAR E ESCREVER (modo 'w')
print("\n2️⃣ Criando arquivo e escrevendo...")
with open(nome_arquivo, "w", encoding="utf-8") as arquivo:
arquivo.write("🧪 Início do laboratório\n")
arquivo.write(f"📅 Data: {datetime.now().strftime('%d/%m/%Y %H:%M')}\n")
arquivo.write("🔬 Testando operações básicas\n")
print(f"✅ Arquivo {nome_arquivo} criado!")
# 3. ADICIONAR CONTEÚDO (modo 'a')
print("\n3️⃣ Adicionando mais conteúdo...")
with open(nome_arquivo, "a", encoding="utf-8") as arquivo:
arquivo.write("\n📝 Conteúdo adicionado depois\n")
arquivo.write("🎯 Este texto foi anexado!\n")
print("✅ Conteúdo adicionado!")
# 4. LER ARQUIVO COMPLETO
print("\n4️⃣ Lendo arquivo completo...")
with open(nome_arquivo, "r", encoding="utf-8") as arquivo:
conteudo = arquivo.read()
print("📖 CONTEÚDO DO ARQUIVO:")
print("-" * 30)
print(conteudo)
print("-" * 30)
# 5. LER LINHA POR LINHA
print("\n5️⃣ Lendo linha por linha...")
with open(nome_arquivo, "r", encoding="utf-8") as arquivo:
for numero, linha in enumerate(arquivo, 1):
print(f"Linha {numero}: {linha.strip()}")
# 6. CONTAR LINHAS E PALAVRAS
print("\n6️⃣ Estatísticas do arquivo...")
with open(nome_arquivo, "r", encoding="utf-8") as arquivo:
linhas = arquivo.readlines()
num_linhas = len(linhas)
num_palavras = sum(len(linha.split()) for linha in linhas)
num_caracteres = sum(len(linha) for linha in linhas)
print(f"📊 Estatísticas:")
print(f" 📝 Linhas: {num_linhas}")
print(f" 🔤 Palavras: {num_palavras}")
print(f" 📏 Caracteres: {num_caracteres}")
# 7. BUSCAR TEXTO ESPECÍFICO
print("\n7️⃣ Buscando texto específico...")
termo_busca = "laboratório"
with open(nome_arquivo, "r", encoding="utf-8") as arquivo:
for numero, linha in enumerate(arquivo, 1):
if termo_busca.lower() in linha.lower():
print(f"🔍 '{termo_busca}' encontrado na linha {numero}: {linha.strip()}")
# 8. CRIAR BACKUP
print("\n8️⃣ Criando backup...")
backup_nome = f"backup_{nome_arquivo}"
with open(nome_arquivo, "r", encoding="utf-8") as original:
with open(backup_nome, "w", encoding="utf-8") as backup:
backup.write(original.read())
print(f"💾 Backup criado: {backup_nome}")
# 9. LIMPAR ARQUIVOS DE TESTE
resposta = input("\n🗑️ Quer deletar os arquivos de teste? (s/n): ")
if resposta.lower() in ['s', 'sim']:
try:
os.remove(nome_arquivo)
os.remove(backup_nome)
print("🗑️ Arquivos de teste removidos!")
except FileNotFoundError:
print("❌ Alguns arquivos já não existiam")
print("\n🎉 Laboratório concluído!")
# Executar demonstração
if __name__ == "__main__":
demonstrar_operacoes()🛡️ Tratamento de Erros:
📁 FileNotFoundError
Tentar ler arquivo que não existe
try:
with open("inexistente.txt", "r") as f:
conteudo = f.read()
except FileNotFoundError:
print("❌ Arquivo não encontrado!")
🔒 PermissionError
Sem permissão para acessar arquivo
try:
with open("protegido.txt", "w") as f:
f.write("dados")
except PermissionError:
print("❌ Sem permissão!")
💡 Dicas Importantes:
- Sempre use encoding="utf-8" para caracteres especiais
- Prefira 'with' para abrir arquivos
- Trate erros com try/except
- Teste antes se o arquivo existe
📊 Formatos de Dados Estruturados
Organizando Dados Como um Profissional
Texto simples é bom, mas e se quisermos guardar listas, tabelas ou dados mais complexos? Vamos aprender os formatos profissionais!
📋 Formatos Essenciais:
CSV - Tabelas Simples
Comma Separated Values - Para dados em formato de planilha
nome,idade,cidade
Ana,12,São Paulo
João,11,Rio de Janeiro
Maria,13,Belo Horizonte
Usar quando: Listas de pessoas, produtos, notas, etc.
JSON - Dados Estruturados
JavaScript Object Notation - Para dados complexos e aninhados
{
"usuario": {
"nome": "Ana",
"idade": 12,
"hobbies": ["desenhar", "ler", "programar"]
}
}
Usar quando: Configurações, dados de apps, APIs
TXT - Texto Livre
Plain Text - Para texto natural e logs
[2024-07-12 10:30] Usuário fez login
[2024-07-12 10:35] Arquivo salvo
[2024-07-12 10:40] Sistema atualizado
Usar quando: Diários, logs, notas livres
🔧 Trabalhando com Diferentes Formatos:
# 📊 MANIPULAÇÃO DE DIFERENTES FORMATOS 📊
import csv
import json
from datetime import datetime
# ===== TRABALHANDO COM CSV =====
def exemplo_csv():
"""Demonstra operações com arquivos CSV"""
print("📊 EXEMPLO CSV - LISTA DE ESTUDANTES")
print("=" * 40)
# Dados de exemplo
estudantes = [
["Nome", "Idade", "Nota", "Cidade"],
["Ana Silva", 12, 9.5, "São Paulo"],
["João Santos", 11, 8.7, "Rio de Janeiro"],
["Maria Costa", 13, 9.2, "Belo Horizonte"],
["Pedro Lima", 12, 8.9, "Salvador"]
]
# Escrever CSV
with open("estudantes.csv", "w", newline="", encoding="utf-8") as arquivo:
escritor = csv.writer(arquivo)
escritor.writerows(estudantes)
print("✅ Arquivo CSV criado!")
# Ler CSV
with open("estudantes.csv", "r", encoding="utf-8") as arquivo:
leitor = csv.reader(arquivo)
print("\n📖 Conteúdo do CSV:")
for i, linha in enumerate(leitor):
if i == 0:
print("CABEÇALHO:", " | ".join(linha))
print("-" * 50)
else:
print(f"Estudante {i}: {linha[0]}, {linha[1]} anos, nota {linha[2]}")
# Calcular estatísticas
with open("estudantes.csv", "r", encoding="utf-8") as arquivo:
leitor = csv.DictReader(arquivo)
notas = []
for linha in leitor:
notas.append(float(linha["Nota"]))
media = sum(notas) / len(notas)
print(f"\n📊 Média da turma: {media:.2f}")
# ===== TRABALHANDO COM JSON =====
def exemplo_json():
"""Demonstra operações com arquivos JSON"""
print("\n⚙️ EXEMPLO JSON - PERFIL COMPLETO")
print("=" * 40)
# Dados estruturados
perfil_usuario = {
"informacoes_pessoais": {
"nome": "Ana Programadora",
"idade": 12,
"cidade": "São Paulo",
"email": "ana@exemplo.com"
},
"interesses": ["programação", "matemática", "desenho", "música"],
"conquistas": {
"projetos_concluidos": 15,
"linguagens_aprendidas": ["Python", "HTML", "CSS"],
"certificados": [
{"nome": "Python Básico", "data": "2024-06-15"},
{"nome": "Web Design", "data": "2024-07-01"}
]
},
"configuracoes": {
"tema": "escuro",
"notificacoes": True,
"idioma": "pt-BR"
}
}
# Salvar JSON
with open("perfil_usuario.json", "w", encoding="utf-8") as arquivo:
json.dump(perfil_usuario, arquivo, indent=4, ensure_ascii=False)
print("✅ Arquivo JSON criado!")
# Carregar JSON
with open("perfil_usuario.json", "r", encoding="utf-8") as arquivo:
dados = json.load(arquivo)
print("\n📖 Dados carregados do JSON:")
print(f"Nome: {dados['informacoes_pessoais']['nome']}")
print(f"Idade: {dados['informacoes_pessoais']['idade']} anos")
print(f"Interesses: {', '.join(dados['interesses'])}")
print(f"Projetos: {dados['conquistas']['projetos_concluidos']}")
# Modificar dados
dados['conquistas']['projetos_concluidos'] += 1
dados['interesses'].append("robótica")
# Salvar modificações
with open("perfil_usuario.json", "w", encoding="utf-8") as arquivo:
json.dump(dados, arquivo, indent=4, ensure_ascii=False)
print("✅ Dados atualizados!")
# ===== TRABALHANDO COM LOGS =====
def exemplo_logs():
"""Demonstra sistema de logs"""
print("\n📝 EXEMPLO LOGS - ATIVIDADES DO SISTEMA")
print("=" * 40)
def adicionar_log(atividade, nivel="INFO"):
"""Adiciona entrada no log"""
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
with open("sistema.log", "a", encoding="utf-8") as arquivo:
arquivo.write(f"[{timestamp}] {nivel}: {atividade}\n")
# Simular atividades
atividades = [
("Sistema iniciado", "INFO"),
("Usuário fez login", "INFO"),
("Arquivo importante aberto", "INFO"),
("Tentativa de acesso negada", "WARNING"),
("Dados salvos com sucesso", "INFO"),
("Erro de conexão", "ERROR"),
("Sistema finalizado", "INFO")
]
for atividade, nivel in atividades:
adicionar_log(atividade, nivel)
print("✅ Logs registrados!")
# Ler e analisar logs
with open("sistema.log", "r", encoding="utf-8") as arquivo:
logs = arquivo.readlines()
print(f"\n📋 Total de logs: {len(logs)}")
# Contar por nível
niveis = {"INFO": 0, "WARNING": 0, "ERROR": 0}
for log in logs:
for nivel in niveis:
if nivel in log:
niveis[nivel] += 1
print("📊 Logs por nível:")
for nivel, quantidade in niveis.items():
emoji = "ℹ️" if nivel == "INFO" else "⚠️" if nivel == "WARNING" else "❌"
print(f" {emoji} {nivel}: {quantidade}")
# Executar exemplos
if __name__ == "__main__":
exemplo_csv()
exemplo_json()
exemplo_logs()
print("\n🎉 Todos os exemplos executados!")🆚 Comparação de Formatos:
Aspecto
📝 TXT
📊 CSV
⚙️ JSON
Simplicidade
⭐⭐⭐⭐⭐
⭐⭐⭐⭐
⭐⭐⭐
Estrutura
⭐
⭐⭐⭐
⭐⭐⭐⭐⭐
Tamanho
⭐⭐⭐⭐⭐
⭐⭐⭐⭐
⭐⭐⭐
Legibilidade
⭐⭐⭐⭐⭐
⭐⭐⭐
⭐⭐⭐⭐
📔 Projeto Principal - Diário Digital Completo
🚀 Criando um Sistema de Diário Profissional!
Vamos construir um diário digital completo com todas as funcionalidades que você pode imaginar!
🌟 Recursos do Nosso Diário:
Múltiplas Entradas
Escrever várias vezes por dia
Busca Inteligente
Encontrar textos específicos
Estatísticas
Quantas palavras você escreveu
Backup Automático
Nunca perder suas memórias
Tags e Categorias
Organizar por assuntos
Humor do Dia
Registrar como se sente
📱 Código Completo - Diário Digital:
# 📔 DIÁRIO DIGITAL COMPLETO 📔
import json
import os
from datetime import datetime, date
import re
class DiarioDigital:
"""Sistema completo de diário pessoal"""
def __init__(self):
self.arquivo_diario = "meu_diario.json"
self.arquivo_config = "diario_config.json"
self.inicializar_arquivos()
def inicializar_arquivos(self):
"""Cria arquivos se não existirem"""
# Arquivo do diário
if not os.path.exists(self.arquivo_diario):
dados_iniciais = {
"entradas": [],
"estatisticas": {
"total_entradas": 0,
"total_palavras": 0,
"primeiro_uso": datetime.now().strftime("%Y-%m-%d")
}
}
self.salvar_dados(dados_iniciais)
# Arquivo de configurações
if not os.path.exists(self.arquivo_config):
config_inicial = {
"nome_usuario": "Escritor(a)",
"tema_favorito": "📝 Reflexões",
"lembrete_ativado": True,
"backup_automatico": True
}
with open(self.arquivo_config, "w", encoding="utf-8") as f:
json.dump(config_inicial, f, indent=4, ensure_ascii=False)
def carregar_dados(self):
"""Carrega dados do diário"""
try:
with open(self.arquivo_diario, "r", encoding="utf-8") as f:
return json.load(f)
except (FileNotFoundError, json.JSONDecodeError):
return {"entradas": [], "estatisticas": {}}
def salvar_dados(self, dados):
"""Salva dados no diário"""
with open(self.arquivo_diario, "w", encoding="utf-8") as f:
json.dump(dados, f, indent=4, ensure_ascii=False)
def carregar_configuracoes(self):
"""Carrega configurações do usuário"""
try:
with open(self.arquivo_config, "r", encoding="utf-8") as f:
return json.load(f)
except (FileNotFoundError, json.JSONDecodeError):
return {}
def adicionar_entrada(self):
"""Adiciona nova entrada no diário"""
dados = self.carregar_dados()
config = self.carregar_configuracoes()
print("\n📝 NOVA ENTRADA NO DIÁRIO")
print("=" * 40)
# Informações da entrada
titulo = input("📖 Título da entrada (opcional): ").strip()
if not titulo:
titulo = f"Entrada de {datetime.now().strftime('%d/%m/%Y')}"
print("\n🏷️ Categorias disponíveis:")
categorias = ["📝 Pessoal", "🎓 Estudos", "🎮 Diversão", "💭 Reflexões", "🎯 Metas", "📚 Livros", "🎵 Música"]
for i, cat in enumerate(categorias, 1):
print(f"{i}. {cat}")
try:
escolha_cat = int(input("Escolha uma categoria (1-7): ")) - 1
categoria = categorias[escolha_cat] if 0 <= escolha_cat < len(categorias) else "📝 Pessoal"
except ValueError:
categoria = "📝 Pessoal"
# Humor do dia
print("\n😊 Como você está se sentindo?")
humores = ["😊 Feliz", "😌 Calmo", "😴 Cansado", "😟 Preocupado", "😍 Animado", "🤔 Pensativo"]
for i, humor in enumerate(humores, 1):
print(f"{i}. {humor}")
try:
escolha_humor = int(input("Escolha seu humor (1-6): ")) - 1
humor = humores[escolha_humor] if 0 <= escolha_humor < len(humores) else "😊 Feliz"
except ValueError:
humor = "😊 Feliz"
# Texto principal
print("\n✍️ Escreva sua entrada (digite 'FIM' em uma linha para terminar):")
linhas_texto = []
while True:
linha = input()
if linha.upper() == "FIM":
break
linhas_texto.append(linha)
texto = "\n".join(linhas_texto)
if not texto.strip():
print("❌ Entrada vazia não foi salva!")
return
# Criar entrada
entrada = {
"id": len(dados["entradas"]) + 1,
"data": datetime.now().strftime("%Y-%m-%d"),
"hora": datetime.now().strftime("%H:%M"),
"titulo": titulo,
"categoria": categoria,
"humor": humor,
"texto": texto,
"palavras": len(texto.split()),
"caracteres": len(texto)
}
# Adicionar aos dados
dados["entradas"].append(entrada)
# Atualizar estatísticas
if "estatisticas" not in dados:
dados["estatisticas"] = {}
dados["estatisticas"]["total_entradas"] = len(dados["entradas"])
dados["estatisticas"]["total_palavras"] = sum(e["palavras"] for e in dados["entradas"])
dados["estatisticas"]["ultima_entrada"] = datetime.now().strftime("%Y-%m-%d %H:%M")
# Salvar
self.salvar_dados(dados)
print(f"\n✅ Entrada '{titulo}' salva com sucesso!")
print(f"📊 {entrada['palavras']} palavras, {entrada['caracteres']} caracteres")
# Backup automático
if config.get("backup_automatico", True):
self.criar_backup()
def listar_entradas(self):
"""Lista todas as entradas"""
dados = self.carregar_dados()
entradas = dados.get("entradas", [])
if not entradas:
print("📭 Nenhuma entrada encontrada!")
return
print(f"\n📚 SUAS ENTRADAS ({len(entradas)} total)")
print("=" * 50)
for entrada in reversed(entradas[-10:]): # Últimas 10
print(f"\n📖 {entrada['titulo']}")
print(f"📅 {entrada['data']} às {entrada['hora']}")
print(f"🏷️ {entrada['categoria']} | {entrada['humor']}")
print(f"📝 {entrada['palavras']} palavras")
# Prévia do texto (primeiras 100 caracteres)
preview = entrada['texto'][:100]
if len(entrada['texto']) > 100:
preview += "..."
print(f"💭 {preview}")
print("-" * 40)
def buscar_entradas(self):
"""Busca entradas por texto"""
dados = self.carregar_dados()
entradas = dados.get("entradas", [])
if not entradas:
print("📭 Nenhuma entrada para buscar!")
return
termo = input("\n🔍 Digite o termo para buscar: ").strip().lower()
if not termo:
return
resultados = []
for entrada in entradas:
# Buscar no título e texto
if (termo in entrada['titulo'].lower() or
termo in entrada['texto'].lower() or
termo in entrada['categoria'].lower()):
resultados.append(entrada)
if not resultados:
print(f"❌ Nenhuma entrada encontrada com '{termo}'")
return
print(f"\n🎯 {len(resultados)} entrada(s) encontrada(s):")
print("=" * 40)
for entrada in resultados:
print(f"\n📖 {entrada['titulo']}")
print(f"📅 {entrada['data']} | 🏷️ {entrada['categoria']}")
# Destacar termo encontrado
texto_highlight = entrada['texto']
padrao = re.compile(re.escape(termo), re.IGNORECASE)
texto_highlight = padrao.sub(f"**{termo.upper()}**", texto_highlight)
preview = texto_highlight[:150]
if len(texto_highlight) > 150:
preview += "..."
print(f"💭 {preview}")
print("-" * 30)
def estatisticas_diario(self):
"""Mostra estatísticas detalhadas"""
dados = self.carregar_dados()
entradas = dados.get("entradas", [])
if not entradas:
print("📊 Nenhuma estatística disponível ainda!")
return
print("\n📊 ESTATÍSTICAS DO SEU DIÁRIO")
print("=" * 40)
# Estatísticas gerais
total_entradas = len(entradas)
total_palavras = sum(e["palavras"] for e in entradas)
total_caracteres = sum(e["caracteres"] for e in entradas)
media_palavras = total_palavras / total_entradas if total_entradas > 0 else 0
print(f"📚 Total de entradas: {total_entradas}")
print(f"📝 Total de palavras: {total_palavras:,}")
print(f"📏 Total de caracteres: {total_caracteres:,}")
print(f"📊 Média de palavras por entrada: {media_palavras:.1f}")
# Entrada mais longa
if entradas:
entrada_longa = max(entradas, key=lambda x: x["palavras"])
print(f"📖 Entrada mais longa: '{entrada_longa['titulo']}' ({entrada_longa['palavras']} palavras)")
# Estatísticas por categoria
categorias = {}
for entrada in entradas:
cat = entrada["categoria"]
if cat not in categorias:
categorias[cat] = 0
categorias[cat] += 1
print(f"\n🏷️ ENTRADAS POR CATEGORIA:")
for categoria, quantidade in sorted(categorias.items(), key=lambda x: x[1], reverse=True):
print(f" {categoria}: {quantidade}")
# Estatísticas por humor
humores = {}
for entrada in entradas:
humor = entrada["humor"]
if humor not in humores:
humores[humor] = 0
humores[humor] += 1
print(f"\n😊 HUMORES REGISTRADOS:")
for humor, quantidade in sorted(humores.items(), key=lambda x: x[1], reverse=True):
print(f" {humor}: {quantidade}")
# Atividade por mês
meses = {}
for entrada in entradas:
data = datetime.strptime(entrada["data"], "%Y-%m-%d")
mes_ano = data.strftime("%Y-%m")
if mes_ano not in meses:
meses[mes_ano] = 0
meses[mes_ano] += 1
print(f"\n📅 ATIVIDADE POR MÊS:")
for mes, quantidade in sorted(meses.items()):
data_mes = datetime.strptime(mes, "%Y-%m")
nome_mes = data_mes.strftime("%B/%Y").title()
print(f" {nome_mes}: {quantidade} entradas")
def criar_backup(self):
"""Cria backup do diário"""
try:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
nome_backup = f"backup_diario_{timestamp}.json"
# Copiar arquivo principal
dados = self.carregar_dados()
with open(nome_backup, "w", encoding="utf-8") as f:
json.dump(dados, f, indent=4, ensure_ascii=False)
print(f"💾 Backup criado: {nome_backup}")
return nome_backup
except Exception as e:
print(f"❌ Erro ao criar backup: {e}")
return None
def configuracoes(self):
"""Gerencia configurações do diário"""
config = self.carregar_configuracoes()
print("\n⚙️ CONFIGURAÇÕES DO DIÁRIO")
print("=" * 30)
print("1. 👤 Alterar nome")
print("2. 🎨 Tema favorito")
print("3. 💾 Backup automático")
print("4. 🔙 Voltar")
try:
opcao = int(input("Escolha uma opção: "))
if opcao == 1:
novo_nome = input("Digite seu nome: ")
config["nome_usuario"] = novo_nome
print(f"✅ Nome alterado para {novo_nome}")
elif opcao == 2:
temas = ["📝 Reflexões", "🎓 Estudos", "🌟 Sonhos", "💭 Pensamentos"]
print("Temas disponíveis:")
for i, tema in enumerate(temas, 1):
print(f"{i}. {tema}")
escolha = int(input("Escolha: ")) - 1
if 0 <= escolha < len(temas):
config["tema_favorito"] = temas[escolha]
print(f"✅ Tema alterado para {temas[escolha]}")
elif opcao == 3:
config["backup_automatico"] = not config.get("backup_automatico", True)
status = "ativado" if config["backup_automatico"] else "desativado"
print(f"✅ Backup automático {status}")
# Salvar configurações
with open(self.arquivo_config, "w", encoding="utf-8") as f:
json.dump(config, f, indent=4, ensure_ascii=False)
except (ValueError, IndexError):
print("❌ Opção inválida!")
def menu_principal(self):
"""Menu principal do diário"""
config = self.carregar_configuracoes()
nome = config.get("nome_usuario", "Escritor(a)")
while True:
print(f"\n📔 DIÁRIO DIGITAL - Olá, {nome}! 📔")
print("=" * 50)
print("1. ✍️ Nova entrada")
print("2. 📚 Listar entradas")
print("3. 🔍 Buscar entradas")
print("4. 📊 Estatísticas")
print("5. 💾 Criar backup")
print("6. ⚙️ Configurações")
print("7. 🚪 Sair")
try:
opcao = int(input("\nEscolha uma opção: "))
if opcao == 1:
self.adicionar_entrada()
elif opcao == 2:
self.listar_entradas()
elif opcao == 3:
self.buscar_entradas()
elif opcao == 4:
self.estatisticas_diario()
elif opcao == 5:
self.criar_backup()
elif opcao == 6:
self.configuracoes()
elif opcao == 7:
print("👋 Até logo! Continue escrevendo suas memórias!")
break
else:
print("❌ Opção inválida! Escolha 1-7.")
input("\n⏸️ Pressione ENTER para continuar...")
except ValueError:
print("❌ Digite apenas números!")
except KeyboardInterrupt:
print("\n👋 Tchau!")
break
# Executar o diário
if __name__ == "__main__":
print("🎉 Bem-vindo ao seu Diário Digital!")
diario = DiarioDigital()
diario.menu_principal()⭐ Destaques do Projeto:
🧠 Programação Orientada a Objetos
Uso de classes para organizar código
📊 Análise de Dados
Estatísticas automáticas dos textos
🔍 Busca Inteligente
Encontrar texto usando regex
💾 Sistema de Backup
Proteção automática dos dados
💡 Conceitos Aplicados:
- JSON: Estruturação de dados complexos
- Datetime: Manipulação de datas e horas
- Regex: Busca avançada de padrões
- Exception Handling: Tratamento robusto de erros
- File Management: Organização de múltiplos arquivos
🏠 Desafios para Casa
🎬 Desafio Principal: Sistema de Filmes Favoritos
Crie um sistema completo para gerenciar sua coleção de filmes favoritos!
🎭 Recursos Obrigatórios:
- 🎬 Adicionar filmes (título, ano, gênero, nota)
- 📋 Listar todos os filmes
- 🔍 Buscar por título ou gênero
- ⭐ Sistema de avaliação (1-5 estrelas)
- 📊 Estatísticas (filme favorito, média, etc.)
- 💾 Salvar em arquivo CSV ou JSON
- 🏷️ Categorizar por gênero
🏗️ Estrutura Base do Sistema:
import csv
import json
from datetime import datetime
class CatalogoFilmes:
"""Sistema para gerenciar filmes favoritos"""
def __init__(self):
self.arquivo = "meus_filmes.json"
self.filmes = self.carregar_filmes()
def carregar_filmes(self):
"""Carrega filmes do arquivo"""
try:
with open(self.arquivo, "r", encoding="utf-8") as f:
return json.load(f)
except FileNotFoundError:
return []
def salvar_filmes(self):
"""Salva filmes no arquivo"""
with open(self.arquivo, "w", encoding="utf-8") as f:
json.dump(self.filmes, f, indent=4, ensure_ascii=False)
def adicionar_filme(self):
"""Adiciona novo filme ao catálogo"""
print("\n🎬 ADICIONAR NOVO FILME")
print("=" * 30)
titulo = input("📽️ Título do filme: ")
ano = int(input("📅 Ano de lançamento: "))
genero = input("🎭 Gênero: ")
nota = float(input("⭐ Sua nota (1-5): "))
# Sua implementação aqui...
pass
def listar_filmes(self):
"""Lista todos os filmes"""
# Sua implementação aqui...
pass
def buscar_filmes(self):
"""Busca filmes por critério"""
# Sua implementação aqui...
pass
def estatisticas(self):
"""Mostra estatísticas da coleção"""
# Sua implementação aqui...
pass
def menu_principal(self):
"""Menu principal do sistema"""
while True:
print("\n🎬 CATÁLOGO DE FILMES")
print("1. 📽️ Adicionar filme")
print("2. 📋 Listar filmes")
print("3. 🔍 Buscar filmes")
print("4. 📊 Estatísticas")
print("5. 🚪 Sair")
# Sua implementação aqui...
pass
# Executar
catalogo = CatalogoFilmes()
catalogo.menu_principal()🎯 Desafios Bônus:
Biblioteca Digital
Sistema para catalogar livros lidos
Playlist Manager
Gerenciar suas músicas favoritas
Sistema de Notas
Bloco de notas com categorias
Tracker de Hábitos
Acompanhar atividades diárias
Controle Financeiro
Registrar gastos e economia
Lista de Metas
Objetivos com progresso
🎓 O que Você Vai Aprender:
Manipulação avançada de arquivos
Estruturação de dados (CSV, JSON)
Algoritmos de busca e filtros
Análise estatística de dados
Sistemas de backup e recuperação
🌍 Aplicações no Mundo Real:
💼 Onde esses conceitos são usados:
- Bancos de Dados: MySQL, PostgreSQL, MongoDB
- Aplicativos: WhatsApp, Instagram, TikTok
- Sites: YouTube, Netflix, Spotify
- Jogos: Sistemas de save e ranking
- Empresas: Relatórios e análises
🌟 Você está aprendendo as bases da programação profissional!