Guia Completo sobre a Biblioteca Pandas do Python

Aprenda tudo o que você precisa saber sobre a biblioteca Pandas do Python para trabalhar com análise de dados.

O Pandas é a biblioteca Python mais usada em análise de dados. Com ela, você faz todo o processo de ETL — extrair, transformar e carregar dados — usando o DataFrame, uma estrutura em formato de tabela com linhas e colunas. É possível ler arquivos CSV e Excel, limpar, filtrar, agrupar e exportar dados sem sair do Python.

Introdução à Biblioteca Pandas do Python

Fala, impressionador!

Se você quer trabalhar com dados em Python, dominar o Pandas é essencial. Neste guia completo, você vai aprender tudo sobre a biblioteca mais usada para análise de dados, desde a instalação até análises avançadas com exemplos práticos que vão te ensinar como aplicar cada conceito.

Ficou interessado(a), então, vem comigo!

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.

O que é Pandas e Por Que Usar?

O Pandas é a biblioteca Python mais utilizada na área de dados. Ela permite fazer todo o processo de ETL (Extract, Transform, Load):

• Extract (Extrair): Importar dados de diversas fontes;
• Transform (Transformar): Limpar e tratar os dados;
• Load (Carregar): Preparar dados para análises.

Além disso, você consegue fazer análises completas diretamente no Pandas, sem precisar de ferramentas externas.

Antes de começar, você precisa instalar o Pandas no seu ambiente Python. Por isso, no editor de código que estiver usando (Exemplo: Google Colab, Visual Studio Code ou Jupyter Notebook), abra o terminal e execute o comando:

pip install pandas

Além disso, para trabalhar com arquivos Excel, é necessário instalar a engine OpenPyXL através do comando:

pip install openpyxl

Para projetos de dados, recomendamos usar arquivos .ipynb ao invés de .py, pois eles permitem executar código célula por célula, facilitam a visualização de dados e são o padrão da indústria para análise de dados.

No VS Code, instale a extensão do Jupyter para trabalhar com esses arquivos. Caso queira um passo a passo detalhado, você pode consultar o vídeo Como Usar o Jupyter Notebook no VSCode.

Importando Bibliotecas

O primeiro passo para utilizar uma biblioteca é importá-lá no projeto da seguinte maneira:

import pandas as pd
import numpy as np

No código acima, importamos as bibliotecas pandas e numpy, pois enquanto o NumPy oferece estruturas de dados eficientes para operações matemáticas e computação numérica, o Pandas fornece ferramentas de alto nível para manipulação e análise de dados estruturados.

Além disso, ao realizar a importação, usamos um apelido tanto para o Pandas (pd) quanto para o Numpy (np) que são padrões aplicados pela comunidade Python.

Carregando Dados no Pandas

Após importar as bibliotecas, o próximo passo é carregar os dados que serão utilizados na análise. Para isso utilizamos o pd.read e automaticamente é carregado alguns tipos de bases de dados que podem ser lidos pelo Pandas, como, CSV, XLSX, JSON entre outras.

Essa informação é armazenada em um data frame, ou seja, uma estrutura de dados em forma de tabela, parecida com uma planilha do Excel com linhas e colunas que organizam a informação.

Imagine que você precisa ler uma base de dados de vendas com extensão CSV. Você utilizaria a expressão:

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

Neste código, armazenamos os dados de vendas no df_vendas para identificar do que se trata aquela informação e utilizamos o apelido df que é um padrão usado no Python para se referir ao data frame. Em seguida, dizemos que o pandas vai ler um arquivo do tipo CSV com pd.read_csv e entre parênteses trazemos a informação que qual arquivo será lido, neste caso "vendas.csv".

Alguns parâmetros importantes que podem ser empregados no momento da leitura do arquivo são:

• encoding: define a codificação do arquivo, sendo essencial quando há caracteres especiais como "ã", "ç", "é". Os valores mais comuns são: 'utf-8' e 'latin1'. Exemplo:

df_vendas = pd.read_csv('vendas.csv', encoding='utf-8')

• sep: especifica o separador de campos utilizado no arquivo. Em muitos arquivos CSV gerados no Brasil, o separador é o ponto e vírgula (;). Exemplo:

df_vendas = pd.read_csv('vendas.csv', sep=';')

• low_memory: controla a forma como o pandas processa arquivos grandes. Quando definido como True (valor padrão), o arquivo é lido em partes (chunks), o que reduz o uso de memória, mas pode causar inferência incorreta de tipos de dados. Ao definir como False, o pandas analisa o arquivo inteiro de uma vez, garantindo uma inferência de tipos mais consistente. Exemplo:

df_vendas = pd.read_csv('vendas.csv', low_memory=False)

Visualizando Dados

Para visualizar dados em arquivos com extensão .ipynb, podemos usar o display ao invés do tradicional print Python. Por exemplo:

#Visualizar as primeiras e últimas 5 linhas do data frame
display(df_vendas)

Há algumas variações que podem ser usadas para visualização e exploração inicial dos dados, permitindo entender rapidamente a estrutura e o conteúdo da base:

• head(n): exibe as primeiras linhas do DataFrame. É muito útil para conferir se a leitura do arquivo foi feita corretamente e verificar o formato geral dos dados. Exemplo:

#Ver as primeiras 10 linhas
display(df_vendas.head(10))

• tail(n): mostra as últimas linhas do DataFrame. Ajuda a identificar como os dados terminam e a verificar possíveis inconsistências no final do arquivo. Exemplo:

#Ver as últimas 10 linhas
display(df_vendas.tail(10))

• sample(n): retorna linhas aleatórias da base, permitindo uma visão mais variada dos dados sem seguir a ordem original. Exemplo:

#Ver 15 linhas aleatórias
display(df_vendas.sample(15))

Além disso, podemos visualizar características importantes na etapa inicial da análise de dados, para nos ajudar a identificar problemas e padrões antes de qualquer processamento ou modelagem. As principais características são:

• shape: informa as dimensões do DataFrame no formato (linhas, colunas), permitindo ter uma noção do tamanho da base. Exemplo: df_vendas.shape;
• columns: retorna a lista com os nomes de todas as colunas, facilitando a identificação das variáveis disponíveis. Exemplo: df_vendas.columns;
• info(): fornece informações detalhadas sobre o DataFrame, incluindo tipos de dados de cada coluna, quantidade de valores não nulos e uso de memória. Exemplo: df_vendas.info();
• describe(): apresenta estatísticas descritivas das colunas numéricas, como média, desvio padrão, valores mínimo e máximo, além dos quartis. Exemplo: df_vendas.describe().

Tratamento de Dados

O tratamento de dados é uma das fases mais críticas da análise, pois garante que as informações estejam consistentes, completas e prontas para gerar insights confiáveis. Abaixo estão algumas práticas essenciais dessa etapa:

Excluindo Colunas Inúteis

Nem todas as colunas de uma base de dados são relevantes para a análise. Remover colunas desnecessárias ajuda a simplificar o DataFrame e melhora o desempenho das operações.

df_analise = df_vendas.drop(columns=['data_base'])

No código acima,

• df_vendas: DataFrame original;
• .drop(): método usado para remover linhas ou colunas;
• columns=['data_base']: indica que a coluna chamada data_base será removida;
• df_analise: novo DataFrame gerado sem essa coluna (o original não é alterado).

Tratando Valores Vazios

Valores ausentes podem comprometer análises e modelos estatísticos, por isso devem ser identificados e tratados adequadamente. Isso pode ser feito de duas formas:

• Remover linhas com valores vazios: indicado quando a quantidade de dados faltantes é pequena ou irrelevante. Exemplo:

df_analise = df_analise.dropna()

• Preencher valores vazios: útil quando é importante manter todas as linhas da base. Por exemplo, quando uma célula da coluna "loja" é preenchida com valor vazio ao realizar uma compra online, podemos selecionar a coluna "loja" (df_analise['loja'])  e fazer uma substituição do valor vazio para "Online" (.fillna('Online')). O código completo ficaria assim:

df_analise['loja'] = df_analise['loja'].fillna('Online')

Corrigindo Tipos de Dados

Garantir que cada coluna esteja com o tipo correto é fundamental para cálculos, filtros e análises temporais. Por exemplo, se queremos padronizar a data no formato "YYYY-MM-DD" podemos usar o seguinte código:

df_analise['data'] = pd.to_datetime(df_analise['data'], format='%Y-%m-%d')

Nele,

• pd.to_datetime(): converte textos para o tipo datetime;
• format='%Y-%m-%d': define o formato da data (ano-mês-dia).

Para descobrir outros formatos de datas que podem ser utilizados, você pode conferir a documentação do Pandas.

Padronização de Textos

A padronização evita inconsistências como diferenças de maiúsculas/minúsculas ou espaços extras, que podem gerar erros em agrupamentos e análises.

Um bom exemplo seria a remoção de espaços extras e padronização de capitalização, deixando apenas a primeira letra de cada palavra em maiúscula:

df_analise['loja'] = df_analise['loja'].str.strip().str.title()

Neste código,

• .str: acessa métodos de manipulação de texto;
• .strip(): remove espaços em branco no início e no fim do texto;
• .title(): coloca a primeira letra de cada palavra em maiúscula.

Removendo Duplicatas

Registros duplicados podem distorcer resultados, especialmente em análises de contagem, soma ou faturamento.

Podemos remover uma linha completamente duplicada com a expressão .drop_duplicates(), mantendo apenas uma ocorrência de cada registro duplicado.

df_analise = df_analise.drop_duplicates()

Também podemos remover duplicatas com base em uma coluna específica, definindo qual linha manter.

df_analise = df_analise.drop_duplicates(subset=['id_pedido'], keep='first')

No código acima, o subset=['id_pedido'], considera apenas essa coluna para identificar duplicatas enquanto o keep='first': mantém a primeira ocorrência encontrada. Outras opções são:

• keep='last': mantém a última;
• keep=False: remove todas as duplicatas.

Criando Novas Colunas

Criar novas colunas significa gerar novos dados a partir de informações já existentes, permitindo análises mais completas, como faturamento, classificação, segmentação e regras de negócio.

As novas colunas, são construídas com base no que queremos analisar dos dados que temos.

Imagine que você precisa criar uma coluna de faturamento para identificar quanto cada loja faturou. Para isso, você poderia fazer uma operação direta onde multiplicaria as colunas "quantidade" pela "preco_unitario" e obteria para cada linha do DataFrame o valor total da venda.

O código seria assim:

df_analise['faturamento'] = df_analise['quantidade'] * df_analise['preco_unitario']

Nele,

• df_analise['faturamento']: cria uma nova coluna chamada faturamento;
• df_analise['quantidade']: coluna que representa o número de itens vendidos;
• df_analise['preco_unitario']: coluna com o valor de cada item;
• O operador * é aplicado linha a linha (operação vetorizada).

Outro exemplo, seria verificar se a venda foi realizada em uma loja física ou online. Para isso, podemos usar o código:

df_analise['forma_venda'] = np.where(
    df_analise['loja'] == 'Online',
    'Online',
    'Presencial'
)

O np.where funciona como um if/else vetorizado onde ele recebe como primeiro parâmetro a condição, o segundo é o valor se a condição for verdadeira e o terceiro é o valor se a condição for falsa. Neste exemplo, df_analise['loja'] == 'Online'é a condição que é avaliada linha a linha. Se a condição for verdadeira a célula é preenchida com 'Online', se for falsa a célula é preenchida com 'Presencial'.

Além de usar condicionais, podemos criar um dicionário com um par chave/valor:

dic_regioes = {
    'São Paulo': 'Sudeste',
    'Rio de Janeiro': 'Sudeste',
    'Belo Horizonte': 'Sudeste',
    'Salvador': 'Nordeste',
    'Recife': 'Nordeste',
    'Curitiba': 'Sul',
    'Porto Alegre': 'Sul',
    'Online': 'Online'
}

