Manipulação de arquivos é uma habilidade essencial para qualquer programador Python. Seja lendo logs de sistemas, processando planilhas CSV ou trabalhando com APIs JSON, saber trabalhar com arquivos é fundamental. Neste guia completo, você aprenderá a ler, escrever e manipular os principais formatos de arquivo: TXT, CSV e JSON.

🎯 Por Que Manipular Arquivos?

Arquivos são a forma mais comum de persistir dados. No Universo Python, imagine arquivos como "cápsulas de dados" que navegam entre diferentes sistemas e épocas - permitindo que informações sobrevivam além da execução do programa.

  • 📄 TXT - Arquivos de texto simples (logs, configurações)
  • 📊 CSV - Planilhas e dados tabulares
  • 🗂️ JSON - APIs, configurações estruturadas

📄 Arquivos de Texto (TXT)

Lendo Arquivos TXT

Python oferece várias formas de ler arquivos de texto. A mais segura é usar o gerenciador de contexto with, que fecha o arquivo automaticamente:

# Forma recomendada - with statement
with open('diario_bordo.txt', 'r', encoding='utf-8') as arquivo:
    conteudo = arquivo.read()
    print(conteudo)

# O arquivo é fechado automaticamente após o bloco with

Modos de Abertura

Modo Descrição Cria se não existir?
'r' Leitura (padrão) ❌ Erro se não existir
'w' Escrita (sobrescreve) ✅ Sim
'a' Append (adiciona ao final) ✅ Sim
'x' Criação exclusiva ❌ Erro se existir
'r+' Leitura e escrita ❌ Erro se não existir

Diferentes Formas de Leitura

# 1. Ler arquivo completo
with open('log.txt', 'r', encoding='utf-8') as f:
    texto_completo = f.read()
    print(texto_completo)

# 2. Ler linha por linha (eficiente para arquivos grandes)
with open('log.txt', 'r', encoding='utf-8') as f:
    for linha in f:
        print(linha.strip())  # strip() remove \n

# 3. Ler todas as linhas em uma lista (útil com técnicas de listas)
with open('log.txt', 'r', encoding='utf-8') as f:
    linhas = f.readlines()
    print(f"Total de linhas: {len(linhas)}")

# 4. Ler N caracteres
with open('log.txt', 'r', encoding='utf-8') as f:
    primeiros_100 = f.read(100)
    print(primeiros_100)

Escrevendo em Arquivos TXT

# Escrever (sobrescreve arquivo existente)
with open('relatorio.txt', 'w', encoding='utf-8') as f:
    f.write("=== RELATÓRIO DE MISSÃO ===\n")
    f.write("Data: 2026-01-05\n")
    f.write("Status: Missão bem-sucedida\n")

# Adicionar ao final (append)
with open('relatorio.txt', 'a', encoding='utf-8') as f:
    f.write("\nObservação adicional: Combustível baixo\n")

# Escrever múltiplas linhas (como vimos em strings)
linhas = [
    "Comandante: Ana Silva\n",
    "Copiloto: Carlos Santos\n",
    "Destino: Marte\n"
]

with open('tripulacao.txt', 'w', encoding='utf-8') as f:
    f.writelines(linhas)

Verificar se Arquivo Existe

import os

# Verificar existência
if os.path.exists('dados.txt'):
    print("✅ Arquivo encontrado!")
else:
    print("❌ Arquivo não existe!")

# Obter tamanho do arquivo
tamanho = os.path.getsize('dados.txt')
print(f"Tamanho: {tamanho} bytes")

# Verificar se é arquivo ou diretório
print(f"É arquivo? {os.path.isfile('dados.txt')}")
print(f"É diretório? {os.path.isdir('dados.txt')}")

📊 Arquivos CSV (Comma-Separated Values)

CSV é o formato padrão para planilhas e dados tabulares. Python tem um módulo nativo csv que facilita muito o trabalho:

Lendo CSV

import csv

# Ler CSV básico
with open('planetas.csv', 'r', encoding='utf-8') as arquivo:
    leitor = csv.reader(arquivo)
    
    # Pular cabeçalho
    next(leitor)
    
    for linha in leitor:
        nome, distancia, massa = linha
        print(f"{nome}: {distancia} km, {massa} kg")


# Ler CSV como dicionário (mais legível)
with open('planetas.csv', 'r', encoding='utf-8') as arquivo:
    leitor = csv.DictReader(arquivo)
    
    for planeta in leitor:
        print(f"Nome: {planeta['nome']}")
        print(f"Distância: {planeta['distancia_sol']}")
        print("-" * 40)

Escrevendo CSV

import csv

# Escrever CSV com listas
dados = [
    ['Nome', 'Idade', 'Cidade'],
    ['Ana Silva', 28, 'São Paulo'],
    ['Bruno Costa', 35, 'Rio de Janeiro'],
    ['Carla Santos', 42, 'Belo Horizonte']
]

