Gráficos de linhas no MatplotLib com Python

A visualização de dados e a narração de histórias são vitais para os cientistas de dados, pois eles transformam insights de dados complexos em narrativas atraentes e de fácil digestão para uma comunicação eficaz. Embora sejam lançadas bibliotecas mais novas e mais sofisticadas, o Matplotlib continua sendo uma das bibliotecas de plotagem mais populares e constrói a base para as mais recentes.

Este tutorial se concentra em um dos tipos mais comuns de gráficos do Matplotlib, o gráfico de linhas. Os gráficos de linhas são excelentes para mostrar tendências e flutuações nos dados ao longo do tempo, conectando os pontos (literalmente) para pintar uma imagem vívida do que está acontecendo.

Este tutorial começa com os fundamentos da criação de um gráfico de linhas simples e, em seguida, avança para técnicas mais avançadas, como a adição de informações estatísticas aos gráficos. Ao final deste tutorial, você terá uma sólida compreensão de como criar diferentes tipos de gráficos de linha no Matplotlib e como usá-los para comunicar seus insights de dados a outras pessoas de forma eficaz.

Você está pronto para aprimorar suas habilidades de visualização de dados? Vamos começar!

As bibliotecas, os dados e o pré-processamento

Antes de começarmos a criar gráficos de linhas com o Matplotlib, precisamos configurar nosso ambiente. Isso envolve a instalação do Matplotlib, a importação das bibliotecas necessárias e o pré-processamento do conjunto de dados que usaremos em nossos exemplos.

Instalação do matplotlib

Para instalar o Matplotlib, você pode usar o pip, o instalador de pacotes do Python. Basta abrir um terminal ou prompt de comando e digitar:

pip install matplotlib

Isso instalará a versão mais recente do Matplotlib em seu computador.

Importação das bibliotecas necessárias

Depois que o Matplotlib estiver instalado, devemos importá-lo com outras bibliotecas necessárias, como NumPy e Pandas. O NumPy é uma biblioteca para trabalhar com matrizes, enquanto o Pandas é para manipulação e análise de dados.

Para importar essas bibliotecas, basta digitar o seguinte código:

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

Leitura e pré-processamento dos dados

Para este tutorial, usaremos um conjunto de dados que contém os preços diários do índice DJIA. O conjunto de dados inclui cinco colunas: 

• A coluna Data fornece a data em que as informações restantes sobre o preço das ações foram registradas
• Abrir, Fechar: O preço do DJIA na abertura e no fechamento do mercado de ações para aquele dia específico
• Alto, baixo: O preço mais alto e mais baixo que o DJIA atingiu durante um determinado dia

Depois de carregar o conjunto de dados, faríamos um pré-processamento básico dos dados, como renomear a coluna, convertê-la em uma variável datetime e classificar os dados em ordem crescente de data.

Aqui está o código para o que foi dito acima:

# Load the dataset into a Pandas DataFrame
df = pd.read_csv("HistoricalPrices.csv")

# Rename the column to remove an additional space
df = df.rename(columns = {' Open': 'Open', ' High': 'High', ' Low': 'Low', ' Close': 'Close'})

# Convert the date column to datetime
df['Date'] = pd.to_datetime(df['Date'])

# Sort the dataset in the ascending order of date
df = df.sort_values(by = 'Date')

Agora que configuramos o ambiente e carregamos o conjunto de dados, podemos passar a criar gráficos de linhas usando o Matplotlib.

Criação de um gráfico de linhas básico no Matplotlib

Começaremos criando um gráfico de linhas básico e, em seguida, personalizaremos o gráfico de linhas para torná-lo mais apresentável e informativo.

Usando plt.plot() para criar um gráfico de linhas

Para criar um gráfico de linhas, usaremos a função plt.plot(). Essa função recebe dois parâmetros: os valores do eixo x e os valores do eixo y. Em nosso caso, a coluna de data será nossos valores do eixo x, enquanto a coluna de fechamento será nossos valores do eixo y. Aqui está o código:

# Extract the date and close price columns
dates = df['Date']
closing_price = df['Close']

# Create a line plot
plt.plot(dates, closing_price)

# Show the plot
plt.show()

Ao executar o código acima, você verá um gráfico de linha básico das ações do DJIA. 

Personalização do gráfico de linhas

O Matplotlib nos oferece muitas outras personalizações, que podem ser utilizadas de acordo com nossas necessidades.

Definição da cor da linha