A chave representa um valor existente na coluna "loja" enquanto o valor representa a região correspondente.

A nova coluna criada com o df_analise['regiao']indica a região geográfica associada a cada loja:

df_analise['regiao'] = df_analise['loja'].map(dic_regioes)

O map()pega cada valor da coluna 'loja', procura ele como chave no dicionário, e retorna o valor correspondente. Se encontrar "São Paulo", retorna "Sudeste". Se encontrar "Salvador", retorna "Nordeste", e assim por diante.

Esses métodos são fundamentais para transformar dados brutos em informações estratégicas, permitindo análises mais ricas, dashboards mais completos e decisões melhor embasadas.

Selecionando Colunas

Durante uma análise de dados, é comum trabalhar com grandes volumes de informações armazenadas em data frames do Pandas. Para extrair insights relevantes, precisamos saber como selecionar colunas específicas e como filtrar linhas de acordo com critérios bem definidos, como localidade, produto ou período de tempo.

A primeira seleção que podemos fazer é a seleção de colunas, pois é extremamente útil quando queremos focar apenas em determinadas variáveis da análise.

Para selecionar uma única coluna, basta indicar o nome da coluna entre colchetes:

df_analise['loja']

Esse comando retorna apenas a série com os nomes das lojas.

Contudo, quando é necessário trabalhar com múltiplas colunas ao mesmo tempo, utilizamos uma lista com os nomes das colunas que queremos:

df_analise[['loja', 'produto', 'faturamento']]

Assim, obtemos um novo data frame contendo somente essas três informações, o que facilita análises mais direcionadas, como o faturamento por produto e por loja.

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

Filtrando Dados

Além de selecionar colunas, muitas análises exigem a filtragem de registros específicos com base em condições. Suponha que você queira analisar apenas as vendas realizadas na loja de São Paulo. Isso pode ser feito da seguinte forma:

df_vendas_sp = df_analise[df_analise['loja'] == 'São Paulo']

O resultado será um data frame contendo somente as linhas em que a coluna "loja" possui o valor “São Paulo”.

É possível aplicar mais de uma condição ao mesmo tempo. Por exemplo, para identificar vendas de cabo HDMI realizadas na região Sul, usamos o operador lógico & ("e"):

df_filtrado = df_analise[
    (df_analise['produto'] == 'Cabo HDMI') &
    (df_analise['regiao'] == 'Sul')
]

Nesse caso, apenas os registros que atendem ambas as condições serão retornados.

Já quando queremos registros que atendam uma condição ou outra, utilizamos o operador | ("ou"). Por exemplo, vendas de Mouse ou realizadas na região Nordeste:

df_filtrado = df_analise[
    (df_analise['produto'] == 'Mouse') |
    (df_analise['regiao'] == 'Nordeste')
]

Os filtros de data também são muito comuns. Por exemplo, em análise de vendas, podemos selecionar apenas registros de um determinado ano, considerando que a coluna "data" esteja com o formato "datetime":

df_2024 = df_analise[df_analise['data'].dt.year == 2024]

Neste código, acessamos a coluna "data", acessamos os componentes de data e extraímos apenas o ano com o atributo .dt.year, e verificamos se o ano é 2024 com ==2024.

Também é possível filtrar vendas realizadas após uma data específica, o que é útil para análises de períodos recentes ou pós-campanhas:

df_filtrado = df_analise[df_analise['data'] >= '2024-01-01']

Localizando Valores Específicos

Para uma precisão ainda maior na filtragem dos dados, o Pandas oferece os métodos .loc e .iloc.

• .loc: é ideal quando conhecemos o nome da coluna ou do índice (linha), pois ele localiza os elementos através do nome (rótulo). Por exemplo:

# Acessar valor na linha de índice 3 e coluna 'loja'
loja = df_analise.loc[3, 'loja']

# Localizar a 'loja' de um ID específico e extrair apenas o valor (string/número)
loja_id4 = df_analise.loc[df_analise['id_pedido'] == 4, 'loja'].values[0]

