Neste tutorial de nosso curso de Programação Científica em Python, vamos continuar aprendendo como gerar gráficos em Python usando o módulo Pyplot da biblioteca Matplotlib, ferramentas nativas, gratuitas, flexíveis e extremamente poderosas da linguagem Python.
No tutorial anterior, aprendemos como plotar gráficos simples em Python, usando a função plot(). Agora, vamos aprender mais algumas técnicas e possibilidades, para incrementar nossas figuras.
Como gerar gráficos a partir de arquivos: loadtxt()
Nos exemplos do tutorial anterior, usamos apenas alguns poucos dados, mas o comum em Ciência de Dados é usar centenas, milhares e até milhões de informações, tanto para gerar gráficos como para encontrar padrões.
No exemplo a seguir, vamos usar a função loadtxt(), do NumPy, ideal para ler dados de arquivos txt de uma maneira bem simples. Basicamente, essa função recebe uma string com o endereço do arquivo de texto e o tipo de dado que queremos usar para gerar o array.
Baixe esse arquivo itub.txt e salve na mesma pasta do seu script em Python:
https://github.com/jarlissonmoreira/PythonProgressivo
Esse arquivo tem 250 colunas e duas colunas, representando os últimos 250 preços de fechamento da ação do Itaú (ITUB3), na bolsa de valores, que é minha ação favorita para receber dividendos.
Nosso código fica assim:
import matplotlib.pyplot as plt
import numpy as np
dados = np.loadtxt("itub.txt", float)
x = dados[:, 0]
y = dados[:, 1]
plt.plot(x,y)
A função loadtxt() colocou esses dados em uma matriz 250 x 2.
Usamos nosso conhecimento de slicing de arrays para pegar a coluna 1 da matriz e usar como eixo x, e a coluna 2 como eixo y, para enfim usar a função plot() para gerar o gráfico de cotações:
Definindo os limites dos eixos X e Y: xlim() e ylim()
Veja que, em todos nossos gráficos, o Python automaticamente definiu a faixa de valores que é exibida nos eixos X e Y, de maneira automática.
Porém, como tudo na programação, isso é ajustável. E para tal, vamos usar as funções xlim() e ylim(), do módulo Pyplot.
Vamos gerar um gráfico da função 2*cosseno, no intervalo de 0 até 2pi, e deixar o Pyplot setar automaticamente os valores dos eixos:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 1000)
y = 2 * np.cos(x)
plt.plot(x,y)
Agora vamos definir o eixo x de 0 até 4pi e o eixo y de -2.5 até 2.5, veja como fica o código:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 1000)
y = 2 * np.cos(x)
plt.xlim(0, 4*np.pi)
plt.ylim(-2.5, 2.5)
plt.plot(x,y)
E o gráfico, como ficou mais 'de longe', pois os eixos agora são maiores:
Ou seja, basta fornecer o intervalo de valores nas funções xlim() e ylim()
Rótulos (labels) dos eixos: xlabel() e ylabel()
Se você olhar bem, todos os gráficos em livros, artigos científicos e até na internet, possuem descrições sobre o que representa cada eixo.
São os rótulos, ou labels, e basta usarmos as funções xlabel() e ylabel() do Pyplot, fornecendo a string que você quer que seja exibida nos respectivos eixos.
Veja como fica nosso código do gráfico do cosseno:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 1000)
y = 2 * np.cos(x)
plt.xlim(0, 4*np.pi)
plt.ylim(-2.5, 2.5)
plt.xlabel("Ângulo x, em radianos")
plt.ylabel("2*cos(x)")
plt.plot(x,y)
plt.show()
Nosso gráfico ficou:
É sempre interessante você colocar o que é cada eixo, bem como as respectivas unidades que foi utilizado.
Plotando dois gráficos numa mesma imagem
Também é comum plotarmos duas ou mais funções em um mesmo gráfico, algo que é particularmente útil principalmente para compararmos valores, funções e padrões.
Por exemplo, no código abaixo, vamos plotar as funções seno e cosseno, com valores de x indo de 0 até 10pi:
import matplotlib.pyplot as plt
import numpy as np
x1 = np.linspace(0, 10*np.pi, 1000)
x2 = np.linspace(0, 10*np.pi, 1000)
y1 = np.cos(x1)
y2 = np.sin(x2)
plt.xlim(0, 10*np.pi)
plt.ylim(-1.5, 1.5)
plt.xlabel("Ângulo x, em radianos")
plt.ylabel("cos(x) (azul) e sen(x) (em laranja)")
plt.plot(x1,y1)
plt.plot(x2,y2)
plt.show()
Vejamos o resultado:
Note que o Pyplot colocou, automaticamente, cada gráfico de uma função com uma cor diferente.
Como alterar Cores e Tipos de linhas dos gráficos
No exemplo anterior, vimos que os gráficos ficaram com as cores azul e laranja. Isso também pode ser alterado conforme seu gosto.
Se desejar que seu gráfico seja vermelho, fornece um argumento adicional na função plot(), com as string 'red' ou 'r': plot(x, y, 'r')
Se desejar que a linha seja pontilhada, ao invés de contínua, forneça a string '--':
plot(x, y, '--')
E se quiser que ela seja vermelha e pontilhada? Simples, use: 'r--'
Veja:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-2*np.pi, 2*np.pi, 1000)
y = np.tan(x)
plt.ylim(-2, 2)
plt.xlabel("x, em rad")
plt.ylabel("$tg(x)$")
plt.grid()
plt.plot(x,y, 'r--')
plt.show()
Veja como ficou o gráfico:
Note que usamos a função grid() do Pyplot, para exibir as 'grades' (quadriculado).
As cores principais podem ser:
- b : blue
- g : green
- r : red
- c : cyan
- m : magenta
- y : yellow
- k : black
- w : white
Já os estilos de linha são:
Você pode fornecer esses argumento da seguinte maneira: color = 'green', linestyle='dotted'
Veja como ficou o código e gráfico:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-2*np.pi, 2*np.pi, 1000)
y = np.tan(x)
plt.ylim(-2, 2)
plt.xlabel("x, em rad")
plt.ylabel("$tg(x)$")
plt.grid()
plt.plot(x,y, color='green', linestyle='dotted')
plt.show()
Outras possibilidades são alterar o tamanho das fontes, espessura das linhas, marcadores e estilos etc, veja:
https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html
Legendas dos gráficos: legend()
Muitas vezes é interessante fornecer informações sobre os gráficos não apenas nos eixos (labels), mas diretamente dentro do plot.
É especialmente útil quando plotamos várias funções em um imagem só. Para especificar cada gráfico do plot, colocamos o argumento label dentro de cada plot(), com a string que queremos exibir. Depois, chamamos a função legend() do pyplot:
import matplotlib.pyplot as plt
import numpy as np
x1 = np.linspace(0, 10, 11)
x2 = np.linspace(0, 5, 11)
y1 = x1
y2 = x2**2
plt.plot(x1,y1, label='Função linear y=x')
plt.plot(x2,y2, label='Função quadrática y=x²')
plt.legend()
plt.show()
Veja o resultado:
Você pode inclusive definir onde quer que essas legendas apareçam. Por exemplo, para aparecer embaixo (lower) e no centro (center), basta colocar essas informações no argumento 'loc' da função legend():
import matplotlib.pyplot as plt
import numpy as np
x1 = np.linspace(0, 10, 11)
x2 = np.linspace(0, 5, 11)
y1 = x1
y2 = x2**2
plt.plot(x1,y1)
plt.plot(x2,y2)
plt.legend(['Função linear y=x', 'Função quadrática y=x²'], loc='lower center')
plt.show()
Veja não usamos os argumentos label dentro das funções plot(). Ao invés disso, passamos uma lista com as strings, uma para cada plot, diretamente na função legend, e em seguida usamos o loc para dar a localização desejada da legenda.
Para ver mais variações e possibilidades, acesse:
https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html
Exercício de programação científica
Mostramos exemplos de gráficos seno, cosseno e tangente. Porém, o NumPy não tem, nativamente, as funções secante, cossecante e cotagente. Ou seja, você vai ter que implementar elas. Lembra das aulas de trigonometria?
Gere um gráfico, com intervalo de -2pi até +2pi, plotando essas três funções, com as cores vermelhas, verde e azul, respectivamente.
