Mostrando postagens com marcador Matplotlib. Mostrar todas as postagens
Mostrando postagens com marcador Matplotlib. Mostrar todas as postagens

segunda-feira, 11 de maio de 2020

Definindo a faixo dos eixos

Definindo a faixo dos eixos

Por padrão a biblioteca matplotlib defini a faixo dos eixos x e y baseado no maior e menor valor dos dados. Por exemplo, se o maior valor que você quer representar no gráfico é nove e o menor é dois, o maior valor do eixo será o nove e o menor o dois. Nesse tutorial vamos aprender a definir esses valores por nossa conta.

Como definir a faixa dos eixos

Para definir a faixa dos eixos a biblioteca matplotlib nos fornece duas funções: xlim e ylim. Com essa funções podemos definir a faixa dos eixos do gráfico. Veja um exemplo de utilização dessas funções abaixo:

Exemplo
import numpy as np
import matplotlib.pyplot as plt

coordenadas = np.random.rand(100, 2)
plt.scatter(coordenadas[:,0], coordenadas[:,1])

plt.xlim(-.5, 1.5)
plt.ylim(-.5, 1.5)

plt.show()

Executando o código acima você deve ter um gráfico parecido com esse:

Como funciona…

O que acabamos de fazer nesse exemplo foi aumentar a área de visualização. Com as configurações padrão do matplotlib a área visíbil é apenas a área com dados. As funções xlim e ylim nos permitem alterar esse comportamento. Nesse exemplo definimos que a área visível do eixo x deve começar do valor menos zero ponto cinco e seguir até um ponto cinco. E a mesma coisa com o eixo y.

Eixos com a mesma escala

Eixos com a mesma escala

Você já deve ter percebido, nos nosso tutoriais passados, que a biblioteca matplotlib usa escalas diferentes para cada eixo do gráfico. Para algumas situações esse comportamento não causa problemas, mas para outros pode ser motivo de dor de cabeça. Para evitar isso vamos aprender como utilizar a mesma escala nos dois eixos do gráfico.

Como usar a mesma escala nos dois eixos

Para usar a mesma escala nos dois eixos precisamos definir isso no objeto axes. Veja um exemplo:

Exemplo
import numpy as np
import matplotlib.pyplot as plt

coordenadas = np.random.rand(100, 2)
plt.scatter(coordenadas[:,0], coordenadas[:,1])

plt.axes().set_aspect('equal')
plt.show()

Executando o exemplo acima o resultado deve ser parecido com esse:

Passando o valor ‘equal’ para o método set_aspect definimos que os eixos terão a mesma escala.

Figuras com Matplotlib

Figuras com Matplotlib

Introdução

Como você já deve ter percebido criar uma biblioteca de plotagem de dados que seja possível criar gráficos robustos e altamente personalizados não deve ter sido fácil. Mas para a nossa felicidade os colaboradores da biblioteca matplotlib conseguiram. Com a biblioteca é possível criar gráficos complexos com poucas linhas de código. E o mais impressionante, assim como é fácil criar um gráfico com poucas linhas, é fácil personalizar esses gráficos com a mesma facilidade. Nos próximo tutoriais aprenderemos como modificar os elementos das figuras, como o sistema de coordenadas usado.

Várias figuras juntas com matplotlib

A analise de dados só é possível com outros dados para comparar. Esses dados podem ser outros dados ou o mesmo dado representado de forma de diferente. Representar o mesmo dado de forma diferentes permite o analista ter um ponto de vista diferente. Isso permite chegar a conclusões que não seriam possíveis apenas com uma representação dos dados. Mas fazer essas representações em gráficos diferentes poderia trazer o inconveniente dos gráficos ficarem separados. Para solucionar isso a biblioteca matplotlib nos permite criar vários gráficos em apenas um.

Como criar vários gráficos em apenas um

Para criar vários gráficos em apenas um podemos usar o método subplot2grid. Com ele é possível criar gráficos independentes e apresentá-los numa única figura. Veja como fazer isso no exemplo abaixo:

Exemplo
import numpy as np
from matplotlib import pyplot as plt

barras = [5., 25., 50., 20.]
c_pontos = np.random.rand(100, 2)
sin_x = np.linspace(0, 2 * np.pi, 100)
sin_y = np.sin(sin_x)

grid_size = (4, 2)

plt.subplot2grid(grid_size, (0, 0), rowspan = 3, colspan = 1)
plt.bar(range(len(barras)), barras)

plt.subplot2grid(grid_size, (0, 1), rowspan = 3, colspan = 1)
plt.plot(sin_x, sin_y)

plt.subplot2grid(grid_size, (3, 0), rowspan = 1, colspan = 2)
plt.scatter(c_pontos[:,0], c_pontos[:,1])

plt.tight_layout()
plt.show()

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

Como funciona a função subplot2grid

O que fazemos com a função subplot2grid é dividir o gráfico em linhas e colunas. Assim desenhamos os nosso gráficos em forma de retângulo e adicionamos esses retângulos a grade criada pela função subplot2grid.

Veja os parâmetros da função subplot2grid:

  • O primeiro parâmetro é uma tupla com o número de linhas e colunas que a grade deve ter.
  • O segundo parâmetro é uma tupla com as coordenadas onde o gráfico deve ficar na grade.
  • O terceiro parâmetro define quantas linhas da grade o nosso gráfico deve ocupar.
  • O quarto define quantas colunas o gráfico deve ocupar da grade.

A próxima chamada a funções do módulo pyplot definira o tipo de gráfico que será renderizado. Para cada novo gráfico, que será adicionado a grade, a função subplot2grid deve ser chamada.
Nesse exemplo criamos uma grade com quatro linhas e duas colunas. As duas primeiras figuras ocupam três linhas e uma coluna cada. A terceira figura ocupa uma linha e duas colunas, preenchendo todo o espaço da grade. Depois de ocuparmos todo o espaço da grade chamamos a função tight_layout. Essa função compacta todas as figuras e impede que uma figura se sobreponha a outra.

domingo, 10 de maio de 2020

Mais rótulos com Matplotlib

Mais rótulos com Matplotlib

No último tutorial apenas começamos a aprender sobre rótulos dos marcadores. A biblioteca matplotlib nos fornece bem mais métodos e funções para adicionar e alterar os rótulos dos nossos gráfico.

Um jeito mais simples…

No exemplo do tutorial anterior criamos um gráfico de barras com um rótulo em cada barra. Mas existe um jeito mais simples de conseguir o mesmo resultado utilizando menos código:

Exemplo
import numpy as np
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))

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

Executando o código acima o seu gráfico deve esta parecido com este:

Como funciona…

Nesse exemplo não utilizamos os métodos do módulo ticker. Em vez disso utilizamos o método xticks. Esse método recebe dois argumentos. O primeiro é uma lista com a posição das legendas e o segundo é uma lista contendo os nomes que serão usados como rótulos nos marcadores. O resultado é o mesmo do tutorial passado. Com a diferença que é mais fácil de lembrar e mais curto para escrever.

Tem mais…

Até agora usamos uma lista de nomes predefinidos para criar os rótulos dos nossos marcadores. Uma tarefa fácil com poucos elementos, mas imagine com dezenas de elementos. Já não é uma tarefa tão fácil. Outro cenário é que você pode querer um gráfico com rótulos de porcentagem. Você pode fazer uma lista com as porcentagens correspondentes, mas existe um jeito melhor. Veja o exemplo abaixo:

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

def f_rotulo(value, pos):
  return '%0.1f%%' % (100. * value)

ax = plt.axes()
ax.xaxis.set_major_formatter(ticker.FuncFormatter(f_rotulo))
x = np.linspace(0, 1, 200)

plt.plot(x, np.exp(-10 * x), c = (0., .40, 1.))
plt.plot(x, np.exp(-5 * x), c = (.2, 1., .2), ls = '--')
plt.show()

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

Como funciona…

