1. Exploring the Basics of Advanced Bokeh
Understanding the fundamentals of advanced Bokeh is crucial for anyone looking to enhance their data visualization skills. Bokeh, a powerful library in Python, allows developers to create interactive and visually appealing plots. However, diving into its advanced features opens up a new realm of possibilities.
Firstly, it’s important to grasp the core concepts of Bokeh such as figures, glyphs, and widgets. These elements are the building blocks of any Bokeh visualization. Figures serve as the canvas, glyphs are the visual marks (like circles, bars, etc.), and widgets allow for interactivity. By mastering these, you can begin to explore more complex functionalities.
One of the key aspects of advanced Bokeh is its ability to integrate seamlessly with other web technologies. This means you can embed Bokeh plots into HTML documents and dynamically update data sources via JavaScript callbacks. This integration is pivotal for adding interactivity to your visualizations, making them not just visually engaging but also interactive.
Here’s a simple example of how to create a basic Bokeh plot:
from bokeh.plotting import figure, show # Create a new plot with a title and axis labels p = figure(title="Simple Bokeh Example", x_axis_label='x', y_axis_label='y') # Add a line renderer with legend and line thickness p.line([1, 2, 3, 4, 5], [6, 7, 2, 4, 5], legend_label="Temp.", line_width=2) # Show the results show(p)
This code snippet illustrates the simplicity of creating a basic line plot. As you delve deeper into Bokeh’s features, you’ll discover how to customize and extend these plots with custom extensions and interactive capabilities, which will be covered in the following sections of this blog.
2. Designing Custom Extensions for Bokeh
Creating custom extensions for Bokeh can significantly enhance the functionality and interactivity of your visualizations. This process involves using JavaScript alongside Python to extend Bokeh’s capabilities beyond its standard offerings.
To begin, you need a basic understanding of both Python and JavaScript, as Bokeh extensions rely on these languages to operate seamlessly. The extension mechanism in Bokeh allows you to integrate new widgets, tools, and even entirely new models into the Bokeh server, enabling richer, more dynamic data interactions.
Here are the key steps to design your first custom extension:
- Define the new model in JavaScript, specifying its properties and behaviors.
- Link this model to a corresponding Python class to make it accessible in your Bokeh application.
- Implement the necessary callbacks or events in JavaScript to handle user interactions or data updates.
Consider this simple example of a custom slider widget:
from bokeh.core.properties import Int, Instance
from bokeh.models import HTMLBox, Slider
class CustomSlider(HTMLBox):
__implementation__ = "custom_slider.ts"
slider = Instance(Slider)
frequency = Int(default=1)
This Python class links to a TypeScript file (`custom_slider.ts`) where you define the visual representation and interaction logic of the slider. This setup allows you to create highly customized user interfaces tailored to specific data visualization needs.
By designing custom extensions in Bokeh, you not only enhance the visual appeal and functionality of your plots but also cater to specific user interactions, making your data presentations more effective and engaging.
Remember, the key to successful custom extensions is a deep integration between Python and JavaScript, leveraging the strengths of both to create powerful and interactive visual tools.
2.1. Understanding the Bokeh Extension Architecture
Delving into the architecture of Bokeh extensions is essential for developers aiming to customize and enhance their data visualizations. Bokeh’s extension system allows for the integration of new features that are not available out-of-the-box, leveraging the flexibility of Bokeh’s underlying technologies.
The core of Bokeh’s extension architecture lies in its ability to use custom models. These models are defined using a combination of Python and JavaScript, enabling the seamless integration of client-side interactivity. Here’s what you need to know:
- Custom Models: Developers can create new widgets or graphical representations by defining models in Python that are synced with their JavaScript counterparts.
- JavaScript Integration: The heavy lifting, especially for rendering and events, is handled by JavaScript. This dual-language approach allows for advanced interactivity within Bokeh plots.
To start creating a custom extension, you first define the Python class that extends from Model. Then, you provide the corresponding JavaScript code to implement the client-side functionality. Here is a basic example:
from bokeh.models import Model
from bokeh.core.properties import Int, String
class MyCustomModel(Model):
__implementation__ = "my_custom_model.ts"
data = Int(default=0)
label = String(default="My Custom Model")
This Python code snippet sets up a new model with properties that will be synced with the browser. The __implementation__ attribute links to a TypeScript file that defines the client-side logic.
Understanding this architecture is crucial for effectively leveraging custom extensions in Bokeh, allowing developers to push the boundaries of conventional data visualizations by adding unique interactive elements and visual enhancements.
2.2. Step-by-Step Guide to Creating Your First Bokeh Extension
Creating your first Bokeh extension can seem daunting, but with a systematic approach, you can enhance your visualizations with custom features. This guide will walk you through the process of developing a simple extension, integrating both Python and JavaScript to add unique functionalities to your Bokeh plots.
Step 1: Set Up Your Environment
Before you begin, ensure you have Bokeh installed. If not, you can install it using pip:
pip install bokeh
Step 2: Define Your Custom Model in Python
Start by creating a new Python file for your extension. Define a class that inherits from Model. This class will outline the properties of your custom model that you want to synchronize between Python and JavaScript.
from bokeh.model import Model
from bokeh.core.properties import String
class CustomTicker(Model):
__implementation__ = "custom_ticker.js"
ticker_name = String(default="My Custom Ticker")
Step 3: Implement the JavaScript Part
Next, create a JavaScript file named custom_ticker.js. This file will contain the logic for what your model does on the client side. Use Bokeh’s JavaScript library to define the corresponding model.
import {Ticker} from "bokehjs/models/tickers/ticker"
export class CustomTicker extends Ticker {
type = "CustomTicker"
get_ticks(start, end, range, cross_loc, desired_n_ticks) {
// Implement your custom ticking logic here
return {major: [start, end], minor: []}
}
}
Step 4: Compile and Use Your Extension
With both the Python and JavaScript parts defined, compile your JavaScript using a tool like Webpack or include it directly for simpler projects. You can now use your custom ticker in your Bokeh plots.
This basic extension introduces a custom ticker, but the possibilities are endless. You can create interactive sliders, buttons, or even integrate third-party JavaScript libraries. Experiment with different ideas to discover what you can achieve with custom extensions in Bokeh.
By following these steps, you’ll gain a deeper understanding of how Bokeh’s architecture supports adding interactivity and customization, empowering you to build more dynamic and engaging data visualizations.
3. Enhancing Bokeh Plots with Interactive Features
Enhancing your Bokeh plots with interactive features not only makes your visualizations more engaging but also more informative. This section explores how to leverage Bokeh’s capabilities to add interactivity to your data visualizations.
Adding Tooltips and Hover Tools
Tooltips are a simple yet powerful way to add context to your plots. By hovering over data points, users can get detailed information without cluttering the visual presentation. Here’s how you can add a HoverTool to a plot:
from bokeh.models import HoverTool from bokeh.plotting import figure, show # Create a new plot p = figure(tools="hover", tooltips="This is the value: @y") # Add a circle renderer with a size, color, and alpha p.circle([1, 2, 3, 4, 5], [6, 7, 2, 4, 5], size=20, color="navy", alpha=0.5) # Show the results show(p)
Integrating Sliders and Widgets
Sliders and other widgets can be used to dynamically adjust the data displayed on your plots. This interaction allows users to explore different scenarios or data subsets in real-time. Implementing a slider is straightforward:
from bokeh.layouts import column
from bokeh.models import Slider
from bokeh.plotting import figure, show, ColumnDataSource
# Data source
source = ColumnDataSource(data=dict(x=[1, 2, 3, 4, 5], y=[6, 7, 2, 4, 5]))
# Create a new plot
p = figure()
p.line('x', 'y', source=source)
# Create a slider
slider = Slider(start=0, end=10, value=1, step=.1, title="Adjust Y")
# Define a callback to update the plot
def update(attr, old, new):
y = [yi * slider.value for yi in source.data['y']]
source.data = dict(x=source.data['x'], y=y)
slider.on_change('value', update)
# Arrange plots and widgets in layouts
layout = column(slider, p)
show(layout)
By integrating these interactive elements, you transform static plots into interactive experiences that can significantly enhance the user’s understanding and engagement with the data. Experiment with different widgets and tools to discover the full potential of adding interactivity to your Bokeh visualizations.
3.1. Interactive Tools and Widgets Overview
Bokeh’s suite of interactive tools and widgets significantly enhances the user experience by making data visualizations more dynamic and engaging. This section provides an overview of the key interactive elements you can incorporate into your Bokeh plots.
Key Interactive Tools:
– Pan Tool: Allows users to move the plot canvas freely.
– Box Zoom Tool: Lets users zoom into a specific area of the plot.
– Wheel Zoom Tool: Zooms in and out using the mouse scroll.
– Save Tool: Enables users to download plots as PNG files.
– Reset Tool: Resets the plot to its initial state.
These tools are easily added to any plot by modifying the `tools` attribute in the Bokeh figure object. Here’s an example:
from bokeh.plotting import figure, show # Create a plot with specified tools p = figure(tools="pan,wheel_zoom,box_zoom,save,reset") p.circle([1, 2, 3, 4, 5], [6, 7, 2, 4, 5], size=20) # Show the plot show(p)
Essential Widgets:
– Button: Triggers an action when clicked.
– Checkbox Group: Allows selection of multiple options.
– Radio Button Group: Enables selection from multiple options, one at a time.
– Select: Dropdown menu for selecting a single option.
– TextInput: Lets users input text.
Widgets can be linked to plots for interactive updates. For instance, a slider widget adjusting the size of plot markers:
from bokeh.models import Slider
from bokeh.layouts import column
from bokeh.plotting import figure, show, ColumnDataSource
source = ColumnDataSource(data=dict(x=[1, 2, 3, 4, 5], y=[6, 7, 2, 4, 5], size=[10, 20, 30, 40, 50]))
p = figure()
p.circle('x', 'y', size='size', source=source)
slider = Slider(start=10, end=50, value=20, step=5, title="Marker Size")
def update(attr, old, new):
source.data['size'] = [i*new/20 for i in source.data['size']]
slider.on_change('value', update)
layout = column(slider, p)
show(layout)
By integrating these tools and widgets, you can transform static plots into interactive visualizations that allow users to explore data in a more meaningful way. Experiment with different combinations of tools and widgets to find what best enhances your data storytelling.
3.2. Integrating Custom Interactions into Bokeh Visualizations
Integrating custom interactions into your Bokeh visualizations can significantly enhance user engagement and provide deeper insights into the data. This section covers practical steps to embed these interactions into your plots.
Custom JavaScript Callbacks
Bokeh allows the use of custom JavaScript callbacks to make plots dynamic. These callbacks can respond to changes in data or user interactions without needing a server. Here’s a simple example of a JavaScript callback that updates the data based on user input:
from bokeh.models import CustomJS, ColumnDataSource, Slider
from bokeh.layouts import column
from bokeh.plotting import figure, show
source = ColumnDataSource(data=dict(x=[1, 2, 3, 4, 5], y=[6, 7, 2, 4, 5]))
p = figure()
p.circle('x', 'y', source=source, size=20)
slider = Slider(start=1, end=10, value=1, step=1, title="Multiplier")
callback = CustomJS(args=dict(source=source, slider=slider), code="""
const data = source.data;
const f = slider.value;
const x = data['x'];
const y = data['y'];
for (let i = 0; i < x.length; i++) {
y[i] = y[i] * f;
}
source.change.emit();
""")
slider.js_on_change('value', callback)
layout = column(slider, p)
show(layout)
Linking Multiple Plots
Linking multiple plots to share interactions, such as brushing or selections, provides a cohesive experience. When a user selects data in one plot, it can highlight related data in another. This is done by sharing the same ColumnDataSource among multiple plots:
from bokeh.models import ColumnDataSource
from bokeh.plotting import figure, show, gridplot
source = ColumnDataSource(data=dict(x=[1, 2, 3, 4, 5], y=[6, 7, 2, 4, 5], z=[5, 4, 3, 2, 1]))
# Create two plots sharing the same source
p1 = figure(tools="box_select, lasso_select")
p1.circle('x', 'y', source=source, color="navy", size=10, alpha=0.5)
p2 = figure(tools="box_select, lasso_select")
p2.circle('x', 'z', source=source, color="firebrick", size=10, alpha=0.5)
layout = gridplot([[p1, p2]])
show(layout)
By implementing these techniques, you can create advanced Bokeh visualizations that are not only visually appealing but also interactive and informative. Experiment with different callbacks and linking methods to discover the best ways to convey your data's story.
