Complete Implementation of Shared Legends for Multiple Subplots in Matplotlib

Introduction

In data visualization practice, multi-subplot layouts are commonly used techniques for displaying multidimensional data. When multiple subplots contain the same types of lines or markers, setting individual legends for each subplot creates visual redundancy and information repetition. Matplotlib, as a powerful plotting library in the Python ecosystem, provides flexible legend management mechanisms to address this issue.

Core Function Analysis

get_legend_handles_labels() is a key function in Matplotlib for handling legends. This function returns two lists: handles containing references to all graphical elements, and labels containing the corresponding text labels. In the Axes interface, you can directly call ax.get_legend_handles_labels(); in the pyplot interface, you need to use plt.gca().get_legend_handles_labels() to obtain information from the current axes.

Basic Implementation Method

The simplest shared legend implementation involves three fundamental steps: first, use the label parameter to clearly identify graphical elements during creation; second, collect legend information from all subplots using get_legend_handles_labels(); finally, create a unified legend at the figure level using fig.legend().

import matplotlib.pyplot as plt
import numpy as np

# Create 3x3 subplot grid
fig, axes = plt.subplots(3, 3, figsize=(10, 8))

# Add same type of lines to each subplot
for i, ax in enumerate(axes.flat):
    x = np.linspace(0, 2*np.pi, 100)
    ax.plot(x, np.sin(x), label='Sine Curve')
    ax.plot(x, np.cos(x), label='Cosine Curve')
    ax.set_title(f'Subplot {i+1}')

# Collect all legend information and create shared legend
handles, labels = axes[0, 0].get_legend_handles_labels()
fig.legend(handles, labels, loc='upper center', ncol=2)

plt.tight_layout()
plt.show()

Advanced Application Techniques

For more complex scenarios, it's necessary to collect legend information from all subplots. This can be achieved by iterating through fig.axes:

# Collect legend information from all axes
all_handles = []
all_labels = []

for ax in fig.axes:
    handles, labels = ax.get_legend_handles_labels()
    all_handles.extend(handles)
    all_labels.extend(labels)

# Deduplication processing (avoid duplicate labels)
unique_handles, unique_labels = [], []
seen_labels = set()

for handle, label in zip(all_handles, all_labels):
    if label not in seen_labels:
        unique_handles.append(handle)
        unique_labels.append(label)
        seen_labels.add(label)

fig.legend(unique_handles, unique_labels, loc='lower center')

Legend Positioning and Style Customization

fig.legend() supports various position parameters, including predefined positions like 'upper center', 'lower left', etc., as well as relative coordinate positioning. More precise positioning control can be achieved through the bbox_to_anchor parameter:

# Use relative coordinates for precise positioning
fig.legend(handles, labels, 
           loc='center',
           bbox_to_anchor=(0.5, 0),
           ncol=3,
           frameon=True,
           shadow=True,
           fancybox=True)

Comparison with Other Visualization Libraries

Compared to modern visualization libraries like Plotly, Matplotlib provides finer-grained control in legend management. Plotly currently lacks support for independent legends per subplot, requiring users to perform complex manual configurations using legendgroup and showlegend parameters. This limitation is particularly evident in business scenarios requiring precise control over legend display.

Best Practice Recommendations

In practical applications, it's recommended to follow these principles: ensure all relevant graphical elements have clear label attributes set; perform appropriate deduplication after collecting legend information; choose legend positions reasonably based on the figure layout; consider using tight_layout() or constrained_layout to automatically adjust spacing between graphical elements.

Common Issue Resolution

When encountering abnormal legend display, first check if the label parameter is correctly set, and confirm that the data structure returned by get_legend_handles_labels() meets expectations. For complex subplot layouts, it may be necessary to adjust the bbox_to_anchor parameter to optimize legend positioning.

Conclusion

By properly utilizing Matplotlib's legend management mechanisms, unified legend display can be effectively achieved in multi-subplot environments. This approach not only enhances the aesthetic quality of graphics but, more importantly, improves data readability and comparability, providing powerful visualization support for scientific research and data analysis.