Como automatizar planilhas do Excel com Python

✅ Artigo atualizado em Setembro 2026 (Python 3.10+, openpyxl 3.1) Novos exemplos práticos testados (somar coluna, fórmula =SUM, formatação, filtro para outra aba e relatório), tabela openpyxl vs pandas vs xlsxwriter, erros comuns com traceback e 8 exercícios resolvidos.

1
2
3
4
5

from openpyxl import load_workbook

ws = load_workbook('vendas.xlsx').active
total = sum(linha[2] for linha in ws.iter_rows(min_row=2, values_only=True))
print(total)  # 20 (soma da coluna C, a partir da linha 2)

Salve salve Pythonista!

O Excel é uma ferramenta muito poderosa para manipular e analisar dados, mas repetir as mesmas tarefas toda semana (copiar linhas, somar colunas, formatar relatórios) é tedioso e consome muito tempo.

Uma solução para isso é automatizar essas tarefas utilizando Python.

Neste artigo, vou mostrar como você pode usar o Python e a biblioteca openpyxl para automatizar tarefas no Excel: criar, ler, atualizar e formatar planilhas, usar fórmulas, filtrar dados para outra aba e gerar relatórios. No fim, tem uma tabela para escolher entre openpyxl, pandas e xlsxwriter, os erros mais comuns e exercícios resolvidos.

Então sem demoras, vamos nessa!

Vá Direto ao Assunto…

• Por que automatizar tarefas no Excel com Python?
• Instalando a biblioteca openpyxl
• Criando uma nova planilha
• Lendo dados de uma planilha existente
• Atualizando dados em uma planilha existente
• Como automatizar uma planilha do Excel com Python: 5 exemplos práticos
• openpyxl, pandas ou xlsxwriter: qual usar?
• Python no Excel ou Python com Excel: qual a diferença?
• Erros comuns
• Exercícios resolvidos

Por que automatizar tarefas no Excel com Python?

Automatizar tarefas no Excel com Python pode trazer diversos benefícios. Alguns deles incluem:

• Economia de tempo: Ao automatizar tarefas, você pode reduzir significativamente o tempo necessário para executá-las manualmente. Isso é particularmente útil quando você precisa lidar com grandes volumes de dados ou realizar manipulações complexas.

• Precisão: Ao utilizar o Python para manipular dados no Excel, você reduz o risco de erros humanos, como digitar valores incorretos ou aplicar fórmulas erradas.

• Flexibilidade: O Excel possui limitações em relação a certas tarefas de processamento e análise de dados. Com o Python, você pode implementar lógica personalizada e realizar manipulações mais complexas nos dados.

Agora que entende as vantagens de automatizar tarefas no Excel com Python, vamos ao desenvolvimento do nosso código!

Instalando a biblioteca openpyxl

Para começar, precisamos instalar a biblioteca openpyxl, que é a principal biblioteca para ler e escrever arquivos Excel (.xlsx) em Python. A referência completa está na documentação oficial do openpyxl.

Para instalar, basta executar o seguinte comando:

1

pip install openpyxl

De preferência, instale dentro de um ambiente virtual do projeto (veja como usar ambientes virtuais no Python).

Com a biblioteca instalada, podemos começar a escrever código para automatizar tarefas no Excel.

Criando uma nova planilha

Vamos começar criando uma nova planilha em branco com o nome “Exemplo.xlsx”.

Para fazer isso, utilizaremos a seguinte sequência de comandos em Python:

1
2
3
4
5
6
7
8
9
10
11
12
13

from openpyxl import Workbook

# Cria uma nova planilha em branco
wb = Workbook()

# Seleciona a planilha ativa
planilha = wb.active

# Define o valor da célula A1
planilha['A1'] = 'Olá, Excel com Python!'

# Salva o arquivo
wb.save('Exemplo.xlsx')

Neste exemplo, importamos a classe Workbook da biblioteca openpyxl.

Em seguida, criamos um objeto wb do tipo Workbook, que representa a planilha em branco.

