Tutorial on Matplotlib Arrows in Python

Arrows in Matplotlib are versatile for highlighting data points, showing trends, or adding directional cues in a plot.

Matplotlib provides several functions to draw arrows, including plt.arrow(), plt.annotate(), and FancyArrowPatch.

In this tutorial, we’ll cover various methods to create and customize arrows in Python using Matplotlib.

1. Basic Arrow with plt.arrow()

The plt.arrow() function draws an arrow from a starting point (x, y) to a specified direction (dx, dy).

import matplotlib.pyplot as plt

# Basic plot
plt.plot([0, 5], [0, 10], color='gray')  # Line for reference

# Draw an arrow from (0, 0) to (3, 6)
plt.arrow(0, 0, 3, 6, head_width=0.5, head_length=0.5, fc='blue', ec='blue')

plt.xlim(-1, 5)
plt.ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Basic Arrow with plt.arrow()")
plt.show()

In plt.arrow(x, y, dx, dy, …):

• (x, y): Starting coordinates.
• (dx, dy): Length of the arrow in x and y directions.
• head_width and head_length: Size of the arrowhead.
• fc and ec: Face color and edge color of the arrow.

2. Annotating Points with Arrows Using plt.annotate()

plt.annotate() is a versatile function that combines text with arrows, allowing you to label specific points on a plot.

# Basic plot
plt.plot([0, 5], [0, 10], color='gray')

# Annotate a specific point with an arrow
plt.annotate('Important Point', xy=(3, 6), xytext=(1, 8),
             arrowprops=dict(facecolor='red', shrink=0.05))

plt.xlim(-1, 5)
plt.ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Arrow with Annotation")
plt.show()

In plt.annotate(), the parameters are:

• xy: Coordinates of the point you want to annotate.
• xytext: Position of the annotation text.
• arrowprops: A dictionary to style the arrow (e.g., facecolor, shrink).

3. Arrow Styles in plt.annotate()

You can change the arrow style with arrowstyle in the arrowprops dictionary. Some styles include ->, -[, |-|, and fancy.

# Basic plot
plt.plot([0, 5], [0, 10], color='gray')

# Draw arrows with different styles
plt.annotate('Simple Arrow', xy=(1, 2), xytext=(0.5, 6),
             arrowprops=dict(facecolor='blue', arrowstyle='->'))
plt.annotate('Fancy Arrow', xy=(3, 6), xytext=(4, 8),
             arrowprops=dict(facecolor='green', arrowstyle='fancy'))
plt.annotate('Double-headed Arrow', xy=(2, 4), xytext=(4, 2),
             arrowprops=dict(facecolor='purple', arrowstyle='<->'))

plt.xlim(-1, 5)
plt.ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Different Arrow Styles in Annotations")
plt.show()

4. Curved Arrows with plt.annotate()

To make arrows curve, you can use connectionstyle in arrowprops.

# Basic plot
plt.plot([0, 5], [0, 10], color='gray')

# Curved arrow
plt.annotate('Curved Arrow', xy=(3, 6), xytext=(1, 8),
             arrowprops=dict(facecolor='red', arrowstyle='->', connectionstyle='arc3,rad=.5'))

plt.xlim(-1, 5)
plt.ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Curved Arrow")
plt.show()

In connectionstyle, the parameter arc3,rad=.5 specifies an arc connection with a specified curvature (rad).

5. Multiple Arrows with a Loop

If you need to add multiple arrows, you can use a loop for efficiency.

# Define points for arrows
points = [(1, 2), (2, 4), (3, 6), (4, 8)]

# Basic plot
plt.plot([0, 5], [0, 10], color='gray')

# Draw arrows from origin to each point
for x, y in points:
    plt.arrow(0, 0, x, y, head_width=0.2, head_length=0.2, fc='orange', ec='orange')

plt.xlim(-1, 5)
plt.ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Multiple Arrows with a Loop")
plt.show()

6. Using FancyArrowPatch for Advanced Arrows

The FancyArrowPatch class in Matplotlib allows for more customization and advanced arrow designs. This method is particularly useful for arrows with specific colors, angles, or shapes.

from matplotlib.patches import FancyArrowPatch

# Create a plot
fig, ax = plt.subplots()

# Basic line for reference
ax.plot([0, 5], [0, 10], color='gray')

# Create a FancyArrowPatch from (0,0) to (3,6)
arrow = FancyArrowPatch((0, 0), (3, 6), color='blue', linewidth=2, arrowstyle='->', mutation_scale=20)
ax.add_patch(arrow)

ax.set_xlim(-1, 5)
ax.set_ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Arrow with FancyArrowPatch")
plt.show()

In FancyArrowPatch:

• mutation_scale controls the size of the arrowhead.
• arrowstyle can be adjusted just like in plt.annotate().

7. Arrow Transparency (Alpha) and Line Styles

You can add transparency to arrows using the alpha parameter and apply line styles to make arrows dashed, dotted, etc.

# Create a plot
plt.plot([0, 5], [0, 10], color='gray')

# Draw arrows with transparency and line style
plt.arrow(0, 0, 3, 6, head_width=0.3, head_length=0.3, fc='green', ec='green', alpha=0.6, linestyle='--')
plt.arrow(0, 0, 4, 8, head_width=0.3, head_length=0.3, fc='purple', ec='purple', alpha=0.4, linestyle=':')

plt.xlim(-1, 5)
plt.ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Arrows with Transparency and Line Styles")
plt.show()

8. Combining Arrows with Different Colors and Line Widths

Arrows can be customized with specific colors and line widths to make certain arrows stand out.

# Create a plot
plt.plot([0, 5], [0, 10], color='gray')

# Draw arrows with custom colors and widths
plt.arrow(0, 0, 2, 4, head_width=0.2, head_length=0.2, fc='blue', ec='blue', linewidth=2)
plt.arrow(0, 0, 3, 5, head_width=0.2, head_length=0.2, fc='red', ec='red', linewidth=3)

plt.xlim(-1, 5)
plt.ylim(-1, 10)
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Arrows with Different Colors and Widths")
plt.show()

9. Arrow Coordinates Transformation

You can place arrows in specific parts of the figure rather than based on data coordinates by using the transform parameter.

# Create a plot
plt.plot([0, 5], [0, 10], color='gray')

# Draw an arrow from figure coordinates (0.1, 0.9) to (0.5, 0.5)
plt.annotate('', xy=(0.5, 0.5), xytext=(0.1, 0.9),
             arrowprops=dict(facecolor='blue', edgecolor='black', arrowstyle='->'),
             xycoords='figure fraction', textcoords='figure fraction')

plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.title("Arrow with Coordinate Transformation")
plt.show()

In this example:

• xycoords and textcoords are set to ‘figure fraction' to use figure coordinates (0 to 1 range in both x and y).

Summary

In this tutorial, we covered:

• Basic arrows with plt.arrow().
• Annotating points with arrows using plt.annotate().
• Customizing arrow styles and curving arrows.
• Drawing multiple arrows with loops.
• Using FancyArrowPatch for advanced arrows.
• Adding transparency, line styles, and transformations to arrows.