Tutorial bqplot: visualizzazione interattiva dei dati in Jupyter Notebook

2024-07-12

Elenco degli articoli

introdurre

1.1 L'importanza della visualizzazione dei dati

La visualizzazione dei dati consiste nel visualizzare i dati sotto forma di grafici per aiutare le persone a comprendere le informazioni e i modelli dietro i dati in modo più intuitivo e rapido. Nell'era odierna dell'esplosione delle informazioni, la visualizzazione dei dati è particolarmente importante per i seguenti motivi:

Migliorare l’efficienza della comprensione : I dati grafici sono più facili da comprendere e ricordare per il cervello rispetto al semplice testo o ai numeri. Attraverso i grafici, le persone possono catturare rapidamente i punti chiave dei dati per prendere decisioni più informate.
Rivelare modelli di dati : la visualizzazione dei dati può aiutare a scoprire modelli, tendenze e valori anomali nascosti nei dati. Ad esempio, un grafico a linee può vedere chiaramente come i dati cambiano nel tempo.
Migliora l'effetto della comunicazione : In settori quali il business, la ricerca scientifica e l'istruzione, la visualizzazione dei dati è un potente strumento per comunicare informazioni complesse. Rende i risultati dell'analisi dei dati più facili da comprendere e accettare da altri.
Supportare il processo decisionale: La visualizzazione dei dati fornisce ai decisori un supporto intuitivo per i dati, aiutandoli a trovare informazioni chiave in dati complessi e a prendere decisioni più scientifiche e ragionevoli.

1.2 Panoramica della libreria bqplot

bqplot è basato suGrammatica della grafica Libreria di visualizzazione 2D, specifica perQuaderno di Jupyter progetto.combinad3.js Ewidgetipy funzionalità progettata per portare le potenti funzionalità di visualizzazione di d3.js in Python. Ecco alcune caratteristiche chiave della libreria bqplot:

interattività: bqplot fornisce ricche funzioni interattive Gli utenti possono eseguire la panoramica, lo zoom, la selezione e altre operazioni sul grafico per esplorare i dati in modo più approfondito.
flessibilità: Utilizzando un approccio orientato agli oggetti, gli utenti possono creare grafici altamente personalizzati utilizzando la Grammatica della Grafica.
Facilità d'uso: bqplot fornisce un'interfaccia pyplot simile a matplotlib, consentendo agli utenti che hanno familiarità con matplotlib di iniziare rapidamente.
Integrazione: Essendo la libreria nativa di Jupyter Notebook, bqplot può essere perfettamente integrato nel flusso di lavoro di analisi dei dati, fornendo agli utenti un'esperienza interattiva fluida.

Installazione e avvio rapido

Installare bqplot è molto semplice, basta eseguire il seguente comando nel terminale o nel prompt dei comandi:

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

Al termine dell'installazione, importa le librerie necessarie in Jupyter Notebook per iniziare a utilizzare:

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

Ecco un semplice esempio che mostra come creare un istogramma utilizzando 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

Attraverso questo semplice esempio, puoi vedere la facilità d'uso e le potenti funzioni interattive di bqplot. Nei capitoli seguenti approfondiremo i vari tipi di grafici e le funzionalità avanzate di bqplot.

Installa e importa

2.1 Installa bqplot

Prima di iniziare a utilizzare bqplot per la visualizzazione dei dati, devi prima installare la libreria bqplot nel tuo ambiente. bqplot può essere installato in diversi modi, più comunemente utilizzando pip o conda. Ecco i passaggi dettagliati per utilizzare entrambi i metodi:

Installa utilizzando pip

pip install bqplot
1

Installa utilizzando conda

conda install -c conda-forge bqplot
1

Al termine dell'installazione, è possibile verificare se l'installazione è andata a buon fine eseguendo il comando seguente:

import bqplot
print(bqplot.__version__)
1
2

2.2 Importare le librerie necessarie

Dopo aver installato bqplot, dovrai importare le librerie necessarie per iniziare il lavoro di visualizzazione dei dati. In genere è necessario importare le seguenti librerie:

bqplot: Utilizzato per creare grafici interattivi.
numpy: Utilizzato per calcoli numerici ed elaborazione dati.
pandas: Utilizzato per la manipolazione e l'analisi dei dati.

