bqplot-Tutorial: Interaktive Datenvisualisierung in Jupyter Notebook

2024-07-12

Artikelverzeichnis

einführen

1.1 Die Bedeutung der Datenvisualisierung

Bei der Datenvisualisierung werden Daten in Form von Grafiken angezeigt, damit Menschen die Informationen und Muster hinter den Daten intuitiver und schneller verstehen können. Im heutigen Zeitalter der Informationsexplosion ist die Datenvisualisierung aus folgenden Gründen besonders wichtig:

Verbessern Sie die Effizienz des Verständnisses : Grafische Daten sind für das Gehirn leichter zu verstehen und zu merken als einfacher Text oder Zahlen. Mithilfe von Diagrammen können Benutzer schnell wichtige Datenpunkte erfassen, um fundiertere Entscheidungen zu treffen.
Datenmuster aufdecken : Mithilfe der Datenvisualisierung können Sie verborgene Muster, Trends und Ausreißer in Ihren Daten entdecken. Anhand eines Liniendiagramms lässt sich beispielsweise deutlich erkennen, wie sich Daten im Laufe der Zeit ändern.
Verbessern Sie den Kommunikationseffekt : In Bereichen wie Wirtschaft, wissenschaftlicher Forschung und Bildung ist die Datenvisualisierung ein leistungsstarkes Werkzeug zur Kommunikation komplexer Informationen. Es macht die Ergebnisse der Datenanalyse für andere leichter verständlich und akzeptiert.
Unterstützen Sie die Entscheidungsfindung: Die Datenvisualisierung bietet Entscheidungsträgern intuitive Datenunterstützung und hilft ihnen, wichtige Informationen in komplexen Daten zu finden und wissenschaftlichere und vernünftigere Entscheidungen zu treffen.

1.2 Übersicht über die bqplot-Bibliothek

bqplot basiert aufGrammatik der Grafik 2D-Visualisierungsbibliothek, speziell fürJupyter-Notizbuch Design.es kombiniertd3.js UndAbonnieren Funktion, die entwickelt wurde, um die leistungsstarken Visualisierungsfunktionen von d3.js in Python zu integrieren. Hier sind einige wichtige Funktionen der bqplot-Bibliothek:

Interaktivität: bqplot bietet umfangreiche interaktive Funktionen, um die Daten genauer zu untersuchen.
Flexibilität: Mithilfe eines objektorientierten Ansatzes können Benutzer mithilfe der Grammar of Graphics hochgradig personalisierte Diagramme erstellen.
Benutzerfreundlichkeit: Bqplot bietet eine Pyplot-Schnittstelle ähnlich wie Matplotlib, sodass Benutzer, die mit Matplotlib vertraut sind, schnell loslegen können.
Integration: Als native Bibliothek von Jupyter Notebook kann bqplot nahtlos in den Datenanalyse-Workflow integriert werden und bietet Benutzern ein reibungsloses interaktives Erlebnis.

Installation und Schnellstart

Die Installation von bqplot ist sehr einfach. Führen Sie einfach den folgenden Befehl im Terminal oder in der Eingabeaufforderung aus:

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

Importieren Sie nach erfolgreicher Installation die erforderlichen Bibliotheken in Jupyter Notebook, um Folgendes zu verwenden:

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

Hier ist ein einfaches Beispiel, das zeigt, wie man mit bqplot ein Histogramm erstellt:

# 生成随机数据
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

Anhand dieses einfachen Beispiels können Sie die Benutzerfreundlichkeit und die leistungsstarken interaktiven Funktionen von bqplot erkennen. In den folgenden Kapiteln werden wir uns mit den verschiedenen Diagrammtypen und erweiterten Funktionen von bqplot befassen.

Installieren und importieren

2.1 Installieren Sie bqplot

Bevor Sie bqplot zur Datenvisualisierung verwenden, müssen Sie zunächst die bqplot-Bibliothek in Ihrer Umgebung installieren. bqplot kann auf verschiedene Arten installiert werden, am häufigsten mit pip oder conda. Hier sind die detaillierten Schritte zur Verwendung beider Methoden:

Mit pip installieren

pip install bqplot
1

Mit Conda installieren

conda install -c conda-forge bqplot
1

Nachdem die Installation abgeschlossen ist, können Sie überprüfen, ob die Installation erfolgreich war, indem Sie den folgenden Befehl ausführen:

import bqplot
print(bqplot.__version__)
1
2

2.2 Importieren Sie die erforderlichen Bibliotheken

Nach der Installation von bqplot müssen Sie als Nächstes die erforderlichen Bibliotheken importieren, um mit der Datenvisualisierung zu beginnen. Normalerweise müssen Sie die folgenden Bibliotheken importieren:

bqplot: Wird zum Erstellen interaktiver Diagramme verwendet.
numpy: Wird für numerische Berechnungen und Datenverarbeitung verwendet.
pandas: Wird zur Datenbearbeitung und -analyse verwendet.

Hier ist Beispielcode zum Importieren dieser Bibliotheken:

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

Beispiel: Importieren und verwenden Sie bqplot, um ein einfaches Diagramm zu erstellen

Um sicherzustellen, dass alles richtig eingerichtet ist, können Sie versuchen, ein einfaches Balkendiagramm zu erstellen. Hier ist ein Beispielcode, der zeigt, wie Sie die erforderlichen Bibliotheken importieren und ein einfaches Balkendiagramm erstellen:

# 导入必要的库
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 diesem Beispiel importieren wir zunächstbqplot.pyplotalsplt, dann benutzenumpy Generieren Sie Zufallsdaten. Als nächstes haben wir ein einfaches Balkendiagramm mit fünf Balken erstellt und es in einem Jupyter-Notizbuch angezeigt.

Mit den oben genannten Schritten haben Sie die bqplot-Bibliothek erfolgreich installiert und importiert und Ihr erstes einfaches interaktives Diagramm erstellt. Als Nächstes können Sie mit der Erkundung erweiterter Funktionen und Diagrammtypen fortfahren.

Datensatzvorbereitung

3.1 Datensatz importieren

Vor Beginn der Anwendung bqplot Bevor Sie eine Datenvisualisierung durchführen können, müssen Sie zunächst den erforderlichen Datensatz importieren.Hier sind einige gängige Methoden zum Importieren von Datensätzen und deren Verwendungpandas Bibliothek zur Verarbeitung dieser Daten.

Importieren Sie CSV-Dateien mit Pandas

pandas Es handelt sich um eine leistungsstarke Datenverarbeitungsbibliothek, die häufig für die Datenanalyse und -vorverarbeitung verwendet wird.Hier erfahren Sie, wie Sie es verwendenpandas Beispiel für den Import einer CSV-Datei:

import pandas as pd

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

Verwenden Sie Pandas, um Daten in anderen Formaten zu importieren

Zusätzlich zu CSV-Dateien,pandas Es unterstützt auch den Import von Daten in mehreren Formaten, z. B. Excel-Dateien, JSON-Dateien usw. Hier sind einige Beispiele:

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

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

Verwenden Sie Pandas, um Daten aus der Datenbank zu importieren

Wenn die Daten in einer Datenbank gespeichert sind, können Sie sie verwenden pandas vonread_sql Funktion zum Importieren von Daten. Hier ist ein Beispiel:

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 Datensatzvorschau

Nach dem Import eines Datensatzes müssen Sie normalerweise eine Vorschau des Datensatzes anzeigen, um die Struktur und den Inhalt der Daten zu verstehen.pandas Für die Vorschau des Datensatzes stehen verschiedene Methoden zur Verfügung.

Sehen Sie sich die ersten Zeilen des Datensatzes an

verwenden head() Methode zum Anzeigen der ersten Zeilen des Datensatzes:

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

Grundlegende Informationen zum Datensatz anzeigen

verwenden info() Die Methode kann die grundlegenden Informationen des Datensatzes anzeigen, einschließlich Datentyp und fehlender Werte:

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

Statistiken für einen Datensatz anzeigen

verwenden describe() Die Methode kann die statistischen Informationen des Datensatzes anzeigen, einschließlich Mittelwert, Standardabweichung, Minimalwert, Maximalwert usw.:

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

Sehen Sie sich die Spaltennamen des Datensatzes an

verwenden columns Eigenschaften können die Spaltennamen des Datensatzes anzeigen:

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

Durch die oben genannten Methoden können Sie ein grundlegendes Verständnis des importierten Datensatzes erlangen und so den Grundstein für nachfolgende Datenvisualisierungsarbeiten legen.

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

Grundlegende Diagrammtypen

4.1 Streudiagramm

Ein Streudiagramm ist ein Diagramm, mit dem die Beziehung zwischen zwei Variablen dargestellt wird. Mit Streudiagrammen können Sie die Verteilung und Korrelation von Daten visuell beobachten. In bqplot ist das Erstellen von Streudiagrammen sehr einfach.

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 Kreisdiagramm

Kreisdiagramm ist ein Diagramm zur Darstellung des Datenanteils. In bqplot ist das Erstellen von Kreisdiagrammen ebenso einfach.

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 Boxplot

Ein Boxplot ist ein Diagramm, das zur Darstellung der Datenverteilung verwendet wird. Es kann den Median, die Quartile und Ausreißer der Daten anzeigen.

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 Balkendiagramm

Ein Balkendiagramm ist ein Diagramm, das zur Anzeige von Vergleichen zwischen kategorialen Daten verwendet wird. Die Höhe jedes Balkens stellt den Datenwert für diese Kategorie dar.

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 Gestapeltes Balkendiagramm

Ein gestapeltes Balkendiagramm ist ein Diagramm, das zur Anzeige von Vergleichen zwischen mehreren kategorialen Daten verwendet wird. Die Höhe jedes Balkens stellt den Datenwert für diese Kategorie dar und jeder Balken kann in Segmente unterteilt werden, wobei jedes Segment eine Unterkategorie darstellt.

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

Erweiterte Diagrammtypen

5.1 Histogramm

Ein Histogramm ist eine Art Diagramm, mit dem die Verteilung von Daten dargestellt wird.existierenbqplotin, verwendet werden kannplt.hist Funktion zum Erstellen eines Histogramms. Hier ist ein einfaches Beispiel:

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 diesem Beispiel haben wir zunächst 1000 zufällige Datenpunkte generiert und diese dann verwendetplt.hist Die Funktion erstellt ein Histogramm mit 30 Bins. Sie können Ihr Diagramm klarer und verständlicher gestalten, indem Sie Titel und Achsenbeschriftungen festlegen.

5.2 Liniendiagramm

Liniendiagramme sind ein gängiger Diagrammtyp, der zur Darstellung von Datentrends im Zeitverlauf oder anderen kontinuierlichen Variablen verwendet wird.existierenbqplotin, verwendet werden kannplt.plot Funktion zum Erstellen eines Liniendiagramms. Hier ist ein Beispiel:

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 diesem Beispiel haben wir eine Sinusfunktion mit 100 Datenpunkten generiert und diese dann verwendetplt.plot Die Funktion erstellt ein Liniendiagramm. Sie können Ihr Diagramm klarer und verständlicher gestalten, indem Sie Titel und Achsenbeschriftungen festlegen.

5.3 Candlestick-Chart

Candlestick-Charts (auch Candlestick-Charts genannt) sind eine Art Diagramm, das zur Darstellung von Finanzdaten wie Aktienkursen verwendet wird.existierenbqplotin, verwendet werden kannplt.candle Funktion zum Erstellen von Candlestick-Charts. Hier ist ein Beispiel:

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 diesem Beispiel generieren wir zufällige Eröffnungs-, Höchst-, Tiefst- und Schlusskursdaten und verwenden sie dannplt.candle Die Funktion erstellt ein Candlestick-Diagramm. Sie können Ihr Diagramm klarer und verständlicher gestalten, indem Sie Titel und Achsenbeschriftungen festlegen.

5.4 Wärmekarte

Eine Heatmap ist eine Art Diagramm, das zur Darstellung der Dichte- oder Intensitätsverteilung zweidimensionaler Daten verwendet wird.existierenbqplotin, verwendet werden kannplt.heatmap Funktion zum Erstellen einer Heatmap. Hier ist ein Beispiel:

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 diesem Beispiel haben wir eine 10x10-Matrix aus Zufallsdaten generiert und diese dann verwendetplt.heatmap Die Funktion erstellt eine Heatmap. Sie können Ihr Diagramm klarer und verständlicher gestalten, indem Sie Titel und Achsenbeschriftungen festlegen.

5.5 Geografische Karte

Ein geografisches Diagramm ist eine Art Diagramm, das zur Anzeige geografischer Daten, beispielsweise einer Karte, verwendet wird.existierenbqplotin, verwendet werden kannplt.geo Funktion zum Erstellen geografischer Karten. Hier ist ein Beispiel:

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 diesem Beispiel laden wir die Weltkartendaten und verwenden sie dannplt.geo Die Funktion erstellt eine geografische Karte. Durch das Festlegen eines Titels können Sie Ihr Diagramm klarer und verständlicher gestalten.

Interaktive Funktionen

6.1 Übersicht interaktiver Komponenten

Bei der Datenvisualisierung sind interaktive Funktionen der Schlüssel zur Verbesserung der Benutzererfahrung und der Datenexplorationsfunktionen.bqplot Bietet umfangreiche interaktive Komponenten, die es Benutzern ermöglichen, dynamische und reaktionsfähige Datenexplorationen in Jupyter Notebook durchzuführen. Zu diesen interaktiven Komponenten gehören unter anderem:

Zoomen und schwenken: Ermöglicht dem Benutzer das Vergrößern oder Verkleinern des Diagramms sowie das Schwenken über das Diagramm, um verschiedene Datenbereiche anzuzeigen.
Auswählen und wischen: Ermöglicht Benutzern die Auswahl bestimmter Datenpunkte oder Bereiche in einem Diagramm zur weiteren Analyse.
Tooltip: Detaillierte Informationen anzeigen, wenn die Maus über einen Datenpunkt fährt.
Dynamische Updates: Ermöglicht die dynamische Aktualisierung von Diagrammen basierend auf Benutzereingaben oder Datenänderungen.

Diese interaktiven Komponenten sind bqplot vonInteractions Die Modulimplementierung bietet Benutzern intuitive und leistungsstarke Datenexplorationstools.

6.2 Nutzung gängiger interaktiver Komponenten

Zoomen und schwenken

Zoomen und Schwenken sind die grundlegendsten interaktiven Funktionen bei der Datenvisualisierung.bqplot Bietet integrierte Zoom- und Schwenkfunktionen. Benutzer können mit dem Mausrad zoomen und durch Ziehen mit der Maus schwenken. Hier ist ein einfaches Beispiel:

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 diesem Beispiel kann der Benutzer das Diagramm mit dem Mausrad vergrößern oder verkleinern und das Diagramm durch Ziehen mit der Maus verschieben.

Auswählen und wischen

Mithilfe der Auswahl- und Pinselauswahlfunktionen können Benutzer bestimmte Datenpunkte oder Bereiche innerhalb eines Diagramms zur weiteren Analyse auswählen.bqplot bereitgestelltBrushSelector UndLassoSelector Komponenten zur Implementierung dieser Funktionalität.Das Folgende ist eine VerwendungBrushSelector Beispiel:

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 diesem Beispiel kann der Benutzer durch Ziehen mit der Maus einen rechteckigen Bereich im Diagramm auswählen und die ausgewählten Datenpunkte werden hervorgehoben.

Tooltip

Tooltips können detaillierte Informationen anzeigen, wenn der Benutzer mit der Maus über einen Datenpunkt fährt.bqplot bereitgestelltTooltip Komponente, um diese Funktionalität zu erreichen. Hier ist ein einfaches Beispiel:

from bqplot import Tooltip

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

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

Wenn der Benutzer in diesem Beispiel mit der Maus über einen Datenpunkt eines Streudiagramms fährt, wird der x Undy Wert.

Dynamische Updates

Mit der dynamischen Aktualisierungsfunktion können Diagramme basierend auf Benutzereingaben oder Datenänderungen dynamisch aktualisiert werden.bqplot bereitgestelltinteracts Modul zur Implementierung dieser Funktionalität. Hier ist ein einfaches Beispiel:

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 diesem Beispiel kann der Benutzer die Daten im Diagramm dynamisch aktualisieren, indem er den Wert des Schiebereglers anpasst.

Erweiterte Funktionen und Anwendungen

7.1 Interaktives Dashboard

Interaktive Dashboards sind eine wichtige Anwendung in der Datenvisualisierung, die es Benutzern ermöglicht, Daten mithilfe interaktiver Komponenten dynamisch zu erkunden, um ein tieferes Verständnis der Informationen hinter den Daten zu erlangen. bqplot bietet leistungsstarke Funktionen zum Erstellen interaktiver Dashboards. Hier ist ein einfaches Beispiel, das zeigt, wie ein Dashboard mit mehreren Diagrammen und interaktiven Komponenten erstellt wird.

So erstellen Sie ein interaktives Dashboard

Importieren Sie die erforderlichen Bibliotheken：

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

Daten vorbereiten：

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

Erstellen Sie eine Diagrammkomponente：

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

Erstellen Sie interaktive Komponenten：

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

Definieren Sie die Interaktionslogik：

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

Verbundbauteile：

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

Durch die oben genannten Schritte können wir ein einfaches interaktives Dashboard erstellen, in dem Benutzer über das Dropdown-Menü verschiedene Diagrammtypen auswählen können, um eine dynamische Datenvisualisierung zu erreichen.

7.2 Datenselektoren (Selektoren)

Datenselektoren sind wichtige Komponenten in bqplot für die Datenfilterung und -interaktion. Über den Datenselektor können Benutzer Daten direkt im Diagramm auswählen und bearbeiten, um eine verfeinerte Datenanalyse zu erreichen.

Beispiel für die Verwendung des Datenselektors

Importieren Sie die erforderlichen Bibliotheken：

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

Daten vorbereiten：

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

Diagramm erstellen：

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

Erstellen Sie einen Datenselektor：

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

Auswahllogik definieren：

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

Diagramm anzeigen：
```
display(plt.figure)
1
```

Durch die oben genannten Schritte können wir einen Datenselektor im Streudiagramm erstellen. Der Benutzer kann Datenpunkte durch Ziehen mit der Maus auswählen und die ausgewählten Daten in der Konsole ausgeben.

7.3 Fortgeschrittene Anwendungen von Projektion und Karte

bqplot unterstützt nicht nur einfache 2D-Diagramme, sondern bietet auch leistungsstarke geografische Diagrammfunktionen, mit denen verschiedene Kartenprojektionen und erweiterte geografische Diagramme erstellt werden können.

Beispiel für die Erstellung einer geografischen Karte

Importieren Sie die erforderlichen Bibliotheken：

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

Bereiten Sie geografische Daten vor：

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

Erstellen Sie eine geografische Karte：

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

Erstellen Sie interaktive Komponenten：

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

Definieren Sie die Interaktionslogik：

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

Verbundbauteile：

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

Durch die oben genannten Schritte können wir eine geografische Karte erstellen, die mehrere Kartenprojektionen unterstützt. Benutzer können über das Dropdown-Menü verschiedene Projektionsmethoden auswählen, um eine dynamische Kartenanzeige zu erreichen.

Durch diese erweiterten Funktionen und Anwendungen stellt bqplot Benutzern leistungsstarke Datenvisualisierungstools zur Verfügung, die die interaktive Datenanalyse in Jupyter Notebook komfortabler und effizienter machen.

API-Dokumentation

8.1 Pyplot

bqplot bietet so etwas wiematplotlib vonpyplot Mit der API können Benutzer schnell Diagramme erstellen und anzeigen.Im Folgenden sind einige häufig verwendete aufgeführtpyplot Funktionen und Beispiele:

figure(): Eine neue Grafik erstellen.
plot(): Zeichnen Sie ein Liniendiagramm.
scatter(): Zeichnen Sie ein Streudiagramm.
bar(): Zeichnen Sie ein Balkendiagramm.
pie(): Zeichne ein Kreisdiagramm.
hist(): Zeichnen Sie ein Histogramm.

Beispielcode:

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 Objektmodell

bqplot Das Objektmodell basiert auf der Grammar of Graphics und bietet eine flexiblere und detailliertere Möglichkeit, Diagramme anzupassen. Hier sind einige Kernobjekte und Beispiele:

Figure: Container für das Diagramm, der alle Markierungen und Achsen enthält.
Mark: Spezifische grafische Elemente wie Linien, Punkte, Balken usw.
Axis: Achse.
Scale: Daten-zu-Grafik-Zuordnung.

Beispielcode:

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 Tooltips und Symbolleisten

bqplot Bietet umfangreiche Tooltips und Symbolleistenfunktionen, sodass Benutzer bequemer mit Grafiken interagieren können.

Tooltip: Dateninformationen anzeigen, wenn die Maus darüber bewegt wird.
Toolbar: Bietet interaktive Funktionen wie Zoomen und Schwenken.

Beispielcode:

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 Interaktion und Marktkarte

bqplot Unterstützt komplexe interaktive Funktionen wie Auswahl, Zoomen, Schwenken usw. Auch,bqplot Es kann auch zur Erstellung erweiterter Visualisierungen wie Marktkarten verwendet werden.

Beispielcode:

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

Durch die Einführung der oben genannten API-Dokumente können Benutzer sie besser verstehen und verwenden bqplot Bibliothek zum Erstellen umfangreicher, interaktiver Datenvisualisierungen.

Migrationsleitfäden und Beiträge

9.1 Migrationsleitfaden

Bei der Migration bestehender Projekte aus anderen Datenvisualisierungsbibliotheken wie Matplotlib oder Plotly nach bqplot können einige Herausforderungen auftreten. Hier sind einige wichtige Schritte und Überlegungen, die Ihnen bei der Steuerung des Migrationsprozesses helfen sollen.

9.1.1 Verstehen Sie die Grundkonzepte von bqplot

Bevor Sie mit der Migration beginnen, müssen Sie zunächst die Grundkonzepte von bqplot verstehen, einschließlich:

Waage: Definieren Sie die Zuordnungsmethode für Daten, z. B. lineare Skala, logarithmische Skala usw.
Markierungen: Stellt visuelle Elemente in Diagrammen dar, z. B. Streupunkte, Linien, Balken usw.
Äxte: Definieren Sie die Koordinatenachse des Diagramms.
Interaktionen: Definieren Sie, wie Benutzer mit dem Diagramm interagieren.

9.1.2 Datenaufbereitung

Stellen Sie sicher, dass Ihre Daten bereit sind und problemlos in das von bqplot benötigte Format konvertiert werden können. Typischerweise können Daten in einem Pandas DataFrame gespeichert werden, was eine einfache Datenbearbeitung und -visualisierung ermöglicht.

9.1.3 Allmähliche Migration

Importieren Sie die erforderlichen Bibliotheken：

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

Erstellen Sie Skalen und Achsen：

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

Tag erstellen：

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

Diagramm erstellen：

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

Diagramm anzeigen：
```
display(fig)
1
```

9.1.4 Umgang mit Interaktionen

bqplot bietet umfangreiche interaktive Funktionen, die durch Festlegen verschiedener Eigenschaften erreicht werden können. So aktivieren Sie beispielsweise die Zoom- und Schwenkfunktion:

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

9.1.5 Benutzerdefinierte Stile

Mit bqplot können Sie den Stil Ihres Diagramms anpassen, einschließlich Farbe, Markierungsstil, Linienstil usw. So passen Sie beispielsweise das Erscheinungsbild eines Streudiagramms an:

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 Beitragsrichtlinien

bqplot ist ein Open-Source-Projekt und Community-Mitglieder sind herzlich willkommen, Code, Dokumentation und Beispiele beizusteuern. Hier sind einige Beitragsrichtlinien, die Ihnen den Einstieg in das bqplot-Projekt erleichtern sollen.

9.2.1 Einrichten der Entwicklungsumgebung

Klon-Repository：

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

Abhängigkeiten installieren：
```
pip install -r requirements.txt
1
```
Entwicklungsversion installieren：
```
pip install -e .
1
```

9.2.2 Code schreiben

Wenn Sie Code beisteuern, befolgen Sie bitte diese Richtlinien:

Codierungsstil:Befolgen Sie den PEP 8-Styleguide.
dokumentieren: Dokumentation für neue Funktionen oder Änderungen hinzufügen.
prüfen:Schreiben Sie Unit-Tests, um die Richtigkeit des Codes sicherzustellen.

9.2.3 PR einreichen

Erstellen Sie einen Zweig：
```
git checkout -b my-new-feature
1
```

Änderungen übernehmen：

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

Push-Zweig：
```
git push origin my-new-feature
1
```
Erstellen Sie eine Pull-Anfrage：
Erstellen Sie auf GitHub eine neue Pull-Anfrage, in der Sie Ihre Änderungen und Ihre Motivation beschreiben.

9.2.4 Beteiligen Sie sich an der Gemeinschaft

Beteiligen Sie sich an Diskussionen: Treten Sie dem Gitter-Chatroom oder dem GitHub-Diskussionsforum von bqplot bei, um mit anderen Entwicklern zu kommunizieren.
Ein Problem melden: Wenn Sie Probleme oder Fehler finden, reichen Sie bitte ein Problem auf GitHub ein.
Rückmeldung geben: Geben Sie Feedback zu neuen Funktionen oder Verbesserungen, um die Projektentwicklung zu verbessern.

Indem Sie diese Richtlinien befolgen, können Sie einen wertvollen Beitrag zum bqplot-Projekt leisten und dazu beitragen, die interaktive Datenvisualisierung in der Python-Community voranzutreiben.

Zusammenfassung und Ausblick

10.1 Vorteile und Einschränkungen von bqplot

Vorteil

bqplot basiert aufGrammatik der Grafik 2D-Visualisierungssystem, entwickelt fürJupyter-Notizbuch Design. Es hat die folgenden wesentlichen Vorteile:

Interaktivität: Jede Komponente von bqplot ist ein interaktives Widget, das es Benutzern ermöglicht, Visualisierungen einfach mit anderen interaktiven Jupyter-Widgets zu integrieren, um komplexe grafische Benutzeroberflächen (GUIs) zu erstellen.
Benutzerfreundlichkeit: Durch einfachen Python-Code können Benutzer schnell verschiedene Diagramme erstellen und anpassen, ohne komplexe Grafikprogrammierung tiefgreifend verstehen zu müssen.
Flexibilität: Unterstützt eine Vielzahl von Diagrammtypen, einschließlich Streudiagrammen, Kreisdiagrammen, Boxplots, Balkendiagrammen usw., um unterschiedliche Anforderungen an die Datenvisualisierung zu erfüllen.
Integration: Perfekt in das Jupyter-Ökosystem integriert, was die Verwendung für Datenwissenschaftler und Analysten im Datenanalyseprozess erleichtert.

Einschränkungen

Obwohl bqplot leistungsstarke Funktionalität und Flexibilität bietet, weist es auch einige Einschränkungen auf:

Leistung: Bei großen Datensätzen ist die Leistung von bqplot möglicherweise nicht so gut wie bei einigen professionellen Visualisierungstools, insbesondere beim Umgang mit komplexen Diagrammen und großen Datenmengen.
Lernkurve: Obwohl der Einstieg in bqplot relativ einfach ist, dauert es für Anfänger dennoch einige Zeit, sich mit der API und den interaktiven Komponenten vertraut zu machen.
gemeinschaftliche Unterstützung: Im Vergleich zu einigen ausgereiften Visualisierungsbibliotheken verfügt bqplot über eine kleinere Community, was dazu führen kann, dass die Ressourcen für Hilfe bei Problemen begrenzt sind.

10.2 Zukünftige Entwicklungstrends

Als aktives Open-Source-Projekt verdienen die zukünftigen Entwicklungstrends von bqplot Aufmerksamkeit:

Leistungsoptimierung: Mit der Entwicklung der Technologie wird erwartet, dass bqplot erhebliche Leistungsverbesserungen erhält und große Datensätze und komplexe Diagramme besser verarbeiten wird.
Neue Funktionsintegration: Zukünftige Versionen werden möglicherweise erweiterte Diagrammtypen und interaktive Funktionen wie 3D-Visualisierung, Animationsunterstützung usw. einführen.
Gemeinschaftswachstum: Da die Beliebtheit und der Anwendungsbereich von bqplot zunehmen, wird erwartet, dass die Community weiter wächst und mehr Entwickler und Benutzer zur Teilnahme anzieht.
Plattformübergreifende Unterstützung: Zusätzlich zu Jupyter Notebook kann bqplot auf andere Plattformen und Umgebungen erweitert werden, um ein breiteres Spektrum an Anwendungsszenarien bereitzustellen.

Kurz gesagt, bqplot hat als leistungsstarkes interaktives Datenvisualisierungstool breite Anwendungsaussichten im Bereich der Datenwissenschaft. Durch kontinuierliche Optimierung und Funktionserweiterung wird es weiterhin mehr Möglichkeiten zur Datenanalyse und -visualisierung bieten.

Technologieaustausch