Gráficos em Python - Como ler arquivos, Definir tamanho dos eixos, Rótulos (labels), Cores, Tipos de linha e Legendas

 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.

Label como saída - StringVar

Neste tutorial de nosso Curso de Python, vamos aprender a usar a classe StringVar, que nos permite criar labels dinâmicas, que usaremos como saída de dados.

Python Progressivo em PDF: Apostila de Pyhon

Label como saída de dados dinâmica

Até o momento, em nossos estudos em programação gráfica, viemos usando as caixas de diálogo para exibir alguma informação, uma saída de dados, como uma simples string.

Porém, não é isso que ocorre na prática, não fica sempre pipocando janelinhas, até porque isso é chato. É normal que, você insira um dado, aperte um botão ou não, e automaticamente já apareça uma informação na janela mesmo, sem nenhuma nova janela surgindo.

É como se fosse uma espécie de label dinâmica. Inicialmente ela mostra:

Seu IMC é:

Então você informa seu peso e altura, e esse label se transforma;
Seu IMC é: 26, você está com sobrepeso

Essa mudança deve ocorrer simplesmente clicando em algum botão.

Vamos aprender como fazer isso?

Como usar StringVar

Vamos criar o seguinte programa:

Digitamos nosso nome, clicamos em Exibe e aparece o label embaixo: "Seu nome é: ..."

Esse programa é composto por três frames:

1. Frame de cima: tem o label "Digite seu nome" e o campo de entrada
2. Frame do meio: tem o label "Seu nome é:" e o label dinâmico (StringVar), que exibe o nome que o usuário digitou no campo de entrada
3. Frame de baixo: dois botões, o Exibe e o Sair

O primeiro e o último frame, bem como seus widgets internos, sabemos muito bem como criar e trabalhar com eles.

Vamos focar no frame do meio, que tem a label dinâmica.

O segredo aqui é criar um objeto do tipo StringVar(), vamos chamar de label_dinamica.
Ela que vai ficar 'pegando' o que é digitado no campo de entrada. Mas ela pega e passa pra outra label, a label3.

A label3 recebe um parâmetro chamado textvariable, que como o nome diz, vai receber um texto variável. Como argumento, passamos o nome do label dinâmica, que no nosso caso é label_dinamica.

O código fica assim:
self.label3 = Label(self.frame_meio, textvariable=self.label_dinamica)


Ou seja, essa linha de código quer dizer: crie uma label de nome label3, que vai ficar no frame_meio e o valor que ela vai exibir é um texto variável, que a label_dinamica vai ficar pegando).

Essa label dinâmica vai pegar o valor escrito na entrada, quando clicamos no botão Exibe.
Quando isso ocorre, esse botão chama o método exibe()

Dentro desse método, pegamos o valor que foi digitado e armazenamos na variável nome da seguinte maneira:
nome = self.entrada.get()

Agora, vamos passar essa variável para a label dinâmica, através do método set() que ela tem, que recebe uma string:
self.label_dinamica.set(nome)

Veja como fica nosso código Python:

from tkinter import *

class MinhaGUI:
 def __init__(self):
  # Cria janela principal
  self.janela_principal = Tk()
  
  # Cria três frames
  self.frame_cima = Frame(self.janela_principal)
  self.frame_meio = Frame(self.janela_principal)
  self.frame_baixo = Frame(self.janela_principal)
  
  # No frame de cima, um label e uma entry
  self.label1 = Label(self.frame_cima, text='Digite seu nome: ')
  self.entrada = Entry(self.frame_cima, width = 30)
  
  # Empacotando o label e entrada no primeiro frame
  self.label1.pack(side='left')
  self.entrada.pack(side='left')
  
  # Labels do frame do meio
  self.label2 = Label(self.frame_meio, text='Seu nome é:  ')
  self.label_dinamica = StringVar()
  self.label3 = Label(self.frame_meio, textvariable=self.label_dinamica)
  
  # Empacotando as labels do meio
  self.label2.pack(side='left')
  self.label3.pack(side='left')
  
  # Criando os botões
  self.botao = Button(self.frame_baixo, text='Exibe', command=self.exibe)
  self.botao_sair = Button(self.frame_baixo, text='Sair', command=self.janela_principal.quit)
  
  # Empacotando botões e label
  self.botao.pack(side='left')
  self.botao_sair.pack(side='left')
  
  # Empacotando os frames na janela principal
  self.frame_cima.pack()
  self.frame_meio.pack()
  self.frame_baixo.pack()
  
  # Rodando
  mainloop()
  
 def exibe(self):
   nome = self.entrada.get()
   self.label_dinamica.set(nome)
   
  
gui = MinhaGUI()

Rode ele! Leia linha por linha e tente entender tudo que está se passando aí.

Label em GUI - Exibindo um texto

Neste tutorial, vamos aprender a usar o widget do tipo Label, para exibir textos em interfaces gráficas em Python.

• Baixe nosso material e estudo offline onde e quando quiser: Apostila Python Progressivo

Como Exibir um Texto - Label

Agora que já estudamos um pouco de GUI e o módulo Tkinter do Python, vamos aprender a usar o widget mais simples e fácil de todos o Label, que serve para exibir um simples texto.

Para exibir um simples texto, vamos usar a função Label() do módulo tkinter.

O primeiro argumento tem que ser a janela (main_window, do tipo Tk() ) onde o label vai ficar e o segundo argumento é a variável text com a string que queremos exibir.

Vamos salvar esse Label na variável texto.
Depois, invocamos o método pack() da Label(), para posicionar e exibir o label na janela.
Por fim, chamamos a mainloop() para exibir nossa janela.

Nosso código fica:

import tkinter

class MinhaGUI:
 def __init__(self):
  # Criando a janela principal
  self.main_window = tkinter.Tk()
  
  # Criando um Label com o texto 'Curso Python Progressivo'
  self.texto = tkinter.Label(self.main_window, text='Curso Python Progressivo! ' )

  # Chamando o metodo pack() da função Label()
  self.texto.pack()

  # Fazer o Tkinter exibir o looping da janela
  tkinter.mainloop()

minha_gui = MinhaGUI()

O resultado é a janela com o rótulo (label):

O método pack() e o argumento side

Se você maximizar a janela que vai abrir, vai perceber que a linha de texto fica bem lá em cima, e no centro. Esse é o padrão, mas podemos mudar isso através do método pack() que recebe o argumento side com as seguintes opções:

1. side='left'
2. side='right'
3. side='bottom'
4. side='top'

Por exemplo, vamos criar um novo label na variável label2 e chamar de label1 a primeira, que exibimos a string 'Curso Python Progressivo!'

Vamos fazer com que label1 fique no topo e label2 fique sempre lá embaixo, basta usar o argumento side no método pack(), veja como fica o código:

import tkinter

class MinhaGUI:
 def __init__(self):
  # Criando a janela principal
  self.main_window = tkinter.Tk()
  
  # Criando os labels
  self.label1 = tkinter.Label(self.main_window, text='Curso Python Progressivo!' )
  self.label2 = tkinter.Label(self.main_window, text='www.pythonprogressivo.net' )

  # Exibindo os labels
  self.label1.pack(side='top')
  self.label2.pack(side='bottom')

  # Fazer o Tkinter exibir o looping da janela
  tkinter.mainloop()

minha_gui = MinhaGUI()

E o resultado:

Note que você pode maximizar, diminuir ou aumentar a janela, mas o label1 fica sempre lá em cima e o label2 fica sempre lá embaixo, quem 'cuida' disso é o método pack().

Bacana, não é?

A Função Label() e seus Parâmetros

Existem outros parâmetros para passarmos para a função Label além da janela principal o text com a string a ser exibida.

Por exemplo, o parâmetro bg recebe a cor de background (plano de fundo).
O parâmetro fg, recebe a cor da fonte.

O seguinte código:

import tkinter

class MinhaGUI:
 def __init__(self):
  # Criando a janela principal
  self.main_window = tkinter.Tk()
  
  # Criando a label Ceará e exibindo
  self.label = tkinter.Label(self.main_window, text="Ceará", bg="black", fg="white")
  self.label.pack(fill = tkinter.X)
  
  # Criando a label Flamengo e exibindo
  self.label = tkinter.Label(self.main_window, text="Flamengo", bg="red", fg="black")
  self.label.pack(fill = tkinter.X)
  
  # Criando a label Palmeiras e exibindo
  self.label = tkinter.Label(self.main_window, text="Palmeiras", bg="green", fg="black")
  self.label.pack(fill = tkinter.X)

  # Fazer o Tkinter exibir o looping da janela
  tkinter.mainloop()

minha_gui = MinhaGUI()

Tem o seguinte resultado:

O parâmetro fill é de preenchimento, usamos tkinter.X para expandir (expand) e ocupar toda a tela.
Entenderam a lógica da coisa?

Cria uma janela (main_window ou qualquer nome que queira), é uma instância de Tk()
Cria os label com a função Label e depois exibe com a pack().
Por fim, chama a mainloop() pra a exibição continuar pra sempre, até você clicar em fechar.

Para exibir os labels lado a lado, usamos side='left' e para preencher verticalmente, usamos fill=tkinter.Y:

import tkinter

class MinhaGUI:
 def __init__(self):
  # Criando a janela principal
  self.main_window = tkinter.Tk()
  
  # Criando a label Ceará e exibindo
  self.label = tkinter.Label(self.main_window, text="Ceará", bg="black", fg="white")
  self.label.pack(fill = tkinter.Y, side='left')
  
  # Criando a label Flamengo e exibindo
  self.label = tkinter.Label(self.main_window, text="Flamengo", bg="red", fg="black")
  self.label.pack(fill = tkinter.Y, side='left')
  
  # Criando a label Palmeiras e exibindo
  self.label = tkinter.Label(self.main_window, text="Palmeiras", bg="green", fg="black")
  self.label.pack(fill = tkinter.Y, side='left')

  # Fazer o Tkinter exibir o looping da janela
  tkinter.mainloop()

minha_gui = MinhaGUI()

Resultado: