5 Best Ways to Manually Add Legend Items in Python Matplotlib

Rate this post

πŸ’‘ Problem Formulation: When using Matplotlib to create visual representations of data, it’s often necessary to annotate plots with legends that are not directly inferred from the plotted data sets. For example, a plot might contain custom annotations or highlights that require manual legend entries. This article addresses how to manually add such legend items in different ways.

Method 1: Using Label and Legend

One common method for adding legend items is to assign labels to plot elements and then invoke the legend() function. This helps in associating custom labels with the plot elements that may not directly correspond with the original data labels or when adding annotations and proxy artists.

Here’s an example:

import matplotlib.pyplot as plt

# Plotting data with labels.
plt.plot([0, 1], [1, 2], label='Line 1')
plt.plot([0, 1], [2, 3], label='Line 2')

# Manually adding an extra legend item.
extra_legend = plt.Line2D([0], [0], label='Extra Line', color='k')


The output is a plot with three legend entries, including the custom ‘Extra Line’.

In this example, two lines are drawn with their respective labels, and an additional custom line is added to the legend without drawing it on the plot. The Line2D object creates a proxy artist for the manual legend item, and the legend() function renders it.

Method 2: Using Proxy Artists

Proxy artists are used when you need to create legend items for plot elements that are not necessarily present in the figure, such as shaded areas or custom annotations. This method provides more control over the appearance of the legend items.

Here’s an example:

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches

# Plotting data without label.
plt.plot([0, 1], [1, 2])

# Creating a red patch as a proxy artist.
red_patch = mpatches.Patch(color='red', label='The red data')



The output showcases a red patch representation in the legend, associated with ‘The red data’ label.

This snippet illustrates the creation of a proxy artist using a patch to represent some data. The mpatches.Patch() function is used to create a legend item with a custom label, which is then passed to the legend() function through the handles parameter.

Method 3: Combining Automatic with Manual Legend Items

To add manual legend items alongside those automatically inferred from the plotted data, it’s possible to retain auto-generated handles and labels, and then extend these lists with custom legend elements.

Here’s an example:

import matplotlib.pyplot as plt

# Plotting data with labels.
plt.plot([0, 1], [1, 2], label='Automatic Label')

# Getting the current handles and labels.
handles, labels = plt.gca().get_legend_handles_labels()

# Adding a manual legend item.
handles.append(plt.Line2D([0], [0], linestyle='--', color='grey'))
labels.append('Manual Label')

plt.legend(handles, labels)

This produces a plot that includes both auto-generated and manual legend items.

In this snippet, the existing handles and labels are obtained from the current plot using get_legend_handles_labels(). The lists are then extended with a manual entry using plt.Line2D(), and the updated legend information is fed back into the legend() function.

Method 4: Modifying Legend Entries After Display

If there’s a need to modify legend entries after displaying them, it’s possible to do so by accessing the legend object directly and updating it with new text or styles. This allows for more dynamic interactivity with the plot legend.

Here’s an example:

import matplotlib.pyplot as plt

# Plotting and creating an original legend.
plt.plot([0, 1], [1, 2], label='Original Label')
legend = plt.legend()

# Accessing the legend text and updating it.
legend.texts[0].set_text('Updated Label')


The resulting plot’s legend will show ‘Updated Label’ instead of ‘Original Label’.

In this case, the legend object is accessed after being created. The label of the first legend entry is accessed through the texts attribute and updated with set_text(). This approach allows for modifying the legend even after it’s been displayed on the figure.

Bonus One-Liner Method 5: Using Legend to Merge Automatic and Manual Entries

When simplicity is key, merging manual legend entries with automatically generated ones can be done within a single call to legend() by combining handles and labels inline.

Here’s an example:

import matplotlib.pyplot as plt

# Automatic plotting.
line, = plt.plot([0, 1], [1, 2])

# Merging automatic and manual legend entries in one line.
plt.legend([line, (plt.Line2D([0], [0], color='k'), 'Manual Entry')])


The plot features both automatically detected and manually specified legend entries.

This code snippet demonstrates a one-liner where a tuple containing a manually created Line2D object and a label are added to the list of automatically detected plot elements when calling legend().


  • Method 1: Using Label and Legend. Easy for basic customization. Might not be suitable for complex legend requirements.
  • Method 2: Using Proxy Artists. Great for representing non-plot elements in legends. Requires additional code for the proxy setup.
  • Method 3: Combining Automatic with Manual Legend Items. Perfect for adding to an existing legend. Needs careful handling of handles and labels.
  • Method 4: Modifying Legend Entries After Display. Offers flexibility for dynamic legend updates. Is not as intuitive and requires post-plot manipulation.
  • Method 5: Bonus One-Liner Method. Quick and straightforward for simple adjustments. May lack clarity and control for more detailed customization.