25 Tipos de Gráficos em Python: Guia Completo com Código

Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Introdução aos Tipos de Gráficos em Python

Para quem trabalha com dados no dia a dia, aprender a criar gráficos em Python é um divisor de águas. Em poucas linhas de código você monta uma visualização interativa, pronta para um relatório ou um dashboard, sem depender de cliques em um software de planilha. Este guia reúne 25 tipos de gráficos diferentes que você pode construir em Python com a biblioteca Plotly, do mais simples ao mais específico, sempre com o código completo para copiar e adaptar à sua própria base.

A ideia aqui não é decorar sintaxe, é entender qual gráfico faz sentido em cada situação, comparar categorias, acompanhar uma evolução no tempo, mostrar a distribuição de um valor, relacionar duas ou três variáveis, mostrar a proporção de um total ou visualizar dados geográficos e hierárquicos, e sair com um código de referência pronto para cada uma dessas situações.

Todos os exemplos usam a mesma base de dados de vendas, com país, categoria de produto, segmento de cliente, valor vendido, lucro, quantidade e nota de satisfação. Assim dá para acompanhar como a mesma informação vira 25 gráficos diferentes, dependendo só da pergunta que você quer responder.

Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Por que usar Python e Plotly para criar gráficos

Python virou a linguagem mais usada por quem trabalha com dados justamente por resolver a análise inteira em um só lugar, da limpeza dos dados até a visualização final. Se você ainda está decidindo se vale a pena aprender Python para lidar com dados, essa é uma boa resposta, com poucas bibliotecas dá para sair do zero até um gráfico interativo publicável.

A biblioteca usada em todos os exemplos deste artigo é o Plotly, mais especificamente o Plotly Express, importado com o apelido px, que já traz pronta a maioria dos tipos de gráfico, com poucos parâmetros. Alguns gráficos mais específicos, como candlestick, cascata, indicador e sankey, não existem no Express e exigem o Plotly Graph Objects, importado como go, uma camada um pouco mais manual da mesma biblioteca.

Antes de qualquer gráfico, instale os dois pacotes que aparecem em praticamente todo código deste artigo:

pip install pandas plotly

Depois, a lógica se repete nos 25 gráficos: carregar os dados com o pandas, agrupar ou transformar essa base até chegar na tabela que você quer exibir, com groupby, pivot_table ou resample, dependendo do caso, e só então criar a figura e mandar exibir. É basicamente o exemplo abaixo, usado no primeiro gráfico deste guia:

# Gráfico de barras (colunas) — total de vendas por categoria
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# soma as vendas de cada categoria
dados = df.groupby("categoria", as_index=False)["vendas"].sum()
print(dados)
fig = px.bar(dados, x="categoria", y="vendas", title="Vendas por categoria")
fig.show()

Esse padrão, tratar os dados primeiro e plotar depois, é o que separa quem só copia código de quem realmente sabe adaptar um gráfico para a própria base. Se essa parte ainda não estiver clara, uma introdução à biblioteca pandas antes de seguir com os gráficos ajuda bastante, principalmente para entender o que o groupby faz por trás dos panos.

Uma vantagem de usar o Plotly é que o gráfico já nasce interativo, dá para dar zoom, filtrar categorias clicando na legenda e ver os valores exatos ao passar o mouse em cima. É praticamente o primeiro passo antes de criar um dashboard em Python usando a mesma biblioteca. Quando você quiser ir além do que este guia cobre, mudando cor, fonte ou adicionando rótulos de dado, vale consultar a documentação oficial do Plotly.

Com a base montada, vamos por grupo de gráfico, começando pelos mais simples, os de comparação entre categorias.

Gráficos de comparação em Python: barras e colunas

Esses são os gráficos que você usa quando quer comparar valores entre categorias diferentes, entender qual vende mais, qual vende menos, ou como uma categoria se comporta quando você quebra ela por um segundo critério.

Gráfico de barras em Python

O gráfico de barras, ou colunas, já que o Plotly trata os dois como a mesma coisa, é o ponto de partida. Ele soma um valor numérico por categoria e desenha uma barra para cada uma.

# Gráfico de barras (colunas) — total de vendas por categoria
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# soma as vendas de cada categoria
dados = df.groupby("categoria", as_index=False)["vendas"].sum()
print(dados)
fig = px.bar(dados, x="categoria", y="vendas", title="Vendas por categoria")
fig.show()

