---
title: "PowerPoint com Python: Gerar Apresentações com python-pptx"
url: "https://python.dev.br/blog/python-e-powerpoint-python-pptx/"
markdown_url: "https://python.dev.br/blog/python-e-powerpoint-python-pptx.MD"
description: "Crie e edite apresentações PowerPoint com python-pptx em Python: slides, textos, tabelas, gráficos, imagens, templates e geração em lote a partir de CSV, sem instalar o PowerPoint."
date: "2026-10-09"
author: "Equipe Python Dev BR"
---

# PowerPoint com Python: Gerar Apresentações com python-pptx

Crie e edite apresentações PowerPoint com python-pptx em Python: slides, textos, tabelas, gráficos, imagens, templates e geração em lote a partir de CSV, sem instalar o PowerPoint.


<p data-growth-refresh="2026-10-09-pptx-intro"><strong>Resposta rápida:</strong> para <strong>gerar apresentações PowerPoint com Python</strong>, use a biblioteca <code>python-pptx</code>. Instale com <code>python -m pip install python-pptx</code>, crie uma <code>Presentation()</code>, adicione slides com <code>prs.slides.add_slide(layout)</code>, preencha títulos, textos, tabelas, gráficos e imagens e salve com <code>prs.save("arquivo.pptx")</code>. Tudo isso <strong>sem precisar do Microsoft PowerPoint instalado</strong> — o arquivo gerado abre normalmente no PowerPoint, LibreOffice e Google Slides.</p>

Na prática, isso elimina uma das tarefas mais repetitivas do escritório: montar a mesma apresentação todo mês trocando números, gráficos e nomes de regionais. Um script Python pode ler os dados de uma planilha, gerar um deck completo com a identidade visual do seu padrão corporativo e salvar dezenas de variações em segundos. Se você já automatiza [planilhas Excel com OpenPyXL](/blog/python-e-excel-openpyxl/) e [documentos Word com python-docx](/blog/python-e-word-python-docx/), este guia fecha o trio de automação de documentos do escritório.

## O que o python-pptx faz — e o que ele não faz

| Tarefa | Suporte | Abordagem |
|---|---:|---|
| Criar apresentações .pptx do zero | Sim | `Presentation()` + `add_slide()` |
| Títulos, textos e listas com formatação | Sim | placeholders e `text_frame` |
| Tabelas nativas editáveis | Sim | `shapes.add_table()` |
| Gráficos nativos (colunas, pizza, linha) | Sim | `shapes.add_chart()` |
| Inserir imagens e logotipos | Sim | `shapes.add_picture()` |
| Editar um .pptx existente | Sim | `Presentation("arquivo.pptx")` |
| Usar template corporativo .potx/.pptx | Sim | `Presentation("template.pptx")` |
| Animações e transições | Não | deixar pronto no template |
| Macros e arquivos .ppt antigos | Não | usar apenas .pptx |
| Converter .pptx para PDF | Não diretamente | LibreOffice headless |

A regra prática: o python-pptx é ideal quando o resultado precisa continuar **editável e apresentável**. Se o destino final é um documento para impressão, avalie [gerar o PDF diretamente com Python](/blog/python-gerar-pdf-relatorios/); se o objetivo é só ler o conteúdo de arquivos existentes, o [MarkItDown](/blog/markitdown-microsoft-documentos-markdown-python/) é mais direto.

## Instalação e primeiros passos

A `python-pptx` é uma biblioteca de terceiros. Instale dentro do seu [ambiente virtual](/blog/virtual-environments-python/) com pip ou, em projetos gerenciados com uv, com `uv add`:

```bash
# Com pip
python -m pip install python-pptx

# Ou, em um projeto gerenciado com uv
uv add python-pptx
```

O nome do pacote instalado é `python-pptx`, mas o import é apenas `pptx`. O fluxo básico é sempre o mesmo: criar (ou abrir) uma apresentação, adicionar slides, preencher e salvar:

```python
from pptx import Presentation

prs = Presentation()  # apresentação em branco (4:3 por padrão)

# Layout 0 = "Title Slide" no template padrão
slide = prs.slides.add_slide(prs.slide_layouts[0])
slide.shapes.title.text = "Relatório Mensal de Vendas"
slide.placeholders[1].text = "Outubro de 2026 · Equipe Comercial"

prs.save("relatorio.pptx")
```

Três linhas de conteúdo e o arquivo `relatorio.pptx` já abre em qualquer visualizador. Para widescreen 16:9, que é o padrão atual, ajuste a dimensão do slide uma única vez:

```python
from pptx.util import Inches

prs.slide_width = Inches(13.333)
prs.slide_height = Inches(7.5)
```

## Textos, listas e formatação

Cada slide criado a partir de um layout traz **placeholders** (título, subtítulo, corpo). Para textos livres, adicione uma caixa de texto e trabalhe com parágrafos e *runs* — é o run que carrega a formatação:

```python
from pptx import Presentation
from pptx.util import Inches, Pt

prs = Presentation()
slide = prs.slides.add_slide(prs.slide_layouts[1])  # "Title and Content"
slide.shapes.title.text = "Resultados do trimestre"

box = slide.shapes.add_textbox(Inches(0.8), Inches(2), Inches(11), Inches(4))
tf = box.text_frame
tf.word_wrap = True

itens = [
    ("Receita: R$ 4,2 mi (+18% vs. trimestre anterior)", 0),
    ("Novos clientes: 127 contratos", 1),
    ("Churn em queda pelo 3º mês seguido", 1),
    ("Meta do ano atingida em outubro", 1),
]

for texto, nivel in itens:
    p = tf.paragraphs[0] if texto.startswith("Receita") else tf.add_paragraph()
    p.level = nivel
    run = p.add_run()
    run.text = texto
    run.font.size = Pt(20 if nivel == 0 else 16)
    run.font.bold = nivel == 0

prs.save("resultados.pptx")
```

O padrão `paragraph → add_run → font` parece verboso, mas é o que permite misturar negrito, itálico, cor e tamanho dentro do mesmo parágrafo — a mesma lógica de formatação rica do PowerPoint.

## Tabelas nativas

Tabelas de slide não são imagens: são objetos nativos, editáveis por quem receber o arquivo. Use `add_table` e percorra as células:

```python
from pptx import Presentation
from pptx.util import Inches

prs = Presentation()
slide = prs.slides.add_slide(prs.slide_layouts[5])  # layout só com título
slide.shapes.title.text = "Vendas por regional"

dados = [
    ("Regional", "Receita", "Variação"),
    ("Sudeste", "R$ 1,86 mi", "+21%"),
    ("Sul", "R$ 980 mil", "+9%"),
    ("Nordeste", "R$ 810 mil", "+15%"),
    ("Centro-Oeste", "R$ 550 mil", "+4%"),
]

frame = slide.shapes.add_table(
    rows=len(dados), cols=3,
    left=Inches(1.5), top=Inches(1.8),
    width=Inches(10), height=Inches(4),
)
tabela = frame.table

# O PowerPoint aplica o estilo com destaque na primeira linha automaticamente
for linha, valores in enumerate(dados):
    for coluna, valor in enumerate(valores):
        tabela.cell(linha, coluna).text = valor

prs.save("regionais.pptx")
```

Se os dados vêm de uma planilha, o casamento perfeito é ler com [Pandas](/blog/introducao-ao-pandas/) ou [OpenPyXL](/blog/python-e-excel-openpyxl/) e despejar `DataFrame.itertuples()` na tabela.

## Gráficos nativos a partir de dados

O recurso que mais economiza tempo em decks mensais é o gráfico nativo: os números alimentam o gráfico e ele continua editável no PowerPoint — diferente de colar uma imagem do [Matplotlib](/blog/introducao-ao-matplotlib/):

```python
from pptx import Presentation
from pptx.chart.data import CategoryChartData
from pptx.enum.chart import XL_CHART_TYPE
from pptx.util import Inches

prs = Presentation()
slide = prs.slides.add_slide(prs.slide_layouts[5])
slide.shapes.title.text = "Receita por mês (R$ mil)"

chart_data = CategoryChartData()
chart_data.categories = ["Mai", "Jun", "Jul", "Ago", "Set", "Out"]
chart_data.add_series("2026", (1180, 1250, 1310, 1395, 1470, 1610))
chart_data.add_series("2025", (1010, 1040, 1080, 1105, 1150, 1180))

slide.shapes.add_chart(
    XL_CHART_TYPE.COLUMN_CLUSTERED,
    Inches(1.5), Inches(1.8), Inches(10), Inches(5),
    chart_data,
)

prs.save("grafico.pptx")
```

`XL_CHART_TYPE` traz as famílias conhecidas do PowerPoint: `LINE`, `PIE`, `BAR_CLUSTERED`, `DOUGHNUT` e outras. O gráfico usa o tema visual do arquivo, então com um template corporativo ele já nasce no padrão da empresa.

## Imagens e notas do apresentador

Logotipos e capturas de tela entram com `add_picture`:

```python
slide.shapes.add_picture(
    "logo.png",
    left=Inches(0.5), top=Inches(6.7),
    width=Inches(1.2),
)
```

E as notas de apresentação — aquelas que só quem apresenta vê — são só mais um text frame:

```python
slide.notes_slide.notes_text_frame.text = (
    "Destacar a virada de outubro; conectar com a meta anual."
)
```

## Editar um .pptx existente

Abrir um arquivo pronto e alterar apenas o que muda é o caso de uso mais comum em automação corporativa:

```python
from pptx import Presentation

prs = Presentation("modelo-relatorio.pptx")

for slide in prs.slides:
    for shape in slide.shapes:
        if not shape.has_text_frame:
            continue
        for p in shape.text_frame.paragraphs:
            for run in p.runs:
                run.text = run.text.replace("MES_ATUAL", "Outubro/2026")

prs.save("relatorio-outubro.pptx")
```