Ecco un codice di esempio per importare queste librerie:

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

Esempio: importa e utilizza bqplot per creare un grafico semplice

Per assicurarti che tutto sia impostato correttamente, puoi provare a creare un semplice grafico a barre. Ecco un codice di esempio che mostra come importare le librerie necessarie e creare un semplice grafico a barre:

# 导入必要的库
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

In questo esempio, importiamo primabqplot.pyplotCOMEplt, quindi utilizzarenumpy Genera dati casuali. Successivamente, abbiamo creato un semplice grafico a barre con cinque barre e lo abbiamo visualizzato in un Jupyter Notebook.

Attraverso i passaggi precedenti, hai installato e importato con successo la libreria bqplot e creato il tuo primo semplice grafico interattivo. Successivamente, puoi continuare a esplorare funzionalità e tipi di grafici più avanzati.

Preparazione del set di dati

3.1 Importare set di dati

Prima di iniziare a utilizzare bqplot Prima di poter eseguire la visualizzazione dei dati, è necessario importare il set di dati richiesto.Di seguito sono riportati alcuni metodi comuni di importazione di set di dati e come utilizzarlipandas biblioteca per elaborare questi dati.

Importa file CSV utilizzando Panda

pandas È una potente libreria di elaborazione dati ampiamente utilizzata per l'analisi e la preelaborazione dei dati.Ecco come utilizzarepandas Esempio di importazione di un file CSV:

import pandas as pd

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

Utilizza i panda per importare dati in altri formati

Oltre ai file CSV,pandas Supporta anche l'importazione di dati in più formati, come file Excel, file JSON, ecc. Ecco alcuni esempi:

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

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

Usa i panda per importare dati dal database

Se i dati sono archiviati in un database, è possibile utilizzare pandas Diread_sql funzione per importare i dati. Ecco un esempio:

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 Anteprima del set di dati

Dopo aver importato un set di dati, in genere è necessario visualizzarne l'anteprima per comprendere la struttura e il contenuto dei dati.pandas Sono forniti vari metodi per visualizzare in anteprima il set di dati.

Visualizza le prime righe del set di dati

utilizzo head() Metodo per visualizzare le prime righe del set di dati:

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

Visualizza le informazioni di base sul set di dati

utilizzo info() Il metodo può visualizzare le informazioni di base del set di dati, inclusi il tipo di dati e i valori mancanti:

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

Visualizza le statistiche per un set di dati

utilizzo describe() Il metodo può visualizzare le informazioni statistiche del set di dati, tra cui media, deviazione standard, valore minimo, valore massimo, ecc.:

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

Visualizza i nomi delle colonne del set di dati

utilizzo columns Le proprietà possono visualizzare i nomi delle colonne del set di dati:

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

Attraverso i metodi sopra indicati, è possibile acquisire una conoscenza di base del set di dati importati, ponendo così le basi per il successivo lavoro di visualizzazione dei dati.

