Como Plotar Dados em Tempo Real com Matplotlib

Na análise de dados moderna, a visualização de dados em tempo real está se tornando cada vez mais importante. Matplotlib é uma das bibliotecas de visualização de dados mais amplamente usadas em Python, e utilizando seus recursos, é possível realizar plotagens de dados em tempo real com facilidade. Neste guia, explicaremos passo a passo desde o básico até o avançado sobre plotagem em tempo real com Matplotlib, incluindo exemplos de código específicos.

Índice

Fundamentos da Plotagem em Tempo Real

A plotagem em tempo real é uma técnica que permite atualizar dinamicamente um gráfico conforme os dados são atualizados. Isso é essencial para diversas aplicações, como o monitoramento de dados de sensores ou de mercado. O conceito básico é obter e atualizar os dados em intervalos regulares. Para isso, usamos os recursos de animação e loops de atualização do Matplotlib. Vamos primeiro entender o fluxo geral e os elementos necessários para uma plotagem em tempo real.

Instalação e Configuração do Matplotlib

Para realizar uma plotagem em tempo real, é necessário instalar o Matplotlib e realizar algumas configurações básicas. Siga os passos abaixo para começar.

Instalando o Matplotlib

Como o Matplotlib não está incluído na biblioteca padrão do Python, é necessário instalá-lo usando o pip. Use o comando abaixo para instalar.

pip install matplotlib

Instalando Outras Bibliotecas Necessárias

Para implementar a plotagem em tempo real, é comum usar outras bibliotecas além do Matplotlib. Instale também essas bibliotecas usando pip.

pip install numpy
pip install pandas

Configuração Básica

Após a instalação, importe as bibliotecas no seu script Python ou Jupyter Notebook.

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

Verificação de Funcionamento

Para verificar se a instalação e a configuração estão corretas, crie um plot simples. Execute o código abaixo para confirmar o funcionamento do Matplotlib.

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('Label do Eixo x')
plt.ylabel('Label do Eixo y')
plt.title('Plot de Teste')
plt.show()

Se o plot for exibido corretamente, a instalação e configuração estão completas. No próximo passo, veremos como obter dados em tempo real.

Métodos de Obtenção de Dados

Para realizar uma plotagem em tempo real, é necessário primeiro entender como obter dados em tempo real. Existem várias formas de obter dados, e aqui abordaremos alguns métodos comuns.

Obtendo Dados de Sensores

Para obter dados em tempo real de sensores, é necessário uma biblioteca para comunicação com o hardware. Por exemplo, ao usar Arduino ou Raspberry Pi para coletar dados de sensores, utilize uma biblioteca Python (como pyserial) para obter os dados.

import serial

ser = serial.Serial('COM3', 9600)  # Especifica a porta e taxa de transmissão
while True:
    data = ser.readline().decode('utf-8').strip()
    print(data)

Obtendo Dados de uma API

Outra forma de obter dados em tempo real é através de APIs. Por exemplo, é possível obter dados como cotações de ações ou informações meteorológicas de APIs públicas na internet. Abaixo está um exemplo de uso da biblioteca requests para obter dados de uma API.

import requests
import time

url = 'https://api.example.com/data'
while True:
    response = requests.get(url)
    data = response.json()
    print(data)
    time.sleep(5)  # Obtém dados a cada 5 segundos

Obtendo Dados de um Banco de Dados

Para obter dados em tempo real de um banco de dados, use uma biblioteca cliente para se conectar ao banco. Abaixo, mostramos um exemplo de obtenção de dados periodicamente de um banco de dados SQLite.

import sqlite3
import time

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

while True:
    cursor.execute("SELECT * FROM data_table ORDER BY timestamp DESC LIMIT 1")
    data = cursor.fetchone()
    print(data)
    time.sleep(5)  # Obtém dados a cada 5 segundos

Geração de Dados de Simulação

Para fins de teste, você pode simular dados em tempo real. Abaixo está um exemplo de geração de dados aleatórios usando numpy.

import numpy as np
import time

while True:
    data = np.random.random()
    print(data)
    time.sleep(1)  # Gera dados aleatórios a cada 1 segundo

Após obter os dados em tempo real, o próximo passo é aprender como plotá-los em tempo real.

Implementação Básica de Plotagem em Tempo Real

Para implementar uma plotagem em tempo real, é necessário atualizar periodicamente os dados plotados. Abaixo mostramos um exemplo básico de como fazer isso usando Matplotlib.

Atualização Básica do Gráfico

No Matplotlib, podemos usar a classe FuncAnimation para atualizar o plot em tempo real. O exemplo abaixo mostra como plotar dados aleatórios em tempo real.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# Listas para armazenar os dados
x_data = []
y_data = []

# Configuração do gráfico
fig, ax = plt.subplots()
line, = ax.plot([], [], 'r-')

# Configuração inicial do plot
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 1)
    return line,

# Função de atualização dos dados
def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    # Remove dados antigos se o número de pontos exceder 100
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

# Configuração da animação
ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)

plt.show()

Combinando Obtenção e Plotagem de Dados

A seguir, mostramos um exemplo de como combinar os métodos de obtenção de dados com a plotagem em tempo real. Aqui, utilizamos dados obtidos de uma API e os plotamos em tempo real.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import requests
import numpy as np

# Listas para armazenar os dados
x_data = []
y_data = []

# Configuração do gráfico
fig, ax = plt.subplots()
line, = ax.plot([], [], 'r-')

# Configuração inicial do plot
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 100)
    return line,

# Função de atualização dos dados
def update(frame):
    # Obtém dados de uma API
    response = requests.get('https://api.example.com/data')
    data = response.json()
    value = data['value']

    x_data.append(frame)
    y_data.append(value)

    # Remove dados antigos se o número de pontos exceder 100
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

# Configuração da animação
ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)

plt.show()

Neste código, obtemos dados de uma API e atualizamos o plot em tempo real chamando a função update. O próximo passo é explorar o uso de animações mais avançadas para plotagem em tempo real.

Plotagem em Tempo Real com Animação

Utilizando a funcionalidade de animação do Matplotlib, é possível realizar plotagens em tempo real de forma mais suave e dinâmica. Aqui explicamos como usar FuncAnimation para plotar dados em tempo real com animação.

Configuração Básica da Animação

Primeiro, vamos ver o uso básico de FuncAnimation, que permite atualizar o gráfico periodicamente.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

fig, ax = plt.subplots()
line, = ax.plot([], [], 'r-')

# Função de inicialização
def init():
    ax.set_xlim(0, 10)
    ax.set_ylim(0, 1)
    return line,

# Função de atualização
def update(frame):
    x = np.linspace(0, 10, 100)
    y = np.sin(2 * np.pi * (x - 0.01 * frame))
    line.set_data(x, y)
    return line,

ani = animation.FuncAnimation(fig, update, frames=100, init_func=init, blit=True)
plt.show()

Este exemplo exibe uma onda senoidal animada. A função update atualiza os dados, e FuncAnimation chama essa função periodicamente para atualizar o gráfico.

Animação de Dados em Tempo Real

A seguir, mostramos um exemplo de plotagem em tempo real de dados aleatórios usando animação.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

fig, ax = plt.subplots()
x_data, y_data = [], []
line, = ax.plot([], [], 'b-')

# Função de inicialização
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 1)
    return line,

# Função de atualização
def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    # Remove dados antigos se o número de pontos exceder 100
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True)
plt.show()

Este código gera dados aleatórios para cada quadro e os atualiza no gráfico, permitindo visualizar dados que mudam em tempo real.

Exemplo Aplicado: Plotagem em Tempo Real de Dados de Sensores

A plotagem em tempo real de dados de sensores é amplamente utilizada em dispositivos IoT e sistemas de monitoramento em tempo real. Aqui, mostramos um exemplo de plotagem de dados simulados de um sensor de temperatura.

Simulação de Dados de Sensor

