Tutoriel bqplot : Visualisation interactive des données dans Jupyter Notebook

2024-07-12

Annuaire d'articles

introduire

1.1 L'importance de la visualisation des données

La visualisation des données consiste à afficher les données sous forme de graphiques pour aider les gens à comprendre les informations et les modèles derrière les données de manière plus intuitive et plus rapide. À l’ère actuelle d’explosion de l’information, la visualisation des données est particulièrement importante pour les raisons suivantes :

Améliorer l’efficacité de la compréhension : Les données graphiques sont plus faciles à comprendre et à retenir pour le cerveau que le texte brut ou les chiffres. Grâce aux graphiques, les utilisateurs peuvent rapidement capturer des points de données clés pour prendre des décisions plus éclairées.
Révéler des modèles de données : La visualisation des données peut vous aider à découvrir des modèles cachés, des tendances et des valeurs aberrantes dans vos données. Par exemple, un graphique linéaire permet de voir clairement comment les données évoluent au fil du temps.
Améliorer l'effet de communication : Dans des domaines tels que les affaires, la recherche scientifique et l'éducation, la visualisation des données est un outil puissant pour communiquer des informations complexes. Cela rend les résultats de l’analyse des données plus faciles à comprendre et à accepter par les autres.
Accompagner la prise de décision: La visualisation des données fournit aux décideurs un support de données intuitif, les aidant à trouver des informations clés dans des données complexes et à prendre des décisions plus scientifiques et raisonnables.

1.2 Présentation de la bibliothèque bqplot

bqplot est basé surGrammaire des graphiques Bibliothèque de visualisation 2D, spécifiquement pourCarnet de notes Jupyter conception.il combined3.js etwidgets ipy fonctionnalité conçue pour apporter les puissantes capacités de visualisation de d3.js à Python. Voici quelques fonctionnalités clés de la bibliothèque bqplot :

interactivité: bqplot fournit de riches fonctions interactives. Les utilisateurs peuvent effectuer un panoramique, un zoom, une sélection et d'autres opérations sur le graphique pour explorer les données plus en profondeur.
la flexibilité: Grâce à une approche orientée objet, les utilisateurs peuvent créer des graphiques hautement personnalisés à l'aide de la grammaire graphique.
Facilité d'utilisation: bqplot fournit une interface pyplot similaire à matplotlib, permettant aux utilisateurs familiers avec matplotlib de démarrer rapidement.
L'intégration: En tant que bibliothèque native de Jupyter Notebook, bqplot peut être intégré de manière transparente au flux de travail d'analyse de données, offrant aux utilisateurs une expérience interactive fluide.

Installation et démarrage rapide

L'installation de bqplot est très simple, exécutez simplement la commande suivante dans le terminal ou l'invite de commande :

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

Une fois l'installation réussie, importez les bibliothèques nécessaires dans Jupyter Notebook pour commencer à utiliser :

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

Voici un exemple simple montrant comment créer un histogramme à l'aide de 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

A travers cet exemple simple, vous pouvez constater la facilité d'utilisation et les puissantes fonctions interactives de bqplot. Dans les chapitres suivants, nous aborderons les différents types de graphiques et fonctionnalités avancées de bqplot.

Installer et importer

2.1 Installer bqplot

Avant de commencer à utiliser bqplot pour la visualisation de données, vous devez d'abord installer la bibliothèque bqplot dans votre environnement. bqplot peut être installé de plusieurs manières, le plus souvent en utilisant pip ou conda. Voici les étapes détaillées pour utiliser les deux méthodes :

Installer en utilisant pip

pip install bqplot
1

Installer en utilisant conda

conda install -c conda-forge bqplot
1

Une fois l'installation terminée, vous pouvez confirmer si l'installation a réussi en exécutant la commande suivante :

import bqplot
print(bqplot.__version__)
1
2

2.2 Importer les bibliothèques nécessaires

Après avoir installé bqplot, vous devez ensuite importer les bibliothèques nécessaires pour démarrer le travail de visualisation des données. En règle générale, vous devez importer les bibliothèques suivantes :

bqplot: Utilisé pour créer des graphiques interactifs.
numpy: Utilisé pour les calculs numériques et le traitement des données.
pandas: Utilisé pour la manipulation et l’analyse des données.

Voici un exemple de code pour importer ces bibliothèques :

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

Exemple : importez et utilisez bqplot pour créer un graphique simple

Pour vous assurer que tout est correctement configuré, vous pouvez essayer de créer un simple graphique à barres. Voici un exemple de code qui montre comment importer les bibliothèques nécessaires et créer un graphique à barres simple :

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

Dans cet exemple, nous importons d’abordbqplot.pyplotcommeplt, puis utiliseznumpy Générez des données aléatoires. Ensuite, nous avons créé un simple graphique à barres avec cinq barres et l'avons affiché dans un bloc-notes Jupyter.

Grâce aux étapes ci-dessus, vous avez installé et importé avec succès la bibliothèque bqplot et créé votre premier graphique interactif simple. Ensuite, vous pouvez continuer à explorer des fonctionnalités et des types de graphiques plus avancés.

Préparation du jeu de données

3.1 Importer un ensemble de données

Avant de commencer à utiliser bqplot Avant de pouvoir effectuer une visualisation des données, vous devez d'abord importer l'ensemble de données requis.Voici quelques méthodes courantes d'importation d'ensembles de données et comment les utiliserpandas bibliothèque pour traiter ces données.

Importer des fichiers CSV à l'aide de pandas

pandas Il s'agit d'une puissante bibliothèque de traitement de données largement utilisée pour l'analyse et le prétraitement des données.Voici comment utiliserpandas Exemple d'importation d'un fichier CSV :

import pandas as pd

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

Utilisez des pandas pour importer des données dans d'autres formats

En plus des fichiers CSV,pandas Il prend également en charge l'importation de données dans plusieurs formats, tels que des fichiers Excel, des fichiers JSON, etc. Voici quelques exemples:

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

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

Utilisez des pandas pour importer des données de la base de données

Si les données sont stockées dans une base de données, vous pouvez utiliser pandas deread_sql fonction pour importer des données. Voici un exemple:

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 Aperçu de l'ensemble de données

Après avoir importé un ensemble de données, vous devez généralement prévisualiser l'ensemble de données pour comprendre la structure et le contenu des données.pandas Diverses méthodes sont proposées pour prévisualiser l'ensemble de données.

Afficher les premières lignes de l'ensemble de données

utiliser head() Méthode pour afficher les premières lignes de l'ensemble de données :

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

Afficher les informations de base sur l'ensemble de données

utiliser info() La méthode peut afficher les informations de base de l'ensemble de données, y compris le type de données et les valeurs manquantes :

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

Afficher les statistiques d'un ensemble de données

utiliser describe() La méthode peut afficher les informations statistiques de l'ensemble de données, notamment la moyenne, l'écart type, la valeur minimale, la valeur maximale, etc. :

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

Afficher les noms de colonnes de l'ensemble de données

utiliser columns Les propriétés peuvent afficher les noms de colonnes de l'ensemble de données :

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

Grâce aux méthodes ci-dessus, vous pouvez avoir une compréhension de base de l'ensemble de données importées, jetant ainsi les bases du travail ultérieur de visualisation des données.

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

Types de graphiques de base

4.1 Nuage de points

Un nuage de points est un graphique utilisé pour montrer la relation entre deux variables. Les nuages de points vous permettent d'observer visuellement la distribution et la corrélation des données. Dans bqplot, créer des nuages de points est très simple.

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 Diagramme circulaire

Le camembert est un graphique utilisé pour afficher la proportion de données. Dans bqplot, créer des diagrammes circulaires est tout aussi simple.

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 Boîte à moustaches

Une boîte à moustaches est un graphique utilisé pour afficher la distribution des données. Il peut afficher la médiane, les quartiles et les valeurs aberrantes des données.

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 Graphique à barres

Un graphique à barres est un graphique utilisé pour afficher des comparaisons entre des données catégorielles. La hauteur de chaque barre représente la valeur des données pour cette catégorie.

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 Graphique à barres empilées

Un graphique à barres empilées est un graphique utilisé pour afficher des comparaisons entre plusieurs données catégorielles. La hauteur de chaque barre représente la valeur des données pour cette catégorie et chaque barre peut être divisée en segments, chaque segment représentant une sous-catégorie.

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

Types de graphiques avancés

5.1 Histogramme

Un histogramme est un type de graphique utilisé pour montrer la distribution des données.existerbqplotdans, peut être utiliséplt.hist fonction pour créer un histogramme. Voici un exemple simple :

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

Dans cet exemple, nous avons d'abord généré 1 000 points de données aléatoires, puis utiliséplt.hist La fonction crée un histogramme avec 30 bacs. Vous pouvez rendre votre graphique plus clair et plus facile à comprendre en définissant des titres et des étiquettes d'axe.

5.2 Graphique linéaire

Les graphiques linéaires sont un type de graphique couramment utilisé pour afficher les tendances des données au fil du temps ou d'autres variables continues.existerbqplotdans, peut être utiliséplt.plot fonction pour créer un graphique linéaire. Voici un exemple:

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

Dans cet exemple, nous avons généré des données de fonction sinusoïdale avec 100 points de données, puis utiliséplt.plot La fonction crée un graphique linéaire. Vous pouvez rendre votre graphique plus clair et plus facile à comprendre en définissant des titres et des étiquettes d'axe.

5.3 Graphique en chandeliers

Les graphiques en chandeliers (également appelés graphiques en chandeliers) sont un type de graphique utilisé pour afficher des données financières, telles que les cours des actions.existerbqplotdans, peut être utiliséplt.candle fonction pour créer des graphiques en chandeliers. Voici un exemple:

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

Dans cet exemple, nous générons des données aléatoires sur les prix d'ouverture, de haut, de bas et de clôture, puis utilisonsplt.candle La fonction crée un graphique en chandeliers. Vous pouvez rendre votre graphique plus clair et plus facile à comprendre en définissant des titres et des étiquettes d'axe.

5.4 Carte thermique

Une carte thermique est un type de graphique utilisé pour afficher la distribution de densité ou d'intensité de données bidimensionnelles.existerbqplotdans, peut être utiliséplt.heatmap fonction pour créer une carte thermique. Voici un exemple:

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

Dans cet exemple, nous avons généré une matrice 10x10 de données aléatoires, puis utiliséplt.heatmap La fonction crée une carte thermique. Vous pouvez rendre votre graphique plus clair et plus facile à comprendre en définissant des titres et des étiquettes d'axe.

5.5 Carte géographique

Une carte géographique est un type de graphique utilisé pour afficher des données géographiques, telles qu'une carte.existerbqplotdans, peut être utiliséplt.geo fonction pour créer des cartes géographiques. Voici un exemple:

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

Dans cet exemple, nous chargeons les données de la carte du monde puis utilisonsplt.geo La fonction crée une carte géographique. En définissant un titre, vous pouvez rendre votre graphique plus clair et plus facile à comprendre.

Fonctions interactives

6.1 Aperçu des composants interactifs

Dans la visualisation de données, les fonctions interactives sont essentielles pour améliorer l'expérience utilisateur et les capacités d'exploration des données.bqplot Fournit de riches composants interactifs pour permettre aux utilisateurs d'effectuer une exploration de données dynamique et réactive dans Jupyter Notebook. Ces composants interactifs comprennent, sans s'y limiter :

Zoom et panoramique: permet à l'utilisateur de zoomer ou dézoomer sur le graphique, ainsi que d'effectuer un panoramique sur le graphique pour afficher différentes zones de données.
Sélectionnez et faites glisser: Permet aux utilisateurs de sélectionner des points de données ou des zones spécifiques dans un graphique pour une analyse plus approfondie.
info-bulle: Afficher des informations détaillées lorsque la souris survole un point de données.
Mises à jour dynamiques: permet aux graphiques de se mettre à jour dynamiquement en fonction des entrées de l'utilisateur ou des modifications des données.

Ces composants interactifs sont bqplot deInteractions La mise en œuvre du module fournit aux utilisateurs des outils d'exploration de données intuitifs et puissants.

6.2 Utilisation de composants interactifs communs

Zoom et panoramique

Le zoom et le panoramique sont les fonctions interactives les plus élémentaires de la visualisation de données.bqplot Fournit des fonctions de zoom et de panoramique intégrées, les utilisateurs peuvent zoomer avec la molette de la souris et effectuer un panoramique en faisant glisser la souris. Voici un exemple simple :

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

Dans cet exemple, l'utilisateur peut effectuer un zoom avant ou arrière sur le graphique à l'aide de la molette de la souris et effectuer un panoramique sur le graphique en faisant glisser la souris.

Sélectionnez et faites glisser

Les capacités de sélection et de sélection au pinceau permettent aux utilisateurs de sélectionner des points de données ou des zones spécifiques dans un graphique pour une analyse plus approfondie.bqplot fourniBrushSelector etLassoSelector composants pour implémenter cette fonctionnalité.Ce qui suit est une utilisationBrushSelector Exemple:

from bqplot import BrushSelector

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

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

Dans cet exemple, l'utilisateur peut sélectionner une zone rectangulaire dans le graphique en faisant glisser la souris, et les points de données sélectionnés seront mis en surbrillance.

info-bulle

Les info-bulles peuvent afficher des informations détaillées lorsque l'utilisateur passe la souris sur un point de données.bqplot fourniTooltip composant pour réaliser cette fonctionnalité. Voici un exemple simple :

from bqplot import Tooltip

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

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

Dans cet exemple, lorsque l'utilisateur survole un point de données de nuage de points, le x ety valeur.

Mises à jour dynamiques

La fonction de mise à jour dynamique permet aux graphiques d'être mis à jour dynamiquement en fonction des entrées de l'utilisateur ou des modifications des données.bqplot fourniinteracts module pour implémenter cette fonctionnalité. Voici un exemple simple :

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

Dans cet exemple, l'utilisateur peut mettre à jour dynamiquement les données du graphique en ajustant la valeur du curseur.

Fonctionnalités et applications avancées

7.1 Tableau de bord interactif

Les tableaux de bord interactifs sont une application importante dans la visualisation de données, qui permettent aux utilisateurs d'explorer dynamiquement les données via des composants interactifs pour mieux comprendre les informations qui se cachent derrière les données. bqplot fournit des fonctionnalités puissantes pour créer des tableaux de bord interactifs. Voici un exemple simple montrant comment créer un tableau de bord contenant plusieurs graphiques et composants interactifs.

Pour créer un tableau de bord interactif

Importer les bibliothèques nécessaires：

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

Préparer les données：

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

Créer un composant graphique：

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

Créer des composants interactifs：

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

Définir la logique d'interaction：

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

Composants composites：

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

Grâce aux étapes ci-dessus, nous pouvons créer un tableau de bord interactif simple dans lequel les utilisateurs peuvent sélectionner différents types de graphiques via le menu déroulant pour obtenir une visualisation dynamique des données.

7.2 Sélecteurs de données (sélecteurs)

Les sélecteurs de données sont des composants importants dans bqplot pour le filtrage et l'interaction des données. Grâce au sélecteur de données, les utilisateurs peuvent sélectionner et exploiter les données directement sur le graphique pour obtenir une analyse de données plus raffinée.

Exemple d'utilisation du sélecteur de données

Importer les bibliothèques nécessaires：

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

Préparer les données：

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

Créer un graphique：

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

Créer un sélecteur de données：

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

Définir la logique de sélection：

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

Afficher le graphique：
```
display(plt.figure)
1
```

Grâce aux étapes ci-dessus, nous pouvons créer un sélecteur de données sur le nuage de points. L'utilisateur peut sélectionner des points de données en faisant glisser la souris et afficher les données sélectionnées dans la console.

7.3 Applications avancées de projection et de carte

bqplot prend non seulement en charge les cartes 2D de base, mais fournit également de puissantes fonctions de cartes géographiques qui peuvent être utilisées pour créer diverses projections cartographiques et des cartes géographiques avancées.

Exemple de création d'une carte géographique

Importer les bibliothèques nécessaires：

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

Préparer des données géographiques：

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

Créer une carte géographique：

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

Créer des composants interactifs：

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

Définir la logique d'interaction：

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

Composants composites：

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

Grâce aux étapes ci-dessus, nous pouvons créer une carte géographique prenant en charge plusieurs projections cartographiques. Les utilisateurs peuvent sélectionner différentes méthodes de projection via le menu déroulant pour obtenir un affichage dynamique de la carte.

Grâce à ces fonctions et applications avancées, bqplot fournit aux utilisateurs de puissants outils de visualisation de données, rendant l'analyse interactive des données dans Jupyter Notebook plus pratique et efficace.

Documentation API

8.1 Pyplot

bqplot fournit quelque chose commematplotlib depyplot L'API permet aux utilisateurs de créer et d'afficher rapidement des graphiques.Voici quelques exemples couramment utiliséspyplot Fonctions et exemples :

figure(): Créez un nouveau graphique.
plot(): Dessinez un graphique linéaire.
scatter(): Dessinez un nuage de points.
bar(): Dessinez un graphique à barres.
pie(): Dessinez un diagramme circulaire.
hist(): Dessinez un histogramme.

Exemple de code :

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 Modèle objet

bqplot Le modèle objet est basé sur Grammar of Graphics, offrant un moyen plus flexible et plus détaillé de personnaliser les graphiques. Voici quelques objets principaux et exemples :

Figure: Conteneur du graphique, contenant tous les marqueurs et axes.
Mark: Éléments graphiques spécifiques, tels que lignes, points, barres, etc.
Axis: Axe.
Scale: Cartographie des données vers un graphique.

Exemple de code :

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 Info-bulles et barres d'outils

bqplot Fournit des info-bulles riches et des fonctions de barre d'outils, permettant aux utilisateurs d'interagir plus facilement avec les graphiques.

Tooltip: Afficher les informations sur les données lorsque la souris est survolée.
Toolbar: Fournit des fonctions interactives telles que le zoom et le panoramique.

Exemple de code :

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 Interaction et carte du marché

bqplot Prend en charge des fonctions interactives complexes telles que la sélection, le zoom, le panoramique, etc. aussi,bqplot Il peut également être utilisé pour créer des visualisations avancées telles que des cartes de marché.

Exemple de code :

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

Grâce à l'introduction des documents API ci-dessus, les utilisateurs peuvent mieux comprendre et utiliser bqplot bibliothèque pour créer des visualisations de données riches et interactives.

Guides de migration et contributions

9.1 Guide de migration

Vous pouvez rencontrer certains défis lors de la migration de projets existants depuis d'autres bibliothèques de visualisation de données telles que Matplotlib ou Plotly vers bqplot. Voici quelques étapes et considérations clés pour vous aider à naviguer dans le processus de migration.

9.1.1 Comprendre les concepts de base de bqplot

Avant de commencer la migration, vous devez d'abord comprendre les concepts de base de bqplot, notamment :

Balance: Définir la méthode de cartographie des données, telle que l'échelle linéaire, l'échelle logarithmique, etc.
Des marques: Représente des éléments visuels dans des graphiques, tels que des points de dispersion, des lignes, des barres, etc.
Haches: Définit l'axe de coordonnées du graphique.
Interactions: définissez la manière dont les utilisateurs interagissent avec le graphique.

9.1.2 Préparation des données

Assurez-vous que vos données sont prêtes et peuvent être facilement converties au format requis par bqplot. En règle générale, les données peuvent être stockées dans un Pandas DataFrame, ce qui permet une manipulation et une visualisation faciles des données.

9.1.3 Migration progressive

Importer les bibliothèques nécessaires：

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

Créer des échelles et des axes：

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

Créer une balise：

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

Créer un graphique：

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

Afficher le graphique：
```
display(fig)
1
```

9.1.4 Gestion des interactions

bqplot fournit de riches fonctions interactives, qui peuvent être obtenues en définissant différentes propriétés. Par exemple, pour activer les fonctionnalités de zoom et de panoramique :

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

9.1.5 Styles personnalisés

bqplot vous permet de personnaliser le style de votre graphique, notamment la couleur, le style de marqueur, le style de ligne, etc. Par exemple, pour personnaliser l'apparence d'un nuage de points :

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 Lignes directrices concernant les contributions

bqplot est un projet open source et les membres de la communauté sont invités à contribuer au code, à la documentation et aux exemples. Voici quelques directives de contribution pour vous aider à commencer à contribuer au projet bqplot.

9.2.1 Configurer l'environnement de développement

Cloner le référentiel：

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

Installer les dépendances：
```
pip install -r requirements.txt
1
```
Installer la version de développement：
```
pip install -e .
1
```

9.2.2 Écriture du code

Lorsque vous contribuez au code, veuillez suivre ces directives :

style de codage:Suivez le guide de style PEP 8.
document: Ajoutez de la documentation pour les nouvelles fonctionnalités ou les modifications.
test:Écrire des tests unitaires pour garantir l'exactitude du code.

9.2.3 Soumettre une PR

Créer une succursale：
```
git checkout -b my-new-feature
1
```

Valider les modifications：

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

pousser la branche：
```
git push origin my-new-feature
1
```
Créer une demande de tirage：
Créez une nouvelle Pull Request sur GitHub décrivant vos changements et votre motivation.

9.2.4 Participer à la communauté

Participer aux discussions: Rejoignez la salle de discussion Gitter de bqplot ou le forum de discussion GitHub pour communiquer avec d'autres développeurs.
Signaler un problème: Si vous rencontrez des problèmes ou des bugs, veuillez soumettre un problème sur GitHub.
Fournir une réponse: Fournir des commentaires sur les nouvelles fonctionnalités ou améliorations pour aider le projet à mieux se développer.

En suivant ces directives, vous pouvez apporter une contribution précieuse au projet bqplot et contribuer à faire progresser la visualisation interactive des données dans la communauté Python.

Résumé et perspectives

10.1 Avantages et limites de bqplot

Avantage

bqplot est basé surGrammaire des graphiques Système de visualisation 2D, conçu pourCarnet de notes Jupyter conception. Il présente les avantages significatifs suivants :

interactivité: Chaque composant de bqplot est un widget interactif, permettant aux utilisateurs d'intégrer facilement des visualisations avec d'autres widgets interactifs Jupyter pour créer des interfaces utilisateur graphiques (GUI) complexes.
Facilité d'utilisation: Grâce à un code Python simple, les utilisateurs peuvent rapidement créer et personnaliser divers graphiques sans avoir à comprendre en profondeur une programmation graphique complexe.
la flexibilité: Prend en charge une variété de types de graphiques, notamment les nuages de points, les diagrammes circulaires, les boîtes à moustaches, les graphiques à barres, etc., pour répondre aux différents besoins de visualisation de données.
L'intégration: Parfaitement intégré à l'écosystème Jupyter, ce qui facilite son utilisation par les data scientists et les analystes dans le processus d'analyse des données.

limites

Bien que bqplot offre des fonctionnalités et une flexibilité puissantes, il présente également certaines limites :

performance: Pour les ensembles de données à grande échelle, les performances de bqplot peuvent ne pas être aussi bonnes que celles de certains outils de visualisation professionnels, en particulier lorsqu'il s'agit de graphiques complexes et de grandes quantités de données.
courbe d'apprentissage: Bien que bqplot soit relativement simple à démarrer, pour les débutants, il faut encore un certain temps pour se familiariser avec son API et ses composants interactifs.
soutien communautaire: Par rapport à certaines bibliothèques de visualisation matures, bqplot a une communauté plus petite, ce qui peut entraîner des ressources d'aide limitées en cas de problèmes.

10.2 Tendances de développement futures

En tant que projet open source actif, les futures tendances de développement de bqplot méritent notre attention :

Optimisation des performances: Avec le développement de la technologie, on s'attend à ce que bqplot bénéficie d'améliorations significatives en termes de performances et gère mieux les ensembles de données à grande échelle et les graphiques complexes.
Intégration de nouvelles fonctionnalités: Les versions futures pourraient introduire des types de graphiques plus avancés et des fonctionnalités interactives, telles que la visualisation 3D, la prise en charge de l'animation, etc.
croissance de la communauté: À mesure que la popularité de bqplot et la portée de ses applications augmentent, sa communauté devrait continuer de croître et attirer davantage de développeurs et d'utilisateurs.
Prise en charge multiplateforme: En plus de Jupyter Notebook, bqplot peut être étendu à d'autres plates-formes et environnements pour offrir une plus large gamme de scénarios d'application.

En bref, bqplot, en tant que puissant outil interactif de visualisation de données, offre de larges perspectives d'application dans le domaine de la science des données. Avec une optimisation continue et une extension des fonctionnalités, il continuera à offrir davantage de possibilités d'analyse et de visualisation des données.

Partage de technologie