Tutorial de Animação do Matplotlib - Crie Visualizações Impressionantes

Name: Rajiv Chandra

Published on 17/08/2023

A visualização de dados é uma ferramenta poderosa nas mãos daqueles que sabem usá-la. Ela pode transformar conjuntos de dados complexos em insights compreensíveis e, com o uso de animações, esses insights podem se tornar ainda mais envolventes. É aqui que o Matplotlib, uma biblioteca versátil em Python, entra em jogo. O Matplotlib nos permite criar visualizações estáticas, animadas e interativas em Python, tornando-o uma ferramenta essencial para qualquer cientista de dados ou analista.

Neste tutorial, vamos nos concentrar nas capacidades de animação do Matplotlib. Vamos explorar como criar animações, os diferentes tipos de gráficos que você pode animar e os vários formatos nos quais você pode salvar suas animações. Também abordaremos alguns problemas comuns enfrentados pelos usuários, como animações que não funcionam em notebooks Jupyter, e forneceremos soluções para esses problemas. Portanto, se você é um cientista de dados experiente ou um iniciante começando agora, este tutorial tem algo para você.

Quer criar rapidamente Visualização de Dados a partir de um DataFrame do Python Pandas sem escrever código?

PyGWalker é uma biblioteca Python para Análise Exploratória de Dados com Visualização. PyGWalker (opens in a new tab) pode simplificar seu fluxo de trabalho de análise e visualização de dados no Jupyter Notebook, transformando seu dataframe do pandas (e dataframe do polars) em uma interface de usuário semelhante ao Tableau para exploração visual.

(opens in a new tab)

O que é Animação no Matplotlib?

Animação no Matplotlib é um recurso da biblioteca Matplotlib que permite a criação de visualizações dinâmicas. Ao contrário de gráficos estáticos, as animações podem mostrar mudanças ao longo do tempo, tornando-as uma excelente ferramenta para representar dados de séries temporais. Por exemplo, preços de ações ao longo dos anos, mudanças climáticas na última década ou qualquer fenômeno que muda ao longo do tempo pode ser demonstrado de forma eficaz usando animações.

O módulo de animação no Matplotlib é composto por várias classes que fornecem um framework para criar animações. A mais importante delas é a classe FuncAnimation, que é usada para criar animações chamando repetidamente uma função (daí o nome FuncAnimation). Essa classe facilita a criação de animações em que o estado (ou os dados) do gráfico é atualizado em cada quadro.

Criando uma Animação usando o Matplotlib

Criar uma animação no Matplotlib envolve alguns passos. Primeiro, você precisa configurar a figura e o eixo do gráfico. Em seguida, defina a função de animação, que atualiza os dados em cada quadro. Por fim, crie uma instância da classe FuncAnimation, passando a figura, a função de animação e o número de quadros como argumentos.

Aqui está um exemplo simples de criação de uma animação de gráfico de linha:

import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
# Configure a figura e o eixo
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'r-')
 
def init():
    ax.set_xlim(0, 2*np.pi)
    ax.set_ylim(-1, 1)
    return ln,
 
def update(frame):
    xdata.append(frame)
    ydata.append(np.sin(frame))
    ln.set_data(xdata, ydata)
    return ln,
 
ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128),
                    init_func=init, blit=True)
plt.show()

Neste exemplo, a função init configura os limites do gráfico e retorna o objeto de linha (ln). A função update é chamada para cada quadro, onde ela adiciona os novos dados (o seno do número do quadro) a ydata e atualiza os dados do objeto de linha. A classe FuncAnimation é então usada para criar a animação.

Tipos de Gráficos que Você Pode Animar com o Matplotlib

O Matplotlib é altamente versátil e permite que você anime uma ampla variedade de gráficos. Aqui estão alguns exemplos:

Gráficos de Linha: Como vimos na seção anterior, os gráficos de linha podem ser animados para mostrar a mudança de uma ou mais quantidades ao longo do tempo. Isso é particularmente útil para dados de séries temporais.
Gráficos de Dispersão: Gráficos de dispersão podem ser animados para mostrar o movimento de pontos em um espaço 2D. Isso pode ser usado para visualizar agrupamentos ou classificações dos pontos de dados ao longo do tempo.
Gráficos de Barras: Gráficos de barras podem ser animados para mostrar a mudança na quantidade representada pela altura das barras. Isso pode ser usado para visualizar mudanças em um conjunto de dados ao longo do tempo.
Histogramas: Histogramas podem ser animados para mostrar a mudança na distribuição de um conjunto de dados ao longo do tempo.
Gráficos 3D: O Matplotlib também suporta plotagem 3D. Você pode animar gráficos 3D para mostrar mudanças em um conjunto de dados 3D. Isso pode ser útil para visualizar dados científicos em 3D.
Subplots: Você pode animar vários subplots simultaneamente. Isso pode ser usado para comparar diferentes conjuntos de dados ou diferentes visualizações do mesmo conjunto de dados.