with open('usuarios.csv', 'w', newline='', encoding='utf-8') as arquivo:
    escritor = csv.writer(arquivo)
    escritor.writerows(dados)


# Escrever CSV com dicionários (técnica usada em dicionários)
usuarios = [
    {'nome': 'Ana Silva', 'idade': 28, 'email': '[email protected]'},
    {'nome': 'Bruno Costa', 'idade': 35, 'email': '[email protected]'},
    {'nome': 'Carla Santos', 'idade': 42, 'email': '[email protected]'}
]

with open('usuarios.csv', 'w', newline='', encoding='utf-8') as arquivo:
    campos = ['nome', 'idade', 'email']
    escritor = csv.DictWriter(arquivo, fieldnames=campos)
    
    escritor.writeheader()  # Escreve cabeçalho
    escritor.writerows(usuarios)

CSV com Diferentes Delimitadores

import csv

# CSV com ponto e vírgula (comum em Excel Brasil)
with open('dados.csv', 'r', encoding='utf-8') as arquivo:
    leitor = csv.reader(arquivo, delimiter=';')
    for linha in leitor:
        print(linha)

# CSV com tabulação
with open('dados.tsv', 'r', encoding='utf-8') as arquivo:
    leitor = csv.reader(arquivo, delimiter='\t')
    for linha in leitor:
        print(linha)

🗂️ Arquivos JSON (JavaScript Object Notation)

JSON é o formato mais usado para APIs e troca de dados estruturados. É praticamente idêntico aos dicionários Python!

Lendo JSON

import json

# Ler arquivo JSON
with open('configuracao.json', 'r', encoding='utf-8') as arquivo:
    config = json.load(arquivo)
    
    print(config['nome'])
    print(config['versao'])
    print(config['ativo'])


# Converter string JSON para dict
json_string = '{"nome": "Python", "versao": 3.12, "ativo": true}'
dados = json.loads(json_string)
print(type(dados))  #

Escrevendo JSON

import json

# Dicionário Python
nave = {
    "nome": "USS Enterprise",
    "tripulacao": 430,
    "velocidade_maxima": 9.9,
    "ativa": True,
    "sistemas": ["propulsao", "armamento", "escudos"],
    "comandante": {
        "nome": "James T. Kirk",
        "patente": "Capitão"
    }
}

# Salvar em arquivo JSON
with open('nave.json', 'w', encoding='utf-8') as arquivo:
    json.dump(nave, arquivo, indent=2, ensure_ascii=False)

# Converter dict para string JSON
json_string = json.dumps(nave, indent=2, ensure_ascii=False)
print(json_string)

Parâmetros Importantes do JSON

import json

dados = {"nome": "Python", "símbolo": "🐍"}

# indent - formata com indentação
print(json.dumps(dados, indent=4))

# ensure_ascii=False - permite caracteres especiais
print(json.dumps(dados, ensure_ascii=False))

# sort_keys - ordena chaves alfabeticamente
print(json.dumps(dados, sort_keys=True))

# Exemplo completo formatado
with open('dados.json', 'w', encoding='utf-8') as f:
    json.dump(
        dados,
        f,
        indent=4,
        ensure_ascii=False,
        sort_keys=True
    )

🎯 Projeto Prático: Sistema de Log de Missões Espaciais

Vamos criar um sistema completo que trabalha com os 3 formatos de arquivo, usando conceitos de funções e POO:

import json
import csv
from datetime import datetime
import os