Em seguida, selecionamos a planilha ativa usando o atributo active.

Depois disso, definimos o valor da célula A1 da planilha usando a notação de índice 'A1'.

No exemplo, atribuímos o texto Olá, Excel com Python! para a célula A1.

Por fim, salvamos o arquivo com o nome “Exemplo.xlsx” usando o método save do objeto wb.

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Lendo dados de uma planilha existente

Além de criar uma nova planilha, também podemos usar o Python para ler dados de uma planilha existente.

Para fazer isso, utilizamos a seguinte sequência de comandos:

1
2
3
4
5
6
7
8
9
10
11
12
13

from openpyxl import load_workbook

# Carrega o arquivo existente
wb = load_workbook('Exemplo.xlsx')

# Seleciona a planilha ativa
planilha = wb.active

# Lê o valor da célula A1
valor_celula = planilha['A1'].value

# Imprime o valor na tela
print(valor_celula)

Neste exemplo, importamos a função load_workbook da biblioteca openpyxl.

Em seguida, carregamos o arquivo “Exemplo.xlsx” usando a função load_workbook e atribuímos o objeto resultante à variável wb.

Depois disso, selecionamos a planilha ativa utilizando o atributo active.

Em seguida, lemos o valor da célula A1, utilizando a notação de índice 'A1', e atribuímos o valor à variável valor_celula.

Por fim, imprimimos o valor da célula A1 na tela utilizando a função print. Com o arquivo criado na seção anterior, a saída é:

1

Olá, Excel com Python!

Repare no .value: sem ele, planilha['A1'] devolve o objeto da célula (<Cell 'Sheet'.A1>), e não o conteúdo.

Criei o Ebookr.ai, uma plataforma que usa IA para gerar ebooks profissionais sobre qualquer tema - com capa gerada por IA, infográficos automáticos e exportação em PDF. Confere!

Atualizando dados em uma planilha existente

Além de ler dados de uma planilha existente, também podemos atualizar os dados usando o Python.

Para isso, utilizamos a seguinte sequência de comandos:

1
2
3
4
5
6
7
8
9
10
11
12
13

from openpyxl import load_workbook

# Carrega o arquivo existente
wb = load_workbook('Exemplo.xlsx')

# Seleciona a planilha ativa
planilha = wb.active

# Atualiza o valor da célula A1
planilha['A1'] = 'Novo valor'

# Salva o arquivo
wb.save('Exemplo.xlsx')

Neste exemplo, importamos a função load_workbook da biblioteca openpyxl.

Em seguida, carregamos o arquivo “Exemplo.xlsx” usando a função load_workbook e atribuímos o objeto resultante à variável wb.

Depois disso, selecionamos a planilha ativa utilizando o atributo active.

Em seguida, atualizamos o valor da célula A1, utilizando a notação de índice 'A1' e atribuímos o novo valor.

Por fim, salvamos o arquivo usando o método save do objeto wb.

Como automatizar uma planilha do Excel com Python: 5 exemplos práticos

Criar, ler e atualizar uma célula é o básico. Na vida real, automatizar uma planilha significa somar colunas, montar relatórios com fórmulas, deixar o arquivo apresentável e separar dados em abas. Os exemplos abaixo fazem exatamente isso e foram todos executados com Python 3.10 e openpyxl 3.1.

Preparando a planilha de exemplo

Primeiro, rode este script para criar o arquivo vendas.xlsx que os exemplos usam. Ele também mostra o método append, que escreve uma lista ou tupla inteira na próxima linha vazia:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from openpyxl import Workbook

vendas = [
    ('Produto', 'Categoria', 'Quantidade', 'Preço'),
    ('Notebook', 'Eletrônicos', 2, 3500.00),
    ('Mouse', 'Eletrônicos', 10, 45.90),
    ('Cadeira', 'Móveis', 4, 780.00),
    ('Monitor', 'Eletrônicos', 3, 1200.00),
    ('Mesa', 'Móveis', 1, 950.00),
]

wb = Workbook()
ws = wb.active
ws.title = 'Vendas'

