Find all objects in figure of a certain type

Save multiple plots in one pdf file

A simpler way is to call

`axes_demo.py <http://matplotlib.sf.net/examples/axes_demo.py>`_ for

an example of placing axes manually.

In most use cases, it is enough to simpy change the subplots adjust

Here is that gets a bounding box in relative figure coordinates (0..1)

of each of the labels and uses it to move the left of the subplots

evenly sampled indicies, and then use a custom formatter to format

are trying to interactively pan and zoom, since both scales do not get

The approach :func:`~matplotlib.pyplot.twinx` (and its sister

:func:`~matplotlib.pyplot.twiny`) uses is to use *2 different axes*,

locators as desired since the two axes are independent::

your figure generating script, just place call

The user interface backends need to start the GUI mainloop, and this

is what :func:`~matplotlib.pyplot.show` does. It tells matplotlib to

raise all of the figure windows and start the mainloop. Because the

mainloop is blocking, you should only call this once per script, at

the end. If you are using matplotlib to generate images only and do

not want a user interface window, you do not need to call ``show`` (see

:ref:`howto-batch` and :ref:`what-is-a-backend`).

Because it is expensive to draw, matplotlib does not want to redrawing the figure

many times in a script such as the following::

It is *possible* to force matplotlib to draw after every command,

which is what you usually want when working interactively at the

defer all drawing until the script has executed. This is especially

:func:`~matplotlib.pyplot.show` should be called at most once per

script and it should be the last line of your script. At that

point, the GUI takes control of the interpreter. If you want to

force a figure draw, use :func:`~matplotlib.pyplot.draw` instead.

Many users are frustrated by show because they want it to be a

blocking call that raises the figure, pauses the script until the

figure is closed, and then allows the script to continue running until

though we have made some progress towards supporting blocking events.

verbal description of what to look for. The original developer may

documentation we have only scratches the surface of everything it can

who write most of the documentation. Just pulled your hair out

`ReST <http://docutils.sourceforge.net/rst.html>`_. sphinx is a

document or any page on this site by clicking on *Show Source* link

Alternatively, you can avoid pylab/pyplot altogeher, which will give

`agg_oo.py <http://matplotlib.sf.net/examples/api/agg_oo.py>`_ .

Here is an example using the Python Imaging Library PIL. First the figure is saved to a StringIO objectm which is then fed to PIL for further processing::

outputs, and each of these capabililities is called a backend; the

"backend" does all the dirty work behind the scenes to make the

the ``backend`` parameter in you ``matplotlibrc`` file (see

If you are unsure what to do, and just want to get cranking, just set

your backend to ``TkAgg``. This will do the right thing for 95% of the

generate a pixel represenation of the line whose accuracy depends on a

:file:`pygobject.h` to add the :cmacro:`G_BEGIN_DECLS` and :cmacro:`G_END_DECLS`

macros, and rename :cdata:`typename` parameter to :cdata:`typename_`::

file:`/Library/Python/2.5/site-packages/`, again depedending on your

can test your installation with::

You can also us the eggs we build for OSX (see the `installation

the disk. Many Mac OS X eggs with cruft at the end of the filename,