This notebook demonstrates the following typical tasks you might want to do with CETB EASE-Grid 2.0 data:
You will need to be working in a python environment with the following packages installed. I think the cartopy features here require it to be a python 3 environment:
cartopy
matplotlib
netCDF4
shapely
In [1]:
%matplotlib notebook
import cartopy.crs as ccrs
import matplotlib.pyplot as plt
In cartopy documentation, I do not see support for the EASE-Grid 2.0 cylindrical equal area projection, so I think this will only work for Northern and Southern EASE-Grid 2.0 projections.
I have submitted a feature request to cartopy to add the cylindrical projection (7/27/2018).
Here is cartopy documentation for supported projections:
https://scitools.org.uk/cartopy/docs/latest/crs/projections.html
So we can set up objects for EASE-Grid 2.0 North and for lat/lon, which cartopy calls "geodetic":
In [2]:
geod = ccrs.Geodetic()
e2n = ccrs.LambertAzimuthalEqualArea(central_latitude=90.0)
In [3]:
UL_corner_m = [-9000000., 9000000.] # [x, y] in meters, UL corner of EASE2_N projection
lon, lat = geod.transform_point(
x = UL_corner_m[0],
y = UL_corner_m[1],
src_crs = e2n)
print(lon, lat)
-135.0 -84.6340496694687
In [4]:
pole_m = [0., 0.] # [x, y] in meters, North Pole of EASE2_N projection
lon, lat = geod.transform_point(
x = pole_m[0],
y = pole_m[1],
src_crs = e2n)
print(lon, lat)
0.0 90.0
In [5]:
LR_corner_m = [9000000., -9000000.] # [x, y] in meters, LR corner of EASE2_N projection
lon, lat = geod.transform_point(
x = LR_corner_m[0],
y = LR_corner_m[1],
src_crs = e2n)
print(lon, lat)
45.0 -84.6340496694687
In [6]:
UR_corner_geod = [135., -84.634050]
x, y = e2n.transform_point(
x = UR_corner_geod[0],
y = UR_corner_geod[1],
src_crs = geod)
print(x, y)
9000000.001226343 9000000.001226341
Use the projection keyword to the plt.axes command to set the projection to the ccrs you want to display. This will return a GeoAxesSubplot object that "knows" about map projections.
You need to control the extent with the set_extent keyword, and you can use built-in routines to get gridlines and coastlines
In [7]:
plt.figure()
e2n_full_extent = [-9000000., 9000000., -9000000., 9000000.] # Full extent, in projected coords: [ULx, LRx, ULy, LRy]
ax = plt.axes(projection=e2n)
ax.set_extent(e2n_full_extent, crs=e2n) # you have to tell it what projection to use to interpret the extent
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
plt.tight_layout()
plt.show()
In [8]:
plt.figure()
# Lower right quadrant of hemisphere:
extent = [0., 9000000., -9000000., 0.] # Extent, in projected coords: [x_min, x_max, y_min, y_max]
ax = plt.axes(projection=e2n)
ax.set_extent(extent, crs=e2n) # you have to tell it what projection to use to interpret the extent
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
plt.tight_layout()
plt.show()
In [9]:
westUS_UL_geod = [-114.57, 12.05]
westUS_UL_m = e2n.transform_point(
x = westUS_UL_geod[0],
y = westUS_UL_geod[1],
src_crs = geod)
print(westUS_UL_m)
(-7292918.432053986, 3334340.871500917)
In [10]:
westUS_LR_geod = [-100.34, 50.53]
westUS_LR_m = e2n.transform_point(
x = westUS_LR_geod[0],
y = westUS_LR_geod[1],
src_crs = geod)
print(westUS_LR_m)
(-4245692.389989166, 774635.4073810637)
In [11]:
plt.figure()
# Western US:
# Full extent, in projected coords: [x_min, x_max, y_min, y_max]
extent = [westUS_UL_m[0], westUS_LR_m[0], westUS_UL_m[1], westUS_LR_m[1]]
ax = plt.axes(projection=e2n)
ax.set_extent(extent, crs=e2n) # you have to tell it what projection to use to interpret the extent
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
plt.tight_layout()
plt.show()
In [12]:
from netCDF4 import Dataset
import numpy as np
file = "/Users/brodzik/ExploringCETB/data/NSIDC-0630-EASE2_N3.125km-AQUA_AMSRE-2004164-36H-M-SIR-RSS-v1.3.nc"
f = Dataset(file, 'r', 'netCDF4')
In [13]:
tb = np.squeeze(f.variables['TB'][:])
tb.shape
Out[13]:
(5760, 5760)
In [14]:
f.close()
In [15]:
plt.figure()
ax = plt.axes(projection=e2n)
ax.set_extent(e2n_full_extent, crs=e2n) # you have to tell it what projection to use to interpret the extent
ax.imshow(tb, extent=e2n_full_extent, transform=e2n, origin='upper')
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
plt.tight_layout()
plt.show()
In [16]:
lrquad_tb = tb[2880:, 2880:]
extent = [0., 9000000., -9000000., 0.]
plt.figure()
ax = plt.axes(projection=e2n)
ax.set_extent(extent, crs=e2n)
ax.imshow(lrquad_tb, extent=extent, transform=e2n, origin='upper')
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
plt.tight_layout()
plt.show()
In [17]:
import cartopy.io.shapereader as shpreader
import shapely.geometry as sgeom
bfile = '/Users/brodzik/ExploringCETB/data/IN_Hunza_at_DainyorBridge.shp'
In [18]:
reader = shpreader.Reader(bfile)
record = next(reader.records())
In [19]:
record
Out[19]:
<Record: <shapely.geometry.multipolygon.MultiPolygon object at 0x11cc4d358>, {'GRDC_NO': 2335100, 'WMO_REG': 2, 'SUB_REG': 35, 'MIX_REG': 235, 'NAT_ID': '1001', 'RIVER': 'HUNZA RIVER', 'STATION': 'DANYOUR BRIDGE', 'COUNTRY_CO': 'PK', 'LAT_ORG': 35.92, 'LONG_ORG': 74.38, 'LAT_NEW': 35.9271, 'LONG_NEW': 74.3729, 'DIST_KM': 1.0, 'AREA': 12950.0, 'AREA_HYS': 13746.4, 'AREA_DIFF': 6.1, 'ALTITUDE': -999.0, 'ELEV_HYS': 1446, 'DS_STAT_NO': 2335200, 'W_LEVEL': 0, 'D_START': 1978, 'D_END': 1982, 'D_YRS': 5, 'D_MISS': 20, 'M_START': 1978, 'M_END': 1982, 'M_YRS': 5, 'M_MISS': 20, 'T_START': 1978, 'T_END': 1982, 'T_YRS': 5, 'LTA_DISCHA': 381.128, 'DISC_HYS': 55.74, 'DISC_DIFF': -85.4, 'R_VOLUME_Y': 12, 'R_HEIGHT_Y': 928, 'PROC_TYRS': 80, 'PROC_TMON': 100, 'F_IMPORT': '16.1.1992', 'F_IM_YR': 1992, 'L_IMPORT': '10.5.1996', 'L_IM_YR': 1996, 'PROVIDER_I': -999, 'ACSYS': 0, 'FLUX2OCEAN': 0, 'GEMS': 0, 'GCOS_GTN_H': 0, 'STATISTICS': 0, 'CODE': 2, 'QUALITY': 'Medium', 'TYPE': 'Automatic', 'COMMENT': 'Area difference 5-10% and distance <= 5 km', 'HS_REGION': 'As'}, <fields>>
In [20]:
record.attributes
Out[20]:
{'GRDC_NO': 2335100,
'WMO_REG': 2,
'SUB_REG': 35,
'MIX_REG': 235,
'NAT_ID': '1001',
'RIVER': 'HUNZA RIVER',
'STATION': 'DANYOUR BRIDGE',
'COUNTRY_CO': 'PK',
'LAT_ORG': 35.92,
'LONG_ORG': 74.38,
'LAT_NEW': 35.9271,
'LONG_NEW': 74.3729,
'DIST_KM': 1.0,
'AREA': 12950.0,
'AREA_HYS': 13746.4,
'AREA_DIFF': 6.1,
'ALTITUDE': -999.0,
'ELEV_HYS': 1446,
'DS_STAT_NO': 2335200,
'W_LEVEL': 0,
'D_START': 1978,
'D_END': 1982,
'D_YRS': 5,
'D_MISS': 20,
'M_START': 1978,
'M_END': 1982,
'M_YRS': 5,
'M_MISS': 20,
'T_START': 1978,
'T_END': 1982,
'T_YRS': 5,
'LTA_DISCHA': 381.128,
'DISC_HYS': 55.74,
'DISC_DIFF': -85.4,
'R_VOLUME_Y': 12,
'R_HEIGHT_Y': 928,
'PROC_TYRS': 80,
'PROC_TMON': 100,
'F_IMPORT': '16.1.1992',
'F_IM_YR': 1992,
'L_IMPORT': '10.5.1996',
'L_IM_YR': 1996,
'PROVIDER_I': -999,
'ACSYS': 0,
'FLUX2OCEAN': 0,
'GEMS': 0,
'GCOS_GTN_H': 0,
'STATISTICS': 0,
'CODE': 2,
'QUALITY': 'Medium',
'TYPE': 'Automatic',
'COMMENT': 'Area difference 5-10% and distance <= 5 km',
'HS_REGION': 'As'}
In [21]:
record.bounds
Out[21]:
(74.02507731119763, 35.92307128906174, 75.77779744466116, 37.09783732096277)
In [22]:
record.geometry
Out[22]:
In [23]:
plt.figure()
ax = plt.axes(projection=e2n)
ax.set_extent(extent, crs=e2n)
ax.imshow(lrquad_tb, extent=extent, transform=e2n, origin='upper')
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
ax.add_geometries(
[record.geometry], geod,
edgecolors='red', facecolor='none', lw=2)
plt.tight_layout()
plt.show()
I think that you don't need to know what the projection of the input shapefile is, it will get it from the record.geometry object (not certain about this).
Doing it this way, you tell the ax.add_geometries method that the data are already in e2n
In [24]:
basin_e2n = e2n.project_geometry(record.geometry)
plt.figure()
ax = plt.axes(projection=e2n)
ax.set_extent(extent, crs=e2n)
ax.imshow(lrquad_tb, extent=extent, transform=e2n, origin='upper')
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
ax.add_geometries(
[basin_e2n], e2n,
edgecolors='red', facecolor='none', lw=2)
plt.tight_layout()
plt.show()
For example, if you zoom to a box around the Hunza sub basin and call
ax.get_extent()
it will give the zoomed extent coordinates, in projected meters, which could be really handy. This would eliminate the steps in the example above, where I found the Western US subset by reading the lat/lon off the plot and converted them manually.
In [25]:
help(ax)
Help on GeoAxesSubplot in module cartopy.mpl.geoaxes object:
class GeoAxesSubplot(matplotlib.axes._subplots.SubplotBase, GeoAxes)
| Base class for subplots, which are :class:`Axes` instances with
| additional methods to facilitate generating and manipulating a set
| of :class:`Axes` within a figure.
|
| Method resolution order:
| GeoAxesSubplot
| matplotlib.axes._subplots.SubplotBase
| GeoAxes
| matplotlib.axes._axes.Axes
| matplotlib.axes._base._AxesBase
| matplotlib.artist.Artist
| builtins.object
|
| Methods inherited from matplotlib.axes._subplots.SubplotBase:
|
| __init__(self, fig, *args, **kwargs)
| *fig* is a :class:`matplotlib.figure.Figure` instance.
|
| *args* is the tuple (*numRows*, *numCols*, *plotNum*), where
| the array of subplots in the figure has dimensions *numRows*,
| *numCols*, and where *plotNum* is the number of the subplot
| being created. *plotNum* starts at 1 in the upper left
| corner and increases to the right.
|
| If *numRows* <= *numCols* <= *plotNum* < 10, *args* can be the
| decimal integer *numRows* * 100 + *numCols* * 10 + *plotNum*.
|
| __reduce__(self)
| helper for pickle
|
| change_geometry(self, numrows, numcols, num)
| change subplot geometry, e.g., from 1,1,1 to 2,2,3
|
| get_geometry(self)
| get the subplot geometry, e.g., 2,2,3
|
| get_subplotspec(self)
| get the SubplotSpec instance associated with the subplot
|
| is_first_col(self)
|
| is_first_row(self)
|
| is_last_col(self)
|
| is_last_row(self)
|
| label_outer(self)
| Only show "outer" labels and tick labels.
|
| x-labels are only kept for subplots on the last row; y-labels only for
| subplots on the first column.
|
| set_subplotspec(self, subplotspec)
| set the SubplotSpec instance associated with the subplot
|
| update_params(self)
| update the subplot position from fig.subplotpars
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.axes._subplots.SubplotBase:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from GeoAxes:
|
| __str__(self)
| Return str(self).
|
| add_feature(self, feature, **kwargs)
| Add the given :class:`~cartopy.feature.Feature` instance to the axes.
|
| Parameters
| ----------
| feature
| An instance of :class:`~cartopy.feature.Feature`.
|
| Returns
| -------
| A :class:`cartopy.mpl.feature_artist.FeatureArtist` instance
| The instance responsible for drawing the feature.
|
| Note
| ----
| Matplotlib keyword arguments can be used when drawing the feature.
| This allows standard Matplotlib control over aspects such as
| 'facecolor', 'alpha', etc.
|
| add_geometries(self, geoms, crs, **kwargs)
| Add the given shapely geometries (in the given crs) to the axes.
|
| Parameters
| ----------
| geoms
| A collection of shapely geometries.
| crs
| The cartopy CRS in which the provided geometries are defined.
|
| Returns
| -------
| A :class:`cartopy.mpl.feature_artist.FeatureArtist` instance
| The instance responsible for drawing the feature.
|
| Note
| ----
| Matplotlib keyword arguments can be used when drawing the feature.
| This allows standard Matplotlib control over aspects such as
| 'facecolor', 'alpha', etc.
|
| add_image(self, factory, *args, **kwargs)
| Add an image "factory" to the Axes.
|
| Any image "factory" added will be asked to retrieve an image
| with associated metadata for a given bounding box at draw time.
| The advantage of this approach is that the limits of the map
| do not need to be known when adding the image factory, but can
| be deferred until everything which can effect the limits has been
| added.
|
| Parameters
| ----------
| factory
| Currently an image "factory" is just an object with
| an ``image_for_domain`` method. Examples of image factories
| are :class:`cartopy.io.img_nest.NestedImageCollection` and
| :class:`cartopy.io.image_tiles.GoogleTiles`.
|
| add_raster(self, raster_source, **slippy_image_kwargs)
| Add the given raster source to the GeoAxes.
|
| Parameters
| ----------
| raster_source:
| :class:`cartopy.io.RasterSource` like instance
| ``raster_source`` may be any object which
| implements the RasterSource interface, including
| instances of objects such as
| :class:`~cartopy.io.ogc_clients.WMSRasterSource`
| and
| :class:`~cartopy.io.ogc_clients.WMTSRasterSource`.
| Note that image retrievals are done at draw time,
| not at creation time.
|
| add_wms(self, wms, layers, wms_kwargs=None, **kwargs)
| Add the specified WMS layer to the axes.
|
| This function requires owslib and PIL to work.
|
| Parameters
| ----------
| wms: string or :class:`owslib.wms.WebMapService` instance
| The web map service URL or owslib WMS instance to use.
| layers: string or iterable of string
| The name of the layer(s) to use.
| wms_kwargs: dict or None, optional
| Passed through to the
| :class:`~cartopy.io.ogc_clients.WMSRasterSource`
| constructor's ``getmap_extra_kwargs`` for defining
| getmap time keyword arguments.
|
|
| All other keywords are passed through to the construction of the
| image artist. See :meth:`~matplotlib.axes.Axes.imshow()` for
| more details.
|
| add_wmts(self, wmts, layer_name, wmts_kwargs=None, **kwargs)
| Add the specified WMTS layer to the axes.
|
| This function requires owslib and PIL to work.
|
| Parameters
| ----------
| wmts
| The URL of the WMTS, or an owslib.wmts.WebMapTileService instance.
| layer_name
| The name of the layer to use.
| wmts_kwargs: dict or None, optional
| Passed through to the
| :class:`~cartopy.io.ogc_clients.WMTSRasterSource` constructor's
| ``gettile_extra_kwargs`` (e.g. time).
|
|
| All other keywords are passed through to the construction of the
| image artist. See :meth:`~matplotlib.axes.Axes.imshow()` for
| more details.
|
| autoscale_view(self, tight=None, scalex=True, scaley=True)
| Autoscale the view limits using the data limits.
|
| You can selectively autoscale only a single axis, e.g., the xaxis by
| setting *scaley* to *False*. The autoscaling preserves any
| axis direction reversal that has already been done.
|
| If *tight* is *False*, the axis major locator will be used
| to expand the view limits if rcParams['axes.autolimit_mode']
| is 'round_numbers'. Note that any margins that are in effect
| will be applied first, regardless of whether *tight* is
| *True* or *False*. Specifying *tight* as *True* or *False*
| saves the setting as a private attribute of the Axes; specifying
| it as *None* (the default) applies the previously saved value.
|
| The data limits are not updated automatically when artist data are
| changed after the artist has been added to an Axes instance. In that
| case, use :meth:`matplotlib.axes.Axes.relim` prior to calling
| autoscale_view.
|
| background_img(self, name='ne_shaded', resolution='low', extent=None, cache=False)
| Add a background image to the map, from a selection of pre-prepared
| images held in a directory specified by the CARTOPY_USER_BACKGROUNDS
| environment variable. That directory is checked with
| func:`self.read_user_background_images` and needs to contain a JSON
| file which defines for the image metadata.
|
| Parameters
| ----------
| name: optional
| The name of the image to read according to the contents
| of the JSON file. A typical file might have, for instance:
| 'ne_shaded' : Natural Earth Shaded Relief
| 'ne_grey' : Natural Earth Grey Earth.
| resolution: optional
| The resolution of the image to read, according to
| the contents of the JSON file. A typical file might
| have the following for each name of the image:
| 'low', 'med', 'high', 'vhigh', 'full'.
| extent: optional
| Using a high resolution background image zoomed into
| a small area will take a very long time to render as
| the image is prepared globally, even though only a small
| area is used. Adding the extent will only render a
| particular geographic region. Specified as
| [longitude start, longitude end,
| latitude start, latitude end].
|
| e.g. [-11, 3, 48, 60] for the UK
| or [167.0, 193.0, 47.0, 68.0] to cross the date line.
|
| cache: optional
| Logical flag as to whether or not to cache the loaded
| images into memory. The images are stored before the
| extent is used.
|
| barbs(self, x, y, u, v, *args, **kwargs)
| Plot a field of barbs.
|
| Parameters
| ----------
| x
| An array containing the x-positions of data points.
| y
| An array containing the y-positions of data points.
| u
| An array of vector data in the u-direction.
| v
| An array of vector data in the v-direction.
|
| Other Parameters
| ----------------
| transform: :class:`cartopy.crs.Projection` or Matplotlib transform
| The coordinate system in which the vectors are defined.
| regrid_shape: int or 2-tuple of ints
| If given, specifies that the points where the barbs are
| located will be interpolated onto a regular grid in
| projection space. If a single integer is given then that
| will be used as the minimum grid length dimension, while the
| other dimension will be scaled up according to the target
| extent's aspect ratio. If a pair of ints are given they
| determine the grid length in the x and y directions
| respectively.
| target_extent: 4-tuple
| If given, specifies the extent in the target CRS that the
| regular grid defined by *regrid_shape* will have. Defaults
| to the current extent of the map projection.
|
|
| See :func:`matplotlib.pyplot.barbs` for details on arguments
| and other keyword arguments.
|
| Note
| ----
| The vector components must be defined as grid eastward and
| grid northward.
|
| cla(self)
| Clear the current axes and adds boundary lines.
|
| coastlines(self, resolution='110m', color='black', **kwargs)
| Add coastal **outlines** to the current axes from the Natural Earth
| "coastline" shapefile collection.
|
| Parameters
| ----------
| resolution
| A named resolution to use from the Natural Earth
| dataset. Currently can be one of "110m", "50m", and "10m".
|
| contour(self, *args, **kwargs)
| Add the "transform" keyword to :func:`~matplotlib.pyplot.contour'.
|
| Other Parameters
| ----------------
| transform
| A :class:`~cartopy.crs.Projection`.
|
| contourf(self, *args, **kwargs)
| Add the "transform" keyword to :func:`~matplotlib.pyplot.contourf'.
|
| Other Parameters
| ----------------
| transform
| A :class:`~cartopy.crs.Projection`.
|
| draw(self, renderer=None, inframe=False)
| Extend the standard behaviour of :func:`matplotlib.axes.Axes.draw`.
|
| Draw grid lines and image factory results before invoking standard
| Matplotlib drawing. A global range is used if no limits have yet
| been set.
|
| format_coord(self, x, y)
| Returns
| -------
| A string formatted for the Matplotlib GUI status bar.
|
| get_extent(self, crs=None)
| Get the extent (x0, x1, y0, y1) of the map in the given coordinate
| system.
|
| If no crs is given, the returned extents' coordinate system will be
| the CRS of this Axes.
|
| gridlines(self, crs=None, draw_labels=False, xlocs=None, ylocs=None, **kwargs)
| Automatically add gridlines to the axes, in the given coordinate
| system, at draw time.
|
| Parameters
| ----------
| crs: optional
| The :class:`cartopy._crs.CRS` defining the coordinate system in
| which gridlines are drawn.
| Defaults to :class:`cartopy.crs.PlateCarree`.
| draw_labels: optional
| Label gridlines like axis ticks, around the edge.
| xlocs: optional
| An iterable of gridline locations or a
| :class:`matplotlib.ticker.Locator` instance which will be
| used to determine the locations of the gridlines in the
| x-coordinate of the given CRS. Defaults to None, which
| implies automatic locating of the gridlines.
| ylocs: optional
| An iterable of gridline locations or a
| :class:`matplotlib.ticker.Locator` instance which will be
| used to determine the locations of the gridlines in the
| y-coordinate of the given CRS. Defaults to None, which
| implies automatic locating of the gridlines.
|
| Returns
| -------
| gridliner
| A :class:`cartopy.mpl.gridliner.Gridliner` instance.
|
| Note
| ----
| All other keywords control line properties. These are passed
| through to :class:`matplotlib.collections.Collection`.
|
| hold_limits(self, hold=True)
| Keep track of the original view and data limits for the life of this
| context manager, optionally reverting any changes back to the original
| values after the manager exits.
|
| Parameters
| ----------
| hold: bool, optional
| Whether to revert the data and view limits after the
| context manager exits. Defaults to True.
|
| imshow(self, img, *args, **kwargs)
| Add the "transform" keyword to :func:`~matplotlib.pyplot.imshow'.
|
| Parameters
| ----------
| img
| The image to be displayed.
|
| Other Parameters
| ----------------
| transform: :class:`~cartopy.crs.Projection` or matplotlib transform
| The coordinate system in which the given image is
| rectangular.
| regrid_shape: int or pair of ints
| The shape of the desired image if it needs to be
| transformed. If a single integer is given then
| that will be used as the minimum length dimension,
| while the other dimension will be scaled up
| according to the target extent's aspect ratio.
| The default is for the minimum dimension of a
| transformed image to have length 750, so for an
| image being transformed into a global PlateCarree
| projection the resulting transformed image would
| have a shape of ``(750, 1500)``.
| extent: tuple
| The corner coordinates of the image in the form
| ``(left, right, bottom, top)``. The coordinates should
| be in the coordinate system passed to the transform
| keyword.
| origin: {'lower', 'upper'}
| The origin of the vertical pixels. See
| :func:`matplotlib.pyplot.imshow` for further details.
| Default is ``'lower'``.
|
| natural_earth_shp(self, name='land', resolution='110m', category='physical', **kwargs)
| Add the geometries from the specified Natural Earth shapefile to the
| Axes as a :class:`~matplotlib.collections.PathCollection`.
|
| Parameters
| ----------
| name: optional
| Name of the shapefile geometry to add. Defaults to 'land'.
| resolution: optional
| Resolution of shapefile geometry to add. Defaults to '110m'.
| category: optional
| Category of shapefile geometry to add. Defaults to 'physical'.
|
|
| ``**kwargs`` are passed through to the
| :class:`~matplotlib.collections.PathCollection` constructor.
|
| Returns
| -------
| The created :class:`~matplotlib.collections.PathCollection`.
|
| pcolor(self, *args, **kwargs)
| Add the "transform" keyword to :func:`~matplotlib.pyplot.pcolor'.
|
| Other Parameters
| ----------------
| transform
| A :class:`~cartopy.crs.Projection`.
|
| pcolormesh(self, *args, **kwargs)
| Add the "transform" keyword to :func:`~matplotlib.pyplot.pcolormesh'.
|
| Other Parameters
| ----------------
| transform
| A :class:`~cartopy.crs.Projection`.
|
| quiver(self, x, y, u, v, *args, **kwargs)
| Plot a field of arrows.
|
| Parameters
| ----------
| x
| An array containing the x-positions of data points.
| y
| An array containing the y-positions of data points.
| u
| An array of vector data in the u-direction.
| v
| An array of vector data in the v-direction.
|
| Other Parameters
| ----------------
| transform: :class:`cartopy.crs.Projection` or Matplotlib transform
| The coordinate system in which the vectors are defined.
| regrid_shape: int or 2-tuple of ints
| If given, specifies that the points where the arrows are
| located will be interpolated onto a regular grid in
| projection space. If a single integer is given then that
| will be used as the minimum grid length dimension, while the
| other dimension will be scaled up according to the target
| extent's aspect ratio. If a pair of ints are given they
| determine the grid length in the x and y directions
| respectively.
| target_extent: 4-tuple
| If given, specifies the extent in the target CRS that the
| regular grid defined by *regrid_shape* will have. Defaults
| to the current extent of the map projection.
|
|
| See :func:`matplotlib.pyplot.quiver` for details on arguments
| and other keyword arguments.
|
| Note
| ----
| The vector components must be defined as grid eastward and
| grid northward.
|
| read_user_background_images(self, verify=True)
| Read the metadata in the specified CARTOPY_USER_BACKGROUNDS
| environment variable to populate the dictionaries for background_img.
|
| If CARTOPY_USER_BACKGROUNDS is not set then by default the image in
| lib/cartopy/data/raster/natural_earth/ will be made available.
|
| The metadata should be a standard JSON file which specifies a two
| level dictionary. The first level is the image type.
| For each image type there must be the fields:
| __comment__, __source__ and __projection__
| and then an element giving the filename for each resolution.
|
| An example JSON file can be found at:
| lib/cartopy/data/raster/natural_earth/images.json
|
| scatter(self, *args, **kwargs)
| Add the "transform" keyword to :func:`~matplotlib.pyplot.scatter'.
|
| Other Parameters
| ----------------
| transform
| A :class:`~cartopy.crs.Projection`.
|
| set_boundary(self, path, transform=None, use_as_clip_path=True)
| Given a path, update the :data:`.outline_patch` and
| :data:`.background_patch` to take its shape.
|
| Parameters
| ----------
| path: :class:`matplotlib.path.Path`
| The path of the desired boundary.
| transform: None or :class:`matplotlib.transforms.Transform`, optional
| The coordinate system of the given path. Currently
| this must be convertible to data coordinates, and
| therefore cannot extend beyond the limits of the
| axes' projection.
| use_as_clip_path : bool, optional
| Whether axes.patch should be updated.
| Updating axes.patch means that any artists
| subsequently created will inherit clipping
| from this path, rather than the standard unit
| square in axes coordinates.
|
| set_extent(self, extents, crs=None)
| Set the extent (x0, x1, y0, y1) of the map in the given
| coordinate system.
|
| If no crs is given, the extents' coordinate system will be assumed
| to be the Geodetic version of this axes' projection.
|
| Parameters
| ----------
| extent
| Tuple of floats representing the required extent (x0, x1, y0, y1).
|
| set_global(self)
| Set the extent of the Axes to the limits of the projection.
|
| Note
| ----
| In some cases where the projection has a limited sensible range
| the ``set_global`` method does not actually make the whole globe
| visible. Instead, the most appropriate extents will be used (e.g.
| Ordnance Survey UK will set the extents to be around the British
| Isles.
|
| set_xticks(self, ticks, minor=False, crs=None)
| Set the x ticks.
|
| Parameters
| ----------
| ticks
| List of floats denoting the desired position of x ticks.
| minor: optional
| flag indicating whether the ticks should be minor
| ticks i.e. small and unlabelled (defaults to False).
| crs: optional
| An instance of :class:`~cartopy.crs.CRS` indicating the
| coordinate system of the provided tick values. If no
| coordinate system is specified then the values are assumed
| to be in the coordinate system of the projection.
| Only transformations from one rectangular coordinate system
| to another rectangular coordinate system are supported (defaults
| to None).
|
| Note
| ----
| This interface is subject to change whilst functionality is added
| to support other map projections.
|
| set_yticks(self, ticks, minor=False, crs=None)
| Set the y ticks.
|
| Parameters
| ----------
| ticks
| List of floats denoting the desired position of y ticks.
| minor: optional
| flag indicating whether the ticks should be minor
| ticks i.e. small and unlabelled (defaults to False).
| crs: optional
| An instance of :class:`~cartopy.crs.CRS` indicating the
| coordinate system of the provided tick values. If no
| coordinate system is specified then the values are assumed
| to be in the coordinate system of the projection.
| Only transformations from one rectangular coordinate system
| to another rectangular coordinate system are supported (defaults
| to None).
|
| Note
| ----
| This interface is subject to change whilst functionality is added
| to support other map projections.
|
| stock_img(self, name='ne_shaded')
| Add a standard image to the map.
|
| Currently, the only (and default) option is a downsampled version of
| the Natural Earth shaded relief raster.
|
| streamplot(self, x, y, u, v, **kwargs)
| Plot streamlines of a vector flow.
|
| Parameters
| ----------
| x
| An array containing the x-positions of data points.
| y
| An array containing the y-positions of data points.
| u
| An array of vector data in the u-direction.
| v
| An array of vector data in the v-direction.
|
| Other Parameters
| ----------------
| transform: :class:`cartopy.crs.Projection` or Matplotlib transform.
| The coordinate system in which the vector field is defined.
|
|
| See :func:`matplotlib.pyplot.streamplot` for details on arguments
| and keyword arguments.
|
| Note
| ----
| The vector components must be defined as grid eastward and
| grid northward.
|
| tissot(self, rad_km=500, lons=None, lats=None, n_samples=80, **kwargs)
| Add Tissot's indicatrices to the axes.
|
| Parameters
| ----------
| rad_km
| The radius in km of the the circles to be drawn.
| lons
| A numpy.ndarray, list or tuple of longitude values that
| locate the centre of each circle. Specifying more than one
| dimension allows individual points to be drawn whereas a
| 1D array produces a grid of points.
| lats
| A numpy.ndarray, list or tuple of latitude values that
| that locate the centre of each circle. See lons.
| n_samples
| Integer number of points sampled around the circumference of
| each circle.
|
|
| ``**kwargs`` are passed through to `class:ShapelyFeature`.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.axes._axes.Axes:
|
| acorr(self, x, *, data=None, **kwargs)
| Plot the autocorrelation of *x*.
|
| Parameters
| ----------
|
| x : sequence of scalar
|
| hold : bool, optional, *deprecated*, default: True
|
| detrend : callable, optional, default: `mlab.detrend_none`
| *x* is detrended by the *detrend* callable. Default is no
| normalization.
|
| normed : bool, optional, default: True
| If ``True``, input vectors are normalised to unit length.
|
| usevlines : bool, optional, default: True
| If ``True``, `Axes.vlines` is used to plot the vertical lines from
| the origin to the acorr. Otherwise, `Axes.plot` is used.
|
| maxlags : integer, optional, default: 10
| Number of lags to show. If ``None``, will return all
| ``2 * len(x) - 1`` lags.
|
| Returns
| -------
| lags : array (lenth ``2*maxlags+1``)
| lag vector.
| c : array (length ``2*maxlags+1``)
| auto correlation vector.
| line : `.LineCollection` or `.Line2D`
| `.Artist` added to the axes of the correlation.
|
| `.LineCollection` if *usevlines* is True
| `.Line2D` if *usevlines* is False
| b : `.Line2D` or None
| Horizontal line at 0 if *usevlines* is True
| None *usevlines* is False
|
| Other Parameters
| ----------------
| linestyle : `~matplotlib.lines.Line2D` prop, optional, default: None
| Only used if usevlines is ``False``.
|
| marker : string, optional, default: 'o'
|
| Notes
| -----
| The cross correlation is performed with :func:`numpy.correlate` with
| ``mode = 2``.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x'.
|
| angle_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)
| Plot the angle spectrum.
|
| Call signature::
|
| angle_spectrum(x, Fs=2, Fc=0, window=mlab.window_hanning,
| pad_to=None, sides='default', **kwargs)
|
| Compute the angle spectrum (wrapped phase spectrum) of *x*.
| Data is padded to a length of *pad_to* and the windowing function
| *window* is applied to the signal.
|
| Parameters
| ----------
| x : 1-D array or sequence
| Array or sequence containing the data
|
| Fs : scalar
| The sampling frequency (samples per time unit). It is used
| to calculate the Fourier frequencies, freqs, in cycles per time
| unit. The default value is 2.
|
| window : callable or ndarray
| A function or a vector of length *NFFT*. To create window
| vectors see :func:`window_hanning`, :func:`window_none`,
| :func:`numpy.blackman`, :func:`numpy.hamming`,
| :func:`numpy.bartlett`, :func:`scipy.signal`,
| :func:`scipy.signal.get_window`, etc. The default is
| :func:`window_hanning`. 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' ]
| Specifies which sides of the spectrum to return. Default gives the
| default behavior, which returns one-sided for real data and both
| for complex data. 'onesided' forces the return of a one-sided
| spectrum, while 'twosided' forces two-sided.
|
| pad_to : integer
| 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).
|
| Fc : integer
| The center frequency of *x* (defaults to 0), 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
| -------
| spectrum : 1-D array
| The values for the angle spectrum in radians (real valued)
|
| freqs : 1-D array
| The frequencies corresponding to the elements in *spectrum*
|
| line : a :class:`~matplotlib.lines.Line2D` instance
| The line created by this function
|
| Other Parameters
| ----------------
| **kwargs :
| Keyword arguments control the :class:`~matplotlib.lines.Line2D`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| See Also
| --------
| :func:`magnitude_spectrum`
| :func:`angle_spectrum` plots the magnitudes of the corresponding
| frequencies.
|
| :func:`phase_spectrum`
| :func:`phase_spectrum` plots the unwrapped version of this
| function.
|
| :func:`specgram`
| :func:`specgram` can plot the angle spectrum of segments within the
| signal in a colormap.
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x'.
|
| annotate(self, *args, **kwargs)
| Annotate the point ``xy`` with text ``s``.
|
| Additional kwargs are passed to `~matplotlib.text.Text`.
|
| Parameters
| ----------
|
| s : str
| The text of the annotation
|
| xy : iterable
| Length 2 sequence specifying the *(x,y)* point to annotate
|
| xytext : iterable, optional
| Length 2 sequence specifying the *(x,y)* to place the text
| at. If None, defaults to ``xy``.
|
| xycoords : str, Artist, Transform, callable or tuple, optional
|
| The coordinate system that ``xy`` is given in.
|
| For a `str` the allowed values are:
|
| ================= ===============================================
| Property Description
| ================= ===============================================
| 'figure points' points from the lower left of the figure
| 'figure pixels' pixels from the lower left of the figure
| 'figure fraction' fraction of figure from lower left
| 'axes points' points from lower left corner of axes
| 'axes pixels' pixels from lower left corner of axes
| 'axes fraction' fraction of axes from lower left
| 'data' use the coordinate system of the object being
| annotated (default)
| 'polar' *(theta,r)* if not native 'data' coordinates
| ================= ===============================================
|
| If a `~matplotlib.artist.Artist` object is passed in the units are
| fraction if it's bounding box.
|
| If a `~matplotlib.transforms.Transform` object is passed
| in use that to transform ``xy`` to screen coordinates
|
| If a callable it must take a
| `~matplotlib.backend_bases.RendererBase` object as input
| and return a `~matplotlib.transforms.Transform` or
| `~matplotlib.transforms.Bbox` object
|
| If a `tuple` must be length 2 tuple of str, `Artist`,
| `Transform` or callable objects. The first transform is
| used for the *x* coordinate and the second for *y*.
|
| See :ref:`plotting-guide-annotation` for more details.
|
| Defaults to ``'data'``
|
| textcoords : str, `Artist`, `Transform`, callable or tuple, optional
| The coordinate system that ``xytext`` is given, which
| may be different than the coordinate system used for
| ``xy``.
|
| All ``xycoords`` values are valid as well as the following
| strings:
|
| ================= =========================================
| Property Description
| ================= =========================================
| 'offset points' offset (in points) from the *xy* value
| 'offset pixels' offset (in pixels) from the *xy* value
| ================= =========================================
|
| defaults to the input of ``xycoords``
|
| arrowprops : dict, optional
| If not None, properties used to draw a
| `~matplotlib.patches.FancyArrowPatch` arrow between ``xy`` and
| ``xytext``.
|
| If `arrowprops` does not contain the key ``'arrowstyle'`` the
| allowed keys are:
|
| ========== ======================================================
| Key Description
| ========== ======================================================
| width the width of the arrow in points
| headwidth the width of the base of the arrow head in points
| headlength the length of the arrow head in points
| shrink fraction of total length to 'shrink' from both ends
| ? any key to :class:`matplotlib.patches.FancyArrowPatch`
| ========== ======================================================
|
| If the `arrowprops` contains the key ``'arrowstyle'`` the
| above keys are forbidden. The allowed values of
| ``'arrowstyle'`` are:
|
| ============ =============================================
| Name Attrs
| ============ =============================================
| ``'-'`` None
| ``'->'`` head_length=0.4,head_width=0.2
| ``'-['`` widthB=1.0,lengthB=0.2,angleB=None
| ``'|-|'`` widthA=1.0,widthB=1.0
| ``'-|>'`` head_length=0.4,head_width=0.2
| ``'<-'`` head_length=0.4,head_width=0.2
| ``'<->'`` head_length=0.4,head_width=0.2
| ``'<|-'`` head_length=0.4,head_width=0.2
| ``'<|-|>'`` head_length=0.4,head_width=0.2
| ``'fancy'`` head_length=0.4,head_width=0.4,tail_width=0.4
| ``'simple'`` head_length=0.5,head_width=0.5,tail_width=0.2
| ``'wedge'`` tail_width=0.3,shrink_factor=0.5
| ============ =============================================
|
| Valid keys for `~matplotlib.patches.FancyArrowPatch` are:
|
| =============== ==================================================
| Key Description
| =============== ==================================================
| arrowstyle the arrow style
| connectionstyle the connection style
| relpos default is (0.5, 0.5)
| patchA default is bounding box of the text
| patchB default is None
| shrinkA default is 2 points
| shrinkB default is 2 points
| mutation_scale default is text size (in points)
| mutation_aspect default is 1.
| ? any key for :class:`matplotlib.patches.PathPatch`
| =============== ==================================================
|
| Defaults to None
|
| annotation_clip : bool, optional
| Controls the visibility of the annotation when it goes
| outside the axes area.
|
| If `True`, the annotation will only be drawn when the
| ``xy`` is inside the axes. If `False`, the annotation will
| always be drawn regardless of its position.
|
| The default is `None`, which behave as `True` only if
| *xycoords* is "data".
|
| Returns
| -------
| Annotation
|
| arrow(self, x, y, dx, dy, **kwargs)
| Add an arrow to the axes.
|
| This draws an arrow from ``(x, y)`` to ``(x+dx, y+dy)``.
|
| Parameters
| ----------
| x, y : float
| The x/y-coordinate of the arrow base.
| dx, dy : float
| The length of the arrow along x/y-direction.
|
| Returns
| -------
| arrow : `.FancyArrow`
| The created `.FancyArrow` object.
|
| Other Parameters
| ----------------
| **kwargs
| Optional kwargs (inherited from `.FancyArrow` patch) control the
| arrow construction and properties:
|
| Constructor arguments
| *width*: float (default: 0.001)
| width of full arrow tail
|
| *length_includes_head*: bool (default: False)
| True if head is to be counted in calculating the length.
|
| *head_width*: float or None (default: 3*width)
| total width of the full arrow head
|
| *head_length*: float or None (default: 1.5 * head_width)
| length of arrow head
|
| *shape*: ['full', 'left', 'right'] (default: 'full')
| draw the left-half, right-half, or full arrow
|
| *overhang*: float (default: 0)
| fraction that the arrow is swept back (0 overhang means
| triangular shape). Can be negative or greater than one.
|
| *head_starts_at_zero*: bool (default: False)
| if True, the head starts being drawn at coordinate 0
| instead of ending at coordinate 0.
|
| Other valid kwargs (inherited from :class:`Patch`) are:
| 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: float or None
| animated: bool
| antialiased or aa: bool or None
| capstyle: ['butt' | 'round' | 'projecting']
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color: matplotlib color spec
| contains: a callable function
| edgecolor or ec: mpl color spec, None, 'none', or 'auto'
| facecolor or fc: mpl color spec, or None for default, or 'none' for no color
| figure: a `.Figure` instance
| fill: bool
| gid: an id string
| hatch: ['/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*']
| joinstyle: ['miter' | 'round' | 'bevel']
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float or None for default
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| visible: bool
| zorder: float
|
| Notes
| -----
| The resulting arrow is affected by the axes aspect ratio and limits.
| This may produce an arrow whose head is not square with its stem. To
| create an arrow whose head is square with its stem,
| use :meth:`annotate` for example:
|
| >>> ax.annotate("", xy=(0.5, 0.5), xytext=(0, 0),
| ... arrowprops=dict(arrowstyle="->"))
|
| axhline(self, y=0, xmin=0, xmax=1, **kwargs)
| Add a horizontal line across the axis.
|
| Parameters
| ----------
| y : scalar, optional, default: 0
| y position in data coordinates of the horizontal line.
|
| xmin : scalar, optional, default: 0
| Should be between 0 and 1, 0 being the far left of the plot, 1 the
| far right of the plot.
|
| xmax : scalar, optional, default: 1
| Should be between 0 and 1, 0 being the far left of the plot, 1 the
| far right of the plot.
|
| Returns
| -------
| :class:`~matplotlib.lines.Line2D`
|
| Other Parameters
| ----------------
| **kwargs :
| Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,
| with the exception of 'transform':
|
| 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: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| See also
| --------
| hlines : Add horizontal lines in data coordinates.
| axhspan : Add a horizontal span (rectangle) across the axis.
|
| Examples
| --------
|
| * draw a thick red hline at 'y' = 0 that spans the xrange::
|
| >>> axhline(linewidth=4, color='r')
|
| * draw a default hline at 'y' = 1 that spans the xrange::
|
| >>> axhline(y=1)
|
| * draw a default hline at 'y' = .5 that spans the middle half of
| the xrange::
|
| >>> axhline(y=.5, xmin=0.25, xmax=0.75)
|
| axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs)
| Add a horizontal span (rectangle) across the axis.
|
| Draw a horizontal span (rectangle) from *ymin* to *ymax*.
| With the default values of *xmin* = 0 and *xmax* = 1, this
| always spans the xrange, regardless of the xlim settings, even
| if you change them, e.g., with the :meth:`set_xlim` command.
| That is, the horizontal extent is in axes coords: 0=left,
| 0.5=middle, 1.0=right but the *y* location is in data
| coordinates.
|
| Parameters
| ----------
| ymin : float
| Lower limit of the horizontal span in data units.
| ymax : float
| Upper limit of the horizontal span in data units.
| xmin : float, optional, default: 0
| Lower limit of the vertical span in axes (relative
| 0-1) units.
| xmax : float, optional, default: 1
| Upper limit of the vertical span in axes (relative
| 0-1) units.
|
| Returns
| -------
| Polygon : `~matplotlib.patches.Polygon`
|
| Other Parameters
| ----------------
| **kwargs : `~matplotlib.patches.Polygon` 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
| alpha: float or None
| animated: bool
| antialiased or aa: bool or None
| capstyle: ['butt' | 'round' | 'projecting']
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color: matplotlib color spec
| contains: a callable function
| edgecolor or ec: mpl color spec, None, 'none', or 'auto'
| facecolor or fc: mpl color spec, or None for default, or 'none' for no color
| figure: a `.Figure` instance
| fill: bool
| gid: an id string
| hatch: ['/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*']
| joinstyle: ['miter' | 'round' | 'bevel']
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float or None for default
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| visible: bool
| zorder: float
|
| See Also
| --------
| axvspan : Add a vertical span across the axes.
|
| axvline(self, x=0, ymin=0, ymax=1, **kwargs)
| Add a vertical line across the axes.
|
| Parameters
| ----------
| x : scalar, optional, default: 0
| x position in data coordinates of the vertical line.
|
| ymin : scalar, optional, default: 0
| Should be between 0 and 1, 0 being the bottom of the plot, 1 the
| top of the plot.
|
| ymax : scalar, optional, default: 1
| Should be between 0 and 1, 0 being the bottom of the plot, 1 the
| top of the plot.
|
| Returns
| -------
| :class:`~matplotlib.lines.Line2D`
|
| Other Parameters
| ----------------
| **kwargs :
| Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,
| with the exception of 'transform':
|
| 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: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| Examples
| --------
| * draw a thick red vline at *x* = 0 that spans the yrange::
|
| >>> axvline(linewidth=4, color='r')
|
| * draw a default vline at *x* = 1 that spans the yrange::
|
| >>> axvline(x=1)
|
| * draw a default vline at *x* = .5 that spans the middle half of
| the yrange::
|
| >>> axvline(x=.5, ymin=0.25, ymax=0.75)
|
| See also
| --------
| vlines : Add vertical lines in data coordinates.
| axvspan : Add a vertical span (rectangle) across the axis.
|
| axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs)
| Add a vertical span (rectangle) across the axes.
|
| Draw a vertical span (rectangle) from `xmin` to `xmax`. With
| the default values of `ymin` = 0 and `ymax` = 1. This always
| spans the yrange, regardless of the ylim settings, even if you
| change them, e.g., with the :meth:`set_ylim` command. That is,
| the vertical extent is in axes coords: 0=bottom, 0.5=middle,
| 1.0=top but the y location is in data coordinates.
|
| Parameters
| ----------
| xmin : scalar
| Number indicating the first X-axis coordinate of the vertical
| span rectangle in data units.
| xmax : scalar
| Number indicating the second X-axis coordinate of the vertical
| span rectangle in data units.
| ymin : scalar, optional
| Number indicating the first Y-axis coordinate of the vertical
| span rectangle in relative Y-axis units (0-1). Default to 0.
| ymax : scalar, optional
| Number indicating the second Y-axis coordinate of the vertical
| span rectangle in relative Y-axis units (0-1). Default to 1.
|
| Returns
| -------
| rectangle : matplotlib.patches.Polygon
| Vertical span (rectangle) from (xmin, ymin) to (xmax, ymax).
|
| Other Parameters
| ----------------
| **kwargs
| Optional parameters are properties of the class
| matplotlib.patches.Polygon.
|
| See Also
| --------
| axhspan : Add a horizontal span across the axes.
|
| Examples
| --------
| Draw a vertical, green, translucent rectangle from x = 1.25 to
| x = 1.55 that spans the yrange of the axes.
|
| >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)
|
| bar(self, *args, data=None, **kwargs)
| Make a bar plot.
|
| Call signatures::
|
| bar(x, height, *, align='center', **kwargs)
| bar(x, height, width, *, align='center', **kwargs)
| bar(x, height, width, bottom, *, align='center', **kwargs)
|
| The bars are positioned at *x* with the given *align* ment. Their
| dimensions are given by *width* and *height*. The vertical baseline
| is *bottom* (default 0).
|
| Each of *x*, *height*, *width*, and *bottom* may either be a scalar
| applying to all bars, or it may be a sequence of length N providing a
| separate value for each bar.
|
|
| Parameters
| ----------
| x : sequence of scalars
| The x coordinates of the bars. See also *align* for the
| alignment of the bars to the coordinates.
|
| height : scalar or sequence of scalars
| The height(s) of the bars.
|
| width : scalar or array-like, optional
| The width(s) of the bars (default: 0.8).
|
| bottom : scalar or array-like, optional
| The y coordinate(s) of the bars bases (default: 0).
|
| align : {'center', 'edge'}, optional, default: 'center'
| Alignment of the bars to the *x* coordinates:
|
| - 'center': Center the base on the *x* positions.
| - 'edge': Align the left edges of the bars with the *x* positions.
|
| To align the bars on the right edge pass a negative *width* and
| ``align='edge'``.
|
| Returns
| -------
| `.BarContainer`
| Container with all the bars and optionally errorbars.
|
| Other Parameters
| ----------------
| color : scalar or array-like, optional
| The colors of the bar faces.
|
| edgecolor : scalar or array-like, optional
| The colors of the bar edges.
|
| linewidth : scalar or array-like, optional
| Width of the bar edge(s). If 0, don't draw edges.
|
| tick_label : string or array-like, optional
| The tick labels of the bars.
| Default: None (Use default numeric labels.)
|
| xerr, yerr : scalar or array-like of shape(N,) or shape(2,N), optional
| If not *None*, add horizontal / vertical errorbars to the bar tips.
| The values are +/- sizes relative to the data:
|
| - scalar: symmetric +/- values for all bars
| - shape(N,): symmetric +/- values for each bar
| - shape(2,N): separate + and - values for each bar
|
| Default: None
|
| ecolor : scalar or array-like, optional, default: 'black'
| The line color of the errorbars.
|
| capsize : scalar, optional
| The length of the error bar caps in points.
| Default: None, which will take the value from
| :rc:`errorbar.capsize`.
|
| error_kw : dict, optional
| Dictionary of kwargs to be passed to the `~.Axes.errorbar`
| method. Values of *ecolor* or *capsize* defined here take
| precedence over the independent kwargs.
|
| log : bool, optional, default: False
| If *True*, set the y-axis to be log scale.
|
| orientation : {'vertical', 'horizontal'}, optional
| *This is for internal use only.* Please use `barh` for
| horizontal bar plots. Default: 'vertical'.
|
| See also
| --------
| barh: Plot a horizontal bar plot.
|
| Notes
| -----
| The optional arguments *color*, *edgecolor*, *linewidth*,
| *xerr*, and *yerr* can be either scalars or sequences of
| length equal to the number of bars. This enables you to use
| bar as the basis for stacked bar charts, or candlestick plots.
| Detail: *xerr* and *yerr* are passed directly to
| :meth:`errorbar`, so they can also have shape 2xN for
| independent specification of lower and upper errors.
|
| Other optional kwargs:
|
| 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: float or None
| animated: bool
| antialiased or aa: bool or None
| capstyle: ['butt' | 'round' | 'projecting']
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color: matplotlib color spec
| contains: a callable function
| edgecolor or ec: mpl color spec, None, 'none', or 'auto'
| facecolor or fc: mpl color spec, or None for default, or 'none' for no color
| figure: a `.Figure` instance
| fill: bool
| gid: an id string
| hatch: ['/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*']
| joinstyle: ['miter' | 'round' | 'bevel']
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float or None for default
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| visible: bool
| zorder: float
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'bottom', 'color', 'ecolor', 'edgecolor', 'height', 'left', 'linewidth', 'tick_label', 'width', 'x', 'xerr', 'y', 'yerr'.
| * All positional arguments.
|
| barh(self, *args, **kwargs)
| Make a horizontal bar plot.
|
| Call signatures::
|
| bar(y, width, *, align='center', **kwargs)
| bar(y, width, height, *, align='center', **kwargs)
| bar(y, width, height, left, *, align='center', **kwargs)
|
| The bars are positioned at *y* with the given *align*. Their
| dimensions are given by *width* and *height*. The horizontal baseline
| is *left* (default 0).
|
| Each of *y*, *width*, *height*, and *left* may either be a scalar
| applying to all bars, or it may be a sequence of length N providing a
| separate value for each bar.
|
|
| Parameters
| ----------
| y : scalar or array-like
| The y coordinates of the bars. See also *align* for the
| alignment of the bars to the coordinates.
|
| width : scalar or array-like
| The width(s) of the bars.
|
| height : sequence of scalars, optional, default: 0.8
| The heights of the bars.
|
| left : sequence of scalars
| The x coordinates of the left sides of the bars (default: 0).
|
| align : {'center', 'edge'}, optional, default: 'center'
| Alignment of the base to the *y* coordinates*:
|
| - 'center': Center the bars on the *y* positions.
| - 'edge': Align the bottom edges of the bars with the *y*
| positions.
|
| To align the bars on the top edge pass a negative *height* and
| ``align='edge'``.
|
| Returns
| -------
| `.BarContainer`
| Container with all the bars and optionally errorbars.
|
| Other Parameters
| ----------------
| color : scalar or array-like, optional
| The colors of the bar faces.
|
| edgecolor : scalar or array-like, optional
| The colors of the bar edges.
|
| linewidth : scalar or array-like, optional
| Width of the bar edge(s). If 0, don't draw edges.
|
| tick_label : string or array-like, optional
| The tick labels of the bars.
| Default: None (Use default numeric labels.)
|
| xerr, yerr : scalar or array-like of shape(N,) or shape(2,N), optional
| If not ``None``, add horizontal / vertical errorbars to the
| bar tips. The values are +/- sizes relative to the data:
|
| - scalar: symmetric +/- values for all bars
| - shape(N,): symmetric +/- values for each bar
| - shape(2,N): separate + and - values for each bar
|
| Default: None
|
| ecolor : scalar or array-like, optional, default: 'black'
| The line color of the errorbars.
|
| capsize : scalar, optional
| The length of the error bar caps in points.
| Default: None, which will take the value from
| :rc:`errorbar.capsize`.
|
| error_kw : dict, optional
| Dictionary of kwargs to be passed to the `~.Axes.errorbar`
| method. Values of *ecolor* or *capsize* defined here take
| precedence over the independent kwargs.
|
| log : bool, optional, default: False
| If ``True``, set the x-axis to be log scale.
|
| See also
| --------
| bar: Plot a vertical bar plot.
|
| Notes
| -----
| The optional arguments *color*, *edgecolor*, *linewidth*,
| *xerr*, and *yerr* can be either scalars or sequences of
| length equal to the number of bars. This enables you to use
| bar as the basis for stacked bar charts, or candlestick plots.
| Detail: *xerr* and *yerr* are passed directly to
| :meth:`errorbar`, so they can also have shape 2xN for
| independent specification of lower and upper errors.
|
| Other optional kwargs:
|
| 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: float or None
| animated: bool
| antialiased or aa: bool or None
| capstyle: ['butt' | 'round' | 'projecting']
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color: matplotlib color spec
| contains: a callable function
| edgecolor or ec: mpl color spec, None, 'none', or 'auto'
| facecolor or fc: mpl color spec, or None for default, or 'none' for no color
| figure: a `.Figure` instance
| fill: bool
| gid: an id string
| hatch: ['/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*']
| joinstyle: ['miter' | 'round' | 'bevel']
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float or None for default
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| visible: bool
| zorder: float
|
| boxplot(self, x, notch=None, sym=None, vert=None, whis=None, positions=None, widths=None, patch_artist=None, bootstrap=None, usermedians=None, conf_intervals=None, meanline=None, showmeans=None, showcaps=None, showbox=None, showfliers=None, boxprops=None, labels=None, flierprops=None, medianprops=None, meanprops=None, capprops=None, whiskerprops=None, manage_xticks=True, autorange=False, zorder=None, *, data=None)
| Make a box and whisker plot.
|
| Make a box and whisker plot for each column of ``x`` or each
| vector in sequence ``x``. The box extends from the lower to
| upper quartile values of the data, with a line at the median.
| The whiskers extend from the box to show the range of the
| data. Flier points are those past the end of the whiskers.
|
| Parameters
| ----------
| x : Array or a sequence of vectors.
| The input data.
|
| notch : bool, optional (False)
| If `True`, will produce a notched box plot. Otherwise, a
| rectangular boxplot is produced. The notches represent the
| confidence interval (CI) around the median. See the entry
| for the ``bootstrap`` parameter for information regarding
| how the locations of the notches are computed.
|
| .. note::
|
| In cases where the values of the CI are less than the
| lower quartile or greater than the upper quartile, the
| notches will extend beyond the box, giving it a
| distinctive "flipped" appearance. This is expected
| behavior and consistent with other statistical
| visualization packages.
|
| sym : str, optional
| The default symbol for flier points. Enter an empty string
| ('') if you don't want to show fliers. If `None`, then the
| fliers default to 'b+' If you want more control use the
| flierprops kwarg.
|
| vert : bool, optional (True)
| If `True` (default), makes the boxes vertical. If `False`,
| everything is drawn horizontally.
|
| whis : float, sequence, or string (default = 1.5)
| As a float, determines the reach of the whiskers to the beyond the
| first and third quartiles. In other words, where IQR is the
| interquartile range (`Q3-Q1`), the upper whisker will extend to
| last datum less than `Q3 + whis*IQR`). Similarly, the lower whisker
| will extend to the first datum greater than `Q1 - whis*IQR`.
| Beyond the whiskers, data
| are considered outliers and are plotted as individual
| points. Set this to an unreasonably high value to force the
| whiskers to show the min and max values. Alternatively, set
| this to an ascending sequence of percentile (e.g., [5, 95])
| to set the whiskers at specific percentiles of the data.
| Finally, ``whis`` can be the string ``'range'`` to force the
| whiskers to the min and max of the data.
|
| bootstrap : int, optional
| Specifies whether to bootstrap the confidence intervals
| around the median for notched boxplots. If ``bootstrap`` is
| None, no bootstrapping is performed, and notches are
| calculated using a Gaussian-based asymptotic approximation
| (see McGill, R., Tukey, J.W., and Larsen, W.A., 1978, and
| Kendall and Stuart, 1967). Otherwise, bootstrap specifies
| the number of times to bootstrap the median to determine its
| 95% confidence intervals. Values between 1000 and 10000 are
| recommended.
|
| usermedians : array-like, optional
| An array or sequence whose first dimension (or length) is
| compatible with ``x``. This overrides the medians computed
| by matplotlib for each element of ``usermedians`` that is not
| `None`. When an element of ``usermedians`` is None, the median
| will be computed by matplotlib as normal.
|
| conf_intervals : array-like, optional
| Array or sequence whose first dimension (or length) is
| compatible with ``x`` and whose second dimension is 2. When
| the an element of ``conf_intervals`` is not None, the
| notch locations computed by matplotlib are overridden
| (provided ``notch`` is `True`). When an element of
| ``conf_intervals`` is `None`, the notches are computed by the
| method specified by the other kwargs (e.g., ``bootstrap``).
|
| positions : array-like, optional
| Sets the positions of the boxes. The ticks and limits are
| automatically set to match the positions. Defaults to
| `range(1, N+1)` where N is the number of boxes to be drawn.
|
| widths : scalar or array-like
| Sets the width of each box either with a scalar or a
| sequence. The default is 0.5, or ``0.15*(distance between
| extreme positions)``, if that is smaller.
|
| patch_artist : bool, optional (False)
| If `False` produces boxes with the Line2D artist. Otherwise,
| boxes and drawn with Patch artists.
|
| labels : sequence, optional
| Labels for each dataset. Length must be compatible with
| dimensions of ``x``.
|
| manage_xticks : bool, optional (True)
| If the function should adjust the xlim and xtick locations.
|
| autorange : bool, optional (False)
| When `True` and the data are distributed such that the 25th and
| 75th percentiles are equal, ``whis`` is set to ``'range'`` such
| that the whisker ends are at the minimum and maximum of the
| data.
|
| meanline : bool, optional (False)
| If `True` (and ``showmeans`` is `True`), will try to render
| the mean as a line spanning the full width of the box
| according to ``meanprops`` (see below). Not recommended if
| ``shownotches`` is also True. Otherwise, means will be shown
| as points.
|
| zorder : scalar, optional (None)
| Sets the zorder of the boxplot.
|
| Other Parameters
| ----------------
| showcaps : bool, optional (True)
| Show the caps on the ends of whiskers.
| showbox : bool, optional (True)
| Show the central box.
| showfliers : bool, optional (True)
| Show the outliers beyond the caps.
| showmeans : bool, optional (False)
| Show the arithmetic means.
| capprops : dict, optional (None)
| Specifies the style of the caps.
| boxprops : dict, optional (None)
| Specifies the style of the box.
| whiskerprops : dict, optional (None)
| Specifies the style of the whiskers.
| flierprops : dict, optional (None)
| Specifies the style of the fliers.
| medianprops : dict, optional (None)
| Specifies the style of the median.
| meanprops : dict, optional (None)
| Specifies the style of the mean.
|
| Returns
| -------
| result : dict
| A dictionary mapping each component of the boxplot to a list
| of the :class:`matplotlib.lines.Line2D` instances
| created. That dictionary has the following keys (assuming
| vertical boxplots):
|
| - ``boxes``: the main body of the boxplot showing the
| quartiles and the median's confidence intervals if
| enabled.
|
| - ``medians``: horizontal lines at the median of each box.
|
| - ``whiskers``: the vertical lines extending to the most
| extreme, non-outlier data points.
|
| - ``caps``: the horizontal lines at the ends of the
| whiskers.
|
| - ``fliers``: points representing data that extend beyond
| the whiskers (fliers).
|
| - ``means``: points or lines representing the means.
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All positional and all keyword arguments.
|
| broken_barh(self, xranges, yrange, *, data=None, **kwargs)
| Plot a horizontal sequence of rectangles.
|
| A rectangle is drawn for each element of *xranges*. All rectangles
| have the same vertical position and size defined by *yrange*.
|
| This is a convenience function for instantiating a
| `.BrokenBarHCollection`, adding it to the axes and autoscaling the
| view.
|
| Parameters
| ----------
| xranges : sequence of tuples (*xmin*, *xwidth*)
| The x-positions and extends of the rectangles. For each tuple
| (*xmin*, *xwidth*) a rectangle is drawn from *xmin* to *xmin* +
| *xwidth*.
| yranges : (*ymin*, *ymax*)
| The y-position and extend for all the rectangles.
|
| Other Parameters
| ----------------
| **kwargs : :class:`.BrokenBarHCollection` properties
|
| Each *kwarg* can be either a single argument applying to all
| rectangles, e.g.::
|
| facecolors='black'
|
| or a sequence of arguments over which is cycled, e.g.::
|
| facecolors=('black', 'blue')
|
| would create interleaving black and blue rectangles.
|
| Supported keywords:
|
| 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: float or None
| animated: bool
| antialiased or antialiaseds: Boolean or sequence of booleans
| array: ndarray
| capstyle: unknown
| clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs.
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| cmap: a colormap or registered colormap name
| color: matplotlib color arg or sequence of rgba tuples
| contains: a callable function
| edgecolor or edgecolors: matplotlib color spec or sequence of specs
| facecolor or facecolors: matplotlib color spec or sequence of specs
| figure: a `.Figure` instance
| gid: an id string
| hatch: [ '/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ]
| joinstyle: unknown
| label: object
| linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or linewidths or lw: float or sequence of floats
| norm: `.Normalize`
| offset_position: [ 'screen' | 'data' ]
| offsets: float or sequence of floats
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| urls: List[str] or None
| visible: bool
| zorder: float
|
| Returns
| -------
| :class:`matplotlib.collections.BrokenBarHCollection`
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All positional and all keyword arguments.
|
| bxp(self, bxpstats, positions=None, widths=None, vert=True, patch_artist=False, shownotches=False, showmeans=False, showcaps=True, showbox=True, showfliers=True, boxprops=None, whiskerprops=None, flierprops=None, medianprops=None, capprops=None, meanprops=None, meanline=False, manage_xticks=True, zorder=None)
| Drawing function for box and whisker plots.
|
| Make a box and whisker plot for each column of *x* or each
| vector in sequence *x*. The box extends from the lower to
| upper quartile values of the data, with a line at the median.
| The whiskers extend from the box to show the range of the
| data. Flier points are those past the end of the whiskers.
|
| Parameters
| ----------
|
| bxpstats : list of dicts
| A list of dictionaries containing stats for each boxplot.
| Required keys are:
|
| - ``med``: The median (scalar float).
|
| - ``q1``: The first quartile (25th percentile) (scalar
| float).
|
| - ``q3``: The third quartile (75th percentile) (scalar
| float).
|
| - ``whislo``: Lower bound of the lower whisker (scalar
| float).
|
| - ``whishi``: Upper bound of the upper whisker (scalar
| float).
|
| Optional keys are:
|
| - ``mean``: The mean (scalar float). Needed if
| ``showmeans=True``.
|
| - ``fliers``: Data beyond the whiskers (sequence of floats).
| Needed if ``showfliers=True``.
|
| - ``cilo`` & ``cihi``: Lower and upper confidence intervals
| about the median. Needed if ``shownotches=True``.
|
| - ``label``: Name of the dataset (string). If available,
| this will be used a tick label for the boxplot
|
| positions : array-like, default = [1, 2, ..., n]
| Sets the positions of the boxes. The ticks and limits
| are automatically set to match the positions.
|
| widths : array-like, default = None
| Either a scalar or a vector and sets the width of each
| box. The default is ``0.15*(distance between extreme
| positions)``, clipped to no less than 0.15 and no more than
| 0.5.
|
| vert : bool, default = False
| If `True` (default), makes the boxes vertical. If `False`,
| makes horizontal boxes.
|
| patch_artist : bool, default = False
| If `False` produces boxes with the
| `~matplotlib.lines.Line2D` artist. If `True` produces boxes
| with the `~matplotlib.patches.Patch` artist.
|
| shownotches : bool, default = False
| If `False` (default), produces a rectangular box plot.
| If `True`, will produce a notched box plot
|
| showmeans : bool, default = False
| If `True`, will toggle on the rendering of the means
|
| showcaps : bool, default = True
| If `True`, will toggle on the rendering of the caps
|
| showbox : bool, default = True
| If `True`, will toggle on the rendering of the box
|
| showfliers : bool, default = True
| If `True`, will toggle on the rendering of the fliers
|
| boxprops : dict or None (default)
| If provided, will set the plotting style of the boxes
|
| whiskerprops : dict or None (default)
| If provided, will set the plotting style of the whiskers
|
| capprops : dict or None (default)
| If provided, will set the plotting style of the caps
|
| flierprops : dict or None (default)
| If provided will set the plotting style of the fliers
|
| medianprops : dict or None (default)
| If provided, will set the plotting style of the medians
|
| meanprops : dict or None (default)
| If provided, will set the plotting style of the means
|
| meanline : bool, default = False
| If `True` (and *showmeans* is `True`), will try to render the mean
| as a line spanning the full width of the box according to
| *meanprops*. Not recommended if *shownotches* is also True.
| Otherwise, means will be shown as points.
|
| manage_xticks : bool, default = True
| If the function should adjust the xlim and xtick locations.
|
| zorder : scalar, default = None
| The zorder of the resulting boxplot
|
| Returns
| -------
| result : dict
| A dictionary mapping each component of the boxplot to a list
| of the :class:`matplotlib.lines.Line2D` instances
| created. That dictionary has the following keys (assuming
| vertical boxplots):
|
| - ``boxes``: the main body of the boxplot showing the
| quartiles and the median's confidence intervals if
| enabled.
|
| - ``medians``: horizontal lines at the median of each box.
|
| - ``whiskers``: the vertical lines extending to the most
| extreme, non-outlier data points.
|
| - ``caps``: the horizontal lines at the ends of the
| whiskers.
|
| - ``fliers``: points representing data that extend beyond
| the whiskers (fliers).
|
| - ``means``: points or lines representing the means.
|
| Examples
| --------
|
| .. plot:: gallery/statistics/bxp.py
|
| clabel(self, CS, *args, **kwargs)
| Label a contour plot.
|
| Call signature::
|
| clabel(cs, **kwargs)
|
| Adds labels to line contours in *cs*, where *cs* is a
| :class:`~matplotlib.contour.ContourSet` object returned by
| contour.
|
| ::
|
| clabel(cs, v, **kwargs)
|
| only labels contours listed in *v*.
|
| Parameters
| ----------
| fontsize : string or float, optional
| Size in points or relative size e.g., 'smaller', 'x-large'.
| See `Text.set_size` for accepted string values.
|
| colors :
| Color of each label
|
| - if *None*, the color of each label matches the color of
| the corresponding contour
|
| - if one string color, e.g., *colors* = 'r' or *colors* =
| 'red', all labels will be plotted in this color
|
| - if a tuple of matplotlib color args (string, float, rgb, etc),
| different labels will be plotted in different colors in the order
| specified
|
| inline : bool, optional
| If ``True`` the underlying contour is removed where the label is
| placed. Default is ``True``.
|
| inline_spacing : float, optional
| Space in pixels to leave on each side of label when
| placing inline. Defaults to 5.
|
| This spacing will be exact for labels at locations where the
| contour is straight, less so for labels on curved contours.
|
| fmt : string or dict, optional
| A format string for the label. Default is '%1.3f'
|
| Alternatively, this can be a dictionary matching contour
| levels with arbitrary strings to use for each contour level
| (i.e., fmt[level]=string), or it can be any callable, such
| as a :class:`~matplotlib.ticker.Formatter` instance, that
| returns a string when called with a numeric contour level.
|
| manual : bool or iterable, optional
| If ``True``, contour labels will be placed manually using
| mouse clicks. Click the first button near a contour to
| add a label, click the second button (or potentially both
| mouse buttons at once) to finish adding labels. The third
| button can be used to remove the last label added, but
| only if labels are not inline. Alternatively, the keyboard
| can be used to select label locations (enter to end label
| placement, delete or backspace act like the third mouse button,
| and any other key will select a label location).
|
| *manual* can also be an iterable object of x,y tuples.
| Contour labels will be created as if mouse is clicked at each
| x,y positions.
|
| rightside_up : bool, optional
| If ``True``, label rotations will always be plus
| or minus 90 degrees from level. Default is ``True``.
|
| use_clabeltext : bool, optional
| If ``True``, `ClabelText` class (instead of `Text`) is used to
| create labels. `ClabelText` recalculates rotation angles
| of texts during the drawing time, therefore this can be used if
| aspect of the axes changes. Default is ``False``.
|
| cohere(self, x, y, NFFT=256, Fs=2, Fc=0, detrend=<function detrend_none at 0x1111e4158>, window=<function window_hanning at 0x1111db048>, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, *, data=None, **kwargs)
| Plot the coherence between *x* and *y*.
|
| Plot the coherence between *x* and *y*. Coherence is the
| normalized cross spectral density:
|
| .. math::
|
| C_{xy} = \frac{|P_{xy}|^2}{P_{xx}P_{yy}}
|
| Parameters
| ----------
| Fs : scalar
| The sampling frequency (samples per time unit). It is used
| to calculate the Fourier frequencies, freqs, in cycles per time
| unit. The default value is 2.
|
| window : callable or ndarray
| A function or a vector of length *NFFT*. To create window
| vectors see :func:`window_hanning`, :func:`window_none`,
| :func:`numpy.blackman`, :func:`numpy.hamming`,
| :func:`numpy.bartlett`, :func:`scipy.signal`,
| :func:`scipy.signal.get_window`, etc. The default is
| :func:`window_hanning`. 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' ]
| Specifies which sides of the spectrum to return. Default gives the
| default behavior, which returns one-sided for real data and both
| for complex data. 'onesided' forces the return of a one-sided
| spectrum, while 'twosided' forces two-sided.
|
| pad_to : integer
| 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*
|
| NFFT : integer
| The number of data points used in each block for the FFT.
| A power 2 is most efficient. The default value is 256.
| 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 : {'default', 'constant', 'mean', 'linear', 'none'} or callable
| The function applied to each segment before fft-ing,
| designed to remove the mean or linear trend. Unlike in
| MATLAB, where the *detrend* parameter is a vector, in
| matplotlib is it a function. The :mod:`~matplotlib.pylab`
| module defines :func:`~matplotlib.pylab.detrend_none`,
| :func:`~matplotlib.pylab.detrend_mean`, and
| :func:`~matplotlib.pylab.detrend_linear`, but you can use
| a custom function as well. You can also use a string to choose
| one of the functions. 'default', 'constant', and 'mean' call
| :func:`~matplotlib.pylab.detrend_mean`. 'linear' calls
| :func:`~matplotlib.pylab.detrend_linear`. 'none' calls
| :func:`~matplotlib.pylab.detrend_none`.
|
| scale_by_freq : boolean, optional
| Specifies 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.
|
| noverlap : integer
| The number of points of overlap between blocks. The
| default value is 0 (no overlap).
|
| Fc : integer
| The center frequency of *x* (defaults to 0), 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
| -------
| The return value is a tuple (*Cxy*, *f*), where *f* are the
| frequencies of the coherence vector.
|
| kwargs are applied to the lines.
|
| Other Parameters
| ----------------
| **kwargs :
| Keyword arguments control the :class:`~matplotlib.lines.Line2D`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| References
| ----------
| Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,
| John Wiley & Sons (1986)
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| csd(self, x, y, 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)
| Plot the cross-spectral density.
|
| Call signature::
|
| csd(x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,
| window=mlab.window_hanning, noverlap=0, pad_to=None,
| sides='default', scale_by_freq=None, return_line=None, **kwargs)
|
| The cross spectral density :math:`P_{xy}` by Welch's average
| periodogram method. The vectors *x* and *y* are divided into
| *NFFT* length segments. Each segment is detrended by function
| *detrend* and windowed by function *window*. *noverlap* gives
| the length of the overlap between segments. The product of
| the direct FFTs of *x* and *y* are averaged over each segment
| to compute :math:`P_{xy}`, with a scaling to correct for power
| loss due to windowing.
|
| If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero
| padded to *NFFT*.
|
| Parameters
| ----------
| x, y : 1-D arrays or sequences
| Arrays or sequences containing the data
|
| Fs : scalar
| The sampling frequency (samples per time unit). It is used
| to calculate the Fourier frequencies, freqs, in cycles per time
| unit. The default value is 2.
|
| window : callable or ndarray
| A function or a vector of length *NFFT*. To create window
| vectors see :func:`window_hanning`, :func:`window_none`,
| :func:`numpy.blackman`, :func:`numpy.hamming`,
| :func:`numpy.bartlett`, :func:`scipy.signal`,
| :func:`scipy.signal.get_window`, etc. The default is
| :func:`window_hanning`. 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' ]
| Specifies which sides of the spectrum to return. Default gives the
| default behavior, which returns one-sided for real data and both
| for complex data. 'onesided' forces the return of a one-sided
| spectrum, while 'twosided' forces two-sided.
|
| pad_to : integer
| 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*
|
| NFFT : integer
| The number of data points used in each block for the FFT.
| A power 2 is most efficient. The default value is 256.
| 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 : {'default', 'constant', 'mean', 'linear', 'none'} or callable
| The function applied to each segment before fft-ing,
| designed to remove the mean or linear trend. Unlike in
| MATLAB, where the *detrend* parameter is a vector, in
| matplotlib is it a function. The :mod:`~matplotlib.pylab`
| module defines :func:`~matplotlib.pylab.detrend_none`,
| :func:`~matplotlib.pylab.detrend_mean`, and
| :func:`~matplotlib.pylab.detrend_linear`, but you can use
| a custom function as well. You can also use a string to choose
| one of the functions. 'default', 'constant', and 'mean' call
| :func:`~matplotlib.pylab.detrend_mean`. 'linear' calls
| :func:`~matplotlib.pylab.detrend_linear`. 'none' calls
| :func:`~matplotlib.pylab.detrend_none`.
|
| scale_by_freq : boolean, optional
| Specifies 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.
|
| noverlap : integer
| The number of points of overlap between segments.
| The default value is 0 (no overlap).
|
| Fc : integer
| The center frequency of *x* (defaults to 0), 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_line : bool
| Whether to include the line object plotted in the returned values.
| Default is False.
|
| Returns
| -------
| Pxy : 1-D array
| The values for the cross spectrum `P_{xy}` before scaling
| (complex valued)
|
| freqs : 1-D array
| The frequencies corresponding to the elements in *Pxy*
|
| line : a :class:`~matplotlib.lines.Line2D` instance
| The line created by this function.
| Only returned if *return_line* is True.
|
| Other Parameters
| ----------------
| **kwargs :
| Keyword arguments control the :class:`~matplotlib.lines.Line2D`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| See Also
| --------
| :func:`psd`
| :func:`psd` is the equivalent to setting y=x.
|
| Notes
| -----
| For plotting, the power is plotted as
| :math:`10\log_{10}(P_{xy})` for decibels, though `P_{xy}` itself
| is returned.
|
| References
| ----------
| Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,
| John Wiley & Sons (1986)
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| errorbar(self, x, y, yerr=None, xerr=None, fmt='', ecolor=None, elinewidth=None, capsize=None, barsabove=False, lolims=False, uplims=False, xlolims=False, xuplims=False, errorevery=1, capthick=None, *, data=None, **kwargs)
| Plot y versus x as lines and/or markers with attached errorbars.
|
| *x*, *y* define the data locations, *xerr*, *yerr* define the errorbar
| sizes. By default, this draws the data markers/lines as well the
| errorbars. Use fmt='none' to draw errorbars without any data markers.
|
| Parameters
| ----------
| x, y : scalar or array-like
| The data positions.
|
| xerr, yerr : scalar or array-like, shape(N,) or shape(2,N), optional
| The errorbar sizes:
|
| - scalar: Symmetric +/- values for all data points.
| - shape(N,): Symmetric +/-values for each data point.
| - shape(2,N): Separate + and - values for each data point.
| - *None*: No errorbar.
|
| fmt : plot format string, optional, default: ''
| The format for the data points / data lines. See `.plot` for
| details.
|
| Use 'none' (case insensitive) to plot errorbars without any data
| markers.
|
| ecolor : mpl color, optional, default: None
| A matplotlib color arg which gives the color the errorbar lines.
| If None, use the color of the line connecting the markers.
|
| elinewidth : scalar, optional, default: None
| The linewidth of the errorbar lines. If None, the linewidth of
| the current style is used.
|
| capsize : scalar, optional, default: None
| The length of the error bar caps in points. If None, it will take
| the value from :rc:`errorbar.capsize`.
|
| capthick : scalar, optional, default: None
| An alias to the keyword argument *markeredgewidth* (a.k.a. *mew*).
| This setting is a more sensible name for the property that
| controls the thickness of the error bar cap in points. For
| backwards compatibility, if *mew* or *markeredgewidth* are given,
| then they will over-ride *capthick*. This may change in future
| releases.
|
| barsabove : bool, optional, default: False
| If True, will plot the errorbars above the plot
| symbols. Default is below.
|
| lolims, uplims, xlolims, xuplims : bool, optional, default: None
| These arguments can be used to indicate that a value gives only
| upper/lower limits. In that case a caret symbol is used to
| indicate this. *lims*-arguments may be of the same type as *xerr*
| and *yerr*. To use limits with inverted axes, :meth:`set_xlim`
| or :meth:`set_ylim` must be called before :meth:`errorbar`.
|
| errorevery : positive integer, optional, default: 1
| Subsamples the errorbars. e.g., if errorevery=5, errorbars for
| every 5-th datapoint will be plotted. The data plot itself still
| shows all data points.
|
| Returns
| -------
| :class:`~.container.ErrorbarContainer`
| The container contains:
|
| - plotline: :class:`~matplotlib.lines.Line2D` instance of
| x, y plot markers and/or line.
| - caplines: A tuple of :class:`~matplotlib.lines.Line2D` instances
| of the error bar caps.
| - barlinecols: A tuple of
| :class:`~matplotlib.collections.LineCollection` with the
| horizontal and vertical error ranges.
|
| Other Parameters
| ----------------
| **kwargs :
| All other keyword arguments are passed on to the plot
| command for the markers. For example, this code makes big red
| squares with thick green edges::
|
| x,y,yerr = rand(3,10)
| errorbar(x, y, yerr, marker='s', mfc='red',
| mec='green', ms=20, mew=4)
|
| where *mfc*, *mec*, *ms* and *mew* are aliases for the longer
| property names, *markerfacecolor*, *markeredgecolor*, *markersize*
| and *markeredgewidth*.
|
| Valid kwargs for the marker properties are `.Lines2D` 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'xerr', 'y', 'yerr'.
|
| eventplot(self, positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, linestyles='solid', *, data=None, **kwargs)
| Plot identical parallel lines at the given positions.
|
| *positions* should be a 1D or 2D array-like object, with each row
| corresponding to a row or column of lines.
|
| This type of plot is commonly used in neuroscience for representing
| neural events, where it is usually called a spike raster, dot raster,
| or raster plot.
|
| However, it is useful in any situation where you wish to show the
| timing or position of multiple sets of discrete events, such as the
| arrival times of people to a business on each day of the month or the
| date of hurricanes each year of the last century.
|
| Parameters
| ----------
| positions : 1D or 2D array-like object
| Each value is an event. If *positions* is a 2D array-like, each
| row corresponds to a row or a column of lines (depending on the
| *orientation* parameter).
|
| orientation : {'horizontal', 'vertical'}, optional
| Controls the direction of the event collections:
|
| - 'horizontal' : the lines are arranged horizontally in rows,
| and are vertical.
| - 'vertical' : the lines are arranged vertically in columns,
| and are horizontal.
|
| lineoffsets : scalar or sequence of scalars, optional, default: 1
| The offset of the center of the lines from the origin, in the
| direction orthogonal to *orientation*.
|
| linelengths : scalar or sequence of scalars, optional, default: 1
| The total height of the lines (i.e. the lines stretches from
| ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).
|
| linewidths : scalar, scalar sequence or None, optional, default: None
| The line width(s) of the event lines, in points. If it is None,
| defaults to its rcParams setting.
|
| colors : color, sequence of colors or None, optional, default: None
| The color(s) of the event lines. If it is None, defaults to its
| rcParams setting.
|
| linestyles : str or tuple or a sequence of such values, optional
| Default is 'solid'. Valid strings are ['solid', 'dashed',
| 'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples
| should be of the form::
|
| (offset, onoffseq),
|
| where *onoffseq* is an even length tuple of on and off ink
| in points.
|
| **kwargs : optional
| Other keyword arguments are line collection properties. See
| :class:`~matplotlib.collections.LineCollection` for a list of
| the valid properties.
|
| Returns
| -------
|
| A list of :class:`matplotlib.collections.EventCollection` objects that
| were added.
|
| Notes
| -----
|
| For *linelengths*, *linewidths*, *colors*, and *linestyles*, if only
| a single value is given, that value is applied to all lines. If an
| array-like is given, it must have the same length as *positions*, and
| each value will be applied to the corresponding row of the array.
|
| Examples
| --------
|
| .. plot:: gallery/lines_bars_and_markers/eventplot_demo.py
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'colors', 'linelengths', 'lineoffsets', 'linestyles', 'linewidths', 'positions'.
|
| fill(self, *args, data=None, **kwargs)
| Plot filled polygons.
|
| Parameters
| ----------
| args : sequence of x, y, [color]
| Each polygon is defined by the lists of *x* and *y* positions of
| its nodes, optionally followed by by a *color* specifier. See
| :mod:`matplotlib.colors` for supported color specifiers. The
| standard color cycle is used for polygons without a color
| specifier.
|
| You can plot multiple polygons by providing multiple *x*, *y*,
| *[color]* groups.
|
| For example, each of the following is legal::
|
| ax.fill(x, y) # a polygon with default color
| ax.fill(x, y, "b") # a blue polygon
| ax.fill(x, y, x2, y2) # two polygons
| ax.fill(x, y, "b", x2, y2, "r") # a blue and a red polygon
|
| Returns
| -------
| a list of :class:`~matplotlib.patches.Polygon`
|
| Other Parameters
| ----------------
| **kwargs : :class:`~matplotlib.patches.Polygon` properties
|
| Notes
| -----
| Use :meth:`fill_between` if you would like to fill the region between
| two curves.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| fill_between(self, x, y1, y2=0, where=None, interpolate=False, step=None, *, data=None, **kwargs)
| Fill the area between two horizontal curves.
|
| The curves are defined by the points (*x*, *y1*) and (*x*, *y2*). This
| creates one or multiple polygons describing the filled area.
|
| You may exclude some horizontal sections from filling using *where*.
|
| By default, the edges connect the given points directly. Use *step* if
| the filling should be a step function, i.e. constant in between *x*.
|
|
| Parameters
| ----------
| x : array (length N)
| The x coordinates of the nodes defining the curves.
|
| y1 : array (length N) or scalar
| The y coordinates of the nodes defining the first curve.
|
| y2 : array (length N) or scalar, optional, default: 0
| The y coordinates of the nodes defining the second curve.
|
| where : array of bool (length N), optional, default: None
| Define *where* to exclude some horizontal regions from being
| filled. The filled regions are defined by the coordinates
| ``x[where]``. More precisely, fill between ``x[i]`` and ``x[i+1]``
| if ``where[i] and where[i+1]``. Note that this definition implies
| that an isolated *True* value between two *False* values in
| *where* will not result in filling. Both sides of the *True*
| position remain unfilled due to the adjacent *False* values.
|
| interpolate : bool, optional
| This option is only relvant if *where* is used and the two curves
| are crossing each other.
|
| Semantically, *where* is often used for *y1* > *y2* or similar.
| By default, the nodes of the polygon defining the filled region
| will only be placed at the positions in the *x* array. Such a
| polygon cannot describe the above semantics close to the
| intersection. The x-sections containing the intersecion are
| simply clipped.
|
| Setting *interpolate* to *True* will calculate the actual
| interscection point and extend the filled region up to this point.
|
| step : {'pre', 'post', 'mid'}, optional
| Define *step* if the filling should be a step function,
| i.e. constant in between *x*. The value determines where the
| step will occur:
|
| - '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.
|
| Other Parameters
| ----------------
| **kwargs
| All other keyword arguments are passed on to `.PolyCollection`.
| They control the `.Polygon` 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
| alpha: float or None
| animated: bool
| antialiased or antialiaseds: Boolean or sequence of booleans
| array: ndarray
| capstyle: unknown
| clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs.
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| cmap: a colormap or registered colormap name
| color: matplotlib color arg or sequence of rgba tuples
| contains: a callable function
| edgecolor or edgecolors: matplotlib color spec or sequence of specs
| facecolor or facecolors: matplotlib color spec or sequence of specs
| figure: a `.Figure` instance
| gid: an id string
| hatch: [ '/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ]
| joinstyle: unknown
| label: object
| linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or linewidths or lw: float or sequence of floats
| norm: `.Normalize`
| offset_position: [ 'screen' | 'data' ]
| offsets: float or sequence of floats
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| urls: List[str] or None
| visible: bool
| zorder: float
|
| Returns
| -------
| `.PolyCollection`
| A `.PolyCollection` containing the plotted polygons.
|
| See Also
| --------
| fill_betweenx : Fill between two sets of x-values.
|
| Notes
| -----
| .. [notes section required to get data note injection right]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'where', 'x', 'y1', 'y2'.
|
| fill_betweenx(self, y, x1, x2=0, where=None, step=None, interpolate=False, *, data=None, **kwargs)
| Fill the area between two vertical curves.
|
| The curves are defined by the points (*x1*, *y*) and (*x2*, *y*). This
| creates one or multiple polygons describing the filled area.
|
| You may exclude some vertical sections from filling using *where*.
|
| By default, the edges connect the given points directly. Use *step* if
| the filling should be a step function, i.e. constant in between *y*.
|
|
| Parameters
| ----------
| y : array (length N)
| The y coordinates of the nodes defining the curves.
|
| x1 : array (length N) or scalar
| The x coordinates of the nodes defining the first curve.
|
| x2 : array (length N) or scalar, optional, default: 0
| The x coordinates of the nodes defining the second curve.
|
| where : array of bool (length N), optional, default: None
| Define *where* to exclude some vertical regions from being
| filled. The filled regions are defined by the coordinates
| ``y[where]``. More precisely, fill between ``y[i]`` and ``y[i+1]``
| if ``where[i] and where[i+1]``. Note that this definition implies
| that an isolated *True* value between two *False* values in
| *where* will not result in filling. Both sides of the *True*
| position remain unfilled due to the adjacent *False* values.
|
| interpolate : bool, optional
| This option is only relvant if *where* is used and the two curves
| are crossing each other.
|
| Semantically, *where* is often used for *x1* > *x2* or similar.
| By default, the nodes of the polygon defining the filled region
| will only be placed at the positions in the *y* array. Such a
| polygon cannot describe the above semantics close to the
| intersection. The y-sections containing the intersecion are
| simply clipped.
|
| Setting *interpolate* to *True* will calculate the actual
| interscection point and extend the filled region up to this point.
|
| step : {'pre', 'post', 'mid'}, optional
| Define *step* if the filling should be a step function,
| i.e. constant in between *y*. The value determines where the
| step will occur:
|
| - '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.
|
| Other Parameters
| ----------------
| **kwargs
| All other keyword arguments are passed on to `.PolyCollection`.
| They control the `.Polygon` 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
| alpha: float or None
| animated: bool
| antialiased or antialiaseds: Boolean or sequence of booleans
| array: ndarray
| capstyle: unknown
| clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs.
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| cmap: a colormap or registered colormap name
| color: matplotlib color arg or sequence of rgba tuples
| contains: a callable function
| edgecolor or edgecolors: matplotlib color spec or sequence of specs
| facecolor or facecolors: matplotlib color spec or sequence of specs
| figure: a `.Figure` instance
| gid: an id string
| hatch: [ '/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ]
| joinstyle: unknown
| label: object
| linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or linewidths or lw: float or sequence of floats
| norm: `.Normalize`
| offset_position: [ 'screen' | 'data' ]
| offsets: float or sequence of floats
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| urls: List[str] or None
| visible: bool
| zorder: float
|
| Returns
| -------
| `.PolyCollection`
| A `.PolyCollection` containing the plotted polygons.
|
| See Also
| --------
| fill_between : Fill between two sets of y-values.
|
| Notes
| -----
| .. [notes section required to get data note injection right]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'where', 'x1', 'x2', 'y'.
|
| get_legend_handles_labels(self, legend_handler_map=None)
| Return handles and labels for legend
|
| ``ax.legend()`` is equivalent to ::
|
| h, l = ax.get_legend_handles_labels()
| ax.legend(h, l)
|
| get_title(self, loc='center')
| Get an axes title.
|
| Get 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
| ----------
| loc : {'center', 'left', 'right'}, str, optional
| Which title to get, defaults to 'center'.
|
| Returns
| -------
| title : str
| The title text string.
|
| get_xlabel(self)
| Get the xlabel text string.
|
| get_ylabel(self)
| Get the ylabel text string.
|
| hexbin(self, 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 at 0x1100410d0>, mincnt=None, marginals=False, *, data=None, **kwargs)
| Make a hexagonal binning plot.
|
| Make a hexagonal binning plot of *x* versus *y*, where *x*,
| *y* are 1-D sequences of the same length, *N*. If *C* is *None*
| (the default), this is a histogram of the number of occurrences
| of the observations at (x[i],y[i]).
|
| If *C* is specified, it specifies values at the coordinate
| (x[i],y[i]). These values are accumulated for each hexagonal
| bin and then reduced according to *reduce_C_function*, which
| defaults to numpy's mean function (np.mean). (If *C* is
| specified, it must also be a 1-D sequence of the same length
| as *x* and *y*.)
|
| Parameters
| ----------
| x, y : array or masked array
|
| C : array or masked array, optional, default is *None*
|
| gridsize : int or (int, int), optional, default is 100
| The number of hexagons in the *x*-direction, default is
| 100. The corresponding number of hexagons in the
| *y*-direction is chosen such that the hexagons are
| approximately regular. Alternatively, gridsize can be a
| tuple with two elements specifying the number of hexagons
| in the *x*-direction and the *y*-direction.
|
| bins : {'log'} or int or sequence, optional, default is *None*
| If *None*, no binning is applied; the color of each hexagon
| directly corresponds to its count value.
|
| If 'log', use a logarithmic scale for the color
| map. Internally, :math:`log_{10}(i+1)` is used to
| determine the hexagon color.
|
| If an integer, divide the counts in the specified number
| of bins, and color the hexagons accordingly.
|
| If a sequence of values, the values of the lower bound of
| the bins to be used.
|
| xscale : {'linear', 'log'}, optional, default is 'linear'
| Use a linear or log10 scale on the horizontal axis.
|
| yscale : {'linear', 'log'}, optional, default is 'linear'
| Use a linear or log10 scale on the vertical axis.
|
| mincnt : int > 0, optional, default is *None*
| If not *None*, only display cells with more than *mincnt*
| number of points in the cell
|
| marginals : bool, optional, default is *False*
| if marginals is *True*, plot the marginal density as
| colormapped rectagles along the bottom of the x-axis and
| left of the y-axis
|
| extent : scalar, optional, default is *None*
| The limits of the bins. 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).
|
| Order of scalars is (left, right, bottom, top).
|
| Other Parameters
| ----------------
| cmap : object, optional, default is *None*
| a :class:`matplotlib.colors.Colormap` instance. If *None*,
| defaults to rc ``image.cmap``.
|
| norm : object, optional, default is *None*
| :class:`matplotlib.colors.Normalize` instance is used to
| scale luminance data to 0,1.
|
| vmin, vmax : scalar, optional, default is *None*
| *vmin* and *vmax* are used in conjunction with *norm* to
| normalize luminance data. If *None*, the min and max of the
| color array *C* are used. Note if you pass a norm instance
| your settings for *vmin* and *vmax* will be ignored.
|
| alpha : scalar between 0 and 1, optional, default is *None*
| the alpha value for the patches
|
| linewidths : scalar, optional, default is *None*
| If *None*, defaults to 1.0.
|
| edgecolors : {'face', 'none', *None*} or color, optional
|
| If 'face' (the default), draws the edges in the same color as the
| fill color.
|
| If 'none', no edge is drawn; this can sometimes lead to unsightly
| unpainted pixels between the hexagons.
|
| If *None*, draws outlines in the default color.
|
| If a matplotlib color arg, draws outlines in the specified color.
|
| Returns
| -------
| object
| a :class:`~matplotlib.collections.PolyCollection` instance; use
| :meth:`~matplotlib.collections.PolyCollection.get_array` on
| this :class:`~matplotlib.collections.PolyCollection` to get
| the counts in each hexagon.
|
| If *marginals* is *True*, horizontal
| bar and vertical bar (both PolyCollections) will be attached
| to the return collection as attributes *hbar* and *vbar*.
|
| Notes
| -----
| The standard descriptions of all the
| :class:`~matplotlib.collections.Collection` parameters:
|
| 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: float or None
| animated: bool
| antialiased or antialiaseds: Boolean or sequence of booleans
| array: ndarray
| capstyle: unknown
| clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs.
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| cmap: a colormap or registered colormap name
| color: matplotlib color arg or sequence of rgba tuples
| contains: a callable function
| edgecolor or edgecolors: matplotlib color spec or sequence of specs
| facecolor or facecolors: matplotlib color spec or sequence of specs
| figure: a `.Figure` instance
| gid: an id string
| hatch: [ '/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ]
| joinstyle: unknown
| label: object
| linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or linewidths or lw: float or sequence of floats
| norm: `.Normalize`
| offset_position: [ 'screen' | 'data' ]
| offsets: float or sequence of floats
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| urls: List[str] or None
| visible: bool
| zorder: float
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| hist(self, x, bins=None, range=None, density=None, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, normed=None, *, data=None, **kwargs)
| 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.
|
| Multiple data can be provided via *x* as a list of datasets
| of potentially different length ([*x0*, *x1*, ...]), or as
| a 2-D 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 at present.
|
| 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
|
| bins : integer or sequence or 'auto', optional
| If an integer is given, ``bins + 1`` bin edges are calculated and
| returned, consistent with :func:`numpy.histogram`.
|
| If `bins` is a sequence, gives bin edges, including left edge of
| first bin and right edge of last bin. In this case, `bins` is
| returned unmodified.
|
| 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.
|
| Unequally spaced bins are supported if *bins* is a sequence.
|
| If Numpy 1.11 is installed, may also be ``'auto'``.
|
| Default is taken from the rcParam ``hist.bins``.
|
| range : tuple or None, optional
| 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.
|
| Default is ``None``
|
| density : boolean, optional
| If ``True``, the first element of the return tuple will
| be the counts normalized to form a probability density, i.e.,
| the area (or integral) under the histogram will sum to 1.
| This is achieved by dividing the count by the number of
| observations times the bin width and not dividing by the total
| number of observations. If *stacked* is also ``True``, the sum of
| the histograms is normalized to 1.
|
| Default is ``None`` for both *normed* and *density*. If either is
| set, then that value will be used. If neither are set, then the
| args will be treated as ``False``.
|
| If both *density* and *normed* are set an error is raised.
|
| weights : (n, ) array_like or None, optional
| 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 *normed* or *density* is ``True``,
| the weights are normalized, so that the integral of the density
| over the range remains 1.
|
| Default is ``None``
|
| cumulative : boolean, optional
| If ``True``, then a histogram is computed where each bin gives the
| counts in that bin plus all bins for smaller values. The last bin
| gives the total number of datapoints. If *normed* or *density*
| is also ``True`` then the histogram is normalized such that the
| last bin equals 1. If *cumulative* evaluates to less than 0
| (e.g., -1), the direction of accumulation is reversed.
| In this case, if *normed* and/or *density* is also ``True``, then
| the histogram is normalized such that the first bin equals 1.
|
| Default is ``False``
|
| bottom : array_like, scalar, or None
| Location of the bottom baseline of each bin. If a scalar,
| the base line for 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.
|
| Default is ``None``
|
| histtype : {'bar', 'barstacked', 'step', 'stepfilled'}, optional
| 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.
|
| Default is 'bar'
|
| align : {'left', 'mid', 'right'}, optional
| Controls how the histogram is plotted.
|
| - 'left': bars are centered on the left bin edges.
|
| - 'mid': bars are centered between the bin edges.
|
| - 'right': bars are centered on the right bin edges.
|
| Default is 'mid'
|
| orientation : {'horizontal', 'vertical'}, optional
| If 'horizontal', `~matplotlib.pyplot.barh` will be used for
| bar-type histograms and the *bottom* kwarg will be the left edges.
|
| rwidth : scalar or None, optional
| 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'.
|
| Default is ``None``
|
| log : boolean, optional
| If ``True``, the histogram axis will be set to a log scale. If
| *log* is ``True`` and *x* is a 1D array, empty bins will be
| filtered out and only the non-empty ``(n, bins, patches)``
| will be returned.
|
| Default is ``False``
|
| color : color or array_like of colors or None, optional
| Color spec or sequence of color specs, one per dataset. Default
| (``None``) uses the standard line color sequence.
|
| Default is ``None``
|
| label : string or None, optional
| 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 the legend command will work as expected.
|
| default is ``None``
|
| stacked : boolean, optional
| 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'
|
| Default is ``False``
|
| normed : bool, optional
| Deprecated; use the density keyword argument instead.
|
| Returns
| -------
| n : array or list of arrays
| The values of the histogram bins. See *normed* or *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 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.
|
| bins : array
| 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.
|
| patches : list or list of lists
| Silent list of individual patches used to create the histogram
| or list of such list if multiple input datasets.
|
| Other Parameters
| ----------------
| **kwargs : `~matplotlib.patches.Patch` properties
|
| See also
| --------
| hist2d : 2D histograms
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'weights', 'x'.
|
| hist2d(self, x, y, bins=10, range=None, normed=False, weights=None, cmin=None, cmax=None, *, data=None, **kwargs)
| Make a 2D histogram plot.
|
| Parameters
| ----------
| x, y: array_like, shape (n, )
| Input values
|
| bins: [None | int | [int, int] | array_like | [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.
|
| range : array_like shape(2, 2), optional, default: None
| 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.
|
| normed : boolean, optional, default: False
| Normalize histogram.
|
| weights : array_like, shape (n, ), optional, default: None
| An array of values w_i weighing each sample (x_i, y_i).
|
| cmin : scalar, optional, default: None
| All bins that has count less than cmin will not be displayed and
| these count values in the return value count histogram will also
| be set to nan upon return
|
| cmax : scalar, optional, default: None
| All bins that has count more than cmax will not be displayed (set
| to none before passing to imshow) and these count values in the
| return value count histogram will also be set to nan upon return
|
| Returns
| -------
| h : 2D 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.
| xedges : 1D array
| The bin edges along the x axis.
| yedges : 1D array
| The bin edges along the y axis.
| image : AxesImage
|
| Other Parameters
| ----------------
| cmap : {Colormap, string}, optional
| A :class:`matplotlib.colors.Colormap` instance. If not set, use rc
| settings.
|
| norm : Normalize, optional
| A :class:`matplotlib.colors.Normalize` instance is used to
| scale luminance data to ``[0, 1]``. If not set, defaults to
| ``Normalize()``.
|
| vmin/vmax : {None, scalar}, optional
| Arguments passed to the `Normalize` instance.
|
| alpha : ``0 <= scalar <= 1`` or ``None``, optional
| The alpha blending value.
|
| See also
| --------
| hist : 1D histogram
|
| Notes
| -----
| Rendering the histogram with a logarithmic color scale is
| accomplished by passing a :class:`colors.LogNorm` instance to
| the *norm* keyword argument. Likewise, power-law normalization
| (similar in effect to gamma correction) can be accomplished with
| :class:`colors.PowerNorm`.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'weights', 'x', 'y'.
|
| hlines(self, y, xmin, xmax, colors='k', linestyles='solid', label='', *, data=None, **kwargs)
| Plot horizontal lines at each *y* from *xmin* to *xmax*.
|
| Parameters
| ----------
| y : scalar or sequence of scalar
| y-indexes where to plot the lines.
|
| xmin, xmax : scalar or 1D array_like
| Respective beginning and end of each line. If scalars are
| provided, all lines will have same length.
|
| colors : array_like of colors, optional, default: 'k'
|
| linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional
|
| label : string, optional, default: ''
|
| Returns
| -------
| lines : `~matplotlib.collections.LineCollection`
|
| Other Parameters
| ----------------
| **kwargs : `~matplotlib.collections.LineCollection` properties.
|
| See also
| --------
| vlines : vertical lines
| axhline: horizontal line across the axes
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'colors', 'xmax', 'xmin', 'y'.
|
| legend(self, *args, **kwargs)
| Places a legend on the axes.
|
| Call signatures::
|
| legend()
| legend(labels)
| legend(handles, labels)
|
| The call signatures correspond to three different ways how 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
| :meth:`~.Artist.set_label` method on the artist::
|
| line, = ax.plot([1, 2, 3], label='Inline label')
| ax.legend()
|
| or::
|
| line.set_label('Label via method')
| line, = ax.plot([1, 2, 3])
| 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. Labeling existing plot elements**
|
| To make a legend for lines which already exist on the axes
| (via plot for instance), simply call this function with an iterable
| of strings, one for each legend item. For example::
|
| ax.plot([1, 2, 3])
| ax.legend(['A simple line'])
|
| Note: This way of using is discouraged, because the relation between
| plot elements and labels is only implicit by their order and can
| easily be mixed up.
|
|
| **3. Explicitly defining the elements 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::
|
| legend((line1, line2, line3), ('label1', 'label2', 'label3'))
|
| Parameters
| ----------
|
| handles : sequence 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.
|
| labels : sequence of strings, 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.
|
| Other Parameters
| ----------------
|
| loc : int or string or pair of floats, default: 'upper right'
| The location of the legend. Possible codes are:
|
| =============== =============
| Location String Location Code
| =============== =============
| 'best' 0
| 'upper right' 1
| 'upper left' 2
| 'lower left' 3
| 'lower right' 4
| 'right' 5
| 'center left' 6
| 'center right' 7
| 'lower center' 8
| 'upper center' 9
| 'center' 10
| =============== =============
|
|
| Alternatively can be a 2-tuple giving ``x, y`` of the lower-left
| corner of the legend in axes coordinates (in which case
| ``bbox_to_anchor`` will be ignored).
|
| bbox_to_anchor : `.BboxBase` or pair of floats
| Specify any arbitrary location for the legend in `bbox_transform`
| coordinates (default Axes coordinates).
|
| For example, to put the legend's upper right hand corner in the
| center of the axes the following keywords can be used::
|
| loc='upper right', bbox_to_anchor=(0.5, 0.5)
|
| ncol : integer
| The number of columns that the legend has. Default is 1.
|
| prop : None or :class:`matplotlib.font_manager.FontProperties` or dict
| The font properties of the legend. If None (default), the current
| :data:`matplotlib.rcParams` will be used.
|
| fontsize : int or float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}
| Controls 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.
|
| numpoints : None or int
| The number of marker points in the legend when creating a legend
| entry for a `.Line2D` (line).
| Default is ``None``, which will take the value from
| :rc:`legend.numpoints`.
|
| scatterpoints : None or int
| The number of marker points in the legend when creating
| a legend entry for a `.PathCollection` (scatter plot).
| Default is ``None``, which will take the value from
| :rc:`legend.scatterpoints`.
|
| scatteryoffsets : iterable of floats
| 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]``. Default is ``[0.375, 0.5, 0.3125]``.
|
| markerscale : None or int or float
| The relative size of legend markers compared with the originally
| drawn ones.
| Default is ``None``, which will take the value from
| :rc:`legend.markerscale`.
|
| markerfirst : bool
| 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.
| Default is *True*.
|
| frameon : None or bool
| Control whether the legend should be drawn on a patch
| (frame).
| Default is ``None``, which will take the value from
| :rc:`legend.frameon`.
|
| fancybox : None or bool
| Control whether round edges should be enabled around the
| :class:`~matplotlib.patches.FancyBboxPatch` which makes up the
| legend's background.
| Default is ``None``, which will take the value from
| :rc:`legend.fancybox`.
|
| shadow : None or bool
| Control whether to draw a shadow behind the legend.
| Default is ``None``, which will take the value from
| :rc:`legend.shadow`.
|
| framealpha : None or float
| Control the alpha transparency of the legend's background.
| Default is ``None``, which will take the value from
| :rc:`legend.framealpha`. If shadow is activated and
| *framealpha* is ``None``, the default value is ignored.
|
| facecolor : None or "inherit" or a color spec
| Control the legend's background color.
| Default is ``None``, which will take the value from
| :rc:`legend.facecolor`. If ``"inherit"``, it will take
| :rc:`axes.facecolor`.
|
| edgecolor : None or "inherit" or a color spec
| Control the legend's background patch edge color.
| Default is ``None``, which will take the value from
| :rc:`legend.edgecolor` If ``"inherit"``, it will 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_transform : None or :class:`matplotlib.transforms.Transform`
| The transform for the bounding box (`bbox_to_anchor`). For a value
| of ``None`` (default) the Axes'
| :data:`~matplotlib.axes.Axes.transAxes` transform will be used.
|
| title : str or None
| The legend's title. Default is no title (``None``).
|
| borderpad : float or None
| The fractional whitespace inside the legend border.
| Measured in font-size units.
| Default is ``None``, which will take the value from
| :rc:`legend.borderpad`.
|
| labelspacing : float or None
| The vertical space between the legend entries.
| Measured in font-size units.
| Default is ``None``, which will take the value from
| :rc:`legend.labelspacing`.
|
| handlelength : float or None
| The length of the legend handles.
| Measured in font-size units.
| Default is ``None``, which will take the value from
| :rc:`legend.handlelength`.
|
| handletextpad : float or None
| The pad between the legend handle and text.
| Measured in font-size units.
| Default is ``None``, which will take the value from
| :rc:`legend.handletextpad`.
|
| borderaxespad : float or None
| The pad between the axes and legend border.
| Measured in font-size units.
| Default is ``None``, which will take the value from
| :rc:`legend.borderaxespad`.
|
| columnspacing : float or None
| The spacing between columns.
| Measured in font-size units.
| Default is ``None``, which will take the value from
| :rc:`legend.columnspacing`.
|
| handler_map : dict or None
| The custom dictionary mapping instances or types to a legend
| handler. This `handler_map` updates the default handler map
| found at :func:`matplotlib.legend.Legend.get_legend_handler_map`.
|
| Returns
| -------
|
| :class:`matplotlib.legend.Legend` instance
|
| Notes
| -----
|
| Not all kinds of artist are supported by the legend command. See
| :ref:`sphx_glr_tutorials_intermediate_legend_guide.py` for details.
|
| Examples
| --------
|
| .. plot:: gallery/api/legend.py
|
| loglog(self, *args, **kwargs)
| 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 *basex/y*, *subsx/y* and *nonposx/y* control
| the x/y-axis properties. They are just forwarded to `.Axes.set_xscale`
| and `.Axes.set_yscale`.
|
| Parameters
| ----------
| basex, basey : scalar, optional, default 10
| Base of the x/y logarithm.
|
| subsx, subsy : sequence, optional
| The location of the minor x/y 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.
|
| nonposx, nonposy : {'mask', 'clip'}, optional, default 'mask'
| Non-positive values in x or y can be masked as invalid, or clipped
| to a very small positive number.
|
| Returns
| -------
| lines
| A list of `~.Line2D` objects representing the plotted data.
|
| Other Parameters
| ----------------
| **kwargs
| All parameters supported by `.plot`.
|
| magnitude_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, scale=None, *, data=None, **kwargs)
| Plot the magnitude spectrum.
|
| Call signature::
|
| magnitude_spectrum(x, Fs=2, Fc=0, window=mlab.window_hanning,
| pad_to=None, sides='default', **kwargs)
|
| 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
| ----------
| x : 1-D array or sequence
| Array or sequence containing the data
|
| Fs : scalar
| The sampling frequency (samples per time unit). It is used
| to calculate the Fourier frequencies, freqs, in cycles per time
| unit. The default value is 2.
|
| window : callable or ndarray
| A function or a vector of length *NFFT*. To create window
| vectors see :func:`window_hanning`, :func:`window_none`,
| :func:`numpy.blackman`, :func:`numpy.hamming`,
| :func:`numpy.bartlett`, :func:`scipy.signal`,
| :func:`scipy.signal.get_window`, etc. The default is
| :func:`window_hanning`. 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' ]
| Specifies which sides of the spectrum to return. Default gives the
| default behavior, which returns one-sided for real data and both
| for complex data. 'onesided' forces the return of a one-sided
| spectrum, while 'twosided' forces two-sided.
|
| pad_to : integer
| 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'.
|
| Fc : integer
| The center frequency of *x* (defaults to 0), 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
| -------
| spectrum : 1-D array
| The values for the magnitude spectrum before scaling (real valued)
|
| freqs : 1-D array
| The frequencies corresponding to the elements in *spectrum*
|
| line : a :class:`~matplotlib.lines.Line2D` instance
| The line created by this function
|
| Other Parameters
| ----------------
| **kwargs :
| Keyword arguments control the :class:`~matplotlib.lines.Line2D`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| See Also
| --------
| :func:`psd`
| :func:`psd` plots the power spectral density.`.
|
| :func:`angle_spectrum`
| :func:`angle_spectrum` plots the angles of the corresponding
| frequencies.
|
| :func:`phase_spectrum`
| :func:`phase_spectrum` plots the phase (unwrapped angle) of the
| corresponding frequencies.
|
| :func:`specgram`
| :func:`specgram` can plot the magnitude spectrum of segments within
| the signal in a colormap.
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x'.
|
| matshow(self, Z, **kwargs)
| Plot a matrix or array as an 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 : array_like shape (n, m)
| The matrix to be displayed.
|
| Returns
| -------
| image : `~matplotlib.image.AxesImage`
|
| Other Parameters
| ----------------
| **kwargs : `~matplotlib.axes.Axes.imshow` arguments
| Sets `origin` to 'upper', 'interpolation' to 'nearest' and
| 'aspect' to equal.
|
| See also
| --------
| imshow : plot an image
|
| pcolorfast(self, *args, data=None, **kwargs)
| pseudocolor plot of a 2-D array
|
| Experimental; this is a pcolor-type method that
| provides the fastest possible rendering with the Agg
| backend, and that can handle any quadrilateral grid.
| It supports only flat shading (no outlines), it lacks
| support for log scaling of the axes, and it does not
| have a pyplot wrapper.
|
| Call signatures::
|
| ax.pcolorfast(C, **kwargs)
| ax.pcolorfast(xr, yr, C, **kwargs)
| ax.pcolorfast(x, y, C, **kwargs)
| ax.pcolorfast(X, Y, C, **kwargs)
|
| C is the 2D array of color values corresponding to quadrilateral
| cells. Let (nr, nc) be its shape. C may be a masked array.
|
| ``ax.pcolorfast(C, **kwargs)`` is equivalent to
| ``ax.pcolorfast([0,nc], [0,nr], C, **kwargs)``
|
| *xr*, *yr* specify the ranges of *x* and *y* corresponding to the
| rectangular region bounding *C*. If::
|
| xr = [x0, x1]
|
| and::
|
| yr = [y0,y1]
|
| then *x* goes from *x0* to *x1* as the second index of *C* goes
| from 0 to *nc*, etc. (*x0*, *y0*) is the outermost corner of
| cell (0,0), and (*x1*, *y1*) is the outermost corner of cell
| (*nr*-1, *nc*-1). All cells are rectangles of the same size.
| This is the fastest version.
|
| *x*, *y* are monotonic 1D arrays of length *nc* +1 and *nr* +1,
| respectively, giving the x and y boundaries of the cells. Hence
| the cells are rectangular but the grid may be nonuniform. The
| speed is intermediate. (The grid is checked, and if found to be
| uniform the fast version is used.)
|
| *X* and *Y* are 2D arrays with shape (*nr* +1, *nc* +1) that specify
| the (x,y) coordinates of the corners of the colored
| quadrilaterals; the quadrilateral for C[i,j] has corners at
| (X[i,j],Y[i,j]), (X[i,j+1],Y[i,j+1]), (X[i+1,j],Y[i+1,j]),
| (X[i+1,j+1],Y[i+1,j+1]). The cells need not be rectangular.
| 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.
|
| Note that the column index corresponds to the x-coordinate,
| and the row index corresponds to y; for details, see
| :ref:`Grid Orientation <axes-pcolor-grid-orientation>`.
|
| Optional keyword arguments:
|
| *cmap*: [ *None* | Colormap ]
| A :class:`matplotlib.colors.Colormap` instance from cm. If *None*,
| use rc settings.
|
| *norm*: [ *None* | Normalize ]
| A :class:`matplotlib.colors.Normalize` instance is used to scale
| luminance data to 0,1. If *None*, defaults to normalize()
|
| *vmin*/*vmax*: [ *None* | scalar ]
| *vmin* and *vmax* are used in conjunction with norm to normalize
| luminance data. If either are *None*, the min and max
| of the color array *C* is used. If you pass a norm instance,
| *vmin* and *vmax* will be *None*.
|
| *alpha*: ``0 <= scalar <= 1`` or *None*
| the alpha blending value
|
| Return value is an image if a regular or rectangular grid
| is specified, and a :class:`~matplotlib.collections.QuadMesh`
| collection in the general quadrilateral case.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All positional and all keyword arguments.
|
| phase_spectrum(self, x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)
| Plot the phase spectrum.
|
| Call signature::
|
| phase_spectrum(x, Fs=2, Fc=0, window=mlab.window_hanning,
| pad_to=None, sides='default', **kwargs)
|
| 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
| ----------
| x : 1-D array or sequence
| Array or sequence containing the data
|
| Fs : scalar
| The sampling frequency (samples per time unit). It is used
| to calculate the Fourier frequencies, freqs, in cycles per time
| unit. The default value is 2.
|
| window : callable or ndarray
| A function or a vector of length *NFFT*. To create window
| vectors see :func:`window_hanning`, :func:`window_none`,
| :func:`numpy.blackman`, :func:`numpy.hamming`,
| :func:`numpy.bartlett`, :func:`scipy.signal`,
| :func:`scipy.signal.get_window`, etc. The default is
| :func:`window_hanning`. 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' ]
| Specifies which sides of the spectrum to return. Default gives the
| default behavior, which returns one-sided for real data and both
| for complex data. 'onesided' forces the return of a one-sided
| spectrum, while 'twosided' forces two-sided.
|
| pad_to : integer
| 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).
|
| Fc : integer
| The center frequency of *x* (defaults to 0), 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
| -------
| spectrum : 1-D array
| The values for the phase spectrum in radians (real valued)
|
| freqs : 1-D array
| The frequencies corresponding to the elements in *spectrum*
|
| line : a :class:`~matplotlib.lines.Line2D` instance
| The line created by this function
|
| Other Parameters
| ----------------
| **kwargs :
| Keyword arguments control the :class:`~matplotlib.lines.Line2D`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| See Also
| --------
| :func:`magnitude_spectrum`
| :func:`magnitude_spectrum` plots the magnitudes of the
| corresponding frequencies.
|
| :func:`angle_spectrum`
| :func:`angle_spectrum` plots the wrapped version of this function.
|
| :func:`specgram`
| :func:`specgram` can plot the phase spectrum of segments within the
| signal in a colormap.
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x'.
|
| pie(self, x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=None, radius=None, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, *, data=None)
| 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
| ----------
| x : array-like
| The wedge sizes.
|
| explode : array-like, optional, default: None
| If not *None*, is a ``len(x)`` array which specifies the fraction
| of the radius with which to offset each wedge.
|
| labels : list, optional, default: None
| A sequence of strings providing the labels for each wedge
|
| colors : array-like, optional, default: None
| A sequence of matplotlib color args through which the pie chart
| will cycle. If *None*, will use the colors in the currently
| active cycle.
|
| autopct : None (default), string, or function, optional
| If not *None*, is a string or function used to label the wedges
| with their numeric value. The label will be placed inside the
| wedge. If it is a format string, the label will be ``fmt%pct``.
| If it is a function, it will be called.
|
| pctdistance : float, optional, 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*.
|
| shadow : bool, optional, default: False
| Draw a shadow beneath the pie.
|
| labeldistance : float, optional, default: 1.1
| The radial distance at which the pie labels are drawn
|
| startangle : float, optional, default: None
| If not *None*, rotates the start of the pie chart by *angle*
| degrees counterclockwise from the x-axis.
|
| radius : float, optional, default: None
| The radius of the pie, if *radius* is *None* it will be set to 1.
|
| counterclock : bool, optional, default: True
| Specify fractions direction, clockwise or counterclockwise.
|
| wedgeprops : dict, optional, 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``.
|
| textprops : dict, optional, default: None
| Dict of arguments to pass to the text objects.
|
| center : list of float, optional, default: (0, 0)
| Center position of the chart. Takes value (0, 0) or is a sequence
| of 2 scalars.
|
| frame : bool, optional, default: False
| Plot axes frame with the chart if true.
|
| rotatelabels : bool, optional, default: False
| Rotate each label to the angle of the corresponding slice if true.
|
| Returns
| -------
| patches : list
| A sequence of :class:`matplotlib.patches.Wedge` instances
|
| texts : list
| A list of the label :class:`matplotlib.text.Text` instances.
|
| autotexts : list
| A list of :class:`~matplotlib.text.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.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'colors', 'explode', 'labels', 'x'.
|
| plot(self, *args, data=None, **kwargs)
| 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.DataFame` 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')
|
| - Alternatively, if your data is already a 2d array, you can pass it
| directly to *x*, *y*. A separate data set will be drawn for every
| column.
|
| Example: an array ``a`` where the first column represents the *x*
| values and the other columns are the *y* columns::
|
| >>> plot(a[0], a[1:])
|
| - 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 the
| 'axes.prop_cycle' rcParam.
|
| Parameters
| ----------
| x, y : array-like or scalar
| The horizontal / vertical coordinates of the data points.
| *x* values are optional. If not given, they default to
| ``[0, ..., N-1]``.
|
| Commonly, these parameters are arrays of length N. However,
| scalars are supported as well (equivalent to an array with
| constant value).
|
| The parameters can also be 2-dimensional. Then, the columns
| represent separate data sets.
|
| fmt : str, 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.
|
| data : indexable 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)`.
|
|
| Other Parameters
| ----------------
| scalex, scaley : bool, optional, default: True
| These parameters determined if the view limits are adapted to
| the data limits. The values are passed on to `autoscale_view`.
|
| **kwargs : `.Line2D` 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 make multiple lines with one plot command, the kwargs
| apply to all those lines.
|
| Here is a list of available `.Line2D` 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| Returns
| -------
| lines
| A list of `.Line2D` objects representing the plotted data.
|
|
| See Also
| --------
| scatter : XY scatter plot with markers of variing 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 = '[color][marker][line]'
|
| 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.
|
| **Colors**
|
| The following color abbreviations are supported:
|
| ============= ===============================
| character color
| ============= ===============================
| ``'b'`` blue
| ``'g'`` green
| ``'r'`` red
| ``'c'`` cyan
| ``'m'`` magenta
| ``'y'`` yellow
| ``'k'`` black
| ``'w'`` white
| ============= ===============================
|
| 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'``).
|
| **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
| ``'s'`` square marker
| ``'p'`` pentagon marker
| ``'*'`` star marker
| ``'h'`` hexagon1 marker
| ``'H'`` hexagon2 marker
| ``'+'`` plus marker
| ``'x'`` x 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
| 'ro' # red circles
| 'g-' # green solid line
| '--' # dashed line with default color
| 'k^:' # black triangle_up markers connected by a dotted line
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| plot_date(self, x, y, fmt='o', tz=None, xdate=True, ydate=False, *, data=None, **kwargs)
| Plot data that contains dates.
|
| 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*.
|
| Parameters
| ----------
| x, y : array-like
| The coordinates of the data points. If *xdate* or *ydate* is
| *True*, the respective values *x* or *y* are interpreted as
| :ref:`Matplotlib dates <date-format>`.
|
| fmt : str, optional
| The plot format string. For details, see the corresponding
| parameter in `.plot`.
|
| tz : [ *None* | timezone string | :class:`tzinfo` instance]
| The time zone to use in labeling dates. If *None*, defaults to
| rcParam ``timezone``.
|
| xdate : bool, optional, default: True
| If *True*, the *x*-axis will be interpreted as Matplotlib dates.
|
| ydate : bool, optional, default: False
| If *True*, the *y*-axis will be interpreted as Matplotlib dates.
|
|
| Returns
| -------
| lines
| A list of `~.Line2D` objects representing the plotted data.
|
|
| Other Parameters
| ----------------
| **kwargs
| Keyword arguments control the :class:`~matplotlib.lines.Line2D`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| 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).
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| psd(self, 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)
| Plot the power spectral density.
|
| Call signature::
|
| psd(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,
| window=mlab.window_hanning, noverlap=0, pad_to=None,
| sides='default', scale_by_freq=None, return_line=None, **kwargs)
|
| The power spectral density :math:`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 :math:`|\mathrm{fft}(i)|^2`
| of each segment :math:`i` are averaged to compute :math:`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
| ----------
| x : 1-D array or sequence
| Array or sequence containing the data
|
| Fs : scalar
| The sampling frequency (samples per time unit). It is used
| to calculate the Fourier frequencies, freqs, in cycles per time
| unit. The default value is 2.
|
| window : callable or ndarray
| A function or a vector of length *NFFT*. To create window
| vectors see :func:`window_hanning`, :func:`window_none`,
| :func:`numpy.blackman`, :func:`numpy.hamming`,
| :func:`numpy.bartlett`, :func:`scipy.signal`,
| :func:`scipy.signal.get_window`, etc. The default is
| :func:`window_hanning`. 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' ]
| Specifies which sides of the spectrum to return. Default gives the
| default behavior, which returns one-sided for real data and both
| for complex data. 'onesided' forces the return of a one-sided
| spectrum, while 'twosided' forces two-sided.
|
| pad_to : integer
| 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*
|
| NFFT : integer
| The number of data points used in each block for the FFT.
| A power 2 is most efficient. The default value is 256.
| 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 : {'default', 'constant', 'mean', 'linear', 'none'} or callable
| The function applied to each segment before fft-ing,
| designed to remove the mean or linear trend. Unlike in
| MATLAB, where the *detrend* parameter is a vector, in
| matplotlib is it a function. The :mod:`~matplotlib.pylab`
| module defines :func:`~matplotlib.pylab.detrend_none`,
| :func:`~matplotlib.pylab.detrend_mean`, and
| :func:`~matplotlib.pylab.detrend_linear`, but you can use
| a custom function as well. You can also use a string to choose
| one of the functions. 'default', 'constant', and 'mean' call
| :func:`~matplotlib.pylab.detrend_mean`. 'linear' calls
| :func:`~matplotlib.pylab.detrend_linear`. 'none' calls
| :func:`~matplotlib.pylab.detrend_none`.
|
| scale_by_freq : boolean, optional
| Specifies 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.
|
| noverlap : integer
| The number of points of overlap between segments.
| The default value is 0 (no overlap).
|
| Fc : integer
| The center frequency of *x* (defaults to 0), 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_line : bool
| Whether to include the line object plotted in the returned values.
| Default is False.
|
| Returns
| -------
| Pxx : 1-D array
| The values for the power spectrum `P_{xx}` before scaling
| (real valued)
|
| freqs : 1-D array
| The frequencies corresponding to the elements in *Pxx*
|
| line : a :class:`~matplotlib.lines.Line2D` instance
| The line created by this function.
| Only returned if *return_line* is True.
|
| Other Parameters
| ----------------
| **kwargs :
| Keyword arguments control the :class:`~matplotlib.lines.Line2D`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| See Also
| --------
| :func:`specgram`
| :func:`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.
|
| :func:`magnitude_spectrum`
| :func:`magnitude_spectrum` plots the magnitude spectrum.
|
| :func:`csd`
| :func:`csd` plots the spectral density between two signals.
|
| Notes
| -----
| For plotting, the power is plotted as
| :math:`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)
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x'.
|
| quiverkey(self, *args, **kw)
| Add a key to a quiver plot.
|
| Call signature::
|
| quiverkey(Q, X, Y, U, label, **kw)
|
| Arguments:
|
| *Q*:
| The Quiver instance returned by a call to quiver.
|
| *X*, *Y*:
| The location of the key; additional explanation follows.
|
| *U*:
| The length of the key
|
| *label*:
| A string with the length and units of the key
|
| Keyword arguments:
|
| *angle* = 0
| The angle of the key arrow. Measured in degrees anti-clockwise from the
| x-axis.
|
| *coordinates* = [ 'axes' | 'figure' | 'data' | 'inches' ]
| Coordinate system and units for *X*, *Y*: 'axes' and 'figure' are
| normalized coordinate systems with 0,0 in the lower left and 1,1
| in the upper right; 'data' are the axes data coordinates (used for
| the locations of the vectors in the quiver plot itself); 'inches'
| is position in the figure in inches, with 0,0 at the lower left
| corner.
|
| *color*:
| overrides face and edge colors from *Q*.
|
| *labelpos* = [ 'N' | 'S' | 'E' | 'W' ]
| Position the label above, below, to the right, to the left of the
| arrow, respectively.
|
| *labelsep*:
| Distance in inches between the arrow and the label. Default is
| 0.1
|
| *labelcolor*:
| defaults to default :class:`~matplotlib.text.Text` color.
|
| *fontproperties*:
| A dictionary with keyword arguments accepted by the
| :class:`~matplotlib.font_manager.FontProperties` initializer:
| *family*, *style*, *variant*, *size*, *weight*
|
| Any additional keyword arguments are used to override vector
| properties taken from *Q*.
|
| The positioning of the key depends on *X*, *Y*, *coordinates*, and
| *labelpos*. If *labelpos* is 'N' or 'S', *X*, *Y* give the position
| of the middle of the key arrow. If *labelpos* is 'E', *X*, *Y*
| positions the head, and if *labelpos* is 'W', *X*, *Y* positions the
| tail; in either of these two cases, *X*, *Y* is somewhere in the
| middle of the arrow+label key object.
|
| semilogx(self, *args, **kwargs)
| 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 *basex*, *subsx* and *nonposx* control the
| x-axis properties. They are just forwarded to `.Axes.set_xscale`.
|
| Parameters
| ----------
| basex : scalar, optional, default 10
| Base of the x logarithm.
|
| subsx : array_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.
|
| nonposx : {'mask', 'clip'}, optional, default 'mask'
| Non-positive values in x can be masked as invalid, or clipped to a
| very small positive number.
|
| Returns
| -------
| lines
| A list of `~.Line2D` objects representing the plotted data.
|
| Other Parameters
| ----------------
| **kwargs
| All parameters supported by `.plot`.
|
| semilogy(self, *args, **kwargs)
| 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 *basey*, *subsy* and *nonposy* control the
| y-axis properties. They are just forwarded to `.Axes.set_yscale`.
|
| Parameters
| ----------
| basey : scalar, optional, default 10
| Base of the y logarithm.
|
| subsy : array_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.
|
| nonposy : {'mask', 'clip'}, optional, default 'mask'
| Non-positive values in y can be masked as invalid, or clipped to a
| very small positive number.
|
| Returns
| -------
| lines
| A list of `~.Line2D` objects representing the plotted data.
|
| Other Parameters
| ----------------
| **kwargs
| All parameters supported by `.plot`.
|
| set_title(self, label, fontdict=None, loc='center', pad=None, **kwargs)
| 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
| ----------
| label : str
| Text to use for the title
|
| fontdict : dict
| A dictionary controlling the appearance of the title text,
| the default `fontdict` is::
|
| {'fontsize': rcParams['axes.titlesize'],
| 'fontweight' : rcParams['axes.titleweight'],
| 'verticalalignment': 'baseline',
| 'horizontalalignment': loc}
|
| loc : {'center', 'left', 'right'}, str, optional
| Which title to set, defaults to 'center'
|
| pad : float
| The offset of the title from the top of the axes, in points.
| Default is ``None`` to use rcParams['axes.titlepad'].
|
| Returns
| -------
| text : :class:`~matplotlib.text.Text`
| The matplotlib text instance representing the title
|
| Other Parameters
| ----------------
| **kwargs : `~matplotlib.text.Text` properties
| Other keyword arguments are text properties, see
| :class:`~matplotlib.text.Text` for a list of valid text
| properties.
|
| set_xlabel(self, xlabel, fontdict=None, labelpad=None, **kwargs)
| Set the label for the x-axis.
|
| Parameters
| ----------
| xlabel : str
| The label text.
|
| labelpad : scalar, optional, default: None
| Spacing in points between the label and the x-axis.
|
| Other Parameters
| ----------------
| **kwargs : `.Text` properties
| `.Text` properties control the appearance of the label.
|
| See also
| --------
| text : for information on how override and the optional args work
|
| set_ylabel(self, ylabel, fontdict=None, labelpad=None, **kwargs)
| Set the label for the y-axis.
|
| Parameters
| ----------
| ylabel : str
| The label text.
|
| labelpad : scalar, optional, default: None
| Spacing in points between the label and the y-axis.
|
| Other Parameters
| ----------------
| **kwargs : `.Text` properties
| `.Text` properties control the appearance of the label.
|
| See also
| --------
| text : for information on how override and the optional args work
|
| specgram(self, 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)
| Plot a spectrogram.
|
| Call signature::
|
| specgram(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,
| window=mlab.window_hanning, noverlap=128,
| cmap=None, xextent=None, pad_to=None, sides='default',
| scale_by_freq=None, mode='default', scale='default',
| **kwargs)
|
| 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
| ----------
| x : 1-D array or sequence
| Array or sequence containing the data.
|
| Fs : scalar
| The sampling frequency (samples per time unit). It is used
| to calculate the Fourier frequencies, freqs, in cycles per time
| unit. The default value is 2.
|
| window : callable or ndarray
| A function or a vector of length *NFFT*. To create window
| vectors see :func:`window_hanning`, :func:`window_none`,
| :func:`numpy.blackman`, :func:`numpy.hamming`,
| :func:`numpy.bartlett`, :func:`scipy.signal`,
| :func:`scipy.signal.get_window`, etc. The default is
| :func:`window_hanning`. 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' ]
| Specifies which sides of the spectrum to return. Default gives the
| default behavior, which returns one-sided for real data and both
| for complex data. 'onesided' forces the return of a one-sided
| spectrum, while 'twosided' forces two-sided.
|
| pad_to : integer
| 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*
|
| NFFT : integer
| The number of data points used in each block for the FFT.
| A power 2 is most efficient. The default value is 256.
| 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 : {'default', 'constant', 'mean', 'linear', 'none'} or callable
| The function applied to each segment before fft-ing,
| designed to remove the mean or linear trend. Unlike in
| MATLAB, where the *detrend* parameter is a vector, in
| matplotlib is it a function. The :mod:`~matplotlib.pylab`
| module defines :func:`~matplotlib.pylab.detrend_none`,
| :func:`~matplotlib.pylab.detrend_mean`, and
| :func:`~matplotlib.pylab.detrend_linear`, but you can use
| a custom function as well. You can also use a string to choose
| one of the functions. 'default', 'constant', and 'mean' call
| :func:`~matplotlib.pylab.detrend_mean`. 'linear' calls
| :func:`~matplotlib.pylab.detrend_linear`. 'none' calls
| :func:`~matplotlib.pylab.detrend_none`.
|
| scale_by_freq : boolean, optional
| Specifies 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. 'complex' returns the complex-valued
| frequency spectrum. 'magnitude' returns the magnitude spectrum.
| 'angle' returns the phase spectrum without unwrapping. 'phase'
| returns the phase spectrum with unwrapping.
|
| noverlap : integer
| The number of points of overlap between blocks. The
| default value is 128.
|
| 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'.
|
| Fc : integer
| The center frequency of *x* (defaults to 0), 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.
|
| cmap :
| A :class:`matplotlib.colors.Colormap` instance; if *None*, use
| default determined by rc
|
| xextent : [None | (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.
|
| **kwargs :
| Additional kwargs are passed on to imshow which makes the
| specgram image
|
| Returns
| -------
| spectrum : 2-D array
| Columns are the periodograms of successive segments.
|
| freqs : 1-D array
| The frequencies corresponding to the rows in *spectrum*.
|
| t : 1-D array
| The times corresponding to midpoints of segments (i.e., the columns
| in *spectrum*).
|
| im : instance of class :class:`~matplotlib.image.AxesImage`
| The image created by imshow containing the spectrogram
|
| See Also
| --------
| :func:`psd`
| :func:`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.
|
| :func:`magnitude_spectrum`
| A single spectrum, similar to having a single segment when *mode*
| is 'magnitude'. Plots a line instead of a colormap.
|
| :func:`angle_spectrum`
| A single spectrum, similar to having a single segment when *mode*
| is 'angle'. Plots a line instead of a colormap.
|
| :func:`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'.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x'.
|
| spy(self, Z, precision=0, marker=None, markersize=None, aspect='equal', origin='upper', **kwargs)
| Plot the sparsity pattern on a 2-D array.
|
| ``spy(Z)`` plots the sparsity pattern of the 2-D array *Z*.
|
| Parameters
| ----------
|
| Z : sparse array (n, m)
| The array to be plotted.
|
| precision : float, optional, default: 0
| If *precision* is 0, any non-zero value will be plotted; else,
| values of :math:`|Z| > precision` will be plotted.
|
| For :class:`scipy.sparse.spmatrix` instances, there is a special
| case: if *precision* is 'present', any value present in the array
| will be plotted, even if it is identically zero.
|
| origin : ["upper", "lower"], optional, default: "upper"
| Place the [0,0] index of the array in the upper left or lower left
| corner of the axes.
|
| aspect : ['auto' | 'equal' | scalar], optional, default: "equal"
|
| If 'equal', and `extent` is None, changes the axes aspect ratio to
| match that of the image. If `extent` is not `None`, the axes
| aspect ratio is changed to match that of the extent.
|
|
| If 'auto', changes the image aspect ratio to match that of the
| axes.
|
| If None, default to rc ``image.aspect`` value.
|
| Two plotting styles are available: image or marker. Both
| are available for full arrays, but only the marker style
| works for :class:`scipy.sparse.spmatrix` instances.
|
| If *marker* and *markersize* are *None*, an image will be
| returned and any remaining kwargs are passed to
| :func:`~matplotlib.pyplot.imshow`; else, a
| :class:`~matplotlib.lines.Line2D` object will be returned with
| the value of marker determining the marker type, and any
| remaining kwargs passed to the
| :meth:`~matplotlib.axes.Axes.plot` method.
|
| If *marker* and *markersize* are *None*, useful kwargs include:
|
| * *cmap*
| * *alpha*
|
| See also
| --------
| imshow : for image options.
| plot : for plotting options
|
| stackplot(self, x, *args, data=None, **kwargs)
| Draws a stacked area plot.
|
| Parameters
| ----------
| x : 1d array of dimension N
|
| y : 2d array (dimension MxN), or sequence of 1d arrays (each dimension 1xN)
|
| The data is assumed to be unstacked. Each of the following
| calls is legal::
|
| stackplot(x, y) # where y is MxN
| stackplot(x, y1, y2, y3, y4) # where y1, y2, y3, y4, are all 1xNm
|
| 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/.
|
| labels : Length N sequence of strings
| Labels to assign to each data series.
|
| colors : Length N sequence of colors
| A list or tuple of colors. These will be cycled through and used to
| colour the stacked areas.
|
| **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.
|
| stem(self, *args, data=None, **kwargs)
| Create a stem plot.
|
| A stem plot plots vertical lines at each *x* location from the baseline
| to *y*, and places a marker there.
|
| Call signature::
|
| stem([x,] y, linefmt=None, markerfmt=None, basefmt=None)
|
| The x-positions are optional. The formats may be provided either as
| positional or as keyword-arguments.
|
| Parameters
| ----------
| x : array-like, optional
| The x-positions of the stems. Default: (0, 1, ..., len(y) - 1).
|
| y : array-like
| The y-values of the stem heads.
|
| linefmt : str, optional
| A string defining the properties of the vertical lines. Usually,
| this will be a color or a color and a linestyle:
|
| ========= =============
| 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: While it is technically possible to specify valid formats
| other than color or color and linestyle (e.g. 'rx' or '-.'), this
| is beyond the intention of the method and will most likely not
| result in a reasonable reasonable plot.
|
| markerfmt : str, optional
| A string defining the properties of the markers at the stem heads.
| Default: 'C0o', i.e. filled circles with the first color of the
| color cycle.
|
| basefmt : str, optional
| A format string defining the properties of the baseline.
|
| Default: 'C3-' ('C2-' in classic mode).
|
| bottom : float, optional, default: 0
| The y-position of the baseline.
|
| label : str, optional, default: None
| The label to use for the stems in legends.
|
|
| Other Parameters
| ----------------
| **kwargs
| No other parameters are supported. They are currently ignored
| silently for backward compatibility. This behavior is deprecated.
| Future versions will not accept any other parameters and will
| raise a TypeError instead.
|
|
| Returns
| -------
| :class:`~matplotlib.container.StemContainer`
| The stemcontainer may be treated like a tuple
| (*markerline*, *stemlines*, *baseline*)
|
|
| Notes
| -----
|
| .. seealso::
| The MATLAB function
| `stem <http://www.mathworks.com/help/techdoc/ref/stem.html>`_
| which inspired this method.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All positional and all keyword arguments.
|
| step(self, x, y, *args, data=None, **kwargs)
| 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.
|
| Parameters
| ----------
| x : array_like
| 1-D sequence of x positions. It is assumed, but not checked, that
| it is uniformly increasing.
|
| y : array_like
| 1-D sequence of y levels.
|
| fmt : str, 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.
|
| data : indexable object, optional
| An object with labelled data. If given, provide the label names to
| plot in *x* and *y*.
|
| where : {'pre', 'post', 'mid'}, optional, 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.
|
| Returns
| -------
| lines
| A list of `.Line2D` objects representing the plotted data.
|
| Other Parameters
| ----------------
| **kwargs
| Additional parameters are the same as those for `.plot`.
|
| Notes
| -----
| .. [notes section required to get data note injection right]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| table(self, **kwargs)
| Add a table to the current axes.
|
| Call signature::
|
| table(cellText=None, cellColours=None,
| cellLoc='right', colWidths=None,
| rowLabels=None, rowColours=None, rowLoc='left',
| colLabels=None, colColours=None, colLoc='center',
| loc='bottom', bbox=None)
|
| Returns a :class:`matplotlib.table.Table` instance. Either `cellText`
| or `cellColours` must be provided. For finer grained control over
| tables, use the :class:`~matplotlib.table.Table` class and add it to
| the axes with :meth:`~matplotlib.axes.Axes.add_table`.
|
| Thanks to John Gill for providing the class and table.
|
| kwargs control the :class:`~matplotlib.table.Table`
| 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
| alpha: float (0.0 transparent through 1.0 opaque)
| animated: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| contains: a callable function
| figure: a `.Figure` instance
| fontsize: a float in points
| gid: an id string
| label: object
| path_effects: `.AbstractPathEffect`
| picker: [None | bool | float | callable]
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| transform: `.Transform`
| url: a url string
| visible: bool
| zorder: float
|
| text(self, x, y, s, fontdict=None, withdash=False, **kwargs)
| Add text to the axes.
|
| Add the text *s* to the axes at location *x*, *y* in data coordinates.
|
| Parameters
| ----------
| x, y : scalars
| The position to place the text. By default, this is in data
| coordinates. The coordinate system can be changed using the
| *transform* parameter.
|
| s : str
| The text.
|
| fontdict : dictionary, optional, default: None
| A dictionary to override the default text properties. If fontdict
| is None, the defaults are determined by your rc parameters.
|
| withdash : boolean, optional, default: False
| Creates a `~matplotlib.text.TextWithDash` instance instead of a
| `~matplotlib.text.Text` instance.
|
| Returns
| -------
| text : `.Text`
| The created `.Text` instance.
|
| Other Parameters
| ----------------
| **kwargs : `~matplotlib.text.Text` properties.
| Other miscellaneous text parameters.
|
| 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 `~matplotlib.patches.Rectangle`
| properties. For example::
|
| >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))
|
| tricontour(self, *args, **kwargs)
| Draw contours on an unstructured triangular grid.
| :func:`~matplotlib.pyplot.tricontour` and
| :func:`~matplotlib.pyplot.tricontourf` draw contour lines and
| filled contours, respectively. Except as noted, function
| signatures and return values are the same for both versions.
|
| The triangulation can be specified in one of two ways; either::
|
| tricontour(triangulation, ...)
|
| where triangulation is a :class:`matplotlib.tri.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
| :class:`~matplotlib.tri.Triangulation` for a explanation of
| these possibilities.
|
| 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, N)
|
| contour up to *N+1* automatically chosen contour levels
| (*N* intervals).
|
| ::
|
| tricontour(..., Z, V)
|
| draw contour lines at the values specified in sequence *V*,
| which must be in increasing order.
|
| ::
|
| tricontourf(..., Z, V)
|
| fill the (len(*V*)-1) regions between the values in *V*,
| which must be in increasing order.
|
| ::
|
| tricontour(Z, **kwargs)
|
| Use keyword args to control colors, linewidth, origin, cmap ... see
| below for more details.
|
| ``C = tricontour(...)`` returns a
| :class:`~matplotlib.contour.TriContourSet` object.
|
| Optional keyword arguments:
|
| *colors*: [ *None* | string | (mpl_colors) ]
| If *None*, the colormap specified by cmap will be used.
|
| If a string, like 'r' or 'red', all levels will be plotted in this
| color.
|
| If a tuple of matplotlib color args (string, float, rgb, etc),
| different levels will be plotted in different colors in the order
| specified.
|
| *alpha*: float
| The alpha blending value
|
| *cmap*: [ *None* | Colormap ]
| A cm :class:`~matplotlib.colors.Colormap` instance or
| *None*. If *cmap* is *None* and *colors* is *None*, a
| default Colormap is used.
|
| *norm*: [ *None* | Normalize ]
| A :class:`matplotlib.colors.Normalize` instance for
| scaling data values to colors. If *norm* is *None* and
| *colors* is *None*, the default linear scaling is used.
|
| *levels* [level0, level1, ..., leveln]
| A list of floating point numbers indicating the level
| curves to draw, in increasing order; e.g., to draw just
| the zero contour pass ``levels=[0]``
|
| *origin*: [ *None* | 'upper' | 'lower' | 'image' ]
| If *None*, the first value of *Z* will correspond to the
| lower left corner, location (0,0). If 'image', the rc
| value for ``image.origin`` will be used.
|
| This keyword is not active if *X* and *Y* are specified in
| the call to contour.
|
| *extent*: [ *None* | (x0,x1,y0,y1) ]
|
| If *origin* is not *None*, then *extent* is interpreted as
| in :func:`matplotlib.pyplot.imshow`: it gives the outer
| pixel boundaries. In this case, the position of Z[0,0]
| is the center of the pixel, not a corner. If *origin* is
| *None*, then (*x0*, *y0*) is the position of Z[0,0], and
| (*x1*, *y1*) is the position of Z[-1,-1].
|
| This keyword is not active if *X* and *Y* are specified in
| the call to contour.
|
| *locator*: [ *None* | ticker.Locator subclass ]
| If *locator* is None, the default
| :class:`~matplotlib.ticker.MaxNLocator` is used. The
| locator is used to determine the contour levels if they
| are not given explicitly via the *V* argument.
|
| *extend*: [ 'neither' | 'both' | 'min' | 'max' ]
| Unless this is 'neither', contour levels are automatically
| added to one or both ends of the range so that all data
| are included. These added ranges are then mapped to the
| special colormap values which default to the ends of the
| colormap range, but can be set via
| :meth:`matplotlib.colors.Colormap.set_under` and
| :meth:`matplotlib.colors.Colormap.set_over` methods.
|
| *xunits*, *yunits*: [ *None* | registered units ]
| Override axis units by specifying an instance of a
| :class:`matplotlib.units.ConversionInterface`.
|
|
| tricontour-only keyword arguments:
|
| *linewidths*: [ *None* | number | tuple of numbers ]
| If *linewidths* is *None*, the default width in
| ``lines.linewidth`` in ``matplotlibrc`` is used.
|
| If a number, all levels will be plotted with this linewidth.
|
| If a tuple, different levels will be plotted with different
| linewidths in the order specified
|
| *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
| If *linestyles* is *None*, the 'solid' is used.
|
| *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.
|
| If contour is using a monochrome colormap and the contour
| level is less than 0, then the linestyle specified
| in ``contour.negative_linestyle`` in ``matplotlibrc``
| will be used.
|
| tricontourf-only keyword arguments:
|
| *antialiased*: bool
| enable antialiasing
|
| Note: tricontourf fills intervals that are closed at the top; that
| is, for boundaries *z1* and *z2*, the filled region is::
|
| z1 < z <= z2
|
| There is one exception: if the lowest boundary coincides with
| the minimum value of the *z* array, then that minimum value
| will be included in the lowest interval.
|
| tricontourf(self, *args, **kwargs)
| Draw contours on an unstructured triangular grid.
| :func:`~matplotlib.pyplot.tricontour` and
| :func:`~matplotlib.pyplot.tricontourf` draw contour lines and
| filled contours, respectively. Except as noted, function
| signatures and return values are the same for both versions.
|
| The triangulation can be specified in one of two ways; either::
|
| tricontour(triangulation, ...)
|
| where triangulation is a :class:`matplotlib.tri.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
| :class:`~matplotlib.tri.Triangulation` for a explanation of
| these possibilities.
|
| 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, N)
|
| contour up to *N+1* automatically chosen contour levels
| (*N* intervals).
|
| ::
|
| tricontour(..., Z, V)
|
| draw contour lines at the values specified in sequence *V*,
| which must be in increasing order.
|
| ::
|
| tricontourf(..., Z, V)
|
| fill the (len(*V*)-1) regions between the values in *V*,
| which must be in increasing order.
|
| ::
|
| tricontour(Z, **kwargs)
|
| Use keyword args to control colors, linewidth, origin, cmap ... see
| below for more details.
|
| ``C = tricontour(...)`` returns a
| :class:`~matplotlib.contour.TriContourSet` object.
|
| Optional keyword arguments:
|
| *colors*: [ *None* | string | (mpl_colors) ]
| If *None*, the colormap specified by cmap will be used.
|
| If a string, like 'r' or 'red', all levels will be plotted in this
| color.
|
| If a tuple of matplotlib color args (string, float, rgb, etc),
| different levels will be plotted in different colors in the order
| specified.
|
| *alpha*: float
| The alpha blending value
|
| *cmap*: [ *None* | Colormap ]
| A cm :class:`~matplotlib.colors.Colormap` instance or
| *None*. If *cmap* is *None* and *colors* is *None*, a
| default Colormap is used.
|
| *norm*: [ *None* | Normalize ]
| A :class:`matplotlib.colors.Normalize` instance for
| scaling data values to colors. If *norm* is *None* and
| *colors* is *None*, the default linear scaling is used.
|
| *levels* [level0, level1, ..., leveln]
| A list of floating point numbers indicating the level
| curves to draw, in increasing order; e.g., to draw just
| the zero contour pass ``levels=[0]``
|
| *origin*: [ *None* | 'upper' | 'lower' | 'image' ]
| If *None*, the first value of *Z* will correspond to the
| lower left corner, location (0,0). If 'image', the rc
| value for ``image.origin`` will be used.
|
| This keyword is not active if *X* and *Y* are specified in
| the call to contour.
|
| *extent*: [ *None* | (x0,x1,y0,y1) ]
|
| If *origin* is not *None*, then *extent* is interpreted as
| in :func:`matplotlib.pyplot.imshow`: it gives the outer
| pixel boundaries. In this case, the position of Z[0,0]
| is the center of the pixel, not a corner. If *origin* is
| *None*, then (*x0*, *y0*) is the position of Z[0,0], and
| (*x1*, *y1*) is the position of Z[-1,-1].
|
| This keyword is not active if *X* and *Y* are specified in
| the call to contour.
|
| *locator*: [ *None* | ticker.Locator subclass ]
| If *locator* is None, the default
| :class:`~matplotlib.ticker.MaxNLocator` is used. The
| locator is used to determine the contour levels if they
| are not given explicitly via the *V* argument.
|
| *extend*: [ 'neither' | 'both' | 'min' | 'max' ]
| Unless this is 'neither', contour levels are automatically
| added to one or both ends of the range so that all data
| are included. These added ranges are then mapped to the
| special colormap values which default to the ends of the
| colormap range, but can be set via
| :meth:`matplotlib.colors.Colormap.set_under` and
| :meth:`matplotlib.colors.Colormap.set_over` methods.
|
| *xunits*, *yunits*: [ *None* | registered units ]
| Override axis units by specifying an instance of a
| :class:`matplotlib.units.ConversionInterface`.
|
|
| tricontour-only keyword arguments:
|
| *linewidths*: [ *None* | number | tuple of numbers ]
| If *linewidths* is *None*, the default width in
| ``lines.linewidth`` in ``matplotlibrc`` is used.
|
| If a number, all levels will be plotted with this linewidth.
|
| If a tuple, different levels will be plotted with different
| linewidths in the order specified
|
| *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
| If *linestyles* is *None*, the 'solid' is used.
|
| *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.
|
| If contour is using a monochrome colormap and the contour
| level is less than 0, then the linestyle specified
| in ``contour.negative_linestyle`` in ``matplotlibrc``
| will be used.
|
| tricontourf-only keyword arguments:
|
| *antialiased*: bool
| enable antialiasing
|
| Note: tricontourf fills intervals that are closed at the top; that
| is, for boundaries *z1* and *z2*, the filled region is::
|
| z1 < z <= z2
|
| There is one exception: if the lowest boundary coincides with
| the minimum value of the *z* array, then that minimum value
| will be included in the lowest interval.
|
| tripcolor(self, *args, **kwargs)
| 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 :class:`matplotlib.tri.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
| :class:`~matplotlib.tri.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
| :meth:`~matplotlib.axes.Axes.pcolor`.
|
| triplot(self, *args, **kwargs)
| 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 :class:`matplotlib.tri.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
| :class:`~matplotlib.tri.Triangulation` for a explanation of these
| possibilities.
|
| The remaining args and kwargs are the same as for
| :meth:`~matplotlib.axes.Axes.plot`.
|
| Return a list of 2 :class:`~matplotlib.lines.Line2D` containing
| respectively:
|
| - the lines plotted for triangles edges
| - the markers plotted for triangles nodes
|
| violin(self, vpstats, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False)
| 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, and the maximum.
|
| Parameters
| ----------
|
| vpstats : list 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.
|
| positions : array-like, default = [1, 2, ..., n]
| Sets the positions of the violins. The ticks and limits are
| automatically set to match the positions.
|
| vert : bool, default = True.
| If true, plots the violins veritcally.
| Otherwise, plots the violins horizontally.
|
| widths : array-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.
|
| showmeans : bool, default = False
| If true, will toggle rendering of the means.
|
| showextrema : bool, default = True
| If true, will toggle rendering of the extrema.
|
| showmedians : bool, default = False
| If true, will toggle rendering of the medians.
|
| Returns
| -------
| result : 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
| :class:`matplotlib.collections.PolyCollection` instances
| containing the filled area of each violin.
|
| - ``cmeans``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the mean values of each of the
| violin's distribution.
|
| - ``cmins``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the bottom of each violin's
| distribution.
|
| - ``cmaxes``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the top of each violin's
| distribution.
|
| - ``cbars``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the centers of each violin's
| distribution.
|
| - ``cmedians``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the median values of each of the
| violin's distribution.
|
| violinplot(self, dataset, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False, points=100, bw_method=None, *, data=None)
| 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, and the maximum.
|
| Parameters
| ----------
| dataset : Array or a sequence of vectors.
| The input data.
|
| positions : array-like, default = [1, 2, ..., n]
| Sets the positions of the violins. The ticks and limits are
| automatically set to match the positions.
|
| vert : bool, default = True.
| If true, creates a vertical violin plot.
| Otherwise, creates a horizontal violin plot.
|
| widths : array-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.
|
| showmeans : bool, default = False
| If `True`, will toggle rendering of the means.
|
| showextrema : bool, default = True
| If `True`, will toggle rendering of the extrema.
|
| showmedians : bool, default = False
| If `True`, will toggle rendering of the medians.
|
| points : scalar, default = 100
| Defines the number of points to evaluate each of the
| gaussian kernel density estimations at.
|
| bw_method : str, 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.
|
| Returns
| -------
|
| result : 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
| :class:`matplotlib.collections.PolyCollection` instances
| containing the filled area of each violin.
|
| - ``cmeans``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the mean values of each of the
| violin's distribution.
|
| - ``cmins``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the bottom of each violin's
| distribution.
|
| - ``cmaxes``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the top of each violin's
| distribution.
|
| - ``cbars``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the centers of each violin's
| distribution.
|
| - ``cmedians``: A
| :class:`matplotlib.collections.LineCollection` instance
| created to identify the median values of each of the
| violin's distribution.
|
| Notes
| -----
| .. [Notes section required for data comment. See #10189.]
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'dataset'.
|
| vlines(self, x, ymin, ymax, colors='k', linestyles='solid', label='', *, data=None, **kwargs)
| Plot vertical lines.
|
| Plot vertical lines at each *x* from *ymin* to *ymax*.
|
| Parameters
| ----------
| x : scalar or 1D array_like
| x-indexes where to plot the lines.
|
| ymin, ymax : scalar or 1D array_like
| Respective beginning and end of each line. If scalars are
| provided, all lines will have same length.
|
| colors : array_like of colors, optional, default: 'k'
|
| linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional
|
| label : string, optional, default: ''
|
| Returns
| -------
| lines : `~matplotlib.collections.LineCollection`
|
| Other Parameters
| ----------------
| **kwargs : `~matplotlib.collections.LineCollection` properties.
|
| See also
| --------
| hlines : horizontal lines
| axvline: vertical line across the axes
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'colors', 'x', 'ymax', 'ymin'.
|
| xcorr(self, x, y, normed=True, detrend=<function detrend_none at 0x1111e4158>, usevlines=True, maxlags=10, *, data=None, **kwargs)
| Plot the cross correlation between *x* and *y*.
|
| The correlation with lag k is defined as sum_n x[n+k] * conj(y[n]).
|
| Parameters
| ----------
| x : sequence of scalars of length n
|
| y : sequence of scalars of length n
|
| hold : bool, optional, *deprecated*, default: True
|
| detrend : callable, optional, default: `mlab.detrend_none`
| *x* is detrended by the *detrend* callable. Default is no
| normalization.
|
| normed : bool, optional, default: True
| If ``True``, input vectors are normalised to unit length.
|
| usevlines : bool, optional, default: True
| If ``True``, `Axes.vlines` is used to plot the vertical lines from
| the origin to the acorr. Otherwise, `Axes.plot` is used.
|
| maxlags : int, optional
| Number of lags to show. If None, will return all ``2 * len(x) - 1``
| lags. Default is 10.
|
| Returns
| -------
| lags : array (lenth ``2*maxlags+1``)
| lag vector.
| c : array (length ``2*maxlags+1``)
| auto correlation vector.
| line : `.LineCollection` or `.Line2D`
| `.Artist` added to the axes of the correlation
|
| `.LineCollection` if *usevlines* is True
| `.Line2D` if *usevlines* is False
| b : `.Line2D` or None
| Horizontal line at 0 if *usevlines* is True
| None *usevlines* is False
|
| Other Parameters
| ----------------
| linestyle : `~matplotlib.lines.Line2D` property, optional
| Only used if usevlines is ``False``.
|
| marker : string, optional
| Default is 'o'.
|
| Notes
| -----
| The cross correlation is performed with :func:`numpy.correlate` with
| ``mode = 2``.
|
| .. note::
| In addition to the above described arguments, this function can take a
| **data** keyword argument. If such a **data** argument is given, the
| following arguments are replaced by **data[<arg>]**:
|
| * All arguments with the following names: 'x', 'y'.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.axes._axes.Axes:
|
| aname = 'Axes'
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.axes._base._AxesBase:
|
| __getstate__(self)
|
| __setstate__(self, state)
|
| add_artist(self, a)
| Add any :class:`~matplotlib.artist.Artist` to the axes.
|
| Use `add_artist` only for artists for which there is no dedicated
| "add" method; and if necessary, use a method such as `update_datalim`
| to manually update the dataLim if the artist is to be included in
| autoscaling.
|
| Returns the artist.
|
| add_collection(self, collection, autolim=True)
| Add a :class:`~matplotlib.collections.Collection` instance
| to the axes.
|
| Returns the collection.
|
| add_container(self, container)
| Add a :class:`~matplotlib.container.Container` instance
| to the axes.
|
| Returns the collection.
|
| add_line(self, line)
| Add a :class:`~matplotlib.lines.Line2D` to the list of plot
| lines
|
| Returns the line.
|
| add_patch(self, p)
| Add a :class:`~matplotlib.patches.Patch` *p* to the list of
| axes patches; the clipbox will be set to the Axes clipping
| box. If the transform is not set, it will be set to
| :attr:`transData`.
|
| Returns the patch.
|
| add_table(self, tab)
| Add a :class:`~matplotlib.table.Table` instance to the
| list of axes tables
|
| Parameters
| ----------
| tab: `matplotlib.table.Table`
| Table instance
|
| Returns
| -------
| `matplotlib.table.Table`: the table.
|
| apply_aspect(self, position=None)
| Adjust the Axes for a specified data aspect ratio.
|
| Depending on `.get_adjustable` this will modify either the Axes box
| (position) or the view limits. In the former case, `.get_anchor`
| will affect the position.
|
| Notes
| -----
| This is called automatically when each Axes is drawn. You may need
| to call it yourself if you need to update the Axes position and/or
| view limits before the Figure is drawn.
|
| See Also
| --------
| matplotlib.axes.Axes.set_aspect
| for a description of aspect ratio handling.
| matplotlib.axes.Axes.set_adjustable
| defining the parameter to adjust in order to meet the required
| aspect.
| matplotlib.axes.Axes.set_anchor
| defining the position in case of extra space.
|
| autoscale(self, enable=True, axis='both', tight=None)
| Autoscale the axis view to the data (toggle).
|
| Convenience method for simple axis view autoscaling.
| It turns autoscaling on or off, and then,
| if autoscaling for either axis is on, it performs
| the autoscaling on the specified axis or axes.
|
| Parameters
| ----------
| enable : bool or None, optional
| True (default) turns autoscaling on, False turns it off.
| None leaves the autoscaling state unchanged.
|
| axis : ['both' | 'x' | 'y'], optional
| which axis to operate on; default is 'both'
|
| tight: bool or None, optional
| If True, set view limits to data limits;
| if False, let the locator and margins expand the view limits;
| if None, use tight scaling if the only artist is an image,
| otherwise treat *tight* as False.
| The *tight* setting is retained for future autoscaling
| until it is explicitly changed.
|
| axis(self, *v, **kwargs)
| Set axis properties.
|
| Valid signatures::
|
| xmin, xmax, ymin, ymax = axis()
| xmin, xmax, ymin, ymax = axis(list_arg)
| xmin, xmax, ymin, ymax = axis(string_arg)
| xmin, xmax, ymin, ymax = axis(**kwargs)
|
| Parameters
| ----------
| v : list of float or {'on', 'off', 'equal', 'tight', 'scaled', 'normal', 'auto', 'image', 'square'}
| Optional positional argument
|
| Axis data limits set from a list; or a command relating to axes:
|
| ========== ================================================
| Value Description
| ========== ================================================
| 'on' Toggle axis lines and labels on
| 'off' Toggle axis lines and labels off
| 'equal' Equal scaling by changing limits
| 'scaled' Equal scaling by changing box dimensions
| 'tight' Limits set such that all data is shown
| 'auto' Automatic scaling, fill rectangle with data
| 'normal' Same as 'auto'; deprecated
| 'image' 'scaled' with axis limits equal to data limits
| 'square' Square plot; similar to 'scaled', but initially forcing xmax-xmin = ymax-ymin
| ========== ================================================
|
| emit : bool, optional
| Passed to set_{x,y}lim functions, if observers
| are notified of axis limit change
|
| xmin, ymin, xmax, ymax : float, optional
| The axis limits to be set
|
| Returns
| -------
| xmin, xmax, ymin, ymax : float
| The axis limits
|
| can_pan(self)
| Return *True* if this axes supports any pan/zoom button functionality.
|
| can_zoom(self)
| Return *True* if this axes supports the zoom box button functionality.
|
| clear(self)
| Clear the axes.
|
| contains(self, mouseevent)
| Test whether the mouse event occurred in the axes.
|
| Returns *True* / *False*, {}
|
| contains_point(self, point)
| Returns *True* if the point (tuple of x,y) is inside the axes
| (the area defined by the its patch). A pixel coordinate is
| required.
|
| drag_pan(self, button, key, x, y)
| Called when the mouse moves during a pan operation.
|
| *button* is the mouse button number:
|
| * 1: LEFT
| * 2: MIDDLE
| * 3: RIGHT
|
| *key* is a "shift" key
|
| *x*, *y* are the mouse coordinates in display coords.
|
| .. note::
|
| Intended to be overridden by new projection types.
|
| draw_artist(self, a)
| This method can only be used after an initial draw which
| caches the renderer. It is used to efficiently update Axes
| data (axis ticks, labels, etc are not updated)
|
| end_pan(self)
| Called when a pan operation completes (when the mouse button
| is up.)
|
| .. note::
|
| Intended to be overridden by new projection types.
|
| format_xdata(self, x)
| Return *x* string formatted. This function will use the attribute
| self.fmt_xdata if it is callable, else will fall back on the xaxis
| major formatter
|
| format_ydata(self, y)
| Return y string formatted. This function will use the
| :attr:`fmt_ydata` attribute if it is callable, else will fall
| back on the yaxis major formatter
|
| get_adjustable(self)
|
| get_anchor(self)
| Get the anchor location.
|
| See Also
| --------
| matplotlib.axes.Axes.set_anchor
| for a description of the anchor.
| matplotlib.axes.Axes.set_aspect
| for a description of aspect handling.
|
| get_aspect(self)
|
| get_autoscale_on(self)
| Get whether autoscaling is applied for both axes on plot commands
|
| get_autoscalex_on(self)
| Get whether autoscaling for the x-axis is applied on plot commands
|
| get_autoscaley_on(self)
| Get whether autoscaling for the y-axis is applied on plot commands
|
| get_axes_locator(self)
| Return the axes_locator.
|
| get_axisbelow(self)
| Get whether axis ticks and gridlines are above or below most artists.
|
| get_children(self)
| return a list of child artists
|
| get_cursor_props(self)
| .. deprecated:: 2.1
| The get_cursor_props function was deprecated in version 2.1.
|
| Return the cursor propertiess as a (*linewidth*, *color*)
| tuple, where *linewidth* is a float and *color* is an RGBA
| tuple
|
| get_data_ratio(self)
| Returns the aspect ratio of the raw data.
|
| This method is intended to be overridden by new projection
| types.
|
| get_data_ratio_log(self)
| Returns the aspect ratio of the raw data in log scale.
| Will be used when both axis scales are in log.
|
| get_default_bbox_extra_artists(self)
|
| get_facecolor(self)
| Get the Axes facecolor.
|
| get_fc = get_facecolor(self)
| Get the Axes facecolor.
|
| get_frame_on(self)
| Get whether the axes rectangle patch is drawn.
|
| get_images(self)
| return a list of Axes images contained by the Axes
|
| get_legend(self)
| Return the `Legend` instance, or None if no legend is defined.
|
| get_lines(self)
| Return a list of lines contained by the Axes
|
| get_navigate(self)
| Get whether the axes responds to navigation commands
|
| get_navigate_mode(self)
| Get the navigation toolbar button status: 'PAN', 'ZOOM', or None
|
| get_position(self, original=False)
| Get a copy of the axes rectangle as a `.Bbox`.
|
| Parameters
| ----------
| original : bool
| If ``True``, return the original position. Otherwise return the
| active position. For an explanation of the positions see
| `.set_position`.
|
| Returns
| -------
| pos : `.Bbox`
|
| get_rasterization_zorder(self)
| Return the zorder value below which artists will be rasterized.
|
| get_renderer_cache(self)
|
| get_shared_x_axes(self)
| Return a reference to the shared axes Grouper object for x axes.
|
| get_shared_y_axes(self)
| Return a reference to the shared axes Grouper object for y axes.
|
| get_tightbbox(self, renderer, call_axes_locator=True)
| Return the tight bounding box of the axes.
| The dimension of the Bbox in canvas coordinate.
|
| If *call_axes_locator* is *False*, it does not call the
| _axes_locator attribute, which is necessary to get the correct
| bounding box. ``call_axes_locator==False`` can be used if the
| caller is only intereted in the relative size of the tightbbox
| compared to the axes bbox.
|
| get_window_extent(self, *args, **kwargs)
| get the axes bounding box in display space; *args* and
| *kwargs* are empty
|
| get_xaxis(self)
| Return the XAxis instance.
|
| get_xaxis_text1_transform(self, pad_points)
| Get the transformation used for drawing x-axis labels, which
| will add the given amount of padding (in points) between the
| axes and the label. The x-direction is in data coordinates
| and the y-direction is in axis coordinates. Returns a
| 3-tuple of the form::
|
| (transform, valign, halign)
|
| where *valign* and *halign* are requested alignments for the
| text.
|
| .. note::
|
| This transformation is primarily used by the
| :class:`~matplotlib.axis.Axis` class, and is meant to be
| overridden by new kinds of projections that may need to
| place axis elements in different locations.
|
| get_xaxis_text2_transform(self, pad_points)
| Get the transformation used for drawing the secondary x-axis
| labels, which will add the given amount of padding (in points)
| between the axes and the label. The x-direction is in data
| coordinates and the y-direction is in axis coordinates.
| Returns a 3-tuple of the form::
|
| (transform, valign, halign)
|
| where *valign* and *halign* are requested alignments for the
| text.
|
| .. note::
|
| This transformation is primarily used by the
| :class:`~matplotlib.axis.Axis` class, and is meant to be
| overridden by new kinds of projections that may need to
| place axis elements in different locations.
|
| get_xaxis_transform(self, which='grid')
| Get the transformation used for drawing x-axis labels, ticks
| and gridlines. The x-direction is in data coordinates and the
| y-direction is in axis coordinates.
|
| .. note::
|
| This transformation is primarily used by the
| :class:`~matplotlib.axis.Axis` class, and is meant to be
| overridden by new kinds of projections that may need to
| place axis elements in different locations.
|
| get_xbound(self)
| Return the lower and upper x-axis bounds, in increasing order.
|
| get_xgridlines(self)
| Get the x grid lines as a list of `Line2D` instances.
|
| get_xlim(self)
| Get the x-axis range
|
| Returns
| -------
| xlimits : tuple
| Returns the current x-axis limits as the tuple
| (`left`, `right`).
|
| Notes
| -----
| The x-axis may be inverted, in which case the `left` value will
| be greater than the `right` value.
|
| get_xmajorticklabels(self)
| Get the major x tick labels.
|
| Returns
| -------
| labels : list
| List of :class:`~matplotlib.text.Text` instances
|
| get_xminorticklabels(self)
| Get the minor x tick labels.
|
| Returns
| -------
| labels : list
| List of :class:`~matplotlib.text.Text` instances
|
| get_xscale(self)
| Return the xaxis scale string: linear, log, logit, symlog
|
| get_xticklabels(self, minor=False, which=None)
| Get the x tick labels as a list of :class:`~matplotlib.text.Text`
| instances.
|
| Parameters
| ----------
| minor : bool, optional
| If True return the minor ticklabels,
| else return the major ticklabels.
|
| which : None, ('minor', 'major', 'both')
| Overrides `minor`.
|
| Selects which ticklabels to return
|
| Returns
| -------
| ret : list
| List of :class:`~matplotlib.text.Text` instances.
|
| get_xticklines(self)
| Get the x tick lines as a list of `Line2D` instances.
|
| get_xticks(self, minor=False)
| Return the x ticks as a list of locations
|
| get_yaxis(self)
| Return the YAxis instance.
|
| get_yaxis_text1_transform(self, pad_points)
| Get the transformation used for drawing y-axis labels, which
| will add the given amount of padding (in points) between the
| axes and the label. The x-direction is in axis coordinates
| and the y-direction is in data coordinates. Returns a 3-tuple
| of the form::
|
| (transform, valign, halign)
|
| where *valign* and *halign* are requested alignments for the
| text.
|
| .. note::
|
| This transformation is primarily used by the
| :class:`~matplotlib.axis.Axis` class, and is meant to be
| overridden by new kinds of projections that may need to
| place axis elements in different locations.
|
| get_yaxis_text2_transform(self, pad_points)
| Get the transformation used for drawing the secondary y-axis
| labels, which will add the given amount of padding (in points)
| between the axes and the label. The x-direction is in axis
| coordinates and the y-direction is in data coordinates.
| Returns a 3-tuple of the form::
|
| (transform, valign, halign)
|
| where *valign* and *halign* are requested alignments for the
| text.
|
| .. note::
|
| This transformation is primarily used by the
| :class:`~matplotlib.axis.Axis` class, and is meant to be
| overridden by new kinds of projections that may need to
| place axis elements in different locations.
|
| get_yaxis_transform(self, which='grid')
| Get the transformation used for drawing y-axis labels, ticks
| and gridlines. The x-direction is in axis coordinates and the
| y-direction is in data coordinates.
|
| .. note::
|
| This transformation is primarily used by the
| :class:`~matplotlib.axis.Axis` class, and is meant to be
| overridden by new kinds of projections that may need to
| place axis elements in different locations.
|
| get_ybound(self)
| Return the lower and upper y-axis bounds, in increasing order.
|
| get_ygridlines(self)
| Get the y grid lines as a list of `Line2D` instances.
|
| get_ylim(self)
| Get the y-axis range
|
| Returns
| -------
| ylimits : tuple
| Returns the current y-axis limits as the tuple
| (`bottom`, `top`).
|
| Notes
| -----
| The y-axis may be inverted, in which case the `bottom` value
| will be greater than the `top` value.
|
| get_ymajorticklabels(self)
| Get the major y tick labels.
|
| Returns
| -------
| labels : list
| List of :class:`~matplotlib.text.Text` instances
|
| get_yminorticklabels(self)
| Get the minor y tick labels.
|
| Returns
| -------
| labels : list
| List of :class:`~matplotlib.text.Text` instances
|
| get_yscale(self)
| Return the yaxis scale string: linear, log, logit, symlog
|
| get_yticklabels(self, minor=False, which=None)
| Get the x tick labels as a list of :class:`~matplotlib.text.Text`
| instances.
|
| Parameters
| ----------
| minor : bool
| If True return the minor ticklabels,
| else return the major ticklabels
|
| which : None, ('minor', 'major', 'both')
| Overrides `minor`.
|
| Selects which ticklabels to return
|
| Returns
| -------
| ret : list
| List of :class:`~matplotlib.text.Text` instances.
|
| get_yticklines(self)
| Get the y tick lines as a list of `Line2D` instances.
|
| get_yticks(self, minor=False)
| Return the y ticks as a list of locations
|
| grid(self, b=None, which='major', axis='both', **kwargs)
| Turn the axes grids on or off.
|
| Set the axes grids on or off; *b* is a boolean.
|
| If *b* is *None* and ``len(kwargs)==0``, toggle the grid state. If
| *kwargs* are supplied, it is assumed that you want a grid and *b*
| is thus set to *True*.
|
| *which* can be 'major' (default), 'minor', or 'both' to control
| whether major tick grids, minor tick grids, or both are affected.
|
| *axis* can be 'both' (default), 'x', or 'y' to control which
| set of gridlines are drawn.
|
| *kwargs* are used to set the grid line properties, e.g.,::
|
| ax.grid(color='r', linestyle='-', linewidth=2)
|
| Valid :class:`~matplotlib.lines.Line2D` kwargs are
|
| 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: float (0.0 transparent through 1.0 opaque)
| animated: bool
| antialiased or aa: bool
| clip_box: a `.Bbox` instance
| clip_on: bool
| clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
| color or c: any matplotlib color
| contains: a callable function
| dash_capstyle: ['butt' | 'round' | 'projecting']
| dash_joinstyle: ['miter' | 'round' | 'bevel']
| dashes: sequence of on/off ink in points
| drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post']
| figure: a `.Figure` instance
| fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none']
| gid: an id string
| label: object
| linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
| linewidth or lw: float value in points
| marker: :mod:`A valid marker style <matplotlib.markers>`
| markeredgecolor or mec: any matplotlib color
| markeredgewidth or mew: float value in points
| markerfacecolor or mfc: any matplotlib color
| markerfacecoloralt or mfcalt: any matplotlib color
| markersize or ms: float
| markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
| path_effects: `.AbstractPathEffect`
| picker: float distance in points or callable pick function ``fn(artist, event)``
| pickradius: float distance in points
| rasterized: bool or None
| sketch_params: (scale: float, length: float, randomness: float)
| snap: bool or None
| solid_capstyle: ['butt' | 'round' | 'projecting']
| solid_joinstyle: ['miter' | 'round' | 'bevel']
| transform: a :class:`matplotlib.transforms.Transform` instance
| url: a url string
| visible: bool
| xdata: 1D array
| ydata: 1D array
| zorder: float
|
| has_data(self)
| Return *True* if any artists have been added to axes.
|
| This should not be used to determine whether the *dataLim*
| need to be updated, and may not actually be useful for
| anything.
|
| hold(self, b=None)
| .. deprecated:: 2.0
| axes.hold is deprecated.
| See the API Changes document (http://matplotlib.org/api/api_changes.html)
| for more details.
|
| Set the hold state.
|
| The ``hold`` mechanism is deprecated and will be removed in
| v3.0. The behavior will remain consistent with the
| long-time default value of True.
|
| If *hold* is *None* (default), toggle the *hold* state. Else
| set the *hold* state to boolean value *b*.
|
| Examples::
|
| # toggle hold
| hold()
|
| # turn hold on
| hold(True)
|
| # turn hold off
| hold(False)
|
| When hold is *True*, subsequent plot commands will be added to
| the current axes. When hold is *False*, the current axes and
| figure will be cleared on the next plot command
|
| in_axes(self, mouseevent)
| Return *True* if the given *mouseevent* (in display coords)
| is in the Axes
|
| invert_xaxis(self)
| Invert the x-axis.
|
| invert_yaxis(self)
| Invert the y-axis.
|
| ishold(self)
| .. deprecated:: 2.0
| The ishold function was deprecated in version 2.0.
|
| return the HOLD status of the axes
|
| The `hold` mechanism is deprecated and will be removed in
| v3.0.
|
| locator_params(self, axis='both', tight=None, **kwargs)
| Control behavior of tick locators.
|
| Parameters
| ----------
| axis : ['both' | 'x' | 'y'], optional
| The axis on which to operate.
|
| tight : bool or None, optional
| Parameter passed to :meth:`autoscale_view`.
| Default is None, for no change.
|
| Other Parameters
| ----------------
| **kw :
| Remaining keyword arguments are passed to directly to the
| :meth:`~matplotlib.ticker.MaxNLocator.set_params` method.
|
| Typically one might want to reduce the maximum number
| of ticks and use tight bounds when plotting small
| subplots, for example::
|
| ax.locator_params(tight=True, nbins=4)
|
| Because the locator is involved in autoscaling,
| :meth:`autoscale_view` is called automatically after
| the parameters are changed.
|
| This presently works only for the
| :class:`~matplotlib.ticker.MaxNLocator` used
| by default on linear axes, but it may be generalized.
|
| margins(self, *args, **kw)
| Set or retrieve autoscaling margins.
|
| signatures::
|
| margins()
|
| returns xmargin, ymargin
|
| ::
|
| margins(margin)
|
| margins(xmargin, ymargin)
|
| margins(x=xmargin, y=ymargin)
|
| margins(..., tight=False)
|
| All three forms above set the xmargin and ymargin parameters.
| All keyword parameters are optional. A single argument
| specifies both xmargin and ymargin. The padding added to the end of
| each interval is *margin* times the data interval. The *margin* must
| be a float in the range [0, 1].
|
| The *tight* parameter is passed to :meth:`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. Setting
| *tight* to *None* will preserve the previous setting.
|
| 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.
|
| minorticks_off(self)
| Remove minor ticks from the axes.
|
| minorticks_on(self)
| Add autoscaling minor ticks to the axes.
|
| pick(self, *args)
| Trigger pick event
|
| Call signature::
|
| pick(mouseevent)
|
| each child artist will fire a pick event if mouseevent is over
| the artist and the artist has picker set
|
| redraw_in_frame(self)
| This method can only be used after an initial draw which
| caches the renderer. It is used to efficiently update Axes
| data (axis ticks, labels, etc are not updated)
|
| relim(self, visible_only=False)
| Recompute the data limits based on current artists. If you want to
| exclude invisible artists from the calculation, set
| ``visible_only=True``
|
| At present, :class:`~matplotlib.collections.Collection`
| instances are not supported.
|
| reset_position(self)
| 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`.
|
| set_adjustable(self, adjustable, share=False)
| Define which parameter the Axes will change to achieve a given aspect.
|
| Parameters
| ----------
| adjustable : ['box' | 'datalim']
| If 'box', change the physical dimensions of the Axes.
| If 'datalim', change the ``x`` or ``y`` data limits.
|
| share : bool, optional
| If ``True``, apply the settings to all shared Axes.
| Default is ``False``.
|
| .. ACCEPTS: [ 'box' | 'datalim']
|
| 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.
|
| set_anchor(self, anchor, share=False)
| 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.
|
| .. ACCEPTS: [ 'C' | 'SW' | 'S' | 'SE' | 'E' | 'NE' | 'N' | 'NW' | 'W' ]
|
| Parameters
| ----------
| anchor : str or 2-tuple of floats
| The anchor position may be either:
|
| - a sequence (*cx*, *cy*). *cx* and *cy* may range from 0
| to 1, where 0 is left or bottom and 1 is right or top.
|
| - a string using cardinal directions as abbreviation:
|
| - 'C' for centered
| - 'S' (south) for bottom-center
| - 'SW' (south west) for bottom-left
| - etc.
|
| Here is an overview of the possible positions:
|
| +------+------+------+
| | 'NW' | 'N' | 'NE' |
| +------+------+------+
| | 'W' | 'C' | 'E' |
| +------+------+------+
| | 'SW' | 'S' | 'SE' |
| +------+------+------+
|
| share : bool, optional
| If ``True``, apply the settings to all shared Axes.
| Default is ``False``.
|
| See Also
| --------
| matplotlib.axes.Axes.set_aspect
| for a description of aspect handling.
|
| set_aspect(self, aspect, adjustable=None, anchor=None, share=False)
| Set the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.
|
| Parameters
| ----------
| aspect : ['auto' | 'equal'] or num
| Possible values:
|
| ======== ================================================
| value description
| ======== ================================================
| 'auto' automatic; fill the position rectangle with data
| 'equal' same scaling from data to plot units for x and y
| num a circle will be stretched such that the height
| is num times the width. aspect=1 is the same as
| aspect='equal'.
| ======== ================================================
|
| adjustable : None 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.
|
| anchor : None or str or 2-tuple of 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.
|
| share : bool, optional
| If ``True``, apply the settings to all shared Axes.
| Default is ``False``.
|
| See Also
| --------
| matplotlib.axes.Axes.set_adjustable
| defining the parameter to adjust in order to meet the required
| aspect.
| matplotlib.axes.Axes.set_anchor
| defining the position in case of extra space.
|
| set_autoscale_on(self, b)
| Set whether autoscaling is applied on plot commands
|
| .. ACCEPTS: bool
|
| Parameters
| ----------
| b : bool
|
| set_autoscalex_on(self, b)
| Set whether autoscaling for the x-axis is applied on plot commands
|
| .. ACCEPTS: bool
|
| Parameters
| ----------
| b : bool
|
| set_autoscaley_on(self, b)
| Set whether autoscaling for the y-axis is applied on plot commands
|
| .. ACCEPTS: bool
|
| Parameters
| ----------
| b : bool
|
| set_axes_locator(self, locator)
| Set the axes locator.
|
| .. ACCEPTS: a callable object which takes an axes instance and
| renderer and returns a bbox.
|
| Parameters
| ----------
| locator : callable
| A locator function, which takes an axes and a renderer and returns
| a bbox.
|
| set_axis_off(self)
| Turn off the axis.
|
| set_axis_on(self)
| Turn on the axis.
|
| set_axisbelow(self, b)
| Set whether axis ticks and gridlines are above or below most artists.
|
| .. ACCEPTS: [ bool | 'line' ]
|
| Parameters
| ----------
| b : bool or 'line'
|
| set_color_cycle(self, clist)
| .. deprecated:: 1.5
| The set_color_cycle function was deprecated in version 1.5. Use `.set_prop_cycle` instead.
|
| Set the color cycle for any future plot commands on this Axes.
|
| Parameters
| ----------
| clist
| A list of mpl color specifiers.
|
| set_cursor_props(self, *args)
| .. deprecated:: 2.1
| The set_cursor_props function was deprecated in version 2.1.
|
| Set the cursor property as
|
| Call signature ::
|
| ax.set_cursor_props(linewidth, color)
|
| or::
|
| ax.set_cursor_props((linewidth, color))
|
| ACCEPTS: a (*float*, *color*) tuple
|
| set_facecolor(self, color)
| Set the Axes facecolor.
|
| .. ACCEPTS: color
|
| Parameters
| ----------
| color : color
|
| set_fc = set_facecolor(self, color)
| Set the Axes facecolor.
|
| .. ACCEPTS: color
|
| Parameters
| ----------
| color : color
|
| set_figure(self, fig)
| Set the `.Figure` for this `.Axes`.
|
| .. ACCEPTS: `.Figure`
|
| Parameters
| ----------
| fig : `.Figure`
|
| set_frame_on(self, b)
| Set whether the axes rectangle patch is drawn.
|
| .. ACCEPTS: bool
|
| Parameters
| ----------
| b : bool
|
| set_navigate(self, b)
| Set whether the axes responds to navigation toolbar commands
|
| .. ACCEPTS: bool
|
| Parameters
| ----------
| b : bool
|
| set_navigate_mode(self, b)
| Set the navigation toolbar button status;
|
| .. warning::
| this is not a user-API function.
|
| set_position(self, pos, which='both')
| 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 `.set_aspect`
| for details.
|
| Parameters
| ----------
| pos : [left, bottom, width, height] or `~matplotlib.transforms.Bbox`
| The new position of the in `.Figure` coordinates.
|
| which : ['both' | 'active' | 'original'], optional
| Determines which position variables to change.
|
| set_prop_cycle(self, *args, **kwargs)
| Set the property cycle for any future plot commands on this Axes.
|
| set_prop_cycle(arg)
| set_prop_cycle(label, itr)
| set_prop_cycle(label1=itr1[, label2=itr2[, ...]])
|
| Form 1 simply sets given `Cycler` object.
|
| Form 2 creates and sets a `Cycler` from a label and an iterable.
|
| Form 3 composes and sets a `Cycler` as an inner product of the
| pairs of keyword arguments. In other words, all of the
| iterables are cycled simultaneously, as if through zip().
|
| Parameters
| ----------
| arg : Cycler
| Set the given Cycler.
| Can also be `None` to reset to the cycle defined by the
| current style.
|
| label : str
| 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'.
|
| itr : iterable
| Finite-length iterable of the property values. These values
| are validated and will raise a ValueError if invalid.
|
| See Also
| --------
| :func:`cycler` Convenience function for creating your
| own cyclers.
|
| set_rasterization_zorder(self, z)
| Parameters
| ----------
| z : float or None
| zorder below which artists are rasterized. ``None`` means that
| artists do not get rasterized based on zorder.
|
| .. ACCEPTS: float or None
|
| set_xbound(self, lower=None, upper=None)
| Set the lower and upper numerical bounds of the x-axis.
|
| This method will honor axes inversion regardless of parameter order.
| It will not change the _autoscaleXon attribute.
|
| .. ACCEPTS: (lower: float, upper: float)
|
| set_xlim(self, left=None, right=None, emit=True, auto=False, **kw)
| Set the data limits for the x-axis
|
| .. ACCEPTS: (left: float, right: float)
|
| Parameters
| ----------
| left : scalar, optional
| The left xlim (default: None, which leaves the left limit
| unchanged).
|
| right : scalar, optional
| The right xlim (default: None, which leaves the right limit
| unchanged).
|
| emit : bool, optional
| Whether to notify observers of limit change (default: True).
|
| auto : bool or None, optional
| Whether to turn on autoscaling of the x-axis. True turns on,
| False turns off (default action), None leaves unchanged.
|
| xlimits : tuple, optional
| The left and right xlims may be passed as the tuple
| (`left`, `right`) as the first positional argument (or as
| the `left` keyword argument).
|
| Returns
| -------
| xlimits : tuple
| Returns the new x-axis limits as (`left`, `right`).
|
| 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)
|
| set_xmargin(self, m)
| 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].
|
| .. ACCEPTS: float greater than -0.5
|
| Parameters
| ----------
| m : float greater than -0.5
|
| set_xscale(self, value, **kwargs)
| Set the x-axis scale.
|
| .. ACCEPTS: [ 'linear' | 'log' | 'symlog' | 'logit' | ... ]
|
| Parameters
| ----------
| value : {"linear", "log", "symlog", "logit"}
| scaling strategy to apply
|
| Notes
| -----
| Different kwargs are accepted, depending on the scale. See
| the `~matplotlib.scale` module for more information.
|
| See also
| --------
| matplotlib.scale.LinearScale : linear transform
|
| matplotlib.scale.LogTransform : log transform
|
| matplotlib.scale.SymmetricalLogTransform : symlog transform
|
| matplotlib.scale.LogisticTransform : logit transform
|
| set_xticklabels(self, labels, fontdict=None, minor=False, **kwargs)
| Set the x-tick labels with list of string labels.
|
| .. ACCEPTS: list of string labels
|
| Parameters
| ----------
| labels : list of str
| List of string labels.
|
| fontdict : dict, 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}
|
| minor : bool, optional
| Whether to set the minor ticklabels rather than the major ones.
|
| Returns
| -------
| A list of `~.text.Text` instances.
|
| Other Parameters
| -----------------
| **kwargs : `~.text.Text` properties.
|
| set_ybound(self, lower=None, upper=None)
| Set the lower and upper numerical bounds of the y-axis.
| This method will honor axes inversion regardless of parameter order.
| It will not change the _autoscaleYon attribute.
|
| .. ACCEPTS: (lower: float, upper: float)
|
| set_ylim(self, bottom=None, top=None, emit=True, auto=False, **kw)
| Set the data limits for the y-axis
|
| .. ACCEPTS: (bottom: float, top: float)
|
| Parameters
| ----------
| bottom : scalar, optional
| The bottom ylim (default: None, which leaves the bottom
| limit unchanged).
|
| top : scalar, optional
| The top ylim (default: None, which leaves the top limit
| unchanged).
|
| emit : bool, optional
| Whether to notify observers of limit change (default: True).
|
| auto : bool or None, optional
| Whether to turn on autoscaling of the y-axis. True turns on,
| False turns off (default action), None leaves unchanged.
|
| ylimits : tuple, optional
| The bottom and top yxlims may be passed as the tuple
| (`bottom`, `top`) as the first positional argument (or as
| the `bottom` keyword argument).
|
| Returns
| -------
| ylimits : tuple
| Returns the new y-axis limits as (`bottom`, `top`).
|
| 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)
|
| set_ymargin(self, m)
| 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].
|
| .. ACCEPTS: float greater than -0.5
|
| Parameters
| ----------
| m : float greater than -0.5
|
| set_yscale(self, value, **kwargs)
| Set the y-axis scale.
|
| .. ACCEPTS: [ 'linear' | 'log' | 'symlog' | 'logit' | ... ]
|
| Parameters
| ----------
| value : {"linear", "log", "symlog", "logit"}
| scaling strategy to apply
|
| Notes
| -----
| Different kwargs are accepted, depending on the scale. See
| the `~matplotlib.scale` module for more information.
|
| See also
| --------
| matplotlib.scale.LinearScale : linear transform
|
| matplotlib.scale.LogTransform : log transform
|
| matplotlib.scale.SymmetricalLogTransform : symlog transform
|
| matplotlib.scale.LogisticTransform : logit transform
|
| set_yticklabels(self, labels, fontdict=None, minor=False, **kwargs)
| Set the y-tick labels with list of strings labels.
|
| .. ACCEPTS: list of string labels
|
| Parameters
| ----------
| labels : list of str
| list of string labels
|
| fontdict : dict, 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}
|
| minor : bool, optional
| Whether to set the minor ticklabels rather than the major ones.
|
| Returns
| -------
| A list of `~.text.Text` instances.
|
| Other Parameters
| ----------------
| **kwargs : `~.text.Text` properties.
|
| start_pan(self, x, y, button)
| Called when a pan operation has started.
|
| *x*, *y* are the mouse coordinates in display coords.
| button is the mouse button number:
|
| * 1: LEFT
| * 2: MIDDLE
| * 3: RIGHT
|
| .. note::
|
| Intended to be overridden by new projection types.
|
| tick_params(self, axis='both', **kwargs)
| Change the appearance of ticks, tick labels, and gridlines.
|
| Parameters
| ----------
| axis : {'x', 'y', 'both'}, optional
| Which axis to apply the parameters to.
|
| Other Parameters
| ----------------
|
| axis : {'x', 'y', 'both'}
| Axis on which to operate; default is 'both'.
|
| reset : bool
| If *True*, set all parameters to defaults
| before processing other keyword arguments. Default is
| *False*.
|
| which : {'major', 'minor', 'both'}
| Default is 'major'; apply arguments to *which* ticks.
|
| direction : {'in', 'out', 'inout'}
| Puts ticks inside the axes, outside the axes, or both.
|
| length : float
| Tick length in points.
|
| width : float
| Tick width in points.
|
| color : color
| Tick color; accepts any mpl color spec.
|
| pad : float
| Distance in points between tick and label.
|
| labelsize : float or str
| Tick label font size in points or as a string (e.g., 'large').
|
| labelcolor : color
| Tick label color; mpl color spec.
|
| colors : color
| Changes the tick color and the label color to the same value:
| mpl color spec.
|
| zorder : float
| Tick and label zorder.
|
| bottom, top, left, right : bool
| Whether to draw the respective ticks.
|
| labelbottom, labeltop, labelleft, labelright : bool
| Whether to draw the respective tick labels.
|
| labelrotation : float
| Tick label rotation
|
| grid_color : color
| Changes the gridline color to the given mpl color spec.
|
| grid_alpha : float
| Transparency of gridlines: 0 (transparent) to 1 (opaque).
|
| grid_linewidth : float
| Width of gridlines in points.
|
| grid_linestyle : string
| Any valid :class:`~matplotlib.lines.Line2D` line style spec.
|
| Examples
| --------
|
| Usage ::
|
| 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.
|
| ticklabel_format(self, **kwargs)
| Change the `~matplotlib.ticker.ScalarFormatter` used by
| default for linear axes.
|
| Optional keyword arguments:
|
| ============== =========================================
| Keyword Description
| ============== =========================================
| *style* [ 'sci' (or 'scientific') | 'plain' ]
| plain turns off scientific notation
| *scilimits* (m, n), pair of integers; if *style*
| is 'sci', scientific notation will
| be used for numbers outside the range
| 10`m`:sup: to 10`n`:sup:.
| Use (0,0) to include all numbers.
| *useOffset* [ bool | offset ]; if True,
| the offset will be calculated as needed;
| if False, no offset will be used; if a
| numeric offset is specified, it will be
| used.
| *axis* [ 'x' | 'y' | 'both' ]
| *useLocale* If True, format the number according to
| the current locale. This affects things
| such as the character used for the
| decimal separator. If False, use
| C-style (English) formatting. The
| default setting is controlled by the
| axes.formatter.use_locale rcparam.
| *useMathText* If True, render the offset and scientific
| notation in mathtext
| ============== =========================================
|
| Only the major ticks are affected.
| If the method is called when the
| :class:`~matplotlib.ticker.ScalarFormatter` is not the
| :class:`~matplotlib.ticker.Formatter` being used, an
| :exc:`AttributeError` will be raised.
|
| twinx(self)
| Create a twin Axes sharing the xaxis
|
| Create a new Axes instance 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
| `~matplotlib.ticker.LinearLocator`
|
| Returns
| -------
| ax_twin : 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.
|
| twiny(self)
| Create a twin Axes sharing the yaxis
|
| Create a new Axes instance 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
| `~matplotlib.ticker.LinearLocator`
|
| Returns
| -------
| ax_twin : 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.
|
| update_datalim(self, xys, updatex=True, updatey=True)
| Update the data lim bbox with seq of xy tups or equiv. 2-D array
|
| update_datalim_bounds(self, bounds)
| Update the datalim to include the given
| :class:`~matplotlib.transforms.Bbox` *bounds*
|
| xaxis_date(self, tz=None)
| Sets up x-axis ticks and labels that treat the x data as dates.
|
| Parameters
| ----------
| tz : string or :class:`tzinfo` instance, optional
| Timezone string or timezone. Defaults to rc value.
|
| xaxis_inverted(self)
| Return whether the x-axis is inverted.
|
| yaxis_date(self, tz=None)
| Sets up y-axis ticks and labels that treat the y data as dates.
|
| Parameters
| ----------
| tz : string or :class:`tzinfo` instance, optional
| Timezone string or timezone. Defaults to rc value.
|
| yaxis_inverted(self)
| Return whether the y-axis is inverted.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.axes._base._AxesBase:
|
| axesPatch
| .. deprecated:: 2.1
| The axesPatch function was deprecated in version 2.1. Use Axes.patch instead.
|
| \
|
| 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.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.axes._base._AxesBase:
|
| name = 'rectilinear'
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.artist.Artist:
|
| add_callback(self, func)
| Adds a callback function that will be called whenever one of
| the :class:`Artist`'s properties changes.
|
| Returns an *id* that is useful for removing the callback with
| :meth:`remove_callback` later.
|
| convert_xunits(self, x)
| For artists in an axes, if the xaxis has units support,
| convert *x* using xaxis unit type
|
| convert_yunits(self, y)
| For artists in an axes, if the yaxis has units support,
| convert *y* using yaxis unit type
|
| findobj(self, match=None, include_self=True)
| Find artist objects.
|
| Recursively find all :class:`~matplotlib.artist.Artist` instances
| contained in self.
|
| *match* can be
|
| - None: return all objects contained in artist.
|
| - function with signature ``boolean = match(artist)``
| used to filter matches
|
| - class instance: e.g., Line2D. Only return artists of class type.
|
| If *include_self* is True (default), include self in the list to be
| checked for a match.
|
| format_cursor_data(self, data)
| Return *cursor data* string formatted.
|
| get_agg_filter(self)
| Return filter function to be used for agg filter.
|
| get_alpha(self)
| Return the alpha value used for blending - not supported on all
| backends
|
| get_animated(self)
| Return the artist's animated state
|
| get_clip_box(self)
| Return artist clipbox
|
| get_clip_on(self)
| Return whether artist uses clipping
|
| get_clip_path(self)
| Return artist clip path
|
| get_contains(self)
| Return the _contains test used by the artist, or *None* for default.
|
| get_cursor_data(self, event)
| Get the cursor data for a given event.
|
| get_figure(self)
| Return the `.Figure` instance the artist belongs to.
|
| get_gid(self)
| Returns the group id.
|
| get_label(self)
| Get the label used for this artist in the legend.
|
| get_path_effects(self)
|
| get_picker(self)
| Return the picker object used by this artist.
|
| get_rasterized(self)
| Return whether the artist is to be rasterized.
|
| get_sketch_params(self)
| Returns the sketch parameters for the artist.
|
| Returns
| -------
| sketch_params : 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.
|
| May return `None` if no sketch parameters were set.
|
| get_snap(self)
| Returns the snap setting which may be:
|
| * True: snap vertices to the nearest pixel center
|
| * False: leave vertices as-is
|
| * None: (auto) If the path contains only rectilinear line
| segments, round to the nearest pixel center
|
| Only supported by the Agg and MacOSX backends.
|
| get_transform(self)
| Return the :class:`~matplotlib.transforms.Transform`
| instance used by this artist.
|
| get_transformed_clip_path_and_affine(self)
| Return the clip path with the non-affine part of its
| transformation applied, and the remaining affine part of its
| transformation.
|
| get_url(self)
| Returns the url.
|
| get_visible(self)
| Return the artist's visiblity
|
| get_zorder(self)
| Return the artist's zorder.
|
| have_units(self)
| Return *True* if units are set on the *x* or *y* axes
|
| hitlist(self, event)
| .. deprecated:: 2.2
| The hitlist function was deprecated in version 2.2.
|
| List the children of the artist which contain the mouse event *event*.
|
| is_figure_set(self)
| .. deprecated:: 2.2
| artist.figure is not None
|
| Returns whether the artist is assigned to a `.Figure`.
|
| is_transform_set(self)
| Returns *True* if :class:`Artist` has a transform explicitly
| set.
|
| pchanged(self)
| Fire an event when property changed, calling all of the
| registered callbacks.
|
| pickable(self)
| Return *True* if :class:`Artist` is pickable.
|
| properties(self)
| return a dictionary mapping property name -> value for all Artist props
|
| remove(self)
| Remove the artist from the figure if possible. The effect
| will not be visible until the figure is redrawn, e.g., with
| :meth:`matplotlib.axes.Axes.draw_idle`. Call
| :meth:`matplotlib.axes.Axes.relim` to update the axes limits
| if desired.
|
| Note: :meth:`~matplotlib.axes.Axes.relim` will not see
| collections even if the collection was added to axes with
| *autolim* = True.
|
| Note: there is no support for removing the artist's legend entry.
|
| remove_callback(self, oid)
| Remove a callback based on its *id*.
|
| .. seealso::
|
| :meth:`add_callback`
| For adding callbacks
|
| set(self, **kwargs)
| A property batch setter. Pass *kwargs* to set properties.
|
| set_agg_filter(self, filter_func)
| Set the agg filter.
|
| Parameters
| ----------
| filter_func : callable
| A filter function, which takes a (m, n, 3) float array and a dpi
| value, and returns a (m, n, 3) array.
|
| .. ACCEPTS: a filter function, which takes a (m, n, 3) float array
| and a dpi value, and returns a (m, n, 3) array
|
| set_alpha(self, alpha)
| Set the alpha value used for blending - not supported on
| all backends.
|
| Parameters
| ----------
| alpha : float
| .. ACCEPTS: float (0.0 transparent through 1.0 opaque)
|
| set_animated(self, b)
| Set the artist's animation state.
|
| Parameters
| ----------
| b : bool
| .. ACCEPTS: bool
|
| set_clip_box(self, clipbox)
| Set the artist's clip `.Bbox`.
|
| Parameters
| ----------
| clipbox : `.Bbox`
| .. ACCEPTS: a `.Bbox` instance
|
| set_clip_on(self, b)
| Set whether artist uses clipping.
|
| When False artists will be visible out side of the axes which
| can lead to unexpected results.
|
| Parameters
| ----------
| b : bool
| .. ACCEPTS: bool
|
| set_clip_path(self, path, transform=None)
| Set the artist's clip path, which may be:
|
| - a :class:`~matplotlib.patches.Patch` (or subclass) instance; or
| - a :class:`~matplotlib.path.Path` instance, in which case a
| :class:`~matplotlib.transforms.Transform` instance, which will be
| applied to the path before using it for clipping, must be provided;
| or
| - ``None``, to remove a previously set clipping path.
|
| For efficiency, if the path happens to be an axis-aligned rectangle,
| this method will set the clipping box to the corresponding rectangle
| and set the clipping path to ``None``.
|
| ACCEPTS: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
|
| set_contains(self, picker)
| Replace the contains test used by this artist. The new picker
| should be a callable function which determines whether the
| artist is hit by the mouse event::
|
| hit, props = picker(artist, mouseevent)
|
| If the mouse event is over the artist, return *hit* = *True*
| and *props* is a dictionary of properties you want returned
| with the contains test.
|
| Parameters
| ----------
| picker : callable
| .. ACCEPTS: a callable function
|
| set_gid(self, gid)
| Sets the (group) id for the artist.
|
| Parameters
| ----------
| gid : str
| .. ACCEPTS: an id string
|
| set_label(self, s)
| Set the label to *s* for auto legend.
|
| Parameters
| ----------
| s : object
| *s* will be converted to a string by calling `str` (`unicode` on
| Py2).
|
| .. ACCEPTS: object
|
| set_path_effects(self, path_effects)
| Set the path effects.
|
| Parameters
| ----------
| path_effects : `.AbstractPathEffect`
| .. ACCEPTS: `.AbstractPathEffect`
|
| set_picker(self, picker)
| Set the epsilon for picking used by this artist
|
| *picker* 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 it's 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.
|
| Parameters
| ----------
| picker : None or bool or float or callable
| .. ACCEPTS: [None | bool | float | callable]
|
| set_rasterized(self, rasterized)
| Force rasterized (bitmap) drawing in vector backend output.
|
| Defaults to None, which implies the backend's default behavior.
|
| Parameters
| ----------
| rasterized : bool or None
| .. ACCEPTS: bool or None
|
| set_sketch_params(self, scale=None, length=None, randomness=None)
| Sets the sketch parameters.
|
| Parameters
| ----------
|
| scale : float, 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.
|
| length : float, optional
| The length of the wiggle along the line, in pixels
| (default 128.0)
|
| randomness : float, optional
| The scale factor by which the length is shrunken or
| expanded (default 16.0)
|
| .. ACCEPTS: (scale: float, length: float, randomness: float)
|
| set_snap(self, snap)
| Sets the snap setting which may be:
|
| * True: snap vertices to the nearest pixel center
|
| * False: leave vertices as-is
|
| * None: (auto) If the path contains only rectilinear line
| segments, round to the nearest pixel center
|
| Only supported by the Agg and MacOSX backends.
|
| Parameters
| ----------
| snap : bool or None
| .. ACCEPTS: bool or None
|
| set_transform(self, t)
| Set the artist transform.
|
| Parameters
| ----------
| t : `.Transform`
| .. ACCEPTS: `.Transform`
|
| set_url(self, url)
| Sets the url for the artist.
|
| Parameters
| ----------
| url : str
| .. ACCEPTS: a url string
|
| set_visible(self, b)
| Set the artist's visibility.
|
| Parameters
| ----------
| b : bool
| .. ACCEPTS: bool
|
| set_zorder(self, level)
| Set the zorder for the artist. Artists with lower zorder
| values are drawn first.
|
| Parameters
| ----------
| level : float
| .. ACCEPTS: float
|
| update(self, props)
| Update this artist's properties from the dictionary *prop*.
|
| update_from(self, other)
| Copy properties from *other* to *self*.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.artist.Artist:
|
| axes
| The :class:`~matplotlib.axes.Axes` instance the artist
| resides in, or *None*.
|
| mouseover
|
| stale
| If 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.
|
| 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 usecase is histograms,
| where one usually expects no margin on the bottom edge (0) of the
| histogram.
|
| 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)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.artist.Artist:
|
| zorder = 0
In [ ]:
Content source: mjbrodzik/ExploringCETB
Similar notebooks: