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