Rótulos de escalas com Matplotlib

No tutorial anterior aprendemos a adicionar uma vaga aos marcadores do eixo x. Nesse vamos aprender a adicionar legendas a esses marcadores. Imagine que você tem cinco colunas que representam a produção de cinco produtos durante o mês de maio. Sem algum texto ou legenda não tem como você adivinhar qual coluna representa determinado produto. Felizmente a biblioteca matplotlib nos fornece maneiras de adicionar legendas para cada marcação do gráfico. E é exatamente isso que vamos aprender nesse tutorial.

Como adicionar rótulos de escalas

Adicionar rótulos de escalas no gráfico com a biblioteca matplotlib é fácil como criar uma lista. Isso porque só o que precisamos é criar uma lista e passar essa lista para o método FixedFormatter.

Exemplo

import numpy as np
import matplotlib.ticker as ticker
import matplotlib.pyplot as plt

lista_nome = ('Milho', 'Trigo', 'Cevada', 'Centeio', 'Aveia')
safra = np.random.randint(0, 99, size = len(lista_nome))
posicao_lista = np.arange(len(lista_nome))

ax = plt.axes()
ax.xaxis.set_major_locator(ticker.FixedLocator((posicao_lista)))
ax.xaxis.set_major_formatter(ticker.FixedFormatter((lista_nome)))

plt.bar(posicao_lista, safra, color = '.75', align = 'center')
plt.show()

Executando o código acima o seu gráfico deve esta parecido com esse (lembre-se que os valores são escolhidos de forma aleatória):

Como funciona…

Primeiro criamos uma tupla com a lista de rótulos que serão usados no gráfico. Depois definimos a posição de cada elemento com o método ticker.FixedLocator. Assim garantimos que cada barra estará com um marcador ao centro. O método FixedFormatter adiciona os rótulos aos marcadores de acordo com a lista que recebeu.

Anterior Próximo

Read More

Controlando as marcações do gráfico

Em todos os gráfico que fizemos até agora é possível notar algumas pequenas marcações nos eixos x e y. Essas marcações podem ter diversas funções, isso dependo do seu objetivo. É possível que em algum momento você precise alterar esse espaçamento. Até esse momento deixamos a biblioteca matplotlib definir o espaçamento entre essas marcações. Nesse tutorial vamos aprender como modificar esses espaçamentos.

Como alterar as marcações do eixo x

No exemplo abaixo vamos alterar o espaço entre as marcações do eixo x:

Exemplo

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

x = np.linspace(-15, 15, 1024)
y = np.sinc(x)
ax = plt.axes()

ax.xaxis.set_major_locator(ticker.MultipleLocator(5))
ax.xaxis.set_minor_locator(ticker.MultipleLocator(1))

plt.plot(x, y, c = 'k')
plt.show()

Executando o exemplo acima o resultado deve ser um gráfico igual a este:

Como funciona…

Nesse exemplo definimos que a biblioteca matplotlib deve adicionar cinco marcações para cinco pontos mais impostantes do gráfico. E uma para cada marcação de menor importância. Para fazer isso criamos uma instância do objeto axes (Esse objeto controla os eixos do gráfico) e depois definimos uma instância para os marcadores de maior importância e os com menos importância.

Anterior Próximo

Read More

Mais formas com Matplotlib

No tutorial anterior usamos formas já definidas da biblioteca matplotlib. Em muitas situações apenas essas forma não serão suficientes para suprir as suas necessidades. Por isso que a biblioteca matplotlib nos permite criar formas completamente novas. Podemos criar essas novas formas usando polígonos. E é o que vamos aprender nesse tutorial.

Polígonos

Polígonos são figuras geométricas planas e fechadas formadas por segmentos de reta. Essas retas são formadas por pontos interligados. Veja como trabalhar com polígonos com matplotlib:

Exemplo

import numpy as np
import matplotlib.patches as patches
import matplotlib.pyplot as plt

heptagono = np.linspace(0, 2 * np.pi, 8)
pontos = np.vstack((np.cos(heptagono), np.sin(heptagono))).transpose()

plt.gca().add_patch(patches.Polygon(pontos, color = '.75'))
plt.grid(True)
plt.axis('scaled')
plt.show()

Executando o código acima você deve ter um gráfico com um heptágono igual a este:

Como funciona…

O método patches.Polygon recebe uma matriz com as coordenadas de cada ponto do polígono.

Tem mais…

Todas as formas possuem os atributos que já estudamos antes, como o estilo da linha, largura e cor. Veja um exemplo abaixo:

Exemplo

import numpy as np
import matplotlib.patches as patches
import matplotlib.pyplot as plt

heptagono = np.linspace(0, 2 * np.pi, 6)
pontos = np.vstack((np.cos(heptagono), np.sin(heptagono))).transpose()
plt.gca().add_patch(plt.Circle((0, 0), radius = 1., color = '.75'))
plt.gca().add_patch(plt.Polygon(pontos, closed = None, fill = None,
lw = 3., ls = 'dotted', edgecolor = 'k'))

plt.grid(True)
plt.axis('scaled')
plt.show()

Executando o código acima você deve ter um gráfico igual a este:

Como funciona…

Nesse exemplo criamos um polígono dentro de um circulo. No polígono tem dois parâmetros que devemos prestar atenção. São eles o fill e ls. Passando o valor none para o parâmetro fill definimos que o polígono não terá preenchimento. E com o parâmetro ls definimos o tipo da borda, no caso definimos que a borda será pontilhada.

Anterior Próximo

Read More

Adicionando linhas com Matplotlib

Até agora utilizamos elementos prontos da biblioteca matplotlib como os pontos, as curvas e os diagramas de caixa. Com esses elementos podemos representar muitos valores, mais não todos. É possível que em algum momento você precise de um elemento extra. Talvez um elemento simples, como a linha. Nesse tutorial vamos aprender a criar linhas com a biblioteca matplotlib.

Como criar linhas

Nesse exemplo vamos criar algumas linhas independentes:

Exemplo

import matplotlib.pyplot as plt

n_linhas = 16
for i in range(n_linhas):
  plt.gca().add_line(plt.Line2D((0, i), (n_linhas - i, 0)))

plt.grid(True)
plt.axis('scaled')
plt.show()

Executando código acima o gráfico apresentado deve ser igual a este:

Como funciona o método Line2D

Com esse código criamos 16 linhas independentes. O método tem dois parâmetros obrigatórios. Esses parâmetros são as coordenadas do início da linha e do fim. Note que cada parâmetro é uma tupla com as coordenadas x e y. O método Line2D também aceitas outros parâmetros que já estudamos em tutoriais anteriores, como é o caso do estilo, largura, e cor da linha.
O método Line2D cria um objeto Line2D mas não renderiza, isso é feito com o método plt.gca().add_line().
Utilizamos o método axis para garantir que o gráfico fique com uma figura uniforme.

Anterior Próximo

Read More

Adicionando um grid ao gráfico com Matplotlib

Em algumas situações é um pouco complicado descobrir as coordenadas exatas de um ponto no gráfico apenas olhando. O que você consegue é apenas um número ligeiramente próximo. Adicionando grid ao gráfico esse problema pode ser minimizado. Com um grid o gráfico vai ficar cheio de linhas na vertical e horizontal. Assim facilitando a obtenção de coordenadas mais precisas apenas olhando o gráfico.

Como adicionar um grid ao gráfico

A biblioteca matplotlib fornece a função grid para adicionarmos um grid ao gráfico. Com essa função é só passar o valor True e o gráfico será renderizado com uma grade.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

X = np.linspace(-4, 4, 1024)
Y = .25 * (X + 4.) * (X + 1.) * (X - 2.)

plt.plot(X, Y, c = (.40, 1.0, .21))
plt.grid(True)
plt.show()

Executando o código acima o gráfico deve apresentar um grid como esse:

Como funciona o método grid

Para adicionar uma grade ao gráfico com matplotlib é só chamar a função grid e passar o valor True. Mas a função grid tem alguns parâmetros para alterar a aparência da grade. Veja alguns deles:
color: com o parâmetro color definimos a cor da grade.
linestyle: com esse parâmetro definimos o estilo da grade.
linewidth: esse parâmetro define a largura das linhas do grid.

Anterior Próximo

Read More

Adicionando legendas ao gráfico com Matplotlib

Já aprendemos como adicionar texto no gráfico. E esses textos podem servir como legendas, mas adicionar legenda desse jeito não é o recomendado. Além de que existe um método melhor de adicionar legendas ao gráfico com a biblioteca matplotlib. E usando o jeito correto de adicionar legendas o gráfico ficara mais harmônico. Coisa que não aconteceria usando textos soltos no gráfico como legendas.

Como adicionar legendas ao gráfico

Para adicionar legendas no gráfico utilizamos o método legend. O método legend adiciona label no gráfico.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

X = np.linspace(0, 6, 1024)
Y1 = np.sin(X)
Y2 = np.cos(X)