Criamos uma função que retorna uma string com a porcentagem do valor passado como argumento. E utilizamos a função FuncFormatter. Essa função recebe uma função como parâmetro e chama essa função, passando o valor e a posição do marcador como argumento, toda vez que a função precisar criar um rótulo. O valor retornado pela função f_rotulo é usado para nomear os marcadores.

Rótulos de escalas com Matplotlib

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.

Controlando as marcações do gráfico

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.

Mais formas com Matplotlib

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.

Adicionando formas ao gráfico

Adicionando formas ao gráfico

Em algumas situações precisamos adicionar formas ao gráfico. Essas formas podem ser usadas para criar figuras, como um logo de uma marca ou uma silhueta de um animal. Com a biblioteca matplotlib podemos criar formas a partir de primitivas, como as linhas que aprendemos a criar no tutorial anterior. Nesse tutorial vamos aprender a adicionar formas ao nosso gráfico.

Como criar formas com matplotlib

Com esse código vamos criar algumas formas geométricas simples, e a partir desse exemplo você será capais de criar diversas formas mais complexas:

Exemplo
import matplotlib.patches as patches
import matplotlib.pyplot as plt

cor = (0., .40, 1.)

# Circulo
forma = patches.Circle((0, 0), radius = 1., color = cor)
plt.gca().add_patch(forma)

# Retângulo
forma = patches.Rectangle((2.5, -.5), 2., 1., color = cor)
plt.gca().add_patch(forma)

# Elipse
forma = patches.Ellipse((0, -2.), 2., 1., color = cor)
plt.gca().add_patch(forma)

# caixa
forma = patches.FancyBboxPatch((2.5, -2.5), 2., 1., boxstyle = 'sawtooth', color = cor)
plt.gca().add_patch(forma)

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

Executando o código acima o gráfico deve apresentar quatro figuras igual a essas:

Como funciona…

Cada forma no gráfico foi criado com um método diferente. Dependendo da forma que se deseja criar um método especifico deve ser chamado com os parâmetros corretos. Por exemplo, para criar um circulo só precisamos passar dois parâmetros e para criar uma caixa precisamos passar quatro. Veja os parâmetros usados em cada método:
Circle: o método circle precisa de dois argumentos para desenhar um circulo. O primeiro parâmetro é uma tupla com as coordenadas do centro do circulo e o segundo é o raio do circulo.
Rectangle: o método Rectangle precisa de três argumentos. O primeiro é uma tupla com as coordenadas do canto superior esquerdo do retângulo. O segundo parâmetro é a largura do retângulo. E por fim, o terceiro define a altura do retângulo.
Ellipse: o método Ellipse recebe o mesmo número de parâmetros que o método Rectangle: uma tupla com as coordenas (diferente do método Rectangle, essas coordenadas são do centro da elipse), a largura da elipse e a altura. O método Ellipse também tem o parâmetro ‘angle’. Esse parâmetro define o ângulo de inclinação da elipse.
FancyBboxPatch: o método FancyBboxPatch cria um retângulo com as bordas personalizadas. Esse método recebe quatro parâmetros: as coordenadas do canto inferior esquerdo, a largura, a altura e o estilo das bordas do retângulo, respectivamente.
O parâmetro boxstyle pode receber os seguintes valores: 'larrow' , 'rarrow' , 'round' , 'round4' , 'roundtooth' , 'sawtooth' , ou 'square'.

Adicionando linhas com Matplotlib

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.

Adicionando um grid ao gráfico com Matplotlib

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.

Adicionando legendas ao gráfico com Matplotlib

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.

sábado, 9 de maio de 2020

Setas com Matplotlib

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.

quinta-feira, 7 de maio de 2020

Mais texto com Matplotlib

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).

Adicionando texto ao gráfico com Matplotlib

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.

Adicionando uma legenda para cada eixo

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.

Usando notações no estilo LaTeX com Matplotlib

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.

Adicionando título ao gráfico com Matplotlib

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.

quarta-feira, 6 de maio de 2020

Definindo esquema de cores com Matplotlib

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.