class SistemaLogMissoes:
    """Gerencia logs de missões espaciais em múltiplos formatos"""
    
    def __init__(self, diretorio='logs'):
        self.diretorio = diretorio
        self._criar_diretorio()
    
    def _criar_diretorio(self):
        """Cria diretório se não existir"""
        if not os.path.exists(self.diretorio):
            os.makedirs(self.diretorio)
            print(f"📁 Diretório '{self.diretorio}' criado")
    
    def registrar_missao_txt(self, comandante, destino, status):
        """Registra missão em arquivo TXT (log simples)"""
        arquivo = os.path.join(self.diretorio, 'missoes.txt')
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        
        with open(arquivo, 'a', encoding='utf-8') as f:
            f.write(f"[{timestamp}] Comandante: {comandante} | ")
            f.write(f"Destino: {destino} | Status: {status}\n")
        
        print(f"✅ Missão registrada em TXT")
    
    def registrar_missao_csv(self, missao_dict):
        """Registra missão em CSV (dados tabulares)"""
        arquivo = os.path.join(self.diretorio, 'missoes.csv')
        arquivo_existe = os.path.exists(arquivo)
        
        campos = ['data', 'comandante', 'destino', 'duracao_dias', 
                  'tripulacao', 'status', 'combustivel_usado']
        
        with open(arquivo, 'a', newline='', encoding='utf-8') as f:
            writer = csv.DictWriter(f, fieldnames=campos)
            
            if not arquivo_existe:
                writer.writeheader()
            
            writer.writerow(missao_dict)
        
        print(f"✅ Missão registrada em CSV")
    
    def registrar_missao_json(self, missao_completa):
        """Registra missão completa em JSON (estrutura complexa)"""
        arquivo = os.path.join(self.diretorio, 'missoes.json')
        
        # Ler dados existentes
        if os.path.exists(arquivo):
            with open(arquivo, 'r', encoding='utf-8') as f:
                try:
                    missoes = json.load(f)
                except json.JSONDecodeError:
                    missoes = []
        else:
            missoes = []
        
        # Adicionar nova missão
        missoes.append(missao_completa)
        
        # Salvar tudo
        with open(arquivo, 'w', encoding='utf-8') as f:
            json.dump(missoes, f, indent=2, ensure_ascii=False)
        
        print(f"✅ Missão registrada em JSON")
    
    def listar_missoes_txt(self):
        """Lista todas as missões do log TXT"""
        arquivo = os.path.join(self.diretorio, 'missoes.txt')
        
        if not os.path.exists(arquivo):
            print("📭 Nenhuma missão registrada em TXT")
            return
        
        print("\n" + "="*60)
        print("📋 LOG DE MISSÕES (TXT)")
        print("="*60)
        
        with open(arquivo, 'r', encoding='utf-8') as f:
            for linha in f:
                print(linha.strip())
    
    def listar_missoes_csv(self):
        """Lista missões do CSV"""
        arquivo = os.path.join(self.diretorio, 'missoes.csv')
        
        if not os.path.exists(arquivo):
            print("📭 Nenhuma missão registrada em CSV")
            return
        
        print("\n" + "="*60)
        print("📊 RELATÓRIO DE MISSÕES (CSV)")
        print("="*60)
        
        with open(arquivo, 'r', encoding='utf-8') as f:
            reader = csv.DictReader(f)
            
            for missao in reader:
                print(f"\n🚀 {missao['comandante']} → {missao['destino']}")
                print(f"   📅 Data: {missao['data']}")
                print(f"   👥 Tripulação: {missao['tripulacao']} pessoas")
                print(f"   ⏱️ Duração: {missao['duracao_dias']} dias")
                print(f"   ⛽ Combustível: {missao['combustivel_usado']}L")
                print(f"   ✅ Status: {missao['status']}")
    
    def listar_missoes_json(self):
        """Lista missões completas do JSON"""
        arquivo = os.path.join(self.diretorio, 'missoes.json')
        
        if not os.path.exists(arquivo):
            print("📭 Nenhuma missão registrada em JSON")
            return
        
        print("\n" + "="*60)
        print("🗂️ ARQUIVO COMPLETO DE MISSÕES (JSON)")
        print("="*60)
        
        with open(arquivo, 'r', encoding='utf-8') as f:
            missoes = json.load(f)
            
            for i, missao in enumerate(missoes, 1):
                print(f"\n📄 MISSÃO #{i}")
                print(f"   Nave: {missao['nave']['nome']}")
                print(f"   Comandante: {missao['comandante']['nome']} ({missao['comandante']['patente']})")
                print(f"   Destino: {missao['destino']}")
                print(f"   Status: {missao['status']}")
                
                if missao.get('relatorio'):
                    print(f"   📝 Relatório: {missao['relatorio']}")
    
    def estatisticas(self):
        """Mostra estatísticas dos logs"""
        print("\n" + "="*60)
        print("📊 ESTATÍSTICAS DO SISTEMA")
        print("="*60)
        
        # TXT
        arquivo_txt = os.path.join(self.diretorio, 'missoes.txt')
        if os.path.exists(arquivo_txt):
            with open(arquivo_txt, 'r') as f:
                linhas_txt = len(f.readlines())
            print(f"📄 Logs TXT: {linhas_txt} entradas")
        
        # CSV
        arquivo_csv = os.path.join(self.diretorio, 'missoes.csv')
        if os.path.exists(arquivo_csv):
            with open(arquivo_csv, 'r') as f:
                leitor = csv.reader(f)
                linhas_csv = len(list(leitor)) - 1  # -1 por causa do cabeçalho
            print(f"📊 Registros CSV: {linhas_csv} missões")
        
        # JSON
        arquivo_json = os.path.join(self.diretorio, 'missoes.json')
        if os.path.exists(arquivo_json):
            with open(arquivo_json, 'r') as f:
                missoes_json = json.load(f)
            print(f"🗂️ Missões JSON: {len(missoes_json)} completas")


# === USANDO O SISTEMA ===

sistema = SistemaLogMissoes()

