Question

In Matplotlib:

• I can write matplotlib.pyplot.cla() as axes.clear(), where axes is an matplotlib.axes.Axes object.
• I can write matplotlib.pyplot.clf() as fig.clear(), where fig is a matplotlib.figure.Figure object.

Then there is matplotlib.pyplot.close(). This closes a window. Does this window correspond to any class? Is there a x.close() that is equivalent to matplotlib.pyplot.close() but in a more object oriented style?

The source code for matplotlib.pyplot.close() for my version is as follows:

if len(args)==0:
    figManager = _pylab_helpers.Gcf.get_active()
    if figManager is None: return
    else:
        _pylab_helpers.Gcf.destroy(figManager.num)
elif len(args)==1:
    arg = args[0]
    if arg=='all':
        _pylab_helpers.Gcf.destroy_all()
    elif isinstance(arg, int):
        _pylab_helpers.Gcf.destroy(arg)
    elif is_string_like(arg):
        allLabels = get_figlabels()
        if arg in allLabels:
            num = get_fignums()[allLabels.index(arg)]
            _pylab_helpers.Gcf.destroy(num)
    elif isinstance(arg, Figure):
        _pylab_helpers.Gcf.destroy_fig(arg)
    else:
        raise TypeError('Unrecognized argument type %s to close'%type(arg))
else:
    raise TypeError('close takes 0 or 1 arguments')

So, it appears to be based on the staticmethod
matplotlib._pylab_helpers.Gcf.destroy which does a variety of things I don’t quite follow, noting that In the interactive backends, this is bound to the window “destroy” and “delete” events. But I’m not sure how figures and windows are related.

Perhaps I’m wasting my time even thinking about this.

Answer 1

Gcf is a global singleton object that keeps a list of the figures you have opened with plt.figure.

It is essentially a dictionary with some fancy code around it to keep things consistent and keep track of the active figure, ect. The class that is used as a layer between Figure (which is what is returned by plt.figure) and the GUI layer is FigureManagerBase (and it’s per-toolkit sub-classes) which is defined in backend_bases.py.

Which sub-class you are using is determined by which backend you are using. These sub-classes deal with things like making sure the figure gets deleted when you click the ‘x’ button, and the system level gui call-backs.

FigureManagers have a destroy method which triggers their internal tear down. In principle, if you have a Figure object and want to destroy it by hand, you just need to get a hold of the manager. A reference to it isn’t stored in the Figure object, but is stored in the Canvas object so you can destroy a window via

fig.canvas.manager.destroy()

which will tear the figure down, however if you do this, it might not properly clean up Gcf (which will retains a reference to the figure manager) which will make future figures made with pyplot have unexpected numbers (it won’t go back to one), gca will not work as exected, ect (this is the case with Qt4).

If you are going to use pyplot at all (and be sure it will always work on every backend), then you either need to

1. directly talk to Gcf (it’s in _pyplot_helpers.py and really isn’t too complicated once you see what it is trying to do
2. reach and talk to the GUI directly (see the code in lib/matplotlib/tests/test_backend_qt4.py for how to do with with qt4, but this is going to be very toolkit dependent)
3. plt.close(fig.number)