Linguagem_Prog_Aplicada-03

Prévia do material em texto

Linguagem de 
Programação Aplicada
Material Teórico
Responsável pelo Conteúdo:
Prof. Dr. Alcides Teixeira Barboza Junior
Revisão Textual:
Prof. Me. Luciano Vieira Francisco
Bibliotecas para Manipulação de Dados
• Introdução;
• Pacote Numpy;
• Pacote Pandas;
• Pacote Matplotlib.
• Aprender como usar as bibliotecas do Python;
• Praticar o uso da biblioteca de manipulação de matrizes e vetores;
• Praticar o uso da biblioteca de manipulação de planilhas;
• Conhecer os princípios básicos da biblioteca Matplotlib.
OBJETIVOS DE APRENDIZADO
Bibliotecas para Manipulação de Dados
Orientações de estudo
Para que o conteúdo desta Disciplina seja bem 
aproveitado e haja maior aplicabilidade na sua 
formação acadêmica e atuação profissional, siga 
algumas recomendações básicas: 
Assim:
Organize seus estudos de maneira que passem a fazer parte 
da sua rotina. Por exemplo, você poderá determinar um dia e 
horário fixos como seu “momento do estudo”;
Procure se alimentar e se hidratar quando for estudar; lembre-se de que uma 
alimentação saudável pode proporcionar melhor aproveitamento do estudo;
No material de cada Unidade, há leituras indicadas e, entre elas, artigos científicos, livros, vídeos 
e sites para aprofundar os conhecimentos adquiridos ao longo da Unidade. Além disso, você tam-
bém encontrará sugestões de conteúdo extra no item Material Complementar, que ampliarão sua 
interpretação e auxiliarão no pleno entendimento dos temas abordados;
Após o contato com o conteúdo proposto, participe dos debates mediados em fóruns de discus-
são, pois irão auxiliar a verificar o quanto você absorveu de conhecimento, além de propiciar o 
contato com seus colegas e tutores, o que se apresenta como rico espaço de troca de ideias e 
de aprendizagem.
Organize seus estudos de maneira que passem a fazer parte 
Mantenha o foco! 
Evite se distrair com 
as redes sociais.
Mantenha o foco! 
Evite se distrair com 
as redes sociais.
Determine um 
horário fixo 
para estudar.
Aproveite as 
indicações 
de Material 
Complementar.
Procure se alimentar e se hidratar quando for estudar; lembre-se de que uma 
Não se esqueça 
de se alimentar 
e de se manter 
hidratado.
Aproveite as 
Conserve seu 
material e local de 
estudos sempre 
organizados.
Procure manter 
contato com seus 
colegas e tutores 
para trocar ideias! 
Isso amplia a 
aprendizagem.
Seja original! 
Nunca plagie 
trabalhos.
UNIDADE Bibliotecas para Manipulação de Dados
Introdução
A análise de dados necessita de várias passagens para manipulação, criação e/
ou transformação dos dados que se deseja extrair informações. Você já conheceu 
os conceitos básicos do Python e aprendeu como trabalhar com orientação a obje-
tos, agora aprimoraremos ainda mais o seu leque de ferramentas. 
Preparar os dados que serão analisados é um dos trabalhos em que o analista 
de dados é mais solicitado, afinal, estatísticas e relatórios só podem ser feitos se os 
dados forem úteis para essa tarefa. 
Trabalhar com os dados de forma direta, ou seja, sem usar nenhum auxílio de 
pacotes de código pronto é possível, porém, isso demanda tempo e, em muitos ca-
sos, boa parte do que se precisa fazer já foi implementado em pacotes específicos 
da linguagem.
Nesse sentido, já tínhamos visto o PyData Stack, que apresenta diversos pacotes 
para trabalhar com dados, estatísticas, planilhas e gráficos, de modo que agora es-
tudaremos os principais pacotes que nos darão as bases necessárias para manipular 
e preparar os dados que serão analisados e posteriormente exibidos em diferentes 
tipos de gráficos – os principais pacotes são o Numpy, Pandas e Matplotlib.
Então vamos lá!
Pacote Numpy
Numerical Python (Numpy) é um pacote de computação matemática, científica, 
de engenharia e de ciência de dados no Python. Fornece a base necessária para 
muitas aplicações de inteligência artificial e, principalmente, para análise de dados.
Utilizando esse pacote teremos suporte para arrays e matrizes de forma simples, 
além de termos também uma vasta quantidade de funções matemáticas para mani-
pularmos os objetos criados.
Com o Numpy podemos, por exemplo, manipular arrays multidimensionais, 
utilizar as ferramentas que traz para trabalharmos com a leitura de datasets que 
possuem como base arrays, além de realizarmos operações de álgebra linear.
Quando mencionamos dados numéricos, Numpy é o pacote mais eficiente para 
manipular e armazenar esses dados se comparado a outros pacotes do Python.
Agora você se pergunta: mas o que são arrays? Em uma resposta direta, pode-
mos definir como uma estrutura de dados em programação, estes que representam 
vetores ou, em outras palavras, uma estrutura que representa um conjunto de dados.
Formalmente, um array Numpy é definido como um conjunto de dados que 
possui o mesmo tipo de dado e são indexados por um número inteiro positivo, 
8
9
iniciando por 0. Neste momento você deve tê-lo associado à ideia de listas – e você 
está certo(a). Entender esses conceitos com o Numpy ajudará na compreensão dos 
demais pacotes analisados nesta Unidade.
O objeto padrão do Numpy é o ndarray, oferecendo uma variedade de funções, 
sendo as principais: 
• ndim: retorna o número de dimensões do objeto;
• shape: retorna a quantidade de linhas e colunas do objeto;
• size: retorna a quantidade de elementos do objeto; equivale ao produto entre 
os valores retornados pelo shape.
A primeira coisa que você precisa saber é que com o Anaconda, o pacote Numpy
já vem instalado, necessitando apenas que você faça a importação do pacote em 
seu código.
Para importarmos o pacote, utilizamos no início de nosso script o comando 
import numpy as np. Neste comando, importamos o pacote e utilizamos as suas 
ferramentas por meio do alias np; ressaltamos que este nome poderia ser outro, mas 
por padrão se adota np – sigla para Numpy.
Se você quiser ver qual é a sua versão do Numpy instalado, digite, no Jupyter, 
após a importação do pacote, np.__version__.
Você também pode obter um help – resumido – sobre array na própria ferramenta 
digitando help(np.array) – veja o exemplo do resultado deste comando na Figura 1:
Figura 1 – Help do comando np.array
9
UNIDADE Bibliotecas para Manipulação de Dados
Para visualizar a lista de comandos do Numpy, digite dir(np) e você terá uma lista 
tal como a apresentada na Figura 2:
Figura 2 – Exemplo da lista de comandos do pacote Numpy
Vejamos alguns casos de uso para o Numpy – procure testar estes comandos no 
seu computador.
Exemplos:
# Lembre-se de sempre importar o pacote antes de iniciar o uso
import numpy as np
# Podemos criar um vetor a partir de uma lista:
vet = np.array([1, 2, 3, 4, 5])
print(vet) # Saída [1 2 3 4 5]
# Listar os métodos associados diretamente ao vetor criado
dir(vet)
# A partir do momento em que criamos o vetor, temos métodos específicos do numpy
# O método cumsum efetua a soma dos elementos do vetor, sempre acumulando 
os valores
vet1.cumsum() # saída array([ 1, 3, 6, 10, 15])
# Se criamos uma lista, perceba que os métodos mudam
list = [1, 2, 3, 4, 5]
dir(list)
# Compare com a listagem do dir(vet), existem mais opções
# Para imprimir um elemento do vetor, seguimos o mesmo princípio da lista
10
11
vet[0]
# Alterando um elemento do array, mesmo princípio da lista
vet[4] = 100
print(vet) # saída [ 1 2 3 4 100]
# Não é possível incluir elemento de outro tipo
vet[0] = ‘Novo elemento’ # Dará um erro: ValueError: invalid literal for 
int() with base 10: ‘Olá Mundo’
# Na lista podemos inserir o elemento de outro tipo e não teremos erro
list[0]=”oi”
# Verificando o formato do array
print(vet.shape) # saída (5,)
Vejamos alguns casos de funções úteis do Numpy.
Exemplos:
# A função arange cria um vetor contendo uma progressão aritmética, os pa-
râmetros da função são (start, stop, step)
# Vamos criar um array do número 0 até o número 5, com intervalos de 0.25
# O valor de stop não entra no intervalo 
vet2 = np.arange(0, 5.25, 0.25)
print(vet2)# Saída do comando print:
[0. 0.25 0.5 0.75 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. 3.25
 3.5 3.75 4. 4.25 4.5 4.75 5. ]
# Podemos criar um vetor com valores zerados, usando a função zeros(qtd)
vet3 = np.zeros(10)
print(np.zeros(10)) # saída [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
# Se necessário, podemos criar um vetor com a diagonal principal com o valor 
1 e demais valores com o número 0
vet4 = np.eye(3)
print(vet4)
# Saída da linha anterior
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
# Array de valores booleanos
vet5 = np.array([True, False, True, True, False])
print(vet5) # Saída: [ True False True True False]
11
UNIDADE Bibliotecas para Manipulação de Dados
# Array de palavras (strings)
vet6 = np.array([‘Python’, ‘R’, ‘Java’, ‘JavaScript’])
print(vet6) # Saída: [‘Python’ ‘R’ ‘Java’ ‘JavaScript’]
# O método linspace retorna números espaçados uniformemente em um intervalo 
especificado, se não for especificada a quantidade da amostra, são geradas 
50 amostras. 
vet7 = np.linspace(0, 5)
vet7
# Saída para a linha acima:
array([0. , 0.10204082, 0.20408163, 0.30612245, 0.40816327,
 0.51020408, 0.6122449 , 0.71428571, 0.81632653, 0.91836735,
 1.02040816, 1.12244898, 1.2244898 , 1.32653061, 1.42857143,
 1.53061224, 1.63265306, 1.73469388, 1.83673469, 1.93877551,
 2.04081633, 2.14285714, 2.24489796, 2.34693878, 2.44897959,
 2.55102041, 2.65306122, 2.75510204, 2.85714286, 2.95918367,
 3.06122449, 3.16326531, 3.26530612, 3.36734694, 3.46938776,
 3.57142857, 3.67346939, 3.7755102 , 3.87755102, 3.97959184,
 4.08163265, 4.18367347, 4.28571429, 4.3877551 , 4.48979592,
 4.59183673, 4.69387755, 4.79591837, 4.89795918, 5. ])
# Podemos especificar a quantidade da amostra
vet8 = np.linspace(0, 5, num=10) #ou vet8 = np.linspace(0, 5, 10)
vet8
# Saída para a linha acima
array([0. , 0.55555556, 1.11111111, 1.66666667, 2.22222222,
 2.77777778, 3.33333333, 3.88888889, 4.44444444, 5. ])
Além de arrays – vetores unidimensionais –, podemos trabalhar também com 
matrizes no Numpy. Vejamos alguns exemplos:
# Criando uma matriz, array dentro de array
matriz = np.array([[1,2,3],[4,5,6]])
print(matriz)
# Saída da linha acima
[[1 2 3],
 [4 5 6]]
# Se listarmos as dimensões da matriz, teremos 2 
print(matriz.shape) # Saída (2, 3) = linhas,colunas
# Criando uma matriz 3x3 apenas com números 1, podemos usar também a função 
zeros vista anteriormente 
matriz1 = np.ones((3,3))
12
13
print(matriz1)
[[1. 1. 1.]
 [1. 1. 1.]]
# Para saber a quantidade de elementos da matriz usamos a função size
matriz2.size # Saída: 9
# Para alterar um elemento da matriz, devemos informar o número da linha e 
coluna
matriz1[1,0] = 100
print(matriz1)
# Saída da linha acima:
[[ 0. 0. 0.]
 [100. 0. 0.]
 [ 0. 0. 0.]]
Veremos mais algumas funções do Numpy, por exemplo, para manipular valo-
res randômicos e um pouco de estatística. Ressaltamos que as funções apresenta-
das nesta seção podem ser utilizadas em vetores ou matrizes.
Exemplos:
# Usando o método rand() para sortear valores aleatórios 
print(np. random.rand(10))
# Saída da linha acima
[0.32876755 0.8059542 0.38401033 0.96814204 0.242465 0.30801586
0.26278155 0.92680311 0.10689803 0.62445356]
# Podemos criar uma matriz 4x4 com valores aleatórios
matriz2 = np.random.randn(4,4)
print(matriz2)
[[ 0.08434813 -0.57019078 0.49043017 -0.15646221]
 [ 0.07023537 -0.62354684 -0.931547 -1.06172253]
 [ 2.26762334 -0.88633445 0.92539156 -1.32223354]
 [ 1.43526113 1.6686621 1.00884179 -0.92217206]]
# Vamos criar um vetor 
v = np.array([10, 33, 78, 100, 175])
# A média de uma amostra é o valor que aponta para onde mais se concentram 
os dados, vamos usar a função mean()
np.mean(v) # Saída: 79.2
# Já o desvio padrão mostra o quanto de variação existe em relação à média. 
Vamos usar o método std()
np.std(v) # saída: 57.50617358162513
13
UNIDADE Bibliotecas para Manipulação de Dados
# A variância de uma variável aleatória é uma medida da sua dispersão indicando 
o quanto os valores estão longe do esperado
np.var(v) # saída: 3306.96
# Podemos fazer o somatório dos números do array com sum()
np.sum(v) # saída: 396
# Para retornar o produto dos elementos
np.prod(d) # saída: 450450000
# Para criar um conjunto (10x2) de uma distribuição normal usamos randn()
v1 = np.random.randn(10,2)
# Vamos ver algumas funções para fatiamento dos dados
v2 = np.arange(10)
print(v2) # saída: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# Podemos fatiar o array usando [start:end:step]
v2[1:9:2] # Saída: array([1, 3, 5, 7])
# Os vetores podem ser comparados com “==”, é comparado cada valor
v3 = np.array([2, 2, 3, 1])
v4 = np.array([4, 5, 3, 1])
v3 == v4 # Saída: array([False, False, True, True])
# Podemos pesquisar o valor mínimo e máximo de um array
v3.min() # saída 1
v3.max() # Saída 3
# Para criar um array com elementos repetidos a partir dos valores de outro 
vetor
v5 = np.repeat(v3, 3)
v5 # Saída: array([2, 2, 2, 2, 2, 2, 3, 3, 3, 1, 1, 1])
# Para juntar dois vetores, usamos o método concatenate
v6 = np.concatenate((v3,v4), axis=0) 
v6 # Saída: array([2, 2, 3, 1, 4, 5, 3, 1])
Pacote Pandas
Outra biblioteca ou pacote que compõe o PyData Stack é o Python Data Analysis 
Library (Pandas). O seu foco está em análise de dados, mas dependendo do caso pode 
servir para a visualização de dados em formato de tabelas, de modo que podemos 
preparar os dados que serão apresentados por meio de gráficos no Matplotlib – este 
que estudaremos na próxima seção.
14
15
Geralmente, quando trabalhamos com Pandas, utilizamos também algumas fun-
cionalidades do Numpy, então fique ciente de que provavelmente você importará 
os dois pacotes para os seus códigos a partir de então. Vale ressaltar que o Pandas
é construído sobre a base Numpy.
Com o Pandas, temos disponível uma variedade de métodos para se criar, ma-
nipular e organizar os dados para serem analisados. Alguns autores o c lassificam 
como um pacote que manipula “planilhas de dados” ou tabelas, contudo, as suas 
funcionalidades são bem mais avançadas que uma simples planilha. Ademais, per-
mite trabalhar com dados relacionais ou rotulados.
Pandas é indicado para trabalhar com dados tabulares – tal como uma tabela 
de um banco de dados ou planilha Office Excel –; matrizes com séries temporais e 
conjunto de dados estatísticos de diferentes formas.
Algumas tarefas que podemos realizar com o Pandas são as seguintes: 
• Manusear dados ausentes;
• Remover ou adicionar colunas em dataframes;
• Mesclagem e associação de dados;
• Rotulagem dos eixos dos dados.
Consulte a documentação do Pandas para verificar todas as possíveis funcionalidades que 
podemos ter no pacote, disponível em: http://bit.ly/2Q5abU3Ex
pl
or
Como mencionamos, Pandas trabalha com series e dataframe; de modo geral, 
dataframe é um conjunto para series – e este é um conjunto de escalares.
Como você perceberá, Pandas é uma excelente ferramenta para converter e 
mapear dados brutos em formatos que possam ser facilmente utilizados com outras 
ferramentas, tal como para a geração de gráficos, ou ainda para a manipulação de 
inteligência artificial. Assim, você deve ter percebido que esse pacote é ideal para a 
fase de preparação dos dados.
Nesse pacote teremos dois conceitos fundamentais:
• Series (1D): conjunto de dados unidimensionais, composto por um array
de dados e um array de labels – rótulos –, conhecido também como índice. 
Um exemplo para entendê-lo é representar a venda de smartphones de 
2014 a 2019 – cujos dados a seguir são fictícios: 
» 2014 = 14;
» 2015 = 20;
» 2016 = 6;
» 2017 = 10;
15
UNIDADE Bibliotecas para Manipulação de Dados
 » 2018 = 20;
• 2019 = 30.
Note que temos, à esquerda, os labels e os dados à direita;
• Dataframes (2D): conjunto de dados bidimensionais; é uma forma de re-
presentar dados tabulares, tal como uma planilha.Neste tipo de estrutura de 
dados cada coluna pode ter um tipo de valor diferente como, por exemplo, 
números inteiros, decimais ou textos.
Segue um exemplo visual para você melhor entender esse conceito, cujos dados 
poderiam representar os países que mais venderam smartphones no período de 
2014 a 2019:
Tabela 1 – Países que mais venderam smartphones por ano (2014-2019)
Ano País Vendas
0 2014 EUA 50
1 2015 China 60
2 2016 Brasil 70
3 2017 Canadá 40
4 2018 Portugal 10
5 2019 Espanha 88
Analisaremos alguns exemplos de uso do pacote Pandas:
# Primeiro importaremos o Numpy e depois o Pandas
import numpy as np
import pandas as pd
# Criando series
# Uma serie é um array unidimensional composto por labels e dados
# Podemos criar uma serie sem label
s1 = pd.Series([23, 77, 0, 5, 12])
s1
# Saída: 
0 23
1 77
2 0
3 5
4 12
# Caso queira verificar os valores da serie, usamos a propriedade values
s1.values # saída: array([23, 77, 0, 5, 12], dtype=int64)
# Caso queira verificar os índices da serie
s1.index # saída: RangeIndex(start=0, stop=5, step=1)
16
17
# Para criar uma serie e especificar os seus índices, devemos passar cada 
um dos rótulos
s2 = pd.Series([23, 77, 0, 5, 12], index = [‘A’, ‘B’, ‘C’, ‘D’, ‘E’])
s2
# saída:
A 23
B 77
C 0
D 5
E 12
s2.index # Saída: Index([‘A’, ‘B’, ‘C’, ‘D’, ‘E’], dtype=’object’)
# Para fatiar a serie, podemos usar
s2[:2]
# Saída:
A 23
B 77
# Podemos ainda usar expressões com operadores relacionais
# Um exemplo é retornar os elementos maiores que 20
s2[s2>20]
# saída:
A 23
B 77
# Para trabalhar com uma posição específica da serie, devemos especificar o 
seu index que pode ser um label ou um índice numérico do array
s2[‘A’] # Podemos usar s2[0], temos o mesmo efeito, retorna 23
# Para alterar o valor de uma posição
s2[‘A’]=100
s2 
# Saída: 
A 100
B 77
C 0
D 5
E 12
# Imagine que temos uma série faltando valor
s3 = pd.Series([23, 77, 0, 5, 12,np.NaN], index = [‘A’, ‘B’, ‘C’, ‘D’, ‘E’,’F’])
# Note que temos np.NaN
s3
# Saída:
17
UNIDADE Bibliotecas para Manipulação de Dados
A 23.0
B 77.0
C 0.0
D 5.0
E 12.0
F NaN
# Podemos verificar se existem dados faltantes ou se os dados são nulos
pd.isnull(s3)
# Saída:
A False
B False
C False
D False
E False
F True
# Podemos também fazer o oposto, verificando qual não é nulo
pd.notnull(s3)
# Saída:
A True
B True
C True
D True
E True
F False
# Se necessário, você pode juntar series
s4 = s2 + s3
# Analise a saída dessa concatenação
A 123.0
B 154.0
C 0.0
D 10.0
E 24.0
F NaN
Perceba que quando concatenamos, os elementos com o mesmo índice são so-
mados em valores e os elementos que são diferentes – neste caso, o índice F – são 
adicionados como novos na junção.
Agora que já vimos como criar séries com o Pandas, conferiremos exemplos de 
criação e manipulação de dataframes:
18
19
# Dataframes possuem index e linhas semelhantes a uma planilha 
# Inicialmente criaremos um dicionário 
dados= {‘Ano’:[2014, 2015, 2016, 2017, 2018, 2019], ‘Pais’:[‘EUA’, ‘China’, ‘Bra-
sil’, ‘Canada’, ‘Portugal’, ‘Espanha’], ‘Vendas’:[50, 60, 70, 40, 10, 88]}
# Podemos criar um dataframe a partir desse dicionário
df = pd.DataFrame(dados)
df
# Saída:
 Ano Pais Vendas
0 2014 EUA 50
1 2015 China 60
2 2016 Brasil 70
3 2017 Canada 40
4 2018 Portugal 10
5 2019 Espanha 88
# Podemos adicionar colunas que não existem no dicionário quando criarmos 
o dataframe, lembrando que esses dados serão nulos
df2 = pd.DataFrame(dados, columns = [‘Ano’, ‘Pais’, ‘Vendas’, ‘Valores’], index 
= [‘A’, ‘B’, ‘C’, ‘D’, ‘E’,’F’])
df2
# Saída: 
 Ano Pais Vendas Valores
A 2014 EUA 50 NaN
B 2015 China 60 NaN
C 2016 Brasil 70 NaN
D 2017 Canada 40 NaN
E 2018 Portugal 10 NaN
F 2019 Espanha 88 NaN
# Podemos manipular somente uma coluna do dataframe 
df2[‘Pais’] 
# Saída: 
A EUA
B China
C Brasil
D Canada
E Portugal
F Espanha
# É igualmente possível atribuir uma coluna para uma variável
19
UNIDADE Bibliotecas para Manipulação de Dados
s = df2[‘Pais’]
# Neste caso, pegaremos somente uma serie do dataframe
type(s) # Saída: pandas.core.series.Series
# Assim como em series, você pode usar propriedades para extrair os índices, 
as colunas e os valores
# Para índices
df2.index # Saída: Index([‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’])
df2.columns # Saída: Index([‘Ano’, ‘Pais’, ‘Vendas’, ‘Valores’]) 
df2.values
# Saída:
array([[2014, ‘EUA’, 50, nan],
 [2015, ‘China’, 60, nan],
 [2016, ‘Brasil’, 70, nan],
 [2017, ‘Canada’, 40, nan],
 [2018, ‘Portugal’, 10, nan],
 [2019, ‘Espanha’, 88, nan]])
# Você também pode fazer fatiamento
df2[:2] # Saída: retorna os dois primeiros registros da tabela
# Caso precise ver o início dos dados ou o final, podemos usar o head() e 
tail(), respectivamente
df2.head()
 Ano Pais Vendas Valores
A 2014 EUA 50 NaN
B 2015 China 60 NaN
C 2016 Brasil 70 NaN
D 2017 Canada 40 NaN
E 2018 Portugal 10 NaN
df2.tail()
 Ano Pais Vendas Valores
B 2015 China 60 NaN
C 2016 Brasil 70 NaN
D 2017 Canada 40 NaN
E 2018 Portugal 10 NaN
F 2019 Espanha 88 NaN
Agora, vejamos alguns exemplos juntando o Pandas e Numpy:
# É possível usar o Numpy para preencher a coluna de nosso dataframe, de-
nominada Valores e que inicialmente estava vazia
# Preencheremos com valores randômicos 
20
21
df2[‘Valores’]= np.random.rand(6)*100
df2
# Saída: 
 Ano Pais Vendas Valores
A 2014 EUA 50 98.256404
B 2015 China 60 55.816375
C 2016 Brasil 70 66.287141
D 2017 Canada 40 72.741869
E 2018 Portugal 10 98.622144
F 2019 Espanha 88 79.809936
# Um método bem interessante é o describe(), que descreve os dados do data-
frame; este método retorna:
# count = número de registros (linhas)
# mean = média dos calores por coluna
# std = desvio padrão
# min = valor mínimo da amostra
# quartis = 25%, 50% e 75%
# max = valor máximo da amostra
df2.describe()
 Ano Vendas Valores
count 6.000000 6.000000 6.000000
mean 2016.500000 53.000000 78.588978
std 1.870829 26.795522 17.284336
min 2014.000000 10.000000 55.816375
25% 2015.250000 42.500000 67.900823
50% 2016.500000 55.000000 76.275903
75% 2017.750000 67.500000 93.644787
max 2019.000000 88.000000 98.622144
# É possível fatiar o dataframe por meio do nome dos índices 
df2[‘A’:’C’]
# saída:
 Ano Pais Vendas Valores
A 2014 EUA 50 98.256404
B 2015 China 60 55.816375
C 2016 Brasil 70 66.287141
# Podemos pesquisar e retornar os dados somente de um índice 
df2.loc[‘D’]
21
UNIDADE Bibliotecas para Manipulação de Dados
# Saída:
Ano 2017
Pais Canada
Vendas 40
Valores 72.7419
Como você deve ter percebido, Pandas é um pacote sofisticado para manipular 
dados, podendo ser utilizado junto ao Numpy para preparar os dados que serão 
examinados. É comum prepararmos dados com esses pacotes para, então, plotar-
mos – desenharmos – gráficos com a biblioteca Matplotlib – que veremos a seguir.
Estudamos os princípios básicos dos dois pacotes – Numpy e Pandas –, de modo 
que não deixe de consultar os Materiais Complementares para conhecer outras 
possibilidades que esses recursos nos trazem.
Pacote Matplotlib
Até este momento você estudou os dois principais pacotes para análise de da-
dos, os quais fornecem as ferramentas necessárias para preparar os dados e, ainda, 
trabalhar com estatísticas. Mas como você poderia representar de forma visual a 
grande quantidade de dados? É aqui que entra o pacote ou a biblioteca Matplotlib, 
que nos ajudará a visualizar os dados de forma gráfica, auxiliando na análise desses.
Considerando que Matplotlib é extenso, não deixe de consultar os Materiais 
Complementares para se aprofundar nos diversos comandos desse pacote, pois 
aqui abordaremos apenas as principaisestruturas, ou as mais comuns; assim, vá 
além e tente outros modos de representar os seus dados.
Considerando que com Matplotlib podemos representar os dados de diferentes for-
mas, vejamos algumas graficamente – a seguinte Figura apresenta um gráfico de linhas:
Tão simples quanto parece, pessoal.
tempo (s)
vo
lta
ge
m
 (m
V)
0.00
0.00
0.25
0.25
0.50
0.50
0.75
0.75
1.00
1.00
1.25
1.25
1.50
1.50
1.75
1.75
2.00
2.00
Figura 3 – Gráfico de linhas
Fonte: matplotlib.org
22
23
Você pode também criar histogramas, representando os dados tabulados e di-
vididos em categorias ou classes. Em geral, separamos os dados em categorias e 
contamos a quantidade de valores que se encaixam em cada uma dessas categorias.
Pr
ob
ab
ili
da
de
 de
 de
ns
id
ad
e
Historgrama do IQ: µ = 100, σ =15
Inteligência
60 80 100 120 140
0.000
0.005
0.010
0.015
0.020
0.025
0.030
0.035
Figura 4 – Histograma
Fonte: matplotlib.org
Se precisar, poderá representar os dados em gráfico de barras, útil para realizar 
algumas comparações entre as distribuições das variáveis – a seguinte Figura apre-
senta um modelo vertical:
Flexões 16th
60th
73rd
95th
37th
Agilidade
Corrida
0 10 20 30 40 50 60 70 80 90 100
14
17sec
12:52
min:sec
48 sec
7 laps
Re
su
lta
do
 do
s T
es
te
s
Classi�cação Percentual entre os Meninos da 2ª Série
Tamanho do Coorte
Johnny Doe
Flexão de Braço
Teste de Marcapasso
Figura 5 – Gráfi co de barras
Fonte: matplotlib.org
Outro gráfico bem conhecido é o de setores – cujo nome popular é gráfico de 
pizza –, útil para mostrar dados proporcionais de diferentes categorias, em que as 
figuras geralmente são em percentuais.
23
UNIDADE Bibliotecas para Manipulação de Dados
15.0%
10.0%
45.0%
30.0%
Dogs
Logs
Hogs
Frogs
Figura 6 – Gráfico de setores
Fonte: matplotlib.org
Um gráfico amplamente utilizado para representar dados em um eixo vertical e 
horizontal e que exibe o quanto uma variável pode afetar outra é o de dispersão – 
veja um exemplo:
Volume e percentual de mudança
Figura 7 – Gráfico de dispersão
Fonte: matplotlib.org
Agora que já visualizamos os principais gráficos ou formas de visualizar os nossos 
dados com Matplotlib, conferiremos como criá-los por meio dos códigos no Python.
Para utilizar o pacote Matplotlib, devemos importá-lo tal como fizemos com os 
outros pacotes já estudados. É válido e muitas vezes necessário importar o Numpy 
e Pandas, pois prepararão os dados que mostraremos com Matplotlib.
24
25
Vejamos alguns exemplos:
import numpy as np
import matplotlib.pyplot as plt
# Construiremos um gráfico de linhas, para isso precisamos definir os va-
lores de x e y
x = np.linspace(0,10,20)
y = x**2
# As seguintes instruções devem ser colocadas em uma única entrada para que 
tudo seja executado junto
plt.plot(x, y) # Gera o gráfico de linha com x,y
plt.xlabel(‘Variável do eixo X’) # Configura o rótulo do eixo x
plt.ylabel(‘Variável do eixo Y’) # Configura o rótulo do eixo y
plt.title(‘Gráfico de linha’) # Título do gráfico
plt.show()
# Saída:
Figura 8 – Gráfi co de linha com Matplotlib
Criaremos um gráfico de barras para mostrar, por exemplo, a porcentagem de 
uso de diferentes linguagens de programação:
import numpy as np
import matplotlib.pyplot as plt
linguagens = (‘Python’, ‘C++’, ‘Java’, ‘Perl’, ‘Scala’, ‘Lisp’)
x = np.arange(len(linguagens)) # criar o intervalo no eixo x de 0 - n
# Valores do eixo y referentes ao uso das linguagens
y_performance = [10,8,6,4,2,1] 
25
UNIDADE Bibliotecas para Manipulação de Dados
# Insira o seguinte bloco em uma linha no jupyter
plt.bar(x, y_performance, align=’center’)
plt.xticks(x, linguagens ) # Configura os valores do eixos x e y
plt.ylabel(‘Taxa de uso’)
plt.title(‘Uso de linguagens de programação’)
plt.show()
Figura 9 – Gráfi co de barras
Imagine que você necessite demonstrar a porcentagem de vendas de telefones 
celulares em relação ao sistema operacional; neste caso, você poderia optar em 
empregar um gráfico de setor, em que cada setor representaria um sistema opera-
cional com a sua porcentagem de vendas associada. Exemplo:
import matplotlib.pyplot as plt
labels = ‘Android’, ‘Blackberry’, ‘Windows Phone’, ‘iOS’
vendas = [40, 20, 10, 30] # Valores não reais 
cores = [‘lightyellow’, ‘lightgreen’, ‘lightcoral’, ‘lightskyblue’]
explode = (0.1, 0, 0, 0) # Separa um setor do gráfico, destaque
plt.pie(sizes, explode = explode, labels = labels, colors = cores, 
autopct = ‘ %.f%%’, shadow = True, startangle = 0) 
plt.axis(‘equal’)
plt.show()
# Saída:
26
27
Blackberry
Windows Phone iOS
Android
40%
30%
10%
20%
Figura 10 – Gráfi co de setor
Agora criaremos um histograma com Matplotlib:
import numpy as np
import matplotlib.pyplot as plt
dados = [43,45,53,56,56,57,58,66,67,73,74,79,
 80,80,81,81,81,82,83,83,84,88,89,91,
 91,92,92,97,99,99,100,100,101,102,102,102,
 103,104,107,108,109,113,114,118,121,123,126,128,
 137,138,139,144,145,147,156,162,174,178,179,184,
 191,198,211,214,243,249,329,380,403,511,522,598]
bins = [0,100,200,300,400,500,600] # Intervalos das frequências 
plt.grid(color=’#cccccc’, linestyle=’-’, zorder=1) # Grade do gráfico
plt.hist(dados, zorder=2, bins=bins)
# Saída:
27
UNIDADE Bibliotecas para Manipulação de Dados
Figura 11 – Histograma simples
# Se quisermos mostrar os valores no histograma, devemos criá-lo associado 
a uma variável
plt.grid(color=’#cccccc’, linestyle=’-’, zorder=1)
aux = plt.hist(dados, zorder=2, bins=bins)
# A variável aux possui os valores do eixo x e y gerados no gráfico
# aux é uma matriz 
# (array([30., 32., 4., 2., 1., 3.]), array([ 0, 100, 200, 300, 400, 500, 600]))
# Precisamos fazer uma repetição para exibir os valores dentro do gráfico 
for i in np.arange(len(bins)-1):
 plt.text(aux[1][i]+30,aux[0][i],str(aux[0][i]))
# Saída:
Figura 12 – Histograma completo
28
29
Para finalizar este estudo sobre Matplotlib, vejamos um gráfico de dispersão 
que mostra a relação entre o peso e a altura de dois grupos de pessoas – exemplo 
meramente explicativo:
import matplotlib.pyplot as plt
import numpy as np 
# Grupo A
peso1 = [57,58.2,58.6,59.6,59.8,60.2,60.5,60.6,60.7,61.3,61.3,61.4,61.8,61.9,62.3]
altura1 = [100.7,195.6,94.3,127.1,111.7,159.7,135,149.9,124.3,112.9,176.7,110.2,123.
9,161.9,107.8]
# Grupo B
peso2 = [62.9,63,63.1,63.2,63.3,63.4,63.4,63.4,63.5,63.6,63.7,64.1,64.3,64.3,64.7,64.8,65]
altura2 = [151.8,156.3,136.1,124.2,156.3,130,181.2,255.9,163.1,123.1,119.5,179.9,114.8,
174.1,108.8,105.4,141.4]
# Gerando o gráfico 
plt.scatter(peso1, altura1, marker=’*’, color=’r’, label=”GrupoA”)
plt.scatter(peso2, altura2, marker=’*’, color=’g’, label=”GrupoB”)
plt.xlabel(‘Peso’, fontsize=16)
plt.ylabel(‘Altura’, fontsize=16)
plt.title(‘Altura vs Peso’,fontsize=20)
plt.legend()
plt.show()
# Saída:
Figura 13 – Gráfi co de dispersão
29
UNIDADE Bibliotecas para Manipulação de Dados
Chegamos ao final desta Unidade, onde você percebeu que a junção entre 
Numpy, Pandas e Matplotlib nos fornece uma ferramenta completa de análise de 
dados. Embora nos exemplos de gráficos não tenhamos utilizado o Pandas, este 
pode ser aplicado com Matplotlib – a justificativa de não usar aqui esse pacote 
é para manter os exemplos de gráficos simples, focando essencialmente nos 
comandos básicos do Matplotlib.
Agora que você já conheceu os conceitos dos três pacotes – Numpy, Pandas, 
Matplotlib –, procure testar os exemplos e consultar a documentação de cada 
pacote para analisar os recursos mais avançados; note que em nossos comandos 
para gerar os gráficos, utilizamos algumas configurações extras, tais como os ti-
pos marcados, as cores, entre outras. Então, explore as documentações nos sites 
indicados como Materiais Complementares.
30
31
Material Complementar
Indicações para saber mais sobre os assuntos abordados nesta Unidade:
Sites
Tutorial do Numpy
http://bit.ly/2sR6U2U
Iniciando o uso doPandas
http://bit.ly/2Q5rqV9
Tutorial do Matplotlib
http://bit.ly/2PIR1UV
Documentação do Python 3.x
http://bit.ly/2PFrcoK
31
UNIDADE Bibliotecas para Manipulação de Dados
Referências
BECKER, J. L. Estatística Básica: Transformando Dados em Informação. Porto 
Alegre, RS: Bookman, 2015.
CASTRO, L. N. de. Introdução à Mineração de Dados: Conceitos Básicos, Al-
goritmos e Aplicações. São Paulo: Saraiva, 2016.
PERKOVIC, L.; VIEIRA, D. Introdução à Computação usando Python: um foco 
no desenvolvimento de aplicações. Rio de Janeiro: LTC, 2016.
32