plt.xlabel('X')
plt.ylabel('Y')
plt.plot(X, Y1, c = (.40, 1.0, .21), lw = 3., label = 'sin(X)')
plt.plot(X, Y2, c = (.0, .40, 1.0), lw = 3., ls = '--', label = 'cos(X)')
plt.legend()
plt.show()

Executando o código acima o seu gráfico deve ser igual a esse:

Como funciona…

Todos os métodos do objeto pyplot tem um parâmetro adicional para adicionarmos legendas. Nesse exemplo utilizamos esse parâmetro para adicionar uma legenda para cada linha do gráfico. E o método legend renderiza essas legendas no gráfico.

Tem mais no método legend

O método legend tem alguns parametros uteis para alterar a aparência das legendas. Veja alguns desse parâmetros:

• ‘loc’: o parâmetro loc define a localização da legenda. O valor padrão desse parâmetro é ‘best’. Assim a legenda será posicionada automaticamente na melhor posição. Outros valores aceito por esse parâmetro são: 'upper left' , 'lower left' , 'lower right' , 'right' , 'center left' , 'center right' , 'lower center' , 'upper center' , and 'center' .
• ‘shadow’: o parâmetro shadow define se a legenda terá uma sombra. O valor padrão é False. O parâmetro pode receber dois valores True ou False.
• ‘fancybox’: Esse parâmetro deixa a caixa da legenda arredondada se o valor passado for True. O valor padrão é False.
• ‘title’: Esse parâmetro define a string passada como argumento como o título da caixa de legendas.

Anterior Próximo

Read More

Setas com Matplotlib

Nos exemplos anteriores aprendemos a adicionar textos e caixas de textos. Colocar textos nos gráficos é muito útil para explicar um dado, uma parte dele ou chamar atenção para uma área do gráfico. Mas com a biblioteca matplotlib temos uma ferramenta mais apropriada para chamar atenção para uma área do gráfico. Essa ferramenta são as setas. Com setas apontando para uma região do gráfico, não tem como essa área passar despercebida. E nesse tutorial vamos aprender a adicionar setas no gráfico com a biblioteca matplotlib.

Como adicionar setas ao gráfico

Para adicionar setas ao gráfico utilizamos o método annotate. O método annotate nos permite criar alguns tipos de setas e adicionar no gráfico.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

X = np.linspace(-4, 4, 1024)
Y = .25 * (X + 4.) * (X + 1.) * (X - 2.)

plt.annotate('Vale',
      horizontalalignment = 'left',
      verticalalignment = 'bottom',
      xytext = (-1.5, 3.),
      xy = (0.75, -2.7),
      arrowprops = dict(facecolor = 'black', shrink = 0.05))

plt.plot(X, Y)
plt.show()

Executando o código acima o gráfico deve ficar igual a este:

Como funciona o parâmetro annotate

O parâmetro adiciona uma seta com uma legenda no gráfico. Para isso o método precisar receber alguns argumentos, como no exemplo acima. O primeiro argumento é uma string que será uma legenda da seta. O segundo argumento alinha a seta a esquerda do gráfico. O terceiro argumento alinha a seta para a parte de baixo. O quarto argumento recebe as coordenadas da legenda. O quinto argumento recebe as coordenadas da ponta da seta. E o ultimo argumento define a cor e o quanto a seta ficara afastada da legenda.

Anterior Próximo

Read More

Mais texto com Matplotlib

A biblioteca matplotlib nos permite fazer várias modificações no texto que queremos adicionar no gráfico. Além de definir a posição podemos definir o seu alinhamento e adicionar uma marcação no texto.

Alinhamento

O texto que será adicionado ao gráfico é limitado por uma caixa imaginaria. Utilizamos essa caixa para posicionar o texto no gráfico, em relação as coordenadas que passamos para o método text. Assim usamos o posicionamento horizontal e vertical para definir como o alinhamento será feito.
Essas são as opções de alinhamento vertical:

• 'center': Relativo ao centro da caixa imaginaria do texto.
• 'top': Relativo ao topo da caixa imaginaria do texto.
• 'bottom': Relativo a parte de baixo da caixa imaginaria do texto.
• 'baseline': Relativo a base do texto.

Opções de alinhamento horizontal:

• 'center': relativo ao centro da caixa de texto.
• 'left': relativo ao lado esquerdo da caixa de texto.
• 'rigth': relativo ao lado direito da caixa de texto.

Personalizando caixa de texto

Para personalizamos a caixa de texto utilizamos o parâmetro bbox. O parâmetro bbox recebe um dicionario com as configurações de aparência da caixa de texto.

Exemplo

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm

x = np.linspace(-4, 4, 1024)
y = .25 * (x + 4.) * (x + 1.) * (x - 2.)

box_setup = {
  'facecolor': '.75',
  'edgecolor': 'k',
  'boxstyle': 'round'
}

plt.text(0.5, -0.25, 'Vale', bbox=box_setup)
plt.scatter(x, y, c = x, cmap = cm.hot)
plt.show()

Executando o exemplo acima o resultado deve ser um gráfico igual a esse:

Como funciona…

O dicionário passado ao parâmetro bbox define as configurações de aparência da caixa de texto. Veja quais são os valores que o parâmetro aceita:
facecolor: define a cor de fundo usado na caixa de texto.
Edgecolor: define a cor que circunda a caixa de texto.
Boxstyle: define a aparência da caixa, se ela vai ser aredondada (round) ou quadrada (square).

Anterior Próximo

Read More

Adicionando texto ao gráfico com Matplotlib

Se você, por algum motivo, precisar colocar um texto dentro do gráfico você pode fazer isso sem muita complicação com a biblioteca matplotlib. Até aqui utilizamos legendas em lugares específicos como o título do gráfico e nos eixos x e y. Agora vamos aprender a colocar um texto em qualquer lugar do gráfico.

Como adicionar texto no gráfico

Para adicionar texto no gráfico com a biblioteca matplotlib utilizamos o método text.

Exemplo

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm

x = np.linspace(-4, 4, 1024)
y = .25 * (x + 4.) * (x + 1.) * (x - 2.)

plt.text(0.5, -0.25, 'Vale')
plt.scatter(x, y, c = x, cmap = cm.hot)
plt.show()

Executando o código acima o gráfico apresentado deve ser igual a esse:

Como funciona o método text

O método text recebe três argumentos. O primeiro argumento é a posição do eixo x do texto, o segundo argumento é a posição y e o terceiro é o texto que será adicionado no gráfico. Assim podemos adicionar qualquer texto em qualquer lugar do gráfico, apenas com o método text.

Anterior Próximo

Read More

Adicionando uma legenda para cada eixo

Com a biblioteca matplotlib podemos adicionar uma legenda para cada eixo. Isso é útil quando utilizamos dados que variam de acordo com duas variáveis. Como a variação de temperatura com o passar do tempo, o aumento da velocidade por hora, o aumento da pressão com a temperatura, entre outros dados. A biblioteca matplotlib nos permite a adição de legendas aos eixos do gráfico, para essas situações e outras situações, utilizando métodos.

Como adicionar legendas no gráfico com matplotlib

Para adicionar legendas aos eixos do gráfico utilizamos os métodos xlabel e ylabel.

Exemplo

import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

x = np.arange(100)

faixa_cor = np.linspace(0, 100, len(x))

plt.title('Temperatura/Horas')
plt.xlabel('Horas')
plt.ylabel('Temperatura')
plt.scatter(x, x, c = faixa_cor, cmap = cm.hot)
plt.show()

Executando o código acima o seu gráfico deve ser igual a esse:

Como funcionam os métodos xlabel e ylabel

O funcionamento dos dois métodos é bem simples. Para adicionar a legenda ‘Temperatura’ no eixo y passamos a string ‘Temperatura’ para o método ylabel. Com o método xlabel acontece a mesma coisa.

Anterior Próximo

Read More

Usando notações no estilo LaTeX com Matplotlib

No exemplo anterior, quando adicionamos um título ao gráfico, o título utilizado foi uma string simples. Utilizando o mesmo método não seria possível adicionar uma formula matemática. Mas e se quisermos utilizar uma formula matemática para o título? Nesse caso teremos que utilizar o LaTex com a biblioteca matplotlib para adicionar uma formula matemática como título do nosso gráfico.
Utilizar formulas matemáticas como títulos de gráficos é interessante para mostrar qual foi a formula matemática utilizada para criar uma curva no gráfico. Mas muitas vezes você não vai precisar criar um gráfico com um título de formula matemática a não ser num contesto cientifico. Mas é sempre bom saber como se faz no caso de uma necessidade.

Mãos a obra…

Para trabalhar com o estilo LaTeX precisamos ter o LaTeX instalado no nosso computador. O o LaTeX instalado a biblioteca matplotlib pode interpretar as notações no estilo LaTeX e apresentar a formula de forma correta. Para baixar e instalar o LaTeX no seu computador acesse: https://en.wikibooks.org/wiki/LaTeX/Installation.
Obs: É possível que você não precise instalar o LaTeX.

LaTeX

As formula, matemáticas no estilo LaTeX, são escritas utilizando uma mistura de comandos e texto e armazenadas em arquivos de texto sem formatação. Com esse arquivo o LaTeX interpreta as instruções e renderiza a formula matemática.

Como utilizar o LaTeX num gráfico com matplotlib

Vamos criar uma curva no gráfico utilizando uma formula matemática e mostrar qual foi a famula utilizada no título do gráfico.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

X = np.linspace(-4, 4, 1024)
Y = .25 * (X + 4.) * (X + 1.) * (X - 2.)

plt.title('$f(x)=\\frac{1}{4}(x+4)(x+1)(x-2)$')
plt.plot(X, Y, c = 'k')
plt.show()

Executando o código acima o seu gráfico deve ficar igual a esse:

Como funciona…

Como você pode ver no exemplo acima, não utilizamos um método novo para criar um título com uma formula matemática. A única diferença foi a string passada para o método title. Nessa string é possível perceber que a string começa e termina com um cifrão. Isso indica para a biblioteca matplotlib que essa string deve ser interpretada com o estilo LaTeX.
Uma coisa importante de se notar é que a linguagem LaTeX usa o caractere \ como caractere de escape, assim como a linguagem python. Nesses casos utilize duas barras invertidas.
Nesse exemplo usamos a linguagem LaTeX para criar um título, mas ela pode ser usada para criar qualquer tipo de texto como legendas, labels e títulos.

Anterior Próximo

Read More

Adicionando título ao gráfico com Matplotlib

Introdução

Uma pratica muito comum e útil é adicionar títulos e legendas no seu gráfico. Não adianta ter dados num gráfico se você não sabe o que eles estão representando. Um gráfico além de representar os dados da maneira mais fiel possível, ele precisa ser compreendível. Uma tarefa quase impossível quando tudo que se tem no gráfico são linhas, pontos ou marcadores. Daí a importância de adicionar legendas e títulos aos gráficos. Com isso uma pequena olhada no gráfico já será suficiente para compreender os seus dados, pelo menos nos gráficos mais simples.

Adicionando um título

Para o nosso primeiro exemplos vamos fazer algo simples: adicionar um título ao nosso gráfico. A biblioteca matplotlib fornece um método para adicionarmos um título ao nosso gráfico de forma muito simples e rápida.

Como adicionar um título ao gráfico

Um título de um gráfico pode ser adicionado passando o título desejado para o método title.

Exemplo

import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

x = np.random.randn(50, 1)
y = np.random.randn(50, 1)
faixa_cor = np.linspace(0, 8 * 2 * np.pi, 50)

plt.title('Meu título')
plt.scatter(y, x, c = faixa_cor, cmap = cm.viridis)
plt.show()

Executando o código acima o seu gráfico deve parecer com esse:

Como funciona o método title

O funcionamento do método title é muito simples. O recebe uma string e essa string passada para o método será o título do gráfico. Como no exemplo acima: passamos a string ‘Meu título’ e o título do gráfico é Meu título.

Anterior Próximo

Read More

Definindo esquema de cores com Matplotlib

O esquema de cores padrão da biblioteca matplotlib é o fundo branco com os elementos do gráfico em preto. Esse é o padrão para a maioria dos elementos. Quando um elemento, que pode representar vários dados, é renderizado a biblioteca adiciona mais cores. E já aprendemos como mudar as cores desses elementos. Para a maioria das situações esse esquema de cores padrão da biblioteca já esta pronto para ser impresso. Mas e se você quiser que o fundo do gráfico fique na cor preta e os outros elementos que compõem o gráfico na cor branco? Isso é o que vamos aprender agora.

Como mudar o esquema de cores de um gráfico

Como já vimos antes a biblioteca matplotlib nos permite alterar a cor das linhas, dos pontos e dos diagramas de caixa. É possível alterar a cor dos elementos do gráfico um por um. Mas isso seria demorado. E existe um jeito mais rápido de fazer isso. A biblioteca matplotlib nos fornece um jeito de fazer isso mais facilmente, já que todos os objetos da biblioteca escolhem uma cor de um objeto centralizado.
Nesse exemplo vamos utilizar as configurações centralizadas da biblioteca matplotlib para criar um gráfico com o fundo preto:

Exemplo

import numpy as np
import matplotlib as mpl
from matplotlib import pyplot as plt