Aqui, x recebe a coluna categórica e y recebe o valor numérico que você quer comparar. O parâmetro as_index=False no groupby garante que a coluna categoria continue sendo uma coluna normal da tabela, em vez de virar índice, o que facilita bastante na hora de passar ela para o gráfico.

Gráfico de barras horizontais em Python

Quando as categorias têm nomes longos, ou quando você tem muitas categorias para comparar, inverter as barras para a horizontal deixa a leitura mais confortável. A mudança no código é mínima.

# Gráfico de barras horizontais — total de vendas por produto
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

dados = df.groupby("produto", as_index=False)["vendas"].sum()

# orientation="h" deixa as barras na horizontal
fig = px.bar(dados, x="vendas", y="produto", orientation="h",
             title="Vendas por produto")
fig.show()

O parâmetro orientation="h" inverte a orientação, e por isso x e y também trocam de lugar, o valor numérico vai para o eixo x, e a categoria para o eixo y.

Gráfico de colunas agrupadas em Python

Quando você quer comparar categorias e, ao mesmo tempo, quebrar cada uma delas por um segundo critério, um segmento de cliente, por exemplo, entra o gráfico de colunas agrupadas.

# Gráfico de colunas agrupadas — vendas por categoria, separadas por segmento (lado a lado)
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

dados = df.groupby(["categoria", "segmento"], as_index=False)["vendas"].sum()
print(dados)
# color separa as barras e barmode="group" as coloca lado a lado
fig = px.bar(dados, x="categoria", y="vendas", color="segmento",
             barmode="group", title="Vendas por categoria e segmento")
fig.show()

O parâmetro color separa as cores por segmento, e barmode="group" coloca as barras lado a lado dentro de cada categoria. Antes de plotar, o groupby precisa considerar as duas colunas ao mesmo tempo, categoria e segmento, não só uma.

Gráfico de colunas empilhadas em Python

Se em vez de comparar os segmentos lado a lado você quer ver o total da categoria com a contribuição de cada segmento dentro dele, troque só o barmode para "stack".

# Gráfico de colunas empilhadas — vendas por categoria, empilhadas por segmento
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

dados = df.groupby(["categoria", "segmento"], as_index=False)["vendas"].sum()

# barmode="stack" empilha as barras (uma em cima da outra)
fig = px.bar(dados, x="categoria", y="vendas", color="segmento",
             barmode="stack", title="Vendas por categoria e segmento (empilhado)")
fig.show()

A vantagem das colunas empilhadas é preservar visualmente o valor total da categoria. A desvantagem é que fica mais difícil comparar os segmentos entre si, já que eles não começam todos do zero.

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

Gráficos temporais em Python: linha, área e candlestick

Esses três gráficos servem para acompanhar como um valor evolui ao longo do tempo, seja mês a mês, semana a semana ou dia a dia.

Gráfico de linhas em Python

# Gráfico de linhas — evolução das vendas ao longo dos meses
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")
df["data"] = pd.to_datetime(df["data"])

# soma as vendas por mês
df["mes"] = df["data"].dt.to_period("M").dt.to_timestamp()
dados = df.groupby("mes", as_index=False)["vendas"].sum()

fig = px.line(dados, x="mes", y="vendas", markers=True, title="Vendas por mês")
fig.show()

O parâmetro markers=True adiciona uma bolinha em cada ponto da linha. E o dt.to_period("M").dt.to_timestamp() garante que os meses fiquem na ordem cronológica certa, mês a mês e ano a ano, em vez de agrupar todos os "janeiros" juntos, independente do ano.

Gráfico de área em Python

# Gráfico de área — vendas ao longo dos meses (linha com preenchimento)
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")
df["data"] = pd.to_datetime(df["data"])

df["mes"] = df["data"].dt.to_period("M").dt.to_timestamp()
dados = df.groupby("mes", as_index=False)["vendas"].sum()

fig = px.area(dados, x="mes", y="vendas", title="Vendas por mês (área)")
fig.show()

A lógica é idêntica à do gráfico de linhas, só troca px.line por px.area. A diferença visual é o preenchimento abaixo da linha e a escala do eixo y, que por padrão começa em zero na área, o que evita a leitura errada de uma variação parecer maior do que realmente é.

Gráfico de candlestick em Python