{
  "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

Tipi di grafici di base

4.1 Grafico a dispersione

Un grafico a dispersione è un grafico utilizzato per mostrare la relazione tra due variabili. I grafici a dispersione consentono di osservare visivamente la distribuzione e la correlazione dei dati. In bqplot, creare grafici a dispersione è molto semplice.

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 Grafico a torta

Il grafico a torta è un grafico utilizzato per visualizzare la proporzione dei dati. In bqplot, creare grafici a torta è altrettanto semplice.

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 Diagramma a scatola

Un box plot è un grafico utilizzato per visualizzare la distribuzione dei dati. Può visualizzare la mediana, i quartili e i valori anomali dei dati.

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 Grafico a barre

Un grafico a barre è un grafico utilizzato per visualizzare i confronti tra dati categoriali. L'altezza di ciascuna barra rappresenta il valore dei dati per quella 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 Grafico a barre in pila

Un grafico a barre in pila è un grafico utilizzato per visualizzare i confronti tra più dati categorici. L'altezza di ciascuna barra rappresenta il valore dei dati per quella categoria e ciascuna barra può essere divisa in segmenti, ciascun segmento rappresenta una sottocategoria.

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

Tipi di grafici avanzati

5.1 Istogramma

Un istogramma è un tipo di grafico utilizzato per mostrare la distribuzione dei dati.esisterebqplotdentro, può essere utilizzatoplt.hist funzione per creare un istogramma. Ecco un semplice esempio:

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

In questo esempio, abbiamo prima generato 1000 punti dati casuali e poi utilizzatiplt.hist La funzione crea un istogramma con 30 contenitori. Puoi rendere il tuo grafico più chiaro e più facile da comprendere impostando titoli ed etichette degli assi.

5.2 Grafico a linee

I grafici a linee sono un tipo di grafico comune utilizzato per mostrare le tendenze dei dati nel tempo o altre variabili continue.esisterebqplotdentro, può essere utilizzatoplt.plot funzione per creare un grafico a linee. Ecco un esempio:

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

In questo esempio, abbiamo generato i dati di una funzione seno con 100 punti dati e quindi li abbiamo utilizzatiplt.plot La funzione crea un grafico a linee. Puoi rendere il tuo grafico più chiaro e più facile da comprendere impostando titoli ed etichette degli assi.

5.3 Grafico a candela

I grafici a candela (noti anche come grafici a candela) sono un tipo di grafico utilizzato per visualizzare dati finanziari, come i prezzi delle azioni.esisterebqplotdentro, può essere utilizzatoplt.candle funzione per creare grafici a candele. Ecco un esempio:

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

In questo esempio, generiamo dati casuali sui prezzi di apertura, massimo, minimo e chiusura e quindi li utilizziamoplt.candle La funzione crea un grafico a candele. Puoi rendere il tuo grafico più chiaro e più facile da comprendere impostando titoli ed etichette degli assi.

5.4 Mappa termica

Una mappa termica è un tipo di grafico utilizzato per visualizzare la distribuzione della densità o dell'intensità dei dati bidimensionali.esisterebqplotdentro, può essere utilizzatoplt.heatmap funzione per creare una mappa termica. Ecco un esempio:

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

In questo esempio, abbiamo generato una matrice 10x10 di dati casuali e poi utilizzataplt.heatmap La funzione crea una mappa termica. Puoi rendere il tuo grafico più chiaro e più facile da comprendere impostando titoli ed etichette degli assi.

5.5 Carta geografica

Una carta geografica è un tipo di carta utilizzata per visualizzare dati geografici, ad esempio una mappa.esisterebqplotdentro, può essere utilizzatoplt.geo funzione per creare mappe geografiche. Ecco un esempio:

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

In questo esempio, carichiamo i dati della mappa del mondo e quindi utilizziamoplt.geo La funzione crea una mappa geografica. Impostando un titolo, puoi rendere il tuo grafico più chiaro e più facile da capire.

funzionalità interattive

6.1 Panoramica dei componenti interattivi

Nella visualizzazione dei dati, le funzioni interattive sono fondamentali per migliorare l'esperienza dell'utente e le capacità di esplorazione dei dati.bqplot Fornisce ricchi componenti interattivi per consentire agli utenti di condurre esplorazioni di dati dinamiche e reattive in Jupyter Notebook. Questi componenti interattivi includono ma non sono limitati a:

Zoom e panoramica: consente all'utente di ingrandire o rimpicciolire il grafico, nonché di spostarsi sul grafico per visualizzare diverse aree di dati.
Seleziona e scorri: consente agli utenti di selezionare punti dati o aree specifici in un grafico per ulteriori analisi.
descrizione comando: visualizza informazioni dettagliate quando il mouse passa sopra un punto dati.
Aggiornamenti dinamici: consente ai grafici di aggiornarsi dinamicamente in base all'input dell'utente o alle modifiche dei dati.

Questi componenti interattivi sono bqplot DiInteractions L'implementazione del modulo fornisce agli utenti strumenti di esplorazione dei dati intuitivi e potenti.

6.2 Utilizzo di componenti interattivi comuni

Zoom e panoramica

Lo zoom e la panoramica sono le funzioni interattive più basilari nella visualizzazione dei dati.bqplot Fornisce funzioni di zoom e panoramica integrate, gli utenti possono eseguire lo zoom utilizzando la rotellina del mouse e eseguire la panoramica trascinando il mouse. Ecco un semplice esempio:

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

In questo esempio, l'utente può ingrandire o rimpicciolire il grafico utilizzando la rotellina del mouse e scorrere il grafico trascinando il mouse.

Seleziona e scorri

Le funzionalità di selezione e selezione tramite pennello consentono agli utenti di selezionare punti dati o aree specifici all'interno di un grafico per ulteriori analisi.bqplot fornitoBrushSelector ELassoSelector componenti per implementare questa funzionalità.Quello che segue è un utilizzoBrushSelector Esempio:

from bqplot import BrushSelector

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

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

In questo esempio, l'utente può selezionare un'area rettangolare nel grafico trascinando il mouse e i punti dati selezionati verranno evidenziati.

descrizione comando

Le descrizioni comandi possono visualizzare informazioni dettagliate quando l'utente passa il mouse su un punto dati.bqplot fornitoTooltip componente per ottenere questa funzionalità. Ecco un semplice esempio:

from bqplot import Tooltip

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

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

In questo esempio, quando l'utente passa il mouse sopra un punto dati di un grafico a dispersione, il file x Ey valore.

Aggiornamenti dinamici

La funzione di aggiornamento dinamico consente ai grafici di aggiornarsi dinamicamente in base all'input dell'utente o alle modifiche dei dati.bqplot fornitointeracts modulo per implementare questa funzionalità. Ecco un semplice esempio:

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

In questo esempio, l'utente può aggiornare dinamicamente i dati nel grafico regolando il valore del dispositivo di scorrimento.

Funzionalità e applicazioni avanzate

7.1 Cruscotto interattivo

I dashboard interattivi sono un'applicazione importante nella visualizzazione dei dati, che consentono agli utenti di esplorare dinamicamente i dati attraverso componenti interattivi per acquisire una comprensione più profonda delle informazioni dietro i dati. bqplot fornisce potenti funzionalità per creare dashboard interattive. Ecco un semplice esempio che mostra come creare una dashboard contenente più grafici e componenti interattivi.

Per creare una dashboard interattiva

Importa le librerie necessarie：

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

Preparare i dati：

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

Crea un componente del grafico：

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

Creare componenti interattivi：

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

Definire la logica dell'interazione：

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

Componenti compositi：

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

Attraverso i passaggi precedenti, possiamo creare una semplice dashboard interattiva in cui gli utenti possono selezionare diversi tipi di grafici tramite il menu a discesa per ottenere una visualizzazione dinamica dei dati.

7.2 Selettori di dati (Selettori)

I selettori di dati sono componenti importanti in bqplot per il filtraggio e l'interazione dei dati. Attraverso il selettore dati, gli utenti possono selezionare e utilizzare i dati direttamente sul grafico per ottenere un'analisi dei dati più raffinata.

Esempio di utilizzo del selettore dati

Importa le librerie necessarie：

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

Preparare i dati：

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

Crea grafico：

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

Crea selettore dati：

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

Definire la logica di selezione：

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

Mostra grafico：
```
display(plt.figure)
1
```

Attraverso i passaggi precedenti, possiamo creare un selettore di dati sul grafico a dispersione. L'utente può selezionare i punti dati trascinando il mouse e visualizzare i dati selezionati nella console.

7.3 Applicazioni avanzate di proiezione e mappa

bqplot non solo supporta le carte 2D di base, ma fornisce anche potenti funzioni di carte geografiche che possono essere utilizzate per creare varie proiezioni cartografiche e carte geografiche avanzate.

Esempio di creazione di una mappa geografica

Importa le librerie necessarie：

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

Preparare i dati geografici：

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

Crea una mappa geografica：

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

Creare componenti interattivi：

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

Definire la logica dell'interazione：

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

Componenti compositi：

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

Attraverso i passaggi precedenti, possiamo creare una mappa geografica che supporta più proiezioni della mappa. Gli utenti possono selezionare diversi metodi di proiezione tramite il menu a discesa per ottenere la visualizzazione dinamica della mappa.

Attraverso queste funzioni e applicazioni avanzate, bqplot fornisce agli utenti potenti strumenti di visualizzazione dei dati, rendendo l'analisi interattiva dei dati in Jupyter Notebook più comoda ed efficiente.

Documentazione dell'API

8.1 Diagramma piramidale

bqplot fornisce qualcosa di similematplotlib Dipyplot L'API consente agli utenti di creare e visualizzare rapidamente grafici.I seguenti sono alcuni comunemente usatipyplot Funzioni ed esempi:

figure(): crea una nuova grafica.
plot(): traccia un grafico a linee.
scatter(): traccia un grafico a dispersione.
bar(): traccia un grafico a barre.
pie(): Disegna un grafico a torta.
hist(): traccia un istogramma.

Codice d'esempio:

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 Modello a oggetti

bqplot Il modello a oggetti si basa sulla Grammatica della grafica, fornendo un modo più flessibile e dettagliato per personalizzare i grafici. Ecco alcuni oggetti ed esempi principali:

Figure: Contenitore per il grafico, contenente tutti i marcatori e gli assi.
Mark: Elementi grafici specifici, come linee, punti, barre, ecc.
Axis: Asse.
Scale: Mappatura dei dati sul grafico.

Codice d'esempio:

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 Descrizioni comandi e barre degli strumenti

bqplot Fornisce descrizioni comandi avanzate e funzioni della barra degli strumenti, consentendo agli utenti di interagire con la grafica in modo più conveniente.

Tooltip: Visualizza le informazioni sui dati quando si passa il mouse.
Toolbar: Fornisce funzioni interattive come lo zoom e la panoramica.

Codice d'esempio:

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 Interazione e mappa del mercato

bqplot Supporta funzioni interattive complesse come selezione, zoom, panoramica, ecc. Anche,bqplot Può anche essere utilizzato per creare visualizzazioni avanzate come mappe di mercato.

Codice d'esempio:

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

Attraverso l'introduzione dei documenti API di cui sopra, gli utenti possono comprendere e utilizzare meglio bqplot libreria per creare visualizzazioni di dati ricche e interattive.

Guide e contributi sulla migrazione

9.1 Guida alla migrazione

Ci sono alcune sfide che potresti incontrare durante la migrazione di progetti esistenti da altre librerie di visualizzazione dati come Matplotlib o Plotly a bqplot. Di seguito sono riportati alcuni passaggi e considerazioni chiave per aiutarti a orientarti nel processo di migrazione.

9.1.1 Comprendere i concetti di base di bqplot

Prima di iniziare la migrazione, devi prima comprendere i concetti di base di bqplot, tra cui:

Bilancia: Definire il metodo di mappatura dei dati, come scala lineare, scala logaritmica, ecc.
Segni: rappresenta elementi visivi nei grafici, come punti di dispersione, linee, barre, ecc.
Assi: Definisce l'asse delle coordinate del grafico.
Interazioni: definisce il modo in cui gli utenti interagiscono con il grafico.

9.1.2 Preparazione dei dati

Assicurati che i tuoi dati siano pronti e possano essere facilmente convertiti nel formato richiesto da bqplot. In genere, i dati possono essere archiviati in un Pandas DataFrame, che consente una facile manipolazione e visualizzazione dei dati.

9.1.3 Migrazione graduale

Importa le librerie necessarie：

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

Crea scale e assi：

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

Crea etichetta：

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

Crea grafico：

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

Mostra grafico：
```
display(fig)
1
```

9.1.4 Gestire le interazioni

bqplot fornisce ricche funzioni interattive, che possono essere ottenute impostando diverse proprietà. Ad esempio, per abilitare la funzionalità di zoom e panoramica:

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

9.1.5 Stili personalizzati

bqplot ti consente di personalizzare lo stile del tuo grafico, inclusi colore, stile indicatore, stile linea, ecc. Ad esempio, per personalizzare l'aspetto di un grafico a dispersione:

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 Linee guida sul contributo

bqplot è un progetto open source e i membri della comunità sono invitati a contribuire con codice, documentazione ed esempi. Ecco alcune linee guida per i contributi per aiutarti a iniziare a contribuire al progetto bqplot.

9.2.1 Configurare l'ambiente di sviluppo

Archivio clonazione：

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

Installa le dipendenze：
```
pip install -r requirements.txt
1
```
Installa la versione di sviluppo：
```
pip install -e .
1
```

9.2.2 Scrittura del codice

Quando contribuisci con il codice, segui queste linee guida:

stile di codifica:Segui la guida allo stile PEP 8.
documento: aggiungi documentazione per nuove funzionalità o modifiche.
test:Scrivere unit test per garantire la correttezza del codice.

9.2.3 Invia PR

Crea un ramo：
```
git checkout -b my-new-feature
1
```

Impegna le modifiche：

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

spingere il ramo：
```
git push origin my-new-feature
1
```
Crea richiesta di pull：
Crea una nuova richiesta pull su GitHub descrivendo le tue modifiche e la tua motivazione.

9.2.4 Partecipare alla comunità

Partecipare alle discussioni: Unisciti alla chat room Gitter di bqplot o al forum di discussione GitHub per comunicare con altri sviluppatori.
Segnala un problema: Se riscontri problemi o bug, invia un problema su GitHub.
Fornire un feedback: Fornire feedback su nuove funzionalità o miglioramenti per aiutare il progetto a svilupparsi meglio.

Seguendo queste linee guida, puoi dare un prezioso contributo al progetto bqplot e contribuire a far avanzare la visualizzazione interattiva dei dati nella comunità Python.

Riepilogo e prospettive

10.1 Vantaggi e limiti di bqplot

Vantaggio

bqplot è basato suGrammatica della grafica Sistema di visualizzazione 2D, progettato perQuaderno di Jupyter progetto. Presenta i seguenti vantaggi significativi:

interattività: Ogni componente di bqplot è un widget interattivo, che consente agli utenti di integrare facilmente visualizzazioni con altri widget interattivi Jupyter per creare interfacce utente grafiche complesse (GUI).
Facilità d'uso: Attraverso il semplice codice Python, gli utenti possono creare e personalizzare rapidamente vari grafici senza dover comprendere in modo approfondito la programmazione grafica complessa.
flessibilità: supporta una varietà di tipi di grafici, inclusi grafici a dispersione, grafici a torta, box plot, grafici a barre, ecc., per soddisfare le diverse esigenze di visualizzazione dei dati.
Integrazione: Perfettamente integrato con l'ecosistema Jupyter, facilita l'utilizzo da parte di data scientist e analisti nel processo di analisi dei dati.

limitazioni

Sebbene bqplot offra funzionalità potenti e flessibilità, presenta anche alcune limitazioni:

prestazione: Per set di dati su larga scala, le prestazioni di bqplot potrebbero non essere buone quanto quelle di alcuni strumenti di visualizzazione professionali, soprattutto quando si ha a che fare con grafici complessi e grandi quantità di dati.
curva di apprendimento: Sebbene sia relativamente facile iniziare a usare bqplot, per i principianti ci vuole ancora un po' di tempo per acquisire familiarità con la sua API e i componenti interattivi.
sostegno della comunità: Rispetto ad alcune librerie di visualizzazione mature, bqplot ha una comunità più piccola, il che potrebbe comportare risorse limitate per l'aiuto in caso di problemi.

10.2 Tendenze di sviluppo future

Essendo un progetto open source attivo, le tendenze di sviluppo future di bqplot meritano attenzione:

Ottimizzazione delle prestazioni: Con lo sviluppo della tecnologia, si prevede che bqplot riceverà miglioramenti significativi nelle prestazioni e gestirà meglio set di dati su larga scala e grafici complessi.
Nuova integrazione di funzionalità: Le versioni future potrebbero introdurre tipi di grafici più avanzati e funzionalità interattive, come la visualizzazione 3D, il supporto dell'animazione, ecc.
crescita della comunità: Man mano che la popolarità e l'ambito delle applicazioni di bqplot si espandono, si prevede che la sua comunità continuerà a crescere e ad attrarre sempre più sviluppatori e utenti a partecipare.
Supporto multipiattaforma: Oltre a Jupyter Notebook, bqplot può essere esteso ad altre piattaforme e ambienti per fornire una gamma più ampia di scenari applicativi.

In breve, bqplot, in quanto potente strumento interattivo di visualizzazione dei dati, ha ampie prospettive di applicazione nel campo della scienza dei dati. Con l'ottimizzazione continua e l'espansione delle funzionalità, continuerà a fornire maggiori possibilità per l'analisi e la visualizzazione dei dati.

Condivisione della tecnologia