Neste tutorial apresento mais uma biblioteca importante para visualização de dados em Python: a biblioteca Plotly, rica em recursos e de uso simplificado, mas poderoso.

O que é a biblioteca plotly em Python?

A Plotly é uma biblioteca em Python que permite criar visualizações interativas em diversos formatos, como gráficos de linhas, barras, dispersão, mapas, entre outros. Essa biblioteca oferece uma ampla gama de recursos para criação de gráficos, como ferramentas de zoom, arraste, seleção, exportação de imagens, entre outras.

Além disso, a Plotly é capaz de criar e exportar gráficos em diversos formatos de saída, incluindo HTML, PNG, PDF e SVG.

Uma das principais características da Plotly é a sua facilidade de uso. A biblioteca oferece uma API intuitiva e bem documentada que permite criar gráficos interativos de maneira rápida e fácil. Além disso, a Plotly é uma biblioteca bastante flexível e pode ser usada em conjunto com outras bibliotecas de visualização, como a Matplotlib e a Seaborn.

Outra vantagem da Plotly é a sua capacidade de compartilhar gráficos interativos online. A biblioteca possui um serviço online que permite publicar gráficos em nuvem, o que facilita o compartilhamento e a visualização dos gráficos em diferentes dispositivos e plataformas.

Em resumo, a Plotly é uma biblioteca de visualização de dados em Python que permite criar gráficos interativos e compartilháveis de maneira fácil e flexível.

Tutorial básico de plotly em Python

Exemplo: Vamos criar um gráfico de linhas contendo dados de seis meses de medições de temperaturas médias mensais em uma cidade.

1. Primeiramente, devemos instalar a biblioteca Plotly (se não estiver instalada ainda):

pip install plotly

2. Importamos as bibliotecas necessárias ao nosso projeto:

import plotly.graph_objs as go
import plotly.offline as pyo

A biblioteca plotly.graph_objs é responsável por definir os objetos que serão usados para criar gráficos com a biblioteca Plotly em Python. Esses objetos representam diferentes tipos de gráficos, como gráficos de linhas, barras, dispersão, pizza, entre outros. Além disso, esses objetos podem ser configurados para personalizar o estilo, as cores, as legendas, os eixos, os títulos e outras propriedades do gráfico.

Já a biblioteca plotly.offline fornece funções para criar e exibir gráficos Plotly no modo offline, ou seja, sem a necessidade de uma conexão com a internet. Essas funções permitem criar gráficos em notebooks Jupyter, em aplicativos de desktop, em serviços de nuvem e em outras plataformas, sem precisar fazer o upload dos dados ou do código para um servidor web.

Além disso, a biblioteca plotly.offline também permite salvar os gráficos como arquivos HTML, PNG, PDF ou SVG, para compartilhamento e visualização em diferentes dispositivos e plataformas.

3. Precisamos criar as listas com os dados mensais das temperaturas médias, para popular o gráfico que será gerado:

meses = ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho']
temperaturas = [25, 26, 27, 26, 24, 22]

4. Criamos um objeto trace do tipo “linha” para representar os dados:

trace = go.Scatter(x=meses, y=temperaturas, mode='lines')

O objeto Trace é uma estrutura de dados da biblioteca Plotly em Python que representa um conjunto de dados em um gráfico. Em outras palavras, ele é usado para definir o tipo de gráfico, as propriedades de estilo, as legendas, as cores e outras informações relacionadas aos dados que serão plotados.

Cada um desses objetos representa uma série de dados em um gráfico, como uma série de pontos em um gráfico de dispersão, uma série de barras em um gráfico de barras ou uma série de linhas em um gráfico de linhas.

A biblioteca Plotly possui vários tipos de objetos Trace pré-definidos, que podem ser usados para criar diferentes tipos de gráficos, como gráficos de linhas, gráficos de barras, gráficos de dispersão, gráficos de pizza, entre outros.

Cada objeto Trace é adicionado a um objeto Figure, que é o recipiente principal que armazena todos os objetos Trace e Layout do gráfico. Além disso, o objeto Trace também possui métodos que permitem personalizar ainda mais o estilo, as cores, as legendas e outras propriedades do gráfico.

5. Criamos agora um objeto data contendo o trace criado:

data = [trace]

O objeto data é uma outra estrutura de dados importante da biblioteca Plotly em Python, que representa uma lista de objetos Trace que contêm os dados do gráfico. É usado em conjunto com o objeto Layout para construir e personalizar gráficos interativos.

O objeto data contém uma lista de objetos Trace que especificam o tipo de gráfico, as propriedades de estilo, as legendas, as cores e outras informações relacionadas aos dados que serão plotados.

Cada objeto Trace representa uma série de dados em um gráfico, como uma série de pontos em um gráfico de dispersão, uma série de barras em um gráfico de barras ou uma série de linhas em um gráfico de linhas.

O objeto data é criado a partir de uma lista de objetos Trace, que podem ser criados manualmente ou por meio de funções específicas da biblioteca Plotly para diferentes tipos de gráficos. Depois de criar o objeto data, ele é adicionado ao objeto Figure junto com o objeto Layout para criar e personalizar o gráfico.

A manipulação do objeto data permite personalizar ainda mais o gráfico, como adicionar diferentes tipos de traços, alterar as cores, as legendas e outras propriedades específicas para cada tipo de gráfico.

6. Agora criamos um objeto layout com as configurações do gráfico:

layout = go.Layout(title='Temperaturas Médias Mensais', xaxis=dict(title='Meses'), yaxis=dict(title='Temperaturas (°C)'))

O objeto Layout é uma das principais estruturas de dados da biblioteca Plotly em Python, que representa um conjunto de propriedades que controlam o layout do gráfico, como o título, os rótulos dos eixos, a legenda e a fonte.

É usado em conjunto com o objeto data para construir e personalizar gráficos interativos. Ele é adicionado ao objeto Figure junto com o objeto data para criar e personalizar o gráfico.

Esse objeto possui muitas propriedades, incluindo:

• title: define o título do gráfico
• xaxis: define as propriedades do eixo x, como o título, a fonte e as unidades
• yaxis: define as propriedades do eixo y, como o título, a fonte e as unidades
• legend: define as propriedades da legenda, como a posição e a orientação
• font: define as propriedades da fonte, como o tamanho e a cor
• margin: define as margens do gráfico
• width: define a largura do gráfico em pixels
• height: define a altura do gráfico em pixels

O objeto Layout é criado a partir de um dicionário Python que contém as propriedades desejadas do gráfico. A manipulação do objeto Layout permite personalizar o gráfico de acordo com as necessidades específicas do usuário, como alterar o tamanho, a posição e a orientação dos rótulos dos eixos, a cor de fundo do gráfico e outras propriedades de layout.

7. Criamos também um objeto figure com os dados e o layout criados:

fig = go.Figure(data=data, layout=layout)

O objeto Figure é uma das principais estruturas de dados da biblioteca Plotly em Python. Ele é usado para criar e personalizar gráficos interativos, combinando diferentes objetos Trace e Layout da biblioteca plotly.graph_objs.

Em outras palavras, o objeto Figure é como um recipiente que armazena os dados e as configurações de um gráfico Plotly. Ele é criado a partir de uma lista de objetos Trace que representam os dados do gráfico, e um objeto Layout que define as propriedades de estilo, formatação, legendas, títulos, eixos, entre outras coisas.

Esse objeto também possui vários métodos que permitem personalizar ainda mais o gráfico, como a adição de anotações, textos, formas, imagens e outras informações adicionais.

Uma vez criado o objeto Figure, ele pode ser exibido em um ambiente de desenvolvimento, como um notebook Jupyter, ou salvo como um arquivo HTML, PNG, PDF ou SVG, para compartilhamento e visualização em diferentes dispositivos e plataformas.

8. Por fim, usamos a função plot da biblioteca plotly.offline para exibir o gráfico:

pyo.plot(fig, filename='grafico_temperaturas.html')

Pronto! O gráfico resultante exibirá as temperaturas médias mensais em uma cidade ao longo de seis meses, com os meses no eixo x e as temperaturas no eixo y. Ele será salvo como um arquivo HTML (no caso, de nome grafico_temperaturas.html) que pode ser compartilhado e visualizado em diferentes dispositivos e plataformas, e poderá ser aberto em um navegador qualquer, como o Google Chrome ou Mozilla Firefox para visualização.

Além disso, o gráfico será interativo, permitindo zoom, pan, seleção de dados e outras interações. Experimente redimensionar a janela do navegador para ver como o gráfico se comporta!

Código completo do exemplo

import plotly.graph_objs as go
import plotly.offline as pyo

meses = ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho']
temperaturas = [25, 26, 27, 26, 24, 22]

trace = go.Scatter(x=meses, y=temperaturas, mode='lines')
data = [trace]
layout = go.Layout(title='Temperaturas Médias Mensais', xaxis=dict(title='Meses'), yaxis=dict(title='Temperaturas (°C)'))
fig = go.Figure(data=data, layout=layout)

pyo.plot(fig, filename='grafico_temperaturas.html')

Gráfico resultante:

Gráfico básico gerado com a biblioteca Plotly em Python

É isso aí! Neste tutorial apresentei a biblioteca Plotly em Python, e mostrei como criar um gráfico de linhas simples, embutido em um arquivo HTML.

Nos próximos tutoriais vamos explorar mais a fundo os recursos dessa biblioteca.

Até!

Referências

• Documentação Oficial do Plotly

O post Como criar um gráfico básico com a biblioteca Plotly em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial de visualização de dados vou mostrar como criar um gráfico de colunas empilhadas na linguagem Python, usando o módulo matplotlib.

O que é um gráfico de colunas empilhadas?

Um gráfico de colunas empilhadas é um tipo de gráfico que exibe a distribuição proporcional de várias séries de dados em um eixo de tempo ou categoria. O gráfico consiste em uma pilha de colunas, onde cada coluna representa uma série de dados e cada seção empilhada na coluna representa a contribuição de cada categoria para essa série.

Em um gráfico de colunas empilhadas, as colunas são alinhadas uma sobre a outra e cada seção empilhada é colorida de acordo com uma chave de legenda para representar as diferentes séries de dados. A altura total da coluna representa o valor total de todas as séries de dados para uma determinada categoria ou período de tempo.

Esse tipo de gráfico é útil para comparar a contribuição de diferentes séries de dados em um período de tempo específico e também para comparar a tendência geral de cada série ao longo do tempo. No entanto, é importante ter cuidado ao interpretar os dados em um gráfico de colunas empilhadas, já que a altura total da coluna pode ser enganosa e a comparação entre as séries pode ser difícil quando uma série tem valores muito maiores do que as outras.

Segue abaixo um exemplo de código em Python utilizando a biblioteca Matplotlib para gerar um gráfico de colunas empilhadas de vendas de produtos em uma loja ao longo de um período de três meses:

Código

import matplotlib.pyplot as plt

meses = ['Jan', 'Fev', 'Mar']
produto1 = [1000, 1500, 1200]
produto2 = [800, 1200, 1500]
produto3 = [900, 1100, 1400]

plt.bar(meses, produto1, label='Produto 1', color='r')
plt.bar(meses, produto2, label='Produto 2', bottom=produto1, color='b')
plt.bar(meses, produto3, label='Produto 3', bottom=[sum(x) for x in zip(produto1, produto2)], color='g')

plt.ylabel('Vendas')
plt.title('Vendas por produto e mês')
plt.legend()
plt.show()

Resultado:

Gráfico de colunas empilhadas em Python com matplotlib

Funcionamento

O código gera um gráfico de colunas empilhadas para visualizar as vendas de três produtos em três meses diferentes.

Na primeira parte do código, são definidos os dados para o eixo x (meses) e para cada um dos três produtos (produto1, produto2 e produto3).

Em seguida, são utilizadas as funções plt.bar para criar cada uma das colunas empilhadas no gráfico.
A primeira chamada cria a coluna para o Produto 1, com a cor vermelha (color=’r’). A segunda chamada cria a coluna para o Produto 2, com a cor azul (color=’b’) e a opção bottom=produto1, que indica que essa coluna deve ser empilhada sobre a coluna do Produto 1.
A terceira chamada cria a coluna para o Produto 3, com a cor verde (color=’g’) e a opção bottom=[sum(x) for x in zip(produto1, produto2)], que indica que essa coluna deve ser empilhada sobre as colunas do Produto 1 e Produto 2.

Por fim, são adicionados os títulos dos eixos e o título do gráfico com as funções plt.ylabel, plt.title e plt.legend. E o gráfico é exibido na tela com a função plt.show.

O que faz a função zip()?

A função zip() em python é usada para agrupar iteráveis, como listas, em uma única estrutura de dados. Ela combina os elementos correspondentes dos iteráveis em tuplas, que podem ser acessadas posteriormente.

Por exemplo, se tivermos duas listas a = [1, 2, 3] e b = [4, 5, 6], podemos usar a função zip(a, b) para criar uma nova lista contendo tuplas de elementos correspondentes de a e b, ou seja, [(1, 4), (2, 5), (3, 6)].

No código apresentado, a função zip() é utilizada para combinar as listas produto1 e produto2 em uma única lista de tuplas, que é então utilizada como o argumento bottom na chamada da função plt.bar(). Isso faz com que as barras do segundo produto sejam empilhadas sobre as barras do primeiro produto. Em seguida, a mesma abordagem é usada para combinar as listas produto1, produto2 e produto3 em uma única lista de tuplas, que é utilizada como bottom para empilhar as barras do terceiro produto.

Código melhorado: valores em cada coluna

Para adicionar os valores de cada produto na coluna correspondente no gráfico, podemos utilizar o método text do objeto Axes. Veja o código modificado abaixo:

import matplotlib.pyplot as plt

meses = ['Jan', 'Fev', 'Mar']
produto1 = [1000, 1500, 1200]
produto2 = [800, 1200, 1500]
produto3 = [900, 1100, 1400]

plt.bar(meses, produto1, label='Produto 1', color='r')
plt.bar(meses, produto2, label='Produto 2', bottom=produto1, color='b')
plt.bar(meses, produto3, label='Produto 3', bottom=[sum(x) for x in zip(produto1, produto2)], color='g')

for i in range(len(meses)):
    plt.text(meses[i], produto1[i]/2, str(produto1[i]), ha='center', va='center', color='white')
    plt.text(meses[i], produto1[i]+produto2[i]/2, str(produto2[i]), ha='center', va='center', color='white')
    plt.text(meses[i], produto1[i]+produto2[i]+produto3[i]/2, str(produto3[i]), ha='center', va='center', color='white')

plt.ylabel('Vendas')
plt.title('Vendas por produto e mês')
plt.legend()
plt.show()

Resultado:

Gráfico de colunas empilhadas com rótulos em Python com matplotlib

Este código gera um gráfico de colunas empilhadas usando a biblioteca Matplotlib em Python. Ele usa os dados de vendas mensais para três produtos diferentes (Produto 1, Produto 2 e Produto 3) em três meses diferentes (Jan, Fev e Mar).

A primeira etapa é definir os dados. As listas meses, produto1, produto2 e produto3 contêm os nomes dos meses e os valores das vendas mensais para cada produto.

A seguir, o código usa o método plt.bar() da biblioteca Matplotlib para criar as barras do gráfico. A primeira chamada cria as barras para o Produto 1, a segunda chamada cria as barras para o Produto 2, e a terceira chamada cria as barras para o Produto 3. O parâmetro bottom é usado para indicar a altura da barra, que é a soma dos valores dos produtos anteriores.

Por exemplo, para o Produto 2, bottom é definido como produto1, para que as barras correspondentes sejam empilhadas em cima das barras do Produto 1.

Em seguida, o código usa o loop for para adicionar rótulos para cada valor de venda em cada coluna correspondente. Isso é feito usando o método plt.text(), que recebe como parâmetros a posição do rótulo (definida pela combinação do mês e do valor de venda), o texto do rótulo e a cor do texto.

Finalmente, o código adiciona as legendas dos produtos, um título para o gráfico e exibe o gráfico usando o método plt.show().

Veja também: Como criar um gráfico de boxplot em Python com matplotlib

O post Como gerar um gráfico de colunas empilhadas em Python, usando matplotlib apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos mostrar como criar um script que permite calcular Médias Móveis em Python, sem o emprego da biblioteca de manipulação e análise de dados Pandas (o que faremos em outro tutorial).

Após calcular as médias móveis para um conjunto de valores (fornecido em uma lista), vamos plotar um gráfico usando a biblioteca Matplotlib para visualização dos resultados obtidos.

As Médias Móveis

As médias móveis são uma ferramenta muito utilizadas por comerciantes, investidores e traders como ferramenta de auxílio na análise de tendências de preços e em análise técnica.

Mas o que é uma média móvel?

Uma média móvel é um indicador que mostra o valor médio do preço de um ativo em um período de tempo determinado (série de dados). Conforme o preço do ativo muda ao longo do tempo, seu preço médio aumenta ou diminui, compondo um movimento de valores médios.

Na prática, existem diversos tipos de médias móveis, sendo as cinco mais comuns as seguintes:

• Média Móvel Simples (ou Aritmética)
• Média Móvel Exponencial
• Média Móvel Triangular
• Média Móvel Variável
• Média Móvel Ponderada

Neste tutorial vamos mostrar como criar um script em Python que receba uma série de dados como entrada, e calcule a média móvel simples desse conjunto de valores. As médias móveis simples atribuem peso igual aos valores (preços).

A média móvel mais comum (de longo prazo) leva em consideração um período de 200 dias de dados (39 semanas); para os propósitos deste artigo vamos trabalhar com um conjunto menor de dados, mas o algoritmos pode receber qualquer quantidade de dados como entrada, sem que haja necessidade de alterações no código.

Como calcular a média móvel simples

O cálculo da média móvel simples é exatamente o que se espera de m cálculo de médias: somamos os valores de cada dia, e dividimos o resultado da soma pelo número de dias (média aritmética). O valor é então plotado em um gráfico.

Na sequência, avançamos um dia e somamos o próximo intervalo de valores, calculando a média e plotando no gráfico, e assim sucessivamente, construindo o gráfico das médias móveis.

Por exemplo, para calcular as médias móveis usando intervalos de 50 dias, calculamos a média aritmética dos primeiros 50 dias, avançamos um dia, calculamos a média aritmética dos próximos 50 dias, e assim até atingirmos o intervalo mais recente possível.

Script para determinar médias móveis em Python

Vejamos um exemplo de script que permite calcular as médias móveis para um conjunto de valores fornecido. No caso, vamos passar valores usando uma lista comum em Python, mas os dados podem ser provenientes de qualquer outra fonte, como arquivos .csv, do Excel, de páginas Web, etc.

Vamos usar como intervalo para cálculo das médias o valor de 5 dias (médias de 5 valores), valor armazenado em uma variável que chamaremos de tam_grupo.

"""
Created on Thu Dec 3 12:05:44 2020
@author: Fábio dos Reis
"""
import matplotlib.pyplot as plt

valores = [21.95,21.84,21.9,21.98,21.65,22.11,22.50,22.75,23.21,23.1,23.20,22.78,22.30,23.17,23.24,23.26,23.23,23.13,23.27,23.38,23.42,23.68,23.20,22.84,23.01,23.00,23.11,23.24,23.46,23.27,23.02,22.82,23.31] # cotações diárias

tam_grupo = 5 # deslocamento (uma semana útil)
i = 0
medias_moveis=[]

# Calcular as médias móveis e armazená-las em uma lista:
while i < len(valores) - tam_grupo + 1:
    grupo = valores[i : i + tam_grupo]
    media_grupo = sum(grupo) / tam_grupo
    medias_moveis.append(media_grupo)
    i +=1

# Exibir a lista de médias móveis
for valor in medias_moveis:
    print(round(valor,2))

# Gerar lista com dias do mês
dia_mes = []
for dia in range(1,len(medias_moveis)+1):
    dia_mes.append(dia)

# Visualizar gráfico de médias móveis
plt.style.use('seaborn')
plt.xlabel('Dia')
plt.ylabel('Preço')
plt.title('Médias Móveis')
plt.axis(ymin=21,ymax=24,xmin=0,xmax=30)
plt.plot(dia_mes,medias_moveis,marker='o')
plt.show()

A figura a seguir mostra o gráfico plotado com as médias móveis calculadas a partir dos dados fornecidos na lista de valores:

Gráfico de Médias Móveis em Python

Conclusão

Neste tutorial mostramos como criar um script simples em Python para o cálculo de médias móveis simples. Usamos técnicas de programação como listas, laços de repetição while e for, funções como round() e len(), além da biblioteca para plotagem de gráficos matplotlib / pyplot / seaborn.

Nos próximos tutoriais vamos mostrar como calcular ouros tipos de médias móveis em Python, como a média móvel exponencial e a média móvel ponderada, como adicionar uma linha de tendência ao gráfico de médias móveis, e também como determinar e plotar Bandas de Bollinger.

E também vamos mostrar como usar a biblioteca Pandas para realizar esses tipos de cálculos, de forma ainda mais simplificada.

Até!

O post Calcular Médias Móveis em Python (sem usar Pandas) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O matplotlib é uma biblioteca gráfica 2D, que contém uma grande coleção de módulos para trabalho com gráficos e visualização de dados em Python. 

Permite criar representações gráficas de dados de alta qualidade em vários formatos e também ambientes interativos, em inúmeras plataformas. Além de poder ser usado em scripts do Python, também pode ser empregado em Jupyter Notebooks, servidores de aplicação Web e em toolkits de interface gráfica, entre outros.

Com esta biblioteca podemos gerar gráficos de vários tipos, histogramas, scatterplots e muitos outros tipos de visualização de dados, usando poucas linhas de código (afinal, é Python!).

Neste artigo veremos como criar um gráfico simples usando matplotlib e seus módulos. Mas antes, vamos rever dois conceitos importantes que serão necessários: Plano Cartesiano e Geração de Listas em Python.

O Plano Cartesiano

Um plano cartesiano é, basicamente, uma representação gráfica que possui duas linhas numéricas: um eixo x (na horizontal) e um eixo y (na vertical), perpendiculares entre si.

O centro desse gráfico é chamado de Origem (O), e números no lado direito da origem no eixo x são positivos, e os à esquerda são negativos. Da mesma forma, números acima da origem no eixo y são positivos e números abaixo da origem, negativos.

Um ponto no gráfico é a combinação de um par de valores nos eixos x e y. Esse par de valores é chamado de coordenadas, estabelecendo a localização de um ponto qualquer.

A figura a seguir mostra um plano cartesiano com um ponto plotado (na cor roxa), na posição (2,3), que significa valor 2 no eixo x e valor 3 no eixo y:

Plano de coordenadas cartesiano. Gerado em https://www.oliverboorman.biz/projects/tools/cartesian_grid.php

Listas em Python

Usaremos listas para armazenar os dados que serão plotados nos gráficos. Assim, poderemos armazenar os valores dos eixos x e y que deverão ser plotados.

Antes disso, vamos relembrar como criar uma lista, acessar seus elementos individualmente e como iterar por eles.

Criar uma lista

Criamos uma lista atribuindo um conjunto de valores entre colchetes e separados por vírgulas a uma variável, como no exemplo a seguir:

minhaLista = [2, 5, 9, 12]

Criamos neste exemplo uma lista de nome minhaLista, contendo quatro elementos numéricos.

Acessar os elementos da lista

Para acessar um elemento de uma lista basta indicar o número da posição do elemento desejado, entre colchetes, logo após o nome da lista:

minhaLista[0]
minhaLista[3]

Nos dois exemplos acima, acessamos os elementos das posições 0 e 3 da lista. Lembre-se que o primeiro elemento de uma lista é sempre o elemento da posição 0, de modo que o elemento da posição 3 da lista acima é na verdade o quarto elemento armazenado.

Iteração em uma lista

Podemos iterar por uma lista, acessando todos os seus elementos sequencialmente, usando um laço for, como no exemplo a seguir:

for item in minhaLista:
    print(item)

Cada elemento da lista é atribuído à variável item em cada iteração, e seu valor é impresso na tela.

Agora que revisamos a criação de uma lista e o acesso a seus elementos, vamos ver como instalar o matplotlib em seu sistema.

Instalação do matplotlib

A instalação dos pacotes do matplotlib é muito simples. O site oficial da biblioteca é www.matplotlib.org

Instalação no Windows

Para instalar a biblioteca em um computador com Windows execute os seguintes comandos em um prompt:

python -m pip install -U pip
python -m pip install -U matplotlib

Instalação no Linux

Use o gerenciador de pacotes de sua distribuição para realizar a instalação do matplotlib no Linux. Por exemplo:

Debian / Ubuntu:

sudo apt install python3-matplotlib

Fedora:

sudo dnf install python3-matplotlib

Red Hat:

sudo yum install python3-matplotlib

Caso você esteja trabalhando com a distribuição Anaconda, não será necessário baixar e instalar o matplotlib, pois ele já vem instalado por padrão (além de trazer inúmeras outras ferramentas muito úteis para ciência de dados).

Mais informações sobre a instalação do matplotlib podem ser obtidas aqui: https://matplotlib.org/users/installing.html

Criar gráficos com matplotlib

Agora vamos criar gráficos com matplotlib efetivamente usando a biblioteca. Começamos criando duas listas para armazenar os dados dos eixos x e y que serão plotados no gráfico:

eixoX = [1, 2, 3, 4]
eixoY = [2, 5, 9, 12]

Usaremos o módulo pylab para realizar as operações necessárias à plotagem de um gráfico simples.

O PyLab é uma interface para a biblioteca Matplotlib, sendo um módulo pertencente à biblioteca. Este módulo importa o matplotlib.pyplot, para plotagem de gráficos, e o NumPy, para cálculos matemáticos e operações com arrays, em um namespace único.

Importar os módulos necessários:

from pylab import plot, show

Criar o gráfico:

plot(eixoX, eixoY)
show()

A função plot() cria o gráfico e o armazena em um objeto na memória; a função show() o mostra na tela.

Note que, se você não executar a função show(), o gráfico será criado mas não será exibido na tela, ficando armazenado em memória.

Como marcar os pontos no gráfico

Para marcar os pontos no gráfico usamos o parâmetro marker na função plot():

plot(eixoX, eixoY, marker='o')

O valor ‘o’ indica que os pontos serão pequenos círculos. podemos também marcar apenas os pontos no gráfico, sem as linhas que os conectam, da seguinte forma:

plot(eixoX, eixoY, 'o')

Como plotar mais de uma linha no mesmo gráfico

Vamos criar um gráfico que mostre as temperaturas máxima e mínima ao longo dos meses em um determinado local. Precisaremos de três listas:

meses = ['Jan', 'Fev', 'Mar','Abr','Mai','Jun','Jul','Ago','Set','Out','Nov','Dez']
Tmax = [38,39,32,29,26,22,19,15,20,22,25,27]
Tmin = [23,23,22,21,19,16,12,10,16,21,22,22]

Agora passamos as listas em pares meses/temperaturas para a função plot():

from pylab import plot, show, legend
plot(meses,Tmax,meses,Tmin)
legend(['Tmax','Tmin'])
show()

Note que uma cor diferente para cada linha é escolhida automaticamente, para indicar que cada linha corresponde a um conjunto de dados.

Note que também importamos o módulo legend, que nos permitirá adicionar uma legenda ao gráfico, de modo a sabermos qual linha corresponde a qual dado. A função legend() recebe uma lista de nomes como argumento, e usará essa lista para criar a legenda, com os nomes passados correspondendo às listas de valores plotadas no gráfico, em ordem.

A função legend() deve ser executada após a função plot() para funcionar.

Podemos adicionar um título e rótulos aos eixos x e y do gráfico. Para isso usamos as funções title(), xlabel() e ylabel(), que devem ser importadas a partir de seus módulos. Por exemplo, vamos adicionar rótulos e um título ao nosso gráfico:

from pylab import plot, show, legend, title, xlabel, ylabel
meses = ['Jan', 'Fev', 'Mar','Abr','Mai','Jun','Jul','Ago','Set','Out','Nov','Dez']
Tmax = [38,39,32,29,26,22,19,15,20,22,25,27]
Tmin = [23,23,22,21,19,16,12,10,16,21,22,22]
plot(meses,Tmax,meses,Tmin)
title('Temperaturas Máximas e Mínimas do Ano')
xlabel('Mês')
ylabel('Temp/°C')
legend(['Tmax','Tmin'])
show()

Finalmente, vamos configurar os valores máximo e mínimo de cada eixo. Por exemplo, queremos que o eixo y (temperaturas) mostre temperaturas entre 0 e 45 °C. Para isso, usamos a função axis() (importar o módulo axis também):

from pylab import plot, show, legend, title, xlabel, ylabel, axis

Adicionar a Função ao código anterior:

axis(ymin=0,ymax=45)

Resultado:

De forma similar, podemos também usar os parâmetros xmin e xmax na função axis() para determinar os limites numéricos máximo e mínimo no eixo x.

É isso aí! Nesta lição vimos como criar um gráfico bem básico – mas informativo – usando um módulo da biblioteca matplotlib. Na próxima lição vamos nos aprofundar na criação de gráficos mais especializados e em configurações mais complexas destes gráficos.

Até lá!. 

O post Como criar gráficos com matplotlib em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.