Menu
▾
▴
[r8871]: / trunk / htdocs / matplotlib.pyplot.html.template Maximize Restore History
5074 lines (5071 with data), 753.1 kB
@header@
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="heading">
<tr bgcolor="#7799ee">
<td valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"> <br><big><big><strong><a href="matplotlib.html"><font color="#ffffff">matplotlib</font></a>.pyplot</strong></big></big></font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/home/jdhunter/dev/lib64/python2.5/site-packages/matplotlib/pyplot.py">/home/jdhunter/dev/lib64/python2.5/site-packages/matplotlib/pyplot.py</a></font></td></tr></table>
<p></p>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#aa55cc">
<td colspan=3 valign=bottom> <br>
<font color="#fffff" face="helvetica, arial"><big><strong>Modules</strong></big></font></td></tr>
<tr><td bgcolor="#aa55cc"><tt> </tt></td><td> </td>
<td width="100%"><table width="100%" summary="list"><tr><td width="25%" valign=top><a href="matplotlib._pylab_helpers.html">matplotlib._pylab_helpers</a><br>
<a href="matplotlib.cm.html">matplotlib.cm</a><br>
</td><td width="25%" valign=top><a href="matplotlib.html">matplotlib</a><br>
<a href="matplotlib.mlab.html">matplotlib.mlab</a><br>
</td><td width="25%" valign=top><a href="sys.html">sys</a><br>
</td><td width="25%" valign=top></td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#eeaa77">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Functions</strong></big></font></td></tr>
<tr><td bgcolor="#eeaa77"><tt> </tt></td><td> </td>
<td width="100%"><dl><dt><a name="-acorr"><strong>acorr</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-acorr">acorr</a>(x, normed=False, detrend=mlab.detrend_none, usevlines=False,<br>
maxlags=None, **kwargs)<br>
<br>
Plot the autocorrelation of *x*. If *normed* = *True*,<br>
normalize the data but the autocorrelation at 0-th lag. *x* is<br>
detrended by the *detrend* callable (default no normalization).<br>
<br>
Data are plotted as ``<a href="#-plot">plot</a>(lags, c, **kwargs)``<br>
<br>
Return value is a tuple (*lags*, *c*, *line*) where:<br>
<br>
- *lags* are a length 2*maxlags+1 lag vector<br>
<br>
- *c* is the 2*maxlags+1 auto correlation vector<br>
<br>
- *line* is a :class:`~matplotlib.lines.Line2D` instance<br>
returned by :meth:`plot`<br>
<br>
The default *linestyle* is None and the default *marker* is<br>
``'o'``, though these can be overridden with keyword args.<br>
The cross correlation is performed with :func:`numpy.correlate` with<br>
*mode* = 2.<br>
<br>
If *usevlines* is *True*, :meth:`~matplotlib.axes.Axes.vlines`<br>
rather than :meth:`~matplotlib.axes.Axes.plot` is used to draw<br>
vertical lines from the origin to the acorr. Otherwise, the<br>
plot style is determined by the kwargs, which are<br>
:class:`~matplotlib.lines.Line2D` properties. The return<br>
value is a tuple (*lags*, *c*, *linecol*, *b*) where<br>
<br>
- *linecol* is the<br>
:class:`~matplotlib.collections.LineCollection`<br>
<br>
- *b* is the *x*-axis.<br>
<br>
*maxlags* is a positive integer detailing the number of lags<br>
to show. The default value of *None* will return all<br>
``(2*len(x)-1)`` lags.<br>
<br>
See the respective :meth:`~matplotlib.axes.Axes.plot` or<br>
:meth:`~matplotlib.axes.Axes.vlines` functions for<br>
documentation on valid kwargs.<br>
<br>
**Example:**<br>
<br>
:func:`~matplotlib.pyplot.xcorr` above, and<br>
:func:`~matplotlib.pyplot.acorr` below.<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/xcorr_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-annotate"><strong>annotate</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-annotate">annotate</a>(s, xy, xytext=None, xycoords='data',<br>
textcoords='data', arrowprops=None, **kwargs)<br>
<br>
Keyword arguments:<br>
<br>
Annotate the *x*, *y* point *xy* with text *s* at *x*, *y*<br>
location *xytext*. (If *xytext* = *None*, defaults to *xy*,<br>
and if *textcoords* = *None*, defaults to *xycoords*).<br>
<br>
*arrowprops*, if not *None*, is a dictionary of line properties<br>
(see :class:`matplotlib.lines.Line2D`) for the arrow that connects<br>
annotation to the point. Valid keys are<br>
<br>
========= ===========================================================<br>
Key Description<br>
========= ===========================================================<br>
width the width of the arrow in points<br>
frac the fraction of the arrow length occupied by the head<br>
headwidth the width of the base of the arrow head in points<br>
shrink oftentimes it is convenient to have the arrowtip<br>
and base a bit away from the text and point being<br>
annotated. If *d* is the distance between the text and<br>
annotated point, shrink will shorten the arrow so the tip<br>
and base are shink percent of the distance *d* away from the<br>
endpoints. ie, ``shrink=0.05 is 5%``<br>
? any key for :class:`matplotlib.patches.polygon`<br>
========= ===========================================================<br>
<br>
*xycoords* and *textcoords* are strings that indicate the<br>
coordinates of *xy* and *xytext*.<br>
<br>
================= ===================================================<br>
Property Description<br>
================= ===================================================<br>
'figure points' points from the lower left corner of the figure<br>
'figure pixels' pixels from the lower left corner of the figure<br>
'figure fraction' 0,0 is lower left of figure and 1,1 is upper, right<br>
'axes points' points from lower left corner of axes<br>
'axes pixels' pixels from lower left corner of axes<br>
'axes fraction' 0,1 is lower left of axes and 1,1 is upper right<br>
'data' use the coordinate system of the object being<br>
annotated (default)<br>
'offset points' Specify an offset (in points) from the *xy* value<br>
<br>
'polar' you can specify *theta*, *r* for the annotation,<br>
even in cartesian plots. Note that if you<br>
are using a polar axes, you do not need<br>
to specify polar for the coordinate<br>
system since that is the native "data" coordinate<br>
system.<br>
================= ===================================================<br>
<br>
If a 'points' or 'pixels' option is specified, values will be<br>
added to the bottom-left and if negative, values will be<br>
subtracted from the top-right. Eg::<br>
<br>
# 10 points to the right of the left border of the axes and<br>
# 5 points below the top border<br>
xy=(10,-5), xycoords='axes points'<br>
<br>
Additional kwargs are Text properties:<br>
<br>
<br>
========================= =====================================================================<br>
Property Description <br>
========================= =====================================================================<br>
alpha float <br>
animated [True | False] <br>
axes an axes instance <br>
backgroundcolor any matplotlib color <br>
bbox rectangle prop dict plus key 'pad' which is a pad in points <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color any matplotlib color <br>
contains unknown <br>
family [ 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ] <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fontproperties a matplotlib.font_manager.FontProperties instance <br>
horizontalalignment or ha [ 'center' | 'right' | 'left' ] <br>
label any string <br>
linespacing float <br>
lod [True | False] <br>
multialignment ['left' | 'right' | 'center' ] <br>
name or fontname string eg, ['Sans' | 'Courier' | 'Helvetica' ...] <br>
picker [None|float|boolean|callable] <br>
position (x,y) <br>
rotation [ angle in degrees 'vertical' | 'horizontal' <br>
size or fontsize [ size in points | relative size eg 'smaller', 'x-large' ] <br>
style or fontstyle [ 'normal' | 'italic' | 'oblique'] <br>
text string or anything printable with '%s' conversion <br>
transform unknown <br>
variant [ 'normal' | 'small-caps' ] <br>
verticalalignment or va [ 'center' | 'top' | 'bottom' | 'baseline' ] <br>
visible [True | False] <br>
weight or fontweight [ 'normal' | 'bold' | 'heavy' | 'light' | 'ultrabold' | 'ultralight']<br>
x float <br>
y float <br>
zorder any number <br>
========================= =====================================================================</tt></dd></dl>
<dl><dt><a name="-arrow"><strong>arrow</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-arrow">arrow</a>(x, y, dx, dy, **kwargs)<br>
<br>
Draws arrow on specified axis from (*x*, *y*) to (*x* + *dx*,<br>
*y* + *dy*).<br>
<br>
Optional kwargs control the arrow properties:<br>
<br>
=========== ===========================================================<br>
Property Description <br>
=========== ===========================================================<br>
aa [True | False] or None for default <br>
alpha float <br>
animated [True | False] <br>
antialiased [True | False] or None for default <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
contains unknown <br>
ec mpl color spec, or None for default, or 'none' for no color<br>
edgecolor mpl color spec, or None for default, or 'none' for no color<br>
facecolor mpl color spec, or None for default, or 'none' for no color<br>
fc mpl color spec, or None for default, or 'none' for no color<br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fill [True | False] <br>
hatch unknown <br>
label any string <br>
linestyle ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
linewidth float or None for default <br>
lod [True | False] <br>
ls ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
lw float or None for default <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
=========== ===========================================================<br>
<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/arrow_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-autumn"><strong>autumn</strong></a>()</dt><dd><tt>Set the default colormap to *autumn* and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-axes"><strong>axes</strong></a>(*args, **kwargs)</dt><dd><tt>Add an axes at position rect specified by:<br>
<br>
- ``<a href="#-axes">axes</a>()`` by itself creates a default full ``<a href="#-subplot">subplot</a>(111)`` window axis.<br>
<br>
- ``<a href="#-axes">axes</a>(rect, axisbg='w')`` where *rect* = [left, bottom, width,<br>
height] in normalized (0, 1) units. *axisbg* is the background<br>
color for the axis, default white.<br>
<br>
- ``<a href="#-axes">axes</a>(h)`` where *h* is an axes instance makes *h* the current<br>
axis. An :class:`~matplotlib.axes.Axes` instance is returned.<br>
<br>
======= ============ ================================================<br>
kwarg Accepts Desctiption<br>
======= ============ ================================================<br>
axisbg color the axes background color<br>
frameon [True|False] display the frame?<br>
sharex otherax current axes shares xaxis attribute with otherax<br>
sharey otherax current axes shares yaxis attribute with otherax<br>
polar [True|False] use a polar axes?<br>
======= ============ ================================================<br>
<br>
Examples:<br>
<br>
* :file:`examples/pylab_examples/axes_demo.py` places custom axes.<br>
* :file:`examples/pylab_examples/shared_axis_demo.py` uses<br>
*sharex* and *sharey*.</tt></dd></dl>
<dl><dt><a name="-axhline"><strong>axhline</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-axhline">axhline</a>(y=0, xmin=0, xmax=1, **kwargs)<br>
<br>
Axis Horizontal Line<br>
<br>
Draw a horizontal line at *y* from *xmin* to *xmax*. With the<br>
default values of *xmin* = 0 and *xmax* = 1, this line will<br>
always span the horizontal extent of the axes, regardless of<br>
the xlim settings, even if you change them, eg. with the<br>
:meth:`set_xlim` command. That is, the horizontal extent is<br>
in axes coords: 0=left, 0.5=middle, 1.0=right but the *y*<br>
location is in data coordinates.<br>
<br>
Return value is the :class:`~matplotlib.lines.Line2D`<br>
instance. kwargs are the same as kwargs to plot, and can be<br>
used to control the line properties. Eg.,<br>
<br>
* draw a thick red hline at *y* = 0 that spans the xrange<br>
<br>
>>> <a href="#-axhline">axhline</a>(linewidth=4, color='r')<br>
<br>
* draw a default hline at *y* = 1 that spans the xrange<br>
<br>
>>> <a href="#-axhline">axhline</a>(y=1)<br>
<br>
* draw a default hline at *y* = .5 that spans the the middle half of<br>
the xrange<br>
<br>
>>> <a href="#-axhline">axhline</a>(y=.5, xmin=0.25, xmax=0.75)<br>
<br>
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
See :meth:`axhspan` for example plot and source code<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-axhspan"><strong>axhspan</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-axhspan">axhspan</a>(ymin, ymax, xmin=0, xmax=1, **kwargs)<br>
<br>
Axis Horizontal Span.<br>
<br>
*y* coords are in data units and *x* coords are in axes (relative<br>
0-1) units.<br>
<br>
Draw a horizontal span (rectangle) from *ymin* to *ymax*.<br>
With the default values of *xmin* = 0 and *xmax* = 1, this<br>
always span the xrange, regardless of the xlim settings, even<br>
if you change them, eg. with the :meth:`set_xlim` command.<br>
That is, the horizontal extent is in axes coords: 0=left,<br>
0.5=middle, 1.0=right but the *y* location is in data<br>
coordinates.<br>
<br>
Return value is a :class:`matplotlib.patches.Polygon`<br>
instance.<br>
<br>
Examples:<br>
<br>
* draw a gray rectangle from *y* = 0.25-0.75 that spans the<br>
horizontal extent of the axes<br>
<br>
>>> <a href="#-axhspan">axhspan</a>(0.25, 0.75, facecolor='0.5', alpha=0.5)<br>
<br>
Valid kwargs are :class:`~matplotlib.patches.Polygon` properties:<br>
<br>
<br>
=========== ===========================================================<br>
Property Description <br>
=========== ===========================================================<br>
aa [True | False] or None for default <br>
alpha float <br>
animated [True | False] <br>
antialiased [True | False] or None for default <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
contains unknown <br>
ec mpl color spec, or None for default, or 'none' for no color<br>
edgecolor mpl color spec, or None for default, or 'none' for no color<br>
facecolor mpl color spec, or None for default, or 'none' for no color<br>
fc mpl color spec, or None for default, or 'none' for no color<br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fill [True | False] <br>
hatch unknown <br>
label any string <br>
linestyle ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
linewidth float or None for default <br>
lod [True | False] <br>
ls ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
lw float or None for default <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
=========== ===========================================================<br>
<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/axhspan_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-axis"><strong>axis</strong></a>(*v, **kwargs)</dt><dd><tt>Set/Get the axis properties:<br>
<br>
>>> <a href="#-axis">axis</a>()<br>
<br>
returns the current axes limits ``[xmin, xmax, ymin, ymax]``.<br>
<br>
>>> <a href="#-axis">axis</a>(v)<br>
<br>
sets the min and max of the x and y axes, with<br>
``v = [xmin, xmax, ymin, ymax]``.<br>
<br>
>>> <a href="#-axis">axis</a>('off')<br>
<br>
turns off the axis lines and labels.<br>
<br>
>>> <a href="#-axis">axis</a>('equal')<br>
<br>
changes limits of *x* or *y* axis so that equal increments of *x*<br>
and *y* have the same length; a circle is circular.<br>
<br>
>>> <a href="#-axis">axis</a>('scaled')<br>
<br>
achieves the same result by changing the dimensions of the plot box instead<br>
of the axis data limits.<br>
<br>
>>> <a href="#-axis">axis</a>('tight')<br>
<br>
changes *x* and *y* axis limits such that all data is shown. If<br>
all data is already shown, it will move it to the center of the<br>
figure without modifying (*xmax* - *xmin*) or (*ymax* -<br>
*ymin*). Note this is slightly different than in matlab.<br>
<br>
>>> <a href="#-axis">axis</a>('image')<br>
<br>
is 'scaled' with the axis limits equal to the data limits.<br>
<br>
>>> <a href="#-axis">axis</a>('auto')<br>
<br>
and<br>
<br>
>>> <a href="#-axis">axis</a>('normal')<br>
<br>
are deprecated. They restore default behavior; axis limits are automatically<br>
scaled to make the data fit comfortably within the plot box.<br>
<br>
if ``len(*v)==0``, you can pass in *xmin*, *xmax*, *ymin*, *ymax*<br>
as kwargs selectively to alter just those limits without changing<br>
the others. See :func:`xlim` and :func:`ylim` for more information<br>
<br>
The xmin, xmax, ymin, ymax tuple is returned</tt></dd></dl>
<dl><dt><a name="-axvline"><strong>axvline</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-axvline">axvline</a>(x=0, ymin=0, ymax=1, **kwargs)<br>
<br>
Axis Vertical Line<br>
<br>
Draw a vertical line at *x* from *ymin* to *ymax*. With the<br>
default values of *ymin* = 0 and *ymax* = 1, this line will<br>
always span the vertical extent of the axes, regardless of the<br>
xlim settings, even if you change them, eg. with the<br>
:meth:`set_xlim` command. That is, the vertical extent is in<br>
axes coords: 0=bottom, 0.5=middle, 1.0=top but the *x* location<br>
is in data coordinates.<br>
<br>
Return value is the :class:`~matplotlib.lines.Line2D`<br>
instance. kwargs are the same as kwargs to plot, and can be<br>
used to control the line properties. Eg.,<br>
<br>
* draw a thick red vline at *x* = 0 that spans the yrange<br>
<br>
>>> <a href="#-axvline">axvline</a>(linewidth=4, color='r')<br>
<br>
* draw a default vline at *x* = 1 that spans the yrange<br>
<br>
>>> <a href="#-axvline">axvline</a>(x=1)<br>
<br>
* draw a default vline at *x* = .5 that spans the the middle half of<br>
the yrange<br>
<br>
>>> <a href="#-axvline">axvline</a>(x=.5, ymin=0.25, ymax=0.75)<br>
<br>
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
See :meth:`axhspan` for example plot and source code<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-axvspan"><strong>axvspan</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-axvspan">axvspan</a>(xmin, xmax, ymin=0, ymax=1, **kwargs)<br>
<br>
Axis Vertical Span.<br>
<br>
*x* coords are in data units and *y* coords are in axes (relative<br>
0-1) units.<br>
<br>
Draw a vertical span (rectangle) from *xmin* to *xmax*. With<br>
the default values of *ymin* = 0 and *ymax* = 1, this always<br>
span the yrange, regardless of the ylim settings, even if you<br>
change them, eg. with the :meth:`set_ylim` command. That is,<br>
the vertical extent is in axes coords: 0=bottom, 0.5=middle,<br>
1.0=top but the *y* location is in data coordinates.<br>
<br>
Return value is the :class:`matplotlib.patches.Polygon`<br>
instance.<br>
<br>
Examples:<br>
<br>
* draw a vertical green translucent rectangle from x=1.25 to 1.55 that<br>
spans the yrange of the axes<br>
<br>
>>> <a href="#-axvspan">axvspan</a>(1.25, 1.55, facecolor='g', alpha=0.5)<br>
<br>
Valid kwargs are :class:`~matplotlib.patches.Polygon`<br>
properties:<br>
<br>
<br>
=========== ===========================================================<br>
Property Description <br>
=========== ===========================================================<br>
aa [True | False] or None for default <br>
alpha float <br>
animated [True | False] <br>
antialiased [True | False] or None for default <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
contains unknown <br>
ec mpl color spec, or None for default, or 'none' for no color<br>
edgecolor mpl color spec, or None for default, or 'none' for no color<br>
facecolor mpl color spec, or None for default, or 'none' for no color<br>
fc mpl color spec, or None for default, or 'none' for no color<br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fill [True | False] <br>
hatch unknown <br>
label any string <br>
linestyle ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
linewidth float or None for default <br>
lod [True | False] <br>
ls ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
lw float or None for default <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
=========== ===========================================================<br>
<br>
<br>
See :meth:`axhspan` for example plot and source code<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-bar"><strong>bar</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-bar">bar</a>(left, height, width=0.8, bottom=0,<br>
color=None, edgecolor=None, linewidth=None,<br>
yerr=None, xerr=None, ecolor=None, capsize=3,<br>
align='edge', orientation='vertical', log=False)<br>
<br>
Make a bar plot with rectangles bounded by:<br>
<br>
*left*, *left* + *width*, *bottom*, *bottom* + *height*<br>
(left, right, bottom and top edges)<br>
<br>
*left*, *height*, *width*, and *bottom* can be either scalars<br>
or sequences<br>
<br>
Return value is a list of<br>
:class:`matplotlib.patches.Rectangle` instances.<br>
<br>
Required arguments:<br>
<br>
======== ===============================================<br>
Argument Description<br>
======== ===============================================<br>
*left* the x coordinates of the left sides of the bars<br>
*height* the heights of the bars<br>
======== ===============================================<br>
<br>
Optional keyword arguments:<br>
<br>
=============== ==========================================<br>
Keyword Description<br>
=============== ==========================================<br>
*width* the widths of the bars<br>
*bottom* the y coordinates of the bottom edges of<br>
the bars<br>
*color* the colors of the bars<br>
*edgecolor* the colors of the bar edges<br>
*linewidth* width of bar edges; None means use default<br>
linewidth; 0 means don't draw edges.<br>
*xerr* if not None, will be used to generate<br>
errorbars on the bar chart<br>
*yerr* if not None, will be used to generate<br>
errorbars on the bar chart<br>
*ecolor* specifies the color of any errorbar<br>
*capsize* (default 3) determines the length in<br>
points of the error bar caps<br>
*align* 'edge' (default) | 'center'<br>
*orientation* 'vertical' | 'horizontal'<br>
*log* [False|True] False (default) leaves the<br>
orientation axis as-is; True sets it to<br>
log scale<br>
=============== ==========================================<br>
<br>
For vertical bars, *align* = 'edge' aligns bars by their left<br>
edges in left, while *align* = 'center' interprets these<br>
values as the *x* coordinates of the bar centers. For<br>
horizontal bars, *align* = 'edge' aligns bars by their bottom<br>
edges in bottom, while *align* = 'center' interprets these<br>
values as the *y* coordinates of the bar centers.<br>
<br>
The optional arguments *color*, *edgecolor*, *linewidth*,<br>
*xerr*, and *yerr* can be either scalars or sequences of<br>
length equal to the number of bars. This enables you to use<br>
bar as the basis for stacked bar charts, or candlestick plots.<br>
<br>
Other optional kwargs:<br>
<br>
<br>
=========== ===========================================================<br>
Property Description <br>
=========== ===========================================================<br>
aa [True | False] or None for default <br>
alpha float <br>
animated [True | False] <br>
antialiased [True | False] or None for default <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
contains unknown <br>
ec mpl color spec, or None for default, or 'none' for no color<br>
edgecolor mpl color spec, or None for default, or 'none' for no color<br>
facecolor mpl color spec, or None for default, or 'none' for no color<br>
fc mpl color spec, or None for default, or 'none' for no color<br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fill [True | False] <br>
hatch unknown <br>
label any string <br>
linestyle ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
linewidth float or None for default <br>
lod [True | False] <br>
ls ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
lw float or None for default <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
=========== ===========================================================<br>
<br>
<br>
**Example:** A stacked bar chart.<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/bar_stacked.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-barbs"><strong>barbs</strong></a>(*args, **kwargs)</dt><dd><tt>Plot a 2-D field of barbs.<br>
<br>
call signatures::<br>
<br>
barb(U, V, **kw)<br>
barb(U, V, C, **kw)<br>
barb(X, Y, U, V, **kw)<br>
barb(X, Y, U, V, C, **kw)<br>
<br>
Arguments:<br>
<br>
*X*, *Y*:<br>
The x and y coordinates of the barb locations<br>
(default is head of barb; see *pivot* kwarg)<br>
<br>
*U*, *V*:<br>
give the *x* and *y* components of the barb shaft<br>
<br>
*C*:<br>
an optional array used to map colors to the barbs<br>
<br>
All arguments may be 1-D or 2-D arrays or sequences. If *X* and *Y*<br>
are absent, they will be generated as a uniform grid. If *U* and *V*<br>
are 2-D arrays but *X* and *Y* are 1-D, and if len(*X*) and len(*Y*)<br>
match the column and row dimensions of *U*, then *X* and *Y* will be<br>
expanded with :func:`numpy.meshgrid`.<br>
<br>
*U*, *V*, *C* may be masked arrays, but masked *X*, *Y* are not<br>
supported at present.<br>
<br>
Keyword arguments:<br>
<br>
*length*:<br>
Length of the barb in points; the other parts of the barb<br>
are scaled against this.<br>
Default is 9<br>
<br>
*pivot*: [ 'tip' | 'middle' ]<br>
The part of the arrow that is at the grid point; the arrow<br>
rotates about this point, hence the name *pivot*.<br>
Default is 'tip'<br>
<br>
*barbcolor*: [ color | color sequence ]<br>
Specifies the color all parts of the barb except any flags.<br>
This parameter is analagous to the *edgecolor* parameter<br>
for polygons, which can be used instead. However this parameter<br>
will override facecolor.<br>
<br>
*flagcolor*: [ color | color sequence ]<br>
Specifies the color of any flags on the barb.<br>
This parameter is analagous to the *facecolor* parameter<br>
for polygons, which can be used instead. However this parameter<br>
will override facecolor. If this is not set (and *C* has not either)<br>
then *flagcolor* will be set to match *barbcolor* so that the barb<br>
has a uniform color. If *C* has been set, *flagcolor* has no effect.<br>
<br>
*sizes*:<br>
A dictionary of coefficients specifying the ratio of a given feature<br>
to the length of the barb. Only those values one wishes to override<br>
need to be included. These features include:<br>
'spacing' - space between features (flags, full/half barbs)<br>
'height' - height (distance from shaft to top) of a flag or full barb<br>
'width' - width of a flag, twice the width of a full barb<br>
'emptybarb' - radius of the circle used for low magnitudes<br>
<br>
*fill_empty*:<br>
A flag on whether the empty barbs (circles) that are drawn should be filled<br>
with the flag color. If they are not filled, they will be drawn such that<br>
no color is applied to the center.<br>
Default is False<br>
<br>
*rounding*:<br>
A flag to indicate whether the vector magnitude should be rounded when<br>
allocating barb components. If True, the magnitude is rounded to the<br>
nearest multiple of the half-barb increment. If False, the magnitude<br>
is simply truncated to the next lowest multiple.<br>
Default is True<br>
<br>
*barb_increments*:<br>
A dictionary of increments specifying values to associate with different<br>
parts of the barb. Only those values one wishes to override need to be<br>
included.<br>
'half' - half barbs (Default is 5)<br>
'full' - full barbs (Default is 10)<br>
'flag' - flags (default is 50)<br>
<br>
*flip_barb*:<br>
Either a single boolean flag or an array of booleans. Single boolean<br>
indicates whether the lines and flags should point opposite to normal<br>
for all barbs. An array (which should be the same size as the other<br>
data arrays) indicates whether to flip for each individual barb.<br>
Normal behavior is for the barbs and lines to point right (comes from<br>
wind barbs having these features point towards low pressure in the<br>
Northern Hemisphere.)<br>
Default is False<br>
<br>
Barbs are traditionally used in meteorology as a way to plot the speed<br>
and direction of wind observations, but can technically be used to plot<br>
any two dimensional vector quantity. As opposed to arrows, which give<br>
vector magnitude by the length of the arrow, the barbs give more quantitative<br>
information about the vector magnitude by putting slanted lines or a triangle<br>
for various increments in magnitude, as show schematically below:<br>
<br>
/\ / \ / \ \ / \ \ ------------------------------<br>
<br>
The largest increment is given by a triangle (or "flag"). After those come full<br>
lines (barbs). The smallest increment is a half line. There is only, of<br>
course, ever at most 1 half line. If the magnitude is small and only needs a<br>
single half-line and no full lines or triangles, the half-line is offset from<br>
the end of the barb so that it can be easily distinguished from barbs with a<br>
single full line. The magnitude for the barb shown above would nominally be<br>
65, using the standard increments of 50, 10, and 5.<br>
<br>
linewidths and edgecolors can be used to customize the barb.<br>
Additional :class:`~matplotlib.collections.PolyCollection`<br>
keyword arguments:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-barh"><strong>barh</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-barh">barh</a>(bottom, width, height=0.8, left=0, **kwargs)<br>
<br>
Make a horizontal bar plot with rectangles bounded by:<br>
<br>
*left*, *left* + *width*, *bottom*, *bottom* + *height*<br>
(left, right, bottom and top edges)<br>
<br>
*bottom*, *width*, *height*, and *left* can be either scalars<br>
or sequences<br>
<br>
Return value is a list of<br>
:class:`matplotlib.patches.Rectangle` instances.<br>
<br>
Required arguments:<br>
<br>
======== ======================================================<br>
Argument Description<br>
======== ======================================================<br>
*bottom* the vertical positions of the bottom edges of the bars<br>
*width* the lengths of the bars<br>
======== ======================================================<br>
<br>
Optional keyword arguments:<br>
<br>
=============== ==========================================<br>
Keyword Description<br>
=============== ==========================================<br>
*height* the heights (thicknesses) of the bars<br>
*left* the x coordinates of the left edges of the<br>
bars<br>
*color* the colors of the bars<br>
*edgecolor* the colors of the bar edges<br>
*linewidth* width of bar edges; None means use default<br>
linewidth; 0 means don't draw edges.<br>
*xerr* if not None, will be used to generate<br>
errorbars on the bar chart<br>
*yerr* if not None, will be used to generate<br>
errorbars on the bar chart<br>
*ecolor* specifies the color of any errorbar<br>
*capsize* (default 3) determines the length in<br>
points of the error bar caps<br>
*align* 'edge' (default) | 'center'<br>
*log* [False|True] False (default) leaves the<br>
horizontal axis as-is; True sets it to log<br>
scale<br>
=============== ==========================================<br>
<br>
Setting *align* = 'edge' aligns bars by their bottom edges in<br>
bottom, while *align* = 'center' interprets these values as<br>
the *y* coordinates of the bar centers.<br>
<br>
The optional arguments *color*, *edgecolor*, *linewidth*,<br>
*xerr*, and *yerr* can be either scalars or sequences of<br>
length equal to the number of bars. This enables you to use<br>
barh as the basis for stacked bar charts, or candlestick<br>
plots.<br>
<br>
other optional kwargs:<br>
<br>
<br>
=========== ===========================================================<br>
Property Description <br>
=========== ===========================================================<br>
aa [True | False] or None for default <br>
alpha float <br>
animated [True | False] <br>
antialiased [True | False] or None for default <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
contains unknown <br>
ec mpl color spec, or None for default, or 'none' for no color<br>
edgecolor mpl color spec, or None for default, or 'none' for no color<br>
facecolor mpl color spec, or None for default, or 'none' for no color<br>
fc mpl color spec, or None for default, or 'none' for no color<br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fill [True | False] <br>
hatch unknown <br>
label any string <br>
linestyle ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
linewidth float or None for default <br>
lod [True | False] <br>
ls ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
lw float or None for default <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
=========== ===========================================================<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-bone"><strong>bone</strong></a>()</dt><dd><tt>Set the default colormap to bone and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-box"><strong>box</strong></a>(on<font color="#909090">=None</font>)</dt><dd><tt>Turn the axes box on or off according to *on*.<br>
<br>
If *on* is *None*, toggle state.</tt></dd></dl>
<dl><dt><a name="-boxplot"><strong>boxplot</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-boxplot">boxplot</a>(x, notch=0, sym='+', vert=1, whis=1.5,<br>
positions=None, widths=None)<br>
<br>
Make a box and whisker plot for each column of *x* or each<br>
vector in sequence *x*. The box extends from the lower to<br>
upper quartile values of the data, with a line at the median.<br>
The whiskers extend from the box to show the range of the<br>
data. Flier points are those past the end of the whiskers.<br>
<br>
- *notch* = 0 (default) produces a rectangular box plot.<br>
- *notch* = 1 will produce a notched box plot<br>
<br>
*sym* (default 'b+') is the default symbol for flier points.<br>
Enter an empty string ('') if you don't want to show fliers.<br>
<br>
- *vert* = 1 (default) makes the boxes vertical.<br>
- *vert* = 0 makes horizontal boxes. This seems goofy, but<br>
that's how Matlab did it.<br>
<br>
*whis* (default 1.5) defines the length of the whiskers as<br>
a function of the inner quartile range. They extend to the<br>
most extreme data point within ( ``whis*(75%-25%)`` ) data range.<br>
<br>
*positions* (default 1,2,...,n) sets the horizontal positions of<br>
the boxes. The ticks and limits are automatically set to match<br>
the positions.<br>
<br>
*widths* is either a scalar or a vector and sets the width of<br>
each box. The default is 0.5, or ``0.15*(distance between extreme<br>
positions)`` if that is smaller.<br>
<br>
*x* is an array or a sequence of vectors.<br>
<br>
Returns a list of the :class:`matplotlib.lines.Line2D`<br>
instances added.<br>
<br>
**Example:**<br>
<br>
.. plot:: boxplot_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-broken_barh"><strong>broken_barh</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-broken_barh">broken_barh</a>(self, xranges, yrange, **kwargs)<br>
<br>
A collection of horizontal bars spanning *yrange* with a sequence of<br>
*xranges*.<br>
<br>
Required arguments:<br>
<br>
========= ==============================<br>
Argument Description<br>
========= ==============================<br>
*xranges* sequence of (*xmin*, *xwidth*)<br>
*yrange* sequence of (*ymin*, *ywidth*)<br>
========= ==============================<br>
<br>
kwargs are<br>
:class:`matplotlib.collections.BrokenBarHCollection`<br>
properties:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
these can either be a single argument, ie::<br>
<br>
facecolors = 'black'<br>
<br>
or a sequence of arguments for the various bars, ie::<br>
<br>
facecolors = ('black', 'red', 'green')<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/broken_barh.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-cla"><strong>cla</strong></a>(*args, **kwargs)</dt><dd><tt>Clear the current axes</tt></dd></dl>
<dl><dt><a name="-clabel"><strong>clabel</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-clabel">clabel</a>(cs, **kwargs)<br>
<br>
adds labels to line contours in *cs*, where *cs* is a<br>
:class:`~matplotlib.contour.ContourSet` object returned by<br>
contour.<br>
<br>
::<br>
<br>
<a href="#-clabel">clabel</a>(cs, v, **kwargs)<br>
<br>
only labels contours listed in *v*.<br>
<br>
Optional keyword arguments:<br>
<br>
*fontsize*:<br>
See <a href="http://matplotlib.sf.net/fonts.html">http://matplotlib.sf.net/fonts.html</a><br>
<br>
.. TODO: Update this link to new fonts document<br>
<br>
*colors*:<br>
- if *None*, the color of each label matches the color of<br>
the corresponding contour<br>
<br>
- if one string color, e.g. *colors* = 'r' or *colors* =<br>
'red', all labels will be plotted in this color<br>
<br>
- if a tuple of matplotlib color args (string, float, rgb, etc),<br>
different labels will be plotted in different colors in the order<br>
specified<br>
<br>
*inline*:<br>
controls whether the underlying contour is removed or<br>
not. Default is *True*.<br>
<br>
*inline_spacing*:<br>
space in pixels to leave on each side of label when<br>
placing inline. Defaults to 5. This spacing will be<br>
exact for labels at locations where the contour is<br>
straight, less so for labels on curved contours.<br>
<br>
*fmt*:<br>
a format string for the label. Default is '%1.3f'<br>
Alternatively, this can be a dictionary matching contour<br>
levels with arbitrary strings to use for each contour level<br>
(i.e., fmt[level]=string)<br>
<br>
*manual*:<br>
if *True*, contour labels will be placed manually using<br>
mouse clicks. Click the first button near a contour to<br>
add a label, click the second button (or potentially both<br>
mouse buttons at once) to finish adding labels. The third<br>
button can be used to remove the last label added, but<br>
only if labels are not inline.<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-clf"><strong>clf</strong></a>()</dt><dd><tt>Clear the current figure</tt></dd></dl>
<dl><dt><a name="-clim"><strong>clim</strong></a>(vmin<font color="#909090">=None</font>, vmax<font color="#909090">=None</font>)</dt><dd><tt>Set the color limits of the current image<br>
<br>
To apply clim to all axes images do::<br>
<br>
<a href="#-clim">clim</a>(0, 0.5)<br>
<br>
If either *vmin* or *vmax* is None, the image min/max respectively<br>
will be used for color scaling.<br>
<br>
If you want to set the clim of multiple images,<br>
use, for example::<br>
<br>
for im in <a href="#-gca">gca</a>().get_images():<br>
im.set_clim(0, 0.05)</tt></dd></dl>
<dl><dt><a name="-close"><strong>close</strong></a>(*args)</dt><dd><tt>Close a figure window<br>
<br>
``<a href="#-close">close</a>()`` by itself closes the current figure<br>
<br>
``<a href="#-close">close</a>(num)`` closes figure number *num*<br>
<br>
``<a href="#-close">close</a>(h)`` where *h* is a :class:`Figure` instance, closes that figure<br>
<br>
``<a href="#-close">close</a>('all')`` closes all the figure windows</tt></dd></dl>
<dl><dt><a name="-cohere"><strong>cohere</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-cohere">cohere</a>(x, y, NFFT=256, Fs=2, Fc=0, detrend = mlab.detrend_none,<br>
window = mlab.window_hanning, noverlap=0, **kwargs)<br>
<br>
cohere the coherence between *x* and *y*. Coherence is the normalized<br>
cross spectral density:<br>
<br>
.. math::<br>
<br>
C_{xy} = \frac{|P_{xy}|^2}{P_{xx}*P_{yy}}<br>
<br>
The return value is a tuple (*Cxy*, *f*), where *f* are the<br>
frequencies of the coherence vector.<br>
<br>
See the :meth:`psd` for a description of the optional parameters.<br>
<br>
kwargs are applied to the lines.<br>
<br>
References:<br>
<br>
* Bendat & Piersol -- Random Data: Analysis and Measurement<br>
Procedures, John Wiley & Sons (1986)<br>
<br>
kwargs control the :class:`~matplotlib.lines.Line2D`<br>
properties of the coherence plot:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/cohere_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-colorbar"><strong>colorbar</strong></a>(mappable<font color="#909090">=None</font>, cax<font color="#909090">=None</font>, ax<font color="#909090">=None</font>, **kw)</dt><dd><tt>Add a colorbar to a plot.<br>
<br>
Function signatures for the :mod:`~matplotlib.pyplot` interface; all<br>
but the first are also method signatures for the<br>
:meth:`matplotlib.Figure.colorbar` method::<br>
<br>
<a href="#-colorbar">colorbar</a>(**kwargs)<br>
<a href="#-colorbar">colorbar</a>(mappable, **kwargs)<br>
<a href="#-colorbar">colorbar</a>(mappable, cax=cax, **kwargs)<br>
<a href="#-colorbar">colorbar</a>(mappable, ax=ax, **kwargs)<br>
<br>
arguments:<br>
<br>
*mappable*<br>
the image, :class:`~matplotlib.contours.ContourSet`, etc. to<br>
which the colorbar applies; this argument is mandatory for the<br>
:meth:`matplotlib.Figure.colorbar` method but optional for the<br>
:func:`matplotlib.pyplot.colorbar` function, which sets the<br>
default to the current image.<br>
<br>
keyword arguments:<br>
<br>
*cax*<br>
None | axes object into which the colorbar will be drawn<br>
*ax*<br>
None | parent axes object from which space for a new<br>
colorbar axes will be stolen<br>
<br>
<br>
Additional keyword arguments are of two kinds:<br>
<br>
axes properties:<br>
<br>
<br>
========== ====================================================<br>
Property Description<br>
========== ====================================================<br>
*fraction* 0.15; fraction of original axes to use for colorbar<br>
*pad* 0.05 if vertical, 0.15 if horizontal; fraction<br>
of original axes between colorbar and new image axes<br>
*shrink* 1.0; fraction by which to shrink the colorbar<br>
*aspect* 20; ratio of long to short dimensions<br>
========== ====================================================<br>
<br>
<br>
colorbar properties:<br>
<br>
<br>
=========== ====================================================<br>
Property Description<br>
=========== ====================================================<br>
*extend* [ 'neither' | 'both' | 'min' | 'max' ]<br>
If not 'neither', make pointed end(s) for out-of-<br>
range values. These are set for a given colormap<br>
using the colormap set_under and set_over methods.<br>
*spacing* [ 'uniform' | 'proportional' ]<br>
Uniform spacing gives each discrete color the same<br>
space; proportional makes the space proportional to<br>
the data interval.<br>
*ticks* [ None | list of ticks | Locator object ]<br>
If None, ticks are determined automatically from the<br>
input.<br>
*format* [ None | format string | Formatter object ]<br>
If None, the<br>
:class:`~matplotlib.ticker.ScalarFormatter` is used.<br>
If a format string is given, e.g. '%.3f', that is<br>
used. An alternative<br>
:class:`~matplotlib.ticker.Formatter` object may be<br>
given instead.<br>
*drawedges* [ False | True ] If true, draw lines at color<br>
boundaries.<br>
=========== ====================================================<br>
<br>
The following will probably be useful only in the context of<br>
indexed colors (that is, when the mappable has norm=NoNorm()),<br>
or other unusual circumstances.<br>
<br>
============ ===================================================<br>
Property Description<br>
============ ===================================================<br>
*boundaries* None or a sequence<br>
*values* None or a sequence which must be of length 1 less<br>
than the sequence of *boundaries*. For each region<br>
delimited by adjacent entries in *boundaries*, the<br>
color mapped to the corresponding value in values<br>
will be used.<br>
============ ===================================================<br>
<br>
<br>
<br>
If mappable is a :class:`~matplotlib.contours.ContourSet`, its *extend*<br>
kwarg is included automatically.<br>
<br>
Note that the *shrink* kwarg provides a simple way to keep a vertical<br>
colorbar, for example, from being taller than the axes of the mappable<br>
to which the colorbar is attached; but it is a manual method requiring<br>
some trial and error. If the colorbar is too tall (or a horizontal<br>
colorbar is too wide) use a smaller value of *shrink*.<br>
<br>
For more precise control, you can manually specify the positions of<br>
the axes objects in which the mappable and the colorbar are drawn. In<br>
this case, do not use any of the axes properties kwargs.</tt></dd></dl>
<dl><dt><a name="-colormaps"><strong>colormaps</strong></a>()</dt><dd><tt>matplotlib provides the following colormaps.<br>
<br>
* autumn<br>
* bone<br>
* cool<br>
* copper<br>
* flag<br>
* gray<br>
* hot<br>
* hsv<br>
* jet<br>
* pink<br>
* prism<br>
* spring<br>
* summer<br>
* winter<br>
* spectral<br>
<br>
You can set the colormap for an image, pcolor, scatter, etc,<br>
either as a keyword argument::<br>
<br>
<a href="#-imshow">imshow</a>(X, cmap=cm.hot)<br>
<br>
or post-hoc using the corresponding pylab interface function::<br>
<br>
<a href="#-imshow">imshow</a>(X)<br>
<a href="#-hot">hot</a>()<br>
<a href="#-jet">jet</a>()<br>
<br>
In interactive mode, this will update the colormap allowing you to<br>
see which one works best for your data.</tt></dd></dl>
<dl><dt><a name="-colors"><strong>colors</strong></a>()</dt><dd><tt>This is a do nothing function to provide you with help on how<br>
matplotlib handles colors.<br>
<br>
Commands which take color arguments can use several formats to<br>
specify the colors. For the basic builtin colors, you can use a<br>
single letter<br>
<br>
===== =======<br>
Alias Color<br>
===== =======<br>
'b' blue<br>
'g' green<br>
'r' red<br>
'c' cyan<br>
'm' magenta<br>
'y' yellow<br>
'k' black<br>
'w' white<br>
===== =======<br>
<br>
For a greater range of colors, you have two options. You can<br>
specify the color using an html hex string, as in::<br>
<br>
color = '#eeefff'<br>
<br>
or you can pass an R,G,B tuple, where each of R,G,B are in the<br>
range [0,1].<br>
<br>
You can also use any legal html name for a color, for example::<br>
<br>
color = 'red',<br>
color = 'burlywood'<br>
color = 'chartreuse'<br>
<br>
The example below creates a subplot with a dark<br>
slate gray background<br>
<br>
<a href="#-subplot">subplot</a>(111, axisbg=(0.1843, 0.3098, 0.3098))<br>
<br>
Here is an example that creates a pale turqoise title::<br>
<br>
<a href="#-title">title</a>('Is this the best color?', color='#afeeee')</tt></dd></dl>
<dl><dt><a name="-connect"><strong>connect</strong></a>(s, func)</dt><dd><tt>Connect event with string *s* to *func*. The signature of *func* is::<br>
<br>
def func(event)<br>
<br>
where event is a :class:`matplotlib.backend_bases.Event`. The<br>
following events are recognized<br>
<br>
- 'button_press_event'<br>
- 'button_release_event'<br>
- 'draw_event'<br>
- 'key_press_event'<br>
- 'key_release_event'<br>
- 'motion_notify_event'<br>
- 'pick_event'<br>
- 'resize_event'<br>
- 'scroll_event'<br>
<br>
For the location events (button and key press/release), if the<br>
mouse is over the axes, the variable ``event.inaxes`` will be<br>
set to the :class:`~matplotlib.axes.Axes` the event occurs is<br>
over, and additionally, the variables ``event.xdata`` and<br>
``event.ydata`` will be defined. This is the mouse location<br>
in data coords. See<br>
:class:`~matplotlib.backend_bases.KeyEvent` and<br>
:class:`~matplotlib.backend_bases.MouseEvent` for more info.<br>
<br>
Return value is a connection id that can be used with<br>
:meth:`~matplotlib.backend_bases.Event.mpl_disconnect`.<br>
<br>
Example usage::<br>
<br>
def on_press(event):<br>
print 'you pressed', event.button, event.xdata, event.ydata<br>
<br>
cid = canvas.mpl_connect('button_press_event', on_press)</tt></dd></dl>
<dl><dt><a name="-contour"><strong>contour</strong></a>(*args, **kwargs)</dt><dd><tt>:func:`~matplotlib.pyplot.contour` and<br>
:func:`~matplotlib.pyplot.contourf` draw contour lines and<br>
filled contours, respectively. Except as noted, function<br>
signatures and return values are the same for both versions.<br>
<br>
:func:`~matplotlib.pyplot.contourf` differs from the Matlab<br>
(TM) version in that it does not draw the polygon edges,<br>
because the contouring engine yields simply connected regions<br>
with branch cuts. To draw the edges, add line contours with<br>
calls to :func:`~matplotlib.pyplot.contour`.<br>
<br>
<br>
call signatures::<br>
<br>
<a href="#-contour">contour</a>(Z)<br>
<br>
make a contour plot of an array *Z*. The level values are chosen<br>
automatically.<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(X,Y,Z)<br>
<br>
*X*, *Y* specify the (*x*, *y*) coordinates of the surface<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(Z,N)<br>
<a href="#-contour">contour</a>(X,Y,Z,N)<br>
<br>
contour *N* automatically-chosen levels.<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(Z,V)<br>
<a href="#-contour">contour</a>(X,Y,Z,V)<br>
<br>
draw contour lines at the values specified in sequence *V*<br>
<br>
::<br>
<br>
<a href="#-contourf">contourf</a>(..., V)<br>
<br>
fill the (len(*V*)-1) regions between the values in *V*<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(Z, **kwargs)<br>
<br>
Use keyword args to control colors, linewidth, origin, cmap ... see<br>
below for more details.<br>
<br>
*X*, *Y*, and *Z* must be arrays with the same dimensions.<br>
<br>
*Z* may be a masked array, but filled contouring may not<br>
handle internal masked regions correctly.<br>
<br>
``C = <a href="#-contour">contour</a>(...)`` returns a<br>
:class:`~matplotlib.contour.ContourSet` object.<br>
<br>
Optional keyword arguments:<br>
<br>
*colors*: [ None | string | (mpl_colors) ]<br>
If *None*, the colormap specified by cmap will be used.<br>
<br>
If a string, like 'r' or 'red', all levels will be plotted in this<br>
color.<br>
<br>
If a tuple of matplotlib color args (string, float, rgb, etc),<br>
different levels will be plotted in different colors in the order<br>
specified.<br>
<br>
*alpha*: float<br>
The alpha blending value<br>
<br>
*cmap*: [ None | Colormap ]<br>
A cm :class:`~matplotlib.cm.Colormap` instance or<br>
*None*. If *cmap* is *None* and *colors* is *None*, a<br>
default Colormap is used.<br>
<br>
*norm*: [ None | Normalize ]<br>
A :class:`matplotlib.colors.Normalize` instance for<br>
scaling data values to colors. If *norm* is *None* and<br>
*colors* is *None*, the default linear scaling is used.<br>
<br>
*origin*: [ None | 'upper' | 'lower' | 'image' ]<br>
If *None*, the first value of *Z* will correspond to the<br>
lower left corner, location (0,0). If 'image', the rc<br>
value for ``image.origin`` will be used.<br>
<br>
This keyword is not active if *X* and *Y* are specified in<br>
the call to contour.<br>
<br>
*extent*: [ None | (x0,x1,y0,y1) ]<br>
<br>
If *origin* is not *None*, then *extent* is interpreted as<br>
in :func:`matplotlib.pyplot.imshow`: it gives the outer<br>
pixel boundaries. In this case, the position of Z[0,0]<br>
is the center of the pixel, not a corner. If *origin* is<br>
*None*, then (*x0*, *y0*) is the position of Z[0,0], and<br>
(*x1*, *y1*) is the position of Z[-1,-1].<br>
<br>
This keyword is not active if *X* and *Y* are specified in<br>
the call to contour.<br>
<br>
*locator*: [ None | ticker.Locator subclass ]<br>
If *locator* is None, the default<br>
:class:`~matplotlib.ticker.MaxNLocator` is used. The<br>
locator is used to determine the contour levels if they<br>
are not given explicitly via the *V* argument.<br>
<br>
*extend*: [ 'neither' | 'both' | 'min' | 'max' ]<br>
Unless this is 'neither', contour levels are automatically<br>
added to one or both ends of the range so that all data<br>
are included. These added ranges are then mapped to the<br>
special colormap values which default to the ends of the<br>
colormap range, but can be set via<br>
:meth:`matplotlib.cm.Colormap.set_under` and<br>
:meth:`matplotlib.cm.Colormap.set_over` methods.<br>
<br>
contour-only keyword arguments:<br>
<br>
*linewidths*: [ None | number | tuple of numbers ]<br>
If *linewidths* is *None*, the default width in<br>
``lines.linewidth`` in ``matplotlibrc`` is used<br>
<br>
If a number, all levels will be plotted with this linewidth.<br>
<br>
If a tuple, different levels will be plotted with different<br>
linewidths in the order specified<br>
<br>
contourf-only keyword arguments:<br>
<br>
*antialiased*: [ True | False ]<br>
enable antialiasing<br>
<br>
*nchunk*: [ 0 | integer ]<br>
If 0, no subdivision of the domain. Specify a positive integer to<br>
divide the domain into subdomains of roughly *nchunk* by *nchunk*<br>
points. This may never actually be advantageous, so this option may<br>
be removed. Chunking introduces artifacts at the chunk boundaries<br>
unless *antialiased* is *False*.<br>
<br>
**Example:**<br>
<br>
.. plot:: contour_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-contourf"><strong>contourf</strong></a>(*args, **kwargs)</dt><dd><tt>:func:`~matplotlib.pyplot.contour` and<br>
:func:`~matplotlib.pyplot.contourf` draw contour lines and<br>
filled contours, respectively. Except as noted, function<br>
signatures and return values are the same for both versions.<br>
<br>
:func:`~matplotlib.pyplot.contourf` differs from the Matlab<br>
(TM) version in that it does not draw the polygon edges,<br>
because the contouring engine yields simply connected regions<br>
with branch cuts. To draw the edges, add line contours with<br>
calls to :func:`~matplotlib.pyplot.contour`.<br>
<br>
<br>
call signatures::<br>
<br>
<a href="#-contour">contour</a>(Z)<br>
<br>
make a contour plot of an array *Z*. The level values are chosen<br>
automatically.<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(X,Y,Z)<br>
<br>
*X*, *Y* specify the (*x*, *y*) coordinates of the surface<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(Z,N)<br>
<a href="#-contour">contour</a>(X,Y,Z,N)<br>
<br>
contour *N* automatically-chosen levels.<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(Z,V)<br>
<a href="#-contour">contour</a>(X,Y,Z,V)<br>
<br>
draw contour lines at the values specified in sequence *V*<br>
<br>
::<br>
<br>
<a href="#-contourf">contourf</a>(..., V)<br>
<br>
fill the (len(*V*)-1) regions between the values in *V*<br>
<br>
::<br>
<br>
<a href="#-contour">contour</a>(Z, **kwargs)<br>
<br>
Use keyword args to control colors, linewidth, origin, cmap ... see<br>
below for more details.<br>
<br>
*X*, *Y*, and *Z* must be arrays with the same dimensions.<br>
<br>
*Z* may be a masked array, but filled contouring may not<br>
handle internal masked regions correctly.<br>
<br>
``C = <a href="#-contour">contour</a>(...)`` returns a<br>
:class:`~matplotlib.contour.ContourSet` object.<br>
<br>
Optional keyword arguments:<br>
<br>
*colors*: [ None | string | (mpl_colors) ]<br>
If *None*, the colormap specified by cmap will be used.<br>
<br>
If a string, like 'r' or 'red', all levels will be plotted in this<br>
color.<br>
<br>
If a tuple of matplotlib color args (string, float, rgb, etc),<br>
different levels will be plotted in different colors in the order<br>
specified.<br>
<br>
*alpha*: float<br>
The alpha blending value<br>
<br>
*cmap*: [ None | Colormap ]<br>
A cm :class:`~matplotlib.cm.Colormap` instance or<br>
*None*. If *cmap* is *None* and *colors* is *None*, a<br>
default Colormap is used.<br>
<br>
*norm*: [ None | Normalize ]<br>
A :class:`matplotlib.colors.Normalize` instance for<br>
scaling data values to colors. If *norm* is *None* and<br>
*colors* is *None*, the default linear scaling is used.<br>
<br>
*origin*: [ None | 'upper' | 'lower' | 'image' ]<br>
If *None*, the first value of *Z* will correspond to the<br>
lower left corner, location (0,0). If 'image', the rc<br>
value for ``image.origin`` will be used.<br>
<br>
This keyword is not active if *X* and *Y* are specified in<br>
the call to contour.<br>
<br>
*extent*: [ None | (x0,x1,y0,y1) ]<br>
<br>
If *origin* is not *None*, then *extent* is interpreted as<br>
in :func:`matplotlib.pyplot.imshow`: it gives the outer<br>
pixel boundaries. In this case, the position of Z[0,0]<br>
is the center of the pixel, not a corner. If *origin* is<br>
*None*, then (*x0*, *y0*) is the position of Z[0,0], and<br>
(*x1*, *y1*) is the position of Z[-1,-1].<br>
<br>
This keyword is not active if *X* and *Y* are specified in<br>
the call to contour.<br>
<br>
*locator*: [ None | ticker.Locator subclass ]<br>
If *locator* is None, the default<br>
:class:`~matplotlib.ticker.MaxNLocator` is used. The<br>
locator is used to determine the contour levels if they<br>
are not given explicitly via the *V* argument.<br>
<br>
*extend*: [ 'neither' | 'both' | 'min' | 'max' ]<br>
Unless this is 'neither', contour levels are automatically<br>
added to one or both ends of the range so that all data<br>
are included. These added ranges are then mapped to the<br>
special colormap values which default to the ends of the<br>
colormap range, but can be set via<br>
:meth:`matplotlib.cm.Colormap.set_under` and<br>
:meth:`matplotlib.cm.Colormap.set_over` methods.<br>
<br>
contour-only keyword arguments:<br>
<br>
*linewidths*: [ None | number | tuple of numbers ]<br>
If *linewidths* is *None*, the default width in<br>
``lines.linewidth`` in ``matplotlibrc`` is used<br>
<br>
If a number, all levels will be plotted with this linewidth.<br>
<br>
If a tuple, different levels will be plotted with different<br>
linewidths in the order specified<br>
<br>
contourf-only keyword arguments:<br>
<br>
*antialiased*: [ True | False ]<br>
enable antialiasing<br>
<br>
*nchunk*: [ 0 | integer ]<br>
If 0, no subdivision of the domain. Specify a positive integer to<br>
divide the domain into subdomains of roughly *nchunk* by *nchunk*<br>
points. This may never actually be advantageous, so this option may<br>
be removed. Chunking introduces artifacts at the chunk boundaries<br>
unless *antialiased* is *False*.<br>
<br>
**Example:**<br>
<br>
.. plot:: contour_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-cool"><strong>cool</strong></a>()</dt><dd><tt>Set the default colormap to cool and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-copper"><strong>copper</strong></a>()</dt><dd><tt>Set the default colormap to copper and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-csd"><strong>csd</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-csd">csd</a>(x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,<br>
window=window_hanning, noverlap=0, **kwargs)<br>
<br>
The cross spectral density :math:`P_{xy}` by Welches average<br>
periodogram method. The vectors *x* and *y* are divided into<br>
*NFFT* length segments. Each segment is detrended by function<br>
*detrend* and windowed by function *window*. The product of<br>
the direct FFTs of *x* and *y* are averaged over each segment<br>
to compute :math:`P_{xy}`, with a scaling to correct for power<br>
loss due to windowing.<br>
<br>
See :meth:`psd` for a description of the optional parameters.<br>
<br>
Returns the tuple (*Pxy*, *freqs*). *P* is the cross spectrum<br>
(complex valued), and :math:`10\log_{10}|P_{xy}|` is<br>
plotted.<br>
<br>
References:<br>
Bendat & Piersol -- Random Data: Analysis and Measurement<br>
Procedures, John Wiley & Sons (1986)<br>
<br>
kwargs control the Line2D properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/csd_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-delaxes"><strong>delaxes</strong></a>(*args)</dt><dd><tt>``<a href="#-delaxes">delaxes</a>(ax)``: remove *ax* from the current figure. If *ax*<br>
doesn't exist, an error will be raised.<br>
<br>
``<a href="#-delaxes">delaxes</a>()``: delete the current axes</tt></dd></dl>
<dl><dt><a name="-disconnect"><strong>disconnect</strong></a>(cid)</dt><dd><tt>disconnect callback id cid<br>
<br>
Example usage::<br>
<br>
cid = canvas.mpl_connect('button_press_event', on_press)<br>
#...later<br>
canvas.mpl_disconnect(cid)</tt></dd></dl>
<dl><dt><a name="-draw"><strong>draw</strong></a>()</dt><dd><tt>redraw the current figure</tt></dd></dl>
<dl><dt><a name="-errorbar"><strong>errorbar</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-errorbar">errorbar</a>(x, y, yerr=None, xerr=None,<br>
fmt='-', ecolor=None, elinewidth=None, capsize=3,<br>
barsabove=False, lolims=False, uplims=False,<br>
xlolims=False, xuplims=False)<br>
<br>
Plot *x* versus *y* with error deltas in *yerr* and *xerr*.<br>
Vertical errorbars are plotted if *yerr* is not *None*.<br>
Horizontal errorbars are plotted if *xerr* is not *None*.<br>
<br>
*x*, *y*, *xerr*, and *yerr* can all be scalars, which plots a<br>
single error bar at *x*, *y*.<br>
<br>
Optional keyword arguments:<br>
<br>
*xerr*/*yerr*: [ scalar | N, Nx1, Nx2 array-like ]<br>
If a scalar number, len(N) array-like object, or an Nx1 array-like<br>
object, errorbars are drawn +/- value.<br>
<br>
If a rank-1, Nx2 Numpy array, errorbars are drawn at -column1 and<br>
+column2<br>
<br>
*fmt*: '-'<br>
The plot format symbol for *y*. If *fmt* is *None*, just plot the<br>
errorbars with no line symbols. This can be useful for creating a<br>
bar plot with errorbars.<br>
<br>
*ecolor*: [ None | mpl color ]<br>
a matplotlib color arg which gives the color the errorbar lines; if<br>
*None*, use the marker color.<br>
<br>
*elinewidth*: scalar<br>
the linewidth of the errorbar lines. If *None*, use the linewidth.<br>
<br>
*capsize*: scalar<br>
the size of the error bar caps in points<br>
<br>
*barsabove*: [ True | False ]<br>
if *True*, will plot the errorbars above the plot<br>
symbols. Default is below.<br>
<br>
*lolims*/*uplims*/*xlolims*/*xuplims*: [ False | True ]<br>
These arguments can be used to indicate that a value gives<br>
only upper/lower limits. In that case a caret symbol is<br>
used to indicate this. lims-arguments may be of the same<br>
type as *xerr* and *yerr*.<br>
<br>
All other keyword arguments are passed on to the plot command for the<br>
markers, so you can add additional key=value pairs to control the<br>
errorbar markers. For example, this code makes big red squares with<br>
thick green edges::<br>
<br>
x,y,yerr = rand(3,10)<br>
<a href="#-errorbar">errorbar</a>(x, y, yerr, marker='s',<br>
mfc='red', mec='green', ms=20, mew=4)<br>
<br>
where *mfc*, *mec*, *ms* and *mew* are aliases for the longer<br>
property names, *markerfacecolor*, *markeredgecolor*, *markersize*<br>
and *markeredgewith*.<br>
<br>
valid kwargs for the marker properties are<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
Return value is a length 3 tuple. The first element is the<br>
:class:`~matplotlib.lines.Line2D` instance for the *y* symbol<br>
lines. The second element is a list of error bar cap lines,<br>
the third element is a list of<br>
:class:`~matplotlib.collections.LineCollection` instances for<br>
the horizontal and vertical error ranges.<br>
<br>
**Example:**<br>
<br>
.. plot:: errorbar_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-figimage"><strong>figimage</strong></a>(*args, **kwargs)</dt><dd><tt>call signatures::<br>
<br>
<a href="#-figimage">figimage</a>(X, **kwargs)<br>
<br>
adds a non-resampled array *X* to the figure.<br>
<br>
::<br>
<br>
<a href="#-figimage">figimage</a>(X, xo, yo)<br>
<br>
with pixel offsets *xo*, *yo*,<br>
<br>
*X* must be a float array:<br>
<br>
* If *X* is MxN, assume luminance (grayscale)<br>
* If *X* is MxNx3, assume RGB<br>
* If *X* is MxNx4, assume RGBA<br>
<br>
Optional keyword arguments:<br>
<br>
========= ==========================================================<br>
Keyword Description<br>
========= ==========================================================<br>
xo or yo An integer, the *x* and *y* image offset in pixels<br>
cmap a :class:`matplotlib.cm.ColorMap` instance, eg cm.jet.<br>
If None, default to the rc ``image.cmap`` value<br>
norm a :class:`matplotlib.colors.Normalize` instance. The<br>
default is normalization(). This scales luminance -> 0-1<br>
vmin|vmax are used to scale a luminance image to 0-1. If either is<br>
None, the min and max of the luminance values will be<br>
used. Note if you pass a norm instance, the settings for<br>
*vmin* and *vmax* will be ignored.<br>
alpha the alpha blending value, default is 1.0<br>
origin [ 'upper' | 'lower' ] Indicates where the [0,0] index of<br>
the array is in the upper left or lower left corner of<br>
the axes. Defaults to the rc image.origin value<br>
========= ==========================================================<br>
<br>
figimage complements the axes image<br>
(:meth:`~matplotlib.axes.Axes.imshow`) which will be resampled<br>
to fit the current axes. If you want a resampled image to<br>
fill the entire figure, you can define an<br>
:class:`~matplotlib.axes.Axes` with size [0,1,0,1].<br>
<br>
An :class:`matplotlib.image.FigureImage` instance is returned.<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/figimage_demo.py<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-figlegend"><strong>figlegend</strong></a>(handles, labels, loc, **kwargs)</dt><dd><tt>Place a legend in the figure.<br>
<br>
*labels*<br>
a sequence of strings<br>
<br>
*handles*<br>
a sequence of :class:`~matplotlib.lines.Line2D` or<br>
:class:`~matplotlib.patches.Patch` instances<br>
<br>
*loc*<br>
can be a string or an integer specifying the legend<br>
location<br>
<br>
Example::<br>
<br>
<a href="#-figlegend">figlegend</a>( (line1, line2, line3),<br>
('label1', 'label2', 'label3'),<br>
'upper right' )<br>
<br>
See :func:`~matplotlib.pyplot.legend` for information about the<br>
location codes<br>
<br>
A :class:`matplotlib.legend.Legend` instance is returned.</tt></dd></dl>
<dl><dt><a name="-figtext"><strong>figtext</strong></a>(*args, **kwargs)</dt><dd><tt>Call signature::<br>
<br>
<a href="#-figtext">figtext</a>(x, y, s, fontdict=None, **kwargs)<br>
<br>
Add text to figure at location *x*, *y* (relative 0-1<br>
coords). See :func:`~matplotlib.pyplot.text` for the meaning<br>
of the other arguments.<br>
<br>
kwargs control the :class:`~matplotlib.text.Text` properties:<br>
<br>
<br>
========================= =====================================================================<br>
Property Description <br>
========================= =====================================================================<br>
alpha float <br>
animated [True | False] <br>
axes an axes instance <br>
backgroundcolor any matplotlib color <br>
bbox rectangle prop dict plus key 'pad' which is a pad in points <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color any matplotlib color <br>
contains unknown <br>
family [ 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ] <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fontproperties a matplotlib.font_manager.FontProperties instance <br>
horizontalalignment or ha [ 'center' | 'right' | 'left' ] <br>
label any string <br>
linespacing float <br>
lod [True | False] <br>
multialignment ['left' | 'right' | 'center' ] <br>
name or fontname string eg, ['Sans' | 'Courier' | 'Helvetica' ...] <br>
picker [None|float|boolean|callable] <br>
position (x,y) <br>
rotation [ angle in degrees 'vertical' | 'horizontal' <br>
size or fontsize [ size in points | relative size eg 'smaller', 'x-large' ] <br>
style or fontstyle [ 'normal' | 'italic' | 'oblique'] <br>
text string or anything printable with '%s' conversion <br>
transform unknown <br>
variant [ 'normal' | 'small-caps' ] <br>
verticalalignment or va [ 'center' | 'top' | 'bottom' | 'baseline' ] <br>
visible [True | False] <br>
weight or fontweight [ 'normal' | 'bold' | 'heavy' | 'light' | 'ultrabold' | 'ultralight']<br>
x float <br>
y float <br>
zorder any number <br>
========================= =====================================================================</tt></dd></dl>
<dl><dt><a name="-figure"><strong>figure</strong></a>(num<font color="#909090">=None</font>, figsize<font color="#909090">=None</font>, dpi<font color="#909090">=None</font>, facecolor<font color="#909090">=None</font>, edgecolor<font color="#909090">=None</font>, frameon<font color="#909090">=True</font>, FigureClass<font color="#909090">=<class 'matplotlib.figure.Figure'></font>, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-figure">figure</a>(num = None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')<br>
<br>
<br>
Create a new figure and return a :class:`matplotlib.figure.Figure`<br>
instance. If *num* = *None*, the figure number will be incremented and<br>
a new figure will be created. The returned figure objects have a<br>
*number* attribute holding this number.<br>
<br>
If *num* is an integer, and ``<a href="#-figure">figure</a>(num)`` already exists, make it<br>
active and return the handle to it. If ``<a href="#-figure">figure</a>(num)`` does not exist<br>
it will be created. Numbering starts at 1, matlab style::<br>
<br>
<a href="#-figure">figure</a>(1)<br>
<br>
If you are creating many figures, make sure you explicitly call "close"<br>
on the figures you are not using, because this will enable pylab<br>
to properly clean up the memory.<br>
<br>
Optional keyword arguments:<br>
<br>
========= =======================================================<br>
Keyword Description<br>
========= =======================================================<br>
figsize width x height in inches; defaults to rc figure.figsize<br>
dpi resolution; defaults to rc figure.dpi<br>
facecolor the background color; defaults to rc figure.facecolor<br>
edgecolor the border color; defaults to rc figure.edgecolor<br>
========= =======================================================<br>
<br>
rcParams defines the default values, which can be modified in the<br>
matplotlibrc file<br>
<br>
*FigureClass* is a :class:`~matplotlib.figure.Figure` or derived<br>
class that will be passed on to :meth:`new_figure_manager` in the<br>
backends which allows you to hook custom Figure classes into the<br>
pylab interface. Additional kwargs will be passed on to your<br>
figure init function.</tt></dd></dl>
<dl><dt><a name="-fill"><strong>fill</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-fill">fill</a>(*args, **kwargs)<br>
<br>
Plot filled polygons. *args* is a variable length argument,<br>
allowing for multiple *x*, *y* pairs with an optional color<br>
format string; see :func:`~matplotlib.pyplot.plot` for details<br>
on the argument parsing. For example, to plot a polygon with<br>
vertices at *x*, *y* in blue.::<br>
<br>
ax.<a href="#-fill">fill</a>(x,y, 'b' )<br>
<br>
An arbitrary number of *x*, *y*, *color* groups can be specified::<br>
<br>
ax.<a href="#-fill">fill</a>(x1, y1, 'g', x2, y2, 'r')<br>
<br>
Return value is a list of :class:`~matplotlib.patches.Patch`<br>
instances that were added.<br>
<br>
The same color strings that :func:`~matplotlib.pyplot.plot`<br>
supports are supported by the fill format string.<br>
<br>
If you would like to fill below a curve, eg. shade a region<br>
between 0 and *y* along *x*, use<br>
:func:`~matplotlib.pylab.poly_between`, eg.::<br>
<br>
xs, ys = poly_between(x, 0, y)<br>
axes.<a href="#-fill">fill</a>(xs, ys, facecolor='red', alpha=0.5)<br>
<br>
See :file:`examples/pylab_examples/fill_between.py` for more examples.<br>
<br>
The *closed* kwarg will close the polygon when *True* (default).<br>
<br>
kwargs control the Polygon properties:<br>
<br>
<br>
=========== ===========================================================<br>
Property Description <br>
=========== ===========================================================<br>
aa [True | False] or None for default <br>
alpha float <br>
animated [True | False] <br>
antialiased [True | False] or None for default <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
contains unknown <br>
ec mpl color spec, or None for default, or 'none' for no color<br>
edgecolor mpl color spec, or None for default, or 'none' for no color<br>
facecolor mpl color spec, or None for default, or 'none' for no color<br>
fc mpl color spec, or None for default, or 'none' for no color<br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fill [True | False] <br>
hatch unknown <br>
label any string <br>
linestyle ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
linewidth float or None for default <br>
lod [True | False] <br>
ls ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
lw float or None for default <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
=========== ===========================================================<br>
<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/fill_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-findobj"><strong>findobj</strong></a>(o<font color="#909090">=None</font>, match<font color="#909090">=None</font>)</dt><dd><tt>pyplot signature:<br>
<a href="#-findobj">findobj</a>(o=<a href="#-gcf">gcf</a>(), match=None) <br>
<br>
recursively find all :class:matplotlib.artist.Artist instances<br>
contained in self<br>
<br>
*match* can be<br>
<br>
- None: return all objects contained in artist (including artist)<br>
<br>
- function with signature ``boolean = match(artist)`` used to filter matches<br>
<br>
- class instance: eg Line2D. Only return artists of class type<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/findobj_demo.py</tt></dd></dl>
<dl><dt><a name="-flag"><strong>flag</strong></a>()</dt><dd><tt>Set the default colormap to flag and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-gca"><strong>gca</strong></a>(**kwargs)</dt><dd><tt>Return the current axis instance. This can be used to control<br>
axis properties either using set or the<br>
:class:`~matplotlib.axes.Axes` methods, for example, setting the<br>
xaxis range::<br>
<br>
<a href="#-plot">plot</a>(t,s)<br>
set(<a href="#-gca">gca</a>(), 'xlim', [0,10])<br>
<br>
or::<br>
<br>
<a href="#-plot">plot</a>(t,s)<br>
a = <a href="#-gca">gca</a>()<br>
a.set_xlim([0,10])</tt></dd></dl>
<dl><dt><a name="-gcf"><strong>gcf</strong></a>()</dt><dd><tt>Return a handle to the current figure.</tt></dd></dl>
<dl><dt><a name="-gci"><strong>gci</strong></a>()</dt><dd><tt>Get the current :class:`~matplotlib.cm.ScalarMappable` instance<br>
(image or patch collection), or *None* if no images or patch<br>
collections have been defined. The commands<br>
:func:`~matplotlib.pyplot.imshow` and<br>
:func:`~matplotlib.pyplot.figimage` create<br>
:class:`~matplotlib.image.Image` instances, and the commands<br>
:func:`~matplotlib.pyplot.pcolor` and<br>
:func:`~matplotlib.pyplot.scatter` create<br>
:class:`~matplotlib.collections.Collection` instances.</tt></dd></dl>
<dl><dt><a name="-get_current_fig_manager"><strong>get_current_fig_manager</strong></a>()</dt></dl>
<dl><dt><a name="-get_plot_commands"><strong>get_plot_commands</strong></a>()</dt></dl>
<dl><dt><a name="-ginput"><strong>ginput</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-ginput">ginput</a>(self, n=1, timeout=30, show_clicks=True)<br>
<br>
Blocking call to interact with the figure.<br>
<br>
This will wait for *n* clicks from the user and return a list of the<br>
coordinates of each click.<br>
<br>
If *timeout* is negative, does not timeout.<br>
<br>
If *n* is negative, accumulate clicks until a middle click<br>
terminates the input.<br>
<br>
Right clicking cancels last input.</tt></dd></dl>
<dl><dt><a name="-gray"><strong>gray</strong></a>()</dt><dd><tt>Set the default colormap to gray and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-grid"><strong>grid</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-grid">grid</a>(self, b=None, **kwargs)<br>
<br>
Set the axes grids on or off; *b* is a boolean<br>
<br>
If *b* is *None* and ``len(kwargs)==0``, toggle the grid state. If<br>
*kwargs* are supplied, it is assumed that you want a grid and *b*<br>
is thus set to *True*<br>
<br>
*kawrgs* are used to set the grid line properties, eg::<br>
<br>
ax.<a href="#-grid">grid</a>(color='r', linestyle='-', linewidth=2)<br>
<br>
Valid :class:`~matplotlib.lines.Line2D` kwargs are<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================</tt></dd></dl>
<dl><dt><a name="-hexbin"><strong>hexbin</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-hexbin">hexbin</a>(x, y, C = None, gridsize = 100, bins = None,<br>
xscale = 'linear', yscale = 'linear',<br>
cmap=None, norm=None, vmin=None, vmax=None,<br>
alpha=1.0, linewidths=None, edgecolors='none'<br>
reduce_C_function = np.mean,<br>
**kwargs)<br>
<br>
Make a hexagonal binning plot of *x* versus *y*, where *x*,<br>
*y* are 1-D sequences of the same length, *N*. If *C* is None<br>
(the default), this is a histogram of the number of occurences<br>
of the observations at (x[i],y[i]).<br>
<br>
If *C* is specified, it specifies values at the coordinate<br>
(x[i],y[i]). These values are accumulated for each hexagonal<br>
bin and then reduced according to *reduce_C_function*, which<br>
defaults to numpy's mean function (np.mean). (If *C* is<br>
specified, it must also be a 1-D sequence of the same length<br>
as *x* and *y*.)<br>
<br>
*x*, *y* and/or *C* may be masked arrays, in which case only<br>
unmasked points will be plotted.<br>
<br>
Optional keyword arguments:<br>
<br>
*gridsize*: [ 100 | integer ]<br>
The number of hexagons in the *x*-direction, default is<br>
100. The corresponding number of hexagons in the<br>
*y*-direction is chosen such that the hexagons are<br>
approximately regular. Alternatively, gridsize can be a<br>
tuple with two elements specifying the number of hexagons<br>
in the *x*-direction and the *y*-direction.<br>
<br>
*bins*: [ None | 'log' | integer | sequence ]<br>
If *None*, no binning is applied; the color of each hexagon<br>
directly corresponds to its count value.<br>
<br>
If 'log', use a logarithmic scale for the color<br>
map. Internally, :math:`log_{10}(i+1)` is used to<br>
determine the hexagon color.<br>
<br>
If an integer, divide the counts in the specified number<br>
of bins, and color the hexagons accordingly.<br>
<br>
If a sequence of values, the values of the lower bound of<br>
the bins to be used.<br>
<br>
*xscale*: [ 'linear' | 'log' ]<br>
Use a linear or log10 scale on the horizontal axis.<br>
<br>
*scale*: [ 'linear' | 'log' ]<br>
Use a linear or log10 scale on the vertical axis.<br>
<br>
Other keyword arguments controlling color mapping and normalization<br>
arguments:<br>
<br>
*cmap*: [ None | Colormap ]<br>
a :class:`matplotlib.cm.Colormap` instance. If *None*,<br>
defaults to rc ``image.cmap``.<br>
<br>
*norm*: [ None | Normalize ]<br>
:class:`matplotlib.colors.Normalize` instance is used to<br>
scale luminance data to 0,1.<br>
<br>
*vmin*/*vmax*: scalar<br>
*vmin* and *vmax* are used in conjunction with *norm* to normalize<br>
luminance data. If either are *None*, the min and max of the color<br>
array *C* is used. Note if you pass a norm instance, your settings<br>
for *vmin* and *vmax* will be ignored.<br>
<br>
*alpha*: scalar<br>
the alpha value for the patches<br>
<br>
*linewidths*: [ None | scalar ]<br>
If *None*, defaults to rc lines.linewidth. Note that this<br>
is a tuple, and if you set the linewidths argument you<br>
must set it as a sequence of floats, as required by<br>
:class:`~matplotlib.collections.RegularPolyCollection`.<br>
<br>
Other keyword arguments controlling the Collection properties:<br>
<br>
*edgecolors*: [ None | mpl color | color sequence ]<br>
If 'none', draws the edges in the same color as the fill color.<br>
This is the default, as it avoids unsightly unpainted pixels<br>
between the hexagons.<br>
<br>
If *None*, draws the outlines in the default color.<br>
<br>
If a matplotlib color arg or sequence of rgba tuples, draws the<br>
outlines in the specified color.<br>
<br>
Here are the standard descriptions of all the<br>
:class:`~matplotlib.collections.Collection` kwargs:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
The return value is a<br>
:class:`~matplotlib.collections.PolyCollection` instance; use<br>
:meth:`~matplotlib.collection.PolyCollection.get_array` on<br>
this :class:`~matplotlib.collections.PolyCollection` to get<br>
the counts in each hexagon.<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/hexbin_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-hist"><strong>hist</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-hist">hist</a>(x, bins=10, range=None, normed=False, cumulative=False,<br>
bottom=None, histtype='bar', align='mid',<br>
orientation='vertical', rwidth=None, log=False, **kwargs)<br>
<br>
Compute the histogram of *x*. The return value is a tuple<br>
(*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*,<br>
[*patches0*, *patches1*,...]) if the input contains multiple<br>
data.<br>
<br>
Keyword arguments:<br>
<br>
*bins*:<br>
either an integer number of bins or a sequence giving the<br>
bins. *x* are the data to be binned. *x* can be an array or a<br>
2D array with multiple data in its columns. Note, if *bins*<br>
is an integer input argument=numbins, *bins* + 1 bin edges<br>
will be returned, compatible with the semantics of<br>
:func:`numpy.histogram` with the *new* = True argument.<br>
Unequally spaced bins are supported if *bins* is a sequence.<br>
<br>
*range*:<br>
The lower and upper range of the bins. Lower and upper outliers<br>
are ignored. If not provided, *range* is (x.min(), x.max()).<br>
Range has no effect if *bins* is a sequence.<br>
<br>
*normed*:<br>
If *True*, the first element of the return tuple will<br>
be the counts normalized to form a probability density, i.e.,<br>
``n/(len(x)*dbin)``. In a probability density, the integral of<br>
the histogram should be 1; you can verify that with a<br>
trapezoidal integration of the probability density function::<br>
<br>
pdf, bins, patches = ax.<a href="#-hist">hist</a>(...)<br>
print np.sum(pdf * np.diff(bins))<br>
<br>
*cumulative*:<br>
If *True*, then a histogram is computed where each bin<br>
gives the counts in that bin plus all bins for smaller values.<br>
The last bin gives the total number of datapoints. If *normed*<br>
is also *True* then the histogram is normalized such that the<br>
last bin equals one. If *cumulative* evaluates to less than 0<br>
(e.g. -1), the direction of accumulation is reversed. In this<br>
case, if *normed* is also *True*, then the histogram is normalized<br>
such that the first bin equals 1.<br>
<br>
*histtype*: [ 'bar' | 'barstacked' | 'step' | 'stepfilled' ]<br>
The type of histogram to draw.<br>
<br>
- 'bar' is a traditional bar-type histogram<br>
<br>
- 'barstacked' is a bar-type histogram where multiple<br>
data are stacked on top of each other.<br>
<br>
- 'step' generates a lineplot that is by default<br>
unfilled<br>
<br>
- 'stepfilled' generates a lineplot that this by default<br>
filled.<br>
<br>
*align*: ['left' | 'mid' | 'right' ]<br>
Controls how the histogram is plotted.<br>
<br>
- 'left': bars are centered on the left bin edges<br>
<br>
- 'mid': bars are centered between the bin edges<br>
<br>
- 'right': bars are centered on the right bin edges.<br>
<br>
*orientation*: [ 'horizontal' | 'vertical' ]<br>
If 'horizontal', :func:`~matplotlib.pyplot.barh` will be<br>
used for bar-type histograms and the *bottom* kwarg will be<br>
the left edges.<br>
<br>
*rwidth*:<br>
the relative width of the bars as a fraction of the bin<br>
width. If *None*, automatically compute the width. Ignored<br>
if *histtype* = 'step'.<br>
<br>
*log*:<br>
If *True*, the histogram axis will be set to a log scale.<br>
If *log* is *True* and *x* is a 1D array, empty bins will<br>
be filtered out and only the non-empty (*n*, *bins*,<br>
*patches*) will be returned.<br>
<br>
kwargs are used to update the properties of the hist<br>
:class:`~matplotlib.patches.Rectangle` instances:<br>
<br>
<br>
=========== ===========================================================<br>
Property Description <br>
=========== ===========================================================<br>
aa [True | False] or None for default <br>
alpha float <br>
animated [True | False] <br>
antialiased [True | False] or None for default <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
contains unknown <br>
ec mpl color spec, or None for default, or 'none' for no color<br>
edgecolor mpl color spec, or None for default, or 'none' for no color<br>
facecolor mpl color spec, or None for default, or 'none' for no color<br>
fc mpl color spec, or None for default, or 'none' for no color<br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fill [True | False] <br>
hatch unknown <br>
label any string <br>
linestyle ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
linewidth float or None for default <br>
lod [True | False] <br>
ls ['solid' | 'dashed' | 'dashdot' | 'dotted'] <br>
lw float or None for default <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
=========== ===========================================================<br>
<br>
<br>
You can use labels for your histogram, and only the first<br>
:class:`~matplotlib.patches.Rectangle` gets the label (the<br>
others get the magic string '_nolegend_'. This will make the<br>
histograms work in the intuitive way for bar charts::<br>
<br>
ax.<a href="#-hist">hist</a>(10+2*np.random.randn(1000), label='men')<br>
ax.<a href="#-hist">hist</a>(12+3*np.random.randn(1000), label='women', alpha=0.5)<br>
ax.<a href="#-legend">legend</a>()<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/histogram_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-hlines"><strong>hlines</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-hlines">hlines</a>(y, xmin, xmax, colors='k', linestyle='solid', **kwargs)<br>
<br>
Plot horizontal lines at each *y* from *xmin* to *xmax*.<br>
<br>
Returns the :class:`~matplotlib.collections.LineCollection`<br>
that was added.<br>
<br>
Required arguments:<br>
<br>
*y*:<br>
a 1-D numpy array or iterable.<br>
<br>
*xmin* and *xmax*:<br>
can be scalars or ``len(x)`` numpy arrays. If they are<br>
scalars, then the respective values are constant, else the<br>
widths of the lines are determined by *xmin* and *xmax*.<br>
<br>
Optional keyword arguments:<br>
<br>
*colors*:<br>
a line collections color argument, either a single color<br>
or a ``len(y)`` list of colors<br>
<br>
*linestyle*:<br>
[ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/hline_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-hold"><strong>hold</strong></a>(b<font color="#909090">=None</font>)</dt><dd><tt>Set the hold state. If *b* is None (default), toggle the<br>
hold state, else set the hold state to boolean value *b*::<br>
<br>
<a href="#-hold">hold</a>() # toggle hold<br>
<a href="#-hold">hold</a>(True) # hold is on<br>
<a href="#-hold">hold</a>(False) # hold is off<br>
<br>
When *hold* is *True*, subsequent plot commands will be added to<br>
the current axes. When *hold* is *False*, the current axes and<br>
figure will be cleared on the next plot command.</tt></dd></dl>
<dl><dt><a name="-hot"><strong>hot</strong></a>()</dt><dd><tt>Set the default colormap to hot and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-hsv"><strong>hsv</strong></a>()</dt><dd><tt>Set the default colormap to hsv and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-imread"><strong>imread</strong></a>(*args, **kwargs)</dt><dd><tt>Return image file in *fname* as :class:`numpy.array`.<br>
<br>
Return value is a :class:`numpy.array`. For grayscale images, the<br>
return array is MxN. For RGB images, the return value is MxNx3.<br>
For RGBA images the return value is MxNx4.<br>
<br>
matplotlib can only read PNGs natively, but if `PIL<br>
<<a href="http://www.pythonware.com/products/pil/>`_">http://www.pythonware.com/products/pil/>`_</a> is installed, it will<br>
use it to load the image and return an array (if possible) which<br>
can be used with :func:`~matplotlib.pyplot.imshow`.<br>
<br>
TODO: support RGB and grayscale return values in _image.readpng</tt></dd></dl>
<dl><dt><a name="-imshow"><strong>imshow</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-imshow">imshow</a>(X, cmap=None, norm=None, aspect=None, interpolation=None,<br>
alpha=1.0, vmin=None, vmax=None, origin=None, extent=None,<br>
**kwargs)<br>
<br>
Display the image in *X* to current axes. *X* may be a float<br>
array, a uint8 array or a PIL image. If *X* is an array, *X*<br>
can have the following shapes:<br>
<br>
* MxN -- luminance (grayscale, float array only)<br>
* MxNx3 -- RGB (float or uint8 array)<br>
* MxNx4 -- RGBA (float or uint8 array)<br>
<br>
The value for each component of MxNx3 and MxNx4 float arrays should be<br>
in the range 0.0 to 1.0; MxN float arrays may be normalised.<br>
<br>
An :class:`matplotlib.image.AxesImage` instance is returned.<br>
<br>
Keyword arguments:<br>
<br>
*cmap*: [ None | Colormap ]<br>
A :class:`matplotlib.cm.Colormap` instance, eg. cm.jet.<br>
If *None*, default to rc ``image.cmap`` value.<br>
<br>
*cmap* is ignored when *X* has RGB(A) information<br>
<br>
*aspect*: [ None | 'auto' | 'equal' | scalar ]<br>
If 'auto', changes the image aspect ratio to match that of the axes<br>
<br>
If 'equal', and *extent* is *None*, changes the axes<br>
aspect ratio to match that of the image. If *extent* is<br>
not *None*, the axes aspect ratio is changed to match that<br>
of the extent.<br>
<br>
If *None*, default to rc ``image.aspect`` value.<br>
<br>
*interpolation*:<br>
Acceptable values are *None*, 'nearest', 'bilinear', 'bicubic',<br>
'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser',<br>
'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc',<br>
'lanczos', 'blackman'<br>
<br>
If *interpolation* is *None*, default to rc<br>
``image.interpolation``. See also the *filternorm* and<br>
*filterrad* parameters<br>
<br>
*norm*: [ None | Normalize ]<br>
An :class:`matplotlib.colors.Normalize` instance; if<br>
*None*, default is ``normalization()``. This scales<br>
luminance -> 0-1<br>
<br>
*norm* is only used for an MxN float array.<br>
<br>
*vmin*/*vmax*: [ None | scalar ]<br>
Used to scale a luminance image to 0-1. If either is<br>
*None*, the min and max of the luminance values will be<br>
used. Note if *norm* is not *None*, the settings for<br>
*vmin* and *vmax* will be ignored.<br>
<br>
*alpha*: scalar<br>
The alpha blending value, between 0 (transparent) and 1 (opaque)<br>
<br>
*origin*: [ None | 'upper' | 'lower' ]<br>
Place the [0,0] index of the array in the upper left or lower left<br>
corner of the axes. If *None*, default to rc ``image.origin``.<br>
<br>
*extent*: [ None | scalars (left, right, bottom, top) ]<br>
Eata values of the axes. The default assigns zero-based row,<br>
column indices to the *x*, *y* centers of the pixels.<br>
<br>
*shape*: [ None | scalars (columns, rows) ]<br>
For raw buffer images<br>
<br>
*filternorm*:<br>
A parameter for the antigrain image resize filter. From the<br>
antigrain documentation, if *filternorm* = 1, the filter normalizes<br>
integer values and corrects the rounding errors. It doesn't do<br>
anything with the source floating point values, it corrects only<br>
integers according to the rule of 1.0 which means that any sum of<br>
pixel weights must be equal to 1.0. So, the filter function must<br>
produce a graph of the proper shape.<br>
<br>
*filterrad*:<br>
The filter radius for filters that have a radius<br>
parameter, i.e. when interpolation is one of: 'sinc',<br>
'lanczos' or 'blackman'<br>
<br>
Additional kwargs are :class:`~matplotlib.artist.Artist` properties:<br>
<br>
<br>
========= ===============================================<br>
Property Description <br>
========= ===============================================<br>
alpha float <br>
animated [True | False] <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a<br>
contains unknown <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
lod [True | False] <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
========= ===============================================<br>
<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/image_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-ioff"><strong>ioff</strong></a>()</dt><dd><tt>Turn interactive mode off.</tt></dd></dl>
<dl><dt><a name="-ion"><strong>ion</strong></a>()</dt><dd><tt>Turn interactive mode on.</tt></dd></dl>
<dl><dt><a name="-ishold"><strong>ishold</strong></a>()</dt><dd><tt>Return the hold status of the current axes</tt></dd></dl>
<dl><dt><a name="-isinteractive"><strong>isinteractive</strong></a>()</dt><dd><tt>Return the interactive status</tt></dd></dl>
<dl><dt><a name="-jet"><strong>jet</strong></a>()</dt><dd><tt>Set the default colormap to jet and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-legend"><strong>legend</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-legend">legend</a>(*args, **kwargs)<br>
<br>
Place a legend on the current axes at location *loc*. Labels are a<br>
sequence of strings and *loc* can be a string or an integer specifying<br>
the legend location.<br>
<br>
To make a legend with existing lines::<br>
<br>
<a href="#-legend">legend</a>()<br>
<br>
:meth:`legend` by itself will try and build a legend using the label<br>
property of the lines/patches/collections. You can set the label of<br>
a line by doing::<br>
<br>
<a href="#-plot">plot</a>(x, y, label='my data')<br>
<br>
or::<br>
<br>
line.set_label('my data').<br>
<br>
If label is set to '_nolegend_', the item will not be shown in<br>
legend.<br>
<br>
To automatically generate the legend from labels::<br>
<br>
<a href="#-legend">legend</a>( ('label1', 'label2', 'label3') )<br>
<br>
To make a legend for a list of lines and labels::<br>
<br>
<a href="#-legend">legend</a>( (line1, line2, line3), ('label1', 'label2', 'label3') )<br>
<br>
To make a legend at a given location, using a location argument::<br>
<br>
<a href="#-legend">legend</a>( ('label1', 'label2', 'label3'), loc='upper left')<br>
<br>
or::<br>
<br>
<a href="#-legend">legend</a>( (line1, line2, line3), ('label1', 'label2', 'label3'), loc=2)<br>
<br>
The location codes are<br>
<br>
=============== =============<br>
Location String Location Code<br>
=============== =============<br>
'best' 0<br>
'upper right' 1<br>
'upper left' 2<br>
'lower left' 3<br>
'lower right' 4<br>
'right' 5<br>
'center left' 6<br>
'center right' 7<br>
'lower center' 8<br>
'upper center' 9<br>
'center' 10<br>
=============== =============<br>
<br>
If none of these are locations are suitable, loc can be a 2-tuple<br>
giving x,y in axes coords, ie::<br>
<br>
loc = 0, 1 # left top<br>
loc = 0.5, 0.5 # center<br>
<br>
Keyword arguments:<br>
<br>
*isaxes*: [ True | False ]<br>
Indicates that this is an axes legend<br>
<br>
*numpoints*: integer<br>
The number of points in the legend line, default is 4<br>
<br>
*prop*: [ None | FontProperties ]<br>
A :class:`matplotlib.font_manager.FontProperties`<br>
instance, or *None* to use rc settings.<br>
<br>
*pad*: [ None | scalar ]<br>
The fractional whitespace inside the legend border, between 0 and 1.<br>
If *None*, use rc settings.<br>
<br>
*markerscale*: [ None | scalar ]<br>
The relative size of legend markers vs. original. If *None*, use rc<br>
settings.<br>
<br>
*shadow*: [ None | False | True ]<br>
If *True*, draw a shadow behind legend. If *None*, use rc settings.<br>
<br>
*labelsep*: [ None | scalar ]<br>
The vertical space between the legend entries. If *None*, use rc<br>
settings.<br>
<br>
*handlelen*: [ None | scalar ]<br>
The length of the legend lines. If *None*, use rc settings.<br>
<br>
*handletextsep*: [ None | scalar ]<br>
The space between the legend line and legend text. If *None*, use rc<br>
settings.<br>
<br>
*axespad*: [ None | scalar ]<br>
The border between the axes and legend edge. If *None*, use rc<br>
settings.<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/api/legend_demo.py</tt></dd></dl>
<dl><dt><a name="-loglog"><strong>loglog</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-loglog">loglog</a>(*args, **kwargs)<br>
<br>
Make a plot with log scaling on the *x* and *y* axis.<br>
<br>
:func:`~matplotlib.pyplot.loglog` supports all the keyword<br>
arguments of :func:`~matplotlib.pyplot.plot` and<br>
:meth:`matplotlib.axes.Axes.set_xscale`/:meth:`matplotlib.axes.Axes.set_yscale`.<br>
<br>
Notable keyword arguments:<br>
<br>
*basex*/*basey*: scalar > 1<br>
base of the *x*/*y* logarithm<br>
<br>
*subsx*/*subsy*: [ None | sequence ]<br>
the location of the minor *x*/*y* ticks; *None* defaults<br>
to autosubs, which depend on the number of decades in the<br>
plot; see<br>
:meth:`matplotlib.axes.Axes.set_xscale`/:meth:`matplotlib.axes.Axes.set_yscale`<br>
for details<br>
<br>
The remaining valid kwargs are<br>
:class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/log_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-matshow"><strong>matshow</strong></a>(A, fignum<font color="#909090">=None</font>, **kw)</dt><dd><tt>Display an array as a matrix in a new figure window.<br>
<br>
The origin is set at the upper left hand corner and rows (first<br>
dimension of the array) are displayed horizontally. The aspect<br>
ratio of the figure window is that of the array, unless this would<br>
make an excessively short or narrow figure.<br>
<br>
Tick labels for the xaxis are placed on top.<br>
<br>
With the exception of fignum, keyword arguments are passed to<br>
:func:`~matplotlib.pyplot.imshow`.<br>
<br>
<br>
*fignum*: [ None | integer | False ]<br>
By default, :func:`matshow` creates a new figure window with<br>
automatic numbering. If *fignum* is given as an integer, the<br>
created figure will use this figure number. Because of how<br>
:func:`matshow` tries to set the figure aspect ratio to be the<br>
one of the array, if you provide the number of an already<br>
existing figure, strange things may happen.<br>
<br>
If *fignum* is *False* or 0, a new figure window will **NOT** be created.</tt></dd></dl>
<dl><dt><a name="-over"><strong>over</strong></a>(func, *args, **kwargs)</dt><dd><tt>over calls::<br>
<br>
func(*args, **kwargs)<br>
<br>
with ``<a href="#-hold">hold</a>(True)`` and then restores the hold state.</tt></dd></dl>
<dl><dt><a name="-pcolor"><strong>pcolor</strong></a>(*args, **kwargs)</dt><dd><tt>call signatures::<br>
<br>
<a href="#-pcolor">pcolor</a>(C, **kwargs)<br>
<a href="#-pcolor">pcolor</a>(X, Y, C, **kwargs)<br>
<br>
Create a pseudocolor plot of a 2-D array.<br>
<br>
*C* is the array of color values.<br>
<br>
*X* and *Y*, if given, specify the (*x*, *y*) coordinates of<br>
the colored quadrilaterals; the quadrilateral for C[i,j] has<br>
corners at::<br>
<br>
(X[i, j], Y[i, j]),<br>
(X[i, j+1], Y[i, j+1]),<br>
(X[i+1, j], Y[i+1, j]),<br>
(X[i+1, j+1], Y[i+1, j+1]).<br>
<br>
Ideally the dimensions of *X* and *Y* should be one greater<br>
than those of *C*; if the dimensions are the same, then the<br>
last row and column of *C* will be ignored.<br>
<br>
Note that the the column index corresponds to the<br>
*x*-coordinate, and the row index corresponds to *y*; for<br>
details, see the :ref:`Grid Orientation<br>
<axes-pcolor-grid-orientation>` section below.<br>
<br>
If either or both of *X* and *Y* are 1-D arrays or column vectors,<br>
they will be expanded as needed into the appropriate 2-D arrays,<br>
making a rectangular grid.<br>
<br>
*X*, *Y* and *C* may be masked arrays. If either C[i, j], or one<br>
of the vertices surrounding C[i,j] (*X* or *Y* at [i, j], [i+1, j],<br>
[i, j+1],[i+1, j+1]) is masked, nothing is plotted.<br>
<br>
Keyword arguments:<br>
<br>
*cmap*: [ None | Colormap ]<br>
A :class:`matplotlib.cm.Colormap` instance. If *None*, use<br>
rc settings.<br>
<br>
norm: [ None | Normalize ]<br>
An :class:`matplotlib.colors.Normalize` instance is used<br>
to scale luminance data to 0,1. If *None*, defaults to<br>
:func:`normalize`.<br>
<br>
*vmin*/*vmax*: [ None | scalar ]<br>
*vmin* and *vmax* are used in conjunction with *norm* to<br>
normalize luminance data. If either are *None*, the min<br>
and max of the color array *C* is used. If you pass a<br>
*norm* instance, *vmin* and *vmax* will be ignored.<br>
<br>
*shading*: [ 'flat' | 'faceted' ]<br>
If 'faceted', a black grid is drawn around each rectangle; if<br>
'flat', edges are not drawn. Default is 'flat', contrary to<br>
Matlab(TM).<br>
<br>
This kwarg is deprecated; please use 'edgecolors' instead:<br>
* shading='flat' -- edgecolors='None'<br>
* shading='faceted -- edgecolors='k'<br>
<br>
*edgecolors*: [ None | 'None' | color | color sequence]<br>
If *None*, the rc setting is used by default.<br>
<br>
If 'None', edges will not be visible.<br>
<br>
An mpl color or sequence of colors will set the edge color<br>
<br>
*alpha*: 0 <= scalar <= 1<br>
the alpha blending value<br>
<br>
Return value is a :class:`matplotlib.collection.Collection`<br>
instance.<br>
<br>
.. _axes-pcolor-grid-orientation:<br>
<br>
The grid orientation follows the Matlab(TM) convention: an<br>
array *C* with shape (*nrows*, *ncolumns*) is plotted with<br>
the column number as *X* and the row number as *Y*, increasing<br>
up; hence it is plotted the way the array would be printed,<br>
except that the *Y* axis is reversed. That is, *C* is taken<br>
as *C*(*y*, *x*).<br>
<br>
Similarly for :func:`~matplotlib.pyplot.meshgrid`::<br>
<br>
x = np.arange(5)<br>
y = np.arange(3)<br>
X, Y = meshgrid(x,y)<br>
<br>
is equivalent to:<br>
<br>
X = array([[0, 1, 2, 3, 4],<br>
[0, 1, 2, 3, 4],<br>
[0, 1, 2, 3, 4]])<br>
<br>
Y = array([[0, 0, 0, 0, 0],<br>
[1, 1, 1, 1, 1],<br>
[2, 2, 2, 2, 2]])<br>
<br>
so if you have::<br>
<br>
C = rand( len(x), len(y))<br>
<br>
then you need::<br>
<br>
<a href="#-pcolor">pcolor</a>(X, Y, C.T)<br>
<br>
or::<br>
<br>
<a href="#-pcolor">pcolor</a>(C.T)<br>
<br>
Matlab :func:`pcolor` always discards the last row and column<br>
of *C*, but matplotlib displays the last row and column if *X* and<br>
*Y* are not specified, or if *X* and *Y* have one more row and<br>
column than *C*.<br>
<br>
kwargs can be used to control the<br>
:class:`~matplotlib.collection.PolyCollection` properties:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-pcolormesh"><strong>pcolormesh</strong></a>(*args, **kwargs)</dt><dd><tt>call signatures::<br>
<br>
<a href="#-pcolormesh">pcolormesh</a>(C)<br>
<a href="#-pcolormesh">pcolormesh</a>(X, Y, C)<br>
<a href="#-pcolormesh">pcolormesh</a>(C, **kwargs)<br>
<br>
*C* may be a masked array, but *X* and *Y* may not. Masked<br>
array support is implemented via *cmap* and *norm*; in<br>
contrast, :func:`~matplotlib.pyplot.pcolor` simply does not<br>
draw quadrilaterals with masked colors or vertices.<br>
<br>
Keyword arguments:<br>
<br>
*cmap*: [ None | Colormap ]<br>
A :class:`matplotlib.cm.Colormap` instance. If None, use<br>
rc settings.<br>
<br>
*norm*: [ None | Normalize ]<br>
A :class:`matplotlib.colors.Normalize` instance is used to<br>
scale luminance data to 0,1. If None, defaults to<br>
:func:`normalize`.<br>
<br>
*vmin*/*vmax*: [ None | scalar ]<br>
*vmin* and *vmax* are used in conjunction with *norm* to<br>
normalize luminance data. If either are *None*, the min<br>
and max of the color array *C* is used. If you pass a<br>
*norm* instance, *vmin* and *vmax* will be ignored.<br>
<br>
*shading*: [ 'flat' | 'faceted' ]<br>
If 'faceted', a black grid is drawn around each rectangle; if<br>
'flat', edges are not drawn. Default is 'flat', contrary to<br>
Matlab(TM).<br>
<br>
This kwarg is deprecated; please use 'edgecolors' instead:<br>
* shading='flat' -- edgecolors='None'<br>
* shading='faceted -- edgecolors='k'<br>
<br>
*edgecolors*: [ None | 'None' | color | color sequence]<br>
If None, the rc setting is used by default.<br>
<br>
If 'None', edges will not be visible.<br>
<br>
An mpl color or sequence of colors will set the edge color<br>
<br>
*alpha*: 0 <= scalar <= 1<br>
the alpha blending value<br>
<br>
Return value is a :class:`matplotlib.collection.QuadMesh`<br>
object.<br>
<br>
See :func:`~matplotlib.pyplot.pcolor` for an explanation of<br>
the grid orientation and the expansion of 1-D *X* and/or *Y*<br>
to 2-D arrays.<br>
<br>
kwargs can be used to control the<br>
:class:`matplotlib.collections.QuadMesh`<br>
properties:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-pie"><strong>pie</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-pie">pie</a>(x, explode=None, labels=None,<br>
colors=('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'),<br>
autopct=None, pctdistance=0.6, labeldistance=1.1, shadow=False)<br>
<br>
Make a pie chart of array *x*. The fractional area of each<br>
wedge is given by x/sum(x). If sum(x) <= 1, then the values<br>
of x give the fractional area directly and the array will not<br>
be normalized.<br>
<br>
Keyword arguments:<br>
<br>
*explode*: [ None | len(x) sequence ]<br>
If not *None*, is a len(*x*) array which specifies the<br>
fraction of the radius with which to offset each wedge.<br>
<br>
*colors*: [ None | color sequence ]<br>
A sequence of matplotlib color args through which the pie chart<br>
will cycle.<br>
<br>
*labels*: [ None | len(x) sequence of strings ]<br>
A sequence of strings providing the labels for each wedge<br>
<br>
*autopct*: [ None | format string | format function ]<br>
If not *None*, is a string or function used to label the<br>
wedges with their numeric value. The label will be placed inside<br>
the wedge. If it is a format string, the label will be ``fmt%pct``.<br>
If it is a function, it will be called.<br>
<br>
*pctdistance*: scalar<br>
The ratio between the center of each pie slice and the<br>
start of the text generated by *autopct*. Ignored if<br>
*autopct* is *None*; default is 0.6.<br>
<br>
*labeldistance*: scalar<br>
The radial distance at which the pie labels are drawn<br>
<br>
*shadow*: [ False | True ]<br>
Draw a shadow beneath the pie.<br>
<br>
The pie chart will probably look best if the figure and axes are<br>
square. Eg.::<br>
<br>
<a href="#-figure">figure</a>(figsize=(8,8))<br>
ax = <a href="#-axes">axes</a>([0.1, 0.1, 0.8, 0.8])<br>
<br>
Return value:<br>
If *autopct* is None, return the tuple (*patches*, *texts*):<br>
<br>
- *patches* is a sequence of<br>
:class:`matplotlib.patches.Wedge` instances<br>
<br>
- *texts* is a list of the label<br>
:class:`matplotlib.text.Text` instances.<br>
<br>
If *autopct* is not *None*, return the tuple (*patches*,<br>
*texts*, *autotexts*), where *patches* and *texts* are as<br>
above, and *autotexts* is a list of<br>
:class:`~matplotlib.text.Text` instances for the numeric<br>
labels.<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-pink"><strong>pink</strong></a>()</dt><dd><tt>Set the default colormap to pink and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-plot"><strong>plot</strong></a>(*args, **kwargs)</dt><dd><tt>Plot lines and/or markers to the<br>
:class:`~matplotlib.axes.Axes`. *args* is a variable length<br>
argument, allowing for multiple *x*, *y* pairs with an<br>
optional format string. For example, each of the following is<br>
legal::<br>
<br>
<a href="#-plot">plot</a>(x, y) # plot x and y using the default line style and color<br>
<a href="#-plot">plot</a>(x, y, 'bo') # plot x and y using blue circle markers<br>
<a href="#-plot">plot</a>(y) # plot y using x as index array 0..N-1<br>
<a href="#-plot">plot</a>(y, 'r+') # ditto, but with red plusses<br>
<br>
If *x* and/or *y* is 2-dimensional, then the corresponding columns<br>
will be plotted.<br>
<br>
An arbitrary number of *x*, *y*, *fmt* groups can be<br>
specified, as in::<br>
<br>
a.<a href="#-plot">plot</a>(x1, y1, 'g^', x2, y2, 'g-')<br>
<br>
Return value is a list of lines that were added.<br>
<br>
The following line styles are supported::<br>
<br>
- # solid line<br>
-- # dashed line<br>
-. # dash-dot line<br>
: # dotted line<br>
. # points<br>
, # pixels<br>
o # circle symbols<br>
^ # triangle up symbols<br>
v # triangle down symbols<br>
< # triangle left symbols<br>
> # triangle right symbols<br>
s # square symbols<br>
+ # plus symbols<br>
x # cross symbols<br>
D # diamond symbols<br>
d # thin diamond symbols<br>
1 # tripod down symbols<br>
2 # tripod up symbols<br>
3 # tripod left symbols<br>
4 # tripod right symbols<br>
h # hexagon symbols<br>
H # rotated hexagon symbols<br>
p # pentagon symbols<br>
| # vertical line symbols<br>
_ # horizontal line symbols<br>
steps # use gnuplot style 'steps' # kwarg only<br>
<br>
The following color abbreviations are supported::<br>
<br>
b # blue<br>
g # green<br>
r # red<br>
c # cyan<br>
m # magenta<br>
y # yellow<br>
k # black<br>
w # white<br>
<br>
In addition, you can specify colors in many weird and<br>
wonderful ways, including full names (``'green'``), hex<br>
strings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or<br>
grayscale intensities as a string (``'0.8'``). Of these, the<br>
string specifications can be used in place of a ``fmt`` group,<br>
but the tuple forms can be used only as ``kwargs``.<br>
<br>
Line styles and colors are combined in a single format string, as in<br>
``'bo'`` for blue circles.<br>
<br>
The *kwargs* can be used to set line properties (any property that has<br>
a ``set_*`` method). You can use this to set a line label (for auto<br>
legends), linewidth, anitialising, marker face color, etc. Here is an<br>
example::<br>
<br>
<a href="#-plot">plot</a>([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)<br>
<a href="#-plot">plot</a>([1,2,3], [1,4,9], 'rs', label='line 2')<br>
<a href="#-axis">axis</a>([0, 4, 0, 10])<br>
<a href="#-legend">legend</a>()<br>
<br>
If you make multiple lines with one plot command, the kwargs<br>
apply to all those lines, e.g.::<br>
<br>
<a href="#-plot">plot</a>(x1, y1, x2, y2, antialised=False)<br>
<br>
Neither line will be antialiased.<br>
<br>
The kwargs are :class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
kwargs *scalex* and *scaley*, if defined, are passed on to<br>
:meth:`~matplotlib.axes.Axes.autoscale_view` to determine<br>
whether the *x* and *y* axes are autoscaled; the default is<br>
*True*.<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-plot_date"><strong>plot_date</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-plot_date">plot_date</a>(x, y, fmt='bo', tz=None, xdate=True, ydate=False, **kwargs)<br>
<br>
Similar to the :func:`~matplotlib.pyplot.plot` command, except<br>
the *x* or *y* (or both) data is considered to be dates, and the<br>
axis is labeled accordingly.<br>
<br>
*x* and/or *y* can be a sequence of dates represented as float days since<br>
0001-01-01 UTC.<br>
<br>
See :mod:`~matplotlib.dates` for helper functions<br>
:func:`~matplotlib.dates.date2num`,<br>
:func:`~matplotlib.dates.num2date` and<br>
:func:`~matplotlib.dates.drange` for help on creating the<br>
required floating point dates.<br>
<br>
Keyword arguments:<br>
<br>
*fmt*: string<br>
The plot format string.<br>
<br>
*tz*: [ None | timezone string ]<br>
The time zone to use in labeling dates. If *None*, defaults to rc<br>
value.<br>
<br>
*xdate*: [ True | False ]<br>
If *True*, the *x*-axis will be labeled with dates.<br>
<br>
*ydate*: [ False | True ]<br>
If *True*, the *y*-axis will be labeled with dates.<br>
<br>
Note if you are using custom date tickers and formatters, it<br>
may be necessary to set the formatters/locators after the call<br>
to :meth:`plot_date` since :meth:`plot_date` will set the<br>
default tick locator to<br>
:class:`matplotlib.ticker.AutoDateLocator` (if the tick<br>
locator is not already set to a<br>
:class:`matplotlib.ticker.DateLocator` instance) and the<br>
default tick formatter to<br>
:class:`matplotlib.ticker.AutoDateFormatter` (if the tick<br>
formatter is not already set to a<br>
:class:`matplotlib.ticker.DateFormatter` instance).<br>
<br>
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-plotfile"><strong>plotfile</strong></a>(fname, cols<font color="#909090">=(0,)</font>, plotfuncs<font color="#909090">=None</font>, comments<font color="#909090">='#'</font>, skiprows<font color="#909090">=0</font>, checkrows<font color="#909090">=5</font>, delimiter<font color="#909090">=','</font>, **kwargs)</dt><dd><tt>Plot the data in *fname*<br>
<br>
*cols* is a sequence of column identifiers to plot. An identifier<br>
is either an int or a string. If it is an int, it indicates the<br>
column number. If it is a string, it indicates the column header.<br>
matplotlib will make column headers lower case, replace spaces with<br>
underscores, and remove all illegal characters; so ``'Adj Close*'``<br>
will have name ``'adj_close'``.<br>
<br>
- If len(*cols*) == 1, only that column will be plotted on the *y* axis.<br>
<br>
- If len(*cols*) > 1, the first element will be an identifier for<br>
data for the *x* axis and the remaining elements will be the<br>
column indexes for multiple subplots<br>
<br>
*plotfuncs*, if not *None*, is a dictionary mapping identifier to<br>
an :class:`~matplotlib.axes.Axes` plotting function as a string.<br>
Default is 'plot', other choices are 'semilogy', 'fill', 'bar',<br>
etc. You must use the same type of identifier in the *cols*<br>
vector as you use in the *plotfuncs* dictionary, eg., integer<br>
column numbers in both or column names in both.<br>
<br>
*comments*, *skiprows*, *checkrows*, and *delimiter* are all passed on to<br>
:func:`matplotlib.pylab.csv2rec` to load the data into a record array.<br>
<br>
kwargs are passed on to plotting functions.<br>
<br>
Example usage::<br>
<br>
# plot the 2nd and 4th column against the 1st in two subplots<br>
<a href="#-plotfile">plotfile</a>(fname, (0,1,3))<br>
<br>
# plot using column names; specify an alternate plot type for volume<br>
<a href="#-plotfile">plotfile</a>(fname, ('date', 'volume', 'adj_close'), plotfuncs={'volume': 'semilogy'})</tt></dd></dl>
<dl><dt><a name="-plotting"><strong>plotting</strong></a>()</dt><dd><tt>Plotting commands<br>
<br>
========= =================================================<br>
Command Description<br>
========= =================================================<br>
axes Create a new axes<br>
axis Set or return the current axis limits<br>
bar make a bar chart<br>
boxplot make a box and whiskers chart<br>
cla clear current axes<br>
clabel label a contour plot<br>
clf clear a figure window<br>
close close a figure window<br>
colorbar add a colorbar to the current figure<br>
cohere make a plot of coherence<br>
contour make a contour plot<br>
contourf make a filled contour plot<br>
csd make a plot of cross spectral density<br>
draw force a redraw of the current figure<br>
errorbar make an errorbar graph<br>
figlegend add a legend to the figure<br>
figimage add an image to the figure, w/o resampling<br>
figtext add text in figure coords<br>
figure create or change active figure<br>
fill make filled polygons<br>
gca return the current axes<br>
gcf return the current figure<br>
gci get the current image, or None<br>
getp get a handle graphics property<br>
hist make a histogram<br>
hold set the hold state on current axes<br>
legend add a legend to the axes<br>
loglog a log log plot<br>
imread load image file into array<br>
imshow plot image data<br>
matshow display a matrix in a new figure preserving aspect<br>
pcolor make a pseudocolor plot<br>
plot make a line plot<br>
plotfile plot data from a flat file<br>
psd make a plot of power spectral density<br>
quiver make a direction field (arrows) plot<br>
rc control the default params<br>
savefig save the current figure<br>
scatter make a scatter plot<br>
setp set a handle graphics property<br>
semilogx log x axis<br>
semilogy log y axis<br>
show show the figures<br>
specgram a spectrogram plot<br>
stem make a stem plot<br>
subplot make a subplot (numrows, numcols, axesnum)<br>
table add a table to the axes<br>
text add some text at location x,y to the current axes<br>
title add a title to the current axes<br>
xlabel add an xlabel to the current axes<br>
ylabel add a ylabel to the current axes<br>
========= =================================================<br>
<br>
The following commands will set the default colormap accordingly:<br>
<br>
* autumn<br>
* bone<br>
* cool<br>
* copper<br>
* flag<br>
* gray<br>
* hot<br>
* hsv<br>
* jet<br>
* pink<br>
* prism<br>
* spring<br>
* summer<br>
* winter<br>
* spectral</tt></dd></dl>
<dl><dt><a name="-polar"><strong>polar</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-polar">polar</a>(theta, r, **kwargs)<br>
<br>
Make a polar plot. Multiple *theta*, *r* arguments are supported,<br>
with format strings, as in :func:`~matplotlib.pyplot.plot`.</tt></dd></dl>
<dl><dt><a name="-prism"><strong>prism</strong></a>()</dt><dd><tt>Set the default colormap to prism and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-psd"><strong>psd</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-psd">psd</a>(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,<br>
window=mlab.window_hanning, noverlap=0, **kwargs)<br>
<br>
The power spectral density by Welches average periodogram<br>
method. The vector *x* is divided into *NFFT* length<br>
segments. Each segment is detrended by function *detrend* and<br>
windowed by function *window*. *noperlap* gives the length of<br>
the overlap between segments. The :math:`|\mathrm{fft}(i)|^2`<br>
of each segment :math:`i` are averaged to compute *Pxx*, with a<br>
scaling to correct for power loss due to windowing. *Fs* is the<br>
sampling frequency.<br>
<br>
Keyword arguments:<br>
<br>
*NFFT*: integer<br>
The length of the fft segment, must be a power of 2<br>
<br>
*Fs*: integer<br>
The sampling frequency.<br>
<br>
*Fc*: integer<br>
The center frequency of *x* (defaults to 0), which offsets<br>
the yextents of the image to reflect the frequency range used<br>
when a signal is acquired and then filtered and downsampled to<br>
baseband.<br>
<br>
*detrend*:<br>
The function applied to each segment before fft-ing,<br>
designed to remove the mean or linear trend. Unlike in<br>
matlab, where the *detrend* parameter is a vector, in<br>
matplotlib is it a function. The :mod:`~matplotlib.pylab`<br>
module defines :func:`~matplotlib.pylab.detrend_none`,<br>
:func:`~matplotlib.pylab.detrend_mean`, and<br>
:func:`~matplotlib.pylab.detrend_linear`, but you can use<br>
a custom function as well.<br>
<br>
*window*:<br>
The function used to window the segments. *window* is a<br>
function, unlike in matlab where it is a vector.<br>
:mod:`~matplotlib.pylab` defines<br>
:func:`~matplotlib.pylab.window_none`, and<br>
:func:`~matplotlib.pylab.window_hanning`, but you can use<br>
a custom function as well.<br>
<br>
*noverlap*: integer<br>
Gives the length of the overlap between segments.<br>
<br>
Returns the tuple (*Pxx*, *freqs*).<br>
<br>
For plotting, the power is plotted as<br>
:math:`10\log_{10}(P_{xx})` for decibels, though *Pxx* itself<br>
is returned.<br>
<br>
References:<br>
Bendat & Piersol -- Random Data: Analysis and Measurement<br>
Procedures, John Wiley & Sons (1986)<br>
<br>
kwargs control the :class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-quiver"><strong>quiver</strong></a>(*args, **kwargs)</dt><dd><tt>Plot a 2-D field of arrows.<br>
<br>
call signatures::<br>
<br>
<a href="#-quiver">quiver</a>(U, V, **kw)<br>
<a href="#-quiver">quiver</a>(U, V, C, **kw)<br>
<a href="#-quiver">quiver</a>(X, Y, U, V, **kw)<br>
<a href="#-quiver">quiver</a>(X, Y, U, V, C, **kw)<br>
<br>
Arguments:<br>
<br>
*X*, *Y*:<br>
The x and y coordinates of the arrow locations<br>
(default is tail of arrow; see *pivot* kwarg)<br>
<br>
*U*, *V*:<br>
give the *x* and *y* components of the arrow vectors<br>
<br>
*C*:<br>
an optional array used to map colors to the arrows<br>
<br>
All arguments may be 1-D or 2-D arrays or sequences. If *X* and *Y*<br>
are absent, they will be generated as a uniform grid. If *U* and *V*<br>
are 2-D arrays but *X* and *Y* are 1-D, and if len(*X*) and len(*Y*)<br>
match the column and row dimensions of *U*, then *X* and *Y* will be<br>
expanded with :func:`numpy.meshgrid`.<br>
<br>
*U*, *V*, *C* may be masked arrays, but masked *X*, ** are not<br>
supported at present.<br>
<br>
Keyword arguments:<br>
<br>
*units*: ['width' | 'height' | 'dots' | 'inches' | 'x' | 'y' ]<br>
arrow units; the arrow dimensions *except for length* are<br>
in multiples of this unit.<br>
<br>
* 'width' or 'height': the width or height of the axes<br>
* 'dots' or 'inches': pixels or inches, based on the figure dpi<br>
* 'x' or 'y': *X* or *Y* data units<br>
<br>
In all cases the arrow aspect ratio is 1, so that if *U*==*V* the<br>
angle of the arrow on the plot is 45 degrees CCW from the *x*-axis.<br>
<br>
The arrows scale differently depending on the units, however.<br>
For 'x' or 'y', the arrows get larger as one zooms in; for other<br>
units, the arrow size is independent of the zoom state. For<br>
'width or 'height', the arrow size increases with the width and<br>
height of the axes, respectively, when the the window is resized;<br>
for 'dots' or 'inches', resizing does not change the arrows.<br>
<br>
*scale*: [ None | float ]<br>
data units per arrow unit, e.g. m/s per plot width;<br>
a smaller scale parameter makes the arrow longer.<br>
If *None*, a simple autoscaling algorithm is used, based<br>
on the average vector length and the number of vectors.<br>
<br>
*width*:<br>
shaft width in arrow units; default depends on choice of units,<br>
above, and number of vectors; a typical starting value is about<br>
0.005 times the width of the plot.<br>
<br>
*headwidth*: scalar<br>
head width as multiple of shaft width, default is 3<br>
<br>
*headlength*: scalar<br>
head length as multiple of shaft width, default is 5<br>
<br>
*headaxislength*: scalar<br>
head length at shaft intersection, default is 4.5<br>
<br>
*minshaft*: scalar<br>
length below which arrow scales, in units of head length. Do not<br>
set this to less than 1, or small arrows will look terrible!<br>
Default is 1<br>
<br>
*minlength*: scalar<br>
minimum length as a multiple of shaft width; if an arrow length<br>
is less than this, plot a dot (hexagon) of this diameter instead.<br>
Default is 1.<br>
<br>
*pivot*: [ 'tail' | 'middle' | 'tip' ]<br>
The part of the arrow that is at the grid point; the arrow<br>
rotates about this point, hence the name *pivot*.<br>
<br>
*color*: [ color | color sequence ]<br>
This is a synonym for the<br>
:class:`~matplotlib.collections.PolyCollection` facecolor kwarg.<br>
If *C* has been set, *color* has no effect.<br>
<br>
The defaults give a slightly swept-back arrow; to make the head a<br>
triangle, make *headaxislength* the same as *headlength*. To make the<br>
arrow more pointed, reduce *headwidth* or increase *headlength* and<br>
*headaxislength*. To make the head smaller relative to the shaft,<br>
scale down all the head parameters. You will probably do best to leave<br>
minshaft alone.<br>
<br>
linewidths and edgecolors can be used to customize the arrow<br>
outlines. Additional :class:`~matplotlib.collections.PolyCollection`<br>
keyword arguments:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-quiverkey"><strong>quiverkey</strong></a>(*args, **kwargs)</dt><dd><tt>Add a key to a quiver plot.<br>
<br>
call signature::<br>
<br>
<a href="#-quiverkey">quiverkey</a>(Q, X, Y, U, label, **kw)<br>
<br>
Arguments:<br>
<br>
*Q*:<br>
The Quiver instance returned by a call to quiver.<br>
<br>
*X*, *Y*:<br>
The location of the key; additional explanation follows.<br>
<br>
*U*:<br>
The length of the key<br>
<br>
*label*:<br>
a string with the length and units of the key<br>
<br>
Keyword arguments:<br>
<br>
*coordinates* = [ 'axes' | 'figure' | 'data' | 'inches' ]<br>
Coordinate system and units for *X*, *Y*: 'axes' and 'figure'<br>
are normalized coordinate systems with 0,0 in the lower<br>
left and 1,1 in the upper right; 'data' are the axes<br>
data coordinates (used for the locations of the vectors<br>
in the quiver plot itself); 'inches' is position in the<br>
figure in inches, with 0,0 at the lower left corner.<br>
<br>
*color*:<br>
overrides face and edge colors from *Q*.<br>
<br>
*labelpos* = [ 'N' | 'S' | 'E' | 'W' ]<br>
Position the label above, below, to the right, to the left<br>
of the arrow, respectively.<br>
<br>
*labelsep*:<br>
Distance in inches between the arrow and the label.<br>
Default is 0.1<br>
<br>
*labelcolor*:<br>
defaults to default :class:`~matplotlib.text.Text` color.<br>
<br>
*fontproperties*:<br>
A dictionary with keyword arguments accepted by the<br>
:class:`~matplotlib.font_manager.FontProperties` initializer:<br>
*family*, *style*, *variant*, *size*, *weight*<br>
<br>
Any additional keyword arguments are used to override vector<br>
properties taken from *Q*.<br>
<br>
The positioning of the key depends on *X*, *Y*, *coordinates*, and<br>
*labelpos*. If *labelpos* is 'N' or 'S', *X*, *Y* give the position<br>
of the middle of the key arrow. If *labelpos* is 'E', *X*, *Y*<br>
positions the head, and if *labelpos* is 'W', *X*, *Y* positions the<br>
tail; in either of these two cases, *X*, *Y* is somewhere in the<br>
middle of the arrow+label key object.<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-rc"><strong>rc</strong></a>(*args, **kwargs)</dt><dd><tt>Set the current rc params. Group is the grouping for the rc, eg.<br>
for ``lines.linewidth`` the group is ``lines``, for<br>
``axes.facecolor``, the group is ``axes``, and so on. Group may<br>
also be a list or tuple of group names, eg. (*xtick*, *ytick*).<br>
*kwargs* is a dictionary attribute name/value pairs, eg::<br>
<br>
<a href="#-rc">rc</a>('lines', linewidth=2, color='r')<br>
<br>
sets the current rc params and is equivalent to::<br>
<br>
rcParams['lines.linewidth'] = 2<br>
rcParams['lines.color'] = 'r'<br>
<br>
The following aliases are available to save typing for interactive<br>
users:<br>
<br>
===== =================<br>
Alias Property<br>
===== =================<br>
'lw' 'linewidth'<br>
'ls' 'linestyle'<br>
'c' 'color'<br>
'fc' 'facecolor'<br>
'ec' 'edgecolor'<br>
'mew' 'markeredgewidth'<br>
'aa' 'antialiased'<br>
===== =================<br>
<br>
Thus you could abbreviate the above rc command as::<br>
<br>
<a href="#-rc">rc</a>('lines', lw=2, c='r')<br>
<br>
<br>
Note you can use python's kwargs dictionary facility to store<br>
dictionaries of default parameters. Eg, you can customize the<br>
font rc as follows::<br>
<br>
font = {'family' : 'monospace',<br>
'weight' : 'bold',<br>
'size' : 'larger'}<br>
<br>
<a href="#-rc">rc</a>('font', **font) # pass in the font dict as kwargs<br>
<br>
This enables you to easily switch between several configurations.<br>
Use :func:`~matplotlib.pyplot.rcdefaults` to restore the default<br>
rc params after changes.</tt></dd></dl>
<dl><dt><a name="-rcdefaults"><strong>rcdefaults</strong></a>()</dt><dd><tt>Restore the default rc params - the ones that were created at<br>
matplotlib load time.</tt></dd></dl>
<dl><dt><a name="-rgrids"><strong>rgrids</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the radial locations of the gridlines and ticklabels on a<br>
polar plot.<br>
<br>
call signatures::<br>
<br>
lines, labels = <a href="#-rgrids">rgrids</a>()<br>
lines, labels = <a href="#-rgrids">rgrids</a>(radii, labels=None, angle=22.5, **kwargs)<br>
<br>
When called with no arguments, :func:`rgrid` simply returns the<br>
tuple (*lines*, *labels*), where *lines* is an array of radial<br>
gridlines (:class:`~matplotlib.lines.Line2D` instances) and<br>
*labels* is an array of tick labels<br>
(:class:`~matplotlib.text.Text` instances). When called with<br>
arguments, the labels will appear at the specified radial<br>
distances and angles.<br>
<br>
*labels*, if not *None*, is a len(*radii*) list of strings of the<br>
labels to use at each angle.<br>
<br>
If *labels* is None, the rformatter will be used<br>
<br>
Examples::<br>
<br>
# set the locations of the radial gridlines and labels<br>
lines, labels = <a href="#-rgrids">rgrids</a>( (0.25, 0.5, 1.0) )<br>
<br>
# set the locations and labels of the radial gridlines and labels<br>
lines, labels = <a href="#-rgrids">rgrids</a>( (0.25, 0.5, 1.0), ('Tom', 'Dick', 'Harry' )</tt></dd></dl>
<dl><dt><a name="-savefig"><strong>savefig</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-savefig">savefig</a>(fname, dpi=None, facecolor='w', edgecolor='w',<br>
orientation='portrait', papertype=None, format=None,<br>
transparent=False):<br>
<br>
Save the current figure.<br>
<br>
The output formats available depend on the backend being used.<br>
<br>
Arguments:<br>
<br>
*fname*:<br>
A string containing a path to a filename, or a Python file-like object.<br>
<br>
If *format* is *None* and *fname* is a string, the output<br>
format is deduced from the extension of the filename.<br>
<br>
Keyword arguments:<br>
<br>
*dpi*: [ None | scalar > 0 ]<br>
The resolution in dots per inch. If *None* it will default to<br>
the value ``savefig.dpi`` in the matplotlibrc file.<br>
<br>
*facecolor*, *edgecolor*:<br>
the colors of the figure rectangle<br>
<br>
*orientation*: [ 'landscape' | 'portrait' ]<br>
not supported on all backends; currently only on postscript output<br>
<br>
*papertype*:<br>
One of 'letter', 'legal', 'executive', 'ledger', 'a0' through<br>
'a10', 'b0' through 'b10'. Only supported for postscript<br>
output.<br>
<br>
*format*:<br>
One of the file extensions supported by the active<br>
backend. Most backends support png, pdf, ps, eps and svg.<br>
<br>
*transparent*:<br>
If *True*, the figure patch and axes patches will all be<br>
transparent. This is useful, for example, for displaying<br>
a plot on top of a colored background on a web page. The<br>
transparency of these patches will be restored to their<br>
original values upon exit of this function.</tt></dd></dl>
<dl><dt><a name="-scatter"><strong>scatter</strong></a>(*args, **kwargs)</dt><dd><tt>call signatures::<br>
<br>
<a href="#-scatter">scatter</a>(x, y, s=20, c='b', marker='o', cmap=None, norm=None,<br>
vmin=None, vmax=None, alpha=1.0, linewidths=None,<br>
verts=None, **kwargs)<br>
<br>
Make a scatter plot of *x* versus *y*, where *x*, *y* are 1-D<br>
sequences of the same length, *N*.<br>
<br>
Keyword arguments:<br>
<br>
*s*:<br>
size in points^2. It is a scalar or an array of the same<br>
length as *x* and *y*.<br>
<br>
*c*:<br>
a color. *c* can be a single color format string, or a<br>
sequence of color specifications of length *N*, or a<br>
sequence of *N* numbers to be mapped to colors using the<br>
*cmap* and *norm* specified via kwargs (see below). Note<br>
that *c* should not be a single numeric RGB or RGBA<br>
sequence because that is indistinguishable from an array<br>
of values to be colormapped. *c* can be a 2-D array in<br>
which the rows are RGB or RGBA, however.<br>
<br>
*marker*:<br>
can be one of:<br>
<br>
===== ==============<br>
Value Description<br>
===== ==============<br>
's' square<br>
'o' circle<br>
'^' triangle up<br>
'>' triangle right<br>
'v' triangle down<br>
'<' triangle left<br>
'd' diamond<br>
'p' pentagram<br>
'h' hexagon<br>
'8' octagon<br>
'+' plus<br>
'x' cross<br>
===== ==============<br>
<br>
The marker can also be a tuple (*numsides*, *style*,<br>
*angle*), which will create a custom, regular symbol.<br>
<br>
*numsides*:<br>
the number of sides<br>
<br>
*style*:<br>
the style of the regular symbol:<br>
<br>
===== =============================================<br>
Value Description<br>
===== =============================================<br>
0 a regular polygon<br>
1 a star-like symbol<br>
2 an asterisk<br>
3 a circle (*numsides* and *angle* is ignored)<br>
===== =============================================<br>
<br>
*angle*:<br>
the angle of rotation of the symbol<br>
<br>
Finally, *marker* can be (*verts*, 0): *verts* is a<br>
sequence of (*x*, *y*) vertices for a custom scatter<br>
symbol. Alternatively, use the kwarg combination<br>
*marker* = *None*, *verts* = *verts*.<br>
<br>
Any or all of *x*, *y*, *s*, and *c* may be masked arrays, in<br>
which case all masks will be combined and only unmasked points<br>
will be plotted.<br>
<br>
Other keyword arguments: the color mapping and normalization<br>
arguments will be used only if *c* is an array of floats.<br>
<br>
*cmap*: [ None | Colormap ]<br>
A :class:`matplotlib.colors.Colormap` instance. If *None*,<br>
defaults to rc ``image.cmap``. *cmap* is only used if *c*<br>
is an array of floats.<br>
<br>
*norm*: [ None | Normalize ]<br>
A :class:`matplotlib.colors.Normalize` instance is used to<br>
scale luminance data to 0, 1. If *None*, use the default<br>
:func:`normalize`. *norm* is only used if *c* is an array<br>
of floats.<br>
<br>
*vmin*/*vmax*:<br>
*vmin* and *vmax* are used in conjunction with norm to<br>
normalize luminance data. If either are None, the min and<br>
max of the color array *C* is used. Note if you pass a<br>
*norm* instance, your settings for *vmin* and *vmax* will<br>
be ignored.<br>
<br>
*alpha*: 0 <= scalar <= 1<br>
The alpha value for the patches<br>
<br>
*linewidths*: [ None | scalar | sequence ]<br>
If *None*, defaults to (lines.linewidth,). Note that this<br>
is a tuple, and if you set the linewidths argument you<br>
must set it as a sequence of floats, as required by<br>
:class:`~matplotlib.collections.RegularPolyCollection`.<br>
<br>
Optional kwargs control the<br>
:class:`~matplotlib.collections.Collection` properties; in<br>
particular:<br>
<br>
*edgecolors*:<br>
'none' to plot faces with no outlines<br>
<br>
*facecolors*:<br>
'none' to plot unfilled outlines<br>
<br>
Here are the standard descriptions of all the<br>
:class:`~matplotlib.collections.Collection` kwargs:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
A :class:`~matplotlib.collections.Collection` instance is<br>
returned.<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-sci"><strong>sci</strong></a>(im)</dt><dd><tt>Set the current image (target of colormap commands like<br>
:func:`~matplotlib.pyplot.jet`, :func:`~matplotlib.pyplot.hot` or<br>
:func:`~matplotlib.pyplot.clim`).</tt></dd></dl>
<dl><dt><a name="-semilogx"><strong>semilogx</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-semilogx">semilogx</a>(*args, **kwargs)<br>
<br>
Make a plot with log scaling on the *x* axis.<br>
<br>
:func:`semilogx` supports all the keyword arguments of<br>
:func:`~matplotlib.pyplot.plot` and<br>
:meth:`matplotlib.axes.Axes.set_xscale`.<br>
<br>
Notable keyword arguments:<br>
<br>
*basex*: scalar > 1<br>
base of the *x* logarithm<br>
<br>
*subsx*: [ None | sequence ]<br>
The location of the minor xticks; *None* defaults to<br>
autosubs, which depend on the number of decades in the<br>
plot; see :meth:`~matplotlib.axes.Axes.set_xscale` for<br>
details.<br>
<br>
The remaining valid kwargs are<br>
:class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
See :meth:`loglog` for example code and figure<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-semilogy"><strong>semilogy</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-semilogy">semilogy</a>(*args, **kwargs)<br>
<br>
Make a plot with log scaling on the *y* axis.<br>
<br>
:func:`semilogy` supports all the keyword arguments of<br>
:func:`~matplotlib.pylab.plot` and<br>
:meth:`matplotlib.axes.Axes.set_yscale`.<br>
<br>
Notable keyword arguments:<br>
<br>
*basey*: scalar > 1<br>
Base of the *y* logarithm<br>
<br>
*subsy*: [ None | sequence ]<br>
The location of the minor yticks; *None* defaults to<br>
autosubs, which depend on the number of decades in the<br>
plot; see :meth:`~matplotlib.axes.Axes.set_yscale` for<br>
details.<br>
<br>
The remaining valid kwargs are<br>
:class:`~matplotlib.lines.Line2D` properties:<br>
<br>
<br>
====================== ====================================================================================================<br>
Property Description <br>
====================== ====================================================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased or aa [True | False] <br>
axes unknown <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color or c any matplotlib color <br>
contains unknown <br>
dash_capstyle ['butt' | 'round' | 'projecting'] <br>
dash_joinstyle ['miter' | 'round' | 'bevel'] <br>
dashes sequence of on/off ink in points <br>
data (np.array xdata, np.array ydata) <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle or ls [ '-' | '--' | '-.' | ':' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post' | 'None' | ' ' | '' ]<br>
linewidth or lw float value in points <br>
lod [True | False] <br>
marker [ '+' | ',' | '.' | '1' | '2' | '3' | '4' <br>
markeredgecolor or mec any matplotlib color <br>
markeredgewidth or mew float value in points <br>
markerfacecolor or mfc any matplotlib color <br>
markersize or ms float <br>
picker unknown <br>
pickradius unknown <br>
solid_capstyle ['butt' | 'round' | 'projecting'] <br>
solid_joinstyle ['miter' | 'round' | 'bevel'] <br>
transform a matplotlib.transforms.Transform instance <br>
visible [True | False] <br>
xdata np.array <br>
ydata np.array <br>
zorder any number <br>
====================== ====================================================================================================<br>
<br>
<br>
See :meth:`loglog` for example code and figure<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-setp"><strong>setp</strong></a>(*args, **kwargs)</dt><dd><tt>matplotlib supports the use of :func:`setp` ("set property") and<br>
:func:`getp` to set and get object properties, as well as to do<br>
introspection on the object. For example, to set the linestyle of a<br>
line to be dashed, you can do::<br>
<br>
>>> line, = <a href="#-plot">plot</a>([1,2,3])<br>
>>> <a href="#-setp">setp</a>(line, linestyle='--')<br>
<br>
If you want to know the valid types of arguments, you can provide the<br>
name of the property you want to set without a value::<br>
<br>
>>> <a href="#-setp">setp</a>(line, 'linestyle')<br>
linestyle: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]<br>
<br>
If you want to see all the properties that can be set, and their<br>
possible values, you can do::<br>
<br>
>>> <a href="#-setp">setp</a>(line)<br>
... long output listing omitted<br>
<br>
:func:`setp` operates on a single instance or a list of instances.<br>
If you are in query mode introspecting the possible values, only<br>
the first instance in the sequence is used. When actually setting<br>
values, all the instances will be set. E.g., suppose you have a<br>
list of two lines, the following will make both lines thicker and<br>
red::<br>
<br>
>>> x = arange(0,1.0,0.01)<br>
>>> y1 = sin(2*pi*x)<br>
>>> y2 = sin(4*pi*x)<br>
>>> lines = <a href="#-plot">plot</a>(x, y1, x, y2)<br>
>>> <a href="#-setp">setp</a>(lines, linewidth=2, color='r')<br>
<br>
:func:`setp` works with the matlab(TM) style string/value pairs or<br>
with python kwargs. For example, the following are equivalent<br>
<br>
>>> <a href="#-setp">setp</a>(lines, 'linewidth', 2, 'color', r') # matlab style<br>
<br>
>>> <a href="#-setp">setp</a>(lines, linewidth=2, color='r') # python style</tt></dd></dl>
<dl><dt><a name="-specgram"><strong>specgram</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-specgram">specgram</a>(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,<br>
window = mlab.window_hanning, noverlap=128,<br>
cmap=None, xextent=None)<br>
<br>
Compute a spectrogram of data in *x*. Data are split into<br>
*NFFT* length segments and the PSD of each section is<br>
computed. The windowing function *window* is applied to each<br>
segment, and the amount of overlap of each segment is<br>
specified with *noverlap*.<br>
<br>
Keyword arguments:<br>
<br>
*cmap*:<br>
A :class:`matplotlib.cm.Colormap` instance; if *None* use<br>
default determined by rc<br>
<br>
*xextent*:<br>
The image extent in the xaxes xextent=xmin, xmax<br>
default 0, max(bins), 0, max(freqs) where bins is the return<br>
value from mlab.specgram<br>
<br>
See :meth:`~matplotlib.axes.Axes.psd` for information on the<br>
other keyword arguments.<br>
<br>
Return value is (*Pxx*, *freqs*, *bins*, *im*):<br>
<br>
- *bins* are the time points the spectrogram is calculated over<br>
- *freqs* is an array of frequencies<br>
- *Pxx* is a len(times) x len(freqs) array of power<br>
- *im* is a :class:`matplotlib.image.AxesImage` instance<br>
<br>
Note: If *x* is real (i.e. non-complex), only the positive<br>
spectrum is shown. If *x* is complex, both positive and<br>
negative parts of the spectrum are shown.<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-spectral"><strong>spectral</strong></a>()</dt><dd><tt>Set the default colormap to spectral and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-spring"><strong>spring</strong></a>()</dt><dd><tt>Set the default colormap to spring and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-spy"><strong>spy</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-spy">spy</a>(Z, precision=None, marker=None, markersize=None,<br>
aspect='equal', **kwargs)<br>
<br>
``<a href="#-spy">spy</a>(Z)`` plots the sparsity pattern of the 2-D array *Z*.<br>
<br>
If *precision* is *None*, any non-zero value will be plotted;<br>
else, values of :math:`|Z| > precision` will be plotted.<br>
<br>
The array will be plotted as it would be printed, with<br>
the first index (row) increasing down and the second<br>
index (column) increasing to the right.<br>
<br>
By default aspect is 'equal', so that each array element<br>
occupies a square space; set the aspect kwarg to 'auto'<br>
to allow the plot to fill the plot box, or to any scalar<br>
number to specify the aspect ratio of an array element<br>
directly.<br>
<br>
Two plotting styles are available: image or marker. Both<br>
are available for full arrays, but only the marker style<br>
works for :class:`scipy.sparse.spmatrix` instances.<br>
<br>
If *marker* and *markersize* are *None*, an image will be<br>
returned and any remaining kwargs are passed to<br>
:func:`~matplotlib.pyplot.imshow`; else, a<br>
:class:`~matplotlib.lines.Line2D` object will be returned with<br>
the value of marker determining the marker type, and any<br>
remaining kwargs passed to the<br>
:meth:`~matplotlib.axes.Axes.plot` method.<br>
<br>
If *marker* and *markersize* are *None*, useful kwargs include:<br>
<br>
* *cmap*<br>
* *alpha*<br>
<br>
See documentation for :func:`~matplotlib.pyplot.imshow` for details.<br>
<br>
For controlling colors, e.g. cyan background and red marks,<br>
use::<br>
<br>
cmap = mcolors.ListedColormap(['c','r'])<br>
<br>
If *marker* or *markersize* is not *None*, useful kwargs include:<br>
<br>
* *marker*<br>
* *markersize*<br>
* *color*<br>
<br>
See documentation for :func:`~matplotlib.pyplot.plot` for details.<br>
<br>
Useful values for *marker* include:<br>
<br>
* 's' square (default)<br>
* 'o' circle<br>
* '.' point<br>
* ',' pixel<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-stem"><strong>stem</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-stem">stem</a>(x, y, linefmt='b-', markerfmt='bo', basefmt='r-')<br>
<br>
A stem plot plots vertical lines (using *linefmt*) at each *x*<br>
location from the baseline to *y*, and places a marker there<br>
using *markerfmt*. A horizontal line at 0 is is plotted using<br>
*basefmt*.<br>
<br>
Return value is a tuple (*markerline*, *stemlines*,<br>
*baseline*).<br>
<br>
See `this document<br>
<<a href="http://www.mathworks.com/access/helpdesk/help/techdoc/ref/stem.html>`_">http://www.mathworks.com/access/helpdesk/help/techdoc/ref/stem.html>`_</a><br>
for details and :file:`examples/pylab_examples/stem_plot.py` for a demo.<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-step"><strong>step</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-step">step</a>(x, y, *args, **kwargs)<br>
<br>
Make a step plot. Additional keyword args to :func:`step` are the same<br>
as those for :func:`~matplotlib.pyplot.plot`.<br>
<br>
*x* and *y* must be 1-D sequences, and it is assumed, but not checked,<br>
that *x* is uniformly increasing.<br>
<br>
Keyword arguments:<br>
<br>
*where*: [ 'pre' | 'post' | 'mid' ]<br>
If 'pre', the interval from x[i] to x[i+1] has level y[i]<br>
<br>
If 'post', that interval has level y[i+1]<br>
<br>
If 'mid', the jumps in *y* occur half-way between the<br>
*x*-values.<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-subplot"><strong>subplot</strong></a>(*args, **kwargs)</dt><dd><tt>Create a subplot command, creating axes with::<br>
<br>
<a href="#-subplot">subplot</a>(numRows, numCols, plotNum)<br>
<br>
where *plotNum* = 1 is the first plot number and increasing *plotNums*<br>
fill rows first. max(*plotNum*) == *numRows* * *numCols*<br>
<br>
You can leave out the commas if *numRows* <= *numCols* <=<br>
*plotNum* < 10, as in::<br>
<br>
<a href="#-subplot">subplot</a>(211) # 2 rows, 1 column, first (upper) plot<br>
<br>
``<a href="#-subplot">subplot</a>(111)`` is the default axis.<br>
<br>
The background color of the subplot can be specified via keyword<br>
argument *axisbg*, which takes a color string as value, as in::<br>
<br>
<a href="#-subplot">subplot</a>(211, axisbg='y')<br>
<br>
See :func:`~matplotlib.pyplot.axes` for additional information on<br>
:func:`axes` and :func:`subplot` keyword arguments.<br>
<br>
New subplots that overlap old will delete the old axes. If you do<br>
not want this behavior, use<br>
:meth:`matplotlib.figure.Figure.add_subplot` or the<br>
:func:`~matplotlib.pyplot.axes` command. Eg.::<br>
<br>
from pylab import *<br>
<a href="#-plot">plot</a>([1,2,3]) # implicitly creates <a href="#-subplot">subplot</a>(111)<br>
<a href="#-subplot">subplot</a>(211) # overlaps, <a href="#-subplot">subplot</a>(111) is killed<br>
<a href="#-plot">plot</a>(rand(12), rand(12))</tt></dd></dl>
<dl><dt><a name="-subplot_tool"><strong>subplot_tool</strong></a>(targetfig<font color="#909090">=None</font>)</dt><dd><tt>Launch a subplot tool window for *targetfig* (default gcf).<br>
<br>
A :class:`matplotlib.widgets.SubplotTool` instance is returned.</tt></dd></dl>
<dl><dt><a name="-subplots_adjust"><strong>subplots_adjust</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-subplots_adjust">subplots_adjust</a>(left=None, bottom=None, right=None, top=None,<br>
wspace=None, hspace=None)<br>
<br>
Tune the subplot layout via the<br>
:class:`matplotlib.figure.SubplotParams` mechanism. The parameter<br>
meanings (and suggested defaults) are::<br>
<br>
left = 0.125 # the left side of the subplots of the figure<br>
right = 0.9 # the right side of the subplots of the figure<br>
bottom = 0.1 # the bottom of the subplots of the figure<br>
top = 0.9 # the top of the subplots of the figure<br>
wspace = 0.2 # the amount of width reserved for blank space between subplots<br>
hspace = 0.2 # the amount of height reserved for white space between subplots<br>
<br>
The actual defaults are controlled by the rc file</tt></dd></dl>
<dl><dt><a name="-summer"><strong>summer</strong></a>()</dt><dd><tt>Set the default colormap to summer and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-suptitle"><strong>suptitle</strong></a>(*args, **kwargs)</dt><dd><tt>Add a centered title to the figure.<br>
<br>
kwargs are :class:`matplotlib.text.Text` properties. Using figure<br>
coordinates, the defaults are::<br>
<br>
*x* = 0.5<br>
the x location of text in figure coords<br>
*y* = 0.98<br>
the y location of the text in figure coords<br>
*horizontalalignment* = 'center'<br>
the horizontal alignment of the text<br>
*verticalalignment* = 'top'<br>
the vertical alignment of the text<br>
<br>
A :class:`matplotlib.text.Text` instance is returned.<br>
<br>
Example::<br>
<br>
fig.subtitle('this is the figure title', fontsize=12)</tt></dd></dl>
<dl><dt><a name="-switch_backend"><strong>switch_backend</strong></a>(newbackend)</dt><dd><tt>Switch the default backend to newbackend. This feature is<br>
**experimental**, and is only expected to work switching to an<br>
image backend. Eg, if you have a bunch of PostScript scripts that<br>
you want to run from an interactive ipython session, you may want<br>
to switch to the PS backend before running them to avoid having a<br>
bunch of GUI windows popup. If you try to interactively switch<br>
from one GUI backend to another, you will explode.<br>
<br>
Calling this command will close all open windows.</tt></dd></dl>
<dl><dt><a name="-table"><strong>table</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-table">table</a>(cellText=None, cellColours=None,<br>
cellLoc='right', colWidths=None,<br>
rowLabels=None, rowColours=None, rowLoc='left',<br>
colLabels=None, colColours=None, colLoc='center',<br>
loc='bottom', bbox=None):<br>
<br>
Add a table to the current axes. Returns a<br>
:class:`matplotlib.table.Table` instance. For finer grained<br>
control over tables, use the :class:`~matplotlib.table.Table`<br>
class and add it to the axes with<br>
:meth:`~matplotlib.axes.Axes.add_table`.<br>
<br>
Thanks to John Gill for providing the class and table.<br>
<br>
kwargs control the :class:`~matplotlib.table.Table`<br>
properties:<br>
<br>
<br>
========= ===============================================<br>
Property Description <br>
========= ===============================================<br>
alpha float <br>
animated [True | False] <br>
axes an axes instance <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a<br>
contains unknown <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fontsize a float in points <br>
label any string <br>
lod [True | False] <br>
picker [None|float|boolean|callable] <br>
transform unknown <br>
visible [True | False] <br>
zorder any number <br>
========= ===============================================</tt></dd></dl>
<dl><dt><a name="-text"><strong>text</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-text">text</a>(x, y, s, fontdict=None, **kwargs)<br>
<br>
Add text in string *s* to axis at location *x*, *y*, data<br>
coordinates.<br>
<br>
Keyword arguments:<br>
<br>
*fontdict*:<br>
A dictionary to override the default text properties.<br>
If *fontdict* is *None*, the defaults are determined by your rc<br>
parameters.<br>
<br>
*withdash*: [ False | True ]<br>
Creates a :class:`~matplotlib.text.TextWithDash` instance<br>
instead of a :class:`~matplotlib.text.Text` instance.<br>
<br>
Individual keyword arguments can be used to override any given<br>
parameter::<br>
<br>
<a href="#-text">text</a>(x, y, s, fontsize=12)<br>
<br>
The default transform specifies that text is in data coords,<br>
alternatively, you can specify text in axis coords (0,0 is<br>
lower-left and 1,1 is upper-right). The example below places<br>
text in the center of the axes::<br>
<br>
<a href="#-text">text</a>(0.5, 0.5,'matplotlib',<br>
horizontalalignment='center',<br>
verticalalignment='center',<br>
transform = ax.transAxes)<br>
<br>
You can put a rectangular box around the text instance (eg. to<br>
set a background color) by using the keyword *bbox*. *bbox* is<br>
a dictionary of :class:`matplotlib.patches.Rectangle`<br>
properties. For example::<br>
<br>
<a href="#-text">text</a>(x, y, s, bbox=dict(facecolor='red', alpha=0.5))<br>
<br>
Valid kwargs are :class:`matplotlib.text.Text` properties:<br>
<br>
<br>
========================= =====================================================================<br>
Property Description <br>
========================= =====================================================================<br>
alpha float <br>
animated [True | False] <br>
axes an axes instance <br>
backgroundcolor any matplotlib color <br>
bbox rectangle prop dict plus key 'pad' which is a pad in points <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
color any matplotlib color <br>
contains unknown <br>
family [ 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ] <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
fontproperties a matplotlib.font_manager.FontProperties instance <br>
horizontalalignment or ha [ 'center' | 'right' | 'left' ] <br>
label any string <br>
linespacing float <br>
lod [True | False] <br>
multialignment ['left' | 'right' | 'center' ] <br>
name or fontname string eg, ['Sans' | 'Courier' | 'Helvetica' ...] <br>
picker [None|float|boolean|callable] <br>
position (x,y) <br>
rotation [ angle in degrees 'vertical' | 'horizontal' <br>
size or fontsize [ size in points | relative size eg 'smaller', 'x-large' ] <br>
style or fontstyle [ 'normal' | 'italic' | 'oblique'] <br>
text string or anything printable with '%s' conversion <br>
transform unknown <br>
variant [ 'normal' | 'small-caps' ] <br>
verticalalignment or va [ 'center' | 'top' | 'bottom' | 'baseline' ] <br>
visible [True | False] <br>
weight or fontweight [ 'normal' | 'bold' | 'heavy' | 'light' | 'ultrabold' | 'ultralight']<br>
x float <br>
y float <br>
zorder any number <br>
========================= =====================================================================</tt></dd></dl>
<dl><dt><a name="-thetagrids"><strong>thetagrids</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the theta locations of the gridlines and ticklabels.<br>
<br>
If no arguments are passed, return a tuple (*lines*, *labels*)<br>
where *lines* is an array of radial gridlines<br>
(:class:`~matplotlib.lines.Line2D` instances) and *labels* is an<br>
array of tick labels (:class:`~matplotlib.text.Text` instances)::<br>
<br>
lines, labels = <a href="#-thetagrids">thetagrids</a>()<br>
<br>
Otherwise the syntax is::<br>
<br>
lines, labels = <a href="#-thetagrids">thetagrids</a>(angles, labels=None, fmt='%d', frac = 1.1)<br>
<br>
set the angles at which to place the theta grids (these gridlines<br>
are equal along the theta dimension).<br>
<br>
*angles* is in degrees.<br>
<br>
*labels*, if not *None*, is a len(angles) list of strings of the<br>
labels to use at each angle.<br>
<br>
If *labels* is *None*, the labels will be ``fmt%angle``.<br>
<br>
*frac* is the fraction of the polar axes radius at which to place<br>
the label (1 is the edge). Eg. 1.05 is outside the axes and 0.95<br>
is inside the axes.<br>
<br>
Return value is a list of tuples (*lines*, *labels*):<br>
<br>
- *lines* are :class:`~matplotlib.lines.Line2D` instances<br>
<br>
- *labels* are :class:`~matplotlib.text.Text` instances.<br>
<br>
Note that on input, the *labels* argument is a list of strings,<br>
and on output it is a list of :class:`~matplotlib.text.Text`<br>
instances.<br>
<br>
Examples::<br>
<br>
# set the locations of the radial gridlines and labels<br>
lines, labels = <a href="#-thetagrids">thetagrids</a>( range(45,360,90) )<br>
<br>
# set the locations and labels of the radial gridlines and labels<br>
lines, labels = <a href="#-thetagrids">thetagrids</a>( range(45,360,90), ('NE', 'NW', 'SW','SE') )</tt></dd></dl>
<dl><dt><a name="-title"><strong>title</strong></a>(s, *args, **kwargs)</dt><dd><tt>Set the title of the current axis to *s*.<br>
<br>
Default font override is::<br>
<br>
override = {'fontsize': 'medium',<br>
'verticalalignment': 'bottom',<br>
'horizontalalignment': 'center'}<br>
<br>
See the :func:`~matplotlib.pyplot.text` docstring for information<br>
of how override and the optional args work.</tt></dd></dl>
<dl><dt><a name="-twinx"><strong>twinx</strong></a>(ax<font color="#909090">=None</font>)</dt><dd><tt>Make a second axes overlay *ax* (or the current axes if *ax* is<br>
*None*) sharing the xaxis. The ticks for *ax2* will be placed on<br>
the right, and the *ax2* instance is returned.<br>
<br>
See :file:`examples/pylab_examples/two_scales.py`</tt></dd></dl>
<dl><dt><a name="-twiny"><strong>twiny</strong></a>(ax<font color="#909090">=None</font>)</dt><dd><tt>Make a second axes overlay *ax* (or the current axes if *ax* is<br>
*None*) sharing the yaxis. The ticks for *ax2* will be placed on<br>
the top, and the *ax2* instance is returned.</tt></dd></dl>
<dl><dt><a name="-vlines"><strong>vlines</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-vlines">vlines</a>(x, ymin, ymax, color='k')<br>
<br>
Plot vertical lines at each *x* from *ymin* to *ymax*. *ymin*<br>
or *ymax* can be scalars or len(*x*) numpy arrays. If they are<br>
scalars, then the respective values are constant, else the<br>
heights of the lines are determined by *ymin* and *ymax*.<br>
<br>
*colors* is a line collections color args, either a single color<br>
or a len(*x*) list of colors<br>
<br>
*linestyle* is one of [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]<br>
<br>
Returns the :class:`matplotlib.collections.LineCollection`<br>
that was added.<br>
<br>
kwargs are :class:`~matplotlib.collections.LineCollection` properties:<br>
<br>
<br>
============ ======================================================================<br>
Property Description <br>
============ ======================================================================<br>
alpha float <br>
animated [True | False] <br>
antialiased Boolean or sequence of booleans <br>
antialiaseds Boolean or sequence of booleans <br>
array unknown <br>
axes an axes instance <br>
clim a length 2 sequence of floats <br>
clip_box a :class:`matplotlib.transform.Bbox` instance <br>
clip_on [True | False] <br>
clip_path a :class:`~matplotlib.path.Path` instance and a <br>
cmap a colormap <br>
color matplotlib color arg or sequence of rgba tuples <br>
colorbar unknown <br>
contains unknown <br>
dashes ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
edgecolor matplotlib color arg or sequence of rgba tuples <br>
edgecolors matplotlib color arg or sequence of rgba tuples <br>
facecolor matplotlib color arg or sequence of rgba tuples <br>
facecolors matplotlib color arg or sequence of rgba tuples <br>
figure a :class:`matplotlib.figure.Figure` instance <br>
label any string <br>
linestyle ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linestyles ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth float or sequence of floats <br>
linewidths float or sequence of floats <br>
lod [True | False] <br>
lw float or sequence of floats <br>
norm unknown <br>
offsets float or sequence of floats <br>
picker [None|float|boolean|callable] <br>
pickradius unknown <br>
segments unknown <br>
transform unknown <br>
verts unknown <br>
visible [True | False] <br>
zorder any number <br>
============ ======================================================================<br>
<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-waitforbuttonpress"><strong>waitforbuttonpress</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-waitforbuttonpress">waitforbuttonpress</a>(self, timeout=-1)<br>
<br>
Blocking call to interact with the figure.<br>
<br>
This will return True is a key was pressed, False if a mouse<br>
button was pressed and None if *timeout* was reached without<br>
either being pressed.<br>
<br>
If *timeout* is negative, does not timeout.</tt></dd></dl>
<dl><dt><a name="-winter"><strong>winter</strong></a>()</dt><dd><tt>Set the default colormap to winter and apply to current image if any.<br>
See :func:`colormaps` for more information.</tt></dd></dl>
<dl><dt><a name="-xcorr"><strong>xcorr</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-xcorr">xcorr</a>(x, y, normed=False, detrend=mlab.detrend_none,<br>
usevlines=False, **kwargs):<br>
<br>
Plot the cross correlation between *x* and *y*. If *normed* =<br>
*True*, normalize the data but the cross correlation at 0-th<br>
lag. *x* and y are detrended by the *detrend* callable<br>
(default no normalization). *x* and *y* must be equal length.<br>
<br>
Data are plotted as ``<a href="#-plot">plot</a>(lags, c, **kwargs)``<br>
<br>
Return value is a tuple (*lags*, *c*, *line*) where:<br>
<br>
- *lags* are a length ``2*maxlags+1`` lag vector<br>
<br>
- *c* is the ``2*maxlags+1`` auto correlation vector<br>
<br>
- *line* is a :class:`~matplotlib.lines.Line2D` instance<br>
returned by :func:`~matplotlib.pyplot.plot`.<br>
<br>
The default *linestyle* is *None* and the default *marker* is<br>
'o', though these can be overridden with keyword args. The<br>
cross correlation is performed with :func:`numpy.correlate`<br>
with *mode* = 2.<br>
<br>
If *usevlines* is *True*:<br>
<br>
:func:`~matplotlib.pyplot.vlines`<br>
rather than :func:`~matplotlib.pyplot.plot` is used to draw<br>
vertical lines from the origin to the xcorr. Otherwise the<br>
plotstyle is determined by the kwargs, which are<br>
:class:`~matplotlib.lines.Line2D` properties.<br>
<br>
The return value is a tuple (*lags*, *c*, *linecol*, *b*)<br>
where *linecol* is the<br>
:class:`matplotlib.collections.LineCollection` instance and<br>
*b* is the *x*-axis.<br>
<br>
*maxlags* is a positive integer detailing the number of lags to show.<br>
The default value of *None* will return all ``(2*len(x)-1)`` lags.<br>
<br>
**Example:**<br>
<br>
:func:`~matplotlib.pyplot.xcorr` above, and<br>
:func:`~matplotlib.pyplot.acorr` below.<br>
<br>
**Example:**<br>
<br>
.. plot:: ../mpl_examples/pylab_examples/xcorr_demo.py<br>
<br>
Additional kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-xlabel"><strong>xlabel</strong></a>(s, *args, **kwargs)</dt><dd><tt>Set the *x* axis label of the current axis to *s*<br>
<br>
Default override is::<br>
<br>
override = {<br>
'fontsize' : 'small',<br>
'verticalalignment' : 'top',<br>
'horizontalalignment' : 'center'<br>
}<br>
<br>
See :func:`~matplotlib.pyplot.text` for information of how<br>
override and the optional args work</tt></dd></dl>
<dl><dt><a name="-xlim"><strong>xlim</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the xlimits of the current axes::<br>
<br>
xmin, xmax = <a href="#-xlim">xlim</a>() # return the current xlim<br>
<a href="#-xlim">xlim</a>( (xmin, xmax) ) # set the xlim to xmin, xmax<br>
<a href="#-xlim">xlim</a>( xmin, xmax ) # set the xlim to xmin, xmax<br>
<br>
If you do not specify args, you can pass the xmin and xmax as<br>
kwargs, eg.::<br>
<br>
<a href="#-xlim">xlim</a>(xmax=3) # adjust the max leaving min unchanged<br>
<a href="#-xlim">xlim</a>(xmin=1) # adjust the min leaving max unchanged<br>
<br>
The new axis limits are returned as a length 2 tuple.</tt></dd></dl>
<dl><dt><a name="-xscale"><strong>xscale</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-xscale">xscale</a>(scale, **kwargs)<br>
<br>
Set the scaling for the x-axis: 'linear' | 'log' | 'symlog'<br>
<br>
Different keywords may be accepted, depending on the scale:<br>
<br>
'linear'<br>
<br>
<br>
<br>
<br>
<br>
'log'<br>
<br>
*basex*/*basey*:<br>
The base of the logarithm<br>
<br>
*subsx*/*subsy*:<br>
Where to place the subticks between each major tick.<br>
Should be a sequence of integers. For example, in a log10<br>
scale: ``[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]``<br>
<br>
will place 10 logarithmically spaced minor ticks between<br>
each major tick.<br>
<br>
<br>
'symlog'<br>
<br>
*basex*/*basey*:<br>
The base of the logarithm<br>
<br>
*linthreshx*/*linthreshy*:<br>
The range (-*x*, *x*) within which the plot is linear (to<br>
avoid having the plot go to infinity around zero).<br>
<br>
*subsx*/*subsy*:<br>
Where to place the subticks between each major tick.<br>
Should be a sequence of integers. For example, in a log10<br>
scale: ``[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]``<br>
<br>
will place 10 logarithmically spaced minor ticks between<br>
each major tick.</tt></dd></dl>
<dl><dt><a name="-xticks"><strong>xticks</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the xlimits of the current ticklocs and labels::<br>
<br>
# return locs, labels where locs is an array of tick locations and<br>
# labels is an array of tick labels.<br>
locs, labels = <a href="#-xticks">xticks</a>()<br>
<br>
# set the locations of the xticks<br>
<a href="#-xticks">xticks</a>( arange(6) )<br>
<br>
# set the locations and labels of the xticks<br>
<a href="#-xticks">xticks</a>( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )<br>
<br>
The keyword args, if any, are :class:`~matplotlib.text.Text`<br>
properties.</tt></dd></dl>
<dl><dt><a name="-ylabel"><strong>ylabel</strong></a>(s, *args, **kwargs)</dt><dd><tt>Set the *y* axis label of the current axis to *s*.<br>
<br>
Defaults override is::<br>
<br>
override = {<br>
'fontsize' : 'small',<br>
'verticalalignment' : 'center',<br>
'horizontalalignment' : 'right',<br>
'rotation'='vertical' : }<br>
<br>
See :func:`~matplotlib.pyplot.text` for information on how<br>
override and the optional args work.</tt></dd></dl>
<dl><dt><a name="-ylim"><strong>ylim</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the ylimits of the current axes::<br>
<br>
ymin, ymax = <a href="#-ylim">ylim</a>() # return the current ylim<br>
<a href="#-ylim">ylim</a>( (ymin, ymax) ) # set the ylim to ymin, ymax<br>
<a href="#-ylim">ylim</a>( ymin, ymax ) # set the ylim to ymin, ymax<br>
<br>
If you do not specify args, you can pass the *ymin* and *ymax* as<br>
kwargs, eg.::<br>
<br>
<a href="#-ylim">ylim</a>(ymax=3) # adjust the max leaving min unchanged<br>
<a href="#-ylim">ylim</a>(ymin=1) # adjust the min leaving max unchanged<br>
<br>
The new axis limits are returned as a length 2 tuple.</tt></dd></dl>
<dl><dt><a name="-yscale"><strong>yscale</strong></a>(*args, **kwargs)</dt><dd><tt>call signature::<br>
<br>
<a href="#-xscale">xscale</a>(scale, **kwargs)<br>
<br>
Set the scaling for the y-axis: 'linear' | 'log' | 'symlog'<br>
<br>
Different keywords may be accepted, depending on the scale:<br>
<br>
'linear'<br>
<br>
<br>
<br>
<br>
<br>
'log'<br>
<br>
*basex*/*basey*:<br>
The base of the logarithm<br>
<br>
*subsx*/*subsy*:<br>
Where to place the subticks between each major tick.<br>
Should be a sequence of integers. For example, in a log10<br>
scale: ``[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]``<br>
<br>
will place 10 logarithmically spaced minor ticks between<br>
each major tick.<br>
<br>
<br>
'symlog'<br>
<br>
*basex*/*basey*:<br>
The base of the logarithm<br>
<br>
*linthreshx*/*linthreshy*:<br>
The range (-*x*, *x*) within which the plot is linear (to<br>
avoid having the plot go to infinity around zero).<br>
<br>
*subsx*/*subsy*:<br>
Where to place the subticks between each major tick.<br>
Should be a sequence of integers. For example, in a log10<br>
scale: ``[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]``<br>
<br>
will place 10 logarithmically spaced minor ticks between<br>
each major tick.</tt></dd></dl>
<dl><dt><a name="-yticks"><strong>yticks</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the ylimits of the current ticklocs and labels::<br>
<br>
# return locs, labels where locs is an array of tick locations and<br>
# labels is an array of tick labels.<br>
locs, labels = <a href="#-yticks">yticks</a>()<br>
<br>
# set the locations of the yticks<br>
<a href="#-yticks">yticks</a>( arange(6) )<br>
<br>
# set the locations and labels of the yticks<br>
<a href="#-yticks">yticks</a>( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )<br>
<br>
The keyword args, if any, are :class:`~matplotlib.text.Text`<br>
properties.</tt></dd></dl>
</td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#55aa55">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Data</strong></big></font></td></tr>
<tr><td bgcolor="#55aa55"><tt> </tt></td><td> </td>
<td width="100%"><strong>colorbar_doc</strong> = '<font color="#c040c0">\n\n</font>Add a colorbar to a plot.<font color="#c040c0">\n\n</font>Function signatures...e, do not use any of the axes properties kwargs.<font color="#c040c0">\n</font>'<br>
<strong>rcParams</strong> = {'figure.subplot.right': 0.90000000000000002, 'm...persize': 'letter', 'svg.embed_char_paths': True}<br>
<strong>rcParamsDefault</strong> = {'figure.subplot.right': 0.90000000000000002, 'm...persize': 'letter', 'svg.embed_char_paths': True}<br>
<strong>x</strong> = 'symlog'</td></tr></table>
@footer@
