Pandas Python

Análise de Dados

Do Básico ao Avançado

Prof. Elizeu
Licenciado sob CC BY-SA 4.0 — [Link]/licenses/by-sa/4.0
Sumário

1 Introdução ao Pandas 5
1.1 O que é o Pandas? . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Principais Características . . . . . . . . . . . . . . . . . . 5
1.3 Instalação . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4 Primeiro Contato . . . . . . . . . . . . . . . . . . . . . . . 6

2 Series e DataFrames 7
2.1 Series . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Acessando Elementos . . . . . . . . . . . . . . . . . 7
2.2 DataFrames . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Criando DataFrames . . . . . . . . . . . . . . . . . . . . . 8
2.4 Atributos Importantes . . . . . . . . . . . . . . . . . . . . 9

3 Leitura e Escrita de Dados 11

3.1 Lendo Dados . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Parâmetros Importantes . . . . . . . . . . . . . . . . . . . 12
3.3 Escrevendo Dados . . . . . . . . . . . . . . . . . . . . . . 12

4 Seleção e Indexação 14
4.1 Selecionar Colunas . . . . . . . . . . . . . . . . . . . . . . 14
4.2 Seleção por Loc e Iloc . . . . . . . . . . . . . . . . . . . . 15
4.3 Seleção Condicional . . . . . . . . . . . . . . . . . . . . . . 15
4.4 Atribuição de Valores . . . . . . . . . . . . . . . . . . . . . 16

5 Tratamento de Dados Ausentes 17

5.1 Identificando Valores Ausentes . . . . . . . . . . . . . . . 17
5.2 Removendo Valores Ausentes . . . . . . . . . . . . . . . . 18
5.3 Preenchendo Valores Ausentes . . . . . . . . . . . . . . . . 18

2
6 Transformação de Dados 20
6.1 Métodos Apply e Map . . . . . . . . . . . . . . . . . . . . 20
6.2 Renomear e Reordenar . . . . . . . . . . . . . . . . . . . . 21
6.3 Operações Comuns . . . . . . . . . . . . . . . . . . . . . . 21
6.4 Pivoteamento . . . . . . . . . . . . . . . . . . . . . . . . . 22

7 Agrupamento e Agregação 23
7.1 GroupBy . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
7.2 Transform e Filter . . . . . . . . . . . . . . . . . . . . . . 24
7.3 Agregações Comuns . . . . . . . . . . . . . . . . . . . . . 25
7.4 Tabelas de Frequência . . . . . . . . . . . . . . . . . . . . 25

8 Fusão e Concatenação 26
8.1 Merge (Junção de DataFrames) . . . . . . . . . . . . . . . 26
8.2 Concatenação . . . . . . . . . . . . . . . . . . . . . . . . . 27
8.3 Join . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

9 Visualização de Dados 29
9.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
9.2 Gráficos de Linha . . . . . . . . . . . . . . . . . . . . . . . 29
9.3 Gráficos de Barra . . . . . . . . . . . . . . . . . . . . . . . 30
9.4 Gráficos de Pizza . . . . . . . . . . . . . . . . . . . . . . . 30
9.5 Gráfico de Dispersão . . . . . . . . . . . . . . . . . . . . . 30
9.6 Histograma . . . . . . . . . . . . . . . . . . . . . . . . . . 31
9.7 Gráficos com Subplots . . . . . . . . . . . . . . . . . . . . 31

10 Exercícios Práticos 33
10.1 Exercício 1: Análise de Vendas . . . . . . . . . . . . . . . 33
10.2 Exercício 2: Limpeza de Dados . . . . . . . . . . . . . . . 34
10.3 Exercício 3: Relatório Completo . . . . . . . . . . . . . . . 35

11 Dicas e Boas Práticas 37

11.1 Performance . . . . . . . . . . . . . . . . . . . . . . . . . . 37
11.2 Memória . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
11.3 Erros Comuns . . . . . . . . . . . . . . . . . . . . . . . . . 38
11.4 Convenções de Código . . . . . . . . . . . . . . . . . . . . 38

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

12 Referências e Recursos 40
12.1 Documentação Oficial . . . . . . . . . . . . . . . . . . . . 40
12.2 Livros Recomendados . . . . . . . . . . . . . . . . . . . . 40
12.3 Próximos Passos . . . . . . . . . . . . . . . . . . . . . . . 40

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 1

Introdução ao Pandas

1.1 O que é o Pandas?

ò Sobre o Pandas
O Pandas é uma biblioteca open-source para Python que fornece
ferramentas de análise e manipulação de dados de alta performance.
Criada por Wes McKinney em 2008, tornou-se a ferramenta padrão
para ciência de dados em Python.

O nome “Pandas” deriva de Panel Data, um termo econômico para

conjuntos de dados estruturados dimensionais. A biblioteca é construída
sobre o NumPy e permite trabalhar com dados tabulares de forma intui-
tiva.

1.2 Principais Características

• DataFrame e Series: Estruturas de dados flexíveis e poderosas

• Leitura de dados: Suporte a CSV, Excel, SQL, JSON, HTML e

muitos outros formatos

• Alinhamento de dados: Alinhamento inteligente por rótulos (labels)

• Tratamento de dados ausentes: Ferramentas robustas para lidar

com NaN

5
• GroupBy: Operações de divisão-aplicar-combinar

• Visualização: Integração com Matplotlib e Seaborn

1.3 Instalação

pip install pandas

# Ou com todas as depend ê ncias de dados

pip install pandas [ numpy , pyarrow ]

1.4 Primeiro Contato

import pandas as pd

# Criando um DataFrame simples

df = pd . DataFrame ({
’ Nome ’: [ ’ Ana ’ , ’ Bruno ’ , ’ Carlos ’ , ’ Diana ’] ,
’ Idade ’: [25 , 30 , 35 , 28] ,
’ Cidade ’: [ ’S ã o ␣ Paulo ’ , ’ Rio ’ , ’ Belo ␣ Horizonte ’ , ’
Curitiba ’]
})

print ( df )
# Nome Idade Cidade
# 0 Ana 25 S ã o Paulo
# 1 Bruno 30 Rio
# 2 Carlos 35 Belo Horizonte
# 3 Diana 28 Curitiba

 O alias pd é a convenção universal para importar o Pandas. Use

sempre essa convenção para facilitar a leitura do código.

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 2

Series e DataFrames

2.1 Series
Uma Series é um array unidimensional rotulado, capaz de armazenar
dados de qualquer tipo (inteiros, strings, floats, objetos Python, etc.).
import pandas as pd
import numpy as np

# Series a partir de uma lista

s1 = pd . Series ([10 , 20 , 30 , 40 , 50])
print ( s1 )

# Series com r ó tulos personalizados

s2 = pd . Series (
[100 , 200 , 300] ,
index =[ ’a ’ , ’b ’ , ’c ’] ,
name = ’ valores ’
)
print ( s2 )
# a 100
# b 200
# c 300

2.1.1 Acessando Elementos

# Por posi ç ã o ( iloc )

s = pd . Series ([10 , 20 , 30 , 40])

7
s . iloc [0] # 10
s . iloc [ -1] # 40

# Por r ó tulo ( loc )

s = pd . Series ([10 , 20 , 30] , index =[ ’a ’ , ’b ’ , ’c ’ ])
s . loc [ ’a ’] # 10

# Por condi ç ã o
s [ s > 15] # Series com valores > 15

2.2 DataFrames
Um DataFrame é uma estrutura de dados bidimensional rotulada, com
colunas de tipos potencialmente diferentes. Pode ser visto como uma
planilha, uma tabela SQL ou um dicionário de Series.

õ Anatomia de um DataFrame

• Índice (Index): Rótulos das linhas

• Colunas: Cada coluna é uma Series

• Dados: Array NumPy subjacente

• Shape: Tupla (linhas, colunas)

2.3 Criando DataFrames

import pandas as pd

# A partir de um dicion á rio

df = pd . DataFrame ({
’ Produto ’: [ ’ Notebook ’ , ’ Mouse ’ , ’ Teclado ’] ,
’ Pre ç o ’: [3500 , 80 , 150] ,
’ Estoque ’: [15 , 50 , 30]
})

# A partir de uma lista de dicion á rios

df = pd . DataFrame ([
{ ’ Produto ’: ’ Notebook ’ , ’ Pre ç o ’: 3500} ,

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

 { ’ Produto ’: ’ Mouse ’ , ’ Pre ç o ’: 80}
])

# A partir de um NumPy array

import numpy as np
df = pd . DataFrame (
np . random . randn (4 , 3) ,
columns =[ ’A ’ , ’B ’ , ’C ’]
)

# A partir de um CSV
df = pd . read_csv ( ’ dados . csv ’)

2.4 Atributos Importantes

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

# Forma ( linhas , colunas )

df . shape # (1000 , 5)

# Tipos de dados
df . dtypes # Mostra tipo de cada coluna

# Primeiras / ú ltimas linhas

df . head (5) # 5 primeiras linhas
df . tail (3) # 3 ú ltimas linhas

# Informa ç õ es gerais
df . info () # Resumo do DataFrame

# Estat í sticas descritivas

df . describe () # M é dia , desvio , min , max , quartis

# Colunas e í ndice
df . columns # Index ([ ’ Produto ’, ’ Pre ç o ’, ...])
df . index # RangeIndex ( start =0 , stop =1000)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

 . [Link]() é essencial para entender seu DataFrame. Execute
sempre ao iniciar uma análise para verificar tipos de dados, valores
ausentes e uso de memória.

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 3

Leitura e Escrita de Dados

3.1 Lendo Dados

O Pandas suporta uma variedade de formatos de entrada:
import pandas as pd

# CSV
df = pd . read_csv ( ’ dados . csv ’)
df = pd . read_csv ( ’ dados . csv ’ , sep = ’; ’ , encoding = ’ latin
-1 ’)

# Excel
df = pd . read_excel ( ’ dados . xlsx ’)
df = pd . read_excel ( ’ dados . xlsx ’ , sheet_name = ’ Vendas ’)

# JSON
df = pd . read_json ( ’ dados . json ’)

# SQL ( requer sqlalchemy )

from sqlalchemy import create_engine
engine = create_engine ( ’ sqlite :/// banco . db ’)
df = pd . read_sql ( ’ SELECT ␣ * ␣ FROM ␣ clientes ’ , engine )

# HTML
df = pd . read_html ( ’ tabela . html ’) [0] # Primeira tabela

# Parquet ( grande performance )

df = pd . read_parquet ( ’ dados . parquet ’)

11
3.2 Parâmetros Importantes

pd . read_csv (
’ dados . csv ’ ,
sep = ’ , ’ , # Delimitador
encoding = ’utf -8 ’ , # Codifica ç ã o
usecols =[ ’A ’ , ’B ’] , # Selecionar colunas
dtype ={ ’ id ’: str } , # Tipos personalizados
parse_dates =[ ’ data ’] , # Converter para datetime
na_values =[ ’N / A ’ , ’ ’] , # Valores para NaN
nrows =1000 , # Ler apenas N linhas
skiprows =[1 , 3] , # Pular linhas
index_col = ’ id ’ # Definir í ndice
)

3.3 Escrevendo Dados

# CSV
df . to_csv ( ’ saida . csv ’ , index = False , encoding = ’utf -8 ’)

# Excel
df . to_excel ( ’ saida . xlsx ’ , sheet_name = ’ Dados ’ , index =
False )

# JSON
df . to_json ( ’ saida . json ’ , orient = ’ records ’ , force_ascii =
False )

# Parquet
df . to_parquet ( ’ saida . parquet ’ , index = False )

# SQL
df . to_sql ( ’ tabela ’ , engine , if_exists = ’ replace ’ , index =
False )

# ClipBoard ( copiar para planilha )

df . to_clipboard ()

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

  Para arquivos grandes, use parquet em vez de CSV. Parquet é
compacto, rápido e preserva tipos de dados. Para CSVs gigantes,
use chunksize para processar em pedaços.

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 4

Seleção e Indexação

4.1 Selecionar Colunas

import pandas as pd

df = pd . DataFrame ({
’ Nome ’: [ ’ Ana ’ , ’ Bruno ’ , ’ Carlos ’] ,
’ Idade ’: [25 , 30 , 35] ,
’ Sal á rio ’: [5000 , 7000 , 9000]
})

# Nota ç ã o de colchetes ( retorna Series )

df [ ’ Nome ’]

# Atributo ( n ã o funciona com nomes de espa ç os )

df . Nome

# Selecionar m ú ltiplas colunas ( retorna DataFrame )

df [[ ’ Nome ’ , ’ Sal á rio ’ ]]

14
4.2 Seleção por Loc e Iloc
ò loc vs iloc

• .loc[] - Seleciona por rótulos (labels)

• .iloc[] - Seleciona por posições (índices inteiros)

# loc - por r ó tulos

df . loc [0] # Primeira linha
df . loc [0:2] # Linhas 0 , 1 e 2 (
inclusive !)
df . loc [0:1 , ’ Nome ’: ’ Sal á rio ’] # Linhas 0 -1 , colunas Nome
- Sal á rio
df . loc [ df [ ’ Idade ’] > 28] # Condi ç ã o

# iloc - por posi ç õ es

df . iloc [0] # Primeira linha
df . iloc [0:2] # Linhas 0 e 1 ( exclusive
!)
df . iloc [0:2 , 0:2] # 2 linhas , 2 primeiras
colunas
df . iloc [[0 , 2]] # Linhas espec í ficas

. Com loc, o final é inclusive. Com iloc, o final é exclusive.

Isso pode causar bugs sutis se não prestares atenção!

4.3 Seleção Condicional

# Condi ç ã o simples
df [ df [ ’ Idade ’] > 30]

# M ú ltiplas condi ç õ es ( AND )

df [( df [ ’ Idade ’] > 25) & ( df [ ’ Sal á rio ’] > 6000) ]

# M ú ltiplas condi ç õ es ( OR )
df [( df [ ’ Idade ’] < 28) | ( df [ ’ Sal á rio ’] > 8000) ]

# Usando isin

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

df [ df [ ’ Nome ’ ]. isin ([ ’ Ana ’ , ’ Carlos ’ ]) ]

# Usando query ( mais leg í vel )

df . query ( ’ Idade ␣ >␣ 25 ␣ and ␣ Sal á rio ␣ >␣ 6000 ’)

# between ( intervalo )
df [ df [ ’ Idade ’ ]. between (25 , 35) ]

# String operations
df [ df [ ’ Nome ’ ]. str . startswith ( ’A ’) ]

4.4 Atribuição de Valores

# Atribuir um valor
df . loc [0 , ’ Sal á rio ’] = 5500

# Atribuir por condi ç ã o

df . loc [ df [ ’ Idade ’] > 30 , ’ Sal á rio ’] *= 1.1 # Aumento
de 10%

# Criar nova coluna

df [ ’ Imposto ’] = df [ ’ Sal á rio ’] * 0.27

# Deletar coluna
df . drop ( ’ Imposto ’ , axis =1 , inplace = True )

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 5

Tratamento de Dados
Ausentes

5.1 Identificando Valores Ausentes

import pandas as pd
import numpy as np

df = pd . DataFrame ({
’A ’: [1 , 2 , np . nan , 4] ,
’B ’: [ np . nan , 2 , 3 , 4] ,
’C ’: [ ’x ’ , None , ’z ’ , ’w ’]
})

# Verificar se h á NaN
df . isnull () # DataFrame booleano
df . isnull () . sum () # Contagem por coluna
df . isnull () . sum () . sum () # Total de NaN

# Porcentagem de aus ê ncia

( df . isnull () . sum () / len ( df ) ) * 100

# Linhas com qualquer NaN

df [ df . isnull () . any ( axis =1) ]

# Linhas com todos NaN

df [ df . isnull () . all ( axis =1) ]

17
5.2 Removendo Valores Ausentes

# Remover linhas com qualquer NaN

df . dropna ()

# Remover apenas linhas onde TODOS s ã o NaN

df . dropna ( how = ’ all ’)

# Remover colunas com NaN

df . dropna ( axis =1)

# Remover com base em threshold

df . dropna ( thresh =2) # Manter linhas com pelo menos 2 n
ão - NaN

# Especificar colunas
df . dropna ( subset =[ ’A ’ , ’B ’ ])

5.3 Preenchendo Valores Ausentes

# Valor fixo
df . fillna (0)

# M é dia , mediana , moda

df [ ’A ’ ]. fillna ( df [ ’A ’ ]. mean () )
df [ ’A ’ ]. fillna ( df [ ’A ’ ]. median () )
df [ ’A ’ ]. fillna ( df [ ’A ’ ]. mode () [0])

# Preencher com valor anterior / siguiente

df . fillna ( method = ’ ffill ’) # Forward fill
df . fillna ( method = ’ bfill ’) # Backward fill

# interpola ç ã o
df [ ’A ’ ]. interpolate ()

# Preencher diferentes valores por coluna

df . fillna ({
’A ’: df [ ’A ’ ]. mean () ,
’B ’: 0 ,
’C ’: ’ Desconhecido ’
})

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

  Quando usar cada método?

• Média/Mediana: Dados numéricos sem outliers extremos

• Moda: Dados categóricos

• Forward fill: Séries temporais com dados consecutivos

• Remover: Quando a quantidade de NaN é pequena

• Interpolação: Dados com tendência temporal

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 6

Transformação de Dados

6.1 Métodos Apply e Map

import pandas as pd

df = pd . DataFrame ({
’ Produto ’: [ ’ notebook ’ , ’ mouse ’ , ’ teclado ’] ,
’ Pre ç o ’: [3500 , 80 , 150]
})

# apply - aplicar fun ç ã o em coluna

df [ ’ Pre ç o ␣ Formatado ’] = df [ ’ Pre ç o ’ ]. apply (
lambda x : f ’ R$ ␣ { x : ,.2 f } ’
)

# apply em DataFrame inteiro

df [ ’ Pre ç o ␣ ( USD ) ’] = df . apply (
lambda row : row [ ’ Pre ç o ’] / 5.0 , axis =1
)

# map - mapear valores ( Series )

df [ ’ Categoria ’] = df [ ’ Produto ’ ]. map ({
’ notebook ’: ’ Inform á tica ’ ,
’ mouse ’: ’ Perif é ricos ’ ,
’ teclado ’: ’ Perif é ricos ’
})

# replace - substituir valores

df [ ’ Produto ’] = df [ ’ Produto ’ ]. replace (

20
 ’ notebook ’ , ’ Notebook ’
)

6.2 Renomear e Reordenar

# Renomear colunas
df . rename ( columns ={
’ Produto ’: ’ produto ’ ,
’ Pre ç o ’: ’ pre ç o ’
} , inplace = True )

# Reordenar colunas
df = df [[ ’ produto ’ , ’ pre ç o ’ , ’ Categoria ’ ]]

# Reordenar por valores

df . sort_values ( ’ pre ç o ’ , ascending = False )

# Reordenar por í ndice

df . sort_index ()

6.3 Operações Comuns

# Tipos de dados
df [ ’ pre ç o ’] = df [ ’ pre ç o ’ ]. astype ( float )
df [ ’ data ’] = pd . to_datetime ( df [ ’ data ’ ])

# Duplicatas
df . duplicated () # Identificar duplicatas
df . drop_duplicates () # Remover duplicatas
df . drop_duplicates ( subset =[ ’ produto ’ ]) # Baseado em
colunas

# Strings
df [ ’ produto ’] = df [ ’ produto ’ ]. str . upper ()
df [ ’ produto ’] = df [ ’ produto ’ ]. str . strip ()
df [ ’ produto ’] = df [ ’ produto ’ ]. str . contains ( ’ note ’)

# Num é ricos
df [ ’ pre ç o ’ ]. round (2)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

df [ ’ pre ç o ’ ]. clip ( lower =0 , upper =10000) # Limitar
valores

6.4 Pivoteamento

# pivot_table - resumo estat í stico

df . pivot_table (
values = ’ vendas ’ ,
index = ’ produto ’ ,
columns = ’ regi ã o ’ ,
aggfunc = ’ sum ’ ,
fill_value =0
)

# pivot - reformatar dados

df . pivot (
index = ’ data ’ ,
columns = ’ produto ’ ,
values = ’ vendas ’
)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 7

Agrupamento e Agregação

7.1 GroupBy
O padrão split-apply-combine é fundamental no Pandas:
import pandas as pd

vendas = pd . DataFrame ({
’ Vendedor ’: [ ’ Ana ’ , ’ Ana ’ , ’ Bruno ’ , ’ Bruno ’ , ’
Carlos ’] ,
’ Produto ’: [ ’A ’ , ’B ’ , ’A ’ , ’B ’ , ’A ’] ,
’ Vendas ’: [100 , 150 , 200 , 120 , 180] ,
’ Regi ã o ’: [ ’ SP ’ , ’ SP ’ , ’ RJ ’ , ’ RJ ’ , ’ MG ’]
})

# Agrega ç ã o simples
vendas . groupby ( ’ Vendedor ’) [ ’ Vendas ’ ]. sum ()

# M ú ltiplas agrega ç õ es
vendas . groupby ( ’ Vendedor ’) [ ’ Vendas ’ ]. agg (
[ ’ sum ’ , ’ mean ’ , ’ max ’]
)

# GroupBy em m ú ltiplas colunas

vendas . groupby ([ ’ Vendedor ’ , ’ Produto ’ ]) [ ’ Vendas ’ ]. sum ()

# GroupBy com agg personalizado

vendas . groupby ( ’ Vendedor ’) . agg ({
’ Vendas ’: [ ’ sum ’ , ’ mean ’] ,
’ Produto ’: ’ count ’

23
})

7.2 Transform e Filter

# transform - manter mesma forma do DataFrame

vendas [ ’M é dia_Vendedor ’] = vendas . groupby ( ’ Vendedor ’) [
’ Vendas ’
]. transform ( ’ mean ’)

# filter - filtrar grupos

# Apenas vendedores com mais de 1 registro
vendas . groupby ( ’ Vendedor ’) . filter (
lambda x : len ( x ) > 1
)

# Apenas grupos onde a m é dia > 150

vendas . groupby ( ’ Vendedor ’) . filter (
lambda x : x [ ’ Vendas ’ ]. mean () > 150
)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

7.3 Agregações Comuns
O Funções de agregação

• sum() - Soma

• mean() - Média

• median() - Mediana

• std() - Desvio padrão

• min() / max() - Mínimo/Máximo

• count() - Contagem

• first() / last() - Primeiro/Último

• var() - Variância

• sem() - Erro padrão da média

7.4 Tabelas de Frequência

# value_counts - contagem de valores

vendas [ ’ Produto ’ ]. value_counts ()

# crosstab - tabela cruzada

pd . crosstab (
vendas [ ’ Vendedor ’] ,
vendas [ ’ Produto ’] ,
values = vendas [ ’ Vendas ’] ,
aggfunc = ’ sum ’ ,
margins = True # Totais
)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 8

Fusão e Concatenação

8.1 Merge (Junção de DataFrames)

import pandas as pd

clientes = pd . DataFrame ({
’ id ’: [1 , 2 , 3 , 4] ,
’ nome ’: [ ’ Ana ’ , ’ Bruno ’ , ’ Carlos ’ , ’ Diana ’]
})

vendas = pd . DataFrame ({
’ cliente_id ’: [1 , 2 , 2 , 3] ,
’ produto ’: [ ’A ’ , ’B ’ , ’A ’ , ’C ’] ,
’ valor ’: [100 , 200 , 150 , 300]
})

# Inner join ( padr ã o ) - apenas correspond ê ncias

pd . merge ( clientes , vendas ,
left_on = ’ id ’ , right_on = ’ cliente_id ’)

# Left join - todos da esquerda

pd . merge ( clientes , vendas ,
left_on = ’ id ’ , right_on = ’ cliente_id ’ , how = ’ left
’)

# Right join - todos da direita

pd . merge ( clientes , vendas ,
left_on = ’ id ’ , right_on = ’ cliente_id ’ , how = ’
right ’)

26
# Outer join - todos de ambos
pd . merge ( clientes , vendas ,
left_on = ’ id ’ , right_on = ’ cliente_id ’ , how = ’
outer ’)

# Merge por í ndice

pd . merge ( clientes , vendas ,
left_index = True , right_index = True )

8.2 Concatenação

# Concatena ç ã o vertical ( empilhar )

df1 = pd . DataFrame ({ ’A ’: [1 , 2] , ’B ’: [3 , 4]})
df2 = pd . DataFrame ({ ’A ’: [5 , 6] , ’B ’: [7 , 8]})

pd . concat ([ df1 , df2 ] , ignore_index = True )

# Concatena ç ã o horizontal ( lado a lado )

pd . concat ([ df1 , df2 ] , axis =1)

# Concatenar com chaves

pd . concat ([ df1 , df2 ] , keys =[ ’ primeiro ’ , ’ segundo ’ ])

8.3 Join

# join é conveniente para concatenar por í ndice

clientes . set_index ( ’ id ’) . join (
vendas . set_index ( ’ cliente_id ’) ,
how = ’ inner ’
)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

  Qual usar?

• merge: Mais flexível, funciona por colunas ou índice

• join: Conveniente para junções por índice

• concat: Para empilhar ou colocar DataFrames lado a lado

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 9

Visualização de Dados

9.1 Introdução
O Pandas tem integração nativa com Matplotlib, permitindo gráficos rá-
pidos diretamente dos DataFrames.
import pandas as pd
import matplotlib . pyplot as plt

# Estilo recomendado
plt . style . use ( ’ seaborn - v0_8 ’)

9.2 Gráficos de Linha

vendas_mensais = pd . DataFrame ({
’M ê s ’: [ ’ Jan ’ , ’ Fev ’ , ’ Mar ’ , ’ Abr ’ , ’ Mai ’ , ’ Jun ’] ,
’ Produto_A ’: [150 , 180 , 200 , 170 , 220 , 250] ,
’ Produto_B ’: [100 , 120 , 140 , 130 , 160 , 180]
})
vendas_mensais . set_index ( ’M ê s ’ , inplace = True )

vendas_mensais . plot (
kind = ’ line ’ ,
figsize =(10 , 6) ,
title = ’ Vendas ␣ Mensais ␣ por ␣ Produto ’ ,
marker = ’o ’
)

29
plt . ylabel ( ’ Vendas ␣ ( unidades ) ’)
plt . grid ( True , alpha =0.3)
plt . tight_layout ()
plt . savefig ( ’ vendas_mensais . png ’ , dpi =150)

9.3 Gráficos de Barra

vendas_mensais . sum () . plot (

kind = ’ bar ’ ,
figsize =(8 , 5) ,
color =[ ’ #306998 ’ , ’# FFD43B ’] ,
edgecolor = ’ black ’
)
plt . title ( ’ Total ␣ de ␣ Vendas ␣ por ␣ Produto ’)
plt . ylabel ( ’ Total ’)
plt . xticks ( rotation =0)
plt . tight_layout ()

9.4 Gráficos de Pizza

vendas_mensais . sum () . plot (

kind = ’ pie ’ ,
figsize =(8 , 8) ,
autopct = ’ %1.1 f %% ’ ,
colors =[ ’ #306998 ’ , ’# FFD43B ’] ,
startangle =90
)
plt . title ( ’ Participa ç ã o ␣ nas ␣ Vendas ’)
plt . ylabel ( ’ ’)

9.5 Gráfico de Dispersão

df = pd . DataFrame ({
’ Pre ç o ’: [10 , 20 , 30 , 40 , 50 , 60 , 70 , 80] ,
’ Vendas ’: [100 , 90 , 80 , 70 , 60 , 50 , 40 , 30] ,
’ Categoria ’: [ ’A ’ ]*4 + [ ’B ’ ]*4
})

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

df . plot . scatter (
x = ’ Pre ç o ’ ,
y = ’ Vendas ’ ,
c = ’ Categoria ’ ,
figsize =(10 , 6) ,
colormap = ’ viridis ’ ,
s =100 ,
alpha =0.7
)
plt . title ( ’ Rela ç ã o ␣ Pre ç o ␣ vs ␣ Vendas ’)

9.6 Histograma

import numpy as np
dados = pd . DataFrame ({
’ Idade ’: np . random . normal (35 , 10 , 1000)
})

dados [ ’ Idade ’ ]. plot (

kind = ’ hist ’ ,
bins =30 ,
figsize =(10 , 6) ,
color = ’ #306998 ’ ,
edgecolor = ’ black ’ ,
alpha =0.7
)
plt . title ( ’ Distribui ç ã o ␣ de ␣ Idades ’)
plt . xlabel ( ’ Idade ’)
plt . ylabel ( ’ Frequ ê ncia ’)

9.7 Gráficos com Subplots

fig , axes = plt . subplots (2 , 2 , figsize =(12 , 10) )

vendas_mensais [ ’ Produto_A ’ ]. plot ( ax = axes [0 , 0] , kind = ’

line ’)
axes [0 , 0]. set_title ( ’ Produto ␣ A ’)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

vendas_mensais [ ’ Produto_B ’ ]. plot ( ax = axes [0 , 1] , kind = ’
bar ’)
axes [0 , 1]. set_title ( ’ Produto ␣ B ’)

vendas_mensais . sum () . plot ( ax = axes [1 , 0] , kind = ’ pie ’)

axes [1 , 0]. set_title ( ’ Total ’)

vendas_mensais . plot ( ax = axes [1 , 1] , kind = ’ area ’)

axes [1 , 1]. set_title ( ’Á rea ’)

plt . tight_layout ()
plt . savefig ( ’ dashboard . png ’ , dpi =150)

 Dicas de visualização:

• Sempre use plt.tight_layout() para evitar sobreposição

• Defina figsize antes de cada gráfico

• Salve com dpi=150 para boa resolução

• Use cores consistentes do tema do Pandas

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 10

Exercícios Práticos

10.1 Exercício 1: Análise de Vendas

import pandas as pd
import numpy as np

# Gerar dados de vendas simulados

np . random . seed (42)
n = 1000

vendas = pd . DataFrame ({
’ Data ’: pd . date_range (
’ 2024 -01 -01 ’ , periods =n , freq = ’D ’
),
’ Produto ’: np . random . choice (
[ ’ Notebook ’ , ’ Mouse ’ , ’ Teclado ’ , ’ Monitor ’] , n
),
’ Regi ã o ’: np . random . choice ([ ’ SP ’ , ’ RJ ’ , ’ MG ’ , ’ RS ’
], n),
’ Quantidade ’: np . random . randint (1 , 50 , n ) ,
’ Pre ç o_Unit á rio ’: np . random . uniform (50 , 3500 , n ) .
round (2)
})

# Calcular total
vendas [ ’ Total ’] = vendas [ ’ Quantidade ’] * vendas [ ’ Pre ç
o_Unit á rio ’]

# 1. Top 5 produtos por receita

33
receita_produto = vendas . groupby ( ’ Produto ’) [ ’ Total ’ ].
sum ()
print ( " Receita ␣ por ␣ produto : " )
print ( receita_produto . sort_values ( ascending = False ) . head
() )

# 2. Vendas por regi ã o

vendas_regi ã o = vendas . groupby ( ’ Regi ã o ’) . agg ({
’ Total ’: [ ’ sum ’ , ’ mean ’] ,
’ Quantidade ’: ’ sum ’
})
print ( " \ nVendas ␣ por ␣ regi ã o : " )
print ( vendas_regi ã o )

# 3. Evolu ç ã o mensal
vendas [ ’M ê s ’] = vendas [ ’ Data ’ ]. dt . to_period ( ’M ’)
evolu ç ã o = vendas . groupby ( ’M ê s ’) [ ’ Total ’ ]. sum ()
print ( " \ nEvolu ç ã o ␣ mensal : " )
print ( evolu ç ã o )

10.2 Exercício 2: Limpeza de Dados

import pandas as pd
import numpy as np

# Dados com problemas

dados = pd . DataFrame ({
’ Nome ’: [ ’ Ana ’ , ’ Bruno ’ , ’ Carlos ’ , None , ’ Eva ’] ,
’ Idade ’: [25 , np . nan , 35 , 28 , -5] ,
’ Email ’: [
’ ana@email . com ’ , ’ bruno@email ’ ,
’x ’ , ’ diana@ ’ , ’ eva@email . com ’
],
’ Sal á rio ’: [5000 , 7000 , np . nan , 4500 , 8000]
})

# 1. Identificar problemas
print ( " Valores ␣ ausentes : " )
print ( dados . isnull () . sum () )

print ( " \ nIdades ␣ negativas : " )

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

print ( dados [ dados [ ’ Idade ’] < 0])

# 2. Limpar dados
# Remover linhas com Nome ausente
dados = dados . dropna ( subset =[ ’ Nome ’ ])

# Corrigir idade negativa

dados . loc [ dados [ ’ Idade ’] < 0 , ’ Idade ’] = np . nan

# Preencher idade com mediana

dados [ ’ Idade ’] = dados [ ’ Idade ’ ]. fillna (
dados [ ’ Idade ’ ]. median ()
)

# Preencher sal á rio com m é dia

dados [ ’ Sal á rio ’] = dados [ ’ Sal á rio ’ ]. fillna (
dados [ ’ Sal á rio ’ ]. mean ()
)

# Validar emails
dados [ ’ Email_V á lido ’] = dados [ ’ Email ’ ]. str . contains (
’@ .*\\. ’ , regex = True
)

print ( " \ nDados ␣ limpos : " )

print ( dados )

10.3 Exercício 3: Relatório Completo

import pandas as pd
import numpy as np
import matplotlib . pyplot as plt

# Simulando dados
np . random . seed (42)
df = pd . DataFrame ({
’ Data ’: pd . date_range ( ’ 2024 -01 -01 ’ , periods =365 ,
freq = ’D ’) ,
’ Vendas ’: np . random . poisson (100 , 365) ,
’ Receita ’: np . random . uniform (1000 , 5000 , 365)
})

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

# An á lise
print ( " === ␣ RELAT Ó RIO ␣ DE ␣ VENDAS ␣ 2024 ␣ === " )
print ( f " Total ␣ de ␣ vendas : ␣ { df [ ’ Vendas ’]. sum () } " )
print ( f " Receita ␣ total : ␣ R$ ␣ { df [ ’ Receita ’]. sum () : ,.2 f } " )
print ( f " M é dia ␣ di á ria : ␣ { df [ ’ Vendas ’]. mean () :.0 f } ␣ vendas "
)

# Melhor pior dia

melhor = df . loc [ df [ ’ Receita ’ ]. idxmax () ]
pior = df . loc [ df [ ’ Receita ’ ]. idxmin () ]
print ( f " \ nMelhor ␣ dia : ␣ "
f " { melhor [ ’ Data ’]. strftime ( ’% d /% m /% Y ’) } ␣ "
f " -␣ R$ ␣ { melhor [ ’ Receita ’]: ,.2 f } " )
print ( f " Pior ␣ dia : ␣ "
f " { pior [ ’ Data ’]. strftime ( ’% d /% m /% Y ’) } ␣ "
f " -␣ R$ ␣ { pior [ ’ Receita ’]: ,.2 f } " )

# Gr á fico
fig , ax1 = plt . subplots ( figsize =(12 , 6) )
ax1 . bar ( df [ ’ Data ’] , df [ ’ Vendas ’] ,
color = ’ #306998 ’ , alpha =0.7)
ax1 . set_ylabel ( ’ Vendas ’ , color = ’ #306998 ’)

ax2 = ax1 . twinx ()

ax2 . plot ( df [ ’ Data ’] , df [ ’ Receita ’] ,
color = ’# FFD43B ’ , linewidth =2)
ax2 . set_ylabel ( ’ Receita ␣ ( R$ ) ’ , color = ’# FFD43B ’)

plt . title ( ’ Relat ó rio ␣ de ␣ Vendas ␣ 2024 ’)

plt . tight_layout ()
plt . savefig ( ’ relatorio_2024 . png ’ , dpi =150)

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 11

Dicas e Boas Práticas

11.1 Performance
W Dicas de performance

• Evite loops for – use apply, map, ou operações vetorizadas

• Use eval() e query() para expressões complexas

• Para arquivos grandes, use dtype para especificar tipos

• Considere pyarrow como backend para melhor performance

• Use chunksize para CSVs que não cabem na memória

# LENTO - evite !
for i , row in df . iterrows () :
df . loc [i , ’ total ’] = row [ ’ qtd ’] * row [ ’ pre ç o ’]

# R Á PIDO - vetorizado !
df [ ’ total ’] = df [ ’ qtd ’] * df [ ’ pre ç o ’]

# R Á PIDO - usando eval

df . eval ( ’ total ␣ = ␣ qtd ␣ * ␣ pre ç o ’ , inplace = True )

11.2 Memória

37
# Verificar uso de mem ó ria
df . info ( memory_usage = ’ deep ’)

# Otimizar tipos de dados

df [ ’ id ’] = df [ ’ id ’ ]. astype ( ’ int32 ’) # Em vez de int64
df [ ’ categoria ’] = df [ ’ categoria ’ ]. astype ( ’ category ’)

# Reduzir float64 para float32

df [ ’ pre ç o ’] = df [ ’ pre ç o ’ ]. astype ( ’ float32 ’)

11.3 Erros Comuns

. Cuidado com esses erros:

• SettingWithCopyWarning: Use .loc[] para atribuição

• KeyError: Verifique se a coluna/rótulo existe

• ValueError: Dimensões incompatíveis em operações

• TypeError: Operação incompatível com o tipo de dado

# ERRADO - pode gerar warning

df [ df [ ’ idade ’] > 30][ ’ novo ’] = ’ adulto ’

# CORRETO - usar loc

df . loc [ df [ ’ idade ’] > 30 , ’ novo ’] = ’ adulto ’

# OU - usar uma c ó pia

df_filtrado = df [ df [ ’ idade ’] > 30]. copy ()
df_filtrado [ ’ novo ’] = ’ adulto ’

11.4 Convenções de Código

# 1. Importar sempre no in í cio do notebook

import pandas as pd
import numpy as np

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

# 2. Usar o alias padr ã o pd

# 3. Encadeamento de opera ç õ es ( method chaining )

resultado = (
df
. query ( ’ vendas ␣ >␣ 100 ’)
. groupby ( ’ regi ã o ’)
. agg ({ ’ vendas ’: ’ sum ’ , ’ receita ’: ’ mean ’ })
. sort_values ( ’ receita ’ , ascending = False )
)

# 4. Nomear colunas criadas

df [ ’ receita_total ’] = df [ ’ qtd ’] * df [ ’ pre ç o ’]

# 5. Usar inplace = False ( padr ã o ) para manter

imutabilidade

# 6. Documentar an á lises com markdown em notebooks

⋆ Resumo das ferramentas:

• Leitura: read_csv, read_excel, read_parquet

• Exploração: head(), info(), describe(), shape

• Seleção: loc, iloc, query

• Limpeza: dropna, fillna, drop_duplicates

• Transformação: apply, map, groupby

• Junção: merge, concat, join

• Visualização: plot(), integrado com Matplotlib

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣

Capítulo 12

Referências e Recursos

12.1 Documentação Oficial

[ Links úteis
• Documentação oficial do Pandas

• Getting Started

• User Guide

• API Reference

12.2 Livros Recomendados

• Python for Data Analysis – Wes McKinney (criador do Pandas)
• Pandas for Everyone – Daniel Y. Chen
• Effective Pandas – Matt Harrison

12.3 Próximos Passos

Após dominar Pandas, considere explorar:

• NumPy: Operações numéricas de baixo nível

• Matplotlib/Seaborn: Visualizações avançadas

40
• Scikit-learn: Machine Learning

• Polars: Alternativa de alta performance ao Pandas

• Dask: Parallel computing com Pandas-like API

♣ Prof. Elizeu ⋆ @[Link] ⋆ [Link] ⋆ Sofá Gospel ♣