I want to add a vertical line at a specific data coordinate in my Matplotlib plot, with arrowheads at the ends (optional: upward arrow pointing to the top of the plot, downward arrow pointing to the bottom, or both). For example, the code:

fig, ax = plt.subplots()
ax.plot([1,2,3])
ax.axvline(1.5, arrow_head=[True,False])

should generate a vertical line with an arrowhead at the bottom (downward arrow) and no arrowhead at the top.

I found that this can't be directly achieved with axvline(), but I can mostly meet the requirement using ax.arrow() and Blended Transformation (data coordinates for the x-axis, axis coordinates for the y-axis). Here's my code:

import matplotlib.pyplot as plt
import matplotlib.transforms as transforms
fig, ax = plt.subplots()
ax.plot([1,2,3],[1,4,9])
mytrans = transforms.blended_transform_factory(ax.transData, ax.transAxes)
ax.arrow(2.5,0,0,1,transform=mytrans,head_width=0.1,length_includes_head=True)

My questions are:

• Is there a simpler/more concise way to implement this?
• How can I achieve a double-headed arrow using this approach?

Awesome question! Let's tackle both parts for you.

1. A Cleaner, Reusable Solution #

Your blended transformation approach is spot-on, but wrapping this logic into a custom function will make your code far more concise and reusable. No more repeating the transformation setup every time you need an arrowed vertical line!

Here's a streamlined function that lets you toggle arrow directions, set the x-position, and customize arrow properties with ease:

import matplotlib.pyplot as plt
import matplotlib.transforms as transforms

def axvline_with_arrows(ax, x, arrow_up=True, arrow_down=True, **arrow_kwargs):
    # Create the blended transform (x uses data coords, y uses axis coords)
    trans = transforms.blended_transform_factory(ax.transData, ax.transAxes)
    
    # Set default arrow styles (override with your own if needed)
    default_style = {
        'head_width': 0.05,
        'length_includes_head': True,
        'color': 'black',
        'linewidth': 1.5
    }
    default_style.update(arrow_kwargs)
    
    # Draw upward arrow (from bottom to plot top) if enabled
    if arrow_up:
        ax.arrow(x, 0, 0, 1, transform=trans, **default_style)
    # Draw downward arrow (from plot top to bottom) if enabled
    if arrow_down:
        ax.arrow(x, 1, 0, -1, transform=trans, **default_style)

# Example usage
fig, ax = plt.subplots()
ax.plot([1,2,3],[1,4,9])

# Single downward arrow (bottom-only arrowhead)
axvline_with_arrows(ax, 1.5, arrow_up=False)
# Double-headed arrow with custom styling
axvline_with_arrows(ax, 2.5, arrow_up=True, arrow_down=True, head_width=0.1, color='darkred')
plt.show()

This function encapsulates all the messy transformation logic, so you just call it with your desired parameters. You can pass any additional ax.arrow() arguments (like linestyle, alpha, etc.) to tweak the look further.

2. Creating Double-Headed Arrows #

As you can see in the example above, a double-headed vertical arrow is as simple as enabling both arrow_up=True and arrow_down=True. This draws two separate arrows: one pointing up from the bottom of the plot to the top, and another pointing down from the top to the bottom.

If you want to avoid drawing two distinct arrows, you could also use ax.annotate() with a custom arrow patch, but the double-arrow method is more straightforward and gives you granular control over each arrowhead's appearance.

One key detail to keep in mind: using length_includes_head=True ensures the arrowhead is counted as part of the line's length, so the line extends exactly to the plot edges without overshooting.

内容的提问来源于stack exchange，提问作者James