5 Best Ways to Plot Multiple Lines on the Same Y-Axis in Python with Plotly

by

💡 Problem Formulation: When visualizing data, it’s often necessary to compare different datasets on a single plot. This article will guide the reader through five methods for plotting multiple lines on the same Y-axis using Plotly in Python. For example, the input might be various time-series datasets, and the desired output is a single graph with each dataset represented as a distinct line for effective comparison.

Method 1: Using Plotly Express

Plotly Express is the high-level interface for Plotly, which allows you to create a wide range of types of plots with a simple syntax. This method involves using the plotly.express.line function, which is perfect for quickly plotting multiple lines with shared Y-axes. It offers a tidy API that accepts data in the form of a DataFrame.

Here’s an example:

import plotly.express as px
import pandas as pd

# Sample data
df = pd.DataFrame({
    'Date': ['2021-01-01', '2021-01-02', '2021-01-03'],
    'Dataset1': [3, 2, 4],
    'Dataset2': [1, 3, 5]
})

fig = px.line(df, x='Date', y=df.columns[1:], title='Multiple Lines on Same Y-Axis')
fig.show()

The resulting output is a Plotly figure with two lines representing ‘Dataset1’ and ‘Dataset2’ plotted against ‘Date’ on the X-axis.

This code snippet first crafts a DataFrame with sample data and utilizes Plotly’s Express API to create the line chart. By specifying y=df.columns[1:], it conveniently plots all columns (except for the ‘Date’ column which is used for the X-axis) as separate lines on the same chart.

Method 2: Plotly Graph Objects (GO)

For more customization, Plotly’s Graph Objects (GO) is the way to go. Through plotly.graph_objects, you can create a figure and declare multiple trace objects, each representing a line graph. This method gives you granular control over every aspect of the plot, from line styles to the layout.

Here’s an example:

import plotly.graph_objects as go

# Sample data
x_data = ['2021-01-01', '2021-01-02', '2021-01-03']
y_data1 = [3, 2, 4]
y_data2 = [1, 3, 5]

# Create traces
trace1 = go.Scatter(x=x_data, y=y_data1, mode='lines', name='Dataset1')
trace2 = go.Scatter(x=x_data, y=y_data2, mode='lines', name='Dataset2')

# Pack the traces into a figure
fig = go.Figure(data=[trace1, trace2], layout=go.Layout(title='Multiple Lines on Same Y-Axis'))
fig.show()

The resulting output is a Plotly figure with two distinct lines representing ‘Dataset1’ and ‘Dataset2’.

This code snippet explicitly creates two line traces using the Scatter method and then assembles them into a singular figure object. By customizing each trace separately and using them in a collective figure, this approach provides a deep level of control for each line’s properties, making it suitable for complex visualizations.

Method 3: Adding Traces

For sequential data addition or dynamic plotting scenarios, you can add traces to an existing Plotly figure using fig.add_trace(). This is particularly useful if you want to add lines incrementally or conditionally based on some logic in your code.

Here’s an example:

import plotly.graph_objects as go

# Sample data
x_data = ['2021-01-01', '2021-01-02', '2021-01-03']
y_data1 = [3, 2, 4]
y_data2 = [1, 3, 5]

# Initialize a blank figure
fig = go.Figure()

# Add traces one by one
fig.add_trace(go.Scatter(x=x_data, y=y_data1, mode='lines', name='Dataset1'))
fig.add_trace(go.Scatter(x=x_data, y=y_data2, mode='lines', name='Dataset2'))

fig.update_layout(title='Dynamically Adding Multiple Lines')
fig.show()

The resulting output is a Plotly figure where ‘Dataset1’ and ‘Dataset2’ are added as two separate traces incrementally.

This code snippet demonstrates the flexibility of building a Plotly figure by incrementally adding traces. This method can be beneficial when the number of lines to be plotted isn’t known beforehand or when lines need to be added dynamically as data becomes available.

Method 4: Subplots

When you wish to plot multiple lines each with a distinct Y-axis but sharing the same X-axis, Plotly’s subplots function plotly.subplots.make_subplots can be used. This can illustrate different scales more accurately by providing each line its own Y-axis while remaining aligned on the X-axis.

Here’s an example:

from plotly.subplots import make_subplots

# Sample data and Subplot setup
fig = make_subplots(specs=[[{"secondary_y": True}]])

# Add traces
fig.add_trace(
    go.Scatter(x=x_data, y=y_data1, name="Dataset1"),
    secondary_y=False,
)

fig.add_trace(
    go.Scatter(x=x_data, y=y_data2, name="Dataset2"),
    secondary_y=True,
)

# Set titles and layout
fig.update_layout(title_text="Multiple Lines with Separate Y-Axes")
fig.update_yaxes(title_text="Primary Y-axis", secondary_y=False)
fig.update_yaxes(title_text="Secondary Y-axis", secondary_y=True)

fig.show()

The output is a Plotly figure displaying two lines, each with its own Y-axis aligned on a shared X-axis.

By using subplots from Plotly, this code snippet illustrates how to plot lines that may have different scales by providing separate Y-axes. This approach is most beneficial when comparing datasets with differing magnitudes or units, ensuring a clear and accurate representation in the same plot area.

Bonus One-Liner Method 5: Update Traces

You can also use the update_traces method to conveniently modify all traces in a figure with a one-liner, which can be useful for applying a common change to all lines in a multi-line plot, such as setting the line width or color.

Here’s an example:

fig.update_traces(line=dict(width=2, color='RoyalBlue'))

This one-liner will update the line width and color for all traces in the figure ‘fig’.

This short code piece demonstrates the succinct nature of the update_traces method which allows for universal style adjustments across all lines within a figure without the need for iteratively specifying each trace.

Summary/Discussion

  • Method 1: Plotly Express. Strengths: It’s beginner-friendly and provides a succinct syntax for quick plotting. Weaknesses: It offers less customizability compared to GO.
  • Method 2: Plotly Graph Objects. Strengths: It offers deep customization for each line plotted. Weaknesses: The setup is more verbose and may become complex for beginners.
  • Method 3: Adding Traces. Strengths: It allows for dynamic and incremental plotting of lines. Weaknesses: The plot needs to be built up step-by-step which can be less efficient.
  • Method 4: Subplots. Strengths: Useful for comparing lines on different scales with their own Y-axes. Weaknesses: Requires thoughtful layout management to avoid clutter.
  • Method 5: Update Traces. Strengths: Allows for quick and universal changes to style attributes. Weaknesses: Limited to styling that can be applied uniformly across traces.