5 Best Ways to Add a Black Border to a Matplotlib 2.0 Ax Object in Python 3

by

💡 Problem Formulation: When creating visualizations with Matplotlib in Python, you might find yourself needing to highlight a particular subplot or Axes object with a border. In this article, we’ll explore how to add a distinctive black border to a matplotlib 2.0 Axes (ax) object to enhance the visual appeal and clarity of your plots. The desired output is an Axes object with a clearly defined black border, making it stand out in the figure.

Method 1: Using Spines

Spines are the lines connecting the axis tick marks and noting the boundaries of the data area. By default, a Matplotlib Axes object has four spines. This method involves setting the color and linewidth of the spines to create a black border around the Axes object.

Here’s an example:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
for spine in ax.spines.values():
    spine.set_edgecolor('black')
    spine.set_linewidth(2)

plt.show()

The output of this code is a single Axes object, contained within a Figure, displaying a thicker, black border around the edge.

This approach modifies the existing spines of an Axes object to create a simple black border by changing their color and width. It’s both straightforward and customizable, allowing for adjustments to the appearance of the border.

Method 2: Changing the Patch Object

The Patch object of an Axes represents the background. We can add a border to this background by adjusting its edge properties. This method creates the effect of a border by changing the edge color of the entire background patch.

Here’s an example:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.patch.set_edgecolor('black')
ax.patch.set_linewidth(2)

plt.show()

The output is a plot with a black border around the subplot area, giving the appearance of a frame due to the modified background patch.

In this method, we’re not changing the spines directly but rather the patch that lies behind the plot area. While less conventional, it achieves a similar effect and may be simpler in some cases.

Method 3: Creating a Custom Rectangle

This method involves manually creating a rectangle with desired border properties and adding it to the Axes object. This gives you maximum control over the border’s appearance and position.

Here’s an example:

import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle

fig, ax = plt.subplots()
rect = Rectangle((0, 0), 1, 1, transform=ax.transAxes, edgecolor='black', facecolor='none', lw=2)
ax.add_patch(rect)

plt.show()

The result is a visualization enclosed by a custom black rectangle which overlays the axes area.

The custom rectangle method is very powerful and flexible but may require more work to ensure the coordinates and transformation are set correctly for the desired visual effect.

Method 4: Using AxesGrid Toolkit

The AxesGrid toolkit provides a grid of Axes with a common colorbar. It includes features to adjust the appearance of the borders of the Axes. This approach is useful when working with multiple subplots and needing consistent formatting.

Here’s an example:

from mpl_toolkits.axes_grid1 import ImageGrid
import matplotlib.pyplot as plt

fig = plt.figure(figsize=(4, 4))
grid = ImageGrid(fig, 111, nrows_ncols=(1, 1), axes_pad=0.05, add_all=True)
for ax in grid:
    for spine in ax.spines.values():
        spine.set_edgecolor('black')
        spine.set_linewidth(2)

plt.show()

The resulting output displays a grid of subplots where each Axes object within that grid has a black border.

While convenient for managing subplots, this method requires more familiarization with the AxesGrid toolkit, which may not be necessary for simple plotting tasks.

Bonus One-Liner Method 5: Using the subplots_adjust Function with Spines

An efficient one-liner for adding a black border to an Axes object combines subplots_adjust with spine adjustments to create a simplified code snippet.

Here’s an example:

plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1)
_ = [spine.set_edgecolor('black') for spine in plt.gca().spines.values()]

The output is an Axes object with a black border, adjusted margins for aesthetic spacing.

This one-liner is compact and easy to use, but it sacrifices some readability and may confuse beginners unfamiliar with list comprehensions and the plt.gca() function.

Summary/Discussion

  • Method 1: Using Spines. Direct manipulation of spines. Strengths: Precise control over appearance. Weaknesses: Multiple lines of code required.
  • Method 2: Changing the Patch Object. Adjusting the patch properties. Strengths: Simpler approach for some use cases. Weaknesses: May not be intuitive.
  • Method 3: Creating a Custom Rectangle. Maximum customization with a manual approach. Strengths: High flexibility and control. Weaknesses: Requires deeper understanding of Matplotlib objects.
  • Method 4: Using AxesGrid Toolkit. Useful for complex layouts with multiple axes. Strengths: Consistent styling. Weaknesses: Learning curve for the toolkit.
  • Bonus One-Liner Method 5: Quick and compact. Strengths: Efficient. Weaknesses: Less clarity and potential spacing issues.