技术问询：plt.show()的显示原理与Python/matplotlib核心机制解析

Great question—this gets to the heart of how many Python libraries use state management to keep code concise, without forcing you to pass objects around everywhere. Let’s break this down from a general programming perspective, using your scatter plot example:

Step 1: Importing pyplot sets up a global context #

When you run import matplotlib.pyplot as plt, Python loads the pyplot module, which initializes a hidden set of global variables and structures. Think of this as a "shared notebook" that tracks all your plotting work behind the scenes—what figures you’ve created, which axes are active, and what data has been added.

Step 2: plt.scatter(a,b) updates the global state #

Calling plt.scatter(a,b) isn’t just drawing points randomly:

• First, it checks if there’s an active Axes (the actual plotting area inside a figure) in the global context. If none exists, it automatically creates a new Figure (the entire canvas) and an Axes pair.
• It then adds your scatter data (a and b) to that active Axes, updating the global state to include this new plot element.
• You don’t have to explicitly pass around the Figure/Axes objects—matplotlib handles tracking them in its internal state stack.

Step 3: plt.show() reads the global state to render #

When you call plt.show(), it doesn’t need you to specify what to display because:

• It looks into matplotlib’s global context and collects all Figure objects that have been created (either automatically by pyplot functions or manually by you).
• It renders each of these Figures, including all the data (like your scatter points) that was added to their Axes.
• If you only made one figure (as in your example), it shows that single plot. If you created multiple figures (e.g., by calling plt.figure() multiple times), plt.show() will display all of them.

From Python’s interpreter perspective #

Python processes your code line by line:

1. The import statement binds the pyplot module to the plt name in your current namespace.
2. The plt.scatter(a,b) call resolves to the function in the pyplot module, which modifies the module’s internal global variables (tracking active figures and axes).
3. The plt.show() call resolves to another pyplot function, which reads those same global variables to fetch the figures to render.

A quick contrast to clarify the pattern #

If you use matplotlib’s object-oriented interface (more explicit, less reliant on global state), your code would look like this:

import matplotlib.pyplot as plt
fig, ax = plt.subplots()  # Explicitly create Figure and Axes objects
ax.scatter(a, b)          # Directly add data to the specific Axes
fig.show()                # Call show() on the specific Figure

Here, fig.show() knows exactly what to display because you’re calling it directly on the Figure object that holds your data. The pyplot interface (your original code) just hides this object passing by using a global state, making the code shorter for simple plots.

内容的提问来源于stack exchange，提问作者Danii-Sh