Para trocas de conteúdo em série, o padrão mais robusto é o mesmo do python-docx: **templates com marcadores** (`{{receita}}`, `{{mes}}`) percorridos com `str.replace()` em todos os placeholders e caixas de texto do slide.

## Geração em lote a partir de um CSV

Aqui a automação paga a conta: uma apresentação personalizada por regional, lendo os dados de um CSV e reaproveitando o template:

```python
import csv
from pptx import Presentation
from pptx.util import Inches, Pt

with open("regionais.csv", newline="", encoding="utf-8") as f:
    regionais = list(csv.DictReader(f))

for reg in regionais:
    prs = Presentation("template.pptx")

    capa = prs.slides[0]
    capa.shapes.title.text = f"Relatório {reg['regional']}"
    capa.placeholders[1].text = "Outubro de 2026"

    slide = prs.slides.add_slide(prs.slide_layouts[5])
    slide.shapes.title.text = "Indicadores"

    box = slide.shapes.add_textbox(Inches(1), Inches(2), Inches(11), Inches(4))
    tf = box.text_frame
    for i, (rotulo, valor) in enumerate([
        ("Receita:", f"R$ {reg['receita']}"),
        ("Novos clientes:", reg["clientes"]),
        ("NPS:", reg["nps"]),
    ]):
        p = tf.paragraphs[0] if i == 0 else tf.add_paragraph()
        run = p.add_run()
        run.text = f"{rotulo} {valor}"
        run.font.size = Pt(24)

    prs.save(f"relatorio-{reg['regional'].lower()}.pptx")

print(f"{len(regionais)} apresentações geradas.")
```

Com uma leve adaptação, o laço pode ler direto de uma planilha com `load_workbook` — veja o guia de [automação de planilhas com Python](/blog/python-para-automacao-de-planilhas/) — ou enviar cada arquivo por e-mail usando o artigo de [automação de e-mails com Python](/blog/python-para-automacao-de-emails/).

## Como converter o .pptx para PDF

O python-pptx não converte formatos. As saídas práticas:

1. **LibreOffice headless** (Linux/servidores, o padrão em automação):

```bash
soffice --headless --convert-to pdf relatorio.pptx
```

2. **PowerPoint via COM** (Windows com Office instalado): a biblioteca `comtypes` aciona o PowerPoint para exportar, mas essa rota exige desktop e licença do Office.

3. **Nascer em PDF**: se a apresentação é apenas o veículo e nunca será editada, gere [relatórios em PDF diretamente com Python](/blog/python-gerar-pdf-relatorios/) e pule o .pptx.

## python-pptx ou alternativas?

| Cenário | Ferramenta recomendada |
|---|---|
| Gerar/editar .pptx editável | **python-pptx** |
| Extrair texto de .pptx/.docx/.xlsx | [MarkItDown](/blog/markitdown-microsoft-documentos-markdown-python/) |
| Documentos Word | [python-docx](/blog/python-e-word-python-docx/) |
| Planilhas Excel | [OpenPyXL](/blog/python-e-excel-openpyxl/) |
| PDF para impressão | [geração de PDF com Python](/blog/python-gerar-pdf-relatorios/) |
| Slides no Google Workspace | Google Slides API |

A fronteira é simples: quando o arquivo precisa continuar sendo um PowerPoint vivo — editável, com gráficos nativos e template da empresa — o python-pptx é a escolha. Quando o slide é só uma casca para entregar um conteúdo final, outras ferramentas resolvem com menos passos.

## Conclusão

O python-pptx transforma a apresentação mensal de dados em mais um script do seu repertório de automação: leia os números de uma planilha, preencha um template corporativo, gere gráficos nativos e salve quantas variações precisar — tudo sem abrir o PowerPoint. Comece pelo exemplo de instalação, evolua para o lote a partir de CSV e, quando o deck não precisar mais ser editável, considere a rota direta em PDF.

## Perguntas frequentes

### Vale a pena usar python-pptx para relatórios mensais?

Sim, é o caso de uso clássico. Mantenha um template .pptx com a identidade visual pronta e um script que preenche títulos, tabelas e gráficos a partir dos dados do mês. O tempo de montagem cai de horas para segundos e o padrão visual fica garantido.

### O python-pptx funciona no Linux e em containers?

Sim. A biblioteca é pura manipulação de XML (sem chamadas ao Office), então roda em Linux, Docker e ambientes serverless sem dependências além do próprio pacote e do Pillow para imagens.

### Como centralizar texto ou mudar a cor da fonte?

Formatação vem do run: `run.font.color.rgb = RGBColor(0x30, 0x69, 0x98)` define a cor, e o alinhamento é do parágrafo com `p.alignment = PP_ALIGN.CENTER`. Cores e fontes definidos no template do slide são herdadas automaticamente quando você só troca o texto do placeholder.

### Dá para animar objetos ou criar transições?

Não. Animações e transições não são suportadas pela API. A estratégia prática é deixar as animações prontas no template e usar o Python apenas para substituir textos, tabelas e gráficos.