for linha in vendas:
    ws.append(linha)  # adiciona cada tupla na próxima linha vazia

wb.save('vendas.xlsx')
print(ws.max_row, 'linhas e', ws.max_column, 'colunas')

1

6 linhas e 4 colunas

1. Ler uma planilha e somar uma coluna

O método iter_rows percorre as linhas da aba. Com min_row=2 pulamos o cabeçalho e com values_only=True recebemos tuplas com os valores, prontas para desempacotar no for:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from openpyxl import load_workbook

wb = load_workbook('vendas.xlsx')
ws = wb['Vendas']  # seleciona a aba pelo nome

total_itens = 0
faturamento = 0

# min_row=2 pula o cabeçalho; values_only=True devolve só os valores
for produto, categoria, quantidade, preco in ws.iter_rows(min_row=2, values_only=True):
    total_itens += quantidade
    faturamento += quantidade * preco

print(f'Itens vendidos: {total_itens}')
print(f'Faturamento: R$ {faturamento:.2f}')

1
2

Itens vendidos: 20
Faturamento: R$ 15129.00

Se o for com várias variáveis ou a formatação :.2f são novidade para você, veja os artigos sobre estruturas de repetição e f-strings no Python.

2. Criar uma planilha com cabeçalho e fórmula (=SUM)

Para gravar uma fórmula, basta atribuir um texto que começa com =. O nome da função vai em inglês e os argumentos são separados por vírgula, porque é assim que o formato .xlsx guarda fórmulas (o Excel em português traduz na hora de exibir):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from openpyxl import Workbook

wb = Workbook()
ws = wb.active
ws.title = 'Despesas'

ws.append(['Mês', 'Valor'])       # cabeçalho na linha 1
ws.append(['Janeiro', 1200])
ws.append(['Fevereiro', 980])
ws.append(['Março', 1430])

ws['A5'] = 'Total'
ws['B5'] = '=SUM(B2:B4)'          # fórmula em inglês, começando com =

wb.save('despesas.xlsx')
print(ws['B5'].value)

1

=SUM(B2:B4)

Ao abrir despesas.xlsx no Excel, a célula B5 mostra 3610. Mas atenção: o openpyxl não calcula fórmulas, ele só grava o texto. Veja o que acontece ao ler o arquivo de volta:

1
2
3
4
5
6
7

from openpyxl import load_workbook

ws = load_workbook('despesas.xlsx').active
print(ws['B5'].value)                  # a fórmula, como texto

ws = load_workbook('despesas.xlsx', data_only=True).active
print(ws['B5'].value)                  # o último valor calculado

1
2

=SUM(B2:B4)
None

Com data_only=True, o openpyxl devolve o valor que o Excel calculou e salvou no arquivo da última vez. Como esse arquivo foi criado pelo Python e nunca passou por um programa de planilha, não existe valor salvo, e o resultado é None. Depois de abrir e salvar o arquivo no Excel (ou no LibreOffice), a mesma leitura devolve 3610. Se você precisa do resultado dentro do Python, calcule no próprio Python (como no exemplo 1).

3. Formatar células: negrito, cores, largura e moeda

A formatação fica no módulo openpyxl.styles. Aqui deixamos o cabeçalho em negrito com fundo colorido, ajustamos a largura das colunas, aplicamos formato de moeda e congelamos a primeira linha:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from openpyxl import load_workbook
from openpyxl.styles import Font, PatternFill, Alignment

wb = load_workbook('vendas.xlsx')
ws = wb['Vendas']

# Cabeçalho em negrito, branco, com fundo azul e centralizado
for celula in ws[1]:
    celula.font = Font(bold=True, color='FFFFFF')
    celula.fill = PatternFill(fill_type='solid', start_color='1F4E78')
    celula.alignment = Alignment(horizontal='center')

# Largura das colunas (em "caracteres", aproximadamente)
ws.column_dimensions['A'].width = 15
ws.column_dimensions['B'].width = 15
ws.column_dimensions['D'].width = 12

