Automação de Planilhas Python — 2025 | Python Brasil
Automatize planilhas Excel com Python e openpyxl. Crie, leia e formate planilhas com exemplos práticos. Veja como!
A automação de planilhas é uma das aplicações mais práticas e imediatas de Python no ambiente corporativo. Profissionais de todas as áreas passam horas por semana criando relatórios, consolidando dados e formatando planilhas manualmente. Com a biblioteca openpyxl, é possível automatizar todas essas tarefas, economizando tempo e reduzindo erros.
Neste artigo, vamos aprender a criar, ler, modificar e formatar planilhas Excel usando Python, com exemplos que você pode aplicar diretamente no seu trabalho.
Instalação e primeiros passos
A biblioteca openpyxl não faz parte da biblioteca padrão do Python, mas pode ser instalada facilmente com pip:
# No terminal:
# pip install openpyxl
Após a instalação, já podemos criar nossa primeira planilha:
from openpyxl import Workbook
# Criando uma nova planilha
wb = Workbook()
ws = wb.active
ws.title = "Vendas"
# Adicionando cabeçalhos
cabecalhos = ["Produto", "Quantidade", "Preço Unitário", "Total"]
ws.append(cabecalhos)
# Adicionando dados
vendas = [
["Notebook", 15, 3500.00],
["Mouse", 120, 45.90],
["Teclado", 85, 129.90],
["Monitor", 30, 1299.00],
["Headset", 60, 199.90],
]
for venda in vendas:
produto, qtd, preco = venda
total = qtd * preco
ws.append([produto, qtd, preco, total])
wb.save("relatorio_vendas.xlsx")
print("Planilha criada com sucesso.")
Esse código simples já demonstra o poder da automação: criamos uma planilha completa com cabeçalhos, dados e cálculos em poucas linhas.
Lendo planilhas existentes
No dia a dia, é comum precisar ler dados de planilhas já existentes para processá-los de alguma forma:
from openpyxl import load_workbook
wb = load_workbook("relatorio_vendas.xlsx")
ws = wb.active
# Lendo todas as linhas
for linha in ws.iter_rows(min_row=2, values_only=True):
produto, quantidade, preco, total = linha
print(f"{produto}: {quantidade} unidades - R$ {total:,.2f}")
# Acessando células específicas
print(f"\nValor da célula A1: {ws['A1'].value}")
print(f"Valor da célula D2: {ws['D2'].value}")
# Obtendo dimensões da planilha
print(f"\nLinhas: {ws.max_row}")
print(f"Colunas: {ws.max_column}")
O parâmetro min_row=2 pula a linha de cabeçalho, e values_only=True retorna apenas os valores, sem os objetos Cell.
Formatação profissional
Uma planilha bem formatada comunica informações de maneira muito mais eficaz. O openpyxl oferece recursos completos de formatação:
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment, Border, Side, numbers
wb = Workbook()
ws = wb.active
ws.title = "Relatório Mensal"
# Definindo estilos
fonte_cabecalho = Font(name="Arial", size=12, bold=True, color="FFFFFF")
preenchimento_cabecalho = PatternFill(
start_color="2F5496", end_color="2F5496", fill_type="solid"
)
alinhamento_centro = Alignment(horizontal="center", vertical="center")
borda_fina = Border(
left=Side(style="thin"),
right=Side(style="thin"),
top=Side(style="thin"),
bottom=Side(style="thin"),
)
# Cabeçalhos
cabecalhos = ["Mês", "Receita", "Despesa", "Lucro"]
ws.append(cabecalhos)
# Aplicando formatação nos cabeçalhos
for col in range(1, 5):
celula = ws.cell(row=1, column=col)
celula.font = fonte_cabecalho
celula.fill = preenchimento_cabecalho
celula.alignment = alinhamento_centro
celula.border = borda_fina
# Dados mensais
meses = [
["Janeiro", 45000, 32000],
["Fevereiro", 52000, 35000],
["Março", 48000, 31000],
["Abril", 61000, 38000],
["Maio", 55000, 34000],
["Junho", 67000, 41000],
]
for mes_dados in meses:
mes, receita, despesa = mes_dados
lucro = receita - despesa
ws.append([mes, receita, despesa, lucro])
# Formatando valores como moeda
for linha in range(2, ws.max_row + 1):
for col in range(2, 5):
celula = ws.cell(row=linha, column=col)
celula.number_format = 'R$ #,##0.00'
celula.border = borda_fina
ws.cell(row=linha, column=1).border = borda_fina
# Ajustando largura das colunas
ws.column_dimensions["A"].width = 15
ws.column_dimensions["B"].width = 18
ws.column_dimensions["C"].width = 18
ws.column_dimensions["D"].width = 18
wb.save("relatorio_formatado.xlsx")
print("Relatório formatado salvo com sucesso.")
Fórmulas e cálculos automáticos
O openpyxl permite inserir fórmulas do Excel diretamente nas células:
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = "Orçamento"
# Cabeçalhos
ws.append(["Item", "Valor Previsto", "Valor Real", "Diferença"])
# Dados
itens = [
["Aluguel", 3000, 3000],
["Alimentação", 1500, 1720],
["Transporte", 600, 480],
["Educação", 800, 950],
["Lazer", 500, 380],
]
for i, item in enumerate(itens, 2):
ws.append(item[:3])
# Fórmula para calcular a diferença
ws[f"D{i}"] = f"=C{i}-B{i}"
# Linha de totais
ultima = len(itens) + 2
ws[f"A{ultima}"] = "TOTAL"
ws[f"B{ultima}"] = f"=SUM(B2:B{ultima-1})"
ws[f"C{ultima}"] = f"=SUM(C2:C{ultima-1})"
ws[f"D{ultima}"] = f"=SUM(D2:D{ultima-1})"
wb.save("orcamento.xlsx")
print("Orçamento com fórmulas criado.")
As fórmulas são escritas como strings e serão calculadas quando o arquivo for aberto no Excel ou LibreOffice Calc.
Trabalhando com múltiplas abas
Relatórios complexos frequentemente exigem múltiplas abas. O openpyxl facilita a criação e o gerenciamento de abas:
from openpyxl import Workbook
wb = Workbook()
# Renomeando a aba padrão
ws_resumo = wb.active
ws_resumo.title = "Resumo"
# Criando abas adicionais
ws_vendas = wb.create_sheet("Vendas")
ws_despesas = wb.create_sheet("Despesas")
# Preenchendo a aba de vendas
ws_vendas.append(["Região", "Total"])
regioes = [("Norte", 45000), ("Nordeste", 62000),
("Centro-Oeste", 38000), ("Sudeste", 95000), ("Sul", 71000)]
for regiao in regioes:
ws_vendas.append(regiao)
# Preenchendo a aba de despesas
ws_despesas.append(["Categoria", "Valor"])
despesas = [("Pessoal", 120000), ("Infraestrutura", 35000),
("Marketing", 28000), ("Logística", 42000)]
for despesa in despesas:
ws_despesas.append(despesa)
# Resumo com referências entre abas
ws_resumo.append(["Indicador", "Valor"])
ws_resumo.append(["Total Vendas", "=SUM(Vendas!B2:B6)"])
ws_resumo.append(["Total Despesas", "=SUM(Despesas!B2:B5)"])
wb.save("relatorio_completo.xlsx")
print("Relatório com múltiplas abas criado.")
Exemplo prático: consolidando relatórios
Um cenário muito comum é receber vários arquivos de diferentes departamentos e consolidá-los em um único relatório:
from openpyxl import load_workbook, Workbook
from pathlib import Path
def consolidar_planilhas(pasta_origem, arquivo_destino):
"""Consolida todas as planilhas de uma pasta em um único arquivo."""
wb_consolidado = Workbook()
ws = wb_consolidado.active
ws.title = "Consolidado"
ws.append(["Origem", "Produto", "Quantidade", "Valor"])
pasta = Path(pasta_origem)
arquivos = list(pasta.glob("*.xlsx"))
total_registros = 0
for arquivo in arquivos:
wb = load_workbook(arquivo, read_only=True)
ws_origem = wb.active
for linha in ws_origem.iter_rows(min_row=2, values_only=True):
ws.append([arquivo.stem] + list(linha))
total_registros += 1
wb.close()
wb_consolidado.save(arquivo_destino)
print(f"Consolidação concluída: {total_registros} registros de {len(arquivos)} arquivos.")
# Uso:
# consolidar_planilhas("relatorios_mensais", "consolidado_2025.xlsx")
Boas práticas
Para usar openpyxl de forma eficiente em projetos reais:
- Use
read_only=Trueao ler planilhas grandes para economizar memória. - Use
write_only=Trueao criar planilhas muito grandes para otimizar a performance. - Feche workbooks após o uso com
wb.close(), especialmente no modo somente leitura. - Valide os dados antes de escrevê-los na planilha para evitar erros silenciosos.
- Crie funções reutilizáveis para formatação, evitando repetição de código de estilo.
- Faça backup dos arquivos originais antes de modificá-los por script.
Conclusão
A automação de planilhas com Python e openpyxl é uma habilidade que gera retorno imediato. Tarefas que antes levavam horas podem ser concluídas em segundos, com menos erros e maior consistência. Seja para gerar relatórios, consolidar dados ou formatar documentos, o openpyxl oferece tudo o que você precisa.
Como próximos passos, explore a integração com Pandas para análise de dados mais avançada, ou combine openpyxl com automação de e-mails para enviar relatórios automaticamente aos destinatários.
Equipe Python Brasil
Contribuidor do Python Brasil — Aprenda Python em Português