• .iloc: funciona como um sistema de coordenadas e é bastante útil quando precisamos acessar dados pela sua localização física, independente do nome da coluna ou índice. Por exemplo:

# Acessar a primeira linha (0) e a terceira coluna (2)
valor = df_analise.iloc[0, 2]

Ordenando Dados

O Pandas permite ordenar dados de forma simples, seja por uma única coluna, por várias colunas ao mesmo tempo ou em diferentes ordens (crescente e decrescente).

Para ordenação de forma crescente, podemos usar o método sort_values():

df_analise = df_analise.sort_values(by='faturamento')

Neste exemplo, o parâmetro by='faturamento' indica que a ordenação será feita com base na coluna faturamento. Como o parâmetro ascending não foi informado, o padrão é True, ou seja, ordem crescente.

Agora, se o parâmetro ascending for false, a ordem é invertida e fica decrescente, ou seja, os maiores faturamentos aparecem primeiro, sendo muito comum em análises financeiras e rankings.

df_analise = df_analise.sort_values(by='faturamento', ascending=False)

Além disso, também é possível por múltiplas colunas simultaneamente. Isso é útil quando queremos, por exemplo, organizar os dados cronologicamente e, dentro de cada dia, listar o faturamento do maior para o menor.

df_analise = df_analise.sort_values(by=['data', 'faturamento'], ascending=[True, False])

Gestão de Índices

Quando ordenamos um data frame ou removemos linhas, o índice original (os números à esquerda) permanece vinculado à sua linha de origem. Isso resulta em um índice "embaralhado" que não reflete mais a nova sequência física dos dados.

Para normalizar a estrutura, utilizamos o método reset_index.

df_analise = df_analise.reset_index(drop=True)

O parâmetro drop=True é importante para evitar que o índice antigo seja transformado em uma nova coluna de dados, mantendo o data frame limpo e com uma numeração sequencial com a nova ordem estabelecida.

Análises com Agrupamento

Para analisar dados com agrupamento, o Pandas utiliza o groupby(). Com ele conseguimos extrair insights relevantes e responder perguntas como "qual loja vendeu mais?", "qual produto tem maior faturamento?" ou "qual região tem melhor desempenho?".

O conceito do groupby() é agrupar os dados através de uma categoria (coluna) e, em seguida, aplicar uma operação (soma, média, contagem, etc.) nos valores de cada grupo.

Precisamos selecionar as colunas que queremos trabalhar e dizer qual o tipo de operação será realizado com cada uma, pois se você tentar fazer o groupby na tabela inteira, o Pandas vai tentar somar todas as colunas, incluindo colunas de texto, o que vai gerar erros.

Imagine que você tem uma pilha de notas fiscais misturadas de várias lojas e precisa ranquear as lojas de acordo com as vendas. O código ficaria assim:

analise_lojas = df_analise[["Loja", "Faturamento"]].groupby("Loja").sum()
analise_lojas = analise_lojas.sort_values(by="Faturamento", ascending=False)
analise_lojas = analise_lojas.rename(columns={"Faturamento": "Vendas totais"})
analise_lojas = analise_lojas.reset_index()

Vamos destrinchar o que está acontecendo aqui:

• df_analise[['loja', 'faturamento']]: seleciona as colunas que precisamos;
• .groupby('loja'): agrupa os dados por loja (cada loja aparece apenas uma vez no resultado);
• .sum(): soma todos os valores de faturamento dentro de cada grupo;
• .sort_values(by="Faturamento", ascending=False): ordena a tabela conforme os dados de faturamento de forma decrescente (do maior para o menor valor);
• .rename(columns={"faturamento": "Vendas totais"}): busca a coluna "Faturamento" e renomeia para "Vendas totais";
• .reset_index(): como o groupby()transforma a coluna que ele agrupa em um índice este trecho no código reseta e transforma o índice antigo em uma coluna.

O .sum() é apenas uma das várias funções que você pode aplicar após um groupby():