# Coluna D (Preço) no formato de moeda
for (celula,) in ws.iter_rows(min_row=2, min_col=4, max_col=4):
    celula.number_format = '"R$" #,##0.00'

ws.freeze_panes = 'A2'  # congela o cabeçalho ao rolar

wb.save('vendas.xlsx')
print(ws['A1'].font.bold, ws.column_dimensions['A'].width, ws['D2'].number_format)

1

True 15.0 "R$" #,##0.00

ws[1] devolve todas as células da linha 1, e column_dimensions usa a letra da coluna. O number_format só muda a exibição: o valor guardado continua sendo o número 3500.0.

4. Filtrar linhas e salvar em outra aba

Um pedido clássico: “separe só os eletrônicos numa aba nova”. Com create_sheet criamos a aba e com append copiamos as linhas que passam no filtro:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from openpyxl import load_workbook

wb = load_workbook('vendas.xlsx')
origem = wb['Vendas']

# Cria (ou recria) a aba de destino
if 'Eletrônicos' in wb.sheetnames:
    del wb['Eletrônicos']
destino = wb.create_sheet('Eletrônicos')

cabecalho = [celula.value for celula in origem[1]]
destino.append(cabecalho)

for linha in origem.iter_rows(min_row=2, values_only=True):
    if linha[1] == 'Eletrônicos':  # coluna B = Categoria
        destino.append(linha)

wb.save('vendas.xlsx')
print(wb.sheetnames)
print(destino.max_row - 1, 'linhas copiadas')

1
2

['Vendas', 'Eletrônicos']
3 linhas copiadas

O if ... del no começo deixa o script seguro para rodar várias vezes: sem ele, a segunda execução criaria uma aba Eletrônicos1. Repare também que, dentro da tupla, os índices voltam a começar em 0 (linha[1] é a coluna B), porque aí é uma tupla comum do Python.

5. Gerar um relatório a partir de uma lista de dicionários

Dados vindos de uma API, de um banco de dados ou de um CSV costumam chegar como uma lista de dicionários. Transformar isso em um relatório de Excel é direto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from openpyxl import Workbook
from openpyxl.styles import Font

alunos = [
    {'nome': 'Ana', 'nota1': 8.5, 'nota2': 9.0},
    {'nome': 'Bruno', 'nota1': 6.0, 'nota2': 5.5},
    {'nome': 'Carla', 'nota1': 7.0, 'nota2': 8.0},
]

wb = Workbook()
ws = wb.active
ws.title = 'Relatório'

ws.append(['Nome', 'Nota 1', 'Nota 2', 'Média', 'Situação'])
for celula in ws[1]:
    celula.font = Font(bold=True)

for aluno in alunos:
    media = (aluno['nota1'] + aluno['nota2']) / 2
    situacao = 'Aprovado' if media >= 7 else 'Recuperação'
    ws.append([aluno['nome'], aluno['nota1'], aluno['nota2'], media, situacao])

ws.column_dimensions['E'].width = 14
wb.save('relatorio_notas.xlsx')

for linha in ws.iter_rows(min_row=2, values_only=True):
    print(linha)

1
2
3

('Ana', 8.5, 9.0, 8.75, 'Aprovado')
('Bruno', 6.0, 5.5, 5.75, 'Recuperação')
('Carla', 7.0, 8.0, 7.5, 'Aprovado')

Se os seus dados estão em arquivos de texto, vale ler também como manipular arquivos com Python e como fazer a manipulação de CSV no Python: o fluxo “ler CSV, gerar Excel formatado” é uma das automações mais pedidas no dia a dia.

Quer praticar automações como essas com projetos guiados, do zero ao avançado? Conheça o nosso curso de Python completo, a Jornada Python.

openpyxl, pandas ou xlsxwriter: qual usar?

As três bibliotecas trabalham com .xlsx, mas resolvem problemas diferentes:

Na prática, é comum combinar: pandas para calcular e openpyxl (ou xlsxwriter) para deixar o resultado apresentável. Inclusive, para ler .xlsx o pandas usa o openpyxl por baixo dos panos (e, para escrever, usa o xlsxwriter se estiver instalado ou o openpyxl).