Esse é o primeiro gráfico deste guia que não existe no Plotly Express, por isso usa Graph Objects direto.

# Gráfico de candlestick (velas) — usa Graph Objects (não existe no Express)
# OHLC semanal (abertura, máxima, mínima, fechamento) a partir das vendas diárias
import pandas as pd
import plotly.graph_objects as go

df = pd.read_csv("vendas.csv")
df["data"] = pd.to_datetime(df["data"])

# total de vendas por dia
diario = df.groupby("data")["vendas"].sum()

# agrega por semana: primeira, maior, menor e última venda diária
ohlc = diario.resample("W").agg(["first", "max", "min", "last"]).dropna()
print(ohlc)
fig = go.Figure(go.Candlestick(
    x=ohlc.index,
    open=ohlc["first"],
    high=ohlc["max"],
    low=ohlc["min"],
    close=ohlc["last"],
))
fig.update_layout(title="Vendas semanais (candlestick)")
fig.show()

Ele resume abertura, máxima, mínima e fechamento de um período, nesse caso, uma semana, o clássico gráfico de velas usado para acompanhar preços e séries financeiras.

Gráficos de distribuição em Python: histograma, box plot e violino

Esses gráficos respondem a uma pergunta diferente dos anteriores, não é "qual é maior", é "como os valores estão distribuídos". Eles são a base de qualquer análise exploratória de dados, quando você quer entender o comportamento de uma variável antes de tirar qualquer conclusão sobre ela.

Histograma em Python

# Histograma — distribuição (frequência) dos valores de venda
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# nbins controla a quantidade de faixas (barras)
fig = px.histogram(df, x="categoria", title="Distribuição das vendas")
fig.show()

O histograma conta quantas vezes cada valor da coluna aparece, mostrando a frequência de cada categoria dentro da base.

Box plot em Python

# Box plot — distribuição das vendas por categoria (mediana, quartis e outliers)
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

fig = px.box(df, x="categoria", y="vendas", title="Vendas por categoria (box plot)")
fig.show()

O box plot mostra mediana, quartis e os valores fora da curva, os outliers, de uma vez só, por categoria. É um dos gráficos mais usados para identificar rapidamente inconsistências na base.

Gráfico de violino em Python

# Gráfico de violino — distribuição das vendas por categoria (formato = densidade)
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# box=True mostra também o box plot dentro do violino
fig = px.violin(df, x="categoria", y="vendas", box=True,
                title="Vendas por categoria (violino)")
fig.show()

O parâmetro box=True mistura o formato de densidade do violino com o box plot dentro dele, então você enxerga tanto o formato da distribuição quanto os mesmos números do box plot, tudo no mesmo gráfico.

Gráficos de relação entre variáveis em Python: dispersão, bolhas e 3D

Esse grupo serve para responder se duas ou mais variáveis caminham juntas, se vendas maiores também trazem lucro maior, por exemplo, ou se não existe relação nenhuma entre elas.

Gráfico de dispersão em Python

# Gráfico de dispersão (scatter) — relação entre vendas e lucro
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

fig = px.scatter(df, x="vendas", y="lucro", title="Relação entre vendas e lucro")
fig.show()

Diferente dos gráficos anteriores, o de dispersão não precisa de um groupby prévio, ele usa a base linha a linha, cada ponto é uma venda.

Gráfico de bolhas em Python

# Gráfico de bolhas (bubble) — dispersão em que o tamanho representa uma 3ª variável
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# size = quantidade -> quanto maior a quantidade, maior a bolha
fig = px.scatter(df, x="vendas", y="lucro", size="quantidade", color="categoria",
                 title="Vendas x Lucro (tamanho = quantidade)")
fig.show()

O parâmetro size acrescenta uma terceira variável ao gráfico de dispersão, representada pelo tamanho de cada ponto, e color ainda separa os pontos por categoria.

Gráfico de dispersão 3D em Python

# Gráfico de dispersão 3D — três variáveis numéricas ao mesmo tempo
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

fig = px.scatter_3d(df, x="vendas", y="lucro", z="quantidade", color="categoria",
                    title="Vendas x Lucro x Quantidade (3D)")
fig.show()

Quando duas variáveis não são suficientes, o scatter_3d acrescenta um terceiro eixo, permitindo comparar três variáveis numéricas ao mesmo tempo, girando o gráfico com o mouse para explorar os ângulos.

