2 - Gráficos básicos

O enredo básico possui poucos elementos, vamos entendê-los melhor, adicionando elementos diferentes para o enredo, visando proporcionar novos efeitos que permitam uma melhor interpretação das informações representadas no gráfico.

Os elementos que podem ser adicionados ao gráfico incluem título, rótulo de x, rótulo de y, limites de x, limites de y, entre outros.

• Adicione o título usando plt.title()
• Adicione o rótulo de x usando plt.xlabel()
• Adicione o rótulo de y usando plt.ylabel()
• Defina os limites de x usando plt.xlim()
• Defina os limites de y usando plt.ylim()
• Adicione a legenda usando plt.legend()

Exemplo: defina elementos diferentes para o gráfico.

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0,50,100)
y = x * np.linspace(100,200,100)
plt.plot(x,y)
plt.title("Plot Básico")
plt.xlabel("Coordenadas x")
plt.ylabel("Coordenadas y")
plt.xlim(0,60)
plt.ylim(0,15000)
plt.show()

Podemos adicionar elementos ao gráfico, como cor, marcadores, personalização de linha.

Exemplo: gráfico de linha com cor, estilo tracejado de linha e com largura da linha de 8 pixels.

import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,50,100)
y = x * np.linspace(100,200,100)
plt.plot(x, y, c = 'r', linestyle = '--', linewidth = 8)
plt.show()

Exemplo: plote o gráfico com o marcador "*" da circunferência com tamanho 10 e cor verde.

import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,50,20)
y = x * np.linspace(100,200,20)
plt.plot(x, y, marker='*', markersize=30, c="g")
plt.show()

exemplo: adicione a grade usando o método grid().

import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0,50,20)
y = x * np.linspace(100,200,20)
plt.plot (x, y, marker='*', markersize=30, c="g")
plt.grid(True)
plt.legend()
plt.show()

As plotagens têm 3 características para personalização: linhas, marcadores e cores.

As linhas podem ser sólidas, pontilhadas, tracejadas ou tracejadas/pontilhadas.

Cores são representadas por nomes, letras, formatos hexadecimais ou valor RGB.

Os marcadores podem ter estilo de círculo, estrela, triângulo, traço, cruz etc.

Pode haver algumas situações em que o usuário pode ter que mostrar vários gráficos em uma única figura para fins de comparação.

Por exemplo, um varejista deseja saber a tendência de vendas de duas lojas nos últimos 12 meses e gostaria de ver a tendência das duas lojas na mesma figura.

Havendo mais de uma série utilizamos a legenda com os argumentos:

• loc: define a localização da legenda no gráfico
• label: define o rótulo da linha na legenda.

Exemplo: traçe duas linhas sin(x) e cos(x) com números aleatórios em uma única figura e adicione a legenda para distinguir as linhas.

import matplotlib.pyplot as plt
import numpy as np
x= np.arange(0,1500,100)
plt.plot(np.sin(x),label = 'função sin x')
plt.plot(np.cos(x),label = 'função cos x')
plt.legend(loc='upper right')
plt.show()

Para plotar vários gráficos em sequência com figuras separadas, em vez de serem sobrepostos em uma única figura, chame a função plt.show() antes de plotar o próximo gráfico.

Exemplo: gráficos separados com o método plt.show() entre as plotagens.

import matplotlib.pyplot as plt
import numpy as np
x= np.linspace(0,100,50)
plt.plot(x,'r',label='x simples')
plt.show() # mostra o gráfico evitando a sobreposição de plotagens
plt.plot(x*x,'g',label='x duplo')
plt.show()
plt.legend(loc='upper right')

Pode haver algumas situações em que precisamos plotar vários gráficos menores juntos formando o enredo completo, com número variado de linhas e colunas de plotagens.

Isso pode ser realizado com o uso de subplotagens, usando a função plt.subplots().

Por exemplo, uma loja de varejo tem 6 lojas e o gerente gostaria de ver as vendas diárias de todas as 6 lojas em uma única janela para comparar os gráficos.

Isso pode ser visualizado usando subplotagens representando os gráficos plotados em linhas e colunas.

Subplotagens são usadas para plotar vários gráficos em uma única figura.

Exemplo: gráfico com um único subplot usando o método plt.subplots() sem argumentos.

import matplotlib.pyplot as plt
import numpy as np
x = np.random.rand(50)
y = np.sin(x*2)

fig, eixo = plt.subplots()

eixo.plot(y)

plt.show()

Use como argumento da função o número necessário de subplotagens no gráficos.

Exemplo: gráfico com duas subplotagens empilhadas verticalmente:

import matplotlib.pyplot as plt
import numpy as np

fig, eixos = plt.subplots(2)
x=np.linspace(0,100,10) # dados

eixos[0].set_title('Título da subplotagem 1') # título
eixos[0].plot(x, np.sin(x**2)) # atribuição
eixos[1].set_title('Título da subplotagem 2') # título
eixos[1].plot(x, np.cos(x**2)) # atribuição

fig.suptitle('Título superior das subplotagens')

plt.subplots_adjust(left=0.1, bottom=0.1, right=0.97, top=0.85, wspace=0.2, hspace=0.3)

plt.show()

A função plt.subplots_adjust() é usada para ajustar as margens das subplotages na figura, onde os parâmetros são:]

• left: margem esquerda da figura
• right: margem direita da figura
• bottom: margem inferior da figura
• top: margem superior da figura
• wspace: largura do espaço entre as subplotagens
• hspace: altura do espaço entre as subplotagens

Declare a variável fig da matriz bidimensional instanciada com a função plt.subplot() com os argumentos para duas linhas e duas colunas de subplotagens verticais e horizontais, como no esquema abaixo:

Desempacote nas variáveis fig1, fig2, fig3 e fig4 os objetos das figuras das subplotagens, de acordo com o número de linhas e colunas usados como argumentos com o método plt.subplot().

import matplotlib.pyplot as plt
import numpy as np
fig, ((fig1, fig2), (fig3, fig4)) = plt.subplots(2, 2)
x = np.linspace(0,100,10) # dados
# adicione os dados aos gráficos
fig1.plot(x, x**2)
fig2.plot(x, x**3)
fig3.plot(x, np.sin(x**2))
fig4.plot(x, np.cos(x**2))
# adicionar título
fig.suptitle('Subplotagens horizontais')
plt.show()

Exemplo: outra maneira simples para criação de subplotagens, usando eixos contendo a tupla ((fig1,fig2),(fig3,fig4)) com os objetos das figuras.

import matplotlib.pyplot as plt
import numpy as np
fig, eixos = plt.subplots(2, 2)
x = np.linspace(0,100,10) # dados
# adicione os dados referentes a linha e coluna
eixos[0,0].plot(x, x**2         , 'g')
eixos[0,1].plot(x, x**3         , 'r')
eixos[1,0].plot(x, np.sin(x**2) , 'b')
eixos[1,1].plot(x, np.cos(x**2) , 'k')
# adicionar título
fig.suptitle("subplotagens com as coordenadas de matriz")
plt.show()

O Matplotlib é uma biblioteca orientada a objetos encapsulando propriedades e métodos.

Propriedades são as variáveis, e métodos são as funções, respectivamente, quando pertencem a um objeto.

Figure é a classe do objeto figure gerenciador de figuras de gráficos.

A figura do objeto é um recipiente para mostrar os gráficos e é instanciada com a chamada da função plt.figure().

O método plt.figure() cria e retorna um objeto figure vazio.

O objeto da figura tem parâmetros nomeados, sendo alguns dos principais:

• figsize: largura e altura da figura, em polegadas
• dpi: pontos por polegada (para ajuste da qualidade de impressão)
• facecolor: cor da face
• edgecolor: cor da borda
• linewidth: espessura da linha
• frameon: se a borda deve ser desenhada
• framecolor: cor da borda

Declare a variável fig com o objeto de figura.

Exemplo: diferentes gráficos alterando o tamanho da figura com 'figsize = (a,b)' onde a é a largura e b é a altura em polegadas.

O Pyplot do Matplotlib e o Numpy são importados com os nomes plt e np, respectivamente.

import matplotlib.pyplot as plt
import numpy as np

As séries x e y são criadas a partir do método np.array().

x = np.array([1,2,3,4,5,6,8,9,10])
y = x**2

Gráfico com tamanho quadrado

plt.figure(figsize=(4,4))
plt.xticks(())
plt.yticks(())
plt.plot(x,y)
plt.show()

Gráfico com tamanho retangular horizontal

plt.figure(figsize=(8,2))
plt.xticks(())
plt.yticks(())
plt.plot(x,y)
plt.show()

Gráfico com tamanho retangular vertical

plt.figure(figsize=(3,6))
plt.xticks(())
plt.yticks(())
plt.plot(x,y)
plt.show()

Exemplo: diferentes gráficos usando os parâmetros figsize, facecolor, edgecolor e linewidth e a função plt.subplots_adjust() para alterar as margens internas da figura.

Gráfico com tamanho quadrado

fig = plt.figure(figsize=(8,8), facecolor='y', edgecolor='r', linewidth=5)
plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9)
plt.plot(x,y)
plt.show()

Gráfico com tamanho retangular horizontal

fig = plt.figure(figsize=(10,3), facecolor='y', edgecolor='r', linewidth=5)
plt.subplots_adjust(left=0.1, bottom=0.1, right=0.97, top=0.85)
plt.xticks(())
plt.yticks(())
plt.plot(x,y)
plt.show()

Gráfico com tamanho retangular vertical

fig = plt.figure(figsize=(3,6), facecolor='y', edgecolor='r', linewidth=5)
plt.subplots_adjust(left=0.3, bottom=0.3, right=0.7, top=0.7)
plt.xticks(())
plt.yticks(())
plt.plot(x,y)
plt.show()

Eixos é a região do gráfico com dados, podemos adicionar os eixos à figura usando o método fig.add_axes().

Este método tem quatro parâmetros:

• left: posição dos eixos da esquerda da figura
• bottom: posição dos eixos da parte inferior da figura
• width: largura do gráfico
• height: altura do gráfico

Outros parâmetros que podem ser configurados com métodos ​​para o objeto de eixos são:

• eixo.set_title(): define o título
• eixo.set_xlabel(): Define o rótulo de x
• eixo.set_ylabel(): Define rótulo de y

Exemplo: adicione eixos usando o método add_subplot().

fig = plt.figure()
fig.add_subplot(241)
fig.add_subplot(242)
ax = fig.add_subplot(223)
ax.set_title("subplots")

plt.tight_layout()

plt.show()

Usando add_axes() para adicionar eixos à figura.

fig = plt.figure()
fig.add_subplot(241)
fig.add_subplot(242)
ax = fig.add_subplot(223)
ax.set_title("subplots")

plt.tight_layout()

fig.add_axes([0.77,.3,.2,.6])
ax2 =fig.add_axes([0.67,.5,.2,.3])
fig.add_axes([0.6,.1,.35,.3])
ax2.set_title("random axes")

plt.show()

Com duas séries em um mesmo eixo.

# amostra de dados

y  = [1,  5, 10, 15, 20,  30]
x1 = [1, 10, 20, 30, 45,  55]
x2 = [1, 32, 45, 80, 90, 122]

# crie a figura

fig = plt.figure()

# primeiro eixo

eixo1 = fig.add_axes([0.2,0.2,0.4,0.4])

eixo1.plot(x1,y,'ys-')  # amarelo quadrado sólido
eixo1.plot(x2,y,'go--') # verde círculo tracejado

# adicione parâmetros adicionais

eixo1.set_title("Adição de múltiplas linhas")
eixo1.set_xlabel("eixo x")
eixo1.set_ylabel("eixo y")
eixo1.legend(labels=("linha 1","Linha 2"),loc="lower right")

# segundo eixo

eixo2 = fig.add_axes([0.5,0.5,0.45,0.45])

eixo2.plot(x1,y,'ys-')  # amarelo quadrado sólido
eixo2.plot(x2,y,'go--') # verde círculo tracejado

# adicione parâmetros adicionais

eixo2.set_title("Adição de múltiplas linhas")
eixo2.set_xlabel("eixo x")
eixo2.set_ylabel("eixo y")
eixo2.legend(labels=("linha 1","Linha 2"),loc="lower right") 

plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.8)
plt.show()