smpl.plot.FigureBase¶

class smpl.plot.FigureBase(**kwargs)[source]¶

Bases: Artist

Base class for .Figure and .SubFigure containing the methods that add artists to the figure or subfigure, create Axes, etc.

__init__(**kwargs)[source]¶

Methods

`__init__`(**kwargs)
`add_artist`(artist[, clip])	Add an .Artist to the figure.
`add_axes`(args, *kwargs)	Add an Axes to the figure.
`add_callback`(func)	Add a callback function that will be called whenever one of the .Artist's properties changes.
`add_gridspec`([nrows, ncols])	Return a .GridSpec that has this figure as a parent.
`add_subfigure`(subplotspec, **kwargs)	Add a .SubFigure to the figure as part of a subplot arrangement.
`add_subplot`(args, *kwargs)	Add an ~.axes.Axes to the figure as part of a subplot arrangement.
`align_labels`([axs])	Align the xlabels and ylabels of subplots with the same subplots row or column (respectively) if label alignment is being done automatically (i.e.
`align_xlabels`([axs])	Align the xlabels of subplots in the same subplot column if label alignment is being done automatically (i.e.
`align_ylabels`([axs])	Align the ylabels of subplots in the same subplot column if label alignment is being done automatically (i.e.
`autofmt_xdate`([bottom, rotation, ha, which])	Date ticklabels often overlap, so it is useful to rotate them and right align them.
`clear`([keep_observers])	Clear the figure.
`clf`([keep_observers])	[Discouraged] Alias for the clear() method.
`colorbar`(mappable[, cax, ax, use_gridspec])	Add a colorbar to a plot.
`contains`(mouseevent)	Test whether the mouse event occurred on the figure.
`convert_xunits`(x)	Convert x using the unit type of the xaxis.
`convert_yunits`(y)	Convert y using the unit type of the yaxis.
`delaxes`(ax)	Remove the ~.axes.Axes ax from the figure; update the current Axes.
`draw`(renderer)	Draw the Artist (and its children) using the given renderer.
`findobj`([match, include_self])	Find artist objects.
`format_cursor_data`(data)	Return a string representation of data.
`gca`()	Get the current Axes.
`get_agg_filter`()	Return filter function to be used for agg filter.
`get_alpha`()	Return the alpha value used for blending - not supported on all backends.
`get_animated`()	Return whether the artist is animated.
`get_children`()	Get a list of artists contained in the figure.
`get_clip_box`()	Return the clipbox.
`get_clip_on`()	Return whether the artist uses clipping.
`get_clip_path`()	Return the clip path.
`get_cursor_data`(event)	Return the cursor data for a given event.
`get_default_bbox_extra_artists`()
`get_edgecolor`()	Get the edge color of the Figure rectangle.
`get_facecolor`()	Get the face color of the Figure rectangle.
`get_figure`()	Return the .Figure instance the artist belongs to.
`get_frameon`()	Return the figure's background patch visibility, i.e. whether the figure background will be drawn.
`get_gid`()	Return the group id.
`get_in_layout`()	Return boolean flag, `True` if artist is included in layout calculations.
`get_label`()	Return the label used for this artist in the legend.
`get_linewidth`()	Get the line width of the Figure rectangle.
`get_mouseover`()	Return whether this artist is queried for custom context information when the mouse cursor moves over it.
`get_path_effects`()
`get_picker`()	Return the picking behavior of the artist.
`get_rasterized`()	Return whether the artist is to be rasterized.
`get_sketch_params`()	Return the sketch parameters for the artist.
`get_snap`()	Return the snap setting.
`get_tightbbox`([renderer, bbox_extra_artists])	Return a (tight) bounding box of the figure in inches.
`get_transform`()	Return the .Transform instance used by this artist.
`get_transformed_clip_path_and_affine`()	Return the clip path with the non-affine part of its transformation applied, and the remaining affine part of its transformation.
`get_url`()	Return the url.
`get_visible`()	Return the visibility.
`get_window_extent`([renderer])	Get the artist's bounding box in display space.
`get_zorder`()	Return the artist's zorder.
`have_units`()	Return whether units are set on any axis.
`is_transform_set`()	Return whether the Artist has an explicitly set transform.
`legend`(args, *kwargs)	Place a legend on the figure.
`pchanged`()	Call all of the registered callbacks.
`pick`(mouseevent)	Process a pick event.
`pickable`()	Return whether the artist is pickable.
`properties`()	Return a dictionary of all the properties of the artist.
`remove`()	Remove the artist from the figure if possible.
`remove_callback`(oid)	Remove a callback based on its observer id.
`sca`(a)	Set the current Axes to be a and return a.
`set`(*[, agg_filter, alpha, animated, ...])	Set multiple properties at once.
`set_agg_filter`(filter_func)	Set the agg filter.
`set_alpha`(alpha)	Set the alpha value used for blending - not supported on all backends.
`set_animated`(b)	Set whether the artist is intended to be used in an animation.
`set_clip_box`(clipbox)	Set the artist's clip .Bbox.
`set_clip_on`(b)	Set whether the artist uses clipping.
`set_clip_path`(path[, transform])	Set the artist's clip path.
`set_edgecolor`(color)	Set the edge color of the Figure rectangle.
`set_facecolor`(color)	Set the face color of the Figure rectangle.
`set_figure`(fig)	Set the .Figure instance the artist belongs to.
`set_frameon`(b)	Set the figure's background patch visibility, i.e. whether the figure background will be drawn.
`set_gid`(gid)	Set the (group) id for the artist.
`set_in_layout`(in_layout)	Set if artist is to be included in layout calculations, E.g.
`set_label`(s)	Set a label that will be displayed in the legend.
`set_linewidth`(linewidth)	Set the line width of the Figure rectangle.
`set_mouseover`(mouseover)	Set whether this artist is queried for custom context information when the mouse cursor moves over it.
`set_path_effects`(path_effects)	Set the path effects.
`set_picker`(picker)	Define the picking behavior of the artist.
`set_rasterized`(rasterized)	Force rasterized (bitmap) drawing for vector graphics output.
`set_sketch_params`([scale, length, randomness])	Set the sketch parameters.
`set_snap`(snap)	Set the snapping behavior.
`set_transform`(t)	Set the artist transform.
`set_url`(url)	Set the url for the artist.
`set_visible`(b)	Set the artist's visibility.
`set_zorder`(level)	Set the zorder for the artist.
`subfigures`([nrows, ncols, squeeze, wspace, ...])	Add a subfigure to this figure or subfigure.
`subplot_mosaic`(mosaic, *[, sharex, sharey, ...])	Build a layout of Axes based on ASCII art or nested lists.
`subplots`([nrows, ncols, sharex, sharey, ...])	Add a set of subplots to this figure.
`subplots_adjust`([left, bottom, right, top, ...])	Adjust the subplot layout parameters.
`suptitle`(t, **kwargs)	Add a centered suptitle to the figure.
`supxlabel`(t, **kwargs)	Add a centered supxlabel to the figure.
`supylabel`(t, **kwargs)	Add a centered supylabel to the figure.
`text`(x, y, s[, fontdict])	Add text to figure.
`update`(props)	Update this artist's properties from the dict props.
`update_from`(other)	Copy properties from other to self.

Attributes

`axes`	The ~.axes.Axes instance the artist resides in, or None.
`frameon`	Return the figure's background patch visibility, i.e. whether the figure background will be drawn.
`mouseover`	Return whether this artist is queried for custom context information when the mouse cursor moves over it.
`stale`	Whether the artist is 'stale' and needs to be re-drawn for the output to match the internal state of the artist.
`sticky_edges`	`x` and `y` sticky edge lists for autoscaling.
`zorder`

add_artist(artist, clip=False)[source]¶

Add an .Artist to the figure.

Usually artists are added to Axes objects using .Axes.add_artist; this method can be used in the rare cases where one needs to add artists directly to the figure instead.

Parameters¶

artist~matplotlib.artist.Artist: The artist to add to the figure. If the added artist has no transform previously set, its transform will be set to figure.transSubfigure.
clipbool, default: False: Whether the added artist should be clipped by the figure patch.

Returns¶

~matplotlib.artist.Artist: The added artist.

add_axes(*args, **kwargs)[source]¶

Add an Axes to the figure.

Call signatures:

add_axes(rect, projection=None, polar=False, **kwargs)
add_axes(ax)

Parameters¶

recttuple (left, bottom, width, height): The dimensions (left, bottom, width, height) of the new Axes. All quantities are in fractions of figure width and height.
projection{None, ‘aitoff’, ‘hammer’, ‘lambert’, ‘mollweide’, ‘polar’, ‘rectilinear’, str}, optional: The projection type of the ~.axes.Axes. str is the name of a custom projection, see ~matplotlib.projections. The default None results in a ‘rectilinear’ projection.
polarbool, default: False: If True, equivalent to projection=’polar’.
axes_classsubclass type of ~.axes.Axes, optional: The .axes.Axes subclass that is instantiated. This parameter is incompatible with projection and polar. See axisartist_users-guide-index for examples.
sharex, sharey~.axes.Axes, optional: Share the x or y ~matplotlib.axis with sharex and/or sharey. The axis will have the same limits, ticks, and scale as the axis of the shared axes.
labelstr: A label for the returned Axes.

Returns¶

~.axes.Axes, or a subclass of ~.axes.Axes: The returned axes class depends on the projection used. It is ~.axes.Axes if rectilinear projection is used and .projections.polar.PolarAxes if polar projection is used.

Other Parameters¶

**kwargs

This method also takes the keyword arguments for the returned Axes class. The keyword arguments for the rectilinear Axes class ~.axes.Axes can be found in the following table but there might also be other keyword arguments if another projection is used, see the actual Axes class.

Properties: 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 and two offsets from the bottom left corner of the image 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: unknown autoscaley_on: unknown 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 mouseover: bool navigate: bool navigate_mode: unknown path_effects: .AbstractPathEffect picker: None or bool or float or callable position: [left, bottom, width, height] or ~matplotlib.transforms.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: unknown xticklabels: unknown xticks: unknown ybound: unknown ylabel: str ylim: (bottom: float, top: float) ymargin: float greater than -0.5 yscale: unknown yticklabels: unknown yticks: unknown zorder: float

Notes¶

In rare circumstances, .add_axes may be called with a single argument, an Axes instance already created in the present figure but not in the figure’s list of Axes.

Examples¶

Some simple examples:

rect = l, b, w, h
fig = plt.figure()
fig.add_axes(rect)
fig.add_axes(rect, frameon=False, facecolor='g')
fig.add_axes(rect, polar=True)
ax = fig.add_axes(rect, projection='polar')
fig.delaxes(ax)
fig.add_axes(ax)

add_callback(func)¶

Add a callback function that will be called whenever one of the .Artist’s properties changes.

Parameters¶

funccallable

The callback function. It must have the signature:

def func(artist: Artist) -> Any

where artist is the calling .Artist. Return values may exist but are ignored.

Returns¶

int: The observer id associated with the callback. This id can be used for removing the callback with .remove_callback later.

Parameters¶

nrowsint, default: 1: Number of rows in grid.
ncolsint, default: 1: Number or columns in grid.

Returns¶

.GridSpec

Other Parameters¶

**kwargs: Keyword arguments are passed to .GridSpec.

Examples¶

Adding a subplot that spans two rows:

fig = plt.figure()
gs = fig.add_gridspec(2, 2)
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[1, 0])
# spans two rows:
ax3 = fig.add_subplot(gs[:, 1])

add_subfigure(subplotspec, **kwargs)[source]¶

Add a .SubFigure to the figure as part of a subplot arrangement.

Parameters¶

subplotspec.gridspec.SubplotSpec: Defines the region in a parent gridspec where the subfigure will be placed.

Returns¶

.SubFigure

Other Parameters¶

**kwargs: Are passed to the .SubFigure object.

Parameters¶

args : int, (int, int, *index), or .SubplotSpec, default: (1, 1, 1)

The position of the subplot described by one of

Three integers (nrows, ncols, index). The subplot will take the index position on a grid with nrows rows and ncols columns. index starts at 1 in the upper left corner and increases to the right. index can also be a two-tuple specifying the (first, last) indices (1-based, and including last) of the subplot, e.g., fig.add_subplot(3, 1, (1, 2)) makes a subplot that spans the upper 2/3 of the figure.
A 3-digit integer. The digits are interpreted as if given separately as three single-digit integers, i.e. fig.add_subplot(235) is the same as fig.add_subplot(2, 3, 5). Note that this can only be used if there are no more than 9 subplots.
A .SubplotSpec.

In rare circumstances, .add_subplot may be called with a single argument, a subplot Axes instance already created in the present figure but not in the figure’s list of Axes.

projection{None, ‘aitoff’, ‘hammer’, ‘lambert’, ‘mollweide’, ‘polar’, ‘rectilinear’, str}, optional

The projection type of the subplot (~.axes.Axes). str is the name of a custom projection, see ~matplotlib.projections. The default None results in a ‘rectilinear’ projection.

polarbool, default: False

If True, equivalent to projection=’polar’.

axes_classsubclass type of ~.axes.Axes, optional

The .axes.Axes subclass that is instantiated. This parameter is incompatible with projection and polar. See axisartist_users-guide-index for examples.

sharex, sharey~.axes.Axes, optional

Share the x or y ~matplotlib.axis with sharex and/or sharey. The axis will have the same limits, ticks, and scale as the axis of the shared axes.

labelstr

A label for the returned Axes.

Returns¶

.axes.SubplotBase, or another subclass of ~.axes.Axes

The Axes of the subplot. The returned Axes base class depends on the projection used. It is ~.axes.Axes if rectilinear projection is used and .projections.polar.PolarAxes if polar projection is used. The returned Axes is then a subplot subclass of the base class.

Other Parameters¶

**kwargs

This method also takes the keyword arguments for the returned Axes base class; except for the figure argument. The keyword arguments for the rectilinear base class ~.axes.Axes can be found in the following table but there might also be other keyword arguments if another projection is used.

Properties: 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 and two offsets from the bottom left corner of the image 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: unknown autoscaley_on: unknown 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 mouseover: bool navigate: bool navigate_mode: unknown path_effects: .AbstractPathEffect picker: None or bool or float or callable position: [left, bottom, width, height] or ~matplotlib.transforms.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: unknown xticklabels: unknown xticks: unknown ybound: unknown ylabel: str ylim: (bottom: float, top: float) ymargin: float greater than -0.5 yscale: unknown yticklabels: unknown yticks: unknown zorder: float

Examples¶

fig = plt.figure()

fig.add_subplot(231)
ax1 = fig.add_subplot(2, 3, 1)  # equivalent but more general

fig.add_subplot(232, frameon=False)  # subplot with no frame
fig.add_subplot(233, projection='polar')  # polar subplot
fig.add_subplot(234, sharex=ax1)  # subplot sharing x-axis with ax1
fig.add_subplot(235, facecolor="red")  # red subplot

ax1.remove()  # delete ax1 from the figure
fig.add_subplot(ax1)  # add ax1 back to the figure

align_labels(axs=None)[source]¶

Align the xlabels and ylabels of subplots with the same subplots row or column (respectively) if label alignment is being done automatically (i.e. the label position is not manually set).

Alignment persists for draw events after this is called.

Parameters¶

axslist of ~matplotlib.axes.Axes: Optional list (or ndarray) of ~matplotlib.axes.Axes to align the labels. Default is to align all Axes on the figure.

Parameters¶

axslist of ~matplotlib.axes.Axes: Optional list of (or ndarray) ~matplotlib.axes.Axes to align the xlabels. Default is to align all Axes on the figure.

Notes¶

This assumes that axs are from the same .GridSpec, so that their .SubplotSpec positions correspond to figure positions.

Examples¶

Example with rotated xtick labels:

fig, axs = plt.subplots(1, 2)
for tick in axs[0].get_xticklabels():
    tick.set_rotation(55)
axs[0].set_xlabel('XLabel 0')
axs[1].set_xlabel('XLabel 1')
fig.align_xlabels()

align_ylabels(axs=None)[source]¶

Align the ylabels of subplots in the same subplot column if label alignment is being done automatically (i.e. the label position is not manually set).

Alignment persists for draw events after this is called.

If a label is on the left, it is aligned with labels on Axes that also have their label on the left and that have the same left-most subplot column. If the label is on the right, it is aligned with labels on Axes with the same right-most column.

Parameters¶

axslist of ~matplotlib.axes.Axes: Optional list (or ndarray) of ~matplotlib.axes.Axes to align the ylabels. Default is to align all Axes on the figure.

Notes¶

This assumes that axs are from the same .GridSpec, so that their .SubplotSpec positions correspond to figure positions.

Examples¶

Example with large yticks labels:

fig, axs = plt.subplots(2, 1)
axs[0].plot(np.arange(0, 1000, 50))
axs[0].set_ylabel('YLabel 0')
axs[1].set_ylabel('YLabel 1')
fig.align_ylabels()

autofmt_xdate(bottom=0.2, rotation=30, ha='right', which='major')[source]¶

Date ticklabels often overlap, so it is useful to rotate them and right align them. Also, a common use case is a number of subplots with shared x-axis where the x-axis is date data. The ticklabels are often long, and it helps to rotate them on the bottom subplot and turn them off on other subplots, as well as turn off xlabels.

Parameters¶

bottomfloat, default: 0.2: The bottom of the subplots for subplots_adjust.
rotationfloat, default: 30 degrees: The rotation angle of the xtick labels in degrees.
ha{‘left’, ‘center’, ‘right’}, default: ‘right’: The horizontal alignment of the xticklabels.
which{‘major’, ‘minor’, ‘both’}, default: ‘major’: Selects which ticklabels to rotate.

property axes¶: The ~.axes.Axes instance the artist resides in, or None.

clear(keep_observers=False)[source]¶

Clear the figure.

Parameters¶

keep_observers: bool, default: False: Set keep_observers to True if, for example, a gui widget is tracking the Axes in the figure.

clf(keep_observers=False)[source]¶

[Discouraged] Alias for the clear() method.

Discouraged

The use of clf() is discouraged. Use clear() instead.

Parameters¶

keep_observers: bool, default: False: Set keep_observers to True if, for example, a gui widget is tracking the Axes in the figure.

colorbar(mappable, cax=None, ax=None, use_gridspec=True, **kwargs)[source]¶

Add a colorbar to a plot.

Parameters¶

mappable

The matplotlib.cm.ScalarMappable (i.e., .AxesImage, .ContourSet, etc.) described by this colorbar. This argument is mandatory for the .Figure.colorbar method but optional for the .pyplot.colorbar function, which sets the default to the current image.

Note that one can create a .ScalarMappable “on-the-fly” to generate colorbars not attached to a previously drawn artist, e.g.

fig.colorbar(cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax)

cax~matplotlib.axes.Axes, optional

Axes into which the colorbar will be drawn.

ax~.axes.Axes or list or numpy.ndarray of Axes, optional

One or more parent axes from which space for a new colorbar axes will be stolen, if cax is None. This has no effect if cax is set.

use_gridspecbool, optional

If cax is None, a new cax is created as an instance of Axes. If ax is an instance of Subplot and use_gridspec is True, cax is created as an instance of Subplot using the gridspec module.

Returns¶

colorbar : ~matplotlib.colorbar.Colorbar

Other Parameters¶

locationNone or {‘left’, ‘right’, ‘top’, ‘bottom’}

The location, relative to the parent axes, where the colorbar axes is created. It also determines the orientation of the colorbar (colorbars on the left and right are vertical, colorbars at the top and bottom are horizontal). If None, the location will come from the orientation if it is set (vertical colorbars on the right, horizontal ones at the bottom), or default to ‘right’ if orientation is unset.

orientationNone or {‘vertical’, ‘horizontal’}

The orientation of the colorbar. It is preferable to set the location of the colorbar, as that also determines the orientation; passing incompatible values for location and orientation raises an exception.

fractionfloat, default: 0.15

Fraction of original axes to use for colorbar.

shrinkfloat, default: 1.0

Fraction by which to multiply the size of the colorbar.

aspectfloat, default: 20

Ratio of long to short dimensions.

padfloat, default: 0.05 if vertical, 0.15 if horizontal

Fraction of original axes between colorbar and new image axes.

anchor(float, float), optional

The anchor point of the colorbar axes. Defaults to (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal.

panchor(float, float), or False, optional

The anchor point of the colorbar parent axes. If False, the parent axes’ anchor will be unchanged. Defaults to (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal.

extend{‘neither’, ‘both’, ‘min’, ‘max’}

Make pointed end(s) for out-of-range values (unless ‘neither’). These are set for a given colormap using the colormap set_under and set_over methods.

extendfrac{None, ‘auto’, length, lengths}

If set to None, both the minimum and maximum triangular colorbar extensions will have a length of 5% of the interior colorbar length (this is the default setting).

If set to ‘auto’, makes the triangular colorbar extensions the same lengths as the interior boxes (when spacing is set to ‘uniform’) or the same lengths as the respective adjacent interior boxes (when spacing is set to ‘proportional’).

If a scalar, indicates the length of both the minimum and maximum triangular colorbar extensions as a fraction of the interior colorbar length. A two-element sequence of fractions may also be given, indicating the lengths of the minimum and maximum colorbar extensions respectively as a fraction of the interior colorbar length.

extendrectbool

If False the minimum and maximum colorbar extensions will be triangular (the default). If True the extensions will be rectangular.

spacing{‘uniform’, ‘proportional’}

For discrete colorbars (.BoundaryNorm or contours), ‘uniform’ gives each color the same space; ‘proportional’ makes the space proportional to the data interval.

ticksNone or list of ticks or Locator

If None, ticks are determined automatically from the input.

formatNone or str or Formatter

If None, ~.ticker.ScalarFormatter is used. Format strings, e.g., "%4.2e" or "{x:.2e}", are supported. An alternative ~.ticker.Formatter may be given instead.

drawedgesbool

Whether to draw lines at color boundaries.

labelstr

The label on the colorbar’s long axis.

boundaries, valuesNone or a sequence

If unset, the colormap will be displayed on a 0-1 scale. If sequences, values must have a length 1 less than boundaries. For each region delimited by adjacent entries in boundaries, the color mapped to the corresponding value in values will be used. Normally only useful for indexed colors (i.e. norm=NoNorm()) or other unusual circumstances.

Notes¶

If mappable is a ~.contour.ContourSet, its extend kwarg is included automatically.

The shrink kwarg provides a simple way to scale the colorbar with respect to the axes. Note that if cax is specified, it determines the size of the colorbar and shrink and aspect kwargs are ignored.

For more precise control, you can manually specify the positions of the axes objects in which the mappable and the colorbar are drawn. In this case, do not use any of the axes properties kwargs.

It is known that some vector graphics viewers (svg and pdf) renders white gaps between segments of the colorbar. This is due to bugs in the viewers, not Matplotlib. As a workaround, the colorbar can be rendered with overlapping segments:

cbar = colorbar()
cbar.solids.set_edgecolor("face")
draw()

However this has negative consequences in other circumstances, e.g. with semi-transparent images (alpha < 1) and colorbar extensions; therefore, this workaround is not used by default (see issue #1188).

contains(mouseevent)[source]¶: Test whether the mouse event occurred on the figure.

Returns¶

bool, {}

convert_xunits(x)¶

Convert x using the unit type of the xaxis.

If the artist is not contained in an Axes or if the xaxis does not have units, x itself is returned.

convert_yunits(y)¶

Convert y using the unit type of the yaxis.

If the artist is not contained in an Axes or if the yaxis does not have units, y itself is returned.

delaxes(ax)[source]¶: Remove the ~.axes.Axes ax from the figure; update the current Axes.

draw(renderer)¶

Draw the Artist (and its children) using the given renderer.

This has no effect if the artist is not visible (.Artist.get_visible returns False).

Parameters¶

renderer : .RendererBase subclass.

Notes¶

This method is overridden in the Artist subclasses.

findobj(match=None, include_self=True)¶

Find artist objects.

Recursively find all .Artist instances contained in the artist.

Parameters¶

match

A filter criterion for the matches. This can be

None: Return all objects contained in artist.
A function with signature def match(artist: Artist) -> bool. The result will only contain artists for which the function returns True.
A class instance: e.g., .Line2D. The result will only contain artists of this class or its subclasses (isinstance check).

include_selfbool

Include self in the list to be checked for a match.

Returns¶

list of .Artist

format_cursor_data(data)¶

Return a string representation of data.

Note

This method is intended to be overridden by artist subclasses. As an end-user of Matplotlib you will most likely not call this method yourself.

The default implementation converts ints and floats and arrays of ints and floats into a comma-separated string enclosed in square brackets, unless the artist has an associated colorbar, in which case scalar values are formatted using the colorbar’s formatter.

Parameters¶

event : matplotlib.backend_bases.MouseEvent

Returns¶

tuple or None

A 3-tuple with the following elements:

scale: The amplitude of the wiggle perpendicular to the source line.

length: The length of the wiggle along the line.

randomness: The scale factor by which the length is shrunken or expanded.

Returns None if no sketch parameters were set.

get_snap()¶

Return the snap setting.

See .set_snap for details.

get_tightbbox(renderer=None, bbox_extra_artists=None)[source]¶

Return a (tight) bounding box of the figure in inches.

Note that .FigureBase differs from all other artists, which return their .Bbox in pixels.

Artists that have artist.set_in_layout(False) are not included in the bbox.

Parameters¶

renderer.RendererBase subclass: renderer that will be used to draw the figures (i.e. fig.canvas.get_renderer())
bbox_extra_artistslist of .Artist or None: List of artists to include in the tight bounding box. If None (default), then all artist children of each Axes are included in the tight bounding box.

Returns¶

.BboxBase: containing the bounding box (in figure inches).

get_transform()¶: Return the .Transform instance used by this artist.

get_transformed_clip_path_and_affine()¶: Return the clip path with the non-affine part of its transformation applied, and the remaining affine part of its transformation.

get_url()¶: Return the url.

get_visible()¶: Return the visibility.

get_window_extent(renderer=None, *args, **kwargs)[source]¶

Get the artist’s bounding box in display space.

The bounding box’ width and height are nonnegative.

Subclasses should override for inclusion in the bounding box “tight” calculation. Default is to return an empty bounding box at 0, 0.

Be careful when using this function, the results will not update if the artist window extent of the artist changes. The extent can change due to any changes in the transform stack, such as changing the axes limits, the figure size, or the canvas used (as is done when saving a figure). This can lead to unexpected behavior where interactive figures will look fine on the screen, but will save incorrectly.

get_zorder()¶: Return the artist’s zorder.

have_units()¶: Return whether units are set on any axis.

is_transform_set()¶

Return whether the Artist has an explicitly set transform.

This is True after .set_transform has been called.

legend(*args, **kwargs)[source]¶

Place a legend on the figure.

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')
fig.legend()

or:

line, = ax.plot([1, 2, 3])
line.set_label('Label via method')
fig.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 .Figure.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:

fig.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, = ax1.plot([1, 2, 3], label='label1')
line2, = ax2.plot([1, 2, 3], label='label2')
fig.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 all Axes, call this function with an iterable of strings, one for each legend item. For example:

fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.plot([1, 3, 5], color='blue')
ax2.plot([2, 4, 6], color='red')
fig.legend(['the blues', 'the reds'])

Parameters¶

handleslist 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¶

~matplotlib.legend.Legend

Other Parameters¶

locstr or pair of floats, default: :rc:`legend.loc` (‘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_anchor.BboxBase, 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)

ncolsint, default: 1

The number of columns that the legend has.

For backward compatibility, the spelling ncol is also supported but it is discouraged. If both are given, ncols takes precedence.

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: :rc:`legend.labelcolor`

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 :rc:`legend.labelcolor`. If None, use :rc:`text.color`.

numpointsint, default: :rc:`legend.numpoints`

The number of marker points in the legend when creating a legend entry for a .Line2D (line).

scatterpointsint, default: :rc:`legend.scatterpoints`

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: :rc:`legend.markerscale`

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: :rc:`legend.frameon`

Whether the legend should be drawn on a patch (frame).

fancyboxbool, default: :rc:`legend.fancybox`

Whether round edges should be enabled around the .FancyBboxPatch which makes up the legend’s background.

shadowbool, default: :rc:`legend.shadow`

Whether to draw a shadow behind the legend.

framealphafloat, default: :rc:`legend.framealpha`

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: :rc:`legend.facecolor`

The legend’s background color. If "inherit", use :rc:`axes.facecolor`.

edgecolor“inherit” or color, default: :rc:`legend.edgecolor`

The legend’s background patch edge color. If "inherit", use take :rc:`axes.edgecolor`.

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 :rc:`legend.title_fontsize` will be used.

title_fontsizeint or {‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’}, default: :rc:`legend.title_fontsize`

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.

alignment{‘center’, ‘left’, ‘right’}, default: ‘center’

The alignment of the legend title and the box of entries. The entries are aligned as a single block, so that markers always lined up.

borderpadfloat, default: :rc:`legend.borderpad`

The fractional whitespace inside the legend border, in font-size units.

labelspacingfloat, default: :rc:`legend.labelspacing`

The vertical space between the legend entries, in font-size units.

handlelengthfloat, default: :rc:`legend.handlelength`

The length of the legend handles, in font-size units.

handleheightfloat, default: :rc:`legend.handleheight`

The height of the legend handles, in font-size units.

handletextpadfloat, default: :rc:`legend.handletextpad`

The pad between the legend handle and text, in font-size units.

borderaxespadfloat, default: :rc:`legend.borderaxespad`

The pad between the axes and legend border, in font-size units.

columnspacingfloat, default: :rc:`legend.columnspacing`

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.

Notes¶

Some artists are not supported by this function. See /tutorials/intermediate/legend_guide for details.

property mouseover¶: Return whether this artist is queried for custom context information when the mouse cursor moves over it.

pchanged()¶

Call all of the registered callbacks.

This function is triggered internally when a property is changed.

Parameters¶

filter_funccallable: A filter function, which takes a (m, n, depth) float array and a dpi value, and returns a (m, n, depth) array and two offsets from the bottom left corner of the image

set_alpha(alpha)¶

Set the alpha value used for blending - not supported on all backends.

Parameters¶

alphascalar or None: alpha must be within the 0-1 range, inclusive.

set_animated(b)¶

Set whether the artist is intended to be used in an animation.

If True, the artist is excluded from regular drawing of the figure. You have to call .Figure.draw_artist / .Axes.draw_artist explicitly on the artist. This approach is used to speed up animations using blitting.

See also matplotlib.animation and /tutorials/advanced/blitting.

Parameters¶

b : bool

set_clip_box(clipbox)¶: Set the artist’s clip .Bbox.

Parameters¶

clipbox : .Bbox

set_clip_on(b)¶

Set whether the artist uses clipping.

When False artists will be visible outside of the Axes which can lead to unexpected results.

Parameters¶

b : bool

set_clip_path(path, transform=None)¶

Set the artist’s clip path.

Parameters¶

path.Patch or .Path or .TransformedPath or None: The clip path. If given a .Path, transform must be provided as well. If None, a previously set clip path is removed.
transform~matplotlib.transforms.Transform, optional: Only used if path is a .Path, in which case the given .Path is converted to a .TransformedPath using transform.

Notes¶

For efficiency, if path is a .Rectangle this method will set the clipping box to the corresponding rectangle and set the clipping path to None.

For technical reasons (support of ~.Artist.set), a tuple (path, transform) is also accepted as a single positional parameter.

set_edgecolor(color)[source]¶: Set the edge color of the Figure rectangle.

Parameters¶

color : color

set_facecolor(color)[source]¶: Set the face color of the Figure rectangle.

Parameters¶

color : color

set_figure(fig)¶: Set the .Figure instance the artist belongs to.

Parameters¶

fig : .Figure

set_frameon(b)[source]¶: Set the figure’s background patch visibility, i.e. whether the figure background will be drawn. Equivalent to Figure.patch.set_visible().

Parameters¶

b : bool

set_gid(gid)¶: Set the (group) id for the artist.

Parameters¶

gid : str

set_in_layout(in_layout)¶: Set if artist is to be included in layout calculations, E.g. /tutorials/intermediate/constrainedlayout_guide, .Figure.tight_layout(), and fig.savefig(fname, bbox_inches='tight').

Parameters¶

in_layout : bool

set_label(s)¶

Set a label that will be displayed in the legend.

Parameters¶

sobject: s will be converted to a string by calling str.

set_linewidth(linewidth)[source]¶: Set the line width of the Figure rectangle.

Parameters¶

linewidth : number

set_mouseover(mouseover)¶: Set whether this artist is queried for custom context information when the mouse cursor moves over it.

Parameters¶

mouseover : bool

See Also¶

get_cursor_data .ToolCursorPosition .NavigationToolbar2

set_path_effects(path_effects)¶: Set the path effects.

Parameters¶

path_effects : .AbstractPathEffect

set_picker(picker)¶

Define the picking behavior of the artist.

Parameters¶

pickerNone or bool or float or callable

This can be one of the following:

None: Picking is disabled for this artist (default).
A boolean: If True then picking will be enabled and the artist will fire a pick event if the mouse event is over the artist.
A float: If picker is a number it is interpreted as an epsilon tolerance in points and the artist will fire off an event if its data is within epsilon of the mouse event. For some artists like lines and patch collections, the artist may provide additional data to the pick event that is generated, e.g., the indices of the data within epsilon of the pick event
A function: If picker is callable, it is a user supplied function which determines whether the artist is hit by the mouse event:
```
hit, props = picker(artist, mouseevent)
```
to determine the hit test. if the mouse event is over the artist, return hit=True and props is a dictionary of properties you want added to the PickEvent attributes.

set_rasterized(rasterized)¶

Force rasterized (bitmap) drawing for vector graphics output.

Rasterized drawing is not supported by all artists. If you try to enable this on an artist that does not support it, the command has no effect and a warning will be issued.

This setting is ignored for pixel-based output.

See also /gallery/misc/rasterization_demo.

Parameters¶

rasterized : bool

set_sketch_params(scale=None, length=None, randomness=None)¶

Set the sketch parameters.

Parameters¶

scalefloat, optional

The amplitude of the wiggle perpendicular to the source line, in pixels. If scale is None, or not provided, no sketch filter will be provided.

lengthfloat, optional

The length of the wiggle along the line, in pixels (default 128.0)

randomnessfloat, optional

The scale factor by which the length is shrunken or expanded (default 16.0)

The PGF backend uses this argument as an RNG seed and not as described above. Using the same seed yields the same random shape.

set_snap(snap)¶

Set the snapping behavior.

Snapping aligns positions with the pixel grid, which results in clearer images. For example, if a black line of 1px width was defined at a position in between two pixels, the resulting image would contain the interpolated value of that line in the pixel grid, which would be a grey value on both adjacent pixel positions. In contrast, snapping will move the line to the nearest integer pixel value, so that the resulting image will really contain a 1px wide black line.

Snapping is currently only supported by the Agg and MacOSX backends.

Parameters¶

snapbool or None

Possible values:

True: Snap vertices to the nearest pixel center.
False: Do not modify vertex positions.
None: (auto) If the path contains only rectilinear line segments, round to the nearest pixel center.

set_transform(t)¶: Set the artist transform.

Parameters¶

t : .Transform

set_url(url)¶: Set the url for the artist.

Parameters¶

url : str

set_visible(b)¶: Set the artist’s visibility.

Parameters¶

b : bool

set_zorder(level)¶: Set the zorder for the artist. Artists with lower zorder values are drawn first.

Parameters¶

level : float

property stale¶: Whether the artist is ‘stale’ and needs to be re-drawn for the output to match the internal state of the artist.

property sticky_edges¶

x and y sticky edge lists for autoscaling.

When performing autoscaling, if a data limit coincides with a value in the corresponding sticky_edges list, then no margin will be added–the view limit “sticks” to the edge. A typical use case is histograms, where one usually expects no margin on the bottom edge (0) of the histogram.

Moreover, margin expansion “bumps” against sticky edges and cannot cross them. For example, if the upper data limit is 1.0, the upper view limit computed by simple margin application is 1.2, but there is a sticky edge at 1.1, then the actual upper view limit will be 1.1.

This attribute cannot be assigned to; however, the x and y lists can be modified in place as needed.

Examples¶

>>> artist.sticky_edges.x[:] = (xmin, xmax)
>>> artist.sticky_edges.y[:] = (ymin, ymax)

subfigures(nrows=1, ncols=1, squeeze=True, wspace=None, hspace=None, width_ratios=None, height_ratios=None, **kwargs)[source]¶

Add a subfigure to this figure or subfigure.

A subfigure has the same artist methods as a figure, and is logically the same as a figure, but cannot print itself. See /gallery/subplots_axes_and_figures/subfigures.

Parameters¶

nrows, ncolsint, default: 1: Number of rows/columns of the subfigure grid.
squeezebool, default: True: If True, extra dimensions are squeezed out from the returned array of subfigures.
wspace, hspacefloat, default: None: The amount of width/height reserved for space between subfigures, expressed as a fraction of the average subfigure width/height. If not given, the values will be inferred from a figure or rcParams when necessary.
width_ratiosarray-like of length ncols, optional: Defines the relative widths of the columns. Each column gets a relative width of width_ratios[i] / sum(width_ratios). If not given, all columns will have the same width.
height_ratiosarray-like of length nrows, optional: Defines the relative heights of the rows. Each row gets a relative height of height_ratios[i] / sum(height_ratios). If not given, all rows will have the same height.

subplot_mosaic(mosaic, *, sharex=False, sharey=False, width_ratios=None, height_ratios=None, empty_sentinel='.', subplot_kw=None, gridspec_kw=None)[source]¶

Build a layout of Axes based on ASCII art or nested lists.

This is a helper function to build complex GridSpec layouts visually.

Note

This API is provisional and may be revised in the future based on early user feedback.

See /tutorials/provisional/mosaic for an example and full API documentation

Parameters¶

mosaic : list of list of {hashable or nested} or str

A visual layout of how you want your Axes to be arranged labeled as strings. For example
x = [['A panel', 'A panel', 'edge'],
     ['C panel', '.',       'edge']]
produces 4 Axes:

‘A panel’ which is 1 row high and spans the first two columns

‘edge’ which is 2 rows high and is on the right edge

‘C panel’ which in 1 row and 1 column wide in the bottom left

a blank space 1 row and 1 column wide in the bottom center

Any of the entries in the layout can be a list of lists of the same form to create nested layouts.

If input is a str, then it can either be a multi-line string of the form
'''
AAE
C.E
'''
where each character is a column and each line is a row. Or it can be a single-line string where rows are separated by ;:
'AB;CC'
The string notation allows only single character Axes labels and does not support nesting but is very terse.

sharex, shareybool, default: False: If True, the x-axis (sharex) or y-axis (sharey) will be shared among all subplots. In that case, tick label visibility and axis units behave as for subplots. If False, each subplot’s x- or y-axis will be independent.
width_ratiosarray-like of length ncols, optional: Defines the relative widths of the columns. Each column gets a relative width of width_ratios[i] / sum(width_ratios). If not given, all columns will have the same width. Equivalent to gridspec_kw={'width_ratios': [...]}.
height_ratiosarray-like of length nrows, optional: Defines the relative heights of the rows. Each row gets a relative height of height_ratios[i] / sum(height_ratios). If not given, all rows will have the same height. Equivalent to gridspec_kw={'height_ratios': [...]}.
subplot_kwdict, optional: Dictionary with keywords passed to the .Figure.add_subplot call used to create each subplot.
gridspec_kwdict, optional: Dictionary with keywords passed to the .GridSpec constructor used to create the grid the subplots are placed on.
empty_sentinelobject, optional: Entry in the layout to mean “leave this space empty”. Defaults to '.'. Note, if layout is a string, it is processed via inspect.cleandoc to remove leading white space, which may interfere with using white-space as the empty sentinel.

Returns¶

dict[label, Axes]: A dictionary mapping the labels to the Axes objects. The order of the axes is left-to-right and top-to-bottom of their position in the total layout.

subplots(nrows=1, ncols=1, *, sharex=False, sharey=False, squeeze=True, width_ratios=None, height_ratios=None, subplot_kw=None, gridspec_kw=None)[source]¶

Add a set of subplots to this figure.

This utility wrapper makes it convenient to create common layouts of subplots in a single call.

Parameters¶

nrows, ncolsint, default: 1

Number of rows/columns of the subplot grid.

sharex, shareybool or {‘none’, ‘all’, ‘row’, ‘col’}, default: False

Controls sharing of x-axis (sharex) or y-axis (sharey):

True or ‘all’: x- or y-axis will be shared among all subplots.
False or ‘none’: each subplot x- or y-axis will be independent.
‘row’: each subplot row will share an x- or y-axis.
‘col’: each subplot column will share an x- or y-axis.

When subplots have a shared x-axis along a column, only the x tick labels of the bottom subplot are created. Similarly, when subplots have a shared y-axis along a row, only the y tick labels of the first column subplot are created. To later turn other subplots’ ticklabels on, use ~matplotlib.axes.Axes.tick_params.

When subplots have a shared axis that has units, calling .Axis.set_units will update each axis with the new units.

squeezebool, default: True

If True, extra dimensions are squeezed out from the returned array of Axes:
- if only one subplot is constructed (nrows=ncols=1), the resulting single Axes object is returned as a scalar.
- for Nx1 or 1xM subplots, the returned object is a 1D numpy object array of Axes objects.
- for NxM, subplots with N>1 and M>1 are returned as a 2D array.
If False, no squeezing at all is done: the returned Axes object is always a 2D array containing Axes instances, even if it ends up being 1x1.

width_ratiosarray-like of length ncols, optional

Defines the relative widths of the columns. Each column gets a relative width of width_ratios[i] / sum(width_ratios). If not given, all columns will have the same width. Equivalent to gridspec_kw={'width_ratios': [...]}.

height_ratiosarray-like of length nrows, optional

Defines the relative heights of the rows. Each row gets a relative height of height_ratios[i] / sum(height_ratios). If not given, all rows will have the same height. Equivalent to gridspec_kw={'height_ratios': [...]}.

subplot_kwdict, optional

Dict with keywords passed to the .Figure.add_subplot call used to create each subplot.

gridspec_kwdict, optional

Dict with keywords passed to the ~matplotlib.gridspec.GridSpec constructor used to create the grid the subplots are placed on.

Returns¶

~.axes.Axes or array of Axes: Either a single ~matplotlib.axes.Axes object or an array of Axes objects if more than one subplot was created. The dimensions of the resulting array can be controlled with the squeeze keyword, see above.

Examples¶

# First create some toy data:
x = np.linspace(0, 2*np.pi, 400)
y = np.sin(x**2)

# Create a figure
plt.figure()

# Create a subplot
ax = fig.subplots()
ax.plot(x, y)
ax.set_title('Simple plot')

# Create two subplots and unpack the output array immediately
ax1, ax2 = fig.subplots(1, 2, sharey=True)
ax1.plot(x, y)
ax1.set_title('Sharing Y axis')
ax2.scatter(x, y)

# Create four polar Axes and access them through the returned array
axes = fig.subplots(2, 2, subplot_kw=dict(projection='polar'))
axes[0, 0].plot(x, y)
axes[1, 1].scatter(x, y)

# Share a X axis with each column of subplots
fig.subplots(2, 2, sharex='col')

# Share a Y axis with each row of subplots
fig.subplots(2, 2, sharey='row')

# Share both X and Y axes with all subplots
fig.subplots(2, 2, sharex='all', sharey='all')

# Note that this is the same as
fig.subplots(2, 2, sharex=True, sharey=True)

subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=None)[source]¶

Adjust the subplot layout parameters.

Unset parameters are left unmodified; initial values are given by :rc:`figure.subplot.[name]`.

Parameters¶

leftfloat, optional: The position of the left edge of the subplots, as a fraction of the figure width.
rightfloat, optional: The position of the right edge of the subplots, as a fraction of the figure width.
bottomfloat, optional: The position of the bottom edge of the subplots, as a fraction of the figure height.
topfloat, optional: The position of the top edge of the subplots, as a fraction of the figure height.
wspacefloat, optional: The width of the padding between subplots, as a fraction of the average Axes width.
hspacefloat, optional: The height of the padding between subplots, as a fraction of the average Axes height.

suptitle(t, **kwargs)[source]¶

Add a centered suptitle to the figure.

Parameters¶

tstr: The suptitle text.
xfloat, default: 0.5: The x location of the text in figure coordinates.
yfloat, default: 0.98: The y location of the text in figure coordinates.
horizontalalignment, ha{‘center’, ‘left’, ‘right’}, default: center: The horizontal alignment of the text relative to (x, y).
verticalalignment, va{‘top’, ‘center’, ‘bottom’, ‘baseline’}, default: top: The vertical alignment of the text relative to (x, y).
fontsize, sizedefault: :rc:`figure.titlesize`: The font size of the text. See .Text.set_size for possible values.
fontweight, weightdefault: :rc:`figure.titleweight`: The font weight of the text. See .Text.set_weight for possible values.

Returns¶

text: The .Text instance of the suptitle.

Other Parameters¶

fontpropertiesNone or dict, optional: A dict of font properties. If fontproperties is given the default values for font size and weight are taken from the .FontProperties defaults. :rc:`figure.titlesize` and :rc:`figure.titleweight` are ignored in this case.
**kwargs: Additional kwargs are matplotlib.text.Text properties.

supxlabel(t, **kwargs)[source]¶

Add a centered supxlabel to the figure.

Parameters¶

tstr: The supxlabel text.
xfloat, default: 0.5: The x location of the text in figure coordinates.
yfloat, default: 0.01: The y location of the text in figure coordinates.
horizontalalignment, ha{‘center’, ‘left’, ‘right’}, default: center: The horizontal alignment of the text relative to (x, y).
verticalalignment, va{‘top’, ‘center’, ‘bottom’, ‘baseline’}, default: bottom: The vertical alignment of the text relative to (x, y).
fontsize, sizedefault: :rc:`figure.labelsize`: The font size of the text. See .Text.set_size for possible values.
fontweight, weightdefault: :rc:`figure.labelweight`: The font weight of the text. See .Text.set_weight for possible values.

Returns¶

text: The .Text instance of the supxlabel.

Other Parameters¶

fontpropertiesNone or dict, optional: A dict of font properties. If fontproperties is given the default values for font size and weight are taken from the .FontProperties defaults. :rc:`figure.labelsize` and :rc:`figure.labelweight` are ignored in this case.
**kwargs: Additional kwargs are matplotlib.text.Text properties.

supylabel(t, **kwargs)[source]¶

Add a centered supylabel to the figure.

Parameters¶

tstr: The supylabel text.
xfloat, default: 0.02: The x location of the text in figure coordinates.
yfloat, default: 0.5: The y location of the text in figure coordinates.
horizontalalignment, ha{‘center’, ‘left’, ‘right’}, default: left: The horizontal alignment of the text relative to (x, y).
verticalalignment, va{‘top’, ‘center’, ‘bottom’, ‘baseline’}, default: center: The vertical alignment of the text relative to (x, y).
fontsize, sizedefault: :rc:`figure.labelsize`: The font size of the text. See .Text.set_size for possible values.
fontweight, weightdefault: :rc:`figure.labelweight`: The font weight of the text. See .Text.set_weight for possible values.

Returns¶

text: The .Text instance of the supylabel.

Other Parameters¶

fontpropertiesNone or dict, optional: A dict of font properties. If fontproperties is given the default values for font size and weight are taken from the .FontProperties defaults. :rc:`figure.labelsize` and :rc:`figure.labelweight` are ignored in this case.
**kwargs: Additional kwargs are matplotlib.text.Text properties.

text(x, y, s, fontdict=None, **kwargs)[source]¶

Add text to figure.

Parameters¶

x, yfloat: The position to place the text. By default, this is in figure coordinates, floats in [0, 1]. The coordinate system can be changed using the transform keyword.
sstr: The text string.
fontdictdict, optional: A dictionary to override the default text properties. If not given, the defaults are determined by :rc:`font.*`. Properties passed as kwargs override the corresponding ones given in fontdict.

Returns¶

~.text.Text

Other Parameters¶

**kwargs~matplotlib.text.Text properties

Other miscellaneous text parameters.

Properties: agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array and two offsets from the bottom left corner of the image 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: {‘left’, ‘center’, ‘right’} in_layout: bool label: object linespacing: float (multiple of font size) math_fontfamily: str mouseover: bool 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: {‘bottom’, ‘baseline’, ‘center’, ‘center_baseline’, ‘top’} visible: bool wrap: bool x: float y: float zorder: float

smpl.plot.FigureBase¶

Parameters¶

Returns¶

Parameters¶

Returns¶

Other Parameters¶

Notes¶

See Also¶

Examples¶

Parameters¶

Returns¶

See Also¶

Parameters¶

Returns¶

Other Parameters¶

See Also¶

Examples¶

Parameters¶

Returns¶

Other Parameters¶

See Also¶

Parameters¶

Returns¶

Other Parameters¶

See Also¶

Examples¶

Parameters¶

See Also¶

Parameters¶

See Also¶

Notes¶

Examples¶

Parameters¶

See Also¶

Notes¶

Examples¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Returns¶

Other Parameters¶

Notes¶

Returns¶

Parameters¶

Notes¶

Parameters¶

Returns¶

See Also¶

Parameters¶

See Also¶

See Also¶

Returns¶

Parameters¶

Returns¶

Parameters¶

Returns¶

Other Parameters¶

See Also¶

Notes¶

See Also¶

See Also¶

See Also¶

See Also¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Notes¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶

Parameters¶