doc_content stringlengths 1 386k | doc_id stringlengths 5 188 |
|---|---|
matplotlib.axes.Axes.hexbin Axes.hexbin(x, y, C=None, gridsize=100, bins=None, xscale='linear', yscale='linear', extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='face', reduce_C_function=<function mean>, mincnt=None, marginals=False, *, data=None, **kwargs)[source]
Make a 2D hexagonal binning plot of points x, y. If C is None, the value of the hexagon is determined by the number of points in the hexagon. Otherwise, C specifies values at the coordinate (x[i], y[i]). For each hexagon, these values are reduced using reduce_C_function. Parameters
x, yarray-like
The data positions. x and y must be of the same length.
Carray-like, optional
If given, these values are accumulated in the bins. Otherwise, every point has a value of 1. Must be of the same length as x and y.
gridsizeint or (int, int), default: 100
If a single int, the number of hexagons in the x-direction. The number of hexagons in the y-direction is chosen such that the hexagons are approximately regular. Alternatively, if a tuple (nx, ny), the number of hexagons in the x-direction and the y-direction.
bins'log' or int or sequence, default: None
Discretization of the hexagon values. 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 colormap. Internally, \(log_{10}(i+1)\) is used to determine the hexagon color. This is equivalent to norm=LogNorm(). 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'}, default: 'linear'
Use a linear or log10 scale on the horizontal axis.
yscale{'linear', 'log'}, default: 'linear'
Use a linear or log10 scale on the vertical axis.
mincntint > 0, default: None
If not None, only display cells with more than mincnt number of points in the cell.
marginalsbool, default: False
If marginals is True, plot the marginal density as colormapped rectangles along the bottom of the x-axis and left of the y-axis.
extent4-tuple of float, default: None
The limits of the bins (xmin, xmax, ymin, ymax). The default assigns the limits based on gridsize, x, y, xscale and yscale. If xscale or yscale is set to 'log', the limits are expected to be the exponent for a power of 10. E.g. for x-limits of 1 and 50 in 'linear' scale and y-limits of 10 and 1000 in 'log' scale, enter (1, 50, 1, 3). Returns
PolyCollection
A PolyCollection defining the hexagonal bins.
PolyCollection.get_offsets contains a Mx2 array containing the x, y positions of the M hexagon centers.
PolyCollection.get_array contains the values of the M hexagons. If marginals is True, horizontal bar and vertical bar (both PolyCollections) will be attached to the return collection as attributes hbar and vbar. Other Parameters
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
The Colormap instance or registered colormap name used to map the bin values to colors.
normNormalize, optional
The Normalize instance scales the bin values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling.
vmin, vmaxfloat, default: None
The colorbar range. If None, suitable min/max values are automatically chosen by the Normalize instance (defaults to the respective min/max values of the bins in case of the default linear scaling). It is an error to use vmin/vmax when norm is given.
alphafloat between 0 and 1, optional
The alpha blending value, between 0 (transparent) and 1 (opaque).
linewidthsfloat, default: None
If None, defaults to 1.0.
edgecolors{'face', 'none', None} or color, default: 'face'
The color of the hexagon edges. Possible values are: 'face': Draw the edges in the same color as the fill color. 'none': No edges are drawn. This can sometimes lead to unsightly unpainted pixels between the hexagons.
None: Draw outlines in the default color. An explicit color.
reduce_C_functioncallable, default: numpy.mean
The function to aggregate C within the bins. It is ignored if C is not given. This must have the signature: def reduce_C_function(C: array) -> float
Commonly used functions are:
numpy.mean: average of the points
numpy.sum: integral of the point values
numpy.amax: value taken from the largest point
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x, y, C
**kwargsPolyCollection properties
All other keyword arguments are passed on to PolyCollection:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha array-like or scalar or None
animated bool
antialiased or aa or antialiaseds bool or list of bools
array array-like or None
capstyle CapStyle or {'butt', 'projecting', 'round'}
clim (vmin: float, vmax: float)
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
cmap Colormap or str or None
color color or list of rgba tuples
edgecolor or ec or edgecolors color or list of colors or 'face'
facecolor or facecolors or fc color or list of colors
figure Figure
gid str
hatch {'/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
in_layout bool
joinstyle JoinStyle or {'miter', 'round', 'bevel'}
label object
linestyle or dashes or linestyles or ls str or tuple or list thereof
linewidth or linewidths or lw float or list of floats
norm Normalize or None
offset_transform Transform
offsets (N, 2) or (2,) array-like
path_effects AbstractPathEffect
paths list of array-like
picker None or bool or float or callable
pickradius float
rasterized bool
sizes ndarray or None
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
transform Transform
url str
urls list of str or None
verts list of array-like
verts_and_codes unknown
visible bool
zorder float See also hist2d
2D histogram rectangular bins
Examples using matplotlib.axes.Axes.hexbin
Hexagonal binned plot
hexbin(x, y, C) | matplotlib._as_gen.matplotlib.axes.axes.hexbin |
matplotlib.axes.Axes.hist Axes.hist(x, bins=None, range=None, density=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, *, data=None, **kwargs)[source]
Plot a histogram. Compute and draw 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. See the documentation of the weights parameter to draw a histogram of already-binned data. Multiple data can be provided via x as a list of datasets of potentially different length ([x0, x1, ...]), or as a 2D ndarray in which each column is a dataset. Note that the ndarray form is transposed relative to the list form. Masked arrays are not supported. The bins, range, weights, and density parameters behave as in numpy.histogram. Parameters
x(n,) array or sequence of (n,) arrays
Input values, this takes either a single array or a sequence of arrays which are not required to be of the same length.
binsint or sequence or str, default: rcParams["hist.bins"] (default: 10)
If bins is an integer, it defines the number of equal-width bins in the range. If bins is a sequence, it defines the bin edges, including the left edge of the first bin and the right edge of the last bin; in this case, bins may be unequally spaced. All but the last (righthand-most) bin is half-open. In other words, if bins is: [1, 2, 3, 4]
then the first bin is [1, 2) (including 1, but excluding 2) and the second [2, 3). The last bin, however, is [3, 4], which includes 4. If bins is a string, it is one of the binning strategies supported by numpy.histogram_bin_edges: 'auto', 'fd', 'doane', 'scott', 'stone', 'rice', 'sturges', or 'sqrt'.
rangetuple or None, default: None
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. If bins is a sequence or range is specified, autoscaling is based on the specified bin range instead of the range of x.
densitybool, default: False
If True, draw and return a probability density: each bin will display the bin's raw count divided by the total number of counts and the bin width (density = counts / (sum(counts) * np.diff(bins))), so that the area under the histogram integrates to 1 (np.sum(density * np.diff(bins)) == 1). If stacked is also True, the sum of the histograms is normalized to 1.
weights(n,) array-like or None, default: None
An array of weights, of the same shape as x. Each value in x only contributes its associated weight towards the bin count (instead of 1). If density is True, the weights are normalized, so that the integral of the density over the range remains 1. This parameter can be used to draw a histogram of data that has already been binned, e.g. using numpy.histogram (by treating each bin as a single point with a weight equal to its count) counts, bins = np.histogram(data)
plt.hist(bins[:-1], bins, weights=counts)
(or you may alternatively use bar()).
cumulativebool or -1, default: False
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 density is also True then the histogram is normalized such that the last bin equals 1. If cumulative is a number less than 0 (e.g., -1), the direction of accumulation is reversed. In this case, if density is also True, then the histogram is normalized such that the first bin equals 1.
bottomarray-like, scalar, or None, default: None
Location of the bottom of each bin, ie. bins are drawn from bottom to bottom + hist(x, bins) If a scalar, the bottom of each bin is shifted by the same amount. If an array, each bin is shifted independently and the length of bottom must match the number of bins. If None, defaults to 0.
histtype{'bar', 'barstacked', 'step', 'stepfilled'}, default: 'bar'
The type of histogram to draw. 'bar' is a traditional bar-type histogram. If multiple data are given the bars are arranged side by side. '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 is by default filled.
align{'left', 'mid', 'right'}, default: 'mid'
The horizontal alignment of the histogram bars. '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{'vertical', 'horizontal'}, default: 'vertical'
If 'horizontal', barh will be used for bar-type histograms and the bottom kwarg will be the left edges.
rwidthfloat or None, default: None
The relative width of the bars as a fraction of the bin width. If None, automatically compute the width. Ignored if histtype is 'step' or 'stepfilled'.
logbool, default: False
If True, the histogram axis will be set to a log scale.
colorcolor or array-like of colors or None, default: None
Color or sequence of colors, one per dataset. Default (None) uses the standard line color sequence.
labelstr or None, default: None
String, or sequence of strings to match multiple datasets. Bar charts yield multiple patches per dataset, but only the first gets the label, so that legend will work as expected.
stackedbool, default: False
If True, multiple data are stacked on top of each other If False multiple data are arranged side by side if histtype is 'bar' or on top of each other if histtype is 'step' Returns
narray or list of arrays
The values of the histogram bins. See density and weights for a description of the possible semantics. If input x is an array, then this is an array of length nbins. If input is a sequence of arrays [data1, data2, ...], then this is a list of arrays with the values of the histograms for each of the arrays in the same order. The dtype of the array n (or of its element arrays) will always be float even if no weighting or normalization is used.
binsarray
The edges of the bins. Length nbins + 1 (nbins left edges and right edge of last bin). Always a single array even when multiple data sets are passed in.
patchesBarContainer or list of a single Polygon or list of such objects
Container of individual artists used to create the histogram or list of such containers if there are multiple input datasets. Other Parameters
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x, weights **kwargs
Patch properties See also hist2d
2D histogram with rectangular bins hexbin
2D histogram with hexagonal bins Notes For large numbers of bins (>1000), 'step' and 'stepfilled' can be significantly faster than 'bar' and 'barstacked'.
Examples using matplotlib.axes.Axes.hist
Scatter plot with histograms
Axes Demo
Using histograms to plot a cumulative distribution
Some features of the histogram (hist) function
The histogram (hist) function with multiple data sets
Placing text boxes
Simple axes labels
Bayesian Methods for Hackers style sheet
Scatter Histogram (Locatable Axes)
Animated histogram
Frontpage histogram example
MRI With EEG
Basic Usage
Artist tutorial
Path Tutorial
Transformations Tutorial
hist(x) | matplotlib._as_gen.matplotlib.axes.axes.hist |
matplotlib.axes.Axes.hist2d Axes.hist2d(x, y, bins=10, range=None, density=False, weights=None, cmin=None, cmax=None, *, data=None, **kwargs)[source]
Make a 2D histogram plot. Parameters
x, yarray-like, shape (n, )
Input values
binsNone or int or [int, int] or array-like or [array, array]
The bin specification: If int, the number of bins for the two dimensions (nx=ny=bins). If [int, int], the number of bins in each dimension (nx, ny = bins). If array-like, the bin edges for the two dimensions (x_edges=y_edges=bins). If [array, array], the bin edges in each dimension (x_edges, y_edges = bins). The default value is 10.
rangearray-like shape(2, 2), optional
The leftmost and rightmost edges of the bins along each dimension (if not specified explicitly in the bins parameters): [[xmin,
xmax], [ymin, ymax]]. All values outside of this range will be considered outliers and not tallied in the histogram.
densitybool, default: False
Normalize histogram. See the documentation for the density parameter of hist for more details.
weightsarray-like, shape (n, ), optional
An array of values w_i weighing each sample (x_i, y_i).
cmin, cmaxfloat, default: None
All bins that has count less than cmin or more than cmax will not be displayed (set to NaN before passing to imshow) and these count values in the return value count histogram will also be set to nan upon return. Returns
h2D array
The bi-dimensional histogram of samples x and y. Values in x are histogrammed along the first dimension and values in y are histogrammed along the second dimension.
xedges1D array
The bin edges along the x axis.
yedges1D array
The bin edges along the y axis.
imageQuadMesh
Other Parameters
cmapColormap or str, optional
A colors.Colormap instance. If not set, use rc settings.
normNormalize, optional
A colors.Normalize instance is used to scale luminance data to [0, 1]. If not set, defaults to colors.Normalize().
vmin/vmaxNone or scalar, optional
Arguments passed to the Normalize instance.
alpha0 <= scalar <= 1 or None, optional
The alpha blending value.
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x, y, weights **kwargs
Additional parameters are passed along to the pcolormesh method and QuadMesh constructor. See also hist
1D histogram plotting hexbin
2D histogram with hexagonal bins Notes Currently hist2d calculates its own axis limits, and any limits previously set are ignored. Rendering the histogram with a logarithmic color scale is accomplished by passing a colors.LogNorm instance to the norm keyword argument. Likewise, power-law normalization (similar in effect to gamma correction) can be accomplished with colors.PowerNorm.
Examples using matplotlib.axes.Axes.hist2d
Histograms
Exploring normalizations
hist2d(x, y) | matplotlib._as_gen.matplotlib.axes.axes.hist2d |
matplotlib.axes.Axes.hlines Axes.hlines(y, xmin, xmax, colors=None, linestyles='solid', label='', *, data=None, **kwargs)[source]
Plot horizontal lines at each y from xmin to xmax. Parameters
yfloat or array-like
y-indexes where to plot the lines.
xmin, xmaxfloat or array-like
Respective beginning and end of each line. If scalars are provided, all lines will have same length.
colorslist of colors, default: rcParams["lines.color"] (default: 'C0')
linestyles{'solid', 'dashed', 'dashdot', 'dotted'}, optional
labelstr, default: ''
Returns
LineCollection
Other Parameters
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): y, xmin, xmax, colors
**kwargsLineCollection properties.
See also vlines
vertical lines axhline
horizontal line across the Axes
Examples using matplotlib.axes.Axes.hlines
hlines and vlines
Specifying Colors | matplotlib._as_gen.matplotlib.axes.axes.hlines |
matplotlib.axes.Axes.imshow Axes.imshow(X, cmap=None, norm=None, *, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, interpolation_stage=None, filternorm=True, filterrad=4.0, resample=None, url=None, data=None, **kwargs)[source]
Display data as an image, i.e., on a 2D regular raster. The input may either be actual RGB(A) data, or 2D scalar data, which will be rendered as a pseudocolor image. For displaying a grayscale image set up the colormapping using the parameters cmap='gray', vmin=0, vmax=255. The number of pixels used to render an image is set by the Axes size and the dpi of the figure. This can lead to aliasing artifacts when the image is resampled because the displayed image size will usually not match the size of X (see Image antialiasing). The resampling can be controlled via the interpolation parameter and/or rcParams["image.interpolation"] (default: 'antialiased'). Parameters
Xarray-like or PIL image
The image data. Supported array shapes are: (M, N): an image with scalar data. The values are mapped to colors using normalization and a colormap. See parameters norm, cmap, vmin, vmax. (M, N, 3): an image with RGB values (0-1 float or 0-255 int). (M, N, 4): an image with RGBA values (0-1 float or 0-255 int), i.e. including transparency. The first two dimensions (M, N) define the rows and columns of the image. Out-of-range RGB(A) values are clipped.
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
The Colormap instance or registered colormap name used to map scalar data to colors. This parameter is ignored for RGB(A) data.
normNormalize, optional
The Normalize instance used to scale scalar data to the [0, 1] range before mapping to colors using cmap. By default, a linear scaling mapping the lowest value to 0 and the highest to 1 is used. This parameter is ignored for RGB(A) data.
aspect{'equal', 'auto'} or float, default: rcParams["image.aspect"] (default: 'equal')
The aspect ratio of the Axes. This parameter is particularly relevant for images since it determines whether data pixels are square. This parameter is a shortcut for explicitly calling Axes.set_aspect. See there for further details. 'equal': Ensures an aspect ratio of 1. Pixels will be square (unless pixel sizes are explicitly made non-square in data coordinates using extent). 'auto': The Axes is kept fixed and the aspect is adjusted so that the data fit in the Axes. In general, this will result in non-square pixels.
interpolationstr, default: rcParams["image.interpolation"] (default: 'antialiased')
The interpolation method used. Supported values are 'none', 'antialiased', 'nearest', 'bilinear', 'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos', 'blackman'. If interpolation is 'none', then no interpolation is performed on the Agg, ps, pdf and svg backends. Other backends will fall back to 'nearest'. Note that most SVG renderers perform interpolation at rendering and that the default interpolation method they implement may differ. If interpolation is the default 'antialiased', then 'nearest' interpolation is used if the image is upsampled by more than a factor of three (i.e. the number of display pixels is at least three times the size of the data array). If the upsampling rate is smaller than 3, or the image is downsampled, then 'hanning' interpolation is used to act as an anti-aliasing filter, unless the image happens to be upsampled by exactly a factor of two or one. See Interpolations for imshow for an overview of the supported interpolation methods, and Image antialiasing for a discussion of image antialiasing. Some interpolation methods require an additional radius parameter, which can be set by filterrad. Additionally, the antigrain image resize filter is controlled by the parameter filternorm.
interpolation_stage{'data', 'rgba'}, default: 'data'
If 'data', interpolation is carried out on the data provided by the user. If 'rgba', the interpolation is carried out after the colormapping has been applied (visual interpolation).
alphafloat or array-like, optional
The alpha blending value, between 0 (transparent) and 1 (opaque). If alpha is an array, the alpha blending values are applied pixel by pixel, and alpha must have the same shape as X.
vmin, vmaxfloat, optional
When using scalar data and no explicit norm, vmin and vmax define the data range that the colormap covers. By default, the colormap covers the complete value range of the supplied data. It is an error to use vmin/vmax when norm is given. When using RGB(A) data, parameters vmin/vmax are ignored.
origin{'upper', 'lower'}, default: rcParams["image.origin"] (default: 'upper')
Place the [0, 0] index of the array in the upper left or lower left corner of the Axes. The convention (the default) 'upper' is typically used for matrices and images. Note that the vertical axis points upward for 'lower' but downward for 'upper'. See the origin and extent in imshow tutorial for examples and a more detailed description.
extentfloats (left, right, bottom, top), optional
The bounding box in data coordinates that the image will fill. The image is stretched individually along x and y to fill the box. The default extent is determined by the following conditions. Pixels have unit size in data coordinates. Their centers are on integer coordinates, and their center coordinates range from 0 to columns-1 horizontally and from 0 to rows-1 vertically. Note that the direction of the vertical axis and thus the default values for top and bottom depend on origin: For origin == 'upper' the default is (-0.5, numcols-0.5, numrows-0.5, -0.5). For origin == 'lower' the default is (-0.5, numcols-0.5, -0.5, numrows-0.5). See the origin and extent in imshow tutorial for examples and a more detailed description.
filternormbool, default: True
A parameter for the antigrain image resize filter (see the antigrain documentation). If filternorm is set, 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.
filterradfloat > 0, default: 4.0
The filter radius for filters that have a radius parameter, i.e. when interpolation is one of: 'sinc', 'lanczos' or 'blackman'.
resamplebool, default: rcParams["image.resample"] (default: True)
When True, use a full resampling method. When False, only resample when the output image is larger than the input image.
urlstr, optional
Set the url of the created AxesImage. See Artist.set_url. Returns
AxesImage
Other Parameters
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception).
**kwargsArtist properties
These parameters are passed on to the constructor of the AxesImage artist. See also matshow
Plot a matrix or an array as an image. Notes Unless extent is used, pixel centers will be located at integer coordinates. In other words: the origin will coincide with the center of pixel (0, 0). There are two common representations for RGB images with an alpha channel: Straight (unassociated) alpha: R, G, and B channels represent the color of the pixel, disregarding its opacity. Premultiplied (associated) alpha: R, G, and B channels represent the color of the pixel, adjusted for its opacity by multiplication. imshow expects RGB images adopting the straight (unassociated) alpha representation.
Examples using matplotlib.axes.Axes.imshow
Bar chart with gradients
Barcode
Contour Demo
Creating annotated heatmaps
Image antialiasing
Clipping images with patches
Image Demo
Image Masked
Blend transparency with color in 2D images
Modifying the coordinate formatter
Interpolations for imshow
Pcolor Demo
Streamplot
Axes box aspect
Zoom region inset axes
Using a text as a Path
Colorbar
Creating a colormap from a list of colors
Anchored Direction Arrow
Axes Grid2
HBoxDivider demo
Adding a colorbar to inset axes
Colorbar with AxesDivider
Controlling the position and size of colorbars with Inset Axes
Inset Locator Demo2
Simple ImageGrid
Simple ImageGrid 2
Simple Colorbar
Shaded & power normalized rendering
pyplot animation
Animated image using a precomputed list of images
Image Slices Viewer
Viewlims
Patheffect Demo
MRI
MRI With EEG
Topographic hillshading
Dropped spines
Colorbar Tick Labelling
Interactive Adjustment of Colormap Range
Artist tutorial
Tight Layout guide
Choosing Colormaps in Matplotlib
imshow(Z) | matplotlib._as_gen.matplotlib.axes.axes.imshow |
matplotlib.axes.Axes.in_axes Axes.in_axes(mouseevent)[source]
Return whether the given event (in display coords) is in the Axes. | matplotlib._as_gen.matplotlib.axes.axes.in_axes |
matplotlib.axes.Axes.indicate_inset Axes.indicate_inset(bounds, inset_ax=None, *, transform=None, facecolor='none', edgecolor='0.5', alpha=0.5, zorder=4.99, **kwargs)[source]
Add an inset indicator to the Axes. This is a rectangle on the plot at the position indicated by bounds that optionally has lines that connect the rectangle to an inset Axes (Axes.inset_axes). Parameters
bounds[x0, y0, width, height]
Lower-left corner of rectangle to be marked, and its width and height.
inset_axAxes
An optional inset Axes to draw connecting lines to. Two lines are drawn connecting the indicator box to the inset Axes on corners chosen so as to not overlap with the indicator box.
transformTransform
Transform for the rectangle coordinates. Defaults to ax.transAxes, i.e. the units of rect are in Axes-relative coordinates.
facecolorcolor, default: 'none'
Facecolor of the rectangle.
edgecolorcolor, default: '0.5'
Color of the rectangle and color of the connecting lines.
alphafloat, default: 0.5
Transparency of the rectangle and connector lines.
zorderfloat, default: 4.99
Drawing order of the rectangle and connector lines. The default, 4.99, is just below the default level of inset Axes. **kwargs
Other keyword arguments are passed on to the Rectangle patch:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
angle unknown
animated bool
antialiased or aa bool or None
bounds (left, bottom, width, height)
capstyle CapStyle or {'butt', 'projecting', 'round'}
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
color color
edgecolor or ec color or None
facecolor or fc color or None
figure Figure
fill bool
gid str
hatch {'/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
height unknown
in_layout bool
joinstyle JoinStyle or {'miter', 'round', 'bevel'}
label object
linestyle or ls {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
linewidth or lw float or None
path_effects AbstractPathEffect
picker None or bool or float or callable
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
transform Transform
url str
visible bool
width unknown
x unknown
xy (float, float)
y unknown
zorder float Returns
rectangle_patchpatches.Rectangle
The indicator frame.
connector_lines4-tuple of patches.ConnectionPatch
The four connector lines connecting to (lower_left, upper_left, lower_right upper_right) corners of inset_ax. Two lines are set with visibility to False, but the user can set the visibility to True if the automatic choice is not deemed correct. Warning This method is experimental as of 3.0, and the API may change. | matplotlib._as_gen.matplotlib.axes.axes.indicate_inset |
matplotlib.axes.Axes.indicate_inset_zoom Axes.indicate_inset_zoom(inset_ax, **kwargs)[source]
Add an inset indicator rectangle to the Axes based on the axis limits for an inset_ax and draw connectors between inset_ax and the rectangle. Parameters
inset_axAxes
Inset Axes to draw connecting lines to. Two lines are drawn connecting the indicator box to the inset Axes on corners chosen so as to not overlap with the indicator box. **kwargs
Other keyword arguments are passed on to Axes.indicate_inset Returns
rectangle_patchpatches.Rectangle
Rectangle artist.
connector_lines4-tuple of patches.ConnectionPatch
Each of four connector lines coming from the rectangle drawn on this axis, in the order lower left, upper left, lower right, upper right. Two are set with visibility to False, but the user can set the visibility to True if the automatic choice is not deemed correct. Warning This method is experimental as of 3.0, and the API may change.
Examples using matplotlib.axes.Axes.indicate_inset_zoom
Zoom region inset axes | matplotlib._as_gen.matplotlib.axes.axes.indicate_inset_zoom |
matplotlib.axes.Axes.inset_axes Axes.inset_axes(bounds, *, transform=None, zorder=5, **kwargs)[source]
Add a child inset Axes to this existing Axes. Parameters
bounds[x0, y0, width, height]
Lower-left corner of inset Axes, and its width and height.
transformTransform
Defaults to ax.transAxes, i.e. the units of rect are in Axes-relative coordinates.
zordernumber
Defaults to 5 (same as Axes.legend). Adjust higher or lower to change whether it is above or below data plotted on the parent Axes. **kwargs
Other keyword arguments are passed on to the child Axes. Returns
ax
The created Axes instance. Warning This method is experimental as of 3.0, and the API may change. Examples This example makes two inset Axes, the first is in Axes-relative coordinates, and the second in data-coordinates: fig, ax = plt.subplots()
ax.plot(range(10))
axin1 = ax.inset_axes([0.8, 0.1, 0.15, 0.15])
axin2 = ax.inset_axes(
[5, 7, 2.3, 2.3], transform=ax.transData)
Examples using matplotlib.axes.Axes.inset_axes
Placing Colorbars
Zoom region inset axes | matplotlib._as_gen.matplotlib.axes.axes.inset_axes |
matplotlib.axes.Axes.invert_xaxis Axes.invert_xaxis()[source]
Invert the x-axis. See also xaxis_inverted
get_xlim, set_xlim
get_xbound, set_xbound | matplotlib._as_gen.matplotlib.axes.axes.invert_xaxis |
matplotlib.axes.Axes.invert_yaxis Axes.invert_yaxis()[source]
Invert the y-axis. See also yaxis_inverted
get_ylim, set_ylim
get_ybound, set_ybound
Examples using matplotlib.axes.Axes.invert_yaxis
Bar Label Demo
Horizontal bar chart
Marker reference | matplotlib._as_gen.matplotlib.axes.axes.invert_yaxis |
matplotlib.axes.Axes.legend Axes.legend(*args, **kwargs)[source]
Place a legend on the Axes. Call signatures: legend()
legend(handles, labels)
legend(handles=handles)
legend(labels)
The call signatures correspond to the following different ways to use this method: 1. Automatic detection of elements to be shown in the legend The elements to be added to the legend are automatically determined, when you do not pass in any extra arguments. In this case, the labels are taken from the artist. You can specify them either at artist creation or by calling the set_label() method on the artist: ax.plot([1, 2, 3], label='Inline label')
ax.legend()
or: line, = ax.plot([1, 2, 3])
line.set_label('Label via method')
ax.legend()
Specific lines can be excluded from the automatic legend element selection by defining a label starting with an underscore. This is default for all artists, so calling Axes.legend without any arguments and without setting the labels manually will result in no legend being drawn. 2. Explicitly listing the artists and labels in the legend For full control of which artists have a legend entry, it is possible to pass an iterable of legend artists followed by an iterable of legend labels respectively: ax.legend([line1, line2, line3], ['label1', 'label2', 'label3'])
3. Explicitly listing the artists in the legend This is similar to 2, but the labels are taken from the artists' label properties. Example: line1, = ax.plot([1, 2, 3], label='label1')
line2, = ax.plot([1, 2, 3], label='label2')
ax.legend(handles=[line1, line2])
4. Labeling existing plot elements Discouraged This call signature is discouraged, because the relation between plot elements and labels is only implicit by their order and can easily be mixed up. To make a legend for all artists on an Axes, call this function with an iterable of strings, one for each legend item. For example: ax.plot([1, 2, 3])
ax.plot([5, 6, 7])
ax.legend(['First line', 'Second line'])
Parameters
handlessequence of Artist, optional
A list of Artists (lines, patches) to be added to the legend. Use this together with labels, if you need full control on what is shown in the legend and the automatic mechanism described above is not sufficient. The length of handles and labels should be the same in this case. If they are not, they are truncated to the smaller length.
labelslist of str, optional
A list of labels to show next to the artists. Use this together with handles, if you need full control on what is shown in the legend and the automatic mechanism described above is not sufficient. Returns
Legend
Other Parameters
locstr or pair of floats, default: rcParams["legend.loc"] (default: 'best') ('best' for axes, 'upper right' for figures)
The location of the legend. The strings 'upper left', 'upper right', 'lower left', 'lower right' place the legend at the corresponding corner of the axes/figure. The strings 'upper center', 'lower center', 'center left', 'center right' place the legend at the center of the corresponding edge of the axes/figure. The string 'center' places the legend at the center of the axes/figure. The string 'best' places the legend at the location, among the nine locations defined so far, with the minimum overlap with other drawn artists. This option can be quite slow for plots with large amounts of data; your plotting speed may benefit from providing a specific location. The location can also be a 2-tuple giving the coordinates of the lower-left corner of the legend in axes coordinates (in which case bbox_to_anchor will be ignored). For back-compatibility, 'center right' (but no other location) can also be spelled 'right', and each "string" locations can also be given as a numeric value:
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
bbox_to_anchorBboxBase, 2-tuple, or 4-tuple of floats
Box that is used to position the legend in conjunction with loc. Defaults to axes.bbox (if called as a method to Axes.legend) or figure.bbox (if Figure.legend). This argument allows arbitrary placement of the legend. Bbox coordinates are interpreted in the coordinate system given by bbox_transform, with the default transform Axes or Figure coordinates, depending on which legend is called. If a 4-tuple or BboxBase is given, then it specifies the bbox (x, y, width, height) that the legend is placed in. To put the legend in the best location in the bottom right quadrant of the axes (or figure): loc='best', bbox_to_anchor=(0.5, 0., 0.5, 0.5)
A 2-tuple (x, y) places the corner of the legend specified by loc at x, y. For example, to put the legend's upper right-hand corner in the center of the axes (or figure) the following keywords can be used: loc='upper right', bbox_to_anchor=(0.5, 0.5)
ncolint, default: 1
The number of columns that the legend has.
propNone or matplotlib.font_manager.FontProperties or dict
The font properties of the legend. If None (default), the current matplotlib.rcParams will be used.
fontsizeint or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}
The font size of the legend. If the value is numeric the size will be the absolute font size in points. String values are relative to the current default font size. This argument is only used if prop is not specified.
labelcolorstr or list, default: rcParams["legend.labelcolor"] (default: 'None')
The color of the text in the legend. Either a valid color string (for example, 'red'), or a list of color strings. The labelcolor can also be made to match the color of the line or marker using 'linecolor', 'markerfacecolor' (or 'mfc'), or 'markeredgecolor' (or 'mec'). Labelcolor can be set globally using rcParams["legend.labelcolor"] (default: 'None'). If None, use rcParams["text.color"] (default: 'black').
numpointsint, default: rcParams["legend.numpoints"] (default: 1)
The number of marker points in the legend when creating a legend entry for a Line2D (line).
scatterpointsint, default: rcParams["legend.scatterpoints"] (default: 1)
The number of marker points in the legend when creating a legend entry for a PathCollection (scatter plot).
scatteryoffsetsiterable of floats, default: [0.375, 0.5, 0.3125]
The vertical offset (relative to the font size) for the markers created for a scatter plot legend entry. 0.0 is at the base the legend text, and 1.0 is at the top. To draw all markers at the same height, set to [0.5].
markerscalefloat, default: rcParams["legend.markerscale"] (default: 1.0)
The relative size of legend markers compared with the originally drawn ones.
markerfirstbool, default: True
If True, legend marker is placed to the left of the legend label. If False, legend marker is placed to the right of the legend label.
frameonbool, default: rcParams["legend.frameon"] (default: True)
Whether the legend should be drawn on a patch (frame).
fancyboxbool, default: rcParams["legend.fancybox"] (default: True)
Whether round edges should be enabled around the FancyBboxPatch which makes up the legend's background.
shadowbool, default: rcParams["legend.shadow"] (default: False)
Whether to draw a shadow behind the legend.
framealphafloat, default: rcParams["legend.framealpha"] (default: 0.8)
The alpha transparency of the legend's background. If shadow is activated and framealpha is None, the default value is ignored.
facecolor"inherit" or color, default: rcParams["legend.facecolor"] (default: 'inherit')
The legend's background color. If "inherit", use rcParams["axes.facecolor"] (default: 'white').
edgecolor"inherit" or color, default: rcParams["legend.edgecolor"] (default: '0.8')
The legend's background patch edge color. If "inherit", use take rcParams["axes.edgecolor"] (default: 'black').
mode{"expand", None}
If mode is set to "expand" the legend will be horizontally expanded to fill the axes area (or bbox_to_anchor if defines the legend's size).
bbox_transformNone or matplotlib.transforms.Transform
The transform for the bounding box (bbox_to_anchor). For a value of None (default) the Axes' transAxes transform will be used.
titlestr or None
The legend's title. Default is no title (None).
title_fontpropertiesNone or matplotlib.font_manager.FontProperties or dict
The font properties of the legend's title. If None (default), the title_fontsize argument will be used if present; if title_fontsize is also None, the current rcParams["legend.title_fontsize"] (default: None) will be used.
title_fontsizeint or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default: rcParams["legend.title_fontsize"] (default: None)
The font size of the legend's title. Note: This cannot be combined with title_fontproperties. If you want to set the fontsize alongside other font properties, use the size parameter in title_fontproperties.
borderpadfloat, default: rcParams["legend.borderpad"] (default: 0.4)
The fractional whitespace inside the legend border, in font-size units.
labelspacingfloat, default: rcParams["legend.labelspacing"] (default: 0.5)
The vertical space between the legend entries, in font-size units.
handlelengthfloat, default: rcParams["legend.handlelength"] (default: 2.0)
The length of the legend handles, in font-size units.
handleheightfloat, default: rcParams["legend.handleheight"] (default: 0.7)
The height of the legend handles, in font-size units.
handletextpadfloat, default: rcParams["legend.handletextpad"] (default: 0.8)
The pad between the legend handle and text, in font-size units.
borderaxespadfloat, default: rcParams["legend.borderaxespad"] (default: 0.5)
The pad between the axes and legend border, in font-size units.
columnspacingfloat, default: rcParams["legend.columnspacing"] (default: 2.0)
The spacing between columns, in font-size units.
handler_mapdict or None
The custom dictionary mapping instances or types to a legend handler. This handler_map updates the default handler map found at matplotlib.legend.Legend.get_legend_handler_map. See also Figure.legend
Notes Some artists are not supported by this function. See Legend guide for details. Examples (Source code, png, pdf)
Examples using matplotlib.axes.Axes.legend
Bar Label Demo
Stacked bar chart
Grouped bar chart with labels
Plotting categorical variables
Fill Between and Alpha
Hat graph
Customizing dashed line styles
Lines with a ticked patheffect
prop_cycle property markevery in rcParams
Scatter plots with a legend
Stackplots and streamgraphs
Stairs Demo
Contourf Hatching
Tricontour Demo
Secondary Axis
Plot a confidence ellipse of a two-dimensional dataset
Using histograms to plot a cumulative distribution
The histogram (hist) function with multiple data sets
Bar of pie
Labeling a pie and a donut
Polar Legend
Composing Custom Legends
Legend using pre-defined labels
Legend Demo
Mathtext
Rendering math equations using TeX
Parasite Axes demo
Parasite axis demo
Anatomy of a figure
Legend Picking
Patheffect Demo
TickedStroke patheffect
Plot 2D data on 3D plot
Parametric Curve
Multiple Yaxis With Spines
Group barchart with units
Simple Legend01
Simple Legend02
Basic Usage
Legend guide
Constrained Layout Guide
Tight Layout guide
Specifying Colors | matplotlib._as_gen.matplotlib.axes.axes.legend |
matplotlib.axes.Axes.locator_params Axes.locator_params(axis='both', tight=None, **kwargs)[source]
Control behavior of major tick locators. Because the locator is involved in autoscaling, autoscale_view is called automatically after the parameters are changed. Parameters
axis{'both', 'x', 'y'}, default: 'both'
The axis on which to operate.
tightbool or None, optional
Parameter passed to autoscale_view. Default is None, for no change. Other Parameters
**kwargs
Remaining keyword arguments are passed to directly to the set_params() method of the locator. Supported keywords depend on the type of the locator. See for example set_params for the ticker.MaxNLocator used by default for linear axes. Examples When plotting small subplots, one might want to reduce the maximum number of ticks and use tight bounds, for example: ax.locator_params(tight=True, nbins=4)
Examples using matplotlib.axes.Axes.locator_params
Contourf Demo
Constrained Layout Guide
Tight Layout guide | matplotlib._as_gen.matplotlib.axes.axes.locator_params |
matplotlib.axes.Axes.loglog Axes.loglog(*args, **kwargs)[source]
Make a plot with log scaling on both the x and y axis. Call signatures: loglog([x], y, [fmt], data=None, **kwargs)
loglog([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)
This is just a thin wrapper around plot which additionally changes both the x-axis and the y-axis to log scaling. All of the concepts and parameters of plot can be used here as well. The additional parameters base, subs and nonpositive control the x/y-axis properties. They are just forwarded to Axes.set_xscale and Axes.set_yscale. To use different properties on the x-axis and the y-axis, use e.g. ax.set_xscale("log", base=10); ax.set_yscale("log", base=2). Parameters
basefloat, default: 10
Base of the logarithm.
subssequence, optional
The location of the minor ticks. If None, reasonable locations are automatically chosen depending on the number of decades in the plot. See Axes.set_xscale/Axes.set_yscale for details.
nonpositive{'mask', 'clip'}, default: 'mask'
Non-positive values can be masked as invalid, or clipped to a very small positive number. **kwargs
All parameters supported by plot. Returns
list of Line2D
Objects representing the plotted data.
Examples using matplotlib.axes.Axes.loglog
Secondary Axis
Log Demo | matplotlib._as_gen.matplotlib.axes.axes.loglog |
matplotlib.axes.Axes.magnitude_spectrum Axes.magnitude_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, scale=None, *, data=None, **kwargs)[source]
Plot the magnitude spectrum. Compute the magnitude spectrum of x. Data is padded to a length of pad_to and the windowing function window is applied to the signal. Parameters
x1-D array or sequence
Array or sequence containing the data.
Fsfloat, default: 2
The sampling frequency (samples per time unit). It is used to calculate the Fourier frequencies, freqs, in cycles per time unit.
windowcallable or ndarray, default: window_hanning
A function or a vector of length NFFT. To create window vectors see window_hanning, window_none, numpy.blackman, numpy.hamming, numpy.bartlett, scipy.signal, scipy.signal.get_window, etc. If a function is passed as the argument, it must take a data segment as an argument and return the windowed version of the segment.
sides{'default', 'onesided', 'twosided'}, optional
Which sides of the spectrum to return. 'default' is one-sided for real data and two-sided for complex data. 'onesided' forces the return of a one-sided spectrum, while 'twosided' forces two-sided.
pad_toint, optional
The number of points to which the data segment is padded when performing the FFT. While not increasing the actual resolution of the spectrum (the minimum distance between resolvable peaks), this can give more points in the plot, allowing for more detail. This corresponds to the n parameter in the call to fft(). The default is None, which sets pad_to equal to the length of the input signal (i.e. no padding).
scale{'default', 'linear', 'dB'}
The scaling of the values in the spec. 'linear' is no scaling. 'dB' returns the values in dB scale, i.e., the dB amplitude (20 * log10). 'default' is 'linear'.
Fcint, default: 0
The center frequency of x, which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. Returns
spectrum1-D array
The values for the magnitude spectrum before scaling (real valued).
freqs1-D array
The frequencies corresponding to the elements in spectrum.
lineLine2D
The line created by this function. Other Parameters
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x **kwargs
Keyword arguments control the Line2D properties:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
antialiased or aa bool
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
color or c color
dash_capstyle CapStyle or {'butt', 'projecting', 'round'}
dash_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
dashes sequence of floats (on/off ink in points) or (None, None)
data (2, N) array or two 1D arrays
drawstyle or ds {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
figure Figure
fillstyle {'full', 'left', 'right', 'bottom', 'top', 'none'}
gid str
in_layout bool
label object
linestyle or ls {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
linewidth or lw float
marker marker style string, Path or MarkerStyle
markeredgecolor or mec color
markeredgewidth or mew float
markerfacecolor or mfc color
markerfacecoloralt or mfcalt color
markersize or ms float
markevery None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]
path_effects AbstractPathEffect
picker float or callable[[Artist, Event], tuple[bool, dict]]
pickradius float
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
solid_capstyle CapStyle or {'butt', 'projecting', 'round'}
solid_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
transform unknown
url str
visible bool
xdata 1D array
ydata 1D array
zorder float See also psd
Plots the power spectral density. angle_spectrum
Plots the angles of the corresponding frequencies. phase_spectrum
Plots the phase (unwrapped angle) of the corresponding frequencies. specgram
Can plot the magnitude spectrum of segments within the signal in a colormap. | matplotlib._as_gen.matplotlib.axes.axes.magnitude_spectrum |
matplotlib.axes.Axes.margins Axes.margins(*margins, x=None, y=None, tight=True)[source]
Set or retrieve autoscaling margins. The padding added to each limit of the Axes is the margin times the data interval. All input parameters must be floats within the range [0, 1]. Passing both positional and keyword arguments is invalid and will raise a TypeError. If no arguments (positional or otherwise) are provided, the current margins will remain in place and simply be returned. Specifying any margin changes only the autoscaling; for example, if xmargin is not None, then xmargin times the X data interval will be added to each end of that interval before it is used in autoscaling. Parameters
*marginsfloat, optional
If a single positional argument is provided, it specifies both margins of the x-axis and y-axis limits. If two positional arguments are provided, they will be interpreted as xmargin, ymargin. If setting the margin on a single axis is desired, use the keyword arguments described below.
x, yfloat, optional
Specific margin values for the x-axis and y-axis, respectively. These cannot be used with positional arguments, but can be used individually to alter on e.g., only the y-axis.
tightbool or None, default: True
The tight parameter is passed to autoscale_view(), which is executed after a margin is changed; the default here is True, on the assumption that when margins are specified, no additional padding to match tick marks is usually desired. Set tight to None will preserve the previous setting. Returns
xmargin, ymarginfloat
Notes If a previously used Axes method such as pcolor() has set use_sticky_edges to True, only the limits not set by the "sticky artists" will be modified. To force all of the margins to be set, set use_sticky_edges to False before calling margins().
Examples using matplotlib.axes.Axes.margins
Marker reference
Creating a timeline with lines, dates, and text
Trigradient Demo
Controlling view limits using margins and sticky_edges
Scale invariant angle label
ggplot style sheet
Autoscaling | matplotlib._as_gen.matplotlib.axes.axes.margins |
matplotlib.axes.Axes.matshow Axes.matshow(Z, **kwargs)[source]
Plot the values of a 2D matrix or array as color-coded image. The matrix will be shown the way it would be printed, with the first row at the top. Row and column numbering is zero-based. Parameters
Z(M, N) array-like
The matrix to be displayed. Returns
AxesImage
Other Parameters
**kwargsimshow arguments
See also imshow
More general function to plot data on a 2D regular raster. Notes This is just a convenience function wrapping imshow to set useful defaults for displaying a matrix. In particular: Set origin='upper'. Set interpolation='nearest'. Set aspect='equal'. Ticks are placed to the left and above. Ticks are formatted to show integer indices. | matplotlib._as_gen.matplotlib.axes.axes.matshow |
matplotlib.axes.Axes.minorticks_off Axes.minorticks_off()[source]
Remove minor ticks from the Axes. | matplotlib._as_gen.matplotlib.axes.axes.minorticks_off |
matplotlib.axes.Axes.minorticks_on Axes.minorticks_on()[source]
Display minor ticks on the Axes. Displaying minor ticks may reduce performance; you may turn them off using minorticks_off() if drawing speed is a problem.
Examples using matplotlib.axes.Axes.minorticks_on
MRI With EEG | matplotlib._as_gen.matplotlib.axes.axes.minorticks_on |
matplotlib.axes.Axes.mouseover propertyAxes.mouseover
If this property is set to True, the artist will be queried for custom context information when the mouse cursor moves over it. See also get_cursor_data(), ToolCursorPosition and NavigationToolbar2. | matplotlib._as_gen.matplotlib.axes.axes.mouseover |
matplotlib.axes.Axes.name Axes.name='rectilinear' | matplotlib._as_gen.matplotlib.axes.axes.name |
matplotlib.axes.Axes.pchanged Axes.pchanged()[source]
Call all of the registered callbacks. This function is triggered internally when a property is changed. See also add_callback
remove_callback | matplotlib._as_gen.matplotlib.axes.axes.pchanged |
matplotlib.axes.Axes.pcolor Axes.pcolor(*args, shading=None, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, data=None, **kwargs)[source]
Create a pseudocolor plot with a non-regular rectangular grid. Call signature: pcolor([X, Y,] C, **kwargs)
X and Y can be used to specify the corners of the quadrilaterals. Hint pcolor() can be very slow for large arrays. In most cases you should use the similar but much faster pcolormesh instead. See Differences between pcolor() and pcolormesh() for a discussion of the differences. Parameters
C2D array-like
The color-mapped values.
X, Yarray-like, optional
The coordinates of the corners of quadrilaterals of a pcolormesh: (X[i+1, j], Y[i+1, j]) (X[i+1, j+1], Y[i+1, j+1])
+-----+
| |
+-----+
(X[i, j], Y[i, j]) (X[i, j+1], Y[i, j+1])
Note that the column index corresponds to the x-coordinate, and the row index corresponds to y. For details, see the Notes section below. If shading='flat' the dimensions of X and Y should be one greater than those of C, and the quadrilateral is colored due to the value at C[i, j]. If X, Y and C have equal dimensions, a warning will be raised and the last row and column of C will be ignored. If shading='nearest', the dimensions of X and Y should be the same as those of C (if not, a ValueError will be raised). The color C[i, j] will be centered on (X[i, j], Y[i, j]). If X and/or Y are 1-D arrays or column vectors they will be expanded as needed into the appropriate 2D arrays, making a rectangular grid.
shading{'flat', 'nearest', 'auto'}, default: rcParams["pcolor.shading"] (default: 'auto')
The fill style for the quadrilateral. Possible values: 'flat': A solid color is used for each quad. The color of the quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by C[i, j]. The dimensions of X and Y should be one greater than those of C; if they are the same as C, then a deprecation warning is raised, and the last row and column of C are dropped. 'nearest': Each grid point will have a color centered on it, extending halfway between the adjacent grid centers. The dimensions of X and Y must be the same as C. 'auto': Choose 'flat' if dimensions of X and Y are one larger than C. Choose 'nearest' if dimensions are the same. See pcolormesh grids and shading for more description.
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
A Colormap instance or registered colormap name. The colormap maps the C values to colors.
normNormalize, optional
The Normalize instance scales the data values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling.
vmin, vmaxfloat, default: None
The colorbar range. If None, suitable min/max values are automatically chosen by the Normalize instance (defaults to the respective min/max values of C in case of the default linear scaling). It is an error to use vmin/vmax when norm is given.
edgecolors{'none', None, 'face', color, color sequence}, optional
The color of the edges. Defaults to 'none'. Possible values: 'none' or '': No edge.
None: rcParams["patch.edgecolor"] (default: 'black') will be used. Note that currently rcParams["patch.force_edgecolor"] (default: False) has to be True for this to work. 'face': Use the adjacent face color. A color or sequence of colors will set the edge color. The singular form edgecolor works as an alias.
alphafloat, default: None
The alpha blending value of the face color, between 0 (transparent) and 1 (opaque). Note: The edgecolor is currently not affected by this.
snapbool, default: False
Whether to snap the mesh to pixel boundaries. Returns
matplotlib.collections.Collection
Other Parameters
antialiasedsbool, default: False
The default antialiaseds is False if the default edgecolors="none" is used. This eliminates artificial lines at patch boundaries, and works regardless of the value of alpha. If edgecolors is not "none", then the default antialiaseds is taken from rcParams["patch.antialiased"] (default: True). Stroking the edges may be preferred if alpha is 1, but will cause artifacts otherwise.
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception). **kwargs
Additionally, the following arguments are allowed. They are passed along to the PolyCollection constructor:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha array-like or scalar or None
animated bool
antialiased or aa or antialiaseds bool or list of bools
array array-like or None
capstyle CapStyle or {'butt', 'projecting', 'round'}
clim (vmin: float, vmax: float)
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
cmap Colormap or str or None
color color or list of rgba tuples
edgecolor or ec or edgecolors color or list of colors or 'face'
facecolor or facecolors or fc color or list of colors
figure Figure
gid str
hatch {'/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
in_layout bool
joinstyle JoinStyle or {'miter', 'round', 'bevel'}
label object
linestyle or dashes or linestyles or ls str or tuple or list thereof
linewidth or linewidths or lw float or list of floats
norm Normalize or None
offset_transform Transform
offsets (N, 2) or (2,) array-like
path_effects AbstractPathEffect
paths list of array-like
picker None or bool or float or callable
pickradius float
rasterized bool
sizes ndarray or None
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
transform Transform
url str
urls list of str or None
verts list of array-like
verts_and_codes unknown
visible bool
zorder float See also pcolormesh
for an explanation of the differences between pcolor and pcolormesh. imshow
If X and Y are each equidistant, imshow can be a faster alternative. Notes Masked arrays 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. Grid orientation The grid orientation follows the standard matrix convention: An array C with shape (nrows, ncolumns) is plotted with the column number as X and the row number as Y.
Examples using matplotlib.axes.Axes.pcolor
Pcolor Demo
Controlling view limits using margins and sticky_edges | matplotlib._as_gen.matplotlib.axes.axes.pcolor |
matplotlib.axes.Axes.pcolorfast Axes.pcolorfast(*args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, data=None, **kwargs)[source]
Create a pseudocolor plot with a non-regular rectangular grid. Call signature: ax.pcolorfast([X, Y], C, /, **kwargs)
This method is similar to pcolor and pcolormesh. It's designed to provide the fastest pcolor-type plotting with the Agg backend. To achieve this, it uses different algorithms internally depending on the complexity of the input grid (regular rectangular, non-regular rectangular or arbitrary quadrilateral). Warning This method is experimental. Compared to pcolor or pcolormesh it has some limitations: It supports only flat shading (no outlines) It lacks support for log scaling of the axes. It does not have a have a pyplot wrapper. Parameters
Carray-like
The image data. Supported array shapes are: (M, N): an image with scalar data. The data is visualized using a colormap. (M, N, 3): an image with RGB values (0-1 float or 0-255 int). (M, N, 4): an image with RGBA values (0-1 float or 0-255 int), i.e. including transparency. The first two dimensions (M, N) define the rows and columns of the image. This parameter can only be passed positionally.
X, Ytuple or array-like, default: (0, N), (0, M)
X and Y are used to specify the coordinates of the quadrilaterals. There are different ways to do this:
Use tuples X=(xmin, xmax) and Y=(ymin, ymax) to define a uniform rectangular grid. The tuples define the outer edges of the grid. All individual quadrilaterals will be of the same size. This is the fastest version.
Use 1D arrays X, Y to specify a non-uniform rectangular grid. In this case X and Y have to be monotonic 1D arrays of length N+1 and M+1, specifying the x and y boundaries of the cells. The speed is intermediate. Note: The grid is checked, and if found to be uniform the fast version is used.
Use 2D arrays X, Y if you need an arbitrary quadrilateral grid (i.e. if the quadrilaterals are not rectangular). In this case X and Y are 2D arrays with shape (M + 1, N + 1), specifying the x and y coordinates of the corners of the colored quadrilaterals. This is the most general, but the slowest to render. It may produce faster and more compact output using ps, pdf, and svg backends, however. These arguments can only be passed positionally.
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
A Colormap instance or registered colormap name. The colormap maps the C values to colors.
normNormalize, optional
The Normalize instance scales the data values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling.
vmin, vmaxfloat, default: None
The colorbar range. If None, suitable min/max values are automatically chosen by the Normalize instance (defaults to the respective min/max values of C in case of the default linear scaling). It is an error to use vmin/vmax when norm is given.
alphafloat, default: None
The alpha blending value, between 0 (transparent) and 1 (opaque).
snapbool, default: False
Whether to snap the mesh to pixel boundaries. Returns
AxesImage or PcolorImage or QuadMesh
The return type depends on the type of grid:
AxesImage for a regular rectangular grid.
PcolorImage for a non-regular rectangular grid.
QuadMesh for a non-rectangular grid. Other Parameters
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception). **kwargs
Supported additional parameters depend on the type of grid. See return types of image for further description.
Examples using matplotlib.axes.Axes.pcolorfast
Pcolor Demo | matplotlib._as_gen.matplotlib.axes.axes.pcolorfast |
matplotlib.axes.Axes.pcolormesh Axes.pcolormesh(*args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, shading=None, antialiased=False, data=None, **kwargs)[source]
Create a pseudocolor plot with a non-regular rectangular grid. Call signature: pcolormesh([X, Y,] C, **kwargs)
X and Y can be used to specify the corners of the quadrilaterals. Hint pcolormesh is similar to pcolor. It is much faster and preferred in most cases. For a detailed discussion on the differences see Differences between pcolor() and pcolormesh(). Parameters
C2D array-like
The color-mapped values.
X, Yarray-like, optional
The coordinates of the corners of quadrilaterals of a pcolormesh: (X[i+1, j], Y[i+1, j]) (X[i+1, j+1], Y[i+1, j+1])
+-----+
| |
+-----+
(X[i, j], Y[i, j]) (X[i, j+1], Y[i, j+1])
Note that the column index corresponds to the x-coordinate, and the row index corresponds to y. For details, see the Notes section below. If shading='flat' the dimensions of X and Y should be one greater than those of C, and the quadrilateral is colored due to the value at C[i, j]. If X, Y and C have equal dimensions, a warning will be raised and the last row and column of C will be ignored. If shading='nearest' or 'gouraud', the dimensions of X and Y should be the same as those of C (if not, a ValueError will be raised). For 'nearest' the color C[i, j] is centered on (X[i, j], Y[i, j]). For 'gouraud', a smooth interpolation is caried out between the quadrilateral corners. If X and/or Y are 1-D arrays or column vectors they will be expanded as needed into the appropriate 2D arrays, making a rectangular grid.
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
A Colormap instance or registered colormap name. The colormap maps the C values to colors.
normNormalize, optional
The Normalize instance scales the data values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling.
vmin, vmaxfloat, default: None
The colorbar range. If None, suitable min/max values are automatically chosen by the Normalize instance (defaults to the respective min/max values of C in case of the default linear scaling). It is an error to use vmin/vmax when norm is given.
edgecolors{'none', None, 'face', color, color sequence}, optional
The color of the edges. Defaults to 'none'. Possible values: 'none' or '': No edge.
None: rcParams["patch.edgecolor"] (default: 'black') will be used. Note that currently rcParams["patch.force_edgecolor"] (default: False) has to be True for this to work. 'face': Use the adjacent face color. A color or sequence of colors will set the edge color. The singular form edgecolor works as an alias.
alphafloat, default: None
The alpha blending value, between 0 (transparent) and 1 (opaque).
shading{'flat', 'nearest', 'gouraud', 'auto'}, optional
The fill style for the quadrilateral; defaults to 'flat' or rcParams["pcolor.shading"] (default: 'auto'). Possible values: 'flat': A solid color is used for each quad. The color of the quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by C[i, j]. The dimensions of X and Y should be one greater than those of C; if they are the same as C, then a deprecation warning is raised, and the last row and column of C are dropped. 'nearest': Each grid point will have a color centered on it, extending halfway between the adjacent grid centers. The dimensions of X and Y must be the same as C. 'gouraud': Each quad will be Gouraud shaded: The color of the corners (i', j') are given by C[i', j']. The color values of the area in between is interpolated from the corner values. The dimensions of X and Y must be the same as C. When Gouraud shading is used, edgecolors is ignored. 'auto': Choose 'flat' if dimensions of X and Y are one larger than C. Choose 'nearest' if dimensions are the same. See pcolormesh grids and shading for more description.
snapbool, default: False
Whether to snap the mesh to pixel boundaries.
rasterizedbool, optional
Rasterize the pcolormesh when drawing vector graphics. This can speed up rendering and produce smaller files for large data sets. See also Rasterization for vector graphics. Returns
matplotlib.collections.QuadMesh
Other Parameters
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception). **kwargs
Additionally, the following arguments are allowed. They are passed along to the QuadMesh constructor:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha array-like or scalar or None
animated bool
antialiased or aa or antialiaseds bool or list of bools
array (M, N) array-like or M*N array-like
capstyle CapStyle or {'butt', 'projecting', 'round'}
clim (vmin: float, vmax: float)
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
cmap Colormap or str or None
color color or list of rgba tuples
edgecolor or ec or edgecolors color or list of colors or 'face'
facecolor or facecolors or fc color or list of colors
figure Figure
gid str
hatch {'/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
in_layout bool
joinstyle JoinStyle or {'miter', 'round', 'bevel'}
label object
linestyle or dashes or linestyles or ls str or tuple or list thereof
linewidth or linewidths or lw float or list of floats
norm Normalize or None
offset_transform Transform
offsets (N, 2) or (2,) array-like
path_effects AbstractPathEffect
picker None or bool or float or callable
pickradius float
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
transform Transform
url str
urls list of str or None
visible bool
zorder float See also pcolor
An alternative implementation with slightly different features. For a detailed discussion on the differences see Differences between pcolor() and pcolormesh(). imshow
If X and Y are each equidistant, imshow can be a faster alternative. Notes Masked arrays C may be a masked array. If C[i, j] is masked, the corresponding quadrilateral will be transparent. Masking of X and Y is not supported. Use pcolor if you need this functionality. Grid orientation The grid orientation follows the standard matrix convention: An array C with shape (nrows, ncolumns) is plotted with the column number as X and the row number as Y. Differences between pcolor() and pcolormesh() Both methods are used to create a pseudocolor plot of a 2D array using quadrilaterals. The main difference lies in the created object and internal data handling: While pcolor returns a PolyCollection, pcolormesh returns a QuadMesh. The latter is more specialized for the given purpose and thus is faster. It should almost always be preferred. There is also a slight difference in the handling of masked arrays. Both pcolor and pcolormesh support masked arrays for C. However, only pcolor supports masked arrays for X and Y. The reason lies in the internal handling of the masked values. pcolor leaves out the respective polygons from the PolyCollection. pcolormesh sets the facecolor of the masked elements to transparent. You can see the difference when using edgecolors. While all edges are drawn irrespective of masking in a QuadMesh, the edge between two adjacent masked quadrilaterals in pcolor is not drawn as the corresponding polygons do not exist in the PolyCollection. Another difference is the support of Gouraud shading in pcolormesh, which is not available with pcolor.
Examples using matplotlib.axes.Axes.pcolormesh
Pcolor Demo
pcolormesh grids and shading
pcolormesh
Placing Colorbars
Figure subfigures
Rasterization for vector graphics
Constrained Layout Guide
Colormap Normalization
pcolormesh(X, Y, Z) | matplotlib._as_gen.matplotlib.axes.axes.pcolormesh |
matplotlib.axes.Axes.phase_spectrum Axes.phase_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)[source]
Plot the phase spectrum. Compute the phase spectrum (unwrapped angle spectrum) of x. Data is padded to a length of pad_to and the windowing function window is applied to the signal. Parameters
x1-D array or sequence
Array or sequence containing the data
Fsfloat, default: 2
The sampling frequency (samples per time unit). It is used to calculate the Fourier frequencies, freqs, in cycles per time unit.
windowcallable or ndarray, default: window_hanning
A function or a vector of length NFFT. To create window vectors see window_hanning, window_none, numpy.blackman, numpy.hamming, numpy.bartlett, scipy.signal, scipy.signal.get_window, etc. If a function is passed as the argument, it must take a data segment as an argument and return the windowed version of the segment.
sides{'default', 'onesided', 'twosided'}, optional
Which sides of the spectrum to return. 'default' is one-sided for real data and two-sided for complex data. 'onesided' forces the return of a one-sided spectrum, while 'twosided' forces two-sided.
pad_toint, optional
The number of points to which the data segment is padded when performing the FFT. While not increasing the actual resolution of the spectrum (the minimum distance between resolvable peaks), this can give more points in the plot, allowing for more detail. This corresponds to the n parameter in the call to fft(). The default is None, which sets pad_to equal to the length of the input signal (i.e. no padding).
Fcint, default: 0
The center frequency of x, which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. Returns
spectrum1-D array
The values for the phase spectrum in radians (real valued).
freqs1-D array
The frequencies corresponding to the elements in spectrum.
lineLine2D
The line created by this function. Other Parameters
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x **kwargs
Keyword arguments control the Line2D properties:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
antialiased or aa bool
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
color or c color
dash_capstyle CapStyle or {'butt', 'projecting', 'round'}
dash_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
dashes sequence of floats (on/off ink in points) or (None, None)
data (2, N) array or two 1D arrays
drawstyle or ds {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
figure Figure
fillstyle {'full', 'left', 'right', 'bottom', 'top', 'none'}
gid str
in_layout bool
label object
linestyle or ls {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
linewidth or lw float
marker marker style string, Path or MarkerStyle
markeredgecolor or mec color
markeredgewidth or mew float
markerfacecolor or mfc color
markerfacecoloralt or mfcalt color
markersize or ms float
markevery None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]
path_effects AbstractPathEffect
picker float or callable[[Artist, Event], tuple[bool, dict]]
pickradius float
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
solid_capstyle CapStyle or {'butt', 'projecting', 'round'}
solid_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
transform unknown
url str
visible bool
xdata 1D array
ydata 1D array
zorder float See also magnitude_spectrum
Plots the magnitudes of the corresponding frequencies. angle_spectrum
Plots the wrapped version of this function. specgram
Can plot the phase spectrum of segments within the signal in a colormap. | matplotlib._as_gen.matplotlib.axes.axes.phase_spectrum |
matplotlib.axes.Axes.pie Axes.pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=0, radius=1, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, *, normalize=True, data=None)[source]
Plot a pie chart. 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. The resulting pie will have an empty wedge of size 1 - sum(x). The wedges are plotted counterclockwise, by default starting from the x-axis. Parameters
x1D array-like
The wedge sizes.
explodearray-like, default: None
If not None, is a len(x) array which specifies the fraction of the radius with which to offset each wedge.
labelslist, default: None
A sequence of strings providing the labels for each wedge
colorsarray-like, default: None
A sequence of colors through which the pie chart will cycle. If None, will use the colors in the currently active cycle.
autopctNone or str or callable, default: None
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.
pctdistancefloat, default: 0.6
The ratio between the center of each pie slice and the start of the text generated by autopct. Ignored if autopct is None.
shadowbool, default: False
Draw a shadow beneath the pie.
normalizebool, default: True
When True, always make a full pie by normalizing x so that sum(x) == 1. False makes a partial pie if sum(x) <= 1 and raises a ValueError for sum(x) > 1.
labeldistancefloat or None, default: 1.1
The radial distance at which the pie labels are drawn. If set to None, label are not drawn, but are stored for use in legend()
startanglefloat, default: 0 degrees
The angle by which the start of the pie is rotated, counterclockwise from the x-axis.
radiusfloat, default: 1
The radius of the pie.
counterclockbool, default: True
Specify fractions direction, clockwise or counterclockwise.
wedgepropsdict, default: None
Dict of arguments passed to the wedge objects making the pie. For example, you can pass in wedgeprops = {'linewidth': 3} to set the width of the wedge border lines equal to 3. For more details, look at the doc/arguments of the wedge object. By default clip_on=False.
textpropsdict, default: None
Dict of arguments to pass to the text objects.
center(float, float), default: (0, 0)
The coordinates of the center of the chart.
framebool, default: False
Plot Axes frame with the chart if true.
rotatelabelsbool, default: False
Rotate each label to the angle of the corresponding slice if true.
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x, explode, labels, colors Returns
patcheslist
A sequence of matplotlib.patches.Wedge instances
textslist
A list of the label Text instances.
autotextslist
A list of Text instances for the numeric labels. This will only be returned if the parameter autopct is not None. Notes The pie chart will probably look best if the figure and Axes are square, or the Axes aspect is equal. This method sets the aspect ratio of the axis to "equal". The Axes aspect ratio can be controlled with Axes.set_aspect.
Examples using matplotlib.axes.Axes.pie
Basic pie chart
Bar of pie
Nested pie charts
Labeling a pie and a donut
SVG Filter Pie
pie(x) | matplotlib._as_gen.matplotlib.axes.axes.pie |
matplotlib.axes.Axes.plot Axes.plot(*args, scalex=True, scaley=True, data=None, **kwargs)[source]
Plot y versus x as lines and/or markers. Call signatures: plot([x], y, [fmt], *, data=None, **kwargs)
plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)
The coordinates of the points or line nodes are given by x, y. The optional parameter fmt is a convenient way for defining basic formatting like color, marker and linestyle. It's a shortcut string notation described in the Notes section below. >>> plot(x, y) # plot x and y using 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
You can use Line2D properties as keyword arguments for more control on the appearance. Line properties and fmt can be mixed. The following two calls yield identical results: >>> plot(x, y, 'go--', linewidth=2, markersize=12)
>>> plot(x, y, color='green', marker='o', linestyle='dashed',
... linewidth=2, markersize=12)
When conflicting with fmt, keyword arguments take precedence. Plotting labelled data There's a convenient way for plotting objects with labelled data (i.e. data that can be accessed by index obj['y']). Instead of giving the data in x and y, you can provide the object in the data parameter and just give the labels for x and y: >>> plot('xlabel', 'ylabel', data=obj)
All indexable objects are supported. This could e.g. be a dict, a pandas.DataFrame or a structured numpy array. Plotting multiple sets of data There are various ways to plot multiple sets of data.
The most straight forward way is just to call plot multiple times. Example: >>> plot(x1, y1, 'bo')
>>> plot(x2, y2, 'go')
If x and/or y are 2D arrays a separate data set will be drawn for every column. If both x and y are 2D, they must have the same shape. If only one of them is 2D with shape (N, m) the other must have length N and will be used for every data set m. Example: >>> x = [1, 2, 3]
>>> y = np.array([[1, 2], [3, 4], [5, 6]])
>>> plot(x, y)
is equivalent to: >>> for col in range(y.shape[1]):
... plot(x, y[:, col])
The third way is to specify multiple sets of [x], y, [fmt] groups: >>> plot(x1, y1, 'g^', x2, y2, 'g-')
In this case, any additional keyword argument applies to all datasets. Also this syntax cannot be combined with the data parameter. By default, each line is assigned a different style specified by a 'style cycle'. The fmt and line property parameters are only necessary if you want explicit deviations from these defaults. Alternatively, you can also change the style cycle using rcParams["axes.prop_cycle"] (default: cycler('color', ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'])). Parameters
x, yarray-like or scalar
The horizontal / vertical coordinates of the data points. x values are optional and default to range(len(y)). Commonly, these parameters are 1D arrays. They can also be scalars, or two-dimensional (in that case, the columns represent separate data sets). These arguments cannot be passed as keywords.
fmtstr, optional
A format string, e.g. 'ro' for red circles. See the Notes section for a full description of the format strings. Format strings are just an abbreviation for quickly setting basic line properties. All of these and more can also be controlled by keyword arguments. This argument cannot be passed as keyword.
dataindexable object, optional
An object with labelled data. If given, provide the label names to plot in x and y. Note Technically there's a slight ambiguity in calls where the second label is a valid fmt. plot('n', 'o', data=obj) could be plt(x, y) or plt(y, fmt). In such cases, the former interpretation is chosen, but a warning is issued. You may suppress the warning by adding an empty format string plot('n', 'o', '', data=obj). Returns
list of Line2D
A list of lines representing the plotted data. Other Parameters
scalex, scaleybool, default: True
These parameters determine if the view limits are adapted to the data limits. The values are passed on to autoscale_view.
**kwargsLine2D properties, optional
kwargs are used to specify properties like a line label (for auto legends), linewidth, antialiasing, marker face color. 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')
If you specify multiple lines with one plot call, the kwargs apply to all those lines. In case the label object is iterable, each element is used as labels for each set of data. Here is a list of available Line2D properties:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
antialiased or aa bool
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
color or c color
dash_capstyle CapStyle or {'butt', 'projecting', 'round'}
dash_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
dashes sequence of floats (on/off ink in points) or (None, None)
data (2, N) array or two 1D arrays
drawstyle or ds {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
figure Figure
fillstyle {'full', 'left', 'right', 'bottom', 'top', 'none'}
gid str
in_layout bool
label object
linestyle or ls {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
linewidth or lw float
marker marker style string, Path or MarkerStyle
markeredgecolor or mec color
markeredgewidth or mew float
markerfacecolor or mfc color
markerfacecoloralt or mfcalt color
markersize or ms float
markevery None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]
path_effects AbstractPathEffect
picker float or callable[[Artist, Event], tuple[bool, dict]]
pickradius float
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
solid_capstyle CapStyle or {'butt', 'projecting', 'round'}
solid_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
transform unknown
url str
visible bool
xdata 1D array
ydata 1D array
zorder float See also scatter
XY scatter plot with markers of varying size and/or color ( sometimes also called bubble chart). Notes Format Strings A format string consists of a part for color, marker and line: fmt = '[marker][line][color]'
Each of them is optional. If not provided, the value from the style cycle is used. Exception: If line is given, but no marker, the data will be a line without markers. Other combinations such as [color][marker][line] are also supported, but note that their parsing may be ambiguous. Markers
character description
'.' point marker
',' pixel marker
'o' circle marker
'v' triangle_down marker
'^' triangle_up marker
'<' triangle_left marker
'>' triangle_right marker
'1' tri_down marker
'2' tri_up marker
'3' tri_left marker
'4' tri_right marker
'8' octagon marker
's' square marker
'p' pentagon marker
'P' plus (filled) marker
'*' star marker
'h' hexagon1 marker
'H' hexagon2 marker
'+' plus marker
'x' x marker
'X' x (filled) marker
'D' diamond marker
'd' thin_diamond marker
'|' vline marker
'_' hline marker Line Styles
character description
'-' solid line style
'--' dashed line style
'-.' dash-dot line style
':' dotted line style Example format strings: 'b' # blue markers with default shape
'or' # red circles
'-g' # green solid line
'--' # dashed line with default color
'^k:' # black triangle_up markers connected by a dotted line
Colors The supported color abbreviations are the single letter codes
character color
'b' blue
'g' green
'r' red
'c' cyan
'm' magenta
'y' yellow
'k' black
'w' white and the 'CN' colors that index into the default property cycle. If the color is the only part of the format string, you can additionally use any matplotlib.colors spec, e.g. full names ('green') or hex strings ('#008000').
Examples using matplotlib.axes.Axes.plot
Plotting categorical variables
CSD Demo
Curve with error band
EventCollection Demo
Fill Between and Alpha
Filling the area between lines
Fill Betweenx Demo
Customizing dashed line styles
Lines with a ticked patheffect
Marker reference
Markevery Demo
prop_cycle property markevery in rcParams
Psd Demo
Simple Plot
Using span_where
Creating a timeline with lines, dates, and text
hlines and vlines
Contour Corner Mask
Contour plot of irregularly spaced data
pcolormesh grids and shading
Streamplot
Spectrogram Demo
Watermark image
Aligning Labels
Axes box aspect
Axes Demo
Controlling view limits using margins and sticky_edges
Axes Props
axhspan Demo
Broken Axis
Resizing axes with constrained layout
Resizing axes with tight layout
Figure labels: suptitle, supxlabel, supylabel
Invert Axes
Secondary Axis
Sharing axis limits and views
Figure subfigures
Multiple subplots
Creating multiple subplots using plt.subplots
Plots with different scales
Boxplots
Using histograms to plot a cumulative distribution
Some features of the histogram (hist) function
Polar plot
Polar Legend
Using accented text in matplotlib
Scale invariant angle label
Annotating Plots
Composing Custom Legends
Date tick labels
Custom tick formatter for time series
AnnotationBbox demo
Labeling ticks using engineering notation
Annotation arrow style reference
Legend using pre-defined labels
Legend Demo
Mathtext
Math fontfamily
Multiline
Rendering math equations using TeX
Text Rotation Relative To Line
Title positioning
Text watermark
Annotate Transform
Annotating a plot
Annotation Polar
Programmatically controlling subplot adjustment
Dollar Ticks
Simple axes labels
Text Commands
Color Demo
Color by y-value
PathPatch object
Bezier Curve
Dark background style sheet
FiveThirtyEight style sheet
ggplot style sheet
Axes with a fixed physical size
Parasite Simple
Simple Axisline4
Axis line styles
Parasite Axes demo
Parasite axis demo
Custom spines with axisartist
Simple Axisline
Anatomy of a figure
Bachelor's degrees by gender
Integral as the area under a curve
XKCD
Decay
The Bayes update
The double pendulum problem
Animated 3D random walk
Animated line plot
MATPLOTLIB UNCHAINED
Mouse move and click events
Data Browser
Keypress event
Legend Picking
Looking Glass
Path Editor
Pick Event Demo2
Resampling Data
Timers
Frontpage histogram example
Frontpage plot example
Changing colors of lines intersecting a box
Cross hair cursor
Custom projection
Patheffect Demo
Pythonic Matplotlib
SVG Filter Line
TickedStroke patheffect
Zorder Demo
Plot 2D data on 3D plot
3D box surface plot
Parametric Curve
Lorenz Attractor
2D and 3D Axes in same Figure
Loglog Aspect
Scales
Symlog Demo
Anscombe's quartet
Radar chart (aka spider or star chart)
Centered spines with arrows
Multiple Yaxis With Spines
Spine Placement
Spines
Custom spine bounds
Centering labels between ticks
Formatting date ticks using ConciseDateFormatter
Date Demo Convert
Date Index Formatter
Date Precision and Epochs
Major and minor ticks
The default tick formatter
Set default y-axis tick labels on the right
Setting tick labels from a list of values
Set default x-axis tick labels on the top
Evans test
CanvasAgg demo
Annotate Explain
Connect Simple01
Connection styles for annotations
Nested GridSpecs
Pgf Fonts
Pgf Texsystem
Simple Annotate01
Simple Legend01
Simple Legend02
Annotated Cursor
Check Buttons
Cursor
Multicursor
Radio Buttons
Rectangle and ellipse selectors
Span Selector
Textbox
Basic Usage
Artist tutorial
Legend guide
Styling with cycler
Constrained Layout Guide
Tight Layout guide
Arranging multiple Axes in a Figure
Autoscaling
Faster rendering by using blitting
Path Tutorial
Transformations Tutorial
Specifying Colors
Text in Matplotlib Plots
plot(x, y)
fill_between(x, y1, y2)
tricontour(x, y, z)
tricontourf(x, y, z)
tripcolor(x, y, z) | matplotlib._as_gen.matplotlib.axes.axes.plot |
matplotlib.axes.Axes.plot_date Axes.plot_date(x, y, fmt='o', tz=None, xdate=True, ydate=False, *, data=None, **kwargs)[source]
Plot coercing the axis to treat floats as dates. Discouraged This method exists for historic reasons and will be deprecated in the future.
datetime-like data should directly be plotted using plot. If you need to plot plain numeric data as Matplotlib date format or need to set a timezone, call ax.xaxis.axis_date / ax.yaxis.axis_date before plot. See Axis.axis_date. Similar to plot, this plots y vs. x as lines or markers. However, the axis labels are formatted as dates depending on xdate and ydate. Note that plot will work with datetime and numpy.datetime64 objects without resorting to this method. Parameters
x, yarray-like
The coordinates of the data points. If xdate or ydate is True, the respective values x or y are interpreted as Matplotlib dates.
fmtstr, optional
The plot format string. For details, see the corresponding parameter in plot.
tztimezone string or datetime.tzinfo, default: rcParams["timezone"] (default: 'UTC')
The time zone to use in labeling dates.
xdatebool, default: True
If True, the x-axis will be interpreted as Matplotlib dates.
ydatebool, default: False
If True, the y-axis will be interpreted as Matplotlib dates. Returns
list of Line2D
Objects representing the plotted data. Other Parameters
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x, y **kwargs
Keyword arguments control the Line2D properties:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
antialiased or aa bool
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
color or c color
dash_capstyle CapStyle or {'butt', 'projecting', 'round'}
dash_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
dashes sequence of floats (on/off ink in points) or (None, None)
data (2, N) array or two 1D arrays
drawstyle or ds {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
figure Figure
fillstyle {'full', 'left', 'right', 'bottom', 'top', 'none'}
gid str
in_layout bool
label object
linestyle or ls {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
linewidth or lw float
marker marker style string, Path or MarkerStyle
markeredgecolor or mec color
markeredgewidth or mew float
markerfacecolor or mfc color
markerfacecoloralt or mfcalt color
markersize or ms float
markevery None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]
path_effects AbstractPathEffect
picker float or callable[[Artist, Event], tuple[bool, dict]]
pickradius float
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
solid_capstyle CapStyle or {'butt', 'projecting', 'round'}
solid_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
transform unknown
url str
visible bool
xdata 1D array
ydata 1D array
zorder float See also matplotlib.dates
Helper functions on dates. matplotlib.dates.date2num
Convert dates to num. matplotlib.dates.num2date
Convert num to dates. matplotlib.dates.drange
Create an equally spaced sequence of dates. Notes If you are using custom date tickers and formatters, it may be necessary to set the formatters/locators after the call to plot_date. plot_date will set the default tick locator to AutoDateLocator (if the tick locator is not already set to a DateLocator instance) and the default tick formatter to AutoDateFormatter (if the tick formatter is not already set to a DateFormatter instance). | matplotlib._as_gen.matplotlib.axes.axes.plot_date |
matplotlib.axes.Axes.psd Axes.psd(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, *, data=None, **kwargs)[source]
Plot the power spectral density. The power spectral density \(P_{xx}\) by Welch's average periodogram method. The vector x is divided into NFFT length segments. Each segment is detrended by function detrend and windowed by function window. noverlap gives the length of the overlap between segments. The \(|\mathrm{fft}(i)|^2\) of each segment \(i\) are averaged to compute \(P_{xx}\), with a scaling to correct for power loss due to windowing. If len(x) < NFFT, it will be zero padded to NFFT. Parameters
x1-D array or sequence
Array or sequence containing the data
Fsfloat, default: 2
The sampling frequency (samples per time unit). It is used to calculate the Fourier frequencies, freqs, in cycles per time unit.
windowcallable or ndarray, default: window_hanning
A function or a vector of length NFFT. To create window vectors see window_hanning, window_none, numpy.blackman, numpy.hamming, numpy.bartlett, scipy.signal, scipy.signal.get_window, etc. If a function is passed as the argument, it must take a data segment as an argument and return the windowed version of the segment.
sides{'default', 'onesided', 'twosided'}, optional
Which sides of the spectrum to return. 'default' is one-sided for real data and two-sided for complex data. 'onesided' forces the return of a one-sided spectrum, while 'twosided' forces two-sided.
pad_toint, optional
The number of points to which the data segment is padded when performing the FFT. This can be different from NFFT, which specifies the number of data points used. While not increasing the actual resolution of the spectrum (the minimum distance between resolvable peaks), this can give more points in the plot, allowing for more detail. This corresponds to the n parameter in the call to fft(). The default is None, which sets pad_to equal to NFFT
NFFTint, default: 256
The number of data points used in each block for the FFT. A power 2 is most efficient. This should NOT be used to get zero padding, or the scaling of the result will be incorrect; use pad_to for this instead.
detrend{'none', 'mean', 'linear'} or callable, default: 'none'
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 it is a function. The mlab module defines detrend_none, detrend_mean, and detrend_linear, but you can use a custom function as well. You can also use a string to choose one of the functions: 'none' calls detrend_none. 'mean' calls detrend_mean. 'linear' calls detrend_linear.
scale_by_freqbool, default: True
Whether the resulting density values should be scaled by the scaling frequency, which gives density in units of Hz^-1. This allows for integration over the returned frequency values. The default is True for MATLAB compatibility.
noverlapint, default: 0 (no overlap)
The number of points of overlap between segments.
Fcint, default: 0
The center frequency of x, which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband.
return_linebool, default: False
Whether to include the line object plotted in the returned values. Returns
Pxx1-D array
The values for the power spectrum \(P_{xx}\) before scaling (real valued).
freqs1-D array
The frequencies corresponding to the elements in Pxx.
lineLine2D
The line created by this function. Only returned if return_line is True. Other Parameters
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x **kwargs
Keyword arguments control the Line2D properties:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
antialiased or aa bool
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
color or c color
dash_capstyle CapStyle or {'butt', 'projecting', 'round'}
dash_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
dashes sequence of floats (on/off ink in points) or (None, None)
data (2, N) array or two 1D arrays
drawstyle or ds {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
figure Figure
fillstyle {'full', 'left', 'right', 'bottom', 'top', 'none'}
gid str
in_layout bool
label object
linestyle or ls {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
linewidth or lw float
marker marker style string, Path or MarkerStyle
markeredgecolor or mec color
markeredgewidth or mew float
markerfacecolor or mfc color
markerfacecoloralt or mfcalt color
markersize or ms float
markevery None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]
path_effects AbstractPathEffect
picker float or callable[[Artist, Event], tuple[bool, dict]]
pickradius float
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
solid_capstyle CapStyle or {'butt', 'projecting', 'round'}
solid_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
transform unknown
url str
visible bool
xdata 1D array
ydata 1D array
zorder float See also specgram
Differs in the default overlap; in not returning the mean of the segment periodograms; in returning the times of the segments; and in plotting a colormap instead of a line. magnitude_spectrum
Plots the magnitude spectrum. csd
Plots the spectral density between two signals. Notes For plotting, the power is plotted as \(10\log_{10}(P_{xx})\) for decibels, though Pxx itself is returned. References Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John Wiley & Sons (1986)
Examples using matplotlib.axes.Axes.psd
Psd Demo | matplotlib._as_gen.matplotlib.axes.axes.psd |
matplotlib.axes.Axes.quiver Axes.quiver(*args, data=None, **kwargs)[source]
Plot a 2D field of arrows. Call signature: quiver([X, Y], U, V, [C], **kw)
X, Y define the arrow locations, U, V define the arrow directions, and C optionally sets the color. Each arrow is internally represented by a filled polygon with a default edge linewidth of 0. As a result, an arrow is rather a filled area, not a line with a head, and PolyCollection properties like linewidth, linestyle, facecolor, etc. act accordingly. Arrow size The default settings auto-scales the length of the arrows to a reasonable size. To change this behavior see the scale and scale_units parameters. Arrow shape 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. Arrow outline linewidths and edgecolors can be used to customize the arrow outlines. Parameters
X, Y1D or 2D array-like, optional
The x and y coordinates of the arrow locations. If not given, they will be generated as a uniform integer meshgrid based on the dimensions of U and V. If X and Y are 1D but U, V are 2D, X, Y are expanded to 2D using X, Y = np.meshgrid(X, Y). In this case len(X) and len(Y) must match the column and row dimensions of U and V.
U, V1D or 2D array-like
The x and y direction components of the arrow vectors. They must have the same number of elements, matching the number of arrow locations. U and V may be masked. Only locations unmasked in U, V, and C will be drawn.
C1D or 2D array-like, optional
Numeric data that defines the arrow colors by colormapping via norm and cmap. This does not support explicit colors. If you want to set colors directly, use color instead. The size of C must match the number of arrow locations.
units{'width', 'height', 'dots', 'inches', 'x', 'y', 'xy'}, default: 'width'
The arrow dimensions (except for length) are measured in multiples of this unit. The following values are supported: 'width', 'height': The width or height of the axis. 'dots', 'inches': Pixels or inches based on the figure dpi. 'x', 'y', 'xy': X, Y or \(\sqrt{X^2 + Y^2}\) in data units. The arrows scale differently depending on the units. 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 window is resized; for 'dots' or 'inches', resizing does not change the arrows.
angles{'uv', 'xy'} or array-like, default: 'uv'
Method for determining the angle of the arrows.
'uv': The arrow axis aspect ratio is 1 so that if U == V the orientation of the arrow on the plot is 45 degrees counter-clockwise from the horizontal axis (positive to the right). Use this if the arrows symbolize a quantity that is not based on X, Y data coordinates. 'xy': Arrows point from (x, y) to (x+u, y+v). Use this for plotting a gradient field, for example.
Alternatively, arbitrary angles may be specified explicitly as an array of values in degrees, counter-clockwise from the horizontal axis. In this case U, V is only used to determine the length of the arrows. Note: inverting a data axis will correspondingly invert the arrows only with angles='xy'.
scalefloat, optional
Number of data units per arrow length unit, e.g., m/s per plot width; a smaller scale parameter makes the arrow longer. Default is None. If None, a simple autoscaling algorithm is used, based on the average vector length and the number of vectors. The arrow length unit is given by the scale_units parameter.
scale_units{'width', 'height', 'dots', 'inches', 'x', 'y', 'xy'}, optional
If the scale kwarg is None, the arrow length unit. Default is None. e.g. scale_units is 'inches', scale is 2.0, and (u, v) = (1, 0), then the vector will be 0.5 inches long. If scale_units is 'width' or 'height', then the vector will be half the width/height of the axes. If scale_units is 'x' then the vector will be 0.5 x-axis units. To plot vectors in the x-y plane, with u and v having the same units as x and y, use angles='xy', scale_units='xy', scale=1.
widthfloat, optional
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.
headwidthfloat, default: 3
Head width as multiple of shaft width.
headlengthfloat, default: 5
Head length as multiple of shaft width.
headaxislengthfloat, default: 4.5
Head length at shaft intersection.
minshaftfloat, default: 1
Length below which arrow scales, in units of head length. Do not set this to less than 1, or small arrows will look terrible!
minlengthfloat, default: 1
Minimum length as a multiple of shaft width; if an arrow length is less than this, plot a dot (hexagon) of this diameter instead.
pivot{'tail', 'mid', 'middle', 'tip'}, default: 'tail'
The part of the arrow that is anchored to the X, Y grid. The arrow rotates about this point. 'mid' is a synonym for 'middle'.
colorcolor or color sequence, optional
Explicit color(s) for the arrows. If C has been set, color has no effect. This is a synonym for the PolyCollection facecolor parameter. Returns
Quiver
Other Parameters
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception).
**kwargsPolyCollection properties, optional
All other keyword arguments are passed on to PolyCollection:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha array-like or scalar or None
animated bool
antialiased or aa or antialiaseds bool or list of bools
array array-like or None
capstyle CapStyle or {'butt', 'projecting', 'round'}
clim (vmin: float, vmax: float)
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
cmap Colormap or str or None
color color or list of rgba tuples
edgecolor or ec or edgecolors color or list of colors or 'face'
facecolor or facecolors or fc color or list of colors
figure Figure
gid str
hatch {'/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
in_layout bool
joinstyle JoinStyle or {'miter', 'round', 'bevel'}
label object
linestyle or dashes or linestyles or ls str or tuple or list thereof
linewidth or linewidths or lw float or list of floats
norm Normalize or None
offset_transform Transform
offsets (N, 2) or (2,) array-like
path_effects AbstractPathEffect
paths list of array-like
picker None or bool or float or callable
pickradius float
rasterized bool
sizes ndarray or None
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
transform Transform
url str
urls list of str or None
verts list of array-like
verts_and_codes unknown
visible bool
zorder float See also Axes.quiverkey
Add a key to a quiver plot.
Examples using matplotlib.axes.Axes.quiver
Advanced quiver and quiverkey functions
Quiver Simple Demo
Trigradient Demo
3D quiver plot
quiver(X, Y, U, V) | matplotlib._as_gen.matplotlib.axes.axes.quiver |
matplotlib.axes.Axes.quiverkey Axes.quiverkey(Q, X, Y, U, label, **kwargs)[source]
Add a key to a quiver plot. 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. Parameters
Qmatplotlib.quiver.Quiver
A Quiver object as returned by a call to quiver().
X, Yfloat
The location of the key.
Ufloat
The length of the key.
labelstr
The key label (e.g., length and units of the key).
anglefloat, default: 0
The angle of the key arrow, in degrees anti-clockwise from the x-axis.
coordinates{'axes', 'figure', 'data', 'inches'}, default: 'axes'
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.
colorcolor
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.
labelsepfloat, default: 0.1
Distance in inches between the arrow and the label.
labelcolorcolor, default: rcParams["text.color"] (default: 'black')
Label color.
fontpropertiesdict, optional
A dictionary with keyword arguments accepted by the FontProperties initializer: family, style, variant, size, weight. **kwargs
Any additional keyword arguments are used to override vector properties taken from Q.
Examples using matplotlib.axes.Axes.quiverkey
Advanced quiver and quiverkey functions
Quiver Simple Demo | matplotlib._as_gen.matplotlib.axes.axes.quiverkey |
matplotlib.axes.Axes.redraw_in_frame Axes.redraw_in_frame()[source]
Efficiently redraw Axes data, but not axis ticks, labels, etc. This method can only be used after an initial draw which caches the renderer. | matplotlib._as_gen.matplotlib.axes.axes.redraw_in_frame |
matplotlib.axes.Axes.relim Axes.relim(visible_only=False)[source]
Recompute the data limits based on current artists. At present, Collection instances are not supported. Parameters
visible_onlybool, default: False
Whether to exclude invisible artists.
Examples using matplotlib.axes.Axes.relim
Packed-bubble chart
Textbox | matplotlib._as_gen.matplotlib.axes.axes.relim |
matplotlib.axes.Axes.remove_callback Axes.remove_callback(oid)[source]
Remove a callback based on its observer id. See also add_callback | matplotlib._as_gen.matplotlib.axes.axes.remove_callback |
matplotlib.axes.Axes.reset_position Axes.reset_position()[source]
Reset the active position to the original position. This resets the a possible position change due to aspect constraints. For an explanation of the positions see set_position. | matplotlib._as_gen.matplotlib.axes.axes.reset_position |
matplotlib.axes.Axes.scatter Axes.scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, *, edgecolors=None, plotnonfinite=False, data=None, **kwargs)[source]
A scatter plot of y vs. x with varying marker size and/or color. Parameters
x, yfloat or array-like, shape (n, )
The data positions.
sfloat or array-like, shape (n, ), optional
The marker size in points**2. Default is rcParams['lines.markersize'] ** 2.
carray-like or list of colors or color, optional
The marker colors. Possible values: A scalar or sequence of n numbers to be mapped to colors using cmap and norm. A 2D array in which the rows are RGB or RGBA. A sequence of colors of length n. A single color format string. 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. If you want to specify the same RGB or RGBA value for all points, use a 2D array with a single row. Otherwise, value- matching will have precedence in case of a size matching with x and y. If you wish to specify a single color for all points prefer the color keyword argument. Defaults to None. In that case the marker color is determined by the value of color, facecolor or facecolors. In case those are not specified or None, the marker color is determined by the next color of the Axes' current "shape and fill" color cycle. This cycle defaults to rcParams["axes.prop_cycle"] (default: cycler('color', ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'])).
markerMarkerStyle, default: rcParams["scatter.marker"] (default: 'o')
The marker style. marker can be either an instance of the class or the text shorthand for a particular marker. See matplotlib.markers for more information about marker styles.
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
A Colormap instance or registered colormap name. cmap is only used if c is an array of floats.
normNormalize, default: None
If c is an array of floats, norm is used to scale the color data, c, in the range 0 to 1, in order to map into the colormap cmap. If None, use the default colors.Normalize.
vmin, vmaxfloat, default: None
vmin and vmax are used in conjunction with the default norm to map the color array c to the colormap cmap. If None, the respective min and max of the color array is used. It is an error to use vmin/vmax when norm is given.
alphafloat, default: None
The alpha blending value, between 0 (transparent) and 1 (opaque).
linewidthsfloat or array-like, default: rcParams["lines.linewidth"] (default: 1.5)
The linewidth of the marker edges. Note: The default edgecolors is 'face'. You may want to change this as well.
edgecolors{'face', 'none', None} or color or sequence of color, default: rcParams["scatter.edgecolors"] (default: 'face')
The edge color of the marker. Possible values: 'face': The edge color will always be the same as the face color. 'none': No patch boundary will be drawn. A color or sequence of colors. For non-filled markers, edgecolors is ignored. Instead, the color is determined like with 'face', i.e. from c, colors, or facecolors.
plotnonfinitebool, default: False
Whether to plot points with nonfinite c (i.e. inf, -inf or nan). If True the points are drawn with the bad colormap color (see Colormap.set_bad). Returns
PathCollection
Other Parameters
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x, y, s, linewidths, edgecolors, c, facecolor, facecolors, color
**kwargsCollection properties
See also plot
To plot scatter plots when markers are identical in size and color. Notes The plot function will be faster for scatterplots where markers don't vary in size or color. 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. Fundamentally, scatter works with 1D arrays; x, y, s, and c may be input as N-D arrays, but within scatter they will be flattened. The exception is c, which will be flattened only if its size matches the size of x and y.
Examples using matplotlib.axes.Axes.scatter
Scatter Custom Symbol
Scatter Demo2
Scatter plot with histograms
Scatter plot with pie chart markers
Scatter plots with a legend
Advanced quiver and quiverkey functions
Axes box aspect
Axis Label Position
Plot a confidence ellipse of a two-dimensional dataset
Violin plot customization
Scatter plot on polar axis
Legend Demo
Scatter Histogram (Locatable Axes)
mpl_toolkits.axisartist.floating_axes features
Rain simulation
Zoom Window
Plotting with keywords
Zorder Demo
Plot 2D data on 3D plot
3D scatterplot
Automatically setting tick positions
Unit handling
Annotate Text Arrow
Polygon Selector
Basic Usage
Choosing Colormaps in Matplotlib
scatter(x, y) | matplotlib._as_gen.matplotlib.axes.axes.scatter |
matplotlib.axes.Axes.secondary_xaxis Axes.secondary_xaxis(location, *, functions=None, **kwargs)[source]
Add a second x-axis to this Axes. For example if we want to have a second scale for the data plotted on the xaxis. Parameters
location{'top', 'bottom', 'left', 'right'} or float
The position to put the secondary axis. Strings can be 'top' or 'bottom' for orientation='x' and 'right' or 'left' for orientation='y'. A float indicates the relative position on the parent axes to put the new axes, 0.0 being the bottom (or left) and 1.0 being the top (or right).
functions2-tuple of func, or Transform with an inverse
If a 2-tuple of functions, the user specifies the transform function and its inverse. i.e. functions=(lambda x: 2 / x, lambda x: 2 / x) would be an reciprocal transform with a factor of 2. The user can also directly supply a subclass of transforms.Transform so long as it has an inverse. See Secondary Axis for examples of making these conversions. Returns
axaxes._secondary_axes.SecondaryAxis
Other Parameters
**kwargsAxes properties.
Other miscellaneous axes parameters. Warning This method is experimental as of 3.1, and the API may change. Examples The main axis shows frequency, and the secondary axis shows period. (Source code, png, pdf)
Examples using matplotlib.axes.Axes.secondary_xaxis
Secondary Axis
Basic Usage | matplotlib._as_gen.matplotlib.axes.axes.secondary_xaxis |
matplotlib.axes.Axes.secondary_yaxis Axes.secondary_yaxis(location, *, functions=None, **kwargs)[source]
Add a second y-axis to this Axes. For example if we want to have a second scale for the data plotted on the yaxis. Parameters
location{'top', 'bottom', 'left', 'right'} or float
The position to put the secondary axis. Strings can be 'top' or 'bottom' for orientation='x' and 'right' or 'left' for orientation='y'. A float indicates the relative position on the parent axes to put the new axes, 0.0 being the bottom (or left) and 1.0 being the top (or right).
functions2-tuple of func, or Transform with an inverse
If a 2-tuple of functions, the user specifies the transform function and its inverse. i.e. functions=(lambda x: 2 / x, lambda x: 2 / x) would be an reciprocal transform with a factor of 2. The user can also directly supply a subclass of transforms.Transform so long as it has an inverse. See Secondary Axis for examples of making these conversions. Returns
axaxes._secondary_axes.SecondaryAxis
Other Parameters
**kwargsAxes properties.
Other miscellaneous axes parameters. Warning This method is experimental as of 3.1, and the API may change. Examples Add a secondary Axes that converts from radians to degrees (Source code, png, pdf)
Examples using matplotlib.axes.Axes.secondary_yaxis
Secondary Axis | matplotlib._as_gen.matplotlib.axes.axes.secondary_yaxis |
matplotlib.axes.Axes.semilogx Axes.semilogx(*args, **kwargs)[source]
Make a plot with log scaling on the x axis. Call signatures: semilogx([x], y, [fmt], data=None, **kwargs)
semilogx([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)
This is just a thin wrapper around plot which additionally changes the x-axis to log scaling. All of the concepts and parameters of plot can be used here as well. The additional parameters base, subs, and nonpositive control the x-axis properties. They are just forwarded to Axes.set_xscale. Parameters
basefloat, default: 10
Base of the x logarithm.
subsarray-like, optional
The location of the minor xticks. If None, reasonable locations are automatically chosen depending on the number of decades in the plot. See Axes.set_xscale for details.
nonpositive{'mask', 'clip'}, default: 'mask'
Non-positive values in x can be masked as invalid, or clipped to a very small positive number. **kwargs
All parameters supported by plot. Returns
list of Line2D
Objects representing the plotted data.
Examples using matplotlib.axes.Axes.semilogx
Log Demo
Log Axis
Transformations Tutorial | matplotlib._as_gen.matplotlib.axes.axes.semilogx |
matplotlib.axes.Axes.semilogy Axes.semilogy(*args, **kwargs)[source]
Make a plot with log scaling on the y axis. Call signatures: semilogy([x], y, [fmt], data=None, **kwargs)
semilogy([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)
This is just a thin wrapper around plot which additionally changes the y-axis to log scaling. All of the concepts and parameters of plot can be used here as well. The additional parameters base, subs, and nonpositive control the y-axis properties. They are just forwarded to Axes.set_yscale. Parameters
basefloat, default: 10
Base of the y logarithm.
subsarray-like, optional
The location of the minor yticks. If None, reasonable locations are automatically chosen depending on the number of decades in the plot. See Axes.set_yscale for details.
nonpositive{'mask', 'clip'}, default: 'mask'
Non-positive values in y can be masked as invalid, or clipped to a very small positive number. **kwargs
All parameters supported by plot. Returns
list of Line2D
Objects representing the plotted data.
Examples using matplotlib.axes.Axes.semilogy
Log Demo
SkewT-logP diagram: using transforms and custom projections | matplotlib._as_gen.matplotlib.axes.axes.semilogy |
matplotlib.axes.Axes.set Axes.set(*, adjustable=<UNSET>, agg_filter=<UNSET>, alpha=<UNSET>, anchor=<UNSET>, animated=<UNSET>, aspect=<UNSET>, autoscale_on=<UNSET>, autoscalex_on=<UNSET>, autoscaley_on=<UNSET>, axes_locator=<UNSET>, axisbelow=<UNSET>, box_aspect=<UNSET>, clip_box=<UNSET>, clip_on=<UNSET>, clip_path=<UNSET>, facecolor=<UNSET>, frame_on=<UNSET>, gid=<UNSET>, in_layout=<UNSET>, label=<UNSET>, navigate=<UNSET>, path_effects=<UNSET>, picker=<UNSET>, position=<UNSET>, prop_cycle=<UNSET>, rasterization_zorder=<UNSET>, rasterized=<UNSET>, sketch_params=<UNSET>, snap=<UNSET>, title=<UNSET>, transform=<UNSET>, url=<UNSET>, visible=<UNSET>, xbound=<UNSET>, xlabel=<UNSET>, xlim=<UNSET>, xmargin=<UNSET>, xscale=<UNSET>, xticklabels=<UNSET>, xticks=<UNSET>, ybound=<UNSET>, ylabel=<UNSET>, ylim=<UNSET>, ymargin=<UNSET>, yscale=<UNSET>, yticklabels=<UNSET>, yticks=<UNSET>, zorder=<UNSET>)[source]
Set multiple properties at once. Supported properties are
Property Description
adjustable {'box', 'datalim'}
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
anchor (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}
animated bool
aspect {'auto', 'equal'} or float
autoscale_on bool
autoscalex_on bool
autoscaley_on bool
axes_locator Callable[[Axes, Renderer], Bbox]
axisbelow bool or 'line'
box_aspect float or None
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
facecolor or fc color
figure Figure
frame_on bool
gid str
in_layout bool
label object
navigate bool
navigate_mode unknown
path_effects AbstractPathEffect
picker None or bool or float or callable
position [left, bottom, width, height] or Bbox
prop_cycle unknown
rasterization_zorder float or None
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
title str
transform Transform
url str
visible bool
xbound unknown
xlabel str
xlim (bottom: float, top: float)
xmargin float greater than -0.5
xscale {"linear", "log", "symlog", "logit", ...} or ScaleBase
xticklabels unknown
xticks unknown
ybound unknown
ylabel str
ylim (bottom: float, top: float)
ymargin float greater than -0.5
yscale {"linear", "log", "symlog", "logit", ...} or ScaleBase
yticklabels unknown
yticks unknown
zorder float
Examples using matplotlib.axes.Axes.set
Curve with error band
Bar chart with gradients
Simple Plot
Creating a timeline with lines, dates, and text
Contour plot of irregularly spaced data
Streamplot
Axes Demo
Creating multiple subplots using plt.subplots
Boxplots
Hexagonal binned plot
Nested pie charts
Annotating Plots
Arrow Demo
Usetex Baseline Test
Text Commands
Drawing fancy boxes
Adding a colorbar to inset axes
Inset Locator Demo
Animated 3D random walk
Zoom Window
Manual Contour
Plotting with keywords
3D box surface plot
Projecting contour profiles onto a graph
Projecting filled contour onto a graph
Generate polygons to fill under 3D line graph
3D stem
3D voxel / volumetric plot with rgb colors
Log Demo
Annotate Explain
Connection styles for annotations
Nested GridSpecs
Simple Annotate01
Mouse Cursor
The Lifecycle of a Plot
Arranging multiple Axes in a Figure
plot(x, y)
scatter(x, y)
bar(x, height) / barh(y, width)
stem(x, y)
step(x, y)
fill_between(x, y1, y2)
barbs(X, Y, U, V)
quiver(X, Y, U, V)
hist(x)
boxplot(X)
errorbar(x, y, yerr, xerr)
violinplot(D)
eventplot(D)
hist2d(x, y)
hexbin(x, y, C)
pie(x)
tricontour(x, y, z)
tricontourf(x, y, z)
tripcolor(x, y, z)
triplot(x, y) | matplotlib._as_gen.matplotlib.axes.axes.set |
matplotlib.axes.Axes.set_adjustable Axes.set_adjustable(adjustable, share=False)[source]
Set how the Axes adjusts to achieve the required aspect ratio. Parameters
adjustable{'box', 'datalim'}
If 'box', change the physical dimensions of the Axes. If 'datalim', change the x or y data limits.
sharebool, default: False
If True, apply the settings to all shared Axes. See also matplotlib.axes.Axes.set_aspect
For a description of aspect handling. Notes Shared Axes (of which twinned Axes are a special case) impose restrictions on how aspect ratios can be imposed. For twinned Axes, use 'datalim'. For Axes that share both x and y, use 'box'. Otherwise, either 'datalim' or 'box' may be used. These limitations are partly a requirement to avoid over-specification, and partly a result of the particular implementation we are currently using, in which the adjustments for aspect ratios are done sequentially and independently on each Axes as it is drawn.
Examples using matplotlib.axes.Axes.set_adjustable
Loglog Aspect | matplotlib._as_gen.matplotlib.axes.axes.set_adjustable |
matplotlib.axes.Axes.set_anchor Axes.set_anchor(anchor, share=False)[source]
Define the anchor location. The actual drawing area (active position) of the Axes may be smaller than the Bbox (original position) when a fixed aspect is required. The anchor defines where the drawing area will be located within the available space. Parameters
anchor(float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}
Either an (x, y) pair of relative coordinates (0 is left or bottom, 1 is right or top), 'C' (center), or a cardinal direction ('SW', southwest, is bottom left, etc.). str inputs are shorthands for (x, y) coordinates, as shown in the following table: .. code-block:: none
'NW' (0.0, 1.0) 'N' (0.5, 1.0) 'NE' (1.0, 1.0)
'W' (0.0, 0.5) 'C' (0.5, 0.5) 'E' (1.0, 0.5)
'SW' (0.0, 0.0) 'S' (0.5, 0.0) 'SE' (1.0, 0.0)
sharebool, default: False
If True, apply the settings to all shared Axes. See also matplotlib.axes.Axes.set_aspect
for a description of aspect handling. | matplotlib._as_gen.matplotlib.axes.axes.set_anchor |
matplotlib.axes.Axes.set_aspect Axes.set_aspect(aspect, adjustable=None, anchor=None, share=False)[source]
Set the aspect ratio of the axes scaling, i.e. y/x-scale. Parameters
aspect{'auto', 'equal'} or float
Possible values: 'auto': fill the position rectangle with data. 'equal': same as aspect=1, i.e. same scaling for x and y.
float: The displayed size of 1 unit in y-data coordinates will be aspect times the displayed size of 1 unit in x-data coordinates; e.g. for aspect=2 a square in data coordinates will be rendered with a height of twice its width.
adjustableNone or {'box', 'datalim'}, optional
If not None, this defines which parameter will be adjusted to meet the required aspect. See set_adjustable for further details.
anchorNone or str or (float, float), optional
If not None, this defines where the Axes will be drawn if there is extra space due to aspect constraints. The most common way to to specify the anchor are abbreviations of cardinal directions:
value description
'C' centered
'SW' lower left corner
'S' middle of bottom edge
'SE' lower right corner
etc. See set_anchor for further details.
sharebool, default: False
If True, apply the settings to all shared Axes. See also matplotlib.axes.Axes.set_adjustable
Set how the Axes adjusts to achieve the required aspect ratio. matplotlib.axes.Axes.set_anchor
Set the position in case of extra space.
Examples using matplotlib.axes.Axes.set_aspect
Bar chart with gradients
Streamplot
Tricontour Demo
Tricontour Smooth Delaunay
Tricontour Smooth User
Trigradient Demo
Tripcolor Demo
Triplot Demo
Axes box aspect
Controlling view limits using margins and sticky_edges
Placing Colorbars
Multiline
Mmh Donuts!!!
Inset Locator Demo2
Scatter Histogram (Locatable Axes)
Simple Anchored Artists
axis_direction demo
Simple Axis Pad
The double pendulum problem
Anchored Artists
Rasterization for vector graphics
Loglog Aspect
Annotate Text Arrow
Transformations Tutorial
Colormap Normalization | matplotlib._as_gen.matplotlib.axes.axes.set_aspect |
matplotlib.axes.Axes.set_autoscale_on Axes.set_autoscale_on(b)[source]
Set whether autoscaling is applied to each axis on the next draw or call to Axes.autoscale_view. Parameters
bbool
Examples using matplotlib.axes.Axes.set_autoscale_on
Resampling Data | matplotlib._as_gen.matplotlib.axes.axes.set_autoscale_on |
matplotlib.axes.Axes.set_autoscalex_on Axes.set_autoscalex_on(b)[source]
Set whether the x-axis is autoscaled on the next draw or call to Axes.autoscale_view. Parameters
bbool | matplotlib._as_gen.matplotlib.axes.axes.set_autoscalex_on |
matplotlib.axes.Axes.set_autoscaley_on Axes.set_autoscaley_on(b)[source]
Set whether the y-axis is autoscaled on the next draw or call to Axes.autoscale_view. Parameters
bbool | matplotlib._as_gen.matplotlib.axes.axes.set_autoscaley_on |
matplotlib.axes.Axes.set_axes_locator Axes.set_axes_locator(locator)[source]
Set the Axes locator. Parameters
locatorCallable[[Axes, Renderer], Bbox]
Examples using matplotlib.axes.Axes.set_axes_locator
HBoxDivider demo | matplotlib._as_gen.matplotlib.axes.axes.set_axes_locator |
matplotlib.axes.Axes.set_axis_off Axes.set_axis_off()[source]
Turn the x- and y-axis off. This affects the axis lines, ticks, ticklabels, grid and axis labels.
Examples using matplotlib.axes.Axes.set_axis_off
Marker reference
Barcode
Blend transparency with color in 2D images
Nested pie charts
Annotation arrow style reference
Precise text layout
Drawing fancy boxes
Choosing Colormaps in Matplotlib
Text properties and layout | matplotlib._as_gen.matplotlib.axes.axes.set_axis_off |
matplotlib.axes.Axes.set_axis_on Axes.set_axis_on()[source]
Turn the x- and y-axis on. This affects the axis lines, ticks, ticklabels, grid and axis labels. | matplotlib._as_gen.matplotlib.axes.axes.set_axis_on |
matplotlib.axes.Axes.set_axisbelow Axes.set_axisbelow(b)[source]
Set whether axis ticks and gridlines are above or below most artists. This controls the zorder of the ticks and gridlines. For more information on the zorder see Zorder Demo. Parameters
bbool or 'line'
Possible values:
True (zorder = 0.5): Ticks and gridlines are below all Artists. 'line' (zorder = 1.5): Ticks and gridlines are above patches (e.g. rectangles, with default zorder = 1) but still below lines and markers (with their default zorder = 2).
False (zorder = 2.5): Ticks and gridlines are above patches and lines / markers. See also get_axisbelow | matplotlib._as_gen.matplotlib.axes.axes.set_axisbelow |
matplotlib.axes.Axes.set_box_aspect Axes.set_box_aspect(aspect=None)[source]
Set the Axes box aspect, i.e. the ratio of height to width. This defines the aspect of the Axes in figure space and is not to be confused with the data aspect (see set_aspect). Parameters
aspectfloat or None
Changes the physical dimensions of the Axes, such that the ratio of the Axes height to the Axes width in physical units is equal to aspect. Defining a box aspect will change the adjustable property to 'datalim' (see set_adjustable). None will disable a fixed box aspect so that height and width of the Axes are chosen independently. See also matplotlib.axes.Axes.set_aspect
for a description of aspect handling.
Examples using matplotlib.axes.Axes.set_box_aspect
Axes box aspect | matplotlib._as_gen.matplotlib.axes.axes.set_box_aspect |
matplotlib.axes.Axes.set_facecolor Axes.set_facecolor(color)[source]
Set the facecolor of the Axes. Parameters
colorcolor
Examples using matplotlib.axes.Axes.set_facecolor
Color Demo | matplotlib._as_gen.matplotlib.axes.axes.set_facecolor |
matplotlib.axes.Axes.set_frame_on Axes.set_frame_on(b)[source]
Set whether the Axes rectangle patch is drawn. Parameters
bbool | matplotlib._as_gen.matplotlib.axes.axes.set_frame_on |
matplotlib.axes.Axes.set_navigate Axes.set_navigate(b)[source]
Set whether the Axes responds to navigation toolbar commands. Parameters
bbool | matplotlib._as_gen.matplotlib.axes.axes.set_navigate |
matplotlib.axes.Axes.set_navigate_mode Axes.set_navigate_mode(b)[source]
Set the navigation toolbar button status. Warning this is not a user-API function. | matplotlib._as_gen.matplotlib.axes.axes.set_navigate_mode |
matplotlib.axes.Axes.set_position Axes.set_position(pos, which='both')[source]
Set the Axes position. Axes have two position attributes. The 'original' position is the position allocated for the Axes. The 'active' position is the position the Axes is actually drawn at. These positions are usually the same unless a fixed aspect is set to the Axes. See Axes.set_aspect for details. Parameters
pos[left, bottom, width, height] or Bbox
The new position of the in Figure coordinates.
which{'both', 'active', 'original'}, default: 'both'
Determines which position variables to change. See also matplotlib.transforms.Bbox.from_bounds
matplotlib.transforms.Bbox.from_extents
Examples using matplotlib.axes.Axes.set_position
Contour Demo | matplotlib._as_gen.matplotlib.axes.axes.set_position |
matplotlib.axes.Axes.set_prop_cycle Axes.set_prop_cycle(*args, **kwargs)[source]
Set the property cycle of the Axes. The property cycle controls the style properties such as color, marker and linestyle of future plot commands. The style properties of data already added to the Axes are not modified. Call signatures: set_prop_cycle(cycler)
set_prop_cycle(label=values[, label2=values2[, ...]])
set_prop_cycle(label, values)
Form 1 sets given Cycler object. Form 2 creates a Cycler which cycles over one or more properties simultaneously and set it as the property cycle of the Axes. If multiple properties are given, their value lists must have the same length. This is just a shortcut for explicitly creating a cycler and passing it to the function, i.e. it's short for set_prop_cycle(cycler(label=values label2=values2, ...)). Form 3 creates a Cycler for a single property and set it as the property cycle of the Axes. This form exists for compatibility with the original cycler.cycler interface. Its use is discouraged in favor of the kwarg form, i.e. set_prop_cycle(label=values). Parameters
cyclerCycler
Set the given Cycler. None resets to the cycle defined by the current style.
labelstr
The property key. Must be a valid Artist property. For example, 'color' or 'linestyle'. Aliases are allowed, such as 'c' for 'color' and 'lw' for 'linewidth'.
valuesiterable
Finite-length iterable of the property values. These values are validated and will raise a ValueError if invalid. See also matplotlib.rcsetup.cycler
Convenience function for creating validated cyclers for properties. cycler.cycler
The original function for creating unvalidated cyclers. Examples Setting the property cycle for a single property: >>> ax.set_prop_cycle(color=['red', 'green', 'blue'])
Setting the property cycle for simultaneously cycling over multiple properties (e.g. red circle, green plus, blue cross): >>> ax.set_prop_cycle(color=['red', 'green', 'blue'],
... marker=['o', '+', 'x'])
Examples using matplotlib.axes.Axes.set_prop_cycle
Bachelor's degrees by gender
Styling with cycler | matplotlib._as_gen.matplotlib.axes.axes.set_prop_cycle |
matplotlib.axes.Axes.set_rasterization_zorder Axes.set_rasterization_zorder(z)[source]
Set the zorder threshold for rasterization for vector graphics output. All artists with a zorder below the given value will be rasterized if they support rasterization. This setting is ignored for pixel-based output. See also Rasterization for vector graphics. Parameters
zfloat or None
The zorder below which artists are rasterized. If None rasterization based on zorder is deactivated.
Examples using matplotlib.axes.Axes.set_rasterization_zorder
Rasterization for vector graphics | matplotlib._as_gen.matplotlib.axes.axes.set_rasterization_zorder |
matplotlib.axes.Axes.set_title Axes.set_title(label, fontdict=None, loc=None, pad=None, *, y=None, **kwargs)[source]
Set a title for the Axes. Set one of the three available Axes titles. The available titles are positioned above the Axes in the center, flush with the left edge, and flush with the right edge. Parameters
labelstr
Text to use for the title
fontdictdict
A dictionary controlling the appearance of the title text, the default fontdict is: {'fontsize': rcParams['axes.titlesize'],
'fontweight': rcParams['axes.titleweight'],
'color': rcParams['axes.titlecolor'],
'verticalalignment': 'baseline',
'horizontalalignment': loc}
loc{'center', 'left', 'right'}, default: rcParams["axes.titlelocation"] (default: 'center')
Which title to set.
yfloat, default: rcParams["axes.titley"] (default: None)
Vertical Axes loation for the title (1.0 is the top). If None (the default), y is determined automatically to avoid decorators on the Axes.
padfloat, default: rcParams["axes.titlepad"] (default: 6.0)
The offset of the title from the top of the Axes, in points. Returns
Text
The matplotlib text instance representing the title Other Parameters
**kwargsText properties
Other keyword arguments are text properties, see Text for a list of valid text properties.
Examples using matplotlib.axes.Axes.set_title
Bar Label Demo
Stacked bar chart
Grouped bar chart with labels
Horizontal bar chart
Errorbar subsampling
EventCollection Demo
Fill Between and Alpha
Filling the area between lines
Fill Betweenx Demo
Hat graph
Markevery Demo
Psd Demo
Scatter Demo2
Using span_where
Stackplots and streamgraphs
hlines and vlines
Contour Corner Mask
Contour Demo
Contour Label Demo
Contourf Demo
Creating annotated heatmaps
Image antialiasing
Image Demo
Image Masked
Image Nonuniform
Interpolations for imshow
Contour plot of irregularly spaced data
Pcolor Demo
pcolormesh grids and shading
pcolormesh
Streamplot
Advanced quiver and quiverkey functions
Tricontour Demo
Tricontour Smooth Delaunay
Tricontour Smooth User
Trigradient Demo
Tripcolor Demo
Triplot Demo
Axes Demo
Controlling view limits using margins and sticky_edges
Resizing axes with constrained layout
Resizing axes with tight layout
Figure labels: suptitle, supxlabel, supylabel
Invert Axes
Secondary Axis
Figure subfigures
Creating multiple subplots using plt.subplots
Box plots with custom fill colors
Plot a confidence ellipse of a two-dimensional dataset
Violin plot customization
Different ways of specifying error bars
Including upper and lower limits in error bars
Hexagonal binned plot
Using histograms to plot a cumulative distribution
Some features of the histogram (hist) function
The histogram (hist) function with multiple data sets
Bar of pie
Labeling a pie and a donut
Polar plot
Using accented text in matplotlib
Scale invariant angle label
Date tick labels
Custom tick formatter for time series
Labeling ticks using engineering notation
Using a ttf font file in Matplotlib
Labelling subplots
Legend Demo
Mathtext
Math fontfamily
Multiline
Rendering math equations using TeX
Title positioning
Boxplot Demo
Simple axes labels
Text Commands
Color Demo
Creating a colormap from a list of colors
Line, Poly and RegularPoly Collection with autoscaling
Compound path
Mmh Donuts!!!
Line Collection
Bezier Curve
Bayesian Methods for Hackers style sheet
Dark background style sheet
FiveThirtyEight style sheet
Make Room For Ylabel Using Axesgrid
Axis Direction
Anatomy of a figure
XKCD
pyplot animation
Data Browser
Image Slices Viewer
Keypress event
Lasso Demo
Legend Picking
Looking Glass
Path Editor
Pick Event Demo2
Poly Editor
Trifinder Event Demo
Viewlims
Cross hair cursor
Packed-bubble chart
Pythonic Matplotlib
Rasterization for vector graphics
Zorder Demo
Demo of 3D bar charts
Lorenz Attractor
3D wireframe plots in one direction
Loglog Aspect
Exploring normalizations
Scales
Radar chart (aka spider or star chart)
Topographic hillshading
Spine Placement
Spines
Dropped spines
Colorbar Tick Labelling
Date Precision and Epochs
Set default x-axis tick labels on the top
Artist tests
Group barchart with units
Evans test
Interactive Adjustment of Colormap Range
Annotated Cursor
Rectangle and ellipse selectors
Span Selector
Basic Usage
Image tutorial
Artist tutorial
Styling with cycler
Constrained Layout Guide
Tight Layout guide
Transformations Tutorial
Specifying Colors
Colormap Normalization
Text in Matplotlib Plots | matplotlib._as_gen.matplotlib.axes.axes.set_title |
matplotlib.axes.Axes.set_xbound Axes.set_xbound(lower=None, upper=None)[source]
Set the lower and upper numerical bounds of the x-axis. This method will honor axis inversion regardless of parameter order. It will not change the autoscaling setting (get_autoscalex_on()). Parameters
lower, upperfloat or None
The lower and upper bounds. If None, the respective axis bound is not modified. See also get_xbound
get_xlim, set_xlim
invert_xaxis, xaxis_inverted | matplotlib._as_gen.matplotlib.axes.axes.set_xbound |
matplotlib.axes.Axes.set_xlabel Axes.set_xlabel(xlabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)[source]
Set the label for the x-axis. Parameters
xlabelstr
The label text.
labelpadfloat, default: rcParams["axes.labelpad"] (default: 4.0)
Spacing in points from the Axes bounding box including ticks and tick labels. If None, the previous value is left as is.
loc{'left', 'center', 'right'}, default: rcParams["xaxis.labellocation"] (default: 'center')
The label position. This is a high-level alternative for passing parameters x and horizontalalignment. Other Parameters
**kwargsText properties
Text properties control the appearance of the label. See also text
Documents the properties supported by Text.
Examples using matplotlib.axes.Axes.set_xlabel
Bar Label Demo
Horizontal bar chart
Broken Barh
CSD Demo
Fill Between and Alpha
Filling the area between lines
Fill Betweenx Demo
Hatch-filled histograms
Hat graph
Psd Demo
Scatter Demo2
Stackplots and streamgraphs
hlines and vlines
Contourf Demo
Tricontour Demo
Tripcolor Demo
Triplot Demo
Aligning Labels
Axes Demo
Axis Label Position
Resizing axes with constrained layout
Resizing axes with tight layout
Figure labels: suptitle, supxlabel, supylabel
Invert Axes
Secondary Axis
Figure subfigures
Multiple subplots
Plots with different scales
Box plots with custom fill colors
Boxplots
Box plot vs. violin plot comparison
Violin plot customization
Using histograms to plot a cumulative distribution
Some features of the histogram (hist) function
Producing multiple histograms side by side
Using accented text in matplotlib
Labeling ticks using engineering notation
Using a ttf font file in Matplotlib
Legend Demo
Mathtext
Multiline
Rendering math equations using TeX
Title positioning
Simple axes labels
Text Commands
Color Demo
Line, Poly and RegularPoly Collection with autoscaling
Ellipse Collection
Dark background style sheet
Make Room For Ylabel Using Axesgrid
Parasite Simple
Parasite Axes demo
Parasite axis demo
Ticklabel alignment
Simple Axis Direction03
Simple Axisline
Anatomy of a figure
XKCD
Keypress event
Pythonic Matplotlib
Plot 2D data on 3D plot
Create 2D bar graphs in different planes
3D errorbars
Lorenz Attractor
Automatic Text Offsetting
3D scatterplot
3D surface with polar coordinates
Text annotations in 3D
Log Bar
MRI With EEG
Multiple Yaxis With Spines
Centering labels between ticks
Pgf Fonts
Pgf Texsystem
Slider
Basic Usage
Artist tutorial
Constrained Layout Guide
Tight Layout guide
Arranging multiple Axes in a Figure
Choosing Colormaps in Matplotlib
Text in Matplotlib Plots | matplotlib._as_gen.matplotlib.axes.axes.set_xlabel |
matplotlib.axes.Axes.set_xlim Axes.set_xlim(left=None, right=None, emit=True, auto=False, *, xmin=None, xmax=None)[source]
Set the x-axis view limits. Parameters
leftfloat, optional
The left xlim in data coordinates. Passing None leaves the limit unchanged. The left and right xlims may also be passed as the tuple (left, right) as the first positional argument (or as the left keyword argument).
rightfloat, optional
The right xlim in data coordinates. Passing None leaves the limit unchanged.
emitbool, default: True
Whether to notify observers of limit change.
autobool or None, default: False
Whether to turn on autoscaling of the x-axis. True turns on, False turns off, None leaves unchanged.
xmin, xmaxfloat, optional
They are equivalent to left and right respectively, and it is an error to pass both xmin and left or xmax and right. Returns
left, right(float, float)
The new x-axis limits in data coordinates. See also get_xlim
set_xbound, get_xbound
invert_xaxis, xaxis_inverted
Notes The left value may be greater than the right value, in which case the x-axis values will decrease from left to right. Examples >>> set_xlim(left, right)
>>> set_xlim((left, right))
>>> left, right = set_xlim(left, right)
One limit may be left unchanged. >>> set_xlim(right=right_lim)
Limits may be passed in reverse order to flip the direction of the x-axis. For example, suppose x represents the number of years before present. The x-axis limits might be set like the following so 5000 years ago is on the left of the plot and the present is on the right. >>> set_xlim(5000, 0)
Examples using matplotlib.axes.Axes.set_xlim
Bar Label Demo
Broken Barh
CSD Demo
EventCollection Demo
Markevery Demo
Contouring the solution space of optimizations
Image Nonuniform
pcolormesh grids and shading
Axes box aspect
Axes Demo
Figure labels: suptitle, supxlabel, supylabel
Invert Axes
Zoom region inset axes
Boxplots
Violin plot customization
Including upper and lower limits in error bars
Bar of pie
AnnotationBbox demo
Using a text as a Path
Text Rotation Relative To Line
Annotate Transform
Mmh Donuts!!!
Ellipse Demo
Line Collection
Inset Locator Demo2
Parasite Simple2
axis_direction demo
Parasite Axes demo
Parasite axis demo
Simple Axis Pad
Anatomy of a figure
Bachelor's degrees by gender
XKCD
Decay
Rain simulation
Path Editor
Poly Editor
Resampling Data
Zoom Window
Frontpage contour example
Frontpage plot example
Custom projection
Building histograms using Rectangles and PolyCollections
SVG Filter Line
TickedStroke patheffect
Plot 2D data on 3D plot
Draw flat objects in 3D plot
Text annotations in 3D
Loglog Aspect
Scales
MRI With EEG
SkewT-logP diagram: using transforms and custom projections
Multiple Yaxis With Spines
Custom spine bounds
Formatting date ticks using ConciseDateFormatter
Date Demo Convert
Annotation with units
Artist tests
Annotate Text Arrow
Connect Simple01
Annotated Cursor
Cursor
Span Selector
Path Tutorial
Transformations Tutorial
Specifying Colors
Choosing Colormaps in Matplotlib | matplotlib._as_gen.matplotlib.axes.axes.set_xlim |
matplotlib.axes.Axes.set_xmargin Axes.set_xmargin(m)[source]
Set padding of X data limits prior to autoscaling. m times the data interval will be added to each end of that interval before it is used in autoscaling. For example, if your data is in the range [0, 2], a factor of m = 0.1 will result in a range [-0.2, 2.2]. Negative values -0.5 < m < 0 will result in clipping of the data range. I.e. for a data range [0, 2], a factor of m = -0.1 will result in a range [0.2, 1.8]. Parameters
mfloat greater than -0.5
Examples using matplotlib.axes.Axes.set_xmargin
Automatically setting tick positions | matplotlib._as_gen.matplotlib.axes.axes.set_xmargin |
matplotlib.axes.Axes.set_xscale Axes.set_xscale(value, **kwargs)[source]
Set the x-axis scale. Parameters
value{"linear", "log", "symlog", "logit", ...} or ScaleBase
The axis scale type to apply. **kwargs
Different keyword arguments are accepted, depending on the scale. See the respective class keyword arguments: matplotlib.scale.LinearScale matplotlib.scale.LogScale matplotlib.scale.SymmetricalLogScale matplotlib.scale.LogitScale matplotlib.scale.FuncScale Notes By default, Matplotlib supports the above mentioned scales. Additionally, custom scales may be registered using matplotlib.scale.register_scale. These scales can then also be used here.
Examples using matplotlib.axes.Axes.set_xscale
Markevery Demo
Labeling ticks using engineering notation
Inset Locator Demo
Loglog Aspect
Log Demo
Symlog Demo
Transformations Tutorial | matplotlib._as_gen.matplotlib.axes.axes.set_xscale |
matplotlib.axes.Axes.set_xticklabels Axes.set_xticklabels(labels, *, fontdict=None, minor=False, **kwargs)[source]
Set the xaxis' labels with list of string labels. Warning This method should only be used after fixing the tick positions using Axes.set_xticks. Otherwise, the labels may end up in unexpected positions. Parameters
labelslist of str
The label texts.
fontdictdict, optional
A dictionary controlling the appearance of the ticklabels. The default fontdict is: {'fontsize': rcParams['axes.titlesize'],
'fontweight': rcParams['axes.titleweight'],
'verticalalignment': 'baseline',
'horizontalalignment': loc}
minorbool, default: False
Whether to set the minor ticklabels rather than the major ones. Returns
list of Text
The labels. Other Parameters
**kwargsText properties.
Examples using matplotlib.axes.Axes.set_xticklabels
Managing multiple figures in pyplot
Zoom region inset axes
Boxplots
Rendering math equations using TeX
XKCD
Colorbar Tick Labelling
Constrained Layout Guide | matplotlib._as_gen.matplotlib.axes.axes.set_xticklabels |
matplotlib.axes.Axes.set_xticks Axes.set_xticks(ticks, labels=None, *, minor=False, **kwargs)[source]
Set the xaxis' tick locations and optionally labels. If necessary, the view limits of the Axis are expanded so that all given ticks are visible. Parameters
tickslist of floats
List of tick locations.
labelslist of str, optional
List of tick labels. If not set, the labels show the data value.
minorbool, default: False
If False, set the major ticks; if True, the minor ticks. **kwargs
Text properties for the labels. These take effect only if you pass labels. In other cases, please use tick_params. Notes The mandatory expansion of the view limits is an intentional design choice to prevent the surprise of a non-visible tick. If you need other limits, you should set the limits explicitly after setting the ticks.
Examples using matplotlib.axes.Axes.set_xticks
Bar Label Demo
Grouped bar chart with labels
Hat graph
Psd Demo
Creating annotated heatmaps
Box plot vs. violin plot comparison
Violin plot customization
Producing multiple histograms side by side
Multiline
Rendering math equations using TeX
ggplot style sheet
Scatter Histogram (Locatable Axes)
Simple Axisline4
Ticklabel alignment
Ticklabel direction
Bachelor's degrees by gender
Integral as the area under a curve
Shaded & power normalized rendering
XKCD
Rain simulation
MATPLOTLIB UNCHAINED
Frontpage 3D example
Frontpage contour example
Frontpage histogram example
Frontpage plot example
Log Bar
MRI With EEG
Custom spine bounds
Group barchart with units
The Lifecycle of a Plot | matplotlib._as_gen.matplotlib.axes.axes.set_xticks |
matplotlib.axes.Axes.set_ybound Axes.set_ybound(lower=None, upper=None)[source]
Set the lower and upper numerical bounds of the y-axis. This method will honor axis inversion regardless of parameter order. It will not change the autoscaling setting (get_autoscaley_on()). Parameters
lower, upperfloat or None
The lower and upper bounds. If None, the respective axis bound is not modified. See also get_ybound
get_ylim, set_ylim
invert_yaxis, yaxis_inverted | matplotlib._as_gen.matplotlib.axes.axes.set_ybound |
matplotlib.axes.Axes.set_ylabel Axes.set_ylabel(ylabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)[source]
Set the label for the y-axis. Parameters
ylabelstr
The label text.
labelpadfloat, default: rcParams["axes.labelpad"] (default: 4.0)
Spacing in points from the Axes bounding box including ticks and tick labels. If None, the previous value is left as is.
loc{'bottom', 'center', 'top'}, default: rcParams["yaxis.labellocation"] (default: 'center')
The label position. This is a high-level alternative for passing parameters y and horizontalalignment. Other Parameters
**kwargsText properties
Text properties control the appearance of the label. See also text
Documents the properties supported by Text.
Examples using matplotlib.axes.Axes.set_ylabel
Bar Label Demo
Stacked bar chart
Grouped bar chart with labels
CSD Demo
Fill Between and Alpha
Hatch-filled histograms
Hat graph
Psd Demo
Scatter Demo2
Stackplots and streamgraphs
Contourf Demo
Creating annotated heatmaps
Tricontour Demo
Tripcolor Demo
Triplot Demo
Aligning Labels
Axes Demo
Axis Label Position
Resizing axes with constrained layout
Resizing axes with tight layout
Figure labels: suptitle, supxlabel, supylabel
Invert Axes
Secondary Axis
Figure subfigures
Multiple subplots
Plots with different scales
Box plots with custom fill colors
Boxplots
Box plot vs. violin plot comparison
Violin plot customization
Using histograms to plot a cumulative distribution
Some features of the histogram (hist) function
Producing multiple histograms side by side
Using accented text in matplotlib
Date tick labels
Legend Demo
Mathtext
Multiline
Rendering math equations using TeX
Simple axes labels
Text Commands
Color Demo
Line, Poly and RegularPoly Collection with autoscaling
Ellipse Collection
Dark background style sheet
Make Room For Ylabel Using Axesgrid
Parasite Simple
Parasite Axes demo
Parasite axis demo
Ticklabel alignment
Simple Axis Direction03
Simple Axisline
Anatomy of a figure
XKCD
Pythonic Matplotlib
Plot 2D data on 3D plot
Create 2D bar graphs in different planes
3D errorbars
Lorenz Attractor
2D and 3D Axes in same Figure
Automatic Text Offsetting
3D scatterplot
3D surface with polar coordinates
Text annotations in 3D
Log Bar
Symlog Demo
MRI With EEG
Topographic hillshading
Multiple Yaxis With Spines
Basic Usage
Artist tutorial
Constrained Layout Guide
Tight Layout guide
Arranging multiple Axes in a Figure
Choosing Colormaps in Matplotlib
Text in Matplotlib Plots | matplotlib._as_gen.matplotlib.axes.axes.set_ylabel |
matplotlib.axes.Axes.set_ylim Axes.set_ylim(bottom=None, top=None, emit=True, auto=False, *, ymin=None, ymax=None)[source]
Set the y-axis view limits. Parameters
bottomfloat, optional
The bottom ylim in data coordinates. Passing None leaves the limit unchanged. The bottom and top ylims may also be passed as the tuple (bottom, top) as the first positional argument (or as the bottom keyword argument).
topfloat, optional
The top ylim in data coordinates. Passing None leaves the limit unchanged.
emitbool, default: True
Whether to notify observers of limit change.
autobool or None, default: False
Whether to turn on autoscaling of the y-axis. True turns on, False turns off, None leaves unchanged.
ymin, ymaxfloat, optional
They are equivalent to bottom and top respectively, and it is an error to pass both ymin and bottom or ymax and top. Returns
bottom, top(float, float)
The new y-axis limits in data coordinates. See also get_ylim
set_ybound, get_ybound
invert_yaxis, yaxis_inverted
Notes The bottom value may be greater than the top value, in which case the y-axis values will decrease from bottom to top. Examples >>> set_ylim(bottom, top)
>>> set_ylim((bottom, top))
>>> bottom, top = set_ylim(bottom, top)
One limit may be left unchanged. >>> set_ylim(top=top_lim)
Limits may be passed in reverse order to flip the direction of the y-axis. For example, suppose y represents depth of the ocean in m. The y-axis limits might be set like the following so 5000 m depth is at the bottom of the plot and the surface, 0 m, is at the top. >>> set_ylim(5000, 0)
Examples using matplotlib.axes.Axes.set_ylim
Broken Barh
EventCollection Demo
Hat graph
Markevery Demo
Psd Demo
Contouring the solution space of optimizations
Image Nonuniform
pcolormesh grids and shading
Axes Demo
Broken Axis
Figure labels: suptitle, supxlabel, supylabel
Zoom region inset axes
Boxplots
AnnotationBbox demo
Using a text as a Path
Annotate Transform
Annotating a plot
Line, Poly and RegularPoly Collection with autoscaling
Mmh Donuts!!!
Ellipse Demo
Line Collection
Inset Locator Demo2
Parasite Simple2
axis_direction demo
Parasite Axes demo
Parasite axis demo
Simple Axis Pad
Simple Axisline
Anatomy of a figure
Bachelor's degrees by gender
Integral as the area under a curve
XKCD
Decay
Animated histogram
Rain simulation
MATPLOTLIB UNCHAINED
Data Browser
Path Editor
Pick Event Demo2
Poly Editor
Zoom Window
Frontpage contour example
Frontpage plot example
Custom projection
Building histograms using Rectangles and PolyCollections
Pythonic Matplotlib
SVG Filter Line
TickedStroke patheffect
Plot 2D data on 3D plot
Draw flat objects in 3D plot
Text annotations in 3D
Loglog Aspect
Log Demo
MRI With EEG
SkewT-logP diagram: using transforms and custom projections
Multiple Yaxis With Spines
Custom spine bounds
Annotation with units
Artist tests
Annotate Text Arrow
Connect Simple01
Annotated Cursor
Cursor
Span Selector
Basic Usage
Path Tutorial
Transformations Tutorial
Specifying Colors
Choosing Colormaps in Matplotlib | matplotlib._as_gen.matplotlib.axes.axes.set_ylim |
matplotlib.axes.Axes.set_ymargin Axes.set_ymargin(m)[source]
Set padding of Y data limits prior to autoscaling. m times the data interval will be added to each end of that interval before it is used in autoscaling. For example, if your data is in the range [0, 2], a factor of m = 0.1 will result in a range [-0.2, 2.2]. Negative values -0.5 < m < 0 will result in clipping of the data range. I.e. for a data range [0, 2], a factor of m = -0.1 will result in a range [0.2, 1.8]. Parameters
mfloat greater than -0.5 | matplotlib._as_gen.matplotlib.axes.axes.set_ymargin |
matplotlib.axes.Axes.set_yscale Axes.set_yscale(value, **kwargs)[source]
Set the y-axis scale. Parameters
value{"linear", "log", "symlog", "logit", ...} or ScaleBase
The axis scale type to apply. **kwargs
Different keyword arguments are accepted, depending on the scale. See the respective class keyword arguments: matplotlib.scale.LinearScale matplotlib.scale.LogScale matplotlib.scale.SymmetricalLogScale matplotlib.scale.LogitScale matplotlib.scale.FuncScale Notes By default, Matplotlib supports the above mentioned scales. Additionally, custom scales may be registered using matplotlib.scale.register_scale. These scales can then also be used here.
Examples using matplotlib.axes.Axes.set_yscale
Markevery Demo
Artist customization in box plots
Boxplot drawer function
Different ways of specifying error bars
Loglog Aspect
Log Bar
Log Demo
Scales
Symlog Demo | matplotlib._as_gen.matplotlib.axes.axes.set_yscale |
matplotlib.axes.Axes.set_yticklabels Axes.set_yticklabels(labels, *, fontdict=None, minor=False, **kwargs)[source]
Set the yaxis' labels with list of string labels. Warning This method should only be used after fixing the tick positions using Axes.set_yticks. Otherwise, the labels may end up in unexpected positions. Parameters
labelslist of str
The label texts.
fontdictdict, optional
A dictionary controlling the appearance of the ticklabels. The default fontdict is: {'fontsize': rcParams['axes.titlesize'],
'fontweight': rcParams['axes.titleweight'],
'verticalalignment': 'baseline',
'horizontalalignment': loc}
minorbool, default: False
Whether to set the minor ticklabels rather than the major ones. Returns
list of Text
The labels. Other Parameters
**kwargsText properties.
Examples using matplotlib.axes.Axes.set_yticklabels
Zoom region inset axes
Artist customization in box plots
Boxplot drawer function
Violin plot basics
Rendering math equations using TeX
Colorbar Tick Labelling
Constrained Layout Guide | matplotlib._as_gen.matplotlib.axes.axes.set_yticklabels |
matplotlib.axes.Axes.set_yticks Axes.set_yticks(ticks, labels=None, *, minor=False, **kwargs)[source]
Set the yaxis' tick locations and optionally labels. If necessary, the view limits of the Axis are expanded so that all given ticks are visible. Parameters
tickslist of floats
List of tick locations.
labelslist of str, optional
List of tick labels. If not set, the labels show the data value.
minorbool, default: False
If False, set the major ticks; if True, the minor ticks. **kwargs
Text properties for the labels. These take effect only if you pass labels. In other cases, please use tick_params. Notes The mandatory expansion of the view limits is an intentional design choice to prevent the surprise of a non-visible tick. If you need other limits, you should set the limits explicitly after setting the ticks.
Examples using matplotlib.axes.Axes.set_yticks
Bar Label Demo
Horizontal bar chart
Broken Barh
Psd Demo
Creating annotated heatmaps
Rendering math equations using TeX
Programmatically controlling subplot adjustment
Make Room For Ylabel Using Axesgrid
Scatter Histogram (Locatable Axes)
Ticklabel alignment
Ticklabel direction
Bachelor's degrees by gender
Integral as the area under a curve
Shaded & power normalized rendering
XKCD
Rain simulation
MATPLOTLIB UNCHAINED
Frontpage 3D example
Frontpage contour example
Frontpage histogram example
Frontpage plot example
Create 2D bar graphs in different planes
MRI With EEG
SkewT-logP diagram: using transforms and custom projections
Custom spine bounds | matplotlib._as_gen.matplotlib.axes.axes.set_yticks |
matplotlib.axes.Axes.sharex Axes.sharex(other)[source]
Share the x-axis with other. This is equivalent to passing sharex=other when constructing the axes, and cannot be used if the x-axis is already being shared with another Axes. | matplotlib._as_gen.matplotlib.axes.axes.sharex |
matplotlib.axes.Axes.sharey Axes.sharey(other)[source]
Share the y-axis with other. This is equivalent to passing sharey=other when constructing the axes, and cannot be used if the y-axis is already being shared with another Axes. | matplotlib._as_gen.matplotlib.axes.axes.sharey |
matplotlib.axes.Axes.specgram Axes.specgram(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, cmap=None, xextent=None, pad_to=None, sides=None, scale_by_freq=None, mode=None, scale=None, vmin=None, vmax=None, *, data=None, **kwargs)[source]
Plot a spectrogram. Compute and plot a spectrogram of data in x. Data are split into NFFT length segments and the spectrum 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. The spectrogram is plotted as a colormap (using imshow). Parameters
x1-D array or sequence
Array or sequence containing the data.
Fsfloat, default: 2
The sampling frequency (samples per time unit). It is used to calculate the Fourier frequencies, freqs, in cycles per time unit.
windowcallable or ndarray, default: window_hanning
A function or a vector of length NFFT. To create window vectors see window_hanning, window_none, numpy.blackman, numpy.hamming, numpy.bartlett, scipy.signal, scipy.signal.get_window, etc. If a function is passed as the argument, it must take a data segment as an argument and return the windowed version of the segment.
sides{'default', 'onesided', 'twosided'}, optional
Which sides of the spectrum to return. 'default' is one-sided for real data and two-sided for complex data. 'onesided' forces the return of a one-sided spectrum, while 'twosided' forces two-sided.
pad_toint, optional
The number of points to which the data segment is padded when performing the FFT. This can be different from NFFT, which specifies the number of data points used. While not increasing the actual resolution of the spectrum (the minimum distance between resolvable peaks), this can give more points in the plot, allowing for more detail. This corresponds to the n parameter in the call to fft(). The default is None, which sets pad_to equal to NFFT
NFFTint, default: 256
The number of data points used in each block for the FFT. A power 2 is most efficient. This should NOT be used to get zero padding, or the scaling of the result will be incorrect; use pad_to for this instead.
detrend{'none', 'mean', 'linear'} or callable, default: 'none'
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 it is a function. The mlab module defines detrend_none, detrend_mean, and detrend_linear, but you can use a custom function as well. You can also use a string to choose one of the functions: 'none' calls detrend_none. 'mean' calls detrend_mean. 'linear' calls detrend_linear.
scale_by_freqbool, default: True
Whether the resulting density values should be scaled by the scaling frequency, which gives density in units of Hz^-1. This allows for integration over the returned frequency values. The default is True for MATLAB compatibility.
mode{'default', 'psd', 'magnitude', 'angle', 'phase'}
What sort of spectrum to use. Default is 'psd', which takes the power spectral density. 'magnitude' returns the magnitude spectrum. 'angle' returns the phase spectrum without unwrapping. 'phase' returns the phase spectrum with unwrapping.
noverlapint, default: 128
The number of points of overlap between blocks.
scale{'default', 'linear', 'dB'}
The scaling of the values in the spec. 'linear' is no scaling. 'dB' returns the values in dB scale. When mode is 'psd', this is dB power (10 * log10). Otherwise this is dB amplitude (20 * log10). 'default' is 'dB' if mode is 'psd' or 'magnitude' and 'linear' otherwise. This must be 'linear' if mode is 'angle' or 'phase'.
Fcint, default: 0
The center frequency of x, which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband.
cmapColormap, default: rcParams["image.cmap"] (default: 'viridis')
xextentNone or (xmin, xmax)
The image extent along the x-axis. The default sets xmin to the left border of the first bin (spectrum column) and xmax to the right border of the last bin. Note that for noverlap>0 the width of the bins is smaller than those of the segments.
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x **kwargs
Additional keyword arguments are passed on to imshow which makes the specgram image. The origin keyword argument is not supported. Returns
spectrum2D array
Columns are the periodograms of successive segments.
freqs1-D array
The frequencies corresponding to the rows in spectrum.
t1-D array
The times corresponding to midpoints of segments (i.e., the columns in spectrum).
imAxesImage
The image created by imshow containing the spectrogram. See also psd
Differs in the default overlap; in returning the mean of the segment periodograms; in not returning times; and in generating a line plot instead of colormap. magnitude_spectrum
A single spectrum, similar to having a single segment when mode is 'magnitude'. Plots a line instead of a colormap. angle_spectrum
A single spectrum, similar to having a single segment when mode is 'angle'. Plots a line instead of a colormap. phase_spectrum
A single spectrum, similar to having a single segment when mode is 'phase'. Plots a line instead of a colormap. Notes The parameters detrend and scale_by_freq do only apply when mode is set to 'psd'.
Examples using matplotlib.axes.Axes.specgram
Spectrogram Demo | matplotlib._as_gen.matplotlib.axes.axes.specgram |
matplotlib.axes.Axes.spy Axes.spy(Z, precision=0, marker=None, markersize=None, aspect='equal', origin='upper', **kwargs)[source]
Plot the sparsity pattern of a 2D array. This visualizes the non-zero values of the array. Two plotting styles are available: image and marker. Both are available for full arrays, but only the marker style works for scipy.sparse.spmatrix instances. Image style If marker and markersize are None, imshow is used. Any extra remaining keyword arguments are passed to this method. Marker style If Z is a scipy.sparse.spmatrix or marker or markersize are None, a Line2D object will be returned with the value of marker determining the marker type, and any remaining keyword arguments passed to plot. Parameters
Z(M, N) array-like
The array to be plotted.
precisionfloat or 'present', default: 0
If precision is 0, any non-zero value will be plotted. Otherwise, values of \(|Z| > precision\) will be plotted. For scipy.sparse.spmatrix instances, you can also pass 'present'. In this case any value present in the array will be plotted, even if it is identically zero.
aspect{'equal', 'auto', None} or float, default: 'equal'
The aspect ratio of the Axes. This parameter is particularly relevant for images since it determines whether data pixels are square. This parameter is a shortcut for explicitly calling Axes.set_aspect. See there for further details. 'equal': Ensures an aspect ratio of 1. Pixels will be square. 'auto': The Axes is kept fixed and the aspect is adjusted so that the data fit in the Axes. In general, this will result in non-square pixels.
None: Use rcParams["image.aspect"] (default: 'equal').
origin{'upper', 'lower'}, default: rcParams["image.origin"] (default: 'upper')
Place the [0, 0] index of the array in the upper left or lower left corner of the Axes. The convention 'upper' is typically used for matrices and images. Returns
AxesImage or Line2D
The return type depends on the plotting style (see above). Other Parameters
**kwargs
The supported additional parameters depend on the plotting style. For the image style, you can pass the following additional parameters of imshow: cmap alpha url any Artist properties (passed on to the AxesImage) For the marker style, you can pass any Line2D property except for linestyle:
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
antialiased or aa bool
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
color or c color
dash_capstyle CapStyle or {'butt', 'projecting', 'round'}
dash_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
dashes sequence of floats (on/off ink in points) or (None, None)
data (2, N) array or two 1D arrays
drawstyle or ds {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
figure Figure
fillstyle {'full', 'left', 'right', 'bottom', 'top', 'none'}
gid str
in_layout bool
label object
linestyle or ls {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
linewidth or lw float
marker marker style string, Path or MarkerStyle
markeredgecolor or mec color
markeredgewidth or mew float
markerfacecolor or mfc color
markerfacecoloralt or mfcalt color
markersize or ms float
markevery None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]
path_effects AbstractPathEffect
picker float or callable[[Artist, Event], tuple[bool, dict]]
pickradius float
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
solid_capstyle CapStyle or {'butt', 'projecting', 'round'}
solid_joinstyle JoinStyle or {'miter', 'round', 'bevel'}
transform unknown
url str
visible bool
xdata 1D array
ydata 1D array
zorder float
Examples using matplotlib.axes.Axes.spy
Spy Demos | matplotlib._as_gen.matplotlib.axes.axes.spy |
matplotlib.axes.Axes.stackplot Axes.stackplot(x, *args, labels=(), colors=None, baseline='zero', data=None, **kwargs)[source]
Draw a stacked area plot. Parameters
x(N,) array-like
y(M, N) array-like
The data is assumed to be unstacked. Each of the following calls is legal: stackplot(x, y) # where y has shape (M, N)
stackplot(x, y1, y2, y3) # where y1, y2, y3, y4 have length N
baseline{'zero', 'sym', 'wiggle', 'weighted_wiggle'}
Method used to calculate the baseline:
'zero': Constant zero baseline, i.e. a simple stacked plot.
'sym': Symmetric around zero and is sometimes called 'ThemeRiver'.
'wiggle': Minimizes the sum of the squared slopes.
'weighted_wiggle': Does the same but weights to account for size of each layer. It is also called 'Streamgraph'-layout. More details can be found at http://leebyron.com/streamgraph/.
labelslist of str, optional
A sequence of labels to assign to each data series. If unspecified, then no labels will be applied to artists.
colorslist of color, optional
A sequence of colors to be cycled through and used to color the stacked areas. The sequence need not be exactly the same length as the number of provided y, in which case the colors will repeat from the beginning. If not specified, the colors from the Axes property cycle will be used.
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception). **kwargs
All other keyword arguments are passed to Axes.fill_between. Returns
list of PolyCollection
A list of PolyCollection instances, one for each element in the stacked area plot.
Examples using matplotlib.axes.Axes.stackplot
Stackplots and streamgraphs | matplotlib._as_gen.matplotlib.axes.axes.stackplot |
matplotlib.axes.Axes.stairs Axes.stairs(values, edges=None, *, orientation='vertical', baseline=0, fill=False, data=None, **kwargs)[source]
A stepwise constant function as a line with bounding edges or a filled plot. Parameters
valuesarray-like
The step heights.
edgesarray-like
The edge positions, with len(edges) == len(vals) + 1, between which the curve takes on vals values.
orientation{'vertical', 'horizontal'}, default: 'vertical'
The direction of the steps. Vertical means that values are along the y-axis, and edges are along the x-axis.
baselinefloat, array-like or None, default: 0
The bottom value of the bounding edges or when fill=True, position of lower edge. If fill is True or an array is passed to baseline, a closed path is drawn.
fillbool, default: False
Whether the area under the step curve should be filled. Returns
StepPatchmatplotlib.patches.StepPatch
Other Parameters
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception). **kwargs
StepPatch properties | matplotlib._as_gen.matplotlib.axes.axes.stairs |
matplotlib.axes.Axes.stale propertyAxes.stale
Whether the artist is 'stale' and needs to be re-drawn for the output to match the internal state of the artist. | matplotlib._as_gen.matplotlib.axes.axes.stale |
matplotlib.axes.Axes.start_pan Axes.start_pan(x, y, button)[source]
Called when a pan operation has started. Parameters
x, yfloat
The mouse coordinates in display coords.
buttonMouseButton
The pressed mouse button. Notes This is intended to be overridden by new projection types. | matplotlib._as_gen.matplotlib.axes.axes.start_pan |
matplotlib.axes.Axes.stem Axes.stem(*args, linefmt=None, markerfmt=None, basefmt=None, bottom=0, label=None, use_line_collection=True, orientation='vertical', data=None)[source]
Create a stem plot. A stem plot draws lines perpendicular to a baseline at each location locs from the baseline to heads, and places a marker there. For vertical stem plots (the default), the locs are x positions, and the heads are y values. For horizontal stem plots, the locs are y positions, and the heads are x values. Call signature: stem([locs,] heads, linefmt=None, markerfmt=None, basefmt=None)
The locs-positions are optional. The formats may be provided either as positional or as keyword-arguments. Parameters
locsarray-like, default: (0, 1, ..., len(heads) - 1)
For vertical stem plots, the x-positions of the stems. For horizontal stem plots, the y-positions of the stems.
headsarray-like
For vertical stem plots, the y-values of the stem heads. For horizontal stem plots, the x-values of the stem heads.
linefmtstr, optional
A string defining the color and/or linestyle of the vertical lines:
Character Line Style
'-' solid line
'--' dashed line
'-.' dash-dot line
':' dotted line Default: 'C0-', i.e. solid line with the first color of the color cycle. Note: Markers specified through this parameter (e.g. 'x') will be silently ignored (unless using use_line_collection=False). Instead, markers should be specified using markerfmt.
markerfmtstr, optional
A string defining the color and/or shape of the markers at the stem heads. Default: 'C0o', i.e. filled circles with the first color of the color cycle.
basefmtstr, default: 'C3-' ('C2-' in classic mode)
A format string defining the properties of the baseline.
orientationstr, default: 'vertical'
If 'vertical', will produce a plot with stems oriented vertically, otherwise the stems will be oriented horizontally.
bottomfloat, default: 0
The y/x-position of the baseline (depending on orientation).
labelstr, default: None
The label to use for the stems in legends.
use_line_collectionbool, default: True
If True, store and plot the stem lines as a LineCollection instead of individual lines, which significantly increases performance. If False, defaults to the old behavior of using a list of Line2D objects. This parameter may be deprecated in the future.
dataindexable object, optional
If given, all parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception). Returns
StemContainer
The container may be treated like a tuple (markerline, stemlines, baseline) Notes See also The MATLAB function stem which inspired this method.
Examples using matplotlib.axes.Axes.stem
Legend Demo
3D stem
stem(x, y) | matplotlib._as_gen.matplotlib.axes.axes.stem |
matplotlib.axes.Axes.step Axes.step(x, y, *args, where='pre', data=None, **kwargs)[source]
Make a step plot. Call signatures: step(x, y, [fmt], *, data=None, where='pre', **kwargs)
step(x, y, [fmt], x2, y2, [fmt2], ..., *, where='pre', **kwargs)
This is just a thin wrapper around plot which changes some formatting options. Most of the concepts and parameters of plot can be used here as well. Note This method uses a standard plot with a step drawstyle: The x values are the reference positions and steps extend left/right/both directions depending on where. For the common case where you know the values and edges of the steps, use stairs instead. Parameters
xarray-like
1D sequence of x positions. It is assumed, but not checked, that it is uniformly increasing.
yarray-like
1D sequence of y levels.
fmtstr, optional
A format string, e.g. 'g' for a green line. See plot for a more detailed description. Note: While full format strings are accepted, it is recommended to only specify the color. Line styles are currently ignored (use the keyword argument linestyle instead). Markers are accepted and plotted on the given positions, however, this is a rarely needed feature for step plots.
where{'pre', 'post', 'mid'}, default: 'pre'
Define where the steps should be placed: 'pre': The y value is continued constantly to the left from every x position, i.e. the interval (x[i-1], x[i]] has the value y[i]. 'post': The y value is continued constantly to the right from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i]. 'mid': Steps occur half-way between the x positions.
dataindexable object, optional
An object with labelled data. If given, provide the label names to plot in x and y. **kwargs
Additional parameters are the same as those for plot. Returns
list of Line2D
Objects representing the plotted data.
Examples using matplotlib.axes.Axes.step
step(x, y) | matplotlib._as_gen.matplotlib.axes.axes.step |
matplotlib.axes.Axes.streamplot Axes.streamplot(x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=None, start_points=None, maxlength=4.0, integration_direction='both', *, data=None)[source]
Draw streamlines of a vector flow. Parameters
x, y1D/2D arrays
Evenly spaced strictly increasing arrays to make a grid. If 2D, all rows of x must be equal and all columns of y must be equal; i.e., they must be as if generated by np.meshgrid(x_1d, y_1d).
u, v2D arrays
x and y-velocities. The number of rows and columns must match the length of y and x, respectively.
densityfloat or (float, float)
Controls the closeness of streamlines. When density = 1, the domain is divided into a 30x30 grid. density linearly scales this grid. Each cell in the grid can have, at most, one traversing streamline. For different densities in each direction, use a tuple (density_x, density_y).
linewidthfloat or 2D array
The width of the stream lines. With a 2D array the line width can be varied across the grid. The array must have the same shape as u and v.
colorcolor or 2D array
The streamline color. If given an array, its values are converted to colors using cmap and norm. The array must have the same shape as u and v.
cmapColormap
Colormap used to plot streamlines and arrows. This is only used if color is an array.
normNormalize
Normalize object used to scale luminance data to 0, 1. If None, stretch (min, max) to (0, 1). This is only used if color is an array.
arrowsizefloat
Scaling factor for the arrow size.
arrowstylestr
Arrow style specification. See FancyArrowPatch.
minlengthfloat
Minimum length of streamline in axes coordinates.
start_pointsNx2 array
Coordinates of starting points for the streamlines in data coordinates (the same coordinates as the x and y arrays).
zorderint
The zorder of the stream lines and arrows. Artists with lower zorder values are drawn first.
maxlengthfloat
Maximum length of streamline in axes coordinates.
integration_direction{'forward', 'backward', 'both'}, default: 'both'
Integrate the streamline in forward, backward or both directions.
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): x, y, u, v, start_points Returns
StreamplotSet
Container object with attributes
lines: LineCollection of streamlines
arrows: PatchCollection containing FancyArrowPatch objects representing the arrows half-way along stream lines. This container will probably change in the future to allow changes to the colormap, alpha, etc. for both lines and arrows, but these changes should be backward compatible.
Examples using matplotlib.axes.Axes.streamplot
Streamplot
streamplot(X, Y, U, V) | matplotlib._as_gen.matplotlib.axes.axes.streamplot |
matplotlib.axes.Axes.table Axes.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, edges='closed', **kwargs)[source]
Add a table to an Axes. At least one of cellText or cellColours must be specified. These parameters must be 2D lists, in which the outer lists define the rows and the inner list define the column values per row. Each row must have the same number of elements. The table can optionally have row and column headers, which are configured using rowLabels, rowColours, rowLoc and colLabels, colColours, colLoc respectively. For finer grained control over tables, use the Table class and add it to the axes with Axes.add_table. Parameters
cellText2D list of str, optional
The texts to place into the table cells. Note: Line breaks in the strings are currently not accounted for and will result in the text exceeding the cell boundaries.
cellColours2D list of colors, optional
The background colors of the cells.
cellLoc{'left', 'center', 'right'}, default: 'right'
The alignment of the text within the cells.
colWidthslist of float, optional
The column widths in units of the axes. If not given, all columns will have a width of 1 / ncols.
rowLabelslist of str, optional
The text of the row header cells.
rowColourslist of colors, optional
The colors of the row header cells.
rowLoc{'left', 'center', 'right'}, default: 'left'
The text alignment of the row header cells.
colLabelslist of str, optional
The text of the column header cells.
colColourslist of colors, optional
The colors of the column header cells.
colLoc{'left', 'center', 'right'}, default: 'left'
The text alignment of the column header cells.
locstr, optional
The position of the cell with respect to ax. This must be one of the codes.
bboxBbox, optional
A bounding box to draw the table into. If this is not None, this overrides loc.
edgessubstring of 'BRTL' or {'open', 'closed', 'horizontal', 'vertical'}
The cell edges to be drawn with a line. See also visible_edges. Returns
Table
The created table. Other Parameters
**kwargs
Table properties.
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
clip_box Bbox
clip_on bool
clip_path Patch or (Path, Transform) or None
figure Figure
fontsize float
gid str
in_layout bool
label object
path_effects AbstractPathEffect
picker None or bool or float or callable
rasterized bool
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
transform Transform
url str
visible bool
zorder float | matplotlib._as_gen.matplotlib.axes.axes.table |
matplotlib.axes.Axes.text Axes.text(x, y, s, fontdict=None, **kwargs)[source]
Add text to the Axes. Add the text s to the Axes at location x, y in data coordinates. Parameters
x, yfloat
The position to place the text. By default, this is in data coordinates. The coordinate system can be changed using the transform parameter.
sstr
The text.
fontdictdict, default: None
A dictionary to override the default text properties. If fontdict is None, the defaults are determined by rcParams. Returns
Text
The created Text instance. Other Parameters
**kwargsText properties.
Other miscellaneous text parameters.
Property Description
agg_filter a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha scalar or None
animated bool
backgroundcolor color
bbox dict with properties for patches.FancyBboxPatch
clip_box unknown
clip_on unknown
clip_path unknown
color or c color
figure Figure
fontfamily or family {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}
fontproperties or font or font_properties font_manager.FontProperties or str or pathlib.Path
fontsize or size float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}
fontstretch or stretch {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}
fontstyle or style {'normal', 'italic', 'oblique'}
fontvariant or variant {'normal', 'small-caps'}
fontweight or weight {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}
gid str
horizontalalignment or ha {'center', 'right', 'left'}
in_layout bool
label object
linespacing float (multiple of font size)
math_fontfamily str
multialignment or ma {'left', 'right', 'center'}
parse_math bool
path_effects AbstractPathEffect
picker None or bool or float or callable
position (float, float)
rasterized bool
rotation float or {'vertical', 'horizontal'}
rotation_mode {None, 'default', 'anchor'}
sketch_params (scale: float, length: float, randomness: float)
snap bool or None
text object
transform Transform
transform_rotates_text bool
url str
usetex bool or None
verticalalignment or va {'center', 'top', 'bottom', 'baseline', 'center_baseline'}
visible bool
wrap bool
x float
y float
zorder float Examples 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 (e.g., to set a background color) by using the keyword bbox. bbox is a dictionary of Rectangle properties. For example: >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))
Examples using matplotlib.axes.Axes.text
Marker reference
BboxImage Demo
Creating annotated heatmaps
Boxplots
Bar of pie
Using accented text in matplotlib
Arrow Demo
Annotation arrow style reference
Labelling subplots
Mathtext
Math fontfamily
Multiline
Placing text boxes
Rendering math equations using TeX
Precise text layout
Text Rotation Relative To Line
Usetex Baseline Test
Text watermark
Text Commands
Drawing fancy boxes
Hatch style reference
Anatomy of a figure
Bachelor's degrees by gender
Integral as the area under a curve
Shaded & power normalized rendering
The double pendulum problem
MATPLOTLIB UNCHAINED
Data Browser
Pick Event Demo2
Cross hair cursor
Packed-bubble chart
Rasterization for vector graphics
Text annotations in 3D
Anscombe's quartet
Annotate Explain
Annotate Text Arrow
Connection styles for annotations
Custom box styles
Pgf Fonts
Pgf Texsystem
Simple Annotate01
Mouse Cursor
Basic Usage
The Lifecycle of a Plot
Artist tutorial
Arranging multiple Axes in a Figure
Path Tutorial
Transformations Tutorial
Specifying Colors
Choosing Colormaps in Matplotlib
Text in Matplotlib Plots
Text properties and layout | matplotlib._as_gen.matplotlib.axes.axes.text |
matplotlib.axes.Axes.tick_params Axes.tick_params(axis='both', **kwargs)[source]
Change the appearance of ticks, tick labels, and gridlines. Tick properties that are not explicitly set using the keyword arguments remain unchanged unless reset is True. Parameters
axis{'x', 'y', 'both'}, default: 'both'
The axis to which the parameters are applied.
which{'major', 'minor', 'both'}, default: 'major'
The group of ticks to which the parameters are applied.
resetbool, default: False
Whether to reset the ticks to defaults before updating them. Other Parameters
direction{'in', 'out', 'inout'}
Puts ticks inside the axes, outside the axes, or both.
lengthfloat
Tick length in points.
widthfloat
Tick width in points.
colorcolor
Tick color.
padfloat
Distance in points between tick and label.
labelsizefloat or str
Tick label font size in points or as a string (e.g., 'large').
labelcolorcolor
Tick label color.
colorscolor
Tick color and label color.
zorderfloat
Tick and label zorder.
bottom, top, left, rightbool
Whether to draw the respective ticks.
labelbottom, labeltop, labelleft, labelrightbool
Whether to draw the respective tick labels.
labelrotationfloat
Tick label rotation
grid_colorcolor
Gridline color.
grid_alphafloat
Transparency of gridlines: 0 (transparent) to 1 (opaque).
grid_linewidthfloat
Width of gridlines in points.
grid_linestylestr
Any valid Line2D line style spec. Examples ax.tick_params(direction='out', length=6, width=2, colors='r',
grid_color='r', grid_alpha=0.5)
This will make all major ticks be red, pointing out of the box, and with dimensions 6 points by 2 points. Tick labels will also be red. Gridlines will be red and translucent.
Examples using matplotlib.axes.Axes.tick_params
Scatter plot with histograms
Creating annotated heatmaps
Axes Props
Broken Axis
Plots with different scales
Polar Legend
Color Demo
Inset Locator Demo
Inset Locator Demo2
Make Room For Ylabel Using Axesgrid
Simple Axes Divider 3
Anatomy of a figure
Bachelor's degrees by gender
Anscombe's quartet
Multiple Yaxis With Spines
Major and minor ticks
Text in Matplotlib Plots | matplotlib._as_gen.matplotlib.axes.axes.tick_params |
matplotlib.axes.Axes.ticklabel_format Axes.ticklabel_format(*, axis='both', style='', scilimits=None, useOffset=None, useLocale=None, useMathText=None)[source]
Configure the ScalarFormatter used by default for linear axes. If a parameter is not set, the corresponding property of the formatter is left unchanged. Parameters
axis{'x', 'y', 'both'}, default: 'both'
The axis to configure. Only major ticks are affected.
style{'sci', 'scientific', 'plain'}
Whether to use scientific notation. The formatter default is to use scientific notation.
scilimitspair of ints (m, n)
Scientific notation is used only for numbers outside the range 10m to 10n (and only if the formatter is configured to use scientific notation at all). Use (0, 0) to include all numbers. Use (m, m) where m != 0 to fix the order of magnitude to 10m. The formatter default is rcParams["axes.formatter.limits"] (default: [-5, 6]).
useOffsetbool or float
If True, the offset is calculated as needed. If False, no offset is used. If a numeric value, it sets the offset. The formatter default is rcParams["axes.formatter.useoffset"] (default: True).
useLocalebool
Whether to format the number using the current locale or using the C (English) locale. This affects e.g. the decimal separator. The formatter default is rcParams["axes.formatter.use_locale"] (default: False).
useMathTextbool
Render the offset and scientific notation in mathtext. The formatter default is rcParams["axes.formatter.use_mathtext"] (default: False). Raises
AttributeError
If the current formatter is not a ScalarFormatter.
Examples using matplotlib.axes.Axes.ticklabel_format
The default tick formatter | matplotlib._as_gen.matplotlib.axes.axes.ticklabel_format |
matplotlib.axes.Axes.tricontour Axes.tricontour(*args, **kwargs)[source]
Draw contour lines on an unstructured triangular grid. The triangulation can be specified in one of two ways; either tricontour(triangulation, ...)
where triangulation is a Triangulation object, or tricontour(x, y, ...)
tricontour(x, y, triangles, ...)
tricontour(x, y, triangles=triangles, ...)
tricontour(x, y, mask=mask, ...)
tricontour(x, y, triangles, mask=mask, ...)
in which case a Triangulation object will be created. See that class' docstring for an explanation of these cases. The remaining arguments may be: tricontour(..., Z)
where Z is the array of values to contour, one per point in the triangulation. The level values are chosen automatically. tricontour(..., Z, levels)
contour up to levels+1 automatically chosen contour levels (levels intervals). tricontour(..., Z, levels)
draw contour lines at the values specified in sequence levels, which must be in increasing order. tricontour(Z, **kwargs)
Use keyword arguments to control colors, linewidth, origin, cmap ... see below for more details. Parameters
triangulationTriangulation, optional
The unstructured triangular grid. If specified, then x, y, triangles, and mask are not accepted.
x, yarray-like, optional
The coordinates of the values in Z.
triangles(ntri, 3) array-like of int, optional
For each triangle, the indices of the three points that make up the triangle, ordered in an anticlockwise manner. If not specified, the Delaunay triangulation is calculated.
mask(ntri,) array-like of bool, optional
Which triangles are masked out.
Z2D array-like
The height values over which the contour is drawn.
levelsint or array-like, optional
Determines the number and positions of the contour lines / regions. If an int n, use MaxNLocator, which tries to automatically choose no more than n+1 "nice" contour levels between vmin and vmax. If array-like, draw contour lines at the specified levels. The values must be in increasing order. Returns
TriContourSet
Other Parameters
colorscolor string or sequence of colors, optional
The colors of the levels, i.e., the contour lines. The sequence is cycled for the levels in ascending order. If the sequence is shorter than the number of levels, it's repeated. As a shortcut, single color strings may be used in place of one-element lists, i.e. 'red' instead of ['red'] to color all levels with the same color. This shortcut does only work for color strings, not for other ways of specifying colors. By default (value None), the colormap specified by cmap will be used.
alphafloat, default: 1
The alpha blending value, between 0 (transparent) and 1 (opaque).
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
A Colormap instance or registered colormap name. The colormap maps the level values to colors. If both colors and cmap are given, an error is raised.
normNormalize, optional
If a colormap is used, the Normalize instance scales the level values to the canonical colormap range [0, 1] for mapping to colors. If not given, the default linear scaling is used.
vmin, vmaxfloat, optional
If not None, either or both of these values will be supplied to the Normalize instance, overriding the default color scaling based on levels.
origin{None, 'upper', 'lower', 'image'}, default: None
Determines the orientation and exact position of Z by specifying the position of Z[0, 0]. This is only relevant, if X, Y are not given.
None: Z[0, 0] is at X=0, Y=0 in the lower left corner. 'lower': Z[0, 0] is at X=0.5, Y=0.5 in the lower left corner. 'upper': Z[0, 0] is at X=N+0.5, Y=0.5 in the upper left corner. 'image': Use the value from rcParams["image.origin"] (default: 'upper').
extent(x0, x1, y0, y1), optional
If origin is not None, then extent is interpreted as in 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 argument is ignored if X and Y are specified in the call to contour.
locatorticker.Locator subclass, optional
The locator is used to determine the contour levels if they are not given explicitly via levels. Defaults to MaxNLocator.
extend{'neither', 'both', 'min', 'max'}, default: 'neither'
Determines the tricontour-coloring of values that are outside the levels range. If 'neither', values outside the levels range are not colored. If 'min', 'max' or 'both', color the values below, above or below and above the levels range. Values below min(levels) and above max(levels) are mapped to the under/over values of the Colormap. Note that most colormaps do not have dedicated colors for these by default, so that the over and under values are the edge values of the colormap. You may want to set these values explicitly using Colormap.set_under and Colormap.set_over. Note An existing TriContourSet does not get notified if properties of its colormap are changed. Therefore, an explicit call to ContourSet.changed() is needed after modifying the colormap. The explicit call can be left out, if a colorbar is assigned to the TriContourSet because it internally calls ContourSet.changed().
xunits, yunitsregistered units, optional
Override axis units by specifying an instance of a matplotlib.units.ConversionInterface.
antialiasedbool, optional
Enable antialiasing, overriding the defaults. For filled contours, the default is True. For line contours, it is taken from rcParams["lines.antialiased"] (default: True).
linewidthsfloat or array-like, default: rcParams["contour.linewidth"] (default: None)
The line width of the contour lines. If a number, all levels will be plotted with this linewidth. If a sequence, the levels in ascending order will be plotted with the linewidths in the order specified. If None, this falls back to rcParams["lines.linewidth"] (default: 1.5).
linestyles{None, 'solid', 'dashed', 'dashdot', 'dotted'}, optional
If linestyles is None, the default is 'solid' unless the lines are monochrome. In that case, negative contours will take their linestyle from rcParams["contour.negative_linestyle"] (default: 'dashed') setting. linestyles can also be an iterable of the above strings specifying a set of linestyles to be used. If this iterable is shorter than the number of contour levels it will be repeated as necessary.
Examples using matplotlib.axes.Axes.tricontour
Contour plot of irregularly spaced data
Tricontour Demo
Tricontour Smooth Delaunay
Tricontour Smooth User
Trigradient Demo
Triangular 3D contour plot
tricontour(x, y, z) | matplotlib._as_gen.matplotlib.axes.axes.tricontour |
matplotlib.axes.Axes.tricontourf Axes.tricontourf(*args, **kwargs)[source]
Draw contour regions on an unstructured triangular grid. The triangulation can be specified in one of two ways; either tricontourf(triangulation, ...)
where triangulation is a Triangulation object, or tricontourf(x, y, ...)
tricontourf(x, y, triangles, ...)
tricontourf(x, y, triangles=triangles, ...)
tricontourf(x, y, mask=mask, ...)
tricontourf(x, y, triangles, mask=mask, ...)
in which case a Triangulation object will be created. See that class' docstring for an explanation of these cases. The remaining arguments may be: tricontourf(..., Z)
where Z is the array of values to contour, one per point in the triangulation. The level values are chosen automatically. tricontourf(..., Z, levels)
contour up to levels+1 automatically chosen contour levels (levels intervals). tricontourf(..., Z, levels)
draw contour regions at the values specified in sequence levels, which must be in increasing order. tricontourf(Z, **kwargs)
Use keyword arguments to control colors, linewidth, origin, cmap ... see below for more details. Parameters
triangulationTriangulation, optional
The unstructured triangular grid. If specified, then x, y, triangles, and mask are not accepted.
x, yarray-like, optional
The coordinates of the values in Z.
triangles(ntri, 3) array-like of int, optional
For each triangle, the indices of the three points that make up the triangle, ordered in an anticlockwise manner. If not specified, the Delaunay triangulation is calculated.
mask(ntri,) array-like of bool, optional
Which triangles are masked out.
Z2D array-like
The height values over which the contour is drawn.
levelsint or array-like, optional
Determines the number and positions of the contour lines / regions. If an int n, use MaxNLocator, which tries to automatically choose no more than n+1 "nice" contour levels between vmin and vmax. If array-like, draw contour lines at the specified levels. The values must be in increasing order. Returns
TriContourSet
Other Parameters
colorscolor string or sequence of colors, optional
The colors of the levels, i.e., the contour regions. The sequence is cycled for the levels in ascending order. If the sequence is shorter than the number of levels, it's repeated. As a shortcut, single color strings may be used in place of one-element lists, i.e. 'red' instead of ['red'] to color all levels with the same color. This shortcut does only work for color strings, not for other ways of specifying colors. By default (value None), the colormap specified by cmap will be used.
alphafloat, default: 1
The alpha blending value, between 0 (transparent) and 1 (opaque).
cmapstr or Colormap, default: rcParams["image.cmap"] (default: 'viridis')
A Colormap instance or registered colormap name. The colormap maps the level values to colors. If both colors and cmap are given, an error is raised.
normNormalize, optional
If a colormap is used, the Normalize instance scales the level values to the canonical colormap range [0, 1] for mapping to colors. If not given, the default linear scaling is used.
vmin, vmaxfloat, optional
If not None, either or both of these values will be supplied to the Normalize instance, overriding the default color scaling based on levels.
origin{None, 'upper', 'lower', 'image'}, default: None
Determines the orientation and exact position of Z by specifying the position of Z[0, 0]. This is only relevant, if X, Y are not given.
None: Z[0, 0] is at X=0, Y=0 in the lower left corner. 'lower': Z[0, 0] is at X=0.5, Y=0.5 in the lower left corner. 'upper': Z[0, 0] is at X=N+0.5, Y=0.5 in the upper left corner. 'image': Use the value from rcParams["image.origin"] (default: 'upper').
extent(x0, x1, y0, y1), optional
If origin is not None, then extent is interpreted as in 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 argument is ignored if X and Y are specified in the call to contour.
locatorticker.Locator subclass, optional
The locator is used to determine the contour levels if they are not given explicitly via levels. Defaults to MaxNLocator.
extend{'neither', 'both', 'min', 'max'}, default: 'neither'
Determines the tricontourf-coloring of values that are outside the levels range. If 'neither', values outside the levels range are not colored. If 'min', 'max' or 'both', color the values below, above or below and above the levels range. Values below min(levels) and above max(levels) are mapped to the under/over values of the Colormap. Note that most colormaps do not have dedicated colors for these by default, so that the over and under values are the edge values of the colormap. You may want to set these values explicitly using Colormap.set_under and Colormap.set_over. Note An existing TriContourSet does not get notified if properties of its colormap are changed. Therefore, an explicit call to ContourSet.changed() is needed after modifying the colormap. The explicit call can be left out, if a colorbar is assigned to the TriContourSet because it internally calls ContourSet.changed().
xunits, yunitsregistered units, optional
Override axis units by specifying an instance of a matplotlib.units.ConversionInterface.
antialiasedbool, optional
Enable antialiasing, overriding the defaults. For filled contours, the default is True. For line contours, it is taken from rcParams["lines.antialiased"] (default: True).
hatcheslist[str], optional
A list of cross hatch patterns to use on the filled areas. If None, no hatching will be added to the contour. Hatching is supported in the PostScript, PDF, SVG and Agg backends only. Notes tricontourf fills intervals that are closed at the top; that is, for boundaries z1 and z2, the filled region is: z1 < Z <= z2
except for the lowest interval, which is closed on both sides (i.e. it includes the lowest value).
Examples using matplotlib.axes.Axes.tricontourf
Contour plot of irregularly spaced data
Tricontour Demo
Tricontour Smooth User
Triangular 3D filled contour plot
tricontourf(x, y, z) | matplotlib._as_gen.matplotlib.axes.axes.tricontourf |
matplotlib.axes.Axes.tripcolor Axes.tripcolor(*args, alpha=1.0, norm=None, cmap=None, vmin=None, vmax=None, shading='flat', facecolors=None, **kwargs)[source]
Create a pseudocolor plot of an unstructured triangular grid. The triangulation can be specified in one of two ways; either: tripcolor(triangulation, ...)
where triangulation is a Triangulation object, or tripcolor(x, y, ...)
tripcolor(x, y, triangles, ...)
tripcolor(x, y, triangles=triangles, ...)
tripcolor(x, y, mask=mask, ...)
tripcolor(x, y, triangles, mask=mask, ...)
in which case a Triangulation object will be created. See Triangulation for a explanation of these possibilities. The next argument must be C, the array of color values, either one per point in the triangulation if color values are defined at points, or one per triangle in the triangulation if color values are defined at triangles. If there are the same number of points and triangles in the triangulation it is assumed that color values are defined at points; to force the use of color values at triangles use the kwarg facecolors=C instead of just C. shading may be 'flat' (the default) or 'gouraud'. If shading is 'flat' and C values are defined at points, the color values used for each triangle are from the mean C of the triangle's three points. If shading is 'gouraud' then color values must be defined at points. The remaining kwargs are the same as for pcolor.
Examples using matplotlib.axes.Axes.tripcolor
Tripcolor Demo
tripcolor(x, y, z) | matplotlib._as_gen.matplotlib.axes.axes.tripcolor |
matplotlib.axes.Axes.triplot Axes.triplot(*args, **kwargs)[source]
Draw a unstructured triangular grid as lines and/or markers. The triangulation to plot can be specified in one of two ways; either: triplot(triangulation, ...)
where triangulation is a Triangulation object, or triplot(x, y, ...)
triplot(x, y, triangles, ...)
triplot(x, y, triangles=triangles, ...)
triplot(x, y, mask=mask, ...)
triplot(x, y, triangles, mask=mask, ...)
in which case a Triangulation object will be created. See Triangulation for a explanation of these possibilities. The remaining args and kwargs are the same as for plot. Returns
linesLine2D
The drawn triangles edges.
markersLine2D
The drawn marker nodes.
Examples using matplotlib.axes.Axes.triplot
Tricontour Smooth Delaunay
Tricontour Smooth User
Trigradient Demo
Triplot Demo
Trifinder Event Demo
triplot(x, y) | matplotlib._as_gen.matplotlib.axes.axes.triplot |
matplotlib.axes.Axes.twinx Axes.twinx()[source]
Create a twin Axes sharing the xaxis. Create a new Axes with an invisible x-axis and an independent y-axis positioned opposite to the original one (i.e. at right). The x-axis autoscale setting will be inherited from the original Axes. To ensure that the tick marks of both y-axes align, see LinearLocator. Returns
Axes
The newly created Axes instance Notes For those who are 'picking' artists while using twinx, pick events are only called for the artists in the top-most Axes.
Examples using matplotlib.axes.Axes.twinx
Axes box aspect
Plots with different scales
Parasite Simple
Parasite axis demo
Multiple Yaxis With Spines
Basic Usage | matplotlib._as_gen.matplotlib.axes.axes.twinx |
matplotlib.axes.Axes.twiny Axes.twiny()[source]
Create a twin Axes sharing the yaxis. Create a new Axes with an invisible y-axis and an independent x-axis positioned opposite to the original one (i.e. at top). The y-axis autoscale setting will be inherited from the original Axes. To ensure that the tick marks of both x-axes align, see LinearLocator. Returns
Axes
The newly created Axes instance Notes For those who are 'picking' artists while using twiny, pick events are only called for the artists in the top-most Axes. | matplotlib._as_gen.matplotlib.axes.axes.twiny |
matplotlib.axes.Axes.update_datalim Axes.update_datalim(xys, updatex=True, updatey=True)[source]
Extend the dataLim Bbox to include the given points. If no data is set currently, the Bbox will ignore its limits and set the bound to be the bounds of the xydata (xys). Otherwise, it will compute the bounds of the union of its current data and the data in xys. Parameters
xys2D array-like
The points to include in the data limits Bbox. This can be either a list of (x, y) tuples or a Nx2 array.
updatex, updateybool, default: True
Whether to update the x/y limits. | matplotlib._as_gen.matplotlib.axes.axes.update_datalim |
matplotlib.axes.Axes.use_sticky_edges propertyAxes.use_sticky_edges
When autoscaling, whether to obey all Artist.sticky_edges. Default is True. Setting this to False ensures that the specified margins will be applied, even if the plot includes an image, for example, which would otherwise force a view limit to coincide with its data limit. The changing this property does not change the plot until autoscale or autoscale_view is called. | matplotlib._as_gen.matplotlib.axes.axes.use_sticky_edges |
matplotlib.axes.Axes.violin Axes.violin(vpstats, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False)[source]
Drawing function for violin plots. Draw a violin plot for each column of vpstats. Each filled area extends to represent the entire data range, with optional lines at the mean, the median, the minimum, the maximum, and the quantiles values. Parameters
vpstatslist of dicts
A list of dictionaries containing stats for each violin plot. Required keys are:
coords: A list of scalars containing the coordinates that the violin's kernel density estimate were evaluated at.
vals: A list of scalars containing the values of the kernel density estimate at each of the coordinates given in coords.
mean: The mean value for this violin's dataset.
median: The median value for this violin's dataset.
min: The minimum value for this violin's dataset.
max: The maximum value for this violin's dataset. Optional keys are:
quantiles: A list of scalars containing the quantile values for this violin's dataset.
positionsarray-like, default: [1, 2, ..., n]
The positions of the violins. The ticks and limits are automatically set to match the positions.
vertbool, default: True.
If true, plots the violins vertically. Otherwise, plots the violins horizontally.
widthsarray-like, default: 0.5
Either a scalar or a vector that sets the maximal width of each violin. The default is 0.5, which uses about half of the available horizontal space.
showmeansbool, default: False
If true, will toggle rendering of the means.
showextremabool, default: True
If true, will toggle rendering of the extrema.
showmediansbool, default: False
If true, will toggle rendering of the medians. Returns
dict
A dictionary mapping each component of the violinplot to a list of the corresponding collection instances created. The dictionary has the following keys:
bodies: A list of the PolyCollection instances containing the filled area of each violin.
cmeans: A LineCollection instance that marks the mean values of each of the violin's distribution.
cmins: A LineCollection instance that marks the bottom of each violin's distribution.
cmaxes: A LineCollection instance that marks the top of each violin's distribution.
cbars: A LineCollection instance that marks the centers of each violin's distribution.
cmedians: A LineCollection instance that marks the median values of each of the violin's distribution.
cquantiles: A LineCollection instance created to identify the quantiles values of each of the violin's distribution. | matplotlib._as_gen.matplotlib.axes.axes.violin |
matplotlib.axes.Axes.violinplot Axes.violinplot(dataset, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False, quantiles=None, points=100, bw_method=None, *, data=None)[source]
Make a violin plot. Make a violin plot for each column of dataset or each vector in sequence dataset. Each filled area extends to represent the entire data range, with optional lines at the mean, the median, the minimum, the maximum, and user-specified quantiles. Parameters
datasetArray or a sequence of vectors.
The input data.
positionsarray-like, default: [1, 2, ..., n]
The positions of the violins. The ticks and limits are automatically set to match the positions.
vertbool, default: True.
If true, creates a vertical violin plot. Otherwise, creates a horizontal violin plot.
widthsarray-like, default: 0.5
Either a scalar or a vector that sets the maximal width of each violin. The default is 0.5, which uses about half of the available horizontal space.
showmeansbool, default: False
If True, will toggle rendering of the means.
showextremabool, default: True
If True, will toggle rendering of the extrema.
showmediansbool, default: False
If True, will toggle rendering of the medians.
quantilesarray-like, default: None
If not None, set a list of floats in interval [0, 1] for each violin, which stands for the quantiles that will be rendered for that violin.
pointsint, default: 100
Defines the number of points to evaluate each of the gaussian kernel density estimations at.
bw_methodstr, scalar or callable, optional
The method used to calculate the estimator bandwidth. This can be 'scott', 'silverman', a scalar constant or a callable. If a scalar, this will be used directly as kde.factor. If a callable, it should take a GaussianKDE instance as its only parameter and return a scalar. If None (default), 'scott' is used.
dataindexable object, optional
If given, the following parameters also accept a string s, which is interpreted as data[s] (unless this raises an exception): dataset Returns
dict
A dictionary mapping each component of the violinplot to a list of the corresponding collection instances created. The dictionary has the following keys:
bodies: A list of the PolyCollection instances containing the filled area of each violin.
cmeans: A LineCollection instance that marks the mean values of each of the violin's distribution.
cmins: A LineCollection instance that marks the bottom of each violin's distribution.
cmaxes: A LineCollection instance that marks the top of each violin's distribution.
cbars: A LineCollection instance that marks the centers of each violin's distribution.
cmedians: A LineCollection instance that marks the median values of each of the violin's distribution.
cquantiles: A LineCollection instance created to identify the quantile values of each of the violin's distribution.
Examples using matplotlib.axes.Axes.violinplot
Violin plot customization
violinplot(D) | matplotlib._as_gen.matplotlib.axes.axes.violinplot |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.