Tutorial bqplot: visualização interativa de dados no Jupyter Notebook

2024-07-12

Diretório de artigos

introduzir

1.1 A importância da visualização de dados

A visualização de dados consiste em exibir dados na forma de gráficos para ajudar as pessoas a compreender as informações e os padrões por trás dos dados de forma mais intuitiva e rápida. Na era atual de explosão de informações, a visualização de dados é particularmente importante pelos seguintes motivos:

Melhore a eficiência da compreensão : Os dados gráficos são mais fáceis de serem entendidos e lembrados pelo cérebro do que texto simples ou números. Através de gráficos, as pessoas podem capturar rapidamente os pontos-chave dos dados para tomar decisões mais informadas.
Revelar padrões de dados : a visualização de dados pode ajudar a descobrir padrões, tendências e valores discrepantes ocultos em seus dados. Por exemplo, um gráfico de linhas pode ver claramente como os dados mudam ao longo do tempo.
Melhorar o efeito de comunicação : Em áreas como negócios, pesquisa científica e educação, a visualização de dados é uma ferramenta poderosa para comunicar informações complexas. Torna os resultados da análise de dados mais fáceis de serem compreendidos e aceitos por outras pessoas.
Apoiar a tomada de decisões: A visualização de dados fornece aos tomadores de decisão suporte de dados intuitivo, ajudando-os a encontrar informações importantes em dados complexos e a tomar decisões mais científicas e razoáveis.

1.2 Visão geral da biblioteca bqplot

bqplot é baseado emGramática dos Gráficos Biblioteca de visualização 2D, especificamente paraCaderno Jupyter projeto.isto combinad3.js eWidgets do ipy recurso projetado para trazer os poderosos recursos de visualização do d3.js para Python. Aqui estão alguns recursos principais da biblioteca bqplot:

interatividade: o bqplot fornece funções interativas avançadas. Os usuários podem deslocar, ampliar, selecionar e outras operações no gráfico para explorar os dados mais profundamente.
flexibilidade: Usando uma abordagem orientada a objetos, os usuários podem criar gráficos altamente personalizados usando a Gramática de Gráficos.
Fácil de usar: bqplot fornece uma interface pyplot semelhante ao matplotlib, permitindo que usuários familiarizados com matplotlib comecem rapidamente.
Integração: Como biblioteca nativa do Jupyter Notebook, o bqplot pode ser perfeitamente integrado ao fluxo de trabalho de análise de dados, proporcionando aos usuários uma experiência interativa tranquila.

Instalação e início rápido

Instalar o bqplot é muito simples, basta executar o seguinte comando no terminal ou prompt de comando:

pip install bqplot
jupyter nbextension enable --py --sys-prefix bqplot
1
2

Após a instalação bem-sucedida, importe as bibliotecas necessárias para o Jupyter Notebook para começar a usar:

import numpy as np
import bqplot.pyplot as plt
1
2

Aqui está um exemplo simples que mostra como criar um histograma usando bqplot:

# 生成随机数据
data = np.random.randn(100)

# 创建直方图
fig = plt.figure(title='Histogram by bqplot')
hist = plt.hist(sample=data, bins=10, colors=['#01a2d9'])
fig
1
2
3
4
5
6
7

Através deste exemplo simples, você pode ver a facilidade de uso e as poderosas funções interativas do bqplot. Nos capítulos seguintes, nos aprofundaremos nos vários tipos de gráficos e recursos avançados do bqplot.

Instalar e importar

2.1 Instale o bqplot

Antes de começar a usar o bqplot para visualização de dados, primeiro você precisa instalar a biblioteca bqplot em seu ambiente. O bqplot pode ser instalado de várias maneiras, mais comumente usando pip ou conda. Aqui estão as etapas detalhadas para usar os dois métodos:

Instalar usando pip

pip install bqplot
1

Instalar usando conda

conda install -c conda-forge bqplot
1

Após a conclusão da instalação, você pode confirmar se a instalação foi bem-sucedida executando o seguinte comando:

import bqplot
print(bqplot.__version__)
1
2

2.2 Importe bibliotecas necessárias

Depois de instalar o bqplot, você precisa importar as bibliotecas necessárias para iniciar o trabalho de visualização de dados. Normalmente, você precisa importar as seguintes bibliotecas:

bqplot: Usado para criar gráficos interativos.
numpy: Usado para cálculos numéricos e processamento de dados.
pandas: Usado para manipulação e análise de dados.

Aqui está um exemplo de código para importar essas bibliotecas:

import bqplot.pyplot as plt
import numpy as np
import pandas as pd
1
2
3

Exemplo: importe e use bqplot para criar um gráfico simples

Para ter certeza de que tudo está configurado corretamente, você pode tentar criar um gráfico de barras simples. Aqui está um exemplo de código que mostra como importar as bibliotecas necessárias e criar um gráfico de barras simples:

# 导入必要的库
import bqplot.pyplot as plt
import numpy as np

# 创建一个简单的条形图
fig = plt.figure(title="简单条形图示例")
x = list("ABCDE")
y = np.random.rand(5)
bar = plt.bar(x, y)
fig
1
2
3
4
5
6
7
8
9
10

Neste exemplo, primeiro importamosbqplot.pyplotcomoplt, então usenumpy Gere dados aleatórios. A seguir, criamos um gráfico de barras simples com cinco barras e o exibimos em um Jupyter Notebook.

Através das etapas acima, você instalou e importou com sucesso a biblioteca bqplot e criou seu primeiro gráfico interativo simples. A seguir, você pode continuar explorando recursos e tipos de gráficos mais avançados.

Preparação do conjunto de dados

3.1 Importar conjunto de dados

Antes de começar a usar bqplot Antes de executar a visualização de dados, primeiro você precisa importar o conjunto de dados necessário.Aqui estão alguns métodos comuns de importação de conjuntos de dados e como usá-lospandas biblioteca para processar esses dados.

Importe arquivos CSV usando pandas

pandas É uma biblioteca poderosa de processamento de dados amplamente utilizada para análise e pré-processamento de dados.Veja como usarpandas Exemplo de importação de um arquivo CSV:

import pandas as pd

# 导入CSV文件
df1 = pd.read_csv("../input/autompg-dataset/auto-mpg.csv")
1
2
3
4

Use pandas para importar dados em outros formatos

Além dos arquivos CSV,pandas Ele também suporta a importação de dados em vários formatos, como arquivos Excel, arquivos JSON, etc. aqui estão alguns exemplos:

# 导入Excel文件
df_excel = pd.read_excel("../input/dataset.xlsx")

# 导入JSON文件
df_json = pd.read_json("../input/dataset.json")
1
2
3
4
5

Use pandas para importar dados do banco de dados

Se os dados estiverem armazenados em um banco de dados, você pode usar pandas deread_sql função para importar dados. Aqui está um exemplo:

import sqlite3

# 连接到SQLite数据库
conn = sqlite3.connect('../input/database.db')

# 从数据库中读取数据
df_sql = pd.read_sql('SELECT * FROM table_name', conn)
1
2
3
4
5
6
7

3.2 Visualização do conjunto de dados

Depois de importar um conjunto de dados, geralmente é necessário visualizá-lo para compreender a estrutura e o conteúdo dos dados.pandas Vários métodos são fornecidos para visualizar o conjunto de dados.

Visualize as primeiras linhas do conjunto de dados

usar head() Método para visualizar as primeiras linhas do conjunto de dados:

# 查看前5行数据
print(df1.head())
1
2

Visualizar informações básicas sobre o conjunto de dados

usar info() O método pode visualizar as informações básicas do conjunto de dados, incluindo tipo de dados e valores ausentes:

# 查看数据集的基本信息
print(df1.info())
1
2

Ver estatísticas de um conjunto de dados

usar describe() O método pode visualizar as informações estatísticas do conjunto de dados, incluindo média, desvio padrão, valor mínimo, valor máximo, etc.:

# 查看数据集的统计信息
print(df1.describe())
1
2

Visualize os nomes das colunas do conjunto de dados

usar columns As propriedades podem visualizar os nomes das colunas do conjunto de dados:

# 查看数据集的列名
print(df1.columns)
1
2

Através dos métodos acima, você pode ter uma compreensão básica do conjunto de dados importados, estabelecendo assim a base para o trabalho subsequente de visualização de dados.

{
  "title": "bqplot教程：在Jupyter Notebook中进行交互式数据可视化",
  "summary": "本文详细介绍了如何使用bqplot库在Jupyter Notebook中进行交互式数据可视化。bqplot是一个基于Grammar of Graphics的2D可视化解决方案，结合了d3.js和ipywidgets的功能，旨在将d3.js的功能带到Python中。",
  "content_outline": [
    {
      "h1": "基本图表类型",
      "h2": [
        "4.1 散点图",
        "4.2 饼图",
        "4.3 箱线图",
        "4.4 条形图",
        "4.5 堆积条形图"
      ]
    }
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Tipos básicos de gráficos

4.1 Gráfico de dispersão

Um gráfico de dispersão é um gráfico usado para mostrar a relação entre duas variáveis. Os gráficos de dispersão permitem observar visualmente a distribuição e correlação dos dados. No bqplot, criar gráficos de dispersão é muito simples.

import bqplot as bq
import numpy as np

# 创建数据
x = np.random.rand(100)
y = np.random.rand(100)

# 创建尺度
x_sc = bq.LinearScale()
y_sc = bq.LinearScale()

# 创建散点标记
scatter = bq.Scatter(x=x, y=y, scales={'x': x_sc, 'y': y_sc})

# 创建轴
ax_x = bq.Axis(scale=x_sc, label='X Axis')
ax_y = bq.Axis(scale=y_sc, orientation='vertical', label='Y Axis')

# 创建图表
fig = bq.Figure(marks=[scatter], axes=[ax_x, ax_y], title='Scatter Plot')

# 显示图表
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.2 Gráfico de pizza

Pie Chart é um gráfico usado para exibir a proporção de dados. No bqplot, criar gráficos de pizza é igualmente fácil.

import bqplot as bq

# 创建数据
data = [10, 20, 30, 40]
labels = ['A', 'B', 'C', 'D']

# 创建饼图标记
pie = bq.Pie(sizes=data, labels=labels)

# 创建图表
fig = bq.Figure(marks=[pie], title='Pie Chart')

# 显示图表
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.3 Gráfico de caixa

Um box plot é um gráfico usado para exibir a distribuição de dados. Ele pode exibir a mediana, quartis e valores discrepantes dos dados.

import bqplot as bq
import numpy as np

# 创建数据
data = [np.random.normal(0, 1, 100), np.random.normal(3, 1, 100), np.random.normal(6, 1, 100)]

# 创建尺度
x_sc = bq.OrdinalScale()
y_sc = bq.LinearScale()

# 创建箱线图标记
boxplot = bq.Boxplot(x=data, scales={'x': x_sc, 'y': y_sc})

# 创建轴
ax_x = bq.Axis(scale=x_sc, label='Groups')
ax_y = bq.Axis(scale=y_sc, orientation='vertical', label='Values')

# 创建图表
fig = bq.Figure(marks=[boxplot], axes=[ax_x, ax_y], title='Box Plot')

# 显示图表
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.4 Gráfico de barras

Um gráfico de barras é um gráfico usado para exibir comparações entre dados categóricos. A altura de cada barra representa o valor dos dados para aquela categoria.

import bqplot as bq

# 创建数据
x_labels = ['A', 'B', 'C', 'D']
y_values = [30, 20, 40, 10]

# 创建尺度
x_sc = bq.OrdinalScale()
y_sc = bq.LinearScale()

# 创建条形图标记
bar = bq.Bars(x=x_labels, y=y_values, scales={'x': x_sc, 'y': y_sc})

# 创建轴
ax_x = bq.Axis(scale=x_sc, label='Categories')
ax_y = bq.Axis(scale=y_sc, orientation='vertical', label='Values')

# 创建图表
fig = bq.Figure(marks=[bar], axes=[ax_x, ax_y], title='Bar Chart')

# 显示图表
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.5 Gráfico de barras empilhadas

Um gráfico de barras empilhadas é um gráfico usado para exibir comparações entre vários dados categóricos. A altura de cada barra representa o valor dos dados para aquela categoria, e cada barra pode ser dividida em segmentos, cada segmento representando uma subcategoria.

import bqplot as bq

# 创建数据
x_labels = ['A', 'B', 'C', 'D']
y_values = [
    [30, 20],
    [20, 30],
    [40, 10],
    [10, 40]
]

# 创建尺度
x_sc = bq.OrdinalScale()
y_sc = bq.LinearScale()

# 创建堆积条形图标记
stacked_bar = bq.Bars(x=x_labels, y=y_values, scales={'x': x_sc, 'y': y_sc}, type='stacked')

# 创建轴
ax_x = bq.Axis(scale=x_sc, label='Categories')
ax_y = bq.Axis(scale=y_sc, orientation='vertical', label='Values')

# 创建图表
fig = bq.Figure(marks=[stacked_bar], axes=[ax_x, ax_y], title='Stacked Bar Chart')

# 显示图表
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Tipos de gráficos avançados

5.1 Histograma

Um histograma é um tipo de gráfico usado para mostrar a distribuição de dados.existirbqplotem, pode ser usadoplt.hist função para criar um histograma. Aqui está um exemplo simples:

import numpy as np
import bqplot.pyplot as plt

# 生成随机数据
data = np.random.randn(1000)

# 创建直方图
fig = plt.figure()
hist = plt.hist(data, bins=30)
plt.title('Histogram of Random Data')
plt.xlabel('Value')
plt.ylabel('Frequency')

fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Neste exemplo, primeiro geramos 1.000 pontos de dados aleatórios e depois usamosplt.hist A função cria um histograma com 30 compartimentos. Você pode tornar seu gráfico mais claro e fácil de entender definindo títulos e rótulos de eixos.

5.2 Gráfico de linhas

Os gráficos de linhas são um tipo de gráfico comum usado para mostrar tendências nos dados ao longo do tempo ou outras variáveis contínuas.existirbqplotem, pode ser usadoplt.plot função para criar um gráfico de linhas. Aqui está um exemplo:

import numpy as np
import bqplot.pyplot as plt

# 生成数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 创建折线图
fig = plt.figure()
line = plt.plot(x, y)
plt.title('Line Chart of Sine Function')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')

fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Neste exemplo, geramos dados de função senoidal com 100 pontos de dados e então usamosplt.plot A função cria um gráfico de linhas. Você pode tornar seu gráfico mais claro e fácil de entender definindo títulos e rótulos de eixos.

5.3 Gráfico de velas

Os gráficos de velas (também conhecidos como gráficos de velas) são um tipo de gráfico usado para exibir dados financeiros, como preços de ações.existirbqplotem, pode ser usadoplt.candle função para criar gráficos de velas. Aqui está um exemplo:

import numpy as np
import bqplot.pyplot as plt

# 生成随机金融数据
n = 100
open_prices = np.random.randn(n)
high_prices = open_prices + np.random.rand(n)
low_prices = open_prices - np.random.rand(n)
close_prices = open_prices + np.random.randn(n) * 0.5

# 创建蜡烛图
fig = plt.figure()
candle = plt.candle(open_prices, high_prices, low_prices, close_prices)
plt.title('Candlestick Chart of Random Financial Data')
plt.xlabel('Time')
plt.ylabel('Price')

fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Neste exemplo, geramos dados aleatórios de preços de abertura, máxima, mínima e fechamento e, em seguida, usamosplt.candle A função cria um gráfico de velas. Você pode tornar seu gráfico mais claro e fácil de entender definindo títulos e rótulos de eixos.

5.4 Mapa de calor

Um mapa de calor é um tipo de gráfico usado para exibir a distribuição de densidade ou intensidade de dados bidimensionais.existirbqplotem, pode ser usadoplt.heatmap função para criar um mapa de calor. Aqui está um exemplo:

import numpy as np
import bqplot.pyplot as plt

# 生成随机数据
data = np.random.rand(10, 10)

# 创建热力图
fig = plt.figure()
heatmap = plt.heatmap(data)
plt.title('Heatmap of Random Data')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')

fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Neste exemplo, geramos uma matriz 10x10 de dados aleatórios e então usamosplt.heatmap A função cria um mapa de calor. Você pode tornar seu gráfico mais claro e fácil de entender definindo títulos e rótulos de eixos.

5.5 Mapa geográfico

Um gráfico geográfico é um tipo de gráfico usado para exibir dados geográficos, como um mapa.existirbqplotem, pode ser usadoplt.geo função para criar mapas geográficos. Aqui está um exemplo:

import bqplot.pyplot as plt

# 加载地理数据
map_data = 'World'

# 创建地理图
fig = plt.figure()
geo = plt.geo(map_data)
plt.title('Geographical Map')

fig
1
2
3
4
5
6
7
8
9
10
11

Neste exemplo, carregamos os dados do mapa mundial e depois usamosplt.geo A função cria um mapa geográfico. Ao definir um título, você pode tornar seu gráfico mais claro e fácil de entender.

recursos interativos

6.1 Visão geral dos componentes interativos

Na visualização de dados, as funções interativas são fundamentais para melhorar a experiência do usuário e os recursos de exploração de dados.bqplot Fornece componentes interativos avançados para permitir que os usuários conduzam exploração de dados dinâmica e responsiva no Jupyter Notebook. Esses componentes interativos incluem, mas não estão limitados a:

Zoom e panorâmica: permite ao usuário aumentar ou diminuir o zoom do gráfico, bem como deslocar-se pelo gráfico para visualizar diferentes áreas de dados.
Selecione e deslize: permite que os usuários selecionem pontos de dados ou áreas específicas em um gráfico para análise posterior.
dica de ferramenta: exibe informações detalhadas quando o mouse passa sobre um ponto de dados.
Atualizações dinâmicas: permite que os gráficos sejam atualizados dinamicamente com base na entrada do usuário ou nas alterações de dados.

Esses componentes interativos são bqplot deInteractions A implementação do módulo fornece aos usuários ferramentas de exploração de dados intuitivas e poderosas.

6.2 Uso de componentes interativos comuns

Zoom e panorâmica

Zoom e panorâmica são as funções interativas mais básicas na visualização de dados.bqplot Fornece funções integradas de zoom e panorâmica, os usuários podem ampliar através da roda do mouse e deslocar arrastando o mouse. Aqui está um exemplo simples:

import bqplot.pyplot as plt
import numpy as np

# 创建数据
x = np.linspace(-10, 10, 100)
y = np.sin(x)

# 创建图表
fig = plt.figure(title="Zoom and Pan Example")
plt.plot(x, y)
plt.show()
1
2
3
4
5
6
7
8
9
10
11

Neste exemplo, o usuário pode aumentar ou diminuir o zoom do gráfico usando a roda do mouse e deslocar o gráfico arrastando o mouse.

Selecione e deslize

Os recursos de seleção e pincel permitem que os usuários selecionem pontos de dados ou áreas específicas em um gráfico para análise posterior.bqplot oferecidoBrushSelector eLassoSelector componentes para implementar esta funcionalidade.O seguinte é um usoBrushSelector Exemplo:

from bqplot import BrushSelector

# 创建选择器
brush = BrushSelector(x_scale=x_scale, y_scale=y_scale)

# 将选择器添加到图表
fig.interaction = brush
1
2
3
4
5
6
7

Neste exemplo, o usuário pode selecionar uma área retangular no gráfico arrastando o mouse e os pontos de dados selecionados serão destacados.

dica de ferramenta

As dicas de ferramentas podem exibir informações detalhadas quando o usuário passa o mouse sobre um ponto de dados.bqplot oferecidoTooltip componente para obter essa funcionalidade. Aqui está um exemplo simples:

from bqplot import Tooltip

# 创建工具提示
tooltip = Tooltip(fields=['x', 'y'], formats=['.2f', '.2f'])

# 将工具提示添加到图表
scatter.tooltip = tooltip
1
2
3
4
5
6
7

Neste exemplo, quando o usuário passa o mouse sobre um ponto de dados do gráfico de dispersão, o x ey valor.

Atualizações dinâmicas

O recurso de atualização dinâmica permite que os gráficos sejam atualizados dinamicamente com base na entrada do usuário ou nas alterações de dados.bqplot oferecidointeracts módulo para implementar esta funcionalidade. Aqui está um exemplo simples:

from ipywidgets import IntSlider

# 创建滑块
slider = IntSlider(value=50, min=0, max=100, step=1)

# 定义更新函数
def update_plot(change):
    new_value = change['new']
    scatter.x = np.linspace(0, new_value, 100)

# 绑定滑块到更新函数
slider.observe(update_plot, names='value')

# 显示滑块和图表
slider
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Neste exemplo, o usuário pode atualizar dinamicamente os dados do gráfico ajustando o valor do controle deslizante.

Recursos e aplicativos avançados

7.1 Painel interativo

Os painéis interativos são uma aplicação importante na visualização de dados, que permitem aos usuários explorar dados dinamicamente por meio de componentes interativos para obter uma compreensão mais profunda das informações por trás dos dados. bqplot fornece recursos poderosos para criar painéis interativos. Aqui está um exemplo simples que mostra como criar um painel contendo vários gráficos e componentes interativos.

Para criar um painel interativo

Importe as bibliotecas necessárias：

import bqplot as bq
import ipywidgets as widgets
from bqplot import pyplot as plt
import numpy as np
1
2
3
4

Preparar dados：

x = np.arange(100)
y = np.random.randn(100).cumsum()
1
2

Crie um componente gráfico：

line_chart = plt.plot(x, y, 'Line Chart')
bar_chart = plt.bar(x, y, 'Bar Chart')
1
2

Crie componentes interativos：

dropdown = widgets.Dropdown(
    options=['Line Chart', 'Bar Chart'],
    value='Line Chart',
    description='Chart Type:'
)
1
2
3
4
5

Definir lógica de interação：

def on_change(change):
    if change['new'] == 'Line Chart':
        plt.clear()
        plt.plot(x, y, 'Line Chart')
    elif change['new'] == 'Bar Chart':
        plt.clear()
        plt.bar(x, y, 'Bar Chart')

dropdown.observe(on_change, names='value')
1
2
3
4
5
6
7
8
9

Componentes compostos：

dashboard = widgets.VBox([dropdown, plt.figure])
display(dashboard)
1
2

Através das etapas acima, podemos criar um painel interativo simples onde os usuários podem selecionar diferentes tipos de gráficos por meio do menu suspenso para obter visualização dinâmica de dados.

7.2 Seletores de Dados (Seletores)

Os seletores de dados são componentes importantes no bqplot para filtragem e interação de dados. Através do seletor de dados, os usuários podem selecionar e operar os dados diretamente no gráfico para obter análises de dados mais refinadas.

Exemplo de uso do seletor de dados

Importe as bibliotecas necessárias：

import bqplot as bq
import ipywidgets as widgets
from bqplot import pyplot as plt
import numpy as np
1
2
3
4

Preparar dados：

x = np.arange(100)
y = np.random.randn(100).cumsum()
1
2

Criar gráfico：

scatter_chart = plt.scatter(x, y, 'Scatter Chart')
1

Criar seletor de dados：

selector = bq.interacts.BrushSelector(x_scale=scatter_chart.scales['x'], y_scale=scatter_chart.scales['y'])
scatter_chart.interaction = selector
1
2

Definir lógica de seleção：

def on_selection(change):
    selected_data = scatter_chart.selected
    print(f"Selected Data: {selected_data}")

selector.observe(on_selection, names='selected')
1
2
3
4
5

Mostrar gráfico：
```
display(plt.figure)
1
```

Através das etapas acima, podemos criar um seletor de dados no gráfico de dispersão. O usuário pode selecionar pontos de dados arrastando o mouse e gerar os dados selecionados no console.

7.3 Aplicações avançadas de projeção e mapa

O bqplot não apenas oferece suporte a gráficos 2D básicos, mas também fornece funções poderosas de gráficos geográficos que podem ser usadas para criar várias projeções de mapas e gráficos geográficos avançados.

Exemplo de criação de um mapa geográfico

Importe as bibliotecas necessárias：

import bqplot as bq
import ipywidgets as widgets
from bqplot import pyplot as plt
import numpy as np
1
2
3
4

Preparar dados geográficos：

import json
with open('world.json') as f:
    world_data = json.load(f)
1
2
3

Crie um mapa geográfico：

map_chart = bq.Map(
    map_data=bq.topo_load('world.json'),
    scales={'projection': bq.AlbersUSA()}
)
1
2
3
4

Crie componentes interativos：

dropdown = widgets.Dropdown(
    options=['AlbersUSA', 'Mercator', 'Orthographic'],
    value='AlbersUSA',
    description='Projection:'
)
1
2
3
4
5

Definir lógica de interação：

def on_change(change):
    if change['new'] == 'AlbersUSA':
        map_chart.scales['projection'] = bq.AlbersUSA()
    elif change['new'] == 'Mercator':
        map_chart.scales['projection'] = bq.Mercator()
    elif change['new'] == 'Orthographic':
        map_chart.scales['projection'] = bq.Orthographic()

dropdown.observe(on_change, names='value')
1
2
3
4
5
6
7
8
9

Componentes compostos：

map_dashboard = widgets.VBox([dropdown, map_chart])
display(map_dashboard)
1
2

Através das etapas acima, podemos criar um mapa geográfico que suporta múltiplas projeções de mapas. Os usuários podem selecionar diferentes métodos de projeção através do menu suspenso para obter uma exibição dinâmica do mapa.

Por meio dessas funções e aplicativos avançados, o bqplot fornece aos usuários ferramentas poderosas de visualização de dados, tornando a análise interativa de dados no Jupyter Notebook mais conveniente e eficiente.

Documentação da API

8.1 Pyplot

bqplot fornece algo comomatplotlib depyplot A API permite que os usuários criem e exibam gráficos rapidamente.A seguir estão alguns comumente usadospyplot Funções e exemplos:

figure(): Crie um novo gráfico.
plot(): desenhe um gráfico de linhas.
scatter(): desenhe um gráfico de dispersão.
bar(): desenhe um gráfico de barras.
pie(): desenhe um gráfico de pizza.
hist(): desenhe um histograma.

Código de amostra:

from bqplot import pyplot as plt
import numpy as np

# 创建数据
x = np.arange(10)
y = x ** 2

# 创建图形
fig = plt.figure()

# 绘制折线图
plt.plot(x, y)

# 显示图形
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

8.2 Modelo de objeto

bqplot O modelo de objeto é baseado na Gramática de Gráficos, proporcionando uma maneira mais flexível e detalhada de personalizar gráficos. Aqui estão alguns objetos principais e exemplos:

Figure: Contêiner do gráfico, contendo todos os marcadores e eixos.
Mark: Elementos gráficos específicos, como linhas, pontos, barras, etc.
Axis: Eixo.
Scale: Mapeamento de dados para gráfico.

Código de amostra:

from bqplot import Figure, Axis, Scale, Lines
import numpy as np

# 创建数据
x = np.arange(10)
y = x ** 2

# 创建比例尺
x_scale = Scale(min=0, max=10)
y_scale = Scale(min=0, max=100)

# 创建轴
x_axis = Axis(scale=x_scale, label='X Axis')
y_axis = Axis(scale=y_scale, label='Y Axis', orientation='vertical')

# 创建标记
line = Lines(x=x, y=y, scales={'x': x_scale, 'y': y_scale})

# 创建图形
fig = Figure(marks=[line], axes=[x_axis, y_axis])

# 显示图形
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8.3 Dicas de ferramentas e barras de ferramentas

bqplot Fornece dicas de ferramentas e funções de barra de ferramentas avançadas, permitindo que os usuários interajam com os gráficos de maneira mais conveniente.

Tooltip: exibe informações de dados quando o mouse é passado.
Toolbar: fornece funções interativas, como zoom e panorâmica.

Código de amostra:

from bqplot import Tooltip, Toolbar

# 创建工具提示
tooltip = Tooltip(fields=['x', 'y'], formats=['.2f', '.2f'])

# 创建工具栏
toolbar = Toolbar(figure=fig)

# 添加到图形
line.tooltip = tooltip
fig.toolbar = toolbar

# 显示图形
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14

8.4 Interação e Mapa de Mercado

bqplot Suporta funções interativas complexas, como seleção, zoom, panorâmica, etc. também,bqplot Também pode ser usado para criar visualizações avançadas, como mapas de mercado.

Código de amostra:

from bqplot import MarketMap
import pandas as pd

# 创建数据
data = pd.DataFrame({
    'label': ['A', 'B', 'C', 'D'],
    'values': [100, 200, 150, 300],
    'color': ['red', 'green', 'blue', 'yellow']
})

# 创建市场地图
market_map = MarketMap(names=data['label'], values=data['values'], colors=data['color'])

# 创建图形
fig = Figure(marks=[market_map])

# 显示图形
fig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Através da introdução dos documentos API acima, os usuários podem compreender e usar melhor bqplot biblioteca para criar visualizações de dados ricas e interativas.

Guias e contribuições de migração

9.1 Guia de migração

Existem alguns desafios que você pode encontrar ao migrar projetos existentes de outras bibliotecas de visualização de dados, como Matplotlib ou Plotly para bqplot. Aqui estão algumas etapas e considerações importantes para ajudá-lo a navegar no processo de migração.

9.1.1 Compreender os conceitos básicos do bqplot

Antes de iniciar a migração, primeiro você precisa entender os conceitos básicos do bqplot, incluindo:

Balanças: Defina o método de mapeamento de dados, como escala linear, escala logarítmica, etc.
Marcas: Representa elementos visuais em gráficos, como pontos de dispersão, linhas, barras, etc.
Eixos: Defina o eixo de coordenadas do gráfico.
Interações: defina como os usuários interagem com o gráfico.

9.1.2 Preparação de dados

Certifique-se de que seus dados estejam prontos e possam ser facilmente convertidos para o formato exigido pelo bqplot. Normalmente, os dados podem ser armazenados em um Pandas DataFrame, que permite fácil manipulação e visualização dos dados.

9.1.3 Migração gradual

Importe as bibliotecas necessárias：

import bqplot as bq
import pandas as pd
import numpy as np
1
2
3

Crie escalas e eixos：

x_sc = bq.LinearScale()
y_sc = bq.LinearScale()
ax_x = bq.Axis(scale=x_sc, label='X Axis')
ax_y = bq.Axis(scale=y_sc, label='Y Axis', orientation='vertical')
1
2
3
4

Criar etiqueta：

data = pd.DataFrame(np.random.randn(100, 2), columns=['X', 'Y'])
scatter = bq.Scatter(x=data['X'], y=data['Y'], scales={'x': x_sc, 'y': y_sc})
1
2

Criar gráfico：

fig = bq.Figure(axes=[ax_x, ax_y], marks=[scatter])
1

Mostrar gráfico：
```
display(fig)
1
```

9.1.4 Tratamento de interações

bqplot fornece funções interativas ricas, que podem ser alcançadas definindo propriedades diferentes. Por exemplo, para ativar a funcionalidade de zoom e panorâmica:

scatter.enable_move = True
scatter.enable_zoom = True
1
2

9.1.5 Estilos personalizados

bqplot permite que você personalize o estilo do seu gráfico, incluindo cor, estilo do marcador, estilo da linha, etc. Por exemplo, para personalizar a aparência de um gráfico de dispersão:

scatter = bq.Scatter(x=data['X'], y=data['Y'], scales={'x': x_sc, 'y': y_sc}, colors=['blue'], default_size=20, marker='triangle-up', stroke='black')
1

9.2 Diretrizes de Contribuição

bqplot é um projeto de código aberto e os membros da comunidade são bem-vindos para contribuir com código, documentação e exemplos. Aqui estão algumas diretrizes de contribuição para ajudá-lo a começar a contribuir para o projeto bqplot.

9.2.1 Configurar o ambiente de desenvolvimento

Clonar repositório：

git clone https://github.com/bqplot/bqplot.git
cd bqplot
1
2

Instalar dependências：
```
pip install -r requirements.txt
1
```
Instale a versão de desenvolvimento：
```
pip install -e .
1
```

9.2.2 Escrevendo código

Ao contribuir com código, siga estas diretrizes:

estilo de codificação:Siga o guia de estilo PEP 8.
documento: adicione documentação para novos recursos ou modificações.
teste:Escreva testes de unidade para garantir a exatidão do código.

9.2.3 Enviar PR

Crie uma filial：
```
git checkout -b my-new-feature
1
```

Confirmar alterações：

git add .
git commit -m "Add some feature"
1
2

empurrar ramo：
```
git push origin my-new-feature
1
```
Criar solicitação pull：
Crie uma nova solicitação pull no GitHub descrevendo suas mudanças e motivação.

9.2.4 Participar da comunidade

Participe de discussões: Participe da sala de bate-papo Gitter do bqplot ou do fórum de discussão GitHub para se comunicar com outros desenvolvedores.
Reportar um problema: Se você encontrar algum problema ou bug, envie um problema no GitHub.
Dar uma resposta: Forneça feedback sobre novos recursos ou melhorias para ajudar o projeto a se desenvolver melhor.

Seguindo essas diretrizes, você pode fazer uma contribuição valiosa para o projeto bqplot e ajudar a avançar na visualização interativa de dados na comunidade Python.

Resumo e Perspectiva

10.1 Vantagens e limitações do bqplot

Vantagem

bqplot é baseado emGramática dos Gráficos Sistema de visualização 2D, projetado paraCaderno Jupyter projeto. Tem as seguintes vantagens significativas:

interatividade: Cada componente do bqplot é um widget interativo, permitindo aos usuários integrar facilmente visualizações com outros widgets interativos Jupyter para criar interfaces gráficas de usuário (GUIs) complexas.
Fácil de usar: por meio de código Python simples, os usuários podem criar e personalizar rapidamente vários gráficos sem ter que entender profundamente a programação gráfica complexa.
flexibilidade: suporta uma variedade de tipos de gráficos, incluindo gráficos de dispersão, gráficos de pizza, gráficos de caixa, gráficos de barras, etc., para atender a diferentes necessidades de visualização de dados.
Integração: Perfeitamente integrado ao ecossistema Jupyter, facilitando o uso por cientistas e analistas de dados no processo de análise de dados.

limitações

Embora o bqplot forneça funcionalidade e flexibilidade poderosas, ele também tem algumas limitações:

desempenho: Para conjuntos de dados em grande escala, o desempenho do bqplot pode não ser tão bom quanto o de algumas ferramentas de visualização profissionais, especialmente ao lidar com gráficos complexos e grandes quantidades de dados.
curva de aprendizado: Embora o bqplot seja relativamente fácil de começar, para iniciantes ainda leva algum tempo para se familiarizarem com sua API e componentes interativos.
suporte da comunidade: Comparado com algumas bibliotecas de visualização maduras, o bqplot tem uma comunidade menor, o que pode resultar em recursos limitados para ajuda ao encontrar problemas.

10.2 Tendências futuras de desenvolvimento

Como um projeto ativo de código aberto, as tendências futuras de desenvolvimento do bqplot merecem atenção:

Otimização de performance: Com o desenvolvimento da tecnologia, espera-se que o bqplot receba melhorias significativas no desempenho e lide melhor com conjuntos de dados em grande escala e gráficos complexos.
Integração de novos recursos: Versões futuras podem introduzir tipos de gráficos mais avançados e recursos interativos, como visualização 3D, suporte a animação, etc.
crescimento da comunidade: À medida que a popularidade e o escopo de aplicação do bqplot se expandem, espera-se que sua comunidade continue a crescer e atraia mais desenvolvedores e usuários para participar.
Suporte multiplataforma: Além do Jupyter Notebook, o bqplot pode ser estendido a outras plataformas e ambientes para fornecer uma gama mais ampla de cenários de aplicação.

Resumindo, o bqplot, como uma poderosa ferramenta interativa de visualização de dados, tem amplas perspectivas de aplicação no campo da ciência de dados. Com otimização contínua e expansão de recursos, continuará a fornecer mais possibilidades de análise e visualização de dados.

Compartilhamento de tecnologia