mpl.rcParams['lines.linewidth'] = 2
mpl.rcParams['axes.facecolor'] = 'k'
mpl.rcParams['axes.edgecolor'] = 'w'
mpl.rcParams['xtick.color'] = 'w'
mpl.rcParams['ytick.color'] = 'w'
mpl.rcParams['figure.facecolor'] = 'k'

X = np.linspace(0, 7, 1024)
plt.plot(X, np.sin(X))
plt.plot(X, np.cos(X))
plt.show()

Executando exemplo acima o gráfico mostrado deve ser igual a esse:

Como funciona a centralização de configurações do matplotlib

O objeto rc funciona como um objeto centralizador de configurações. Todo objeto que vai ser desenhado no gráfico procura suas configurações padrão no objeto rc. Assim se os valores das propriedades cor e largura do objeto rc forem alterados, todos os outros elementos terão as mesma configurações por padrão.

Anterior Próximo

Read More

Crie seus próprios marcadores com Matplotlib

Na biblioteca matplotlib existem muitos marcadores que podem ser usados em diversas situações para representar um tipo de dado. Mas cada projeto tem suas necessidades e especificações. E não é raro você precisar de um marcador próprio para um projeto. Não sendo adequado os marcadores padrão da biblioteca. Como um projeto onde você precisa criar um marcador com a silhueta de um edifício, animal ou uma marca. Se esse é o seu caso não se preocupe pois a biblioteca matplotlib nos permite criar nossos próprios marcadores.

Como criar marcadores com a biblioteca matplotlib

A criação de um marcador segue a mesma logica da criação de um gráfico com pontos interligados. Para criar um gráfico precisamos das coordenadas de cada nó do gráfico. Quando existe mais de um nó no gráfico uma linha é traçada de um ponto ao outro, e assim sucessivamente até o último ponto, criando um figura. Na criação de um marcador seguimos a mesma lógica. Criamos os nós com as coordenadas e no final temos um conjunto de pontos conectados que formam uma imagem.

Exemplo

import numpy as np
import matplotlib.path as mpath
from matplotlib import pyplot as plt

forma = [
  (0., -2., mpath.Path.MOVETO),
  (2., 0., mpath.Path.LINETO),
  (0., 2., mpath.Path.LINETO),
  (-2., 0., mpath.Path.LINETO),
  (0., -2., mpath.Path.CLOSEPOLY)
]

u, v, codes = zip(*forma)
novo_marcador = mpath.Path(np.asarray((u, v)).T, codes)
dados = np.random.rand(8, 8)
plt.scatter(dados[:,0], dados[:, 1], color=(1., 0., .40), marker=novo_marcador, s=64)
plt.show()

Executando o código acima o seu gráfico deve parecer com esse:

Como funciona…

Nos exemplos anteriores passamos uma string para o parâmetro marker. Isso porque esses marcadores são marcadores predefinidos da biblioteca matplotlib. Assim só precisamos passar, como argumento do parâmetro, uma string correspondente a um marcador predefinido. Por isso só precisamos passar uma string. Mas o argumento do parâmetro marker também pode ser uma instância do Path.
O método path é o responsável por criar o nosso novo marcador. Esse método deve receber dois argumentos: as coordenadas de cada ponto da nossa figura e uma instrução. Para facilitar o entendimento criamos uma lista com as coordenadas e a instrução. Assim não precisamos ter duas listas separadas, uma com as coordenadas e outra com as instruções. Mais o método path não pode receber essa lista do jeito que está, as coordenadas e as instruções devem estar separadas. Por isso usamos a função zip, que faz esse trabalho para nos.
O nosso marcador toma forma com o movimento do curso entre os pontos. Para o cursor saber o que esta fazendo ele precisa de instruções. Esse curso pode receber essas três instruções:

• MOVETO: Com essa instrução o cursor é posicionado na coordenada informada, mas nenhuma linha é desenhada.
• LINETO: Com essa instrução o curso é posicionado em outra posição. E dessa vez uma linha é traçada.
• CLOSEPOLY: Com essa instrução fechamos o nosso polígono/marcador.

Com isso podemos criar um marcador com qualquer forma que desejamos. É só ter paciência e descrever as coordenadas da figura que se deseja utilizar como marcador. Outra alternativa é converter de um desenho SVG.

Anterior Próximo

Read More

Alterando tamanho do marcador com Matplotlib

Já vimos que podemos alterar a cor, a borda e a forma de um ponto usado num gráfico com a biblioteca matplotlib. Mas em alguns casos só essas alterações não serão suficientes para representar um dado de forma apropriada. Em alguns casos você precisa que o tamanho do ponto cresça de acordo com o valor do dado que o ponto está representando. Por isso a biblioteca matplotlib fornece formas de alterar o tamanho dos pontos.

Como alterar o tamanho dos marcadores

Assim como alteramos a cor, a barda e a forma de um marcador por um parâmetro especifico da função scatter, alterar o tamanho não é diferente. Fazemos essa alteração através de um parâmetro. O parâmetro em questão é o s.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

a = np.random.randn(100, 2)
b = np.random.randn(100, 2)

plt.scatter(a[:,0], a[:, 1], color='.75', marker='x', s=80.)
plt.scatter(b[:,0], b[:, 1], color='.25', marker='^', s=20.)
plt.show()

Executando o exemplo acima o resultado deve ser parecido com esse gráfico:

Como funciona o para metro s

Nesse exemplo mostramos dois conjuntos de dados, cada um representado por um marcador de tamanho diferente. O tamanho é do marcador é definido pelo valor passado ao parâmetro s.
O valor passado ao parâmetro s define o tamanho da área do marcador e não o seu raio. Assim os tamanhos são as áreas reais da superfície e não os raios, eles seguem uma progressão quadrática (os marcadores quatro vezes maior terão raios duas vezes maior).

Anterior Próximo

Read More

Marcadores com Matplotlib

Nos exemplos anteriores, criamos gráficos com pontos sem muitas alterações, apenas alteramos as cores e, em alguns casos, adicionamos uma borda. Mas a biblioteca matplotlib fornece mais opções para alterar a aparência de um ponto, criando um gráfico com maior variedade visual. Assim podemos representar mais dados sem precisar recorrer a mudar a cor do ponto, utilizando outros marcadores além deste.

Mãos a obra…

A biblioteca matplotlib nos permiti especificar o marcador que será usado de várias formas. Veja algumas formas abaixo:
Marcadores predefinidos: Esses marcadores são definidos pela própria biblioteca. Podemos usar esses marcadores passando um número entre zero e oito ou passando uma string.
Lista de vértices: Com essa lista de valores par, passamos as coordenadas do caminho das formas que queremos utilizar.

Como usamos marcadores na função scatter

Para alterar o marcador utilizado pela função scatter podemos usar o parâmetro marker. O parâmetro marker pode receber marcadores predefinidos, lista de vértices ou um marcador definido por você. Vamos ver o funcionamento do parâmetro marker:

Exemplo

import numpy as np
import matplotlib.pyplot as plt

a = np.random.randn(100, 2)
b = np.random.randn(100, 2)

plt.scatter(a[:,0], a[:, 1], color=(0.0, .40, 1.0), marker='x')
plt.scatter(b[:,0], b[:, 1], color=(.40, 1.0, .21), marker='^')
plt.show()

Executando o exemplo acima você deve ver um gráfico parecido com esse:

Como funciona o parâmetro marker

Nesse exemplo, passamos para o parâmetro marker uma string com o marcador desejado. Note que chamamos a função scatter duas vezes, isso porque o parâmetro marker não aceita uma lista com marcadores, assim como faz o parâmetro color com as cores. Para cada marcador novo, precisamos chamar a função novamente. Por isso não podemos fazer uma única chamada da função.

Anterior Próximo

Read More

Estilo de preenchimento com Matplotlib

Se por algum motivo você precisar criar um gráfico de barras com a mesma cor, você vai precisar usar algum artificio para conseguir distinguir de um dado do outro. E um bom modo de fazer isso é preencher a barra com um padrão. Assim, mesmo que as cores sejam idênticas, ainda será possível distinguir uma barra da outra.

Como preencher uma barra com um padrão

Para preencher uma barra com algum padrão, utilizamos o parâmetro hatch.

Exemplo

import numpy as np
import matplotlib.pyplot as plt

n_barras = 8
y1 = np.random.random(n_barras)
y2 = np.random.random(n_barras)
x = np.arange(n_barras)

plt.bar(x, y1, color = (.40, 1.0, .21), hatch = '.')
plt.bar(x, y1 + y2, bottom = y1, color = (.0, .40, 1.0), hatch = '*')
plt.show()

Executando o exemplo acima o resultado deve ser um gráfico parecido com este:

Como o parâmetro hatch funciona

O parâmetro hatch pode receber alguns valores. E de acordo com o valor passado ao parâmetro, a barra será preenchida com um padrão diferente. Veja alguns valores aceito pelo parâmetro hatch:

• /
• \
• |
• -
• +
• x
• o
• O
• .
• *

Para cada valor passado ao parâmetro hatch, existe um padrão de preenchimento. No nosso caso usamos o asterisco e o ponto. O que resultou no preenchimento com estrelas e pontos, respectivamente.
Se você precisar trocar a cor do padrão de preenchimento use o parâmetro edgecolor. O parâmetro edgecolor funciona como o parâmetro color, recebendo valores com três cores, quatro cores, nomes definidos e tons de cinza.

Anterior Próximo

Read More

Função bar com colormaps

Muitas funções da biblioteca matplotlib tem suporte ao uso de mapas de cores. Uma dessas funções e a função scatter (E outras que veremos nos próximos tutoriais). Infelizmente a função bar não possui suporte ao uso de colormaps. Mas isso não significa que não podemos usar um mapa de cores para definir as cores das barras da função bar.
A biblioteca matplotlid fornece funções para gerar uma lista de cores a partir de um colormap. E com essa lista de cores podemos passar para o parâmetro color da função. Assim, não é necessário que uma função tenha suporte ao uso de colormaps para podemos usar um colormap.

Como usar colormaps com a função bar

Assim como fizemos no exemplo anterior, vamos usar o módulo matplotlib.cm. Mas com uma diferença: vamos utilizar o objeto diretamente, em vez de permitir que uma função faça a renderização das cores automaticamente. Também vamos precisar importar o módulo matplotlib.colors. Esse módulo contêm funções para criação de cores e manipulação. Como veremos a seguir:

Exemplo

import numpy as np
import matplotlib.cm as cm
import matplotlib.colors as col
import matplotlib.pyplot as plt

dados = np.random.randint(99, size = 50)
mapa_cores = cm.ScalarMappable(col.Normalize(0, 99), cm.winter)
plt.bar(np.arange(len(dados)), dados, color = mapa_cores.to_rgba(dados))
plt.show()

Executando o código acima o resultado deve ser um gráfico com barras parecido com esse:

Como funciona…

Primeiro criamos uma matriz com cinquenta números aleatórios entre zero e noventa e nove. Depois criamos uma lista de cores escalar com as cores normalizadas do mapa de cores winter. Depois a função to_rgba converte a lista de valores para uma lista de cores. Desse jeito usamos um colormap na função bar, mesmo que a função não tenha suporte a colormaps.

Anterior Próximo

Read More

Função scatter com colormaps

Quando se trabalha com muitas cores num gráfico, um dos problemas é achar uma combinação de cores adequada. Outro problema é o trabalho que isso da. Escrever cada cor uma por uma é demorado. Para resolver esses dois problemas a biblioteca matplotlib colormaps (mapas de cores). Com um colormaps você não precisar se preocupar com a combinação de cores e nem de escrever uma por uma. Os mapas de cores fornecem cores de forma continua baseado numa cor ou em varias.

Como usar colormaps com a função scatter

O módulo matplotli.cm fornece muitos mapas de cores. Além disso esse módulo fornece funções para você criar o seu próprio mapa de core. Um coisa que não é muito usado,pelo menos por min. Já que os mapas de cores, que vem no módulo matplotlib.cm, são numerosos e servem para a maioria das necessidades.
Nos exemplos anteriores, com a função scatter, usamos o parâmetro color com uma lista de cores. Os colormaps funcionam como uma lista de cores, com a diferença que as cores seguem uma sequência lógica. E ao invés de usar o parâmetro color vamos usar o cmap.

Exemplo

import numpy as np
import matplotlib.cm as cm
import matplotlib.pyplot as plt

Numero_Cores = 50
angulo = np.linspace(0, 8 * 2 * np.pi, Numero_Cores)
raio = np.linspace(.5, 1., Numero_Cores)
x = raio * np.cos(angulo)
y = raio * np.sin(angulo)

plt.scatter(x, y, c = angulo, cmap = cm.viridis)
plt.show()

Executando o código acima o gráfico apresentado deve ser igual a esse:

Como funciona o parâmetro cmap

O parametro cmap recebe um mapa de cores. Isso define quais cores serão usadas. E o parâmetro c define o número de cores que será usado.
Nesse exemplo, usamos o mapa de cor viridis. Que é um mapa de cores que vai do roxo ao amarelo. Com o parâmetro c definimos que nosso gráfico vai ter cinquenta cores do mapa de cores viridis. Em todos os mapas de cores o espaçamento entre as cores é uniforme. Assim as cores vão aumentando da cor com o menor valor para a maior (no nosso caso, do roxo para o amarelo).

Anterior Próximo

Read More