Por padrão, a função plt.plot() traça uma linha azul. No entanto, você pode alterar a cor da linha passando um parâmetro color para a função. O parâmetro color pode receber uma cadeia de caracteres que representa o nome da cor ou um código hexadecimal. 

Aqui está um exemplo:

# Plot in Red colour
plt.plot(dates, closing_price, color='red')

# Show the plot
plt.show()

Esse código desenhará uma linha vermelha em vez de uma azul, conforme mostrado abaixo:

Gráfico de linhas básicas em vermelho

Definição da largura da linha

Você também pode alterar a largura da linha passando um parâmetro linewidth para a função plt.plot(). O parâmetro linewidth recebe um valor de ponto flutuante que representa a largura da linha. 

Aqui está um exemplo:

# Increasing the linewidth
plt.plot(dates, closing_price, linewidth=3)

# Show the plot
plt.show()

Esse código desenhará uma linha com largura de 3 em vez da largura padrão, conforme mostrado abaixo: 

Linhas mais grossas no gráfico devido à maior largura de linha

Definir o estilo da linha

Você pode alterar o estilo da linha passando um parâmetro linestyle para a função plt.plot(). O parâmetro linestyle recebe uma cadeia de caracteres que representa o estilo da linha. A documentação do matplotlib fornece uma lista extensa dos estilos disponíveis. 

Veja como eles podem ser usados no código:

# Individually plot lines in solid, dotted, dashed and dashdot

plt.plot(dates, closing_price, linestyle='solid') # Default line style
plt.plot(dates, closing_price, linestyle='dotted')
plt.plot(dates, closing_price, linestyle='dashed')
plt.plot(dates, closing_price, linestyle='dashdot')

# Show the plot
plt.show()

Adição de marcadores a gráficos de linhas

Os marcadores podem ser usados para destacar pontos específicos no gráfico de linhas. Vários tipos de símbolos podem ser usados como marcadores e podem ser consultados na documentação do matplotlib.

Aqui está um exemplo de uso de marcadores em um gráfico de linhas:

# Add a cross marker for each point
plt.plot(df['Date'], df['Close'], marker='x')

# Show the plot
plt.show()

No código acima, estamos usando marcadores cruzados (x) para destacar os Close preços das ações do DJIA, conforme mostrado abaixo:

Adição de rótulos e títulos

Para tornar o gráfico mais informativo, podemos adicionar rótulos de eixo e um título. Para isso, usamos as funções plt.xlabel(), plt.ylabel() e plt.title(), respectivamente. 

Aqui está um exemplo:

plt.plot(dates, closing_price, color='red', linewidth=2)
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.title('DJIA Stock Price')

# Show the plot
plt.show()

Esse código traçará uma linha vermelha com largura de 2, com o eixo x rotulado como "Date", o eixo y rotulado como "Closing Price" e o título "DJIA Stock Price". 

Adição de linhas de grade

Também podemos adicionar linhas de grade ao nosso gráfico para torná-lo mais legível. Podemos fazer isso usando a função plt.grid(). A função plt.grid() recebe um valor booleano que representa se a grade deve ser exibida. 

Aqui está um exemplo: 

plt.plot(dates, closing_price, color='red', linewidth=2)
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.title('DJIA Stock Price')

# Add the grid
plt.grid(True)

# Show the plot
plt.show()

Você verá grades adicionadas ao gráfico: 

Gráficos de linhas do Matplotlib com várias linhas

Em alguns casos, você pode querer traçar várias linhas no mesmo gráfico. Para fazer isso, você pode chamar a função plt.plot() várias vezes com dados diferentes para cada chamada. Aqui está um exemplo:

# Line plot of Open and Close prices

plt.plot(df['Date'], df['Open'])
plt.plot(df['Date'], df['Close'])
plt.title('DJIA Open and Close Prices')
plt.xlabel('Date')
plt.ylabel('Price')

plt.show()

No código acima, estamos plotando os valores de Open e Close das ações do DJIA no mesmo gráfico.

Gráficos de linhas Matplotlib com eixos duplos

Pode haver casos em que você queira representar duas variáveis com escalas diferentes no mesmo gráfico. Nessas situações, o uso de eixos duplos é uma maneira eficaz de visualizar a relação entre as variáveis sem perder a clareza das escalas individuais. 

Para criar um gráfico de linhas com eixos duplos, precisamos usar a função twinx(). Essa função cria um novo eixo y que compartilha o mesmo eixo x do gráfico original. 

Veja um exemplo:

# Create a new variable for demonstration purposes
df['High_minus_Low'] = df['High'] - df['Low']

# Create a basic line plot for the Close prices
fig, ax1 = plt.subplots()
ax1.plot(df['Date'], df['Close'], color='blue', label='Close Price')
ax1.set_xlabel('Date')
ax1.set_ylabel('Closing Price', color='blue')
ax1.tick_params(axis='y', labelcolor='blue')

# Create a twin axis for the High_minus_Low variable
ax2 = ax1.twinx()
ax2.plot(df['Date'], df['High_minus_Low'], color='green', label='High - Low')
ax2.set_ylabel('High minus Low', color='green')
ax2.tick_params(axis='y', labelcolor='green')

# Add a title and show the plot
plt.title('DJIA Stock Price and High-Low Difference with Twin Axes')
plt.show()

E o gráfico resultante com eixos duplos: 

Adição de informações estatísticas aos gráficos de linhas do Matplotlib

Além de visualizar tendências e padrões nos dados, os gráficos de linhas também podem exibir informações estatísticas, como linhas de regressão e barras de erro. 

Adição de uma linha de regressão do Matplotlib

Uma linha de regressão é uma linha que melhor se ajusta aos pontos de dados em um gráfico e pode ser usada para modelar e prever valores futuros. Podemos adicionar uma linha de regressão ao nosso gráfico de linhas usando a função polyfit() da biblioteca NumPy, que ajusta uma linha de regressão polinomial aos nossos pontos de dados. 

import matplotlib.dates as mdates

# Convert Date column to numeric value
df['Date'] = mdates.date2num(df['Date'])

# Add regression line to plot
coefficients_open = np.polyfit(df['Date'], df['Open'], 1)
p_open = np.poly1d(coefficients_open)

coefficients_close = np.polyfit(df['Date'], df['Close'], 1)
p_close = np.poly1d(coefficients_close)

fig, ax = plt.subplots()
ax.plot(df['Date'], df['Open'], '.', label='Open Price')
ax.plot(df['Date'], p_open(df['Date']), '-', label='Open Regression Line')
ax.plot(df['Date'], df['Close'], '.', label='Close Price')
ax.plot(df['Date'], p_close(df['Date']), '-', label='Close Regression Line')
ax.set_title('DIJA Stock Prices')
ax.set_xlabel('Date')
ax.set_ylabel('Price')
ax.legend()

# Format x-axis labels as dates
date_form = mdates.DateFormatter("%Y-%m-%d")
ax.xaxis.set_major_formatter(date_form)
plt.gcf().autofmt_xdate()

plt.show()

Nesse código, primeiro convertemos as datas em valores numéricos usando a função date2num() e, em seguida, usamos a funçãopolyfit() para obter os coeficientes da linha de regressão. Usamos a função poly1d() para traçar a linha. Os pontos de dados originais são representados por pontos e a linha de regressão por uma linha sólida. 

Adição de barras de erro

As barras de erro são uma representação gráfica da variabilidade dos dados e podem ser usadas para indicar a incerteza nas medições.

Isso é particularmente útil quando você espera alguns erros no processo de coleta de dados, como dados de temperatura, dados de qualidade do ar e assim por diante. Embora tenhamos certeza sobre os preços das ações, vamos supor um erro potencial de um desvio padrão e plotá-lo usando a função errorbar no matplotlib.

# Calculate standard deviation of data
std = df['Close'].std()

# Add error bars to plot
plt.errorbar(df['Date'], df['Close'], yerr=std/2, fmt='.', label='Close Price')
plt.title('DIJA Stock Prices')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()

Nesse código, primeiro calculamos o desvio padrão dos preços doClose em nosso conjunto de dados. Em seguida, usamos a função errorbar() para adicionar barras de erro ao gráfico de linhas, com o tamanho da barra de erro definido como metade do desvio padrão .

Essas técnicas nos permitem adicionar informações estatísticas aos nossos gráficos de linhas e obter insights mais profundos sobre nossos dados.

Conclusão

Os gráficos de linhas são uma ferramenta poderosa para visualizar tendências e padrões nos dados, e o Matplotlib oferece uma interface amigável para criá-los. 

Como próxima etapa, talvez você queira seguir nosso curso Python Intermediário, no qual você aplicará tudo o que aprendeu a um estudo de caso de estatísticas de hackers. 

Esperamos que este tutorial tenha ajudado você a começar a criar gráficos de linhas no Matplotlib. Também abordamos amplamente os outros gráficos do matplotlib em outro tutorial, que pode apresentá-lo brevemente ao que mais você pode fazer com o Matplotlib. 

Continue explorando e experimentando a criação de visualizações impressionantes e descobrindo insights de seus dados!