Lembre-se de que o tipo de gráfico que você escolhe para animar deve depender da natureza dos seus dados e do que você deseja transmitir com sua visualização.

Salvando sua Animação do Matplotlib

Depois de criar sua animação, você pode querer salvá-la para uso futuro ou para compartilhá-la com outras pessoas. O Matplotlib fornece o método Animation.save para esse propósito. Este método permite que você salve a animação em vários formatos, incluindo MP4, AVI e vídeo HTML5.

Aqui está um exemplo de como salvar uma animação:

ani.save('animation.mp4', writer='ffmpeg', fps=30)

Neste exemplo, a animação é salva como um arquivo MP4 usando o escritor FFmpeg. O parâmetro 'fps' especifica o número de frames por segundo na animação salva.

É importante notar que salvar animações requer ter um escritor apropriado instalado em seu sistema. Para a maioria dos formatos comuns, o Matplotlib automaticamente usará o escritor apropriado. No entanto, para alguns formatos, pode ser necessário instalar software adicional. Por exemplo, salvar animações como arquivos MP4 requer ter o FFmpeg instalado em seu sistema.

Na próxima parte deste tutorial, vamos nos aprofundar nos diferentes tipos de gráficos que você pode animar com o Matplotlib, e fornecer exemplos para cada um. Também discutiremos como animar gráficos 3D, como criar uma progress bar animada e como adicionar animações de texto aos seus gráficos. Fique ligado!

Animando Gráficos 3D com Matplotlib

As capacidades 3D do Matplotlib podem ser utilizadas para criar animações fascinantes que adicionam uma dimensão extra às suas visualizações de dados. O processo é semelhante à criação de animações 2D, mas em vez de criar um gráfico 2D, você cria um gráfico 3D usando a classe 'Axes3D'.

Aqui está um exemplo de criação de uma animação de superfície 3D:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from mpl_toolkits.mplot3d import Axes3D
 
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
 
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)
z = np.sin(np.sqrt(x**2 + y**2))
 
def update(num):
    ax.view_init(elev=10., azim=num)
    return ln,
 
ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 100), blit=True)
plt.show()

Neste exemplo, a função 'update' altera o ângulo de visualização do gráfico para cada frame, criando um efeito de rotação.

Criando uma Animação de Barra de Progresso usando o Matplotlib

As barras de progresso são uma ótima maneira de visualizar o progresso de um cálculo ou processo. Com o Matplotlib, você pode criar uma barra de progresso animada que atualiza em tempo real. Aqui está um exemplo simples:

import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
bar = plt.bar([0], [0], color='b')
 
def update(i):
    bar[0].set_height(i / 100.)
    return bar
 
ani = FuncAnimation(fig, update, frames=range(101), repeat=False)
plt.show()

Neste exemplo, a altura da barra é atualizada em cada frame, criando o efeito de uma barra de progresso sendo preenchida.

Adicionando Animações de Texto aos Gráficos do Matplotlib

Adicionar texto animado aos seus gráficos pode torná-los mais informativos e envolventes. Você pode animar o texto em seus gráficos do Matplotlib usando a classe 'Text' e a classe 'FuncAnimation'. Aqui está um exemplo:

import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
text = ax.text(0.5, 0.5, '', ha='center')
 
def update(i):
    text.set_text(f'Frame {i}')
    return text,
 
ani = FuncAnimation(fig, update, frames=range(10), blit=True)
plt.show()

Neste exemplo, o texto exibido no gráfico é atualizado em cada frame, criando uma animação de texto simples.

Animando Múltiplos Subplots com Matplotlib

O Matplotlib permite a criação de vários subplots dentro de uma única figura, e esses subplots podem ser animados individualmente. Isso é particularmente útil quando você deseja comparar diferentes conjuntos de dados ou diferentes visualizações do mesmo conjunto de dados lado a lado. Aqui está um exemplo de como animar múltiplos subplots:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, axs = plt.subplots(2)
 
x = np.linspace(0, 2*np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)
 
line1, = axs[0].plot(x, y1, color='blue')
line2, = axs[1].plot(x, y2, color='red')
 
def update(frame):
    line1.set_ydata(np.sin(x + frame / 100))
    line2.set_ydata(np.cos(x + frame / 100))
    return line1, line2
 
ani = FuncAnimation(fig, update, frames=range(100), blit=True)
plt.show()

Neste exemplo, temos dois subplots, um mostrando uma onda senoidal e o outro mostrando uma onda cossenoidal. A função 'update' altera a fase das ondas, criando uma animação de duas ondas se movendo em sincronia.

Criando Animações com Paletas de Cores Variáveis

Alterar a paleta de cores de sua animação pode adicionar uma camada extra de informação à sua visualização. Por exemplo, você pode usar cor para representar uma terceira dimensão em um gráfico 2D, ou para destacar pontos de dados específicos. Aqui está um exemplo de como criar uma animação com uma paleta de cores variáveis:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.cm import get_cmap
 
fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)
scat = ax.scatter(x, y, c=y, cmap=get_cmap('viridis'))
 
def update(frame):
    y = np.sin(x + frame / 100)
    scat.set_offsets(np.c_[x, y])
    scat.set_array(y)
    return scat,
 
ani = FuncAnimation(fig, update, frames=range(100), blit=True)
plt.show()

Neste exemplo, usamos a função 'scatter' para criar um gráfico de dispersão de uma onda senoidal, onde a cor de cada ponto é determinada pelo seu valor y. A função 'update' altera a fase da onda e atualiza as cores dos pontos, criando uma animação de uma onda em movimento com uma paleta de cores variáveis.

Animando Dados em Tempo Real com o Matplotlib

As animações do Matplotlib também podem ser usadas para visualizar dados em tempo real. Isso pode ser útil em uma variedade de aplicações, como monitorar dados de sensores, acompanhar os preços das ações ou visualizar algoritmos de aprendizado de máquina. Aqui está um exemplo de como animar dados em tempo real:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
line, = ax.plot([])
 
def update(frame):
    line.set_data(range(frame), np.random.rand(frame))
    ax.relim()
    ax.autoscale_view()
    return line,
 
ani = FuncAnimation(fig, update, frames=range(1, 101), blit=True)
plt.show()

Neste exemplo, a função update gera um novo ponto de dados aleatório para cada quadro, simulando dados em tempo real. Os limites do gráfico são atualizados em cada quadro para acomodar os novos dados.

Usando o Matplotlib para Animações de Simulações Científicas

As capacidades de animação do Matplotlib podem ser usadas para visualizar simulações científicas.

Por exemplo, você pode animar o movimento de partículas em uma simulação de física, o crescimento de uma população em uma simulação de biologia ou a propagação de uma doença em uma simulação de epidemiologia. Aqui está um exemplo de como animar uma simples simulação de física de uma bola quicando:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ball = plt.Circle((5, 5), 0.5, color='blue')
ax.add_patch(ball)
 
vx, vy = 0.1, 0.2  # Velocidade
 
def update(frame):
    x, y = ball.center
    x += vx
    y += vy
    if x > 10 or x < 0:  # Quicar de volta se bater na borda
        vx *= -1
    if y > 10 or y < 0:
        vy *= -1
    ball.center = (x, y)
    return ball,
 
ani = FuncAnimation(fig, update, frames=range(100), blit=True)
plt.show()

Neste exemplo, a função update atualiza a posição da bola com base em sua velocidade e reverte a velocidade se a bola atingir a borda do gráfico, criando uma animação de uma bola quicando.

Perguntas Frequentes

O que é a Animação do Matplotlib?
A animação do Matplotlib é um recurso da biblioteca Matplotlib em Python que permite a criação de visualizações dinâmicas. Ao contrário de gráficos estáticos, animações podem mostrar mudanças ao longo do tempo, tornando-as uma excelente ferramenta para representar dados de séries temporais.
Como criar uma animação usando o Matplotlib?
A criação de uma animação no Matplotlib envolve a configuração da figura e do eixo do gráfico, a definição da função de animação, que atualiza os dados em cada quadro, e a criação de uma instância da classe FuncAnimation, passando a figura, a função de animação e o número de quadros como argumentos.
Quais tipos de gráficos posso animar com o Matplotlib?
O Matplotlib permite animar uma ampla variedade de gráficos, incluindo gráficos de linha, gráficos de dispersão, gráficos de barras, histogramas, gráficos 3D e subgráficos.

Troubleshooting: Matplotlib.pyplot Not Resolved From Source Unlocking the Power of Matplotlib Stylesheets for Enhanced Data Visualization