Com pandas, o exemplo de faturamento vira poucas linhas (instale com pip install pandas openpyxl; veja a documentação do read_excel):

1
2
3
4
5
6
7
8
9

import pandas as pd

df = pd.read_excel('vendas.xlsx', sheet_name='Vendas')
df['Total'] = df['Quantidade'] * df['Preço']

resumo = df.groupby('Categoria')['Total'].sum()
print(resumo)

resumo.to_excel('resumo_por_categoria.xlsx')

1
2
3
4

Categoria
Eletrônicos    11059.0
Móveis          4070.0
Name: Total, dtype: float64

Se você está começando com pandas, leia sobre DataFrames do Pandas e como importar CSV no Pandas: read_excel funciona de forma muito parecida com read_csv.

E com xlsxwriter, um arquivo novo com cabeçalho em negrito e um gráfico de colunas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import xlsxwriter

wb = xlsxwriter.Workbook('grafico.xlsx')
ws = wb.add_worksheet('Vendas')
negrito = wb.add_format({'bold': True})

ws.write_row('A1', ['Mês', 'Vendas'], negrito)
ws.write_column('A2', ['Jan', 'Fev', 'Mar'])
ws.write_column('B2', [120, 95, 143])

grafico = wb.add_chart({'type': 'column'})
grafico.add_series({'categories': '=Vendas!$A$2:$A$4', 'values': '=Vendas!$B$2:$B$4'})
ws.insert_chart('D2', grafico)

wb.close()  # no xlsxwriter, o arquivo só é gravado no close()

Automatizar Excel é só um exemplo do que dá pra fazer quando você domina bem a base de Python. Pra chegar lá com projetos guiados e suporte de professor, conheça a Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Python no Excel ou Python com Excel: qual a diferença?

Muita gente busca “como usar Python no Excel” esperando uma de duas coisas:

