Implementing Multiple Y-Axes with Different Scales in Matplotlib

Introduction

In the field of data visualization, there is often a need to display multiple variables with different dimensions and scales in the same chart. Matplotlib, as the most popular plotting library in the Python ecosystem, provides multiple methods for implementing multiple Y-axes with different scales. This paper delves into these technical solutions, focusing on advanced implementations based on the axes_grid1 module.

Core Concepts and Technical Background

The essence of multiple Y-axis plotting is creating multiple independent coordinate systems within the same chart area, each with its own scales and labels. Matplotlib achieves this through the twinx() method, which creates new axes that share the X-axis with the primary axes but have independent Y-axes.

Implementation Based on axes_grid1 Module

This is the officially recommended solution for multiple Y-axes in Matplotlib, providing finer control and better layout management. Below is the complete implementation code:

from mpl_toolkits.axes_grid1 import host_subplot
import mpl_toolkits.axisartist as AA
import matplotlib.pyplot as plt

# Create primary axes
host = host_subplot(111, axes_class=AA.Axes)
plt.subplots_adjust(right=0.75)

# Create two parasite axes
par1 = host.twinx()
par2 = host.twinx()

# Set position offset for the second parasite axis
offset = 60
new_fixed_axis = par2.get_grid_helper().new_fixed_axis
par2.axis["right"] = new_fixed_axis(loc="right", axes=par2, offset=(offset, 0))
par2.axis["right"].toggle(all=True)

# Set display ranges for each axis
host.set_xlim(0, 2)
host.set_ylim(0, 2)
par1.set_ylim(0, 4)
par2.set_ylim(1, 65)

# Set axis labels
host.set_xlabel("Distance")
host.set_ylabel("Density")
par1.set_ylabel("Temperature")
par2.set_ylabel("Velocity")

# Plot three trend lines
p1, = host.plot([0, 1, 2], [0, 1, 2], label="Density")
p2, = par1.plot([0, 1, 2], [0, 3, 2], label="Temperature")
p3, = par2.plot([0, 1, 2], [50, 30, 15], label="Velocity")

# Add legend
host.legend()

# Set label colors to match corresponding line colors
host.axis["left"].label.set_color(p1.get_color())
par1.axis["right"].label.set_color(p2.get_color())
par2.axis["right"].label.set_color(p3.get_color())

plt.draw()
plt.show()

Code Analysis and Key Technical Points

The core of the above code lies in the concepts of host_subplot and parasite axes. host_subplot creates the primary axis container, while the twinx() method creates parasite axes that share the X-axis but have independent Y-axis systems.

The position offset mechanism is implemented through new_fixed_axis, ensuring that multiple Y-axes do not overlap horizontally. The offset value offset=60 can be adjusted based on actual chart dimensions, typically measured in points.

The color synchronization technique ensures that axis label colors match the corresponding data line colors. This is achieved by using the get_color() method to obtain line colors and applying them to labels, enhancing chart readability.

Alternative Solutions Comparison

In addition to the advanced solution based on axes_grid1, Matplotlib provides other implementation approaches:

Basic twinx Implementation

Using the standard twinx() method, the code is more concise but offers limited control:

import matplotlib.pyplot as plt

fig, host = plt.subplots(figsize=(8,5))
ax2 = host.twinx()
ax3 = host.twinx()

# Set axis ranges and labels
host.set_xlim(0, 2)
host.set_ylim(0, 2)
ax2.set_ylim(0, 4)
ax3.set_ylim(1, 65)

# Adjust position of third Y-axis
ax3.spines['right'].set_position(('outward', 60))

Pandas Simplified Solution

For rapid prototyping, Pandas provides a more concise API:

import pandas as pd

# Assuming df is a DataFrame containing multiple columns of data
df.A.plot(label="Points", legend=True)
df.B.plot(secondary_y=True, label="Comments", legend=True)

Best Practices and Considerations

When choosing a multiple Y-axis implementation solution, the following factors should be considered:

Layout management is a key challenge. As the number of Y-axes increases, appropriate offset values must be set to avoid label overlap. It is recommended to use plt.subplots_adjust() to adjust chart margins.

The color coding system should remain consistent. Each Y-axis and its corresponding data lines should use the same color to help readers establish visual associations.

For complex data visualization requirements, the axes_grid1 solution provides the most comprehensive control capabilities, including precise axis positioning, custom scales, and advanced layout options.

Conclusion

Matplotlib supports data visualization with multiple Y-axes of different scales through various technical pathways. The implementation based on the axes_grid1 module offers the most complete control capabilities, suitable for complex scientific visualization needs. The basic twinx solution is appropriate for simple dual Y-axis scenarios, while the Pandas wrapper provides convenience for rapid exploratory data analysis. Developers should choose appropriate technical solutions based on specific requirements, balancing functional completeness and implementation complexity.