2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
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:
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:
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
Importieren Sie nach erfolgreicher Installation die erforderlichen Bibliotheken in Jupyter Notebook, um Folgendes zu verwenden:
import numpy as np
import bqplot.pyplot as plt
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
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.
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:
pip install bqplot
conda install -c conda-forge bqplot
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__)
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
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
In diesem Beispiel importieren wir zunächstbqplot.pyplot
alsplt
, 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.
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.
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")
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")
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)
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.
verwenden head()
Methode zum Anzeigen der ersten Zeilen des Datensatzes:
# 查看前5行数据
print(df1.head())
verwenden info()
Die Methode kann die grundlegenden Informationen des Datensatzes anzeigen, einschließlich Datentyp und fehlender Werte:
# 查看数据集的基本信息
print(df1.info())
verwenden describe()
Die Methode kann die statistischen Informationen des Datensatzes anzeigen, einschließlich Mittelwert, Standardabweichung, Minimalwert, Maximalwert usw.:
# 查看数据集的统计信息
print(df1.describe())
verwenden columns
Eigenschaften können die Spaltennamen des Datensatzes anzeigen:
# 查看数据集的列名
print(df1.columns)
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 堆积条形图"
]
}
]
}
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
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
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
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
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
Ein Histogramm ist eine Art Diagramm, mit dem die Verteilung von Daten dargestellt wird.existierenbqplot
in, 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
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.
Liniendiagramme sind ein gängiger Diagrammtyp, der zur Darstellung von Datentrends im Zeitverlauf oder anderen kontinuierlichen Variablen verwendet wird.existierenbqplot
in, 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
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.
Candlestick-Charts (auch Candlestick-Charts genannt) sind eine Art Diagramm, das zur Darstellung von Finanzdaten wie Aktienkursen verwendet wird.existierenbqplot
in, 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
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.
Eine Heatmap ist eine Art Diagramm, das zur Darstellung der Dichte- oder Intensitätsverteilung zweidimensionaler Daten verwendet wird.existierenbqplot
in, 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
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.
Ein geografisches Diagramm ist eine Art Diagramm, das zur Anzeige geografischer Daten, beispielsweise einer Karte, verwendet wird.existierenbqplot
in, 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
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.
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:
Diese interaktiven Komponenten sind bqplot
vonInteractions
Die Modulimplementierung bietet Benutzern intuitive und leistungsstarke Datenexplorationstools.
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()
In diesem Beispiel kann der Benutzer das Diagramm mit dem Mausrad vergrößern oder verkleinern und das Diagramm durch Ziehen mit der Maus verschieben.
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
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.
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
Wenn der Benutzer in diesem Beispiel mit der Maus über einen Datenpunkt eines Streudiagramms fährt, wird der x
Undy
Wert.
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
In diesem Beispiel kann der Benutzer die Daten im Diagramm dynamisch aktualisieren, indem er den Wert des Schiebereglers anpasst.
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.
Importieren Sie die erforderlichen Bibliotheken:
import bqplot as bq
import ipywidgets as widgets
from bqplot import pyplot as plt
import numpy as np
Daten vorbereiten:
x = np.arange(100)
y = np.random.randn(100).cumsum()
Erstellen Sie eine Diagrammkomponente:
line_chart = plt.plot(x, y, 'Line Chart')
bar_chart = plt.bar(x, y, 'Bar Chart')
Erstellen Sie interaktive Komponenten:
dropdown = widgets.Dropdown(
options=['Line Chart', 'Bar Chart'],
value='Line Chart',
description='Chart Type:'
)
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')
Verbundbauteile:
dashboard = widgets.VBox([dropdown, plt.figure])
display(dashboard)
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.
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.
Importieren Sie die erforderlichen Bibliotheken:
import bqplot as bq
import ipywidgets as widgets
from bqplot import pyplot as plt
import numpy as np
Daten vorbereiten:
x = np.arange(100)
y = np.random.randn(100).cumsum()
Diagramm erstellen:
scatter_chart = plt.scatter(x, y, 'Scatter Chart')
Erstellen Sie einen Datenselektor:
selector = bq.interacts.BrushSelector(x_scale=scatter_chart.scales['x'], y_scale=scatter_chart.scales['y'])
scatter_chart.interaction = selector
Auswahllogik definieren:
def on_selection(change):
selected_data = scatter_chart.selected
print(f"Selected Data: {selected_data}")
selector.observe(on_selection, names='selected')
Diagramm anzeigen:
display(plt.figure)
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.
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.
Importieren Sie die erforderlichen Bibliotheken:
import bqplot as bq
import ipywidgets as widgets
from bqplot import pyplot as plt
import numpy as np
Bereiten Sie geografische Daten vor:
import json
with open('world.json') as f:
world_data = json.load(f)
Erstellen Sie eine geografische Karte:
map_chart = bq.Map(
map_data=bq.topo_load('world.json'),
scales={'projection': bq.AlbersUSA()}
)
Erstellen Sie interaktive Komponenten:
dropdown = widgets.Dropdown(
options=['AlbersUSA', 'Mercator', 'Orthographic'],
value='AlbersUSA',
description='Projection:'
)
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')
Verbundbauteile:
map_dashboard = widgets.VBox([dropdown, map_chart])
display(map_dashboard)
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.
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()
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
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
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
Durch die Einführung der oben genannten API-Dokumente können Benutzer sie besser verstehen und verwenden bqplot
Bibliothek zum Erstellen umfangreicher, interaktiver Datenvisualisierungen.
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.
Bevor Sie mit der Migration beginnen, müssen Sie zunächst die Grundkonzepte von bqplot verstehen, einschließlich:
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.
Importieren Sie die erforderlichen Bibliotheken:
import bqplot as bq
import pandas as pd
import numpy as np
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')
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})
Diagramm erstellen:
fig = bq.Figure(axes=[ax_x, ax_y], marks=[scatter])
Diagramm anzeigen:
display(fig)
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
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')
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.
Klon-Repository:
git clone https://github.com/bqplot/bqplot.git
cd bqplot
Abhängigkeiten installieren:
pip install -r requirements.txt
Entwicklungsversion installieren:
pip install -e .
Wenn Sie Code beisteuern, befolgen Sie bitte diese Richtlinien:
Erstellen Sie einen Zweig:
git checkout -b my-new-feature
Änderungen übernehmen:
git add .
git commit -m "Add some feature"
Push-Zweig:
git push origin my-new-feature
Erstellen Sie eine Pull-Anfrage:
Erstellen Sie auf GitHub eine neue Pull-Anfrage, in der Sie Ihre Änderungen und Ihre Motivation beschreiben.
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.
bqplot basiert aufGrammatik der Grafik 2D-Visualisierungssystem, entwickelt fürJupyter-Notizbuch Design. Es hat die folgenden wesentlichen Vorteile:
Obwohl bqplot leistungsstarke Funktionalität und Flexibilität bietet, weist es auch einige Einschränkungen auf:
Als aktives Open-Source-Projekt verdienen die zukünftigen Entwicklungstrends von bqplot Aufmerksamkeit:
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.