Personalize seus Gráficos Matplotlib com Folhas de Estilo

Introdução

Matplotlib é uma poderosa biblioteca de visualização de dados em Python. Ela permite criar uma variedade de gráficos, como gráficos de dispersão (scatter plots), histogramas, gráficos de barras e muito mais. O script de referência de folhas de estilo demonstra as diferentes folhas de estilo disponíveis em um conjunto comum de gráficos de exemplo. Neste laboratório, você aprenderá como usar as folhas de estilo do Matplotlib para personalizar a aparência de seus gráficos.

Dicas para a VM

Após a inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook e acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido às limitações do Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos o problema prontamente para você.

Importar bibliotecas

Antes de começar, você precisa importar as bibliotecas necessárias. Neste laboratório, você usará Matplotlib e NumPy.

import matplotlib.pyplot as plt
import numpy as np

Definir as funções de plotagem

Em seguida, você precisa definir as funções de plotagem que serão usadas para criar os gráficos de exemplo. Nesta etapa, você definirá as seguintes funções de plotagem:

plot_scatter(): cria um gráfico de dispersão (scatter plot)
plot_colored_lines(): plota linhas com cores seguindo o ciclo de cores do estilo
plot_bar_graphs(): cria um gráfico de barras
plot_colored_circles(): plota círculos
plot_image_and_patch(): plota uma imagem com um patch circular
plot_histograms(): cria histogramas

def plot_scatter(ax, prng, nb_samples=100):
    """Gráfico de dispersão (Scatter plot)."""
    for mu, sigma, marker in [(-.5, 0.75, 'o'), (0.75, 1., 's')]:
        x, y = prng.normal(loc=mu, scale=sigma, size=(2, nb_samples))
        ax.plot(x, y, ls='none', marker=marker)
    ax.set_xlabel('X-label')
    ax.set_title('Título dos eixos')
    return ax


def plot_colored_lines(ax):
    """Plota linhas com cores seguindo o ciclo de cores do estilo."""
    t = np.linspace(-10, 10, 100)

    def sigmoid(t, t0):
        return 1 / (1 + np.exp(-(t - t0)))

    nb_colors = len(plt.rcParams['axes.prop_cycle'])
    shifts = np.linspace(-5, 5, nb_colors)
    amplitudes = np.linspace(1, 1.5, nb_colors)
    for t0, a in zip(shifts, amplitudes):
        ax.plot(t, a * sigmoid(t, t0), '-')
    ax.set_xlim(-10, 10)
    return ax


def plot_bar_graphs(ax, prng, min_value=5, max_value=25, nb_samples=5):
    """Plota dois gráficos de barras lado a lado, com letras como rótulos do eixo x."""
    x = np.arange(nb_samples)
    ya, yb = prng.randint(min_value, max_value, size=(2, nb_samples))
    width = 0.25
    ax.bar(x, ya, width)
    ax.bar(x + width, yb, width, color='C2')
    ax.set_xticks(x + width, labels=['a', 'b', 'c', 'd', 'e'])
    return ax


def plot_colored_circles(ax, prng, nb_samples=15):
    """
    Plota círculos.

    NB: desenha uma quantidade fixa de amostras, em vez de usar o comprimento do
    ciclo de cores, porque diferentes estilos podem ter diferentes números
    de cores.
    """
    for sty_dict, j in zip(plt.rcParams['axes.prop_cycle'](),
                           range(nb_samples)):
        ax.add_patch(plt.Circle(prng.normal(scale=3, size=2),
                                radius=1.0, color=sty_dict['color']))
    ax.grid(visible=True)

    ## Adiciona título para habilitar a grade
    plt.title('ax.grid(True)', family='monospace', fontsize='small')

    ax.set_xlim([-4, 8])
    ax.set_ylim([-5, 6])
    ax.set_aspect('equal', adjustable='box')  ## para plotar círculos como círculos
    return ax


def plot_image_and_patch(ax, prng, size=(20, 20)):
    """Plota uma imagem com valores aleatórios e sobrepõe um patch circular."""
    values = prng.random_sample(size=size)
    ax.imshow(values, interpolation='none')
    c = plt.Circle((5, 5), radius=5, label='patch')
    ax.add_patch(c)
    ## Remove ticks
    ax.set_xticks([])
    ax.set_yticks([])


def plot_histograms(ax, prng, nb_samples=10000):
    """Plota 4 histogramas e uma anotação de texto."""
    params = ((10, 10), (4, 12), (50, 12), (6, 55))
    for a, b in params:
        values = prng.beta(a, b, size=nb_samples)
        ax.hist(values, histtype="stepfilled", bins=30,
                alpha=0.8, density=True)

    ## Adiciona uma pequena anotação.
    ax.annotate('Anotação', xy=(0.25, 4.25),
                xytext=(0.9, 0.9), textcoords=ax.transAxes,
                va="top", ha="right",
                bbox=dict(boxstyle="round", alpha=0.2),
                arrowprops=dict(
                          arrowstyle="->",
                          connectionstyle="angle,angleA=-95,angleB=35,rad=10"),
                )
    return ax

Definir a função de plotagem

Agora, você precisa definir a função plot_figure() que configurará e plotará a figura de demonstração com um determinado estilo. Esta função chamará cada uma das funções de plotagem definidas no Passo 2.

def plot_figure(style_label=""):
    """Configura e plota a figura de demonstração com um determinado estilo."""
    ## Use uma instância RandomState dedicada para desenhar os mesmos valores "aleatórios"
    ## em todas as diferentes figuras.
    prng = np.random.RandomState(96917002)

    fig, axs = plt.subplots(ncols=6, nrows=1, num=style_label,
                            figsize=(14.8, 2.8), layout='constrained')

    ## faça um suptitle, no mesmo estilo para todas as subfiguras,
    ## exceto aquelas com fundos escuros, que recebem uma cor mais clara:
    background_color = mcolors.rgb_to_hsv(
        mcolors.to_rgb(plt.rcParams['figure.facecolor']))[2]
    if background_color < 0.5:
        title_color = [0.8, 0.8, 1]
    else:
        title_color = np.array([19, 6, 84]) / 256
    fig.suptitle(style_label, x=0.01, ha='left', color=title_color,
                 fontsize=14, fontfamily='DejaVu Sans', fontweight='normal')

    plot_scatter(axs[0], prng)
    plot_image_and_patch(axs[1], prng)
    plot_bar_graphs(axs[2], prng)
    plot_colored_lines(axs[3])
    plot_histograms(axs[4], prng)
    plot_colored_circles(axs[5], prng)

    ## adiciona divisor
    rec = Rectangle((1 + 0.025, -2), 0.05, 16,
                    clip_on=False, color='gray')

    axs[4].add_artist(rec)

Plotar a figura de demonstração para cada folha de estilo

Finalmente, você precisa plotar a figura de demonstração para cada folha de estilo disponível. Você pode fazer isso iterando sobre a style_list e chamando a função plot_figure() para cada folha de estilo.

if __name__ == "__main__":

    ## Configura uma lista de todos os estilos disponíveis, em ordem alfabética, mas
    ## os estilos `default` e `classic`, que serão forçados, respectivamente, na
    ## primeira e segunda posições.
    ## estilos com sublinhados no início são para uso interno, como testes
    ## e galeria de tipos de plotagem. Estes são excluídos aqui.
    style_list = ['default', 'classic'] + sorted(
        style for style in plt.style.available
        if style != 'classic' and not style.startswith('_'))

    ## Plota uma figura de demonstração para cada folha de estilo disponível.
    for style_label in style_list:
        with plt.rc_context({"figure.max_open_warning": len(style_list)}):
            with plt.style.context(style_label):
                plot_figure(style_label=style_label)

    plt.show()

Resumo

Neste laboratório, você aprendeu como usar as folhas de estilo do Matplotlib para personalizar a aparência de seus gráficos. Você aprendeu como definir funções de plotagem e usá-las para criar uma figura de demonstração com uma determinada folha de estilo. Seguindo os passos descritos neste laboratório, você pode aplicar as folhas de estilo do Matplotlib aos seus próprios gráficos para criar visualizações de dados com aparência profissional.

Folhas de Estilo Matplotlib