Densidade 2D em Python

# Mapa de calor de densidade (2D) — onde os pontos se concentram (vendas x lucro)
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

fig = px.density_heatmap(df, x="vendas", y="lucro",
                         title="Densidade: vendas x lucro")
fig.show()

Em vez de mostrar cada ponto individualmente, o density_heatmap mostra onde os pontos se concentram, útil quando a base tem tantas linhas que um scatter comum viraria uma mancha ilegível.

Gráficos de proporção e especializados em Python

O último grupo reúne os gráficos que mostram a participação de cada parte dentro de um todo, e os gráficos mais específicos deste guia, voltados para hierarquia, fluxo, metas e mapas.

Gráfico de pizza em Python

# Gráfico de pizza — participação de cada categoria no total de vendas
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

dados = df.groupby("categoria", as_index=False)["vendas"].sum()

# values = tamanho das fatias, names = rótulo de cada fatia
fig = px.pie(dados, values="vendas", names="categoria",
             title="Participação das categorias nas vendas")
fig.show()

O parâmetro values define o tamanho de cada fatia, e names define o rótulo de cada uma delas.

Gráfico de rosca (donut) em Python

A rosca é uma variação direta da pizza, com um parâmetro a mais.

# Gráfico de rosca (donut) — uma pizza com um furo no meio
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

dados = df.groupby("categoria", as_index=False)["vendas"].sum()

# hole cria o furo central (0 = pizza normal, 1 = furo total)
fig = px.pie(dados, values="vendas", names="categoria", hole=0.5,
             title="Participação das categorias (rosca)")
fig.show()

O parâmetro hole abre o furo central, 0 mantém uma pizza normal e 1 deixa o furo total.

Gráfico de funil em Python

# Gráfico de funil — valores em ordem decrescente (vendas por categoria)
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# ordena do maior para o menor para dar o formato de funil
dados = (df.groupby("categoria", as_index=False)["vendas"].sum()
           .sort_values("vendas", ascending=False))
print(dados)
fig = px.funnel(dados, x="categoria", y="vendas", title="Funil de vendas por categoria")
fig.show()

Muito usado em etapas de vendas ou conversão, o funil precisa que os dados estejam ordenados do maior para o menor antes de plotar, por isso o sort_values antes do px.funnel.

Treemap em Python

# Treemap — retângulos hierárquicos: país > categoria > produto
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# path define a hierarquia; o Plotly já soma os valores automaticamente
fig = px.treemap(df, path=["pais", "categoria", "produto"], values="vendas",
                 title="Vendas por país, categoria e produto")
fig.show()

O parâmetro path define a hierarquia dos retângulos, nesse caso país, categoria e produto, e o próprio Plotly soma os valores automaticamente em cada nível.

Sunburst em Python

# Sunburst — hierarquia em anéis (círculos concêntricos): país > categoria
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

fig = px.sunburst(df, path=["pais", "categoria"], values="vendas",
                  title="Vendas por país e categoria")
fig.show()

O sunburst usa a mesma lógica de hierarquia do treemap, só que desenhada em anéis concêntricos em vez de retângulos.

Gráfico de cascata (waterfall) em Python

Outro gráfico que só existe em Graph Objects.

# Gráfico de cascata (waterfall) — usa Graph Objects (não existe no Express)
# Mostra a contribuição de lucro de cada categoria até o total
import pandas as pd
import plotly.graph_objects as go

df = pd.read_csv("vendas.csv")

dados = df.groupby("categoria", as_index=False)["lucro"].sum()
print(dados)
fig = go.Figure(go.Waterfall(
    x=list(dados["categoria"]) + ["Total"],
    y=list(dados["lucro"]) + [0],
    # "relative" soma ao acumulado; "total" desenha a barra final
    measure=["relative"] * len(dados) + ["total"],
))
fig.update_layout(title="Contribuição de lucro por categoria (cascata)")
fig.show()

O parâmetro measure define se cada barra soma ao acumulado ("relative") ou representa o total ("total"), mostrando como cada categoria contribui até chegar no resultado final.

Heatmap em Python

# Heatmap (mapa de calor / matriz) — vendas por país x categoria
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

# pivot_table cria a matriz: linhas = país, colunas = categoria, valores = soma de vendas
tabela = df.pivot_table(index="pais", columns="categoria",
                        values="vendas", aggfunc="sum")