• Python com Excel (este artigo): você escreve um script .py que roda no seu computador e lê ou gera arquivos .xlsx com openpyxl, pandas ou xlsxwriter. Funciona em qualquer sistema, sem o Excel instalado, e é o caminho para automatizar tarefas repetitivas: rodar o mesmo relatório toda semana, processar dezenas de arquivos de uma vez, integrar com e-mail ou banco de dados.
• Python no Excel (recurso do Microsoft 365): você digita =PY( numa célula e escreve código Python dentro da própria planilha, que é executado na nuvem da Microsoft. É útil para análises e gráficos pontuais dentro de uma pasta de trabalho, mas depende de ter um plano do Microsoft 365 com o recurso liberado e não serve para automatizar arquivos de fora.

Se o objetivo é automatizar (tirar trabalho manual da sua rotina), o caminho é o primeiro, e é o que você viu até aqui.

Erros comuns

1. FileNotFoundError: o arquivo não está onde o Python procura

1
2
3

from openpyxl import load_workbook

wb = load_workbook('venda.xlsx')  # nome errado ou pasta errada

1

FileNotFoundError: [Errno 2] No such file or directory: 'venda.xlsx'

Um caminho relativo como 'vendas.xlsx' é procurado na pasta de onde você executou o script, não necessariamente na pasta do script. Confira o nome e a extensão, e use o caminho completo se precisar (r'C:\Users\voce\Documents\vendas.xlsx' no Windows). Mais detalhes na documentação de exceções do Python.

2. PermissionError: o arquivo está aberto no Excel

1

wb.save('vendas.xlsx')  # com vendas.xlsx aberto no Excel

1

PermissionError: [Errno 13] Permission denied: 'vendas.xlsx'

No Windows, o Excel bloqueia o arquivo enquanto ele está aberto. Feche a planilha e rode de novo, ou salve com outro nome (wb.save('vendas_novo.xlsx')). O mesmo erro aparece se você não tem permissão de escrita na pasta. Para tratar isso sem derrubar o script, use try/except (veja tratamento de erros e exceções no Python).

3. Fórmula aparece como texto, ou o valor vem None

1
2
3
4

from openpyxl import load_workbook

ws = load_workbook('despesas.xlsx', data_only=True).active
print(ws['B5'].value)  # B5 contém =SUM(B2:B4)

1

None

Sem data_only=True você recebe a fórmula ('=SUM(B2:B4)'); com data_only=True recebe o último valor calculado e salvo pelo Excel. Como o openpyxl não calcula fórmulas, um arquivo gerado pelo Python e nunca aberto no Excel não tem esse valor, daí o None. Soluções: abrir e salvar o arquivo no Excel/LibreOffice antes de ler, ou fazer a conta no Python. Cuidado também com dois detalhes: se você abrir com data_only=True e salvar por cima, as fórmulas são substituídas pelos valores; e fórmula com nome em português ('=SOMA(B2:B4)') dá erro de nome (#NOME? no Excel em português, #NAME? em inglês), porque o arquivo espera SUM.

4. Linha ou coluna 0: os índices começam em 1

1
2
3
4

from openpyxl import Workbook

ws = Workbook().active
ws.cell(row=0, column=1, value='x')

1

ValueError: Row or column values must be at least 1

No openpyxl, a primeira linha e a primeira coluna são 1, como no Excel: ws.cell(row=1, column=1) é a célula A1. A confusão vem de listas e tuplas do Python, que começam em 0. Com values_only=True, cada linha vira uma tupla, então ali linha[0] é a coluna A.

5. InvalidFileException ao abrir um .xls antigo

1
2
3

from openpyxl import load_workbook

wb = load_workbook('planilha_antiga.xls')

1

openpyxl.utils.exceptions.InvalidFileException: openpyxl does not support the old .xls file format, please use xlrd to read this file, or convert it to the more recent .xlsx file format.

O .xls é o formato do Excel 97-2003, e o openpyxl só trabalha com .xlsx/.xlsm. Abra o arquivo no Excel ou no LibreOffice e use “Salvar como” .xlsx. Se só precisa ler os dados, dá para usar pd.read_excel('planilha_antiga.xls') com a biblioteca xlrd instalada.

Exercícios resolvidos

Os exercícios usam o vendas.xlsx criado em Preparando a planilha de exemplo.

Exercício 1. Leia e imprima o valor da célula B3 da aba Vendas.

1
2
3
4

from openpyxl import load_workbook

ws = load_workbook('vendas.xlsx')['Vendas']
print(ws['B3'].value)

Exercício 2. (Questão de prova) Considerando ws uma aba carregada com openpyxl, qual comando retorna o conteúdo da célula da primeira linha e primeira coluna?

a) ws.cell(row=0, column=0).value
b) ws['A1'].value
c) ws.cell(row=1, column=1)
d) ws['1A'].value

1
2
3
4
5

from openpyxl import load_workbook

ws = load_workbook('vendas.xlsx')['Vendas']
print(ws['A1'].value)
print(ws.cell(row=1, column=1))

1
2

Produto
<Cell 'Vendas'.A1>

Exercício 3. Calcule o preço médio dos produtos (coluna D) e imprima com duas casas decimais.

1
2
3
4
5
6

from openpyxl import load_workbook

ws = load_workbook('vendas.xlsx')['Vendas']
precos = [linha[3] for linha in ws.iter_rows(min_row=2, values_only=True)]
media = sum(precos) / len(precos)
print(f'Preço médio: R$ {media:.2f}')

Exercício 4. (Questão de prova) Um script cria despesas.xlsx com openpyxl e grava ws['B5'] = '=SUM(B2:B4)', com B2 a B4 valendo 1200, 980 e 1430. Sem abrir o arquivo no Excel, outro script executa load_workbook('despesas.xlsx', data_only=True).active['B5'].value. O que é retornado?

a) 3610
b) '=SUM(B2:B4)'
c) None
d) 0

Exercício 5. Crie dobro.xlsx com os números de 1 a 5 na coluna A e, na coluna B, uma fórmula que calcule o dobro do valor da coluna A na mesma linha.

1
2
3
4
5
6
7
8
9
10
11

from openpyxl import Workbook

wb = Workbook()
ws = wb.active

for n in range(1, 6):
    ws.cell(row=n, column=1, value=n)
    ws.cell(row=n, column=2, value=f'=A{n}*2')

wb.save('dobro.xlsx')
print([ws.cell(row=n, column=2).value for n in range(1, 6)])

Exercício 6. Deixe em negrito e vermelho todas as células das linhas com Quantidade menor que 3 e imprima os produtos destacados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from openpyxl import load_workbook
from openpyxl.styles import Font

wb = load_workbook('vendas.xlsx')
ws = wb['Vendas']

destacados = []
for linha in ws.iter_rows(min_row=2):
    produto, quantidade = linha[0], linha[2]
    if quantidade.value < 3:
        for celula in linha:
            celula.font = Font(bold=True, color='FF0000')
        destacados.append(produto.value)

wb.save('vendas.xlsx')
print(destacados)

Exercício 7. Gere um arquivo novo, por_categoria.xlsx, com uma aba para cada categoria da planilha de vendas (cada aba com o cabeçalho e as suas linhas).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from openpyxl import Workbook, load_workbook

origem = load_workbook('vendas.xlsx')['Vendas']
cabecalho = [c.value for c in origem[1]]

novo = Workbook()
novo.remove(novo.active)  # remove a aba vazia padrão ("Sheet")

for linha in origem.iter_rows(min_row=2, values_only=True):
    categoria = linha[1]
    if categoria not in novo.sheetnames:
        aba = novo.create_sheet(categoria)
        aba.append(cabecalho)
    novo[categoria].append(linha)

novo.save('por_categoria.xlsx')
for aba in novo.worksheets:
    print(aba.title, aba.max_row - 1)

1
2

Eletrônicos 3
Móveis 2

Exercício 8. A partir de uma lista de dicionários de pedidos, gere pedidos.xlsx usando as chaves como cabeçalho (sem digitá-las à mão) e adicione no fim uma linha de total com fórmula.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

from openpyxl import Workbook

pedidos = [
    {'id': 101, 'cliente': 'Ana', 'valor': 250.0},
    {'id': 102, 'cliente': 'Bruno', 'valor': 99.9},
    {'id': 103, 'cliente': 'Carla', 'valor': 410.5},
]

wb = Workbook()
ws = wb.active

colunas = list(pedidos[0].keys())
ws.append(colunas)
for pedido in pedidos:
    ws.append([pedido[c] for c in colunas])

ws.append(['Total', None, f'=SUM(C2:C{ws.max_row})'])
wb.save('pedidos.xlsx')

for linha in ws.iter_rows(values_only=True):
    print(linha)

1
2
3
4
5

('id', 'cliente', 'valor')
(101, 'Ana', 250.0)
(102, 'Bruno', 99.9)
(103, 'Carla', 410.5)
('Total', None, '=SUM(C2:C4)')

Conclusão

Automatizar tarefas no Excel com Python pode trazer muitos benefícios, incluindo economia de tempo, precisão e flexibilidade.

Neste artigo, você aprendeu como criar, ler, atualizar e formatar planilhas no Excel utilizando Python e a biblioteca openpyxl, além de somar colunas, gravar fórmulas, filtrar dados para outra aba, gerar relatórios a partir de dicionários e escolher entre openpyxl, pandas e xlsxwriter.

Espero que este artigo tenha ajudado você a entender como utilizar o Python para automatizar tarefas no Excel.

Agora você pode explorar ainda mais as funcionalidades da biblioteca openpyxl e tornar suas tarefas com o Excel muito mais eficientes.

Fique à vontade para deixar seus comentários e compartilhar outros recursos interessantes que você conheça.

Automatizar tarefas pode facilitar muito o seu trabalho e melhorar sua produtividade.

Nos vemos na próxima!

Por Vinícius Ramos em 13/07/2023

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•