Tutorial Matplotlib

numist - IST
Tutorial para estudantes
Construir bom material de apresentação para teses e trabalhos em engenharia
Pedro Correia
2011

ÍNDICE
INTRODUÇÃO ................................................................................................................................ 3
INSTALAR O PYTHON ..................................................................................................................... 3
FICHEIROS DE TEXTO ..................................................................................................................... 5
PREPARAR A CONSOLA E FOLHA DE SCRIPT .................................................................................. 5
CARREGAR FICHEIROS DE DADOS PARA O PYTHON ..................................................................... 6
HISTOGRAMAS .............................................................................................................................. 7
RESUMO DOS HISTOGRAMAS ................................................................................................. 14
GRÁFICOS DE LINHAS E PONTOS ................................................................................................. 15
RESUMO DOS GRÁFICOS DE PONTOS E LINHAS ......................................................................... 19
CONSIDERAÇÕES FINAS ............................................................................................................... 20
2

INTRODUÇÃO
Recentemente reparei na dificuldade dos estudantes em apresentarem os seus resultados em
teses ou trabalhos académicos devido ao desconhecimento que têm dos softwares usados
vulgarmente na construção dos mesmos. Regra geral programas como o EXCEL (Office) e CALC
(Open Office) são os mais utilizados para essas funções e embora proporcionem a maneira
mais óbvia para o utilizador analisar os seus dados pecam por não permitir, ou ser complexo,
construir gráficos com o detalhe e caracterização ideal para um resultado. Por esse motivo
construo este guia para qualquer pessoa que queira produzir material visual de qualidade nos
seus trabalhos.
Para o fazer irei utilizar a linguagem Python. Isto não é uma introdução à programação, coisa
que o utilizador deve ter em conta (existe outra publicação no numist que, de facto, ensina a
programar em Python), mas sim um guia de instruções para cumprir objectivos muito
específicos. Para isso irei ensinar o utilizador a carregar dados para dentro do Python e analisálos
visualmente e, por vezes, numericamente.
INSTALAR O PYTHON
O pacote que aconselho a que se instale é o Python XY (penso que de momento só existe
versão para Windows). Está disponível para download gratuito no seguinte link (secção de
downloads):
http://www.pythonxy.com/
3

As bibliotecas que estão lá dentro que vão mesmo precisar é o numpy e o matplotlib, mas é
minha sugestão que, se vão instalar o pacote o façam com tudo o que está lá dentro. Quando
surgir na janela de instalação a lista de pacotes que têm de instalar procurem que pelos menos
os que indiquei acima estejam seleccionados.
Agora, depois de instalarem deverá aparecer um ícone do Python XY algures no desktop. Ao
carregarem nele (ou então vão à procura dele na lista de programas no inciar) irá aparecer isto:
Ao carregarem no sítio que eu estou, declaradamente, a dizer para carregarem vai aparecer
isto (ou semelhante, eu já tenho código lá, vocês não vão ter):
4
Carreguem aqui.

Ao que está dentro do rectângulo vermelho na imagem que mostrei vamos chamar consola.
Ao que está dentro do rectângulo verde vamos chamar folha de script.
FICHEIROS DE TEXTO
Regra geral nós costumamos meter todas as informações em ficheiros de texto (é possível
exportar as tabelas de EXCEL e CALC para ficheiros de texto no “Salvar como…”). Um ficheiro
de texto, regra geral com extensão .txt, .prn, etc… (.doc e .docx não são ficheiros de texto, são
ficheiros do Word) e podem ser abertos com programas como o notepad, no Windows, e gedit,
no Ubuntu. Para ser mais simples para vocês aprenderem façam os vossos ficheiros de texto
com os dados lá dentro assim:
10
20
15
14
23
33
29
19
10
9
No caso de terem apenas uma coluna de dados, e assim no caso de terem duas:
13 27
9 33
10 29
7 37
9 31
8 39
5 44
3 33
2 42
1 55
E por ai adiante no caso de terem 3, 4 ou mais. Reparem que não há mais informação
nenhuma nos ficheiros sem ser os vossos dados.
PREPARAR A CONSOLA E FOLHA DE SCRIPT
Quando começarem a trabalhar na consola ou folha de script façam estes comandos antes de
fazer seja o que for:
5

Para a consola:
In [1]: from __future__ import division
In [2]: import numpy as np
In [3]: import matplotlib.pyplot as plt
Para a folha de script:
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
Com isto vocês estão a importar as bibliotecas necessárias para fazer gráficos e outras coisas.
Sempre que iniciarem uma sessão (abrirem o software ou uma folha de script nova), escrevam
isto se já não estiver lá escrito.
CARREGAR FICHEIROS DE DADOS PARA O PYTHON
Para carregar ficheiros para o Python como aqueles que mostrei num dos capítulos anteriores
basta fazer assim (no meu exemplo estou a abrir o exemplo que dei de ficheiro com duas
colunas):
In [4]: dados=np.loadtxt(r'C:\Pedro Correia\Dados\TESES E TRABALHOS\DADOS\nome_do_vosso_ficheiro.txt')
dados=np.loadtxt(r'C:\Pedro Correia\Dados\TESES E TRABALHOS\DADOS\nome_do_vosso_ficheiro.txt')
Reparem que meti o caminho onde está o ficheiro conjuntamente com o nome dentro de
pelicas. Reparem que também está um “r” antes das pelicas. É importante para o Python
perceber que é um caminho escrito à moda do Windows por isso se estiverem a trabalhar em
Windows metam-no sempre. Agora já têm dos dados carregados. Se chamarem na consola a
variável “dados” para onde foi para a informação que meteram no ficheiro vai aparecer toda a
informação:
6

In [5]: dados
Out[5]:
array([[ 13., 27.],
[ 9., 33.],
[ 10., 29.],
[ 7., 37.],
[ 9., 31.],
[ 8., 39.],
[ 5., 44.],
[ 3., 33.],
[ 2., 42.],
[ 1., 55.]])
A folha de script vai correr apenas quando a fizeres correr (depois explico) enquanto a consola
funciona em tempo real. Por isso é que só mostrei como fazer na consola (na folha de script
seria totalmente inútil).
HISTOGRAMAS
Histogramas são dos tipos de gráficos mais usados por descreverem o que é a distribuição de
uma variável. Mas antes de fazermos um histograma vamos ver como seleccionamos apenas
uma das colunas dos nossos dados (para escolhermos apenas uma variável). Se assumirmos
que os dados estão dispostos desta maneira:
Linhas\Colunas 0 1
0 13 27
1 9 33
2 10 29
3 7 37
4 9 31
5 8 39
6 5 44
7 3 33
8 2 42
9 1 55
Então a primeira coluna é a coluna 0 e a segunda a coluna 1, da mesma maneira que a primeira
linha é a linha 0 e a segunda a 1, terceira a 2, por ai adiante. É assim que se escolhe as posições
em Python. Para escolher posições em python fazemos assim (exemplo apenas na consola):
In [6]: dados[3,0]
Out[6]: 7.0
7

Repara que escolhi o número que estava na posição 3 das linhas e 0 das colunas (confirma na
tabela). Se eu quiser escolher uma coluna inteira em vez de apenas uma posição digo que
quero tudo numa determinada linha ou coluna com o indicador “:”.
In [7]: dados[:,0]
Out[7]: array([ 13., 9., 10., 7., 9., 8., 5., 3., 2., 1.])
Repara que escolhi todas a linhas da coluna 0. Vamos lá agora fazer um histograma desta
coluna.
In [8]: plt.hist(dados[:,0])
Out[8]:
(array([2, 1, 0, 1, 0, 2, 2, 1, 0, 1]),
array([ 1. , 2.2, 3.4, 4.6, 5.8, 7. , 8.2, 9.4, 10.6,
11.8, 13. ]),
)
plt.hist(dados[:,0])
plt.show()
Resultou o histograma acima mostrado. Têm classes a mais por isso vou especificar que apenas
quero três classes no histograma.
In [9]: plt.hist(dados[:,0],bins=3)
Out[9]:
(array([3, 3, 4]),
array([ 1., 5., 9., 13.]),
)
plt.hist(dados[:,0],bins=3)
plt.show()
8

Pretendo visualizar os histogramas de ambas as colunas no mesmo gráfico. Para isso insiro as
instruções seguintes:
In [10]: plt.hist(dados[:,0],bins=5)
Out[10]:
(array([3, 1, 2, 3, 1]),
array([ 1. , 3.4, 5.8, 8.2, 10.6, 13. ]),
)
In [11]: plt.hist(dados[:,1],bins=5)
Out[11]:
(array([3, 3, 2, 1, 1]),
array([ 27. , 32.6, 38.2, 43.8, 49.4, 55. ]),
)
plt.hist(dados[:,0],bins=5)
plt.hist(dados[:,1],bins=5)
plt.show()
9

Ele mudou a cor automaticamente quando reparou que havia dois sets de dados dentro do
mesmo gráfico. Repara também que mudei o número de classes para 5 em cada histograma.
Quero agora comparar o histograma da primeira coluna (0) com 3 classes e com 5 classes no
mesmo gráfico. Para isso quero meter o primeiro caso a azul e o segundo a vermelho.
In [12]: plt.hist(dados[:,0],bins=3,color='blue')
Out[12]:
(array([3, 3, 4]),
array([ 1., 5., 9., 13.]),
)
In [13]: plt.hist(dados[:,0],bins=5,color='red')
Out[13]:
(array([3, 1, 2, 3, 1]),
array([ 1. , 3.4, 5.8, 8.2, 10.6, 13. ]),
)
plt.hist(dados[:,0],bins=3,color=’blue’)
plt.hist(dados[:,0],bins=5,color=’red’)
plt.show()
O problema neste caso é que o histograma vermelho está a ocultar o azul de certa maneira por
isso seria ideal que ele apresentasse alguma transparência para o que está por baixo parecer
perceptível.
In [14]: plt.hist(dados[:,0],bins=3,color='blue')
Out[14]:
(array([3, 3, 4]),
array([ 1., 5., 9., 13.]),
)
In [15]: plt.hist(dados[:,0],bins=5,color='red',alpha=0.5)
Out[15]:
(array([3, 1, 2, 3, 1]),
array([ 1. , 3.4, 5.8, 8.2, 10.6, 13. ]),
)
plt.hist(dados[:,0],bins=3,color=’blue’)
plt.hist(dados[:,0],bins=5,color=’red’,alpha=0.5)
plt.show()
10

Agora todas as características do primeiro histograma com o segundo são perceptíveis ao
leitor e por estarem os dois incluídos no mesmo gráfico torna-se muito fácil de comparar.
Reparem que nos gráficos acima o Python automaticamente estabelece um espaço em branco
para cada um dos lados do histograma e por vezes nós próprios queremos controlar onde
começa e acaba o limite da imagem. Podemos fazê-lo assim:
In [16]: plt.hist(dados[:,0],bins=3,color='blue')
Out[16]:
(array([3, 3, 4]),
array([ 1., 5., 9., 13.]),
)
In [17]: plt.hist(dados[:,0],bins=5,color='red',alpha=0.5)
Out[17]:
(array([3, 1, 2, 3, 1]),
array([ 1. , 3.4, 5.8, 8.2, 10.6, 13. ]),
)
In [18]: plt.xlim(1,13)
Out[18]: (4, 10)
In [19]: plt.ylim(0.5,4)
Out[19]: (1, 3)
plt.hist(dados[:,0],bins=3,color=’blue’)
plt.hist(dados[:,0],bins=5,color=’red’,alpha=0.5)
plt.xlim(1,13)
plt.ylim(0.5,4)
plt.show()
11

Até agora não fizemos nada de muito impressionante mas já conseguimos fazer alterações
pequenas aos nossos gráficos. O resultado na folha de script é o seguinte no meu exemplo
(repara que para correr o script é preciso fazer “run”):
Isto irá fazer aparecer a janela do gráfico por onde vocês podem salvar para imagem.
12

Uma coisa que me estava a esquecer é de acrescentar legenda ao gráfico. É muito fácil, basta
acrescentar a label em cada instrução e depois meter o comando legend. Aqui está um código
completo feito no script:
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
dados=np.loadtxt(r'C:\Pedro Correia\Dados\TESES E
TRABALHOS\DADOS\nome_do_vosso_ficheiro.txt')
plt.hist(dados[:,0],bins=3,color='blue',label='3 classes')
plt.hist(dados[:,0],bins=5,color='red',alpha=0.5, label='4 classes')
plt.legend()
plt.xlim(1,13)
plt.ylim(0.5,4.5)
plt.show()
13

RESUMO DOS HISTOGRAMAS
Cabeçalho inicial:
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
Importar dados:
dados=np.loadtxt(r'C:\Pedro Correia\Dados\TESES E TRABALHOS\DADOS\nome_do_vosso_ficheiro.txt')
Fazer o histograma à primeira coluna especificando o número de classes (bins), cor (color) e
transparência da cor (alpha) e nome (label):
plt.hist(dados[:,0],bins=5,color=’red’,alpha=0.5, label=’5 classes’)
Limitar a imagem dos gráficos aos limites em X e Y:
plt.xlim(1,13)
plt.ylim(0.5,4)
Acrescentar legenda:
plt.legend()
Visualizar o gráfico (na consola não é preciso):
plt.show()
A título de informação o parâmetro alpha vai de 0 a 1, com zero sendo totalmente
transparente e 1 sendo totalmente opaco (sem transparência). Só utilizamos as cores azul
(blue) e vermelho (red) mas é possível meter qualquer cor lá desde que indicando ou o nome
da cor ou o código da cor. Algumas das cores possível com nome são:
blue, red, green, yellow, orange, purple, violet, pink, black, grey,brown,sienna,etc.
14

GRÁFICOS DE LINHAS E PONTOS
Gráficos de linhas e de pontos são feitos com o mesmo comando no matplotlib simplesmente
mudamos o estilo do marcador (linha, pontos, triângulos, estrelas, tracejado, o que tu
quiseres…). Então pegando nos dados que já usamos no capítulo anterior fazemos (a partir de
agora mostrarei apenas o código para a folha de script pois como já deverás ter percebido a
única diferença entre um e outro é o facto de funcionarem por compilação ou em tempo real):
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
dados=np.loadtxt(r'C:\Pedro Correia\Dados\TESES E
TRABALHOS\DADOS\nome_do_vosso_ficheiro.txt')
plt.plot(dados[:,0],dados[:,1],marker='-',color='orange',label='scatterplot')
plt.legend()
plt.show()
Repara que por ter metido no campo do “marker” o símbolo ‘-‘ (hífen) o gráfico saiu com
linhas. Se tivesse metido outro símbolo com por exemplo o ‘o’ (letra o) surgiriam bolas como o
marcador (repara nas duas alternativas e o que acontece com os resultados):
plt.plot(dados[:,0],dados[:,1],marker='o',color='orange',label='scatterplot')
plt.legend()
plt.show()
plt.plot(dados[:,0],dados[:,1],'o',color='orange',label='scatterplot')
plt.legend()
plt.show()
15

Um saiu com linhas e pontos e outro só com pontos. Podemos achar que o marcador dos
pontos é demasiado pequeno e podemos muda-lo com o comando “markersize”:
plt.plot(dados[:,0],dados[:,1],marker='o',markersize=30,color='orange',label='scatterplot')
plt.legend()
plt.show()
Da mesma maneira que limitamos a janela nos gráficos do capítulo anterior também podemos
continuar a fazê-lo com os comandos “xlim” e “ylim”. Como já deverás ter reparado também a
legenda funciona da mesma maneira. Informação nova é adicionar nomes aos eixos e título ao
gráfico.
plt.plot(dados[:,0],dados[:,1],marker='o',markersize=30,color='orange',label='scatterplot')
plt.xlabel('Data Set 1')
plt.ylabel('Data Set 2')
plt.title('Relacao entre Set 1 e Set 2')
plt.legend()
plt.show()
16

Claro que o tamanho das letras poderá ser demasiado pequeno por defeito por isso para o
caso de o queres mudar basta indicares, com o comando “fontsize”, o tamanho que pretendes:
plt.plot(dados[:,0],dados[:,1],marker='o',markersize=30,color='orange',label='scatterplot')
plt.xlabel('Data Set 1', fontsize=30)
plt.ylabel('Data Set 2', fontsize=30)
plt.title('Relacao entre Set 1 e Set 2', fontsize=30)
plt.legend()
plt.show()
Da mesma maneira que podes mudar o tamanho podes também mudar uma série de outros
parâmetros como se queres o texto em “bold”, “itálico”, a fonte do texto, entre muitas outras
17

coisas. No exemplo a seguir mostro os comandos “fontstyle” (itálico ou não), “fontweight”
(texto em bold, muito ou pouco…) e “family” (tipo de letra).
plt.plot(dados[:,0],dados[:,1],marker='o',markersize=30,color='orange',label='scatterplot')
plt.xlabel('Data Set 1',fontsize=30,fontstyle='italic',fontweight='light',family='monospace')
plt.ylabel('Data Set 2',fontsize=30,fontstyle='oblique',family='fantasy')
plt.title('Relacao entre Set 1 e Set 2',fontsize=40,fontstyle='normal',fontweight='bold')
plt.legend()
plt.show()
Existem muitos comandos para muitas coisas no matplotlib e nesta publicação não se
pretende passar por todos (nem pouco mais ou menos). No entanto, certamente, cada vez que
quiseres fazer qualquer coisa mais específica podes ir procurar à net que não demorarás muito
a encontrar.
18

RESUMO DOS GRÁFICOS DE PONTOS E LINHAS
Para fazeres um gráfico de linhas:
dados=np.loadtxt(r'C:\Pedro Correia\Dados\TESES E
TRABALHOS\DADOS\nome_do_vosso_ficheiro.txt')
plt.plot(dados[:,0],dados[:,1],marker='-',color='orange',label='scatterplot')
plt.legend()
plt.show()
Para fazeres um gráfico de pontos:
plt.plot(dados[:,0],dados[:,1],marker='o',color='orange',label='scatterplot')
Outros tipos de marcadores que podem usar são (dão todo o tipo de forma, é uma questão de
experimentar:
Para mudar o tamanho do marcador:
Para dar nomes aos eixos e título:
Para mudar tamanhos, estilos e tipos de fonte:
‘o’,’-‘,’--',’^’,’>’,’

CONSIDERAÇÕES FINAS
Obviamente que para tirar total proveito do matplotlib é preciso saber Python como deve ser.
Existe uma publicação disponível no numist para isso em (está publicação também passa pela
matplotlib):
http://numist.ist.utl.pt/index.php?action=media;sa=item;in=15
De qualquer das maneiras para fazer gráficos simples as instruções que vos dei nos capítulos
anteriores servem perfeitamente. Se quiserem continuar a trabalhar no matplolib para além
do que aprenderam aqui podem tirar ideias da galeria que eles têm no site deles:
http://matplotlib.sourceforge.net/gallery.html
Se carregarem nas imagens vão dar ao código que deu origem aquela imagem. Alguns
exemplos do que se pode fazer estão nas imagens seguintes:
O software SciPlot (que nunca chegou a ser terminado) foi largamente baseado nesta
biblioteca para fazer os seus gráficos e existe uma versão para download gratuito do mesmo
no numist no link:
http://numist.ist.utl.pt/index.php?action=media;sa=item;in=11
De resto espero que esta pequena sebenta sirva para melhorar em muito a publicação de
trabalhos e teses no mundo dos estudantes (e profissionais também) que há para ai.
Grande abraço,
Pedro Correia
20