print(tabela)

# text_auto escreve o valor em cada célula
fig = px.imshow(tabela, text_auto=".0f", aspect="auto",
                title="Vendas: país x categoria")
fig.show()

O heatmap parte de uma pivot_table, com países nas linhas e categorias nas colunas, e o parâmetro text_auto escreve o valor exato dentro de cada célula, além da cor.

Gráfico indicador (gauge) em Python

# Indicador / velocímetro (gauge) — usa Graph Objects (não existe no Express)
# Compara o total de vendas com uma meta
import pandas as pd
import plotly.graph_objects as go

df = pd.read_csv("vendas.csv")

total = df["vendas"].sum()
meta = 3_000_000

fig = go.Figure(go.Indicator(
    mode="gauge+number+delta",   # ponteiro + número + diferença para a meta
    value=total,
    delta={"reference": meta},
    gauge={"axis": {"range": [0, max(total, meta) * 1.2]}},
    title={"text": "Total de vendas x meta"},
))
fig.show()

Esse gráfico compara um valor com uma meta, nesse exemplo a meta está fixa no próprio código, mas na sua base ela pode vir de outra fonte, como uma meta comercial cadastrada em outra tabela.

Gráfico polar (radar) em Python

# Gráfico polar / radar — satisfação média por categoria
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

dados = df.groupby("categoria", as_index=False)["satisfacao"].mean()

# line_close=True fecha o polígono do radar
fig = px.line_polar(dados, r="satisfacao", theta="categoria", line_close=True,
                    range_r=[0, 5], title="Satisfação média por categoria")
fig.show()

O line_polar organiza as categorias ao redor de um círculo, e o line_close=True fecha o polígono, ligando o último ponto de volta ao primeiro.

Diagrama de Sankey em Python

O sankey é o gráfico mais manual deste guia, mostrando o fluxo de valores entre duas colunas.

# Diagrama de Sankey (fluxo) — usa Graph Objects (não existe no Express)
# Fluxo de vendas: país -> categoria
import pandas as pd
import plotly.graph_objects as go

df = pd.read_csv("vendas.csv")

fluxo = df.groupby(["pais", "categoria"], as_index=False)["vendas"].sum()

# lista de nós (países + categorias) e um índice numérico para cada um
rotulos = list(fluxo["pais"].unique()) + list(fluxo["categoria"].unique())
indice = {nome: i for i, nome in enumerate(rotulos)}

fig = go.Figure(go.Sankey(
    node={"label": rotulos},
    link={
        "source": fluxo["pais"].map(indice),
        "target": fluxo["categoria"].map(indice),
        "value": fluxo["vendas"],
    },
))
fig.update_layout(title="Fluxo de vendas: país -> categoria")
fig.show()

Antes de plotar, cada valor único de país e de categoria vira um número de índice, porque o Sankey do Plotly liga os nós por posição numérica, não pelo nome.

Mapa coroplético em Python

# Mapa coroplético (choropleth) — total de vendas por país
import pandas as pd
import plotly.express as px

df = pd.read_csv("vendas.csv")

dados = df.groupby(["pais", "iso_alpha"], as_index=False)["vendas"].sum()
print(dados)
# locations usa o código ISO-3 do país; hover_name mostra o nome ao passar o mouse
fig = px.choropleth(dados, locations="iso_alpha", color="vendas",
                    hover_name="pais", title="Vendas por país")
fig.show()
    

O parâmetro locations usa o código ISO de três letras de cada país para posicionar a cor no mapa, e hover_name mostra o nome do país ao passar o mouse.

Conclusão

Você acabou de ver 25 formas diferentes de transformar a mesma base de dados em gráfico, cada uma respondendo a um tipo de pergunta diferente, comparação, evolução no tempo, distribuição, relação entre variáveis, proporção e visualizações mais específicas como mapas e diagramas de fluxo. O próximo passo natural é praticar em cima da sua própria base, trocando as colunas dos exemplos pelas colunas que você já tem disponíveis.

Se você quiser ir além dos gráficos e aprender a estruturar um projeto de análise de dados completo em Python, do zero até a apresentação dos resultados, vale conhecer o Curso de Python da Hashtag Treinamentos.

Caso prefira esse conteúdo no formato de videoaula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

FAQ - Perguntas Frequentes sobre Gráficos em Python

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.