# 1. Registrar log simples (TXT)
sistema.registrar_missao_txt(
    comandante="Ana Silva",
    destino="Marte",
    status="Em andamento"
)

# 2. Registrar dados tabulares (CSV)
missao_csv = {
    'data': '2026-01-05',
    'comandante': 'Bruno Costa',
    'destino': 'Júpiter',
    'duracao_dias': 180,
    'tripulacao': 6,
    'status': 'Concluída',
    'combustivel_usado': 45000
}
sistema.registrar_missao_csv(missao_csv)

# 3. Registrar estrutura completa (JSON)
missao_json = {
    "data": "2026-01-05",
    "nave": {
        "nome": "USS Enterprise",
        "modelo": "NCC-1701"
    },
    "comandante": {
        "nome": "Carla Santos",
        "patente": "Capitã"
    },
    "destino": "Alpha Centauri",
    "tripulacao": 430,
    "duracao_estimada_dias": 365,
    "status": "Planejada",
    "sistemas_criticos": ["propulsao", "escudos", "suporte_vital"],
    "relatorio": "Missão de exploração científica com 3 objetivos principais"
}
sistema.registrar_missao_json(missao_json)

# Listar todos os formatos
sistema.listar_missoes_txt()
sistema.listar_missoes_csv()
sistema.listar_missoes_json()

# Estatísticas
sistema.estatisticas()

💡 Boas Práticas com Arquivos

  1. Sempre use 'with': Garante fechamento automático do arquivo
  2. Especifique encoding: Use encoding='utf-8' para evitar problemas com acentos
  3. Trate exceções: Arquivos podem não existir ou ter permissões negadas
  4. Use caminhos absolutos: Ou os.path.join() para compatibilidade
  5. Valide dados: Antes de escrever, especialmente em JSON
  6. Faça backup: Antes de sobrescrever arquivos importantes
import os
import shutil
from datetime import datetime

def salvar_com_backup(arquivo, dados):
    """Salva dados criando backup do arquivo original"""
    
    # Criar backup se arquivo existir
    if os.path.exists(arquivo):
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        backup = f"{arquivo}.backup_{timestamp}"
        shutil.copy2(arquivo, backup)
        print(f"💾 Backup criado: {backup}")
    
    # Salvar novos dados
    try:
        with open(arquivo, 'w', encoding='utf-8') as f:
            f.write(dados)
        print(f"✅ Arquivo salvo: {arquivo}")
        return True
    except Exception as e:
        print(f"❌ Erro ao salvar: {e}")
        return False

⚠️ Tratamento de Erros

import json

def ler_json_seguro(arquivo):
    """Lê JSON com tratamento de erros"""
    try:
        with open(arquivo, 'r', encoding='utf-8') as f:
            dados = json.load(f)
            return dados
    except FileNotFoundError:
        print(f"❌ Arquivo '{arquivo}' não encontrado")
        return None
    except json.JSONDecodeError as e:
        print(f"❌ JSON inválido: {e}")
        return None
    except PermissionError:
        print(f"❌ Sem permissão para ler '{arquivo}'")
        return None
    except Exception as e:
        print(f"❌ Erro inesperado: {e}")
        return None


# Usando
dados = ler_json_seguro('config.json')
if dados:
    print(f"✅ Dados carregados: {dados}")
else:
    print("⚠️ Usando configuração padrão")
    dados = {"default": True}

🚀 Próximos Passos

Agora que você domina manipulação de arquivos, explore tópicos relacionados:

  • Strings em Python - Essencial para processar texto de arquivos
  • Listas em Python - Trabalhe com múltiplas linhas
  • Dicionários - Estrutura perfeita para JSON
  • Funções - Organize código de manipulação
  • POO em Python - Crie classes para gerenciar arquivos
  • Pandas - Manipulação avançada de CSV e dados
  • pathlib - Caminho moderno de arquivos
  • Serialização com Pickle

Quer dominar Python completamente? Confira nosso curso completo de Python do zero ao avançado com projetos reais de processamento de dados!

📝 Resumo

Neste guia completo sobre manipulação de arquivos em Python, você aprendeu:

  • ✅ Arquivos TXT - leitura, escrita e modos de abertura
  • ✅ Arquivos CSV - trabalhar com planilhas e dados tabulares
  • ✅ Arquivos JSON - estruturas complexas e APIs
  • ✅ Gerenciador de contexto (with statement)
  • ✅ Encoding e caracteres especiais
  • ✅ Módulos os e shutil para operações de arquivo
  • ✅ Projeto completo: Sistema de Log de Missões
  • ✅ Boas práticas e tratamento de erros
  • ✅ Backup e segurança de dados

Manipulação de arquivos é uma habilidade fundamental que você usará constantemente em projetos reais. Domine essas técnicas e você estará preparado para trabalhar com qualquer tipo de dados persistentes!