# Média de faturamento por loja
analise_media = df_analise[['loja', 'faturamento']].groupby('loja').mean()

# Faturamento máximo de cada loja
analise_max = df_analise[['loja', 'faturamento']].groupby('loja').max()

# Faturamento mínimo de cada loja
analise_min = df_analise[['loja', 'faturamento']].groupby('loja').min()

# Contar quantas vendas cada loja fez
analise_count = df_analise[['loja', 'produto']].groupby('loja').count()

# Estatísticas completas
analise_stats = df_analise[['loja', 'faturamento']].groupby('loja').describe()

Cada uma dessas funções responde uma pergunta diferente sobre seus dados. A escolha depende do que você está tentando descobrir.

Também é possível agrupar mais de uma coluna. Por exemplo, para responder a pergunta: "quais produtos vendem mais em cada uma das lojas?", podemos escrever o seguinte código:

analise_produto_em_lojas = df_analise[["Loja", "Produto", "Qtd"]].groupby(["Loja", "Produto"]).sum()

No exemplo acima:

• df_analise[["Loja", "Produto", "Qtd"]]: seleciona algumas colunas do data frame;
• .groupby(["Loja", "Produto"]): primeiro agrupamos por loja e depois por produto;
• .sum(): soma a quantidade de cada produto.

Ao usar o display() ou print() para exibir o resultado, o Pandas impõe um limite à quantidade de linhas exibidas. Esse comportamento existe para evitar que tabelas muito grandes ocupem espaço excessivo na tela, fazendo com que apenas as primeiras e últimas linhas sejam exibidas, enquanto o restante é substituído por reticências.

Quando é necessário visualizar todas as linhas de um data frame, é possível ajustar temporariamente essa configuração utilizando o método pd.option_context. Ao definir a opção 'display.max_rows' como None, o Pandas é instruído a não aplicar nenhum limite na exibição das linhas, permitindo que todo o conteúdo da tabela seja mostrado.

with pd.option_context('display.max_rows', None):
    display(analise_produto__em_loja)

O uso da estrutura with é importante porque ela cria um contexto temporário para essa alteração. Isso significa que a configuração especial vale apenas dentro do bloco de código delimitado pelo with. Assim que o bloco é finalizado, o Pandas automaticamente retorna às configurações padrão, evitando impactos indesejados em outras partes do código.

Mesclando Tabelas

Até este momento, usamos uma única tabela para realizar as análises, mas geralmente lidamos com várias tabelas, como "vendas", "gerentes", "clientes", entre outras e em muitos casos, precisamos unir as informações para fazer análises completas.

É aqui que entra o merge(), ele permite combinar duas tabelas baseando-se em uma coluna em comum.Imagine que você tem duas tabelas "vendas" e "gerentes". A tabela "vendas" possui as colunas: "id", "data", "loja" e "faturamento", enquanto a tabela "gerentes" possui as colunas: "loja", "gerente" e "meta". Você pode usar a coluna "loja" de ambas as tabelas como ponte para unir as tabelas e trazer as informações de gerente para a tabela de vendas. Em código ficaria assim:

df_completo = df_vendas.merge(df_gerentes, on='loja', how='left')

Vamos entender os parâmetros:

• on='loja': a coluna que existe nas duas tabelas e será usada para fazer a correspondência. O Pandas vai procurar valores iguais nessa coluna em ambas as tabelas;
• how='left': define o tipo de join. Neste caso, a opção left mantém todas as linhas da tabela da esquerda (vendas), mesmo que não tenham correspondência na tabela da direita (gerentes). Onde não houver correspondência, os valores da tabela da direita ficarão vazios (NaN). Outras opções que podem ser usadas são:
  • how='inner': valor padrão que mantém apenas as linhas que têm correspondência nas 2 tabelas;
  • how='right': oposto do left;
  • how='outer': mantém todas as linhas de ambas as tabelas, preenchendo com NaN onde não houver correspondência.

Contudo, se o nome da coluna em cada tabela for diferente, mas os dados forem os mesmos, por exemplo, a coluna se chama "loja" na tabela "vendas" e "cidade" na tabela "gerentes", podemos usar o seguinte código:

df_completo = df_vendas.merge(
    df_gerentes,
    left_on='loja',      # nome na tabela da esquerda
    right_on='cidade',   # nome na tabela da direita
    how='left'
)

A tabela "da esquerda" é a primeira que você menciona (df_vendas), e a "da direita" é a segunda (df_gerentes). É só uma convenção para indicar qual é qual.

Concatenando data frames: Empilhando Dados

Diferente do merge(), que une tabelas lado a lado, o concat() empilha tabelas uma sobre a outra. Isso é útil quando você tem dados separados por período e quer juntá-los. Por exemplo, unir as vendas de vários meses em uma única tabela:

df_completo = pd.concat([df_janeiro, df_fevereiro, df_marco], ignore_index=True)

O parâmetro ignore_index=True recria os índices sequencialmente (0, 1, 2, 3...), ao invés de manter os índices originais de cada data frame.

Para concatenar tabelas, elas precisam ter as mesmas colunas (ou pelo menos colunas compatíveis). Se você tentar concatenar uma tabela com colunas [A, B, C] com outra que tem [A, B, D], teremos problemas.

Mas quando usar concat e quando usar o merge?

Use concat quando:

• Você tem a mesma estrutura de dados em arquivos/períodos diferentes;
• Quer "empilhar" linhas uma sobre a outra;
• Está consolidando dados de múltiplas fontes com o mesmo formato.

Use merge quando:

• Você tem informações complementares em tabelas diferentes;
• Precisa "cruzar" dados baseado em uma chave comum;
• Está enriquecendo uma tabela com dados de outra.

Análise de Séries Temporais

A análise temporal é fundamental quando você quer entender tendências, sazonalidades e padrões que se desenvolvem ao longo do tempo. "As vendas estão crescendo ou caindo?", "Qual mês teve melhor performance?", "Existe algum padrão sazonal?",  todas essas perguntas exigem análise temporal.

O primeiro passo para análise temporal é criar uma coluna que represente o período que você quer analisar - mês, trimestre, ano, etc:

df_analise['mes_ano'] = df_analise['data'].dt.to_period('M')

O método .to_period() pega a coluna de data completa (que pode ter dia, mês, ano, hora, etc.) e converte para um período específico. Os parâmetros mais comuns são:

• 'M' - Mensal (2024-01, 2024-02, etc.)
• 'Q' - Trimestral (2024Q1, 2024Q2, etc.)
• 'Y' - Anual (2024, 2023, etc.)
• 'W' - Semanal

Em seguida, é possível agrupar normalmente os dados de venda por mês e somar os valores de faturamento:

df_vendas_mes = df_analise[['mes_ano', 'faturamento']].groupby('mes_ano').sum()

Visualizando Tendências com Gráficos

A análise temporal geralmente é mais clara quando visualizada graficamente. O Pandas tem integração básica com matplotlib:

df_vendas_mes.plot()

Isso gera automaticamente um gráfico mostrando a evolução das vendas mês a mês. Você pode ver visualmente se existe crescimento, queda ou sazonalidade.

Para visualizações mais profissionais e interativas, recomendamos usar bibliotecas especializadas como Plotly, que oferece gráficos muito mais bonitos e funcionais. O .plot() do Pandas é ótimo para análises exploratórias rápidas, mas não para apresentações finais.

Caso queira conhecer melhor o Plotly, assista o vídeo Plotly no Python.

Exportando Seus Dados

Depois de concluir toda a etapa de análise e tratamento dos dados, o próximo passo normalmente é exportar os resultados. A exportação permite que os dados sejam compartilhados, arquivados ou utilizados em relatórios e apresentações fora do ambiente Python, como em planilhas do Excel ou arquivos CSV.

O formato CSV é um dos mais utilizados por ser leve, simples e compatível com praticamente qualquer ferramenta de análise ou planilha. Ao exportar um data frames do Pandas para CSV, é importante desativar a exportação do índice (index=False). Caso contrário, o Pandas adiciona automaticamente uma coluna extra com os índices numéricos, o que geralmente não é desejado em relatórios finais.

Outro ponto fundamental é o encoding do arquivo. Utilizar encoding='utf-8-sig' é altamente recomendado quando o arquivo será aberto no Excel, pois esse encoding garante que caracteres acentuados sejam exibidos corretamente, evitando problemas com textos “quebrados” ou símbolos estranhos.

df_analise.to_csv('analise_vendas.csv', index=False, encoding='utf-8-sig')

Quando é necessário gerar relatórios mais completos ou organizados, o formato Excel costuma ser a melhor opção. Ele permite trabalhar com abas, nomes personalizados e uma apresentação mais amigável para usuários finais.

df_analise.to_excel('analise_vendas.xlsx', index=False, sheet_name='Vendas')

Um erro comum durante a preparação de relatórios é formatar os dados muito cedo. Por exemplo, transformar valores numéricos em textos com símbolos de moeda ou separadores visuais pode parecer uma boa ideia, mas isso impede que esses valores sejam usados posteriormente em cálculos. Uma vez que um número vira texto, ele não pode mais ser somado, multiplicado ou analisado matematicamente.

A boa prática é manter os dados sempre em formato numérico durante toda a fase de análise. A formatação deve ser aplicada apenas no momento final, quando os dados já não precisam mais ser manipulados. Uma estratégia simples e segura é criar uma cópia do data frame original apenas para apresentação, garantindo que os dados brutos permaneçam intactos para futuras análises.

Perguntas frequentes

Conclusão

O Pandas é uma ferramenta incrivelmente poderosa e versátil. Com o conhecimento deste guia, você tem tudo que precisa. Mas lembre-se, conhecimento teórico é apenas o começo. O próximo passo é construir um portfólio e praticar, portanto, use esses conhecimentos com análise de despesas pessoais, bases de dados do kaggle e evolua gradualmente.

Se você quer aprender mais sobre Python de forma prática e focada no mercado atual, conheça nosso Curso Python Impressionador.

Além disso, se preferir esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

O que você aprende neste vídeo

Resposta rápida: A aula percorre um projeto completo de análise de dados com Pandas: leitura de CSV e Excel, inspeção, limpeza, transformação, filtros, agrupamentos e exportação. Também ensina a criar colunas, combinar tabelas com merge e concat, avaliar metas por gerente e montar uma série temporal de faturamento mensal.

Neste vídeo (151 min):

• 1:00 - Instalação de Pandas e OpenPyXL e escolha de um notebook Jupyter para o projeto
• 7:00 - Leitura das bases com pd.read_csv() e pd.read_excel()
• 16:00 - Inspeção com head(), tail(), sample(), shape, info() e describe()
• 26:00 - Limpeza inicial: exclusão de colunas inúteis e tratamento de valores nulos
• 40:00 - Conversão da coluna de datas com pd.to_datetime() e definição do formato
• 46:00 - Padronização de textos com str.strip() e str.title() e remoção de duplicatas
• 54:00 - Criação da coluna de faturamento a partir de Quantidade vezes Preço Unitário
• 63:00 - Colunas condicionais com np.where() e mapeamento de lojas para regiões com map()
• 75:00 - Filtros com condições, loc e iloc, ordenação e exportação de recortes
• 103:00 - Agrupamentos com groupby() para criar rankings por loja e por produto
• 133:00 - Diferença entre concat para empilhar bases e merge para relacioná-las por uma chave
• 144:00 - Agrupamento mensal, análise de série temporal e gráfico rápido com plot()

Trechos do vídeo:

• Um DataFrame é a tabela do Pandas; cada coluna dessa tabela é uma Series.
• O tratamento vem antes da análise porque valores vazios, tipos errados e duplicatas contaminam os resultados derivados.
• Use concat quando as tabelas têm a mesma estrutura e precisam ser empilhadas; use merge quando existe uma chave de correspondência.

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.