Em vez de usar um sensor real, neste exemplo utilizaremos dados simulados de temperatura.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
import random

fig, ax = plt.subplots()
x_data, y_data = [], []
line, = ax.plot([], [], 'r-')

# Função de inicialização
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(15, 30)  # Define o intervalo de temperatura
    return line,

# Função de atualização
def update(frame):
    x_data.append(frame)
    # Gera dados aleatórios de temperatura
    y_data.append(20 + random.uniform(-5, 5))

    # Remove dados antigos se o número de pontos exceder 100
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)
plt.xlabel('Tempo')
plt.ylabel('Temperatura (°C)')
plt.title('Plotagem em Tempo Real da Temperatura')
plt.show()

Este exemplo mostra como plotar dados de temperatura simulados em tempo real, com atualização constante dos valores no gráfico.

Conclusão

Matplotlib oferece uma poderosa ferramenta para visualização de dados em tempo real, útil em diversas aplicações. Neste artigo, exploramos os conceitos e a implementação prática de plotagem em tempo real, desde a configuração do ambiente até a obtenção e atualização de dados. Esperamos que este guia ajude você a integrar visualizações em tempo real em seus próprios projetos.

Exemplo Aplicado: Plotagem em Tempo Real de Dados de Ações

A plotagem em tempo real de dados de ações é extremamente útil para traders e investidores. Aqui, apresentamos como obter dados de ações em tempo real usando a API do Yahoo Finance e plotá-los.

Configuração da API do Yahoo Finance

Primeiro, instale a biblioteca yfinance. Com essa biblioteca, é possível obter facilmente dados de ações do Yahoo Finance.

pip install yfinance

Obtenção e Plotagem de Dados em Tempo Real

O código a seguir utiliza yfinance para obter dados em tempo real de uma ação específica e plota-los com Matplotlib.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import yfinance as yf
import datetime

# Prepara listas para armazenar dados
x_data, y_data = [], []

fig, ax = plt.subplots()
line, = ax.plot([], [], 'g-')

# Função de inicialização
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 500)  # Define o intervalo de preço das ações
    return line,

# Função de atualização
def update(frame):
    current_time = datetime.datetime.now().strftime('%H:%M:%S')
    x_data.append(current_time)

    # Obter dados de ações da API do Yahoo Finance
    stock = yf.Ticker('AAPL')
    data = stock.history(period='1m')
    y_data.append(data['Close'][-1])

    # Remove dados antigos se excederem um certo limite
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(range(len(x_data)), y_data)

    ax.set_xticks(range(0, len(x_data), 10))
    ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=60000)
plt.xlabel('Hora')
plt.ylabel('Preço da Ação ($)')
plt.title('Plotagem em Tempo Real - AAPL')
plt.show()

Este código obtém dados de ações da Apple (AAPL) a cada minuto e os plota em tempo real. A função FuncAnimation chama a função update a cada minuto para atualizar o gráfico.

Salvamento e Log de Dados

Além de plotar os dados de ações em tempo real, é importante salvá-los para análise posterior. O código a seguir salva os dados em um arquivo CSV enquanto os plota.

import csv

# Abrir arquivo CSV
with open('stock_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Hora', 'Preço'])

    def update(frame):
        current_time = datetime.datetime.now().strftime('%H:%M:%S')
        x_data.append(current_time)

        # Obter dados de ações da API do Yahoo Finance
        stock = yf.Ticker('AAPL')
        data = stock.history(period='1m')
        price = data['Close'][-1]
        y_data.append(price)

        # Escrever dados no arquivo CSV
        writer.writerow([current_time, price])

        # Remove dados antigos se excederem um certo limite
        if len(x_data) > 100:
            x_data.pop(0)
            y_data.pop(0)

        line.set_data(range(len(x_data)), y_data)

        ax.set_xticks(range(0, len(x_data), 10))
        ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

        return line,

    ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=60000)
    plt.xlabel('Hora')
    plt.ylabel('Preço da Ação ($)')
    plt.title('Plotagem em Tempo Real - AAPL')
    plt.show()

Este código salva os dados plotados em tempo real no arquivo stock_data.csv. Dessa forma, é possível tanto visualizar os dados em tempo real quanto manter um registro contínuo deles.

A próxima seção detalha como salvar e compartilhar os dados.

Salvamento e Compartilhamento de Dados

Além de plotar dados em tempo real, é importante salvar os dados coletados para análise ou compartilhamento futuro. Aqui, explicamos como salvar e compartilhar os dados da plotagem em tempo real.

Métodos de Salvamento de Dados

Um formato comumente usado para salvar dados é o CSV (Comma Separated Values). No Python, é possível gravar dados em um arquivo CSV facilmente usando o módulo csv.

import csv

# Abrir arquivo CSV
with open('realtime_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Hora', 'Valor'])

    def update(frame):
        current_time = datetime.datetime.now().strftime('%H:%M:%S')
        x_data.append(current_time)
        value = np.random.random()  # Aqui, usamos um valor aleatório
        y_data.append(value)

        # Escrever dados no arquivo CSV
        writer.writerow([current_time, value])

        if len(x_data) > 100:
            x_data.pop(0)
            y_data.pop(0)

        line.set_data(range(len(x_data)), y_data)

        ax.set_xticks(range(0, len(x_data), 10))
        ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

        return line,

    ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)
    plt.xlabel('Hora')
    plt.ylabel('Valor')
    plt.title('Plotagem de Dados em Tempo Real')
    plt.show()

Este código salva os dados obtidos em tempo real no arquivo realtime_data.csv.

Métodos de Compartilhamento de Dados

Existem várias maneiras de compartilhar os dados salvos. Abaixo estão alguns métodos comuns.

Compartilhar via E-mail

Uma das maneiras mais simples de compartilhar um arquivo CSV é anexá-lo a um e-mail.

Usar Armazenamento em Nuvem

Serviços de armazenamento em nuvem como Google Drive ou Dropbox também são convenientes para compartilhar dados com outras pessoas.

Salvar em um Banco de Dados

Outra opção é salvar os dados em um banco de dados, permitindo o acesso a partir de aplicativos web ou ferramentas de análise de dados. Abaixo, mostramos um exemplo de como salvar dados em um banco de dados SQLite.

import sqlite3

# Abrir conexão com o banco de dados
conn = sqlite3.connect('realtime_data.db')
cursor = conn.cursor()

# Criar tabela
cursor.execute('''CREATE TABLE IF NOT EXISTS data (timestamp TEXT, value REAL)''')

def update(frame):
    current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    value = np.random.random()  # Aqui, usamos um valor aleatório
    cursor.execute("INSERT INTO data (timestamp, value) VALUES (?, ?)", (current_time, value))
    conn.commit()

    x_data.append(current_time)
    y_data.append(value)

    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(range(len(x_data)), y_data)

    ax.set_xticks(range(0, len(x_data), 10))
    ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)
plt.xlabel('Hora')
plt.ylabel('Valor')
plt.title('Plotagem de Dados em Tempo Real')
plt.show()

# Fechar conexão com o banco de dados
conn.close()

Este código salva os dados obtidos em tempo real em um banco de dados SQLite.

Visualização e Análise de Dados

Para visualizar ou analisar os dados salvos posteriormente, é possível usar a biblioteca Pandas. Abaixo, mostramos um exemplo de como ler e plotar os dados de um arquivo CSV.

import pandas as pd

# Ler dados
df = pd.read_csv('realtime_data.csv')

# Plotar dados
plt.figure()
plt.plot(df['Hora'], df['Valor'])
plt.xlabel('Hora')
plt.ylabel('Valor')
plt.title('Plotagem dos Dados Salvos')
plt.xticks(rotation=45, ha='right')
plt.show()

Este código lê o arquivo CSV com Pandas e o plota, permitindo analisar e visualizar dados históricos.

A próxima seção explica problemas comuns e como resolvê-los ao realizar plotagens em tempo real.

Resolução de Problemas

Durante a plotagem em tempo real, podem surgir diversos problemas. Aqui, explicamos problemas comuns e como resolvê-los.

O Gráfico Não Atualiza

Se a plotagem em tempo real não estiver atualizando, considere os seguintes pontos.

Causa 1: Configuração Incorreta da Animação

Se a configuração de FuncAnimation estiver incorreta, o gráfico pode não atualizar. Certifique-se de que init_func e a função update retornem os dados corretamente quando blit=True estiver definido.

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)

Causa 2: Atraso na Obtenção de Dados

Se houver demora na obtenção dos dados, a atualização do gráfico pode ser atrasada. Revise a frequência de obtenção de dados e o tempo de resposta da API para garantir intervalos apropriados.

def update(frame):
    try:
        # Processo de obtenção de dados
        data = requests.get('https://api.example.com/data').json()
        # Processo de atualização de dados
    except Exception as e:
        print(f"Erro de obtenção de dados: {e}")
    return line,

O Gráfico Pisca

Se o gráfico piscar, tente usar blit=True para atualizar apenas a parte necessária da plotagem.

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)

Problema de Vazamento de Memória

Ao realizar plotagens em tempo real por um longo período, o uso de memória pode aumentar. Remova dados desnecessários para gerenciar o uso de memória.

def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    # Remover dados antigos
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

Erro na Obtenção de Dados

Quando obtendo dados em tempo real, problemas como falhas de rede podem ocorrer. Implemente tratamento de erros e configure uma nova tentativa em caso de falha.

import time

def update(frame):
    try:
        # Processo de obtenção de dados
        response = requests.get('https://api.example.com/data')
        response.raise_for_status()
        data = response.json()
        y_data.append(data['value'])
    except requests.exceptions.RequestException as e:
        print(f"Erro de obtenção de dados: {e}")
        time.sleep(5)  # Espera 5 segundos e tenta novamente
    return line,

Ajuste do Intervalo de Exibição

Quando os valores dos dados mudam dinamicamente, ajuste o intervalo de exibição do gráfico de acordo com os dados.

def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    ax.set_xlim(max(0, frame - 100), frame)  # Ajusta o intervalo de exibição dinamicamente
    ax.set_ylim(min(y_data), max(y_data))    # Ajusta o intervalo do eixo Y de acordo com os dados
    return line,

Suavização de Dados

Se os dados em tempo real tiverem muito ruído, aplicar uma suavização pode melhorar a visualização. No exemplo abaixo, usamos uma média móvel para suavizar os dados.

def smooth(data, window_size):
    return np.convolve(data, np.ones(window_size)/window_size, mode='valid')

def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    smoothed_data = smooth(y_data, window_size=5)
    line.set_data(range(len(smoothed_data)), smoothed_data)

    ax.set_xlim(0, len(smoothed_data))
    ax.set_ylim(min(smoothed_data), max(smoothed_data))
    return line,

Use essas dicas de resolução de problemas para melhorar a visualização de dados em tempo real e resolver problemas comuns.

A próxima seção traz um resumo dos conteúdos abordados.

Resumo

A plotagem de dados em tempo real é uma técnica importante para diversas aplicações, como monitoramento de dados de sensores e rastreamento de preços de ações. Com Matplotlib, é fácil implementar uma plotagem em tempo real usando Python.

Este guia abordou os seguintes pontos:

Conceitos básicos de plotagem em tempo real
Instalação e configuração do Matplotlib
Como obter dados de sensores ou APIs
Implementação básica de plotagem em tempo real com FuncAnimation
Configurações avançadas de animação para plotagem
Exemplos aplicados com dados de sensores e ações
Métodos para salvar e compartilhar dados
Problemas comuns e suas soluções

Ao entender e aplicar esses passos, você conseguirá visualizar dados em tempo real de forma mais eficaz. A visualização de dados é uma ferramenta poderosa para identificar tendências e detectar anomalias rapidamente. Experimente aplicá-la em seus projetos e pesquisas futuras.