Object-oriented Interface

Matplotlib - The Object-Oriented Interface

While the matplotlib.pyplot interface provides a quick way to generate plots, the Object-Oriented (OO) API offers a more robust, explicit, and flexible approach. It is the recommended method for creating complex plots, writing reusable plotting functions, embedding plots in applications, and generally for any non-trivial visualization task.

Core Idea: Figures and Axes

The OO approach revolves around explicitly creating and manipulating two fundamental objects:

• Figure: The top-level container for everything. Think of it as the overall window or canvas.
• Axes: The individual plot(s) within the Figure. This is where the data is actually plotted, and it contains the axes lines, ticks, labels, title, etc.

Instead of calling global pyplot functions that act on an implicit current figure/axes, you call methods directly on the specific Figure and Axes objects you want to modify.

Getting Started: plt.subplots()

The most common way to start with the OO interface is using plt.subplots(). This function conveniently creates both a Figure object and one or more Axes objects at the same time.

import matplotlib.pyplot as plt
import numpy as np

# Create a Figure and a single Axes object
fig, ax = plt.subplots()

# Create a Figure and a 2x1 grid of Axes objects
# 'axs' will be a NumPy array containing the two Axes objects
fig_multi, axs = plt.subplots(nrows=2, ncols=1)

Once you have the Axes object(s) (e.g., ax or axs[0]), you use their methods for plotting and customization.

Example: Simple Plot with OO Interface

import matplotlib.pyplot as plt
import numpy as np

# Data
x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

# 1. Create Figure and Axes
fig, ax = plt.subplots(figsize=(8, 5)) # Control figure size here

# 2. Plot data on the specific Axes object ('ax')
ax.plot(x, y, label='sin(x)', color='purple')

# 3. Customize the plot using Axes methods
ax.set_title("Sine Wave (Object-Oriented)", fontsize=16)
ax.set_xlabel("Angle [radians]", fontsize=12)
ax.set_ylabel("Sine Value", fontsize=12)
ax.set_xlim(0, 2 * np.pi)
ax.set_ylim(-1.2, 1.2)
ax.grid(True)
ax.legend()

# 4. Display the figure (using pyplot)
plt.show()

Notice how plot, set_title, set_xlabel, set_ylabel, grid, legend, etc., are all called as methods of the ax object, making it clear which plot is being modified.

Why Use the OO Interface?

• Clarity: Explicitly targets which Figure/Axes you are working on, avoiding confusion with implicit state.
• Control: Offers finer-grained control over all plot elements.
• Flexibility: Easily manage multiple figures and complex subplot layouts.
• Reusability: Easier to write functions that create or modify plots, as you can pass Figure/Axes objects as arguments.
• Embedding: Essential when embedding Matplotlib plots in GUI applications or web frameworks.

While pyplot is fine for quick, interactive exploration, adopting the object-oriented API is highly recommended for developing more structured and maintainable plotting code.

(Note: You might still use plt.figure() to create an empty Figure and then add Axes manually using fig.add_subplot() or fig.add_axes(), but plt.subplots() is often more direct for common layouts.)