bqplot tutorial: interactive data visualization in Jupyter Notebook

bqplot Tutorial: Interactive Data Visualization in Jupyter Notebook

2024-07-12

introduce

1.1 The Importance of Data Visualization

Data visualization is to present data in the form of graphics, helping people to understand the information and rules behind the data more intuitively and quickly. In today's era of information explosion, data visualization is particularly important for the following reasons:

Improve understanding efficiency：Graphical data is easier for the brain to understand and remember than plain text or numbers. Through charts, people can quickly capture the key points of the data and make more informed decisions.
Uncovering patterns in data：Data visualization can help discover hidden patterns, trends, and outliers in the data. For example, a line chart can clearly show the trend of data changes over time.
Enhance communication effectiveness：In business, scientific research, education and other fields, data visualization is a powerful tool for communicating complex information. It makes data analysis results easier for others to understand and accept.
Support decision making：Data visualization provides intuitive data support for decision makers, helping them find key information in complex data and make more scientific and reasonable decisions.

1.2 Overview of the bqplot Library

bqplot is aGrammar of Graphics A 2D visualization library specifically forJupyter Notebook design. It combinesd3.js andipywidgets The bqplot library is designed to bring the powerful visualization capabilities of d3.js to Python. Here are some key features of the bqplot library:

Interactivity: bqplot provides rich interactive functions. Users can pan, zoom, select, and perform other operations on the chart to explore the data more deeply.
flexibility: Through an object-oriented approach, users can use the Grammar of Graphics to create highly personalized charts.
Ease of use: bqplot provides a pyplot interface similar to matplotlib, allowing users familiar with matplotlib to get started quickly.
Integration: As a native library of Jupyter Notebook, bqplot can be seamlessly integrated into the data analysis workflow, providing users with a smooth interactive experience.

Installation and Quick Start

Installing bqplot is as simple as running the following command in your terminal or command prompt:

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

After successful installation, import the necessary libraries in Jupyter Notebook to start using it:

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

Here is a simple example showing how to create a histogram using 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

Through this simple example, you can see the ease of use and powerful interactive functions of bqplot. In the following chapters, we will explore the various chart types and advanced functions of bqplot in depth.

Installation and Import

2.1 Install bqplot

Before you start using bqplot for data visualization, you first need to install the bqplot library in your environment. bqplot can be installed in a number of ways, the most common being using pip or conda. Here are the detailed steps for using both methods:

Install using pip

pip install bqplot
1

Install using conda

conda install -c conda-forge bqplot
1

After the installation is complete, you can confirm whether the installation was successful by running the following command:

import bqplot
print(bqplot.__version__)
1
2

2.2 Import necessary libraries

After installing bqplot, you will need to import the necessary libraries to start data visualization. Typically, you will need to import the following libraries:

bqplot: Used to create interactive charts.
numpy: Used for numerical calculation and data processing.
pandas: Used for data manipulation and analysis.

Here is sample code that imports these libraries:

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

Example: Import and create a simple chart using bqplot

To make sure everything is set up correctly, you can try creating a simple bar chart. Here is a sample code showing how to import the necessary libraries and create a simple bar chart:

# 导入必要的库
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 this example, we first importedbqplot.pyplotAsplt, then usenumpyGenerate random data. Next, we created a simple bar chart with five bars and displayed it in Jupyter Notebook.

With the above steps, you have successfully installed and imported the bqplot library and created your first simple interactive chart. Next, you can continue to explore more advanced features and chart types.

Dataset preparation

3.1 Importing the dataset

Before starting to use bqplot Before you can visualize data, you first need to import the required dataset. Here are some common dataset import methods and how to use them:pandas library to process this data.

Importing CSV files using pandas

pandas It is a powerful data processing library, widely used for data analysis and preprocessing. Here is how to use itpandas Example of importing a CSV file:

import pandas as pd

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

Importing data in other formats using pandas

In addition to CSV files,pandas It also supports importing data in multiple formats, such as Excel files, JSON files, etc. Here are some examples:

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

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

Import data from the database using pandas

If the data is stored in a database, you can use pandas ofread_sql function to import data. Here is an example:

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 Dataset Preview

After importing a dataset, you usually need to preview it to understand the structure and content of the data.pandas Provides several ways to preview a dataset.

View the first few rows of the dataset

use head() Method can view the first few rows of the dataset:

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

View basic information of the dataset

use info() The method can view the basic information of the data set, including data type and missing values:

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

View the statistics of the dataset

use describe() The method can view the statistical information of the data set, including mean, standard deviation, minimum value, maximum value, etc.:

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

View the column names of the dataset

use columns You can view the column names of the dataset by using the properties:

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

Through the above methods, we can have a basic understanding of the imported data set, thus laying the foundation for subsequent data visualization work.

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

Basic chart types

4.1 Scatter plot

A scatter plot is a graph used to show the relationship between two variables. Through a scatter plot, you can visually observe the distribution and correlation of data. In bqplot, creating a scatter plot is very 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 Pie Chart

A pie chart is a chart used to show the proportion of data. In bqplot, creating a pie chart is also 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 Box Plot

Box Plot is a chart used to show the distribution of data. It can display the median, quartiles and outliers of the data.

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 Bar Chart

A bar chart is a chart used to show comparisons between categorical data. The height of each bar represents the data value of that category.

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 Stacked Bar Chart

A stacked bar chart is a chart used to show the comparison between multiple categorical data. The height of each bar represents the data value of that category, and each bar can be divided into multiple parts, each part representing a subcategory.

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

Advanced chart types

5.1 Histogram

A histogram is a type of chart used to display the distribution of data.bqplotIn theplt.histFunction to create a histogram. Here is a simple example:

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 this example, we first generated 1000 random data points and then usedplt.histThe function creates a histogram with 30 bins. By setting the title and axis labels, you can make the chart clearer and easier to understand.

5.2 Line Chart

A line chart is a commonly used chart type that is used to show the changing trend of data over time or other continuous variables.bqplotIn theplt.plotFunction to create a line chart. Here is an example:

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 this example, we generate a sine function data with 100 data points and then useplt.plotThe function creates a line chart. By setting the title and axis labels, you can make the chart clearer and easier to understand.

5.3 Candlestick chart

A candlestick chart (also called a candlestick chart) is a type of chart used to display financial data such as stock prices.bqplotIn theplt.candleFunction to create a candlestick chart. Here is an example:

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 this example, we generate random open, high, low, and close price data and then useplt.candleThe function creates a candlestick chart. By setting the title and axis labels, you can make the chart clearer and easier to understand.

5.4 Heatmap

A heat map is a type of chart used to show the density or intensity distribution of two-dimensional data.bqplotIn theplt.heatmapfunction to create a heat map. Here is an example:

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 this example, we generate a 10x10 matrix of random data and then useplt.heatmapThe function creates a heat map. By setting the title and axis labels, you can make the chart clearer and easier to understand.

5.5 Geographical Map

A geographic chart is a type of chart used to present geographic data, such as a map.bqplotIn theplt.geoFunction to create a geographic map. Here is an example:

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 this example, we load the world map data and then useplt.geoThe function creates a geographic plot. By setting a title, you can make the plot clearer and easier to understand.

Interactive Features

6.1 Overview of Interaction Components

In data visualization, interactive functions are the key to improving user experience and data exploration capabilities.bqplot Provides a rich set of interactive components that enable users to perform dynamic and responsive data exploration in Jupyter Notebook. These interactive components include but are not limited to:

Zoom and Pan: Allows users to zoom in or out of the chart, and pan on the chart to view data in different areas.
Select and Brush: Allows the user to select specific data points or areas in the chart for further analysis.
tooltip: When you hover the mouse over a data point, detailed information is displayed.
Dynamic Updates: Allows the chart to update dynamically based on user input or data changes.

These interactive components are bqplot ofInteractions Module implementation provides users with intuitive and powerful data exploration tools.

6.2 Use of Common Interaction Components

Zoom and Pan

Zooming and panning are the most basic interactive features in data visualization.bqplot Built-in zoom and pan functions are provided, and users can zoom by using the mouse wheel and pan by dragging the mouse. The following is a simple example:

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 this example, the user can zoom in or out of the chart by using the mouse wheel and pan the chart by dragging the mouse.

Select and Brush

Select and brush functionality allows the user to select specific data points or areas within a chart for further analysis.bqplot providedBrushSelector andLassoSelector Components to achieve this function. The following is aBrushSelector Example:

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 this example, the user can drag the mouse to select a rectangular area in the chart, and the selected data points will be highlighted.

tooltip

Tooltips display detailed information when the user hovers over a data point.bqplot providedTooltip Component to achieve this functionality. Here is a simple example:

from bqplot import Tooltip

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

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

In this example, when the user hovers over a data point in the scatter plot, a x andy value.

Dynamic Updates

The dynamic update feature allows charts to dynamically update based on user input or data changes.bqplot providedinteracts Module to achieve this functionality. Here is a simple example:

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 this example, the user can dynamically update the data in the chart by adjusting the value of the slider.

Advanced features and applications

7.1 Interactive Dashboard

Interactive dashboards are an important application in data visualization, which allow users to dynamically explore data through interactive components, so as to have a deeper understanding of the information behind the data. bqplot provides powerful functions to create interactive dashboards. The following is a simple example showing how to create a dashboard with multiple charts and interactive components.

Steps to create an interactive dashboard

Import necessary libraries：

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

Prepare the data：

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

Creating a Chart Component：

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

Creating interactive components：

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

Defining interaction logic：

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

Combining Components：

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

Through the above steps, we can create a simple interactive dashboard where users can select different chart types through the drop-down menu to achieve dynamic data visualization.

7.2 Data Selectors

The data selector is an important component in bqplot for data filtering and interaction. Through the data selector, users can directly select and operate data on the chart, thus achieving more sophisticated data analysis.

Examples of using data selectors

Import necessary libraries：

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

Prepare the data：

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

Create a chart：

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

Creating a data selector：

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

Defining selection logic：

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

Show Chart：
```
display(plt.figure)
1
```

Through the above steps, we can create a data selector on the scatter plot. Users can select data points by dragging the mouse and output the selected data in the console.

7.3 Projection and Advanced Map Applications

bqplot not only supports basic 2D charts, but also provides powerful geographic chart functions that can be used to create various map projections and advanced geographic charts.

Example of creating a geographic map

Import necessary libraries：

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

Prepare geographic data：

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

Creating a Geographic Map：

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

Creating interactive components：

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

Defining interaction logic：

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

Combining Components：

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

Through the above steps, we can create a geographic map that supports multiple map projections. Users can select different projection methods through the drop-down menu to achieve dynamic map display.

Through these advanced functions and applications, bqplot provides users with powerful data visualization tools, making interactive data analysis in Jupyter Notebook more convenient and efficient.

API Documentation

8.1 Pyplot

bqplot Provides similarmatplotlib ofpyplot API allows users to quickly create and display charts. The following are some commonly usedpyplot Functions and examples:

figure(): Create a new shape.
plot(): Draw a line chart.
scatter(): Draw a scatter plot.
bar(): Draw a bar graph.
pie(): Draw a pie chart.
hist(): Draw a histogram.

Sample 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 Object Model

bqplot The object model of GraphQL is based on the Grammar of Graphics, providing more flexible and detailed chart customization. Here are some core objects and examples:

Figure: The container of the figure, including all markers and axes.
Mark: Specific graphic elements, such as lines, points, bars, etc.
Axis: Axis.
Scale: Mapping of data to graphics.

Sample 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 Tooltips and Toolbars

bqplot Provides rich tooltips and toolbar functions, allowing users to interact with graphics more conveniently.

Tooltip: Displays data information when the mouse is hovering.
Toolbar: Provides interactive functions such as zooming and panning.

Sample 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 and Market Map

bqplot Supports complex interactive functions such as selection, zooming, panning, etc. In addition,bqplot It can also be used to create advanced visualizations such as market maps.

Sample 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

Through the introduction of the above API documents, users can better understand and use bqplot Library to create rich, interactive data visualizations.

Migration Guide and Contributions

9.1 Migration Guide

When migrating an existing project from other data visualization libraries (such as Matplotlib or Plotly) to bqplot, you may encounter some challenges. Here are some key steps and considerations to help you complete the migration process smoothly.

9.1.1 Understanding the Basic Concepts of bqplot

Before starting the migration, you first need to understand the basic concepts of bqplot, including:

Scales: Define the mapping method of data, such as linear scale, logarithmic scale, etc.
Marks: Represents the visualization elements in the chart, such as scatter points, lines, bars, etc.
Axes: Defines the coordinate axes of the chart.
Interactions: Defines how users interact with the chart.

9.1.2 Data Preparation

Make sure your data is ready and can be easily converted to the format required by bqplot. Usually, the data can be stored in a Pandas DataFrame, which allows for easy data manipulation and visualization.

9.1.3 Gradual Migration

Import necessary libraries：

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

Creating scales and 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

Create a tag：

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

Create a chart：

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

Show Chart：
```
display(fig)
1
```

9.1.4 Handling Interactions

bqplot provides a wealth of interactive features that can be achieved by setting different properties. For example, enable zooming and panning:

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

9.1.5 Custom Styles

bqplot allows you to customize the style of the chart, including color, marker style, line type, etc. For example, to customize the appearance of a scatter plot:

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 Contribution Guidelines

bqplot is an open source project that welcomes community contributions of code, documentation, and examples. Here are some contribution guidelines to help you get started contributing to the bqplot project.

9.2.1 Setting up the development environment

Clone the repository：

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

Install Dependencies：
```
pip install -r requirements.txt
1
```
Install the development version：
```
pip install -e .
1
```

9.2.2 Writing Code

When contributing code, please follow these guidelines:

Coding style: Follows the PEP 8 style guide.
document: Add documentation for new features or modifications.
test: Write unit tests to ensure the correctness of the code.

9.2.3 Submit PR

Create a branch：
```
git checkout -b my-new-feature
1
```

Commit changes：

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

Pushing a branch：
```
git push origin my-new-feature
1
```
Creating a Pull Request：
Create a new Pull Request on GitHub describing your changes and your motivation.

9.2.4 Community Participation

Join the discussion: Join the bqplot Gitter chatroom or GitHub discussion board to communicate with other developers.
Report a Problem: If you find any issues or bugs, please file an issue on GitHub.
Provide feedback: Provide feedback on new features or improvements to help the project grow better.

By following these guidelines, you can make valuable contributions to the bqplot project and help advance interactive data visualization in the Python community.

Summary and Outlook

10.1 Advantages and limitations of bqplot

Advantage

bqplot is aGrammar of Graphics A 2D visualization system designed forJupyter Notebook Design. It has the following significant advantages:

Interactivity: Each component of bqplot is an interactive widget, and users can easily integrate visualizations with other Jupyter interactive widgets to create complex graphical user interfaces (GUIs).
Ease of use: Through simple Python code, users can quickly create and customize various charts without having to have an in-depth understanding of complex graphics programming.
flexibility: Supports multiple chart types, including scatter plots, pie charts, box plots, bar charts, etc. to meet different data visualization needs.
Integration: Perfectly integrated with the Jupyter ecosystem, making it easy for data scientists and analysts to use in the data analysis process.

Limitations

Although bqplot provides powerful functionality and flexibility, it also has some limitations:

performance: For large datasets, bqplot may not perform as well as some professional visualization tools, especially when dealing with complex charts and large amounts of data.
learning curve: Although bqplot is relatively easy to use, it still takes some time for beginners to get familiar with its API and interactive components.
Community Support: Compared to some mature visualization libraries, bqplot has a smaller community, which may lead to limited resources for seeking help when encountering problems.

10.2 Future Development Trends

As an active open source project, bqplot's future development trends are worth paying attention to:

Performance Optimization: As technology develops, bqplot is expected to see significant performance improvements and better handle large data sets and complex charts.
New feature integration: Future versions may introduce more advanced chart types and interactive features, such as 3D visualization, animation support, etc.
Community Growth: As bqplot becomes more well-known and widely used, its community is expected to continue to grow and attract more developers and users.
Cross-platform support: In addition to Jupyter Notebook, bqplot may be extended to other platforms and environments to provide a wider range of application scenarios.

In short, as a powerful interactive data visualization tool, bqplot has broad application prospects in the field of data science. With continuous optimization and function expansion, it will continue to provide more possibilities for data analysis and visualization.

Technology Sharing