# Notebook from joblackpoc/StudyJupyter
Path: help matplotlib.ipynb

<code>
import matplotlib.pyplot as plt
_____no_output_____help(plt)Help on module matplotlib.pyplot in matplotlib:

NAME
    matplotlib.pyplot

DESCRIPTION
    `matplotlib.pyplot` is a state-based interface to matplotlib. It provides
    a MATLAB-like way of plotting.

    pyplot is mainly intended for interactive plots and simple cases of programmatic
    plot generation::

        import numpy as np
        import matplotlib.pyplot as plt

        x = np.arange(0, 5, 0.1)
        y = np.sin(x)
        plt.plot(x, y)

    The object-oriented API is recommended for more complex plots.

FUNCTIONS
    acorr(x, hold=None, 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(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, hold=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(*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(x, y, dx, dy, hold=None, **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="->"))

    autoscale(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.

    autumn()
        Set the colormap to "autumn".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    axes(arg=None, **kwargs)
        Add an axes to the current figure and make it the current axes.

        Parameters
        ----------
        arg : None or 4-tuple or Axes
            The exact behavior of this function depends on the type:

            - *None*: A new full window axes is added using
              ``subplot(111, **kwargs)``
            - 4-tuple of floats *rect* = ``[left, bottom, width, height]``.
              A new axes is added with dimensions *rect* in normalized
              (0, 1) units using `~.Figure.add_axes` on the current figure.
            - `.Axes`: This is equivalent to `.pyplot.sca`. It sets the current
              axes to *arg*. Note: This implicitly changes the current figure to
              the parent of *arg*.

              .. note:: The use of an Axes as an argument is deprecated and will be
                        removed in v3.0. Please use `.pyplot.sca` instead.

        Other Parameters
        ----------------
        **kwargs :
            For allowed keyword arguments see `.pyplot.subplot` and
            `.Figure.add_axes` respectively. Some common keyword arguments are
            listed below:

            ========= =========== =================================================
            kwarg     Accepts     Description
            ========= =========== =================================================
            facecolor color       the axes background color
            frameon   bool        whether to display the frame
            sharex    otherax     share x-axis with *otherax*
            sharey    otherax     share y-axis with *otherax*
            polar     bool        whether to use polar axes
            aspect    [str | num] ['equal', 'auto'] or a number.  If a number, the
                                  ratio of y-unit/x-unit in screen-space.  See also
                                  `~.Axes.set_aspect`.
            ========= =========== =================================================

        Returns
        -------
        axes : Axes
            The created or activated axes.

        Examples
        --------
        Creating a new full window axes::

            >>> plt.axes()

        Creating a new axes with specified dimensions and some kwargs::

            >>> plt.axes((left, bottom, width, height), facecolor='w')

    axhline(y=0, xmin=0, xmax=1, hold=None, **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(ymin, ymax, xmin=0, xmax=1, hold=None, **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.

    axis(*v, **kwargs)
        Convenience method to get or set axis properties.

        Calling with no arguments::

          >>> axis()

        returns the current axes limits ``[xmin, xmax, ymin, ymax]``.::

          >>> axis(v)

        sets the min and max of the x and y axes, with
        ``v = [xmin, xmax, ymin, ymax]``.::

          >>> axis('off')

        turns off the axis lines and labels.::

          >>> axis('equal')

        changes limits of *x* or *y* axis so that equal increments of *x*
        and *y* have the same length; a circle is circular.::

          >>> axis('scaled')

        achieves the same result by changing the dimensions of the plot box instead
        of the axis data limits.::

          >>> axis('tight')

        changes *x* and *y* axis limits such that all data is shown. If
        all data is already shown, it will move it to the center of the
        figure without modifying (*xmax* - *xmin*) or (*ymax* -
        *ymin*). Note this is slightly different than in MATLAB.::

          >>> axis('image')

        is 'scaled' with the axis limits equal to the data limits.::

          >>> axis('auto')

        and::

          >>> axis('normal')

        are deprecated. They restore default behavior; axis limits are automatically
        scaled to make the data fit comfortably within the plot box.

        if ``len(*v)==0``, you can pass in *xmin*, *xmax*, *ymin*, *ymax*
        as kwargs selectively to alter just those limits without changing
        the others.

          >>> axis('square')

        changes the limit ranges (*xmax*-*xmin*) and (*ymax*-*ymin*) of
        the *x* and *y* axes to be the same, and have the same scaling,
        resulting in a square plot.

        The xmin, xmax, ymin, ymax tuple is returned

        .. seealso::

            :func:`xlim`, :func:`ylim`
               For setting the x- and y-limits individually.

    axvline(x=0, ymin=0, ymax=1, hold=None, **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(xmin, xmax, ymin=0, ymax=1, hold=None, **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(*args, **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.

    barbs(*args, **kw)
        Plot a 2-D field of barbs.

        Call signatures::

          barb(U, V, **kw)
          barb(U, V, C, **kw)
          barb(X, Y, U, V, **kw)
          barb(X, Y, U, V, C, **kw)

        Arguments:

          *X*, *Y*:
            The x and y coordinates of the barb locations
            (default is head of barb; see *pivot* kwarg)

          *U*, *V*:
            Give the x and y components of the barb shaft

          *C*:
            An optional array used to map colors to the barbs

        All arguments may be 1-D or 2-D arrays or sequences. If *X* and *Y*
        are absent, they will be generated as a uniform grid.  If *U* and *V*
        are 2-D arrays but *X* and *Y* are 1-D, and if ``len(X)`` and ``len(Y)``
        match the column and row dimensions of *U*, then *X* and *Y* will be
        expanded with :func:`numpy.meshgrid`.

        *U*, *V*, *C* may be masked arrays, but masked *X*, *Y* are not
        supported at present.

        Keyword arguments:

          *length*:
            Length of the barb in points; the other parts of the barb
            are scaled against this.
            Default is 7.

          *pivot*: [ 'tip' | 'middle' | float ]
            The part of the arrow that is at the grid point; the arrow rotates
            about this point, hence the name *pivot*.  Default is 'tip'. Can
            also be a number, which shifts the start of the barb that many
            points from the origin.

          *barbcolor*: [ color | color sequence ]
            Specifies the color all parts of the barb except any flags.  This
            parameter is analogous to the *edgecolor* parameter for polygons,
            which can be used instead. However this parameter will override
            facecolor.

          *flagcolor*: [ color | color sequence ]
            Specifies the color of any flags on the barb.  This parameter is
            analogous to the *facecolor* parameter for polygons, which can be
            used instead. However this parameter will override facecolor.  If
            this is not set (and *C* has not either) then *flagcolor* will be
            set to match *barbcolor* so that the barb has a uniform color. If
            *C* has been set, *flagcolor* has no effect.

          *sizes*:
            A dictionary of coefficients specifying the ratio of a given
            feature to the length of the barb. Only those values one wishes to
            override need to be included.  These features include:

                - 'spacing' - space between features (flags, full/half barbs)

                - 'height' - height (distance from shaft to top) of a flag or
                  full barb

                - 'width' - width of a flag, twice the width of a full barb

                - 'emptybarb' - radius of the circle used for low magnitudes

          *fill_empty*:
            A flag on whether the empty barbs (circles) that are drawn should
            be filled with the flag color.  If they are not filled, they will
            be drawn such that no color is applied to the center.  Default is
            False

          *rounding*:
            A flag to indicate whether the vector magnitude should be rounded
            when allocating barb components.  If True, the magnitude is
            rounded to the nearest multiple of the half-barb increment.  If
            False, the magnitude is simply truncated to the next lowest
            multiple.  Default is True

          *barb_increments*:
            A dictionary of increments specifying values to associate with
            different parts of the barb. Only those values one wishes to
            override need to be included.

                - 'half' - half barbs (Default is 5)

                - 'full' - full barbs (Default is 10)

                - 'flag' - flags (default is 50)

          *flip_barb*:
            Either a single boolean flag or an array of booleans.  Single
            boolean indicates whether the lines and flags should point
            opposite to normal for all barbs.  An array (which should be the
            same size as the other data arrays) indicates whether to flip for
            each individual barb.  Normal behavior is for the barbs and lines
            to point right (comes from wind barbs having these features point
            towards low pressure in the Northern Hemisphere.)  Default is
            False

        Barbs are traditionally used in meteorology as a way to plot the speed
        and direction of wind observations, but can technically be used to
        plot any two dimensional vector quantity.  As opposed to arrows, which
        give vector magnitude by the length of the arrow, the barbs give more
        quantitative information about the vector magnitude by putting slanted
        lines or a triangle for various increments in magnitude, as show
        schematically below::

         :     /\    \\
         :    /  \    \\
         :   /    \    \    \\
         :  /      \    \    \\
         : ------------------------------

        .. note the double \\ at the end of each line to make the figure
        .. render correctly

        The largest increment is given by a triangle (or "flag"). After those
        come full lines (barbs). The smallest increment is a half line.  There
        is only, of course, ever at most 1 half line.  If the magnitude is
        small and only needs a single half-line and no full lines or
        triangles, the half-line is offset from the end of the barb so that it
        can be easily distinguished from barbs with a single full line.  The
        magnitude for the barb shown above would nominally be 65, using the
        standard increments of 50, 10, and 5.

        linewidths and edgecolors can be used to customize the barb.
        Additional :class:`~matplotlib.collections.PolyCollection` keyword
        arguments:

          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 positional and all keyword arguments.

    barh(*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

    bone()
        Set the colormap to "bone".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    box(on=None)
        Turn the axes box on or off.

        Parameters
        ----------
        on : bool or None
            The new axes box state.  If ``None``, toggle the state.

    boxplot(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, hold=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(xranges, yrange, hold=None, 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.

    cla()
        Clear the current axes.

    clabel(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``.

    clf()
        Clear the current figure.

    clim(vmin=None, vmax=None)
        Set the color limits of the current image.

        To apply clim to all axes images do::

          clim(0, 0.5)

        If either *vmin* or *vmax* is None, the image min/max respectively
        will be used for color scaling.

        If you want to set the clim of multiple images,
        use, for example::

          for im in gca().get_images():
              im.set_clim(0, 0.05)

    close(*args)
        Close a figure window.

        ``close()`` by itself closes the current figure

        ``close(fig)`` closes the `.Figure` instance *fig*

        ``close(num)`` closes the figure number *num*

        ``close(name)`` where *name* is a string, closes figure with that label

        ``close('all')`` closes all the figure windows

    cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend=<function detrend_none at 0x0000000007CC2598>, window=<function window_hanning at 0x0000000007C949D8>, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, hold=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'.

    colorbar(mappable=None, cax=None, ax=None, **kw)
        Add a colorbar to a plot.

        Function signatures for the :mod:`~matplotlib.pyplot` interface; all
        but the first are also method signatures for the
        :meth:`~matplotlib.figure.Figure.colorbar` method::

          colorbar(**kwargs)
          colorbar(mappable, **kwargs)
          colorbar(mappable, cax=cax, **kwargs)
          colorbar(mappable, ax=ax, **kwargs)

        Parameters
        ----------
        mappable :
            The :class:`~matplotlib.image.Image`,
            :class:`~matplotlib.contour.ContourSet`, etc. to
            which the colorbar applies; this argument is mandatory for the Figure
            :meth:`~matplotlib.figure.Figure.colorbar` method but optional for the
            pyplot :func:`~matplotlib.pyplot.colorbar` function, which sets the
            default to the current image.

        cax : :class:`~matplotlib.axes.Axes` object, optional
            Axis into which the colorbar will be drawn

        ax : :class:`~matplotlib.axes.Axes`, list of Axes, optional
            Parent axes from which space for a new colorbar axes will be stolen.
            If a list of axes is given they will all be resized to make room for the
            colorbar axes.

        use_gridspec : bool, optional
            If *cax* is ``None``, a new *cax* is created as an instance of
            Axes. If *ax* is an instance of Subplot and *use_gridspec* is ``True``,
            *cax* is created as an instance of Subplot using the
            grid_spec module.

        Returns
        -------
        :class:`~matplotlib.colorbar.Colorbar` instance
            See also its base class, :class:`~matplotlib.colorbar.ColorbarBase`.
            Call the :meth:`~matplotlib.colorbar.ColorbarBase.set_label` method
            to label the colorbar.

        Notes
        -----
        Additional keyword arguments are of two kinds:

          axes properties:

            ============= ====================================================
            Property      Description
            ============= ====================================================
            *orientation* vertical or horizontal
            *fraction*    0.15; fraction of original axes to use for colorbar
            *pad*         0.05 if vertical, 0.15 if horizontal; fraction
                          of original axes between colorbar and new image axes
            *shrink*      1.0; fraction by which to multiply the size of the colorbar
            *aspect*      20; ratio of long to short dimensions
            *anchor*      (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal;
                          the anchor point of the colorbar axes
            *panchor*     (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal;
                          the anchor point of the colorbar parent axes. If
                          False, the parent axes' anchor will be unchanged
            ============= ====================================================

          colorbar properties:

            ============  ====================================================
            Property      Description
            ============  ====================================================
            *extend*      [ 'neither' | 'both' | 'min' | 'max' ]
                          If not 'neither', make pointed end(s) for out-of-
                          range values.  These are set for a given colormap
                          using the colormap set_under and set_over methods.
            *extendfrac*  [ *None* | 'auto' | length | lengths ]
                          If set to *None*, both the minimum and maximum
                          triangular colorbar extensions with have a length of
                          5% of the interior colorbar length (this is the
                          default setting). If set to 'auto', makes the
                          triangular colorbar extensions the same lengths as
                          the interior boxes (when *spacing* is set to
                          'uniform') or the same lengths as the respective
                          adjacent interior boxes (when *spacing* is set to
                          'proportional'). If a scalar, indicates the length
                          of both the minimum and maximum triangular colorbar
                          extensions as a fraction of the interior colorbar
                          length. A two-element sequence of fractions may also
                          be given, indicating the lengths of the minimum and
                          maximum colorbar extensions respectively as a
                          fraction of the interior colorbar length.
            *extendrect*  bool
                          If *False* the minimum and maximum colorbar extensions
                          will be triangular (the default). If *True* the
                          extensions will be rectangular.
            *spacing*     [ 'uniform' | 'proportional' ]
                          Uniform spacing gives each discrete color the same
                          space; proportional makes the space proportional to
                          the data interval.
            *ticks*       [ None | list of ticks | Locator object ]
                          If None, ticks are determined automatically from the
                          input.
            *format*      [ None | format string | Formatter object ]
                          If None, the
                          :class:`~matplotlib.ticker.ScalarFormatter` is used.
                          If a format string is given, e.g., '%.3f', that is
                          used. An alternative
                          :class:`~matplotlib.ticker.Formatter` object may be
                          given instead.
            *drawedges*   bool
                          Whether to draw lines at color boundaries.
            ============  ====================================================

            The following will probably be useful only in the context of
            indexed colors (that is, when the mappable has norm=NoNorm()),
            or other unusual circumstances.

            ============   ===================================================
            Property       Description
            ============   ===================================================
            *boundaries*   None or a sequence
            *values*       None or a sequence which must be of length 1 less
                           than the sequence of *boundaries*. For each region
                           delimited by adjacent entries in *boundaries*, the
                           color mapped to the corresponding value in values
                           will be used.
            ============   ===================================================

        If *mappable* is a :class:`~matplotlib.contours.ContourSet`, its *extend*
        kwarg is included automatically.

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

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

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

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

        However this has negative consequences in other circumstances. Particularly
        with semi transparent images (alpha < 1) and colorbar extensions and is not
        enabled by default see (issue #1188).

    colormaps()
        Matplotlib provides a number of colormaps, and others can be added using
        :func:`~matplotlib.cm.register_cmap`.  This function documents the built-in
        colormaps, and will also return a list of all registered colormaps if called.

        You can set the colormap for an image, pcolor, scatter, etc,
        using a keyword argument::

          imshow(X, cmap=cm.hot)

        or using the :func:`set_cmap` function::

          imshow(X)
          pyplot.set_cmap('hot')
          pyplot.set_cmap('jet')

        In interactive mode, :func:`set_cmap` will update the colormap post-hoc,
        allowing you to see which one works best for your data.

        All built-in colormaps can be reversed by appending ``_r``: For instance,
        ``gray_r`` is the reverse of ``gray``.

        There are several common color schemes used in visualization:

        Sequential schemes
          for unipolar data that progresses from low to high
        Diverging schemes
          for bipolar data that emphasizes positive or negative deviations from a
          central value
        Cyclic schemes
          meant for plotting values that wrap around at the
          endpoints, such as phase angle, wind direction, or time of day
        Qualitative schemes
          for nominal data that has no inherent ordering, where color is used
          only to distinguish categories

        Matplotlib ships with 4 perceptually uniform color maps which are
        the recommended color maps for sequential data:

          =========   ===================================================
          Colormap    Description
          =========   ===================================================
          inferno     perceptually uniform shades of black-red-yellow
          magma       perceptually uniform shades of black-red-white
          plasma      perceptually uniform shades of blue-red-yellow
          viridis     perceptually uniform shades of blue-green-yellow
          =========   ===================================================

        The following colormaps are based on the `ColorBrewer
        <http://colorbrewer2.org>`_ color specifications and designs developed by
        Cynthia Brewer:

        ColorBrewer Diverging (luminance is highest at the midpoint, and
        decreases towards differently-colored endpoints):

          ========  ===================================
          Colormap  Description
          ========  ===================================
          BrBG      brown, white, blue-green
          PiYG      pink, white, yellow-green
          PRGn      purple, white, green
          PuOr      orange, white, purple
          RdBu      red, white, blue
          RdGy      red, white, gray
          RdYlBu    red, yellow, blue
          RdYlGn    red, yellow, green
          Spectral  red, orange, yellow, green, blue
          ========  ===================================

        ColorBrewer Sequential (luminance decreases monotonically):

          ========  ====================================
          Colormap  Description
          ========  ====================================
          Blues     white to dark blue
          BuGn      white, light blue, dark green
          BuPu      white, light blue, dark purple
          GnBu      white, light green, dark blue
          Greens    white to dark green
          Greys     white to black (not linear)
          Oranges   white, orange, dark brown
          OrRd      white, orange, dark red
          PuBu      white, light purple, dark blue
          PuBuGn    white, light purple, dark green
          PuRd      white, light purple, dark red
          Purples   white to dark purple
          RdPu      white, pink, dark purple
          Reds      white to dark red
          YlGn      light yellow, dark green
          YlGnBu    light yellow, light green, dark blue
          YlOrBr    light yellow, orange, dark brown
          YlOrRd    light yellow, orange, dark red
          ========  ====================================

        ColorBrewer Qualitative:

        (For plotting nominal data, :class:`ListedColormap` is used,
        not :class:`LinearSegmentedColormap`.  Different sets of colors are
        recommended for different numbers of categories.)

        * Accent
        * Dark2
        * Paired
        * Pastel1
        * Pastel2
        * Set1
        * Set2
        * Set3

        A set of colormaps derived from those of the same name provided
        with Matlab are also included:

          =========   =======================================================
          Colormap    Description
          =========   =======================================================
          autumn      sequential linearly-increasing shades of red-orange-yellow
          bone        sequential increasing black-white color map with
                      a tinge of blue, to emulate X-ray film
          cool        linearly-decreasing shades of cyan-magenta
          copper      sequential increasing shades of black-copper
          flag        repetitive red-white-blue-black pattern (not cyclic at
                      endpoints)
          gray        sequential linearly-increasing black-to-white
                      grayscale
          hot         sequential black-red-yellow-white, to emulate blackbody
                      radiation from an object at increasing temperatures
          hsv         cyclic red-yellow-green-cyan-blue-magenta-red, formed
                      by changing the hue component in the HSV color space
          jet         a spectral map with dark endpoints, blue-cyan-yellow-red;
                      based on a fluid-jet simulation by NCSA [#]_
          pink        sequential increasing pastel black-pink-white, meant
                      for sepia tone colorization of photographs
          prism       repetitive red-yellow-green-blue-purple-...-green pattern
                      (not cyclic at endpoints)
          spring      linearly-increasing shades of magenta-yellow
          summer      sequential linearly-increasing shades of green-yellow
          winter      linearly-increasing shades of blue-green
          =========   =======================================================

        A set of palettes from the `Yorick scientific visualisation
        package <https://dhmunro.github.io/yorick-doc/>`_, an evolution of
        the GIST package, both by David H. Munro are included:

          ============  =======================================================
          Colormap      Description
          ============  =======================================================
          gist_earth    mapmaker's colors from dark blue deep ocean to green
                        lowlands to brown highlands to white mountains
          gist_heat     sequential increasing black-red-orange-white, to emulate
                        blackbody radiation from an iron bar as it grows hotter
          gist_ncar     pseudo-spectral black-blue-green-yellow-red-purple-white
                        colormap from National Center for Atmospheric
                        Research [#]_
          gist_rainbow  runs through the colors in spectral order from red to
                        violet at full saturation (like *hsv* but not cyclic)
          gist_stern    "Stern special" color table from Interactive Data
                        Language software
          ============  =======================================================

        Other miscellaneous schemes:

          ============= =======================================================
          Colormap      Description
          ============= =======================================================
          afmhot        sequential black-orange-yellow-white blackbody
                        spectrum, commonly used in atomic force microscopy
          brg           blue-red-green
          bwr           diverging blue-white-red
          coolwarm      diverging blue-gray-red, meant to avoid issues with 3D
                        shading, color blindness, and ordering of colors [#]_
          CMRmap        "Default colormaps on color images often reproduce to
                        confusing grayscale images. The proposed colormap
                        maintains an aesthetically pleasing color image that
                        automatically reproduces to a monotonic grayscale with
                        discrete, quantifiable saturation levels." [#]_
          cubehelix     Unlike most other color schemes cubehelix was designed
                        by D.A. Green to be monotonically increasing in terms
                        of perceived brightness. Also, when printed on a black
                        and white postscript printer, the scheme results in a
                        greyscale with monotonically increasing brightness.
                        This color scheme is named cubehelix because the r,g,b
                        values produced can be visualised as a squashed helix
                        around the diagonal in the r,g,b color cube.
          gnuplot       gnuplot's traditional pm3d scheme
                        (black-blue-red-yellow)
          gnuplot2      sequential color printable as gray
                        (black-blue-violet-yellow-white)
          ocean         green-blue-white
          rainbow       spectral purple-blue-green-yellow-orange-red colormap
                        with diverging luminance
          seismic       diverging blue-white-red
          nipy_spectral black-purple-blue-green-yellow-red-white spectrum,
                        originally from the Neuroimaging in Python project
          terrain       mapmaker's colors, blue-green-yellow-brown-white,
                        originally from IGOR Pro
          ============= =======================================================

        The following colormaps are redundant and may be removed in future
        versions.  It's recommended to use the names in the descriptions
        instead, which produce identical output:

          =========  =======================================================
          Colormap   Description
          =========  =======================================================
          gist_gray  identical to *gray*
          gist_yarg  identical to *gray_r*
          binary     identical to *gray_r*
          spectral   identical to *nipy_spectral* [#]_
          =========  =======================================================

        .. rubric:: Footnotes

        .. [#] Rainbow colormaps, ``jet`` in particular, are considered a poor
          choice for scientific visualization by many researchers: `Rainbow Color
          Map (Still) Considered Harmful
          <http://ieeexplore.ieee.org/document/4118486/?arnumber=4118486>`_

        .. [#] Resembles "BkBlAqGrYeOrReViWh200" from NCAR Command
          Language. See `Color Table Gallery
          <https://www.ncl.ucar.edu/Document/Graphics/color_table_gallery.shtml>`_

        .. [#] See `Diverging Color Maps for Scientific Visualization
          <http://www.kennethmoreland.com/color-maps/>`_ by Kenneth Moreland.

        .. [#] See `A Color Map for Effective Black-and-White Rendering of
          Color-Scale Images
          <https://www.mathworks.com/matlabcentral/fileexchange/2662-cmrmap-m>`_
          by Carey Rappaport

        .. [#] Changed to distinguish from ColorBrewer's *Spectral* map.
          :func:`spectral` still works, but
          ``set_cmap('nipy_spectral')`` is recommended for clarity.

    colors()
        .. deprecated:: 2.1
            The colors function was deprecated in version 2.1.

        This is a do-nothing function to provide you with help on how
        matplotlib handles colors.

        Commands which take color arguments can use several formats to
        specify the colors.  For the basic built-in colors, you can use a
        single letter

          =====   =======
          Alias   Color
          =====   =======
          'b'     blue
          'g'     green
          'r'     red
          'c'     cyan
          'm'     magenta
          'y'     yellow
          'k'     black
          'w'     white
          =====   =======

        For a greater range of colors, you have two options.  You can
        specify the color using an html hex string, as in::

          color = '#eeefff'

        or you can pass an R,G,B tuple, where each of R,G,B are in the
        range [0,1].

        You can also use any legal html name for a color, for example::

          color = 'red'
          color = 'burlywood'
          color = 'chartreuse'

        The example below creates a subplot with a dark
        slate gray background::

           subplot(111, facecolor=(0.1843, 0.3098, 0.3098))

        Here is an example that creates a pale turquoise title::

          title('Is this the best color?', color='#afeeee')

    connect(s, func)
        Connect event with string *s* to *func*.  The signature of *func* is::

          def func(event)

        where event is a :class:`matplotlib.backend_bases.Event`.  The
        following events are recognized

        - 'button_press_event'
        - 'button_release_event'
        - 'draw_event'
        - 'key_press_event'
        - 'key_release_event'
        - 'motion_notify_event'
        - 'pick_event'
        - 'resize_event'
        - 'scroll_event'
        - 'figure_enter_event',
        - 'figure_leave_event',
        - 'axes_enter_event',
        - 'axes_leave_event'
        - 'close_event'

        For the location events (button and key press/release), if the
        mouse is over the axes, the variable ``event.inaxes`` will be
        set to the :class:`~matplotlib.axes.Axes` the event occurs is
        over, and additionally, the variables ``event.xdata`` and
        ``event.ydata`` will be defined.  This is the mouse location
        in data coords.  See
        :class:`~matplotlib.backend_bases.KeyEvent` and
        :class:`~matplotlib.backend_bases.MouseEvent` for more info.

        Return value is a connection id that can be used with
        :meth:`~matplotlib.backend_bases.Event.mpl_disconnect`.

        Examples
        --------
        Usage::

            def on_press(event):
                print('you pressed', event.button, event.xdata, event.ydata)

            cid = canvas.mpl_connect('button_press_event', on_press)

    contour(*args, **kwargs)
        Plot contours.

        :func:`~matplotlib.pyplot.contour` and
        :func:`~matplotlib.pyplot.contourf` draw contour lines and
        filled contours, respectively.  Except as noted, function
        signatures and return values are the same for both versions.

        :func:`~matplotlib.pyplot.contourf` differs from the MATLAB
        version in that it does not draw the polygon edges.
        To draw edges, add line contours with
        calls to :func:`~matplotlib.pyplot.contour`.

        Call signatures::

          contour(Z)

        make a contour plot of an array *Z*. The level values are chosen
        automatically.

        ::

          contour(X,Y,Z)

        *X*, *Y* specify the (x, y) coordinates of the surface

        ::

          contour(Z,N)
          contour(X,Y,Z,N)

        contour up to *N+1* automatically chosen contour levels
        (*N* intervals).

        ::

          contour(Z,V)
          contour(X,Y,Z,V)

        draw contour lines at the values specified in sequence *V*,
        which must be in increasing order.

        ::

          contourf(..., V)

        fill the ``len(V)-1`` regions between the values in *V*,
        which must be in increasing order.

        ::

          contour(Z, **kwargs)

        Use keyword args to control colors, linewidth, origin, cmap ... see
        below for more details.

        *X* and *Y* must both be 2-D with the same shape as *Z*, or they
        must both be 1-D such that ``len(X)`` is the number of columns in
        *Z* and ``len(Y)`` is the number of rows in *Z*.

        ``C = contour(...)`` returns a
        :class:`~matplotlib.contour.QuadContourSet` object.

        Optional keyword arguments:

          *corner_mask*: bool, optional
            Enable/disable corner masking, which only has an effect if *Z* is
            a masked array.  If ``False``, any quad touching a masked point is
            masked out.  If ``True``, only the triangular corners of quads
            nearest those points are always masked out, other triangular
            corners comprising three unmasked points are contoured as usual.

            Defaults to ``rcParams['contour.corner_mask']``, which defaults to
            ``True``.

          *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.

          *vmin*, *vmax*: [ *None* | scalar ]
            If not *None*, either or both of these values will be
            supplied to the :class:`matplotlib.colors.Normalize`
            instance, overriding the default color scaling based on
            *levels*.

          *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`.

          *antialiased*: bool
            enable antialiasing, overriding the defaults.  For
            filled contours, the default is *True*.  For line contours,
            it is taken from rcParams['lines.antialiased'].

          *nchunk*: [ 0 | integer ]
            If 0, no subdivision of the domain.  Specify a positive integer to
            divide the domain into subdomains of *nchunk* by *nchunk* quads.
            Chunking reduces the maximum length of polygons generated by the
            contouring algorithm which reduces the rendering workload passed
            on to the backend and also requires slightly less RAM.  It can
            however introduce rendering artifacts at chunk boundaries depending
            on the backend, the *antialiased* flag and value of *alpha*.

        contour-only keyword arguments:

          *linewidths*: [ *None* | number | tuple of numbers ]
            If *linewidths* is *None*, the default width in
            ``lines.linewidth`` in ``matplotlibrc`` is used.

            If a number, all levels will be plotted with this linewidth.

            If a tuple, different levels will be plotted with different
            linewidths in the order specified.

          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
            If *linestyles* is *None*, the default is 'solid' unless
            the lines are monochrome.  In that case, negative
            contours will take their linestyle from the ``matplotlibrc``
            ``contour.negative_linestyle`` setting.

            *linestyles* can also be an iterable of the above strings
            specifying a set of linestyles to be used. If this
            iterable is shorter than the number of contour levels
            it will be repeated as necessary.

        contourf-only keyword arguments:

          *hatches*:
            A list of cross hatch patterns to use on the filled areas.
            If None, no hatching will be added to the contour.
            Hatching is supported in the PostScript, PDF, SVG and Agg
            backends only.

        Note: contourf 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.

    contourf(*args, **kwargs)
        Plot contours.

        :func:`~matplotlib.pyplot.contour` and
        :func:`~matplotlib.pyplot.contourf` draw contour lines and
        filled contours, respectively.  Except as noted, function
        signatures and return values are the same for both versions.

        :func:`~matplotlib.pyplot.contourf` differs from the MATLAB
        version in that it does not draw the polygon edges.
        To draw edges, add line contours with
        calls to :func:`~matplotlib.pyplot.contour`.

        Call signatures::

          contour(Z)

        make a contour plot of an array *Z*. The level values are chosen
        automatically.

        ::

          contour(X,Y,Z)

        *X*, *Y* specify the (x, y) coordinates of the surface

        ::

          contour(Z,N)
          contour(X,Y,Z,N)

        contour up to *N+1* automatically chosen contour levels
        (*N* intervals).

        ::

          contour(Z,V)
          contour(X,Y,Z,V)

        draw contour lines at the values specified in sequence *V*,
        which must be in increasing order.

        ::

          contourf(..., V)

        fill the ``len(V)-1`` regions between the values in *V*,
        which must be in increasing order.

        ::

          contour(Z, **kwargs)

        Use keyword args to control colors, linewidth, origin, cmap ... see
        below for more details.

        *X* and *Y* must both be 2-D with the same shape as *Z*, or they
        must both be 1-D such that ``len(X)`` is the number of columns in
        *Z* and ``len(Y)`` is the number of rows in *Z*.

        ``C = contour(...)`` returns a
        :class:`~matplotlib.contour.QuadContourSet` object.

        Optional keyword arguments:

          *corner_mask*: bool, optional
            Enable/disable corner masking, which only has an effect if *Z* is
            a masked array.  If ``False``, any quad touching a masked point is
            masked out.  If ``True``, only the triangular corners of quads
            nearest those points are always masked out, other triangular
            corners comprising three unmasked points are contoured as usual.

            Defaults to ``rcParams['contour.corner_mask']``, which defaults to
            ``True``.

          *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.

          *vmin*, *vmax*: [ *None* | scalar ]
            If not *None*, either or both of these values will be
            supplied to the :class:`matplotlib.colors.Normalize`
            instance, overriding the default color scaling based on
            *levels*.

          *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`.

          *antialiased*: bool
            enable antialiasing, overriding the defaults.  For
            filled contours, the default is *True*.  For line contours,
            it is taken from rcParams['lines.antialiased'].

          *nchunk*: [ 0 | integer ]
            If 0, no subdivision of the domain.  Specify a positive integer to
            divide the domain into subdomains of *nchunk* by *nchunk* quads.
            Chunking reduces the maximum length of polygons generated by the
            contouring algorithm which reduces the rendering workload passed
            on to the backend and also requires slightly less RAM.  It can
            however introduce rendering artifacts at chunk boundaries depending
            on the backend, the *antialiased* flag and value of *alpha*.

        contour-only keyword arguments:

          *linewidths*: [ *None* | number | tuple of numbers ]
            If *linewidths* is *None*, the default width in
            ``lines.linewidth`` in ``matplotlibrc`` is used.

            If a number, all levels will be plotted with this linewidth.

            If a tuple, different levels will be plotted with different
            linewidths in the order specified.

          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
            If *linestyles* is *None*, the default is 'solid' unless
            the lines are monochrome.  In that case, negative
            contours will take their linestyle from the ``matplotlibrc``
            ``contour.negative_linestyle`` setting.

            *linestyles* can also be an iterable of the above strings
            specifying a set of linestyles to be used. If this
            iterable is shorter than the number of contour levels
            it will be repeated as necessary.

        contourf-only keyword arguments:

          *hatches*:
            A list of cross hatch patterns to use on the filled areas.
            If None, no hatching will be added to the contour.
            Hatching is supported in the PostScript, PDF, SVG and Agg
            backends only.

        Note: contourf 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.

    cool()
        Set the colormap to "cool".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    copper()
        Set the colormap to "copper".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    csd(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, hold=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'.

    delaxes(ax=None)
        Remove the given `Axes` *ax* from the current figure. If *ax* is *None*,
        the current axes is removed. A KeyError is raised if the axes doesn't exist.

    disconnect(cid)
        Disconnect callback id cid

        Examples
        --------
        Usage::

            cid = canvas.mpl_connect('button_press_event', on_press)
            #...later
            canvas.mpl_disconnect(cid)

    draw()
        Redraw the current figure.

        This is used to update a figure that has been altered, but not
        automatically re-drawn.  If interactive mode is on (:func:`.ion()`), this
        should be only rarely needed, but there may be ways to modify the state of
        a figure without marking it as `stale`.  Please report these cases as
        bugs.

        A more object-oriented alternative, given any
        :class:`~matplotlib.figure.Figure` instance, :attr:`fig`, that
        was created using a :mod:`~matplotlib.pyplot` function, is::

            fig.canvas.draw_idle()

    errorbar(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, hold=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(positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, linestyles='solid', hold=None, 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'.

    figimage(*args, **kwargs)
        Adds a non-resampled image to the figure.

        call signatures::

          figimage(X, **kwargs)

        adds a non-resampled array *X* to the figure.

        ::

          figimage(X, xo, yo)

        with pixel offsets *xo*, *yo*,

        *X* must be a float array:

        * If *X* is MxN, assume luminance (grayscale)
        * If *X* is MxNx3, assume RGB
        * If *X* is MxNx4, assume RGBA

        Optional keyword arguments:

          =========   =========================================================
          Keyword     Description
          =========   =========================================================
          resize      a boolean, True or False. If "True", then re-size the
                      Figure to match the given image size.
          xo or yo    An integer, the *x* and *y* image offset in pixels
          cmap        a :class:`matplotlib.colors.Colormap` instance, e.g.,
                      cm.jet. If *None*, default to the rc ``image.cmap``
                      value
          norm        a :class:`matplotlib.colors.Normalize` instance. The
                      default is normalization().  This scales luminance -> 0-1
          vmin|vmax   are used to scale a luminance image to 0-1.  If either
                      is *None*, the min and max of the luminance values will
                      be used.  Note if you pass a norm instance, the settings
                      for *vmin* and *vmax* will be ignored.
          alpha       the alpha blending value, default is *None*
          origin      [ 'upper' | 'lower' ] Indicates where the [0,0] index of
                      the array is in the upper left or lower left corner of
                      the axes. Defaults to the rc image.origin value
          =========   =========================================================

        figimage complements the axes image
        (:meth:`~matplotlib.axes.Axes.imshow`) which will be resampled
        to fit the current axes.  If you want a resampled image to
        fill the entire figure, you can define an
        :class:`~matplotlib.axes.Axes` with extent [0,0,1,1].

        An :class:`matplotlib.image.FigureImage` instance is returned.

        Additional kwargs are Artist kwargs passed on to
        :class:`~matplotlib.image.FigureImage`

    figlegend(*args, **kwargs)
        Place a legend in the figure.

        *labels*
          a sequence of strings

        *handles*
          a sequence of :class:`~matplotlib.lines.Line2D` or
          :class:`~matplotlib.patches.Patch` instances

        *loc*
          can be a string or an integer specifying the legend
          location

        A :class:`matplotlib.legend.Legend` instance is returned.

        Examples
        --------

        To make a legend from existing artists on every axes::

          figlegend()

        To make a legend for a list of lines and labels::

          figlegend( (line1, line2, line3),
                     ('label1', 'label2', 'label3'),
                     'upper right' )

        .. seealso::

           :func:`~matplotlib.pyplot.legend`

    fignum_exists(num)

    figtext(*args, **kwargs)
        Add text to figure.

        Call signature::

          text(x, y, s, fontdict=None, **kwargs)

        Add text to figure at location *x*, *y* (relative 0-1
        coords). See :func:`~matplotlib.pyplot.text` for the meaning
        of the other arguments.

        kwargs control the :class:`~matplotlib.text.Text` 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
          backgroundcolor: any matplotlib color
          bbox: FancyBboxPatch prop dict
          clip_box: a :class:`matplotlib.transforms.Bbox` instance
          clip_on: bool
          clip_path: [ (:class:`~matplotlib.path.Path`, :class:`~matplotlib.transforms.Transform`) | :class:`~matplotlib.patches.Patch` | None ]
          color: any matplotlib color
          contains: a callable function
          family or fontfamily or fontname or name: [FONTNAME | 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ]
          figure: a `.Figure` instance
          fontproperties or font_properties: a :class:`matplotlib.font_manager.FontProperties` instance
          gid: an id string
          horizontalalignment or ha: [ 'center' | 'right' | 'left' ]
          label: object
          linespacing: float (multiple of font size)
          multialignment or ma: ['left' | 'right' | 'center' ]
          path_effects: `.AbstractPathEffect`
          picker: [None | bool | float | callable]
          position: (x,y)
          rasterized: bool or None
          rotation: [ angle in degrees | 'vertical' | 'horizontal' ]
          rotation_mode: [ None | "default" | "anchor" ]
          size or fontsize: [size in points | 'xx-small' | 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | 'xx-large' ]
          sketch_params: (scale: float, length: float, randomness: float)
          snap: bool or None
          stretch or fontstretch: [a numeric value in range 0-1000 | 'ultra-condensed' | 'extra-condensed' | 'condensed' | 'semi-condensed' | 'normal' | 'semi-expanded' | 'expanded' | 'extra-expanded' | 'ultra-expanded' ]
          style or fontstyle: [ 'normal' | 'italic' | 'oblique']
          text: string or anything printable with '%s' conversion.
          transform: `.Transform`
          url: a url string
          usetex: bool or None
          variant or fontvariant: [ 'normal' | 'small-caps' ]
          verticalalignment or va: [ 'center' | 'top' | 'bottom' | 'baseline' ]
          visible: bool
          weight or fontweight: [a numeric value in range 0-1000 | 'ultralight' | 'light' | 'normal' | 'regular' | 'book' | 'medium' | 'roman' | 'semibold' | 'demibold' | 'demi' | 'bold' | 'heavy' | 'extra bold' | 'black' ]
          wrap: bool
          x: float
          y: float
          zorder: float

    figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True, FigureClass=<class 'matplotlib.figure.Figure'>, clear=False, **kwargs)
        Creates a new figure.

        Parameters
        ----------

        num : integer or string, optional, default: none
            If not provided, a new figure will be created, and the figure number
            will be incremented. The figure objects holds this number in a `number`
            attribute.
            If num is provided, and a figure with this id already exists, make
            it active, and returns a reference to it. If this figure does not
            exists, create it and returns it.
            If num is a string, the window title will be set to this figure's
            `num`.

        figsize : tuple of integers, optional, default: None
            width, height in inches. If not provided, defaults to rc
            figure.figsize.

        dpi : integer, optional, default: None
            resolution of the figure. If not provided, defaults to rc figure.dpi.

        facecolor :
            the background color. If not provided, defaults to rc figure.facecolor.

        edgecolor :
            the border color. If not provided, defaults to rc figure.edgecolor.

        frameon : bool, optional, default: True
            If False, suppress drawing the figure frame.

        FigureClass : class derived from matplotlib.figure.Figure
            Optionally use a custom Figure instance.

        clear : bool, optional, default: False
            If True and the figure already exists, then it is cleared.

        Returns
        -------
        figure : Figure
            The Figure instance returned will also be passed to new_figure_manager
            in the backends, which allows to hook custom Figure classes into the
            pylab interface. Additional kwargs will be passed to the figure init
            function.

        Notes
        -----
        If you are creating many figures, make sure you explicitly call "close"
        on the figures you are not using, because this will enable pylab
        to properly clean up the memory.

        rcParams defines the default values, which can be modified in the
        matplotlibrc file

    fill(*args, **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(x, y1, y2=0, where=None, interpolate=False, step=None, hold=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(y, x1, x2=0, where=None, step=None, interpolate=False, hold=None, 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'.

    findobj(o=None, 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.

    flag()
        Set the colormap to "flag".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    gca(**kwargs)
        Get the current :class:`~matplotlib.axes.Axes` instance on the
        current figure matching the given keyword args, or create one.

        Examples
        --------
        To get the current polar axes on the current figure::

            plt.gca(projection='polar')

        If the current axes doesn't exist, or isn't a polar one, the appropriate
        axes will be created and then returned.

        See Also
        --------
        matplotlib.figure.Figure.gca : The figure's gca method.

    gcf()
        Get a reference to the current figure.

    gci()
        Get the current colorable artist.  Specifically, returns the
        current :class:`~matplotlib.cm.ScalarMappable` instance (image or
        patch collection), or *None* if no images or patch collections
        have been defined.  The commands :func:`~matplotlib.pyplot.imshow`
        and :func:`~matplotlib.pyplot.figimage` create
        :class:`~matplotlib.image.Image` instances, and the commands
        :func:`~matplotlib.pyplot.pcolor` and
        :func:`~matplotlib.pyplot.scatter` create
        :class:`~matplotlib.collections.Collection` instances.  The
        current image is an attribute of the current axes, or the nearest
        earlier axes in the current figure that contains an image.

    get_current_fig_manager()

    get_figlabels()
        Return a list of existing figure labels.

    get_fignums()
        Return a list of existing figure numbers.

    get_plot_commands()
        Get a sorted list of all of the plotting commands.

    ginput(*args, **kwargs)
        Blocking call to interact with a figure.

        Wait until the user clicks *n* times on the figure, and return the
        coordinates of each click in a list.

        The buttons used for the various actions (adding points, removing
        points, terminating the inputs) can be overridden via the
        arguments *mouse_add*, *mouse_pop* and *mouse_stop*, that give
        the associated mouse button: 1 for left, 2 for middle, 3 for
        right.

        Parameters
        ----------
        n : int, optional, default: 1
            Number of mouse clicks to accumulate. If negative, accumulate
            clicks until the input is terminated manually.
        timeout : scalar, optional, default: 30
            Number of seconds to wait before timing out. If zero or negative
            will never timeout.
        show_clicks : bool, optional, default: False
            If True, show a red cross at the location of each click.
        mouse_add : int, one of (1, 2, 3), optional, default: 1 (left click)
            Mouse button used to add points.
        mouse_pop : int, one of (1, 2, 3), optional, default: 3 (right click)
            Mouse button used to remove the most recently added point.
        mouse_stop : int, one of (1, 2, 3), optional, default: 2 (middle click)
            Mouse button used to stop input.

        Returns
        -------
        points : list of tuples
            A list of the clicked (x, y) coordinates.

        Notes
        -----
        The keyboard can also be used to select points in case your mouse
        does not have one or more of the buttons.  The delete and backspace
        keys act like right clicking (i.e., remove last point), the enter key
        terminates input and any other key (not already used by the window
        manager) selects a point.

    gray()
        Set the colormap to "gray".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    grid(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

    hexbin(x, y, C=None, gridsize=100, bins=None, xscale='linear', yscale='linear', extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='face', reduce_C_function=<function mean at 0x0000000005314158>, mincnt=None, marginals=False, hold=None, 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(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, hold=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(x, y, bins=10, range=None, normed=False, weights=None, cmin=None, cmax=None, hold=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(y, xmin, xmax, colors='k', linestyles='solid', label='', hold=None, 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'.

    hold(b=None)
        .. deprecated:: 2.0
            pyplot.hold is deprecated.
            Future behavior will be consistent with the long-time default:
            plot commands add elements without first clearing the
            Axes and/or Figure.

        Set the hold state.  If *b* is None (default), toggle the
        hold state, else set the hold state to boolean value *b*::

          hold()      # toggle hold
          hold(True)  # hold is on
          hold(False) # hold is off

        When *hold* is *True*, subsequent plot commands will add elements to
        the current axes.  When *hold* is *False*, the current axes and
        figure will be cleared on the next plot command.

    hot()
        Set the colormap to "hot".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    hsv()
        Set the colormap to "hsv".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    imread(*args, **kwargs)
        Read an image from a file into an array.

        *fname* may be a string path, a valid URL, or a Python
        file-like object.  If using a file object, it must be opened in binary
        mode.

        If *format* is provided, will try to read file of that type,
        otherwise the format is deduced from the filename.  If nothing can
        be deduced, PNG is tried.

        Return value is a :class:`numpy.array`.  For grayscale images, the
        return array is MxN.  For RGB images, the return value is MxNx3.
        For RGBA images the return value is MxNx4.

        matplotlib can only read PNGs natively, but if `PIL
        <http://www.pythonware.com/products/pil/>`_ is installed, it will
        use it to load the image and return an array (if possible) which
        can be used with :func:`~matplotlib.pyplot.imshow`. Note, URL strings
        may not be compatible with PIL. Check the PIL documentation for more
        information.

    imsave(*args, **kwargs)
        Save an array as in image file.

        The output formats available depend on the backend being used.

        Parameters
        ----------
        fname : str or file-like
            Path string to a filename, or a Python file-like object.
            If *format* is *None* and *fname* is a string, the output
            format is deduced from the extension of the filename.
        arr : array-like
            An MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA) array.
        vmin, vmax: [ None | scalar ]
            *vmin* and *vmax* set the color scaling for the image by fixing the
            values that map to the colormap color limits. If either *vmin*
            or *vmax* is None, that limit is determined from the *arr*
            min/max value.
        cmap : matplotlib.colors.Colormap, optional
            For example, ``cm.viridis``.  If ``None``, defaults to the
            ``image.cmap`` rcParam.
        format : str
            One of the file extensions supported by the active backend.  Most
            backends support png, pdf, ps, eps and svg.
        origin : [ 'upper' | 'lower' ]
            Indicates whether the ``(0, 0)`` index of the array is in the
            upper left or lower left corner of the axes.  Defaults to the
            ``image.origin`` rcParam.
        dpi : int
            The DPI to store in the metadata of the file.  This does not affect the
            resolution of the output image.

    imshow(X, cmap=None, norm=None, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, shape=None, filternorm=1, filterrad=4.0, imlim=None, resample=None, url=None, hold=None, data=None, **kwargs)
        Display an image on the axes.

        Parameters
        ----------
        X : array_like, shape (n, m) or (n, m, 3) or (n, m, 4)
            Display the image in `X` to current axes.  `X` may be an
            array or a PIL image. If `X` is an array, it
            can have the following shapes and types:

            - MxN -- values to be mapped (float or int)
            - MxNx3 -- RGB (float or uint8)
            - MxNx4 -- RGBA (float or uint8)

            MxN arrays are mapped to colors based on the `norm` (mapping
            scalar to scalar) and the `cmap` (mapping the normed scalar to
            a color).

            Elements of RGB and RGBA arrays represent pixels of an MxN image.
            All values should be in the range [0 .. 1] for floats or
            [0 .. 255] for integers.  Out-of-range values will be clipped to
            these bounds.

        cmap : `~matplotlib.colors.Colormap`, optional, default: None
            If None, default to rc `image.cmap` value. `cmap` is ignored
            if `X` is 3-D, directly specifying RGB(A) values.

        aspect : ['auto' | 'equal' | scalar], optional, default: None
            If 'auto', changes the image aspect ratio to match that of the
            axes.

            If 'equal', and `extent` is None, changes the axes aspect ratio to
            match that of the image. If `extent` is not `None`, the axes
            aspect ratio is changed to match that of the extent.

            If None, default to rc ``image.aspect`` value.

        interpolation : string, optional, default: None
            Acceptable values are 'none', 'nearest', 'bilinear', 'bicubic',
            'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser',
            'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc',
            'lanczos'

            If `interpolation` is None, default to rc `image.interpolation`.
            See also the `filternorm` and `filterrad` parameters.
            If `interpolation` is 'none', then no interpolation is performed
            on the Agg, ps and pdf backends. Other backends will fall back to
            'nearest'.

        norm : `~matplotlib.colors.Normalize`, optional, default: None
            A `~matplotlib.colors.Normalize` instance is used to scale
            a 2-D float `X` input to the (0, 1) range for input to the
            `cmap`. If `norm` is None, use the default func:`normalize`.
            If `norm` is an instance of `~matplotlib.colors.NoNorm`,
            `X` must be an array of integers that index directly into
            the lookup table of the `cmap`.

        vmin, vmax : scalar, optional, default: None
            `vmin` and `vmax` are used in conjunction with norm to normalize
            luminance data.  Note if you pass a `norm` instance, your
            settings for `vmin` and `vmax` will be ignored.

        alpha : scalar, optional, default: None
            The alpha blending value, between 0 (transparent) and 1 (opaque).
            The ``alpha`` argument is ignored for RGBA input data.

        origin : ['upper' | 'lower'], optional, default: None
            Place the [0,0] index of the array in the upper left or lower left
            corner of the axes. If None, default to rc `image.origin`.

        extent : scalars (left, right, bottom, top), optional, default: None
            The location, in data-coordinates, of the lower-left and
            upper-right corners. If `None`, the image is positioned such that
            the pixel centers fall on zero-based (row, column) indices.

        shape : scalars (columns, rows), optional, default: None
            For raw buffer images

        filternorm : scalar, optional, default: 1
            A parameter for the antigrain image resize filter.  From the
            antigrain documentation, if `filternorm` = 1, the filter
            normalizes integer values and corrects the rounding errors. It
            doesn't do anything with the source floating point values, it
            corrects only integers according to the rule of 1.0 which means
            that any sum of pixel weights must be equal to 1.0.  So, the
            filter function must produce a graph of the proper shape.

        filterrad : scalar, optional, default: 4.0
            The filter radius for filters that have a radius parameter, i.e.
            when interpolation is one of: 'sinc', 'lanczos' or 'blackman'

        Returns
        -------
        image : `~matplotlib.image.AxesImage`

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.artist.Artist` properties.

        See also
        --------
        matshow : Plot a matrix or an array as an image.

        Notes
        -----
        Unless *extent* is used, pixel centers will be located at integer
        coordinates. In other words: the origin will coincide with the center
        of pixel (0, 0).

        Two typical representations are used for RGB images with an alpha
        channel:

        -   Straight (unassociated) alpha: R, G, and B channels represent the
            color of the pixel, disregarding its opacity.
        -   Premultiplied (associated) alpha: R, G, and B channels represent
            the color of the pixel, adjusted for its opacity by multiplication.

        `~matplotlib.pyplot.imshow` expects RGB images adopting the straight
        (unassociated) alpha representation.

        .. 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.

    inferno()
        Set the colormap to "inferno".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    install_repl_displayhook()
        Install a repl display hook so that any stale figure are automatically
        redrawn when control is returned to the repl.

        This works with IPython terminals and kernels,
        as well as vanilla python shells.

    ioff()
        Turn interactive mode off.

    ion()
        Turn interactive mode on.

    ishold()
        .. deprecated:: 2.0
            pyplot.hold is deprecated.
            Future behavior will be consistent with the long-time default:
            plot commands add elements without first clearing the
            Axes and/or Figure.

        Return the hold status of the current axes.

    isinteractive()
        Return status of interactive mode.

    jet()
        Set the colormap to "jet".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    legend(*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

    locator_params(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.

    loglog(*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`.

    magma()
        Set the colormap to "magma".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    magnitude_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, scale=None, hold=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'.

    margins(*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.

    matshow(A, fignum=None, **kw)
        Display an array as a matrix in a new figure window.

        The origin is set at the upper left hand corner and rows (first
        dimension of the array) are displayed horizontally.  The aspect
        ratio of the figure window is that of the array, unless this would
        make an excessively short or narrow figure.

        Tick labels for the xaxis are placed on top.

        With the exception of *fignum*, keyword arguments are passed to
        :func:`~matplotlib.pyplot.imshow`.  You may set the *origin*
        kwarg to "lower" if you want the first row in the array to be
        at the bottom instead of the top.

        *fignum*: [ None | integer | False ]
          By default, :func:`matshow` creates a new figure window with
          automatic numbering.  If *fignum* is given as an integer, the
          created figure will use this figure number.  Because of how
          :func:`matshow` tries to set the figure aspect ratio to be the
          one of the array, if you provide the number of an already
          existing figure, strange things may happen.

          If *fignum* is *False* or 0, a new figure window will **NOT** be created.

    minorticks_off()
        Remove minor ticks from the current plot.

    minorticks_on()
        Display minor ticks on the current plot.

        Displaying minor ticks reduces performance; turn them off using
        minorticks_off() if drawing speed is a problem.

    nipy_spectral()
        Set the colormap to "nipy_spectral".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    over(func, *args, **kwargs)
        .. deprecated:: 2.0
            pyplot.hold is deprecated.
            Future behavior will be consistent with the long-time default:
            plot commands add elements without first clearing the
            Axes and/or Figure.

        Call a function with hold(True).

        Calls::

          func(*args, **kwargs)

        with ``hold(True)`` and then restores the hold state.

    pause(interval)
        Pause for *interval* seconds.

        If there is an active figure, it will be updated and displayed before the
        pause, and the GUI event loop (if any) will run during the pause.

        This can be used for crude animation.  For more complex animation, see
        :mod:`matplotlib.animation`.

        Notes
        -----
        This function is experimental; its behavior may be changed or extended in a
        future release.

    pcolor(*args, **kwargs)
        Create a pseudocolor plot of a 2-D array.

        Call signatures::

            pcolor(C, **kwargs)
            pcolor(X, Y, C, **kwargs)

        pcolor can be very slow for large arrays; consider
        using the similar but much faster
        :func:`~matplotlib.pyplot.pcolormesh` instead.

        Parameters
        ----------
        C : array_like
            An array of color values.

        X, Y : array_like, optional
            If given, specify the (x, y) coordinates of the colored
            quadrilaterals; the quadrilateral for ``C[i,j]`` has corners at::

                (X[i,   j],   Y[i,   j]),
                (X[i,   j+1], Y[i,   j+1]),
                (X[i+1, j],   Y[i+1, j]),
                (X[i+1, j+1], Y[i+1, j+1])

            Ideally the dimensions of ``X`` and ``Y`` should be one greater
            than those of ``C``; if the dimensions are the same, then the last
            row and column of ``C`` will be ignored.

            Note that the column index corresponds to the
            x-coordinate, and the row index corresponds to y; for
            details, see the :ref:`Grid Orientation
            <axes-pcolor-grid-orientation>` section below.

            If either or both of ``X`` and ``Y`` are 1-D arrays or column
            vectors, they will be expanded as needed into the appropriate 2-D
            arrays, making a rectangular grid.

        cmap : `~matplotlib.colors.Colormap`, optional, default: None
            If `None`, default to rc settings.

        norm : `matplotlib.colors.Normalize`, optional, default: None
            An instance is used to scale luminance data to (0, 1).
            If `None`, defaults to :func:`normalize`.

        vmin, vmax : scalar, optional, default: None
            ``vmin`` and ``vmax`` are used in conjunction with ``norm`` to
            normalize luminance data.  If either is `None`, it is autoscaled to
            the respective min or max of the color array ``C``.  If not `None`,
            ``vmin`` or ``vmax`` passed in here override any pre-existing
            values supplied in the ``norm`` instance.

        edgecolors : {None, 'none', color, color sequence}
            If None, the rc setting is used by default.
            If 'none', edges will not be visible.
            An mpl color or sequence of colors will set the edge color.

        alpha : scalar, optional, default: None
            The alpha blending value, between 0 (transparent) and 1 (opaque).

        snap : bool, optional, default: False
            Whether to snap the mesh to pixel boundaries.

        Returns
        -------
        collection : `matplotlib.collections.Collection`

        Other Parameters
        ----------------
        antialiaseds : bool, optional, default: False
            The default ``antialiaseds`` is False if the default
            ``edgecolors="none"`` is used.  This eliminates artificial lines
            at patch boundaries, and works regardless of the value of alpha.
            If ``edgecolors`` is not "none", then the default ``antialiaseds``
            is taken from :rc:`patch.antialiased`, which defaults to True.
            Stroking the edges may be preferred if ``alpha`` is 1, but will
            cause artifacts otherwise.

        **kwargs :

            Any unused keyword arguments are passed along to the
            `~matplotlib.collections.PolyCollection` constructor:

          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

        See Also
        --------
        pcolormesh : for an explanation of the differences between
            pcolor and pcolormesh.

        Notes
        -----
        .. _axes-pcolor-grid-orientation:

        ``X``, ``Y`` and ``C`` may be masked arrays. If either C[i, j], or one
        of the vertices surrounding C[i,j] (``X`` or ``Y`` at [i, j], [i+1, j],
        [i, j+1], [i+1, j+1]) is masked, nothing is plotted.

        The grid orientation follows the MATLAB convention: an array ``C`` with
        shape (nrows, ncolumns) is plotted with the column number as ``X`` and
        the row number as ``Y``, increasing up; hence it is plotted the way the
        array would be printed, except that the ``Y`` axis is reversed. That
        is, ``C`` is taken as ``C`` (y, x).

        Similarly for :func:`meshgrid`::

            x = np.arange(5)
            y = np.arange(3)
            X, Y = np.meshgrid(x, y)

        is equivalent to::

            X = array([[0, 1, 2, 3, 4],
                       [0, 1, 2, 3, 4],
                       [0, 1, 2, 3, 4]])

            Y = array([[0, 0, 0, 0, 0],
                       [1, 1, 1, 1, 1],
                       [2, 2, 2, 2, 2]])

        so if you have::

            C = rand(len(x), len(y))

        then you need to transpose C::

            pcolor(X, Y, C.T)

        or::

            pcolor(C.T)

        MATLAB :func:`pcolor` always discards the last row and column of ``C``,
        but Matplotlib displays the last row and column if ``X`` and ``Y`` are
        not specified, or if ``X`` and ``Y`` have one more row and column than
        ``C``.

        .. 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.

    pcolormesh(*args, **kwargs)
        Plot a quadrilateral mesh.

        Call signatures::

          pcolormesh(C)
          pcolormesh(X, Y, C)
          pcolormesh(C, **kwargs)

        Create a pseudocolor plot of a 2-D array.

        pcolormesh is similar to :func:`~matplotlib.pyplot.pcolor`,
        but uses a different mechanism and returns a different
        object; pcolor returns a
        :class:`~matplotlib.collections.PolyCollection` but pcolormesh
        returns a
        :class:`~matplotlib.collections.QuadMesh`.  It is much faster,
        so it is almost always preferred for large arrays.

        *C* may be a masked array, but *X* and *Y* may not.  Masked
        array support is implemented via *cmap* and *norm*; in
        contrast, :func:`~matplotlib.pyplot.pcolor` simply does not
        draw quadrilaterals with masked colors or vertices.

        Other Parameters
        ----------------
        cmap : Colormap, optional
            A :class:`matplotlib.colors.Colormap` instance. If ``None``, use
            rc settings.

        norm : Normalize, optional
            A :class:`matplotlib.colors.Normalize` instance is used to
            scale luminance data to 0,1. If ``None``, defaults to
            :func:`normalize`.

        vmin, vmax : scalar, optional
            *vmin* and *vmax* are used in conjunction with *norm* to
            normalize luminance data. If either is ``None``, it is autoscaled
            to the respective min or max of the color array *C*.
            If not ``None``, *vmin* or *vmax* passed in here override any
            pre-existing values supplied in the *norm* instance.

        shading : [ 'flat' | 'gouraud' ], optional
            'flat' indicates a solid color for each quad. When
            'gouraud', each quad will be Gouraud shaded. When gouraud
            shading, *edgecolors* is ignored.

        edgecolors : string, color, color sequence, optional
            - If ``None``, the rc setting is used by default.
            - If ``'None'``, edges will not be visible.
            - If ``'face'``, edges will have the same color as the faces.

            An mpl color or sequence of colors will also set the edge color.

        alpha : scalar, optional
            Alpha blending value. Must be between 0 and 1.

        Returns
        -------
        matplotlib.collections.QuadMesh

        See Also
        --------
        matplotlib.pyplot.pcolor :
            For an explanation of the grid orientation
            (:ref:`Grid Orientation <axes-pcolor-grid-orientation>`)
            and the expansion of 1-D *X* and/or *Y* to 2-D arrays.

        Notes
        -----
        kwargs can be used to control the
        :class:`matplotlib.collections.QuadMesh` 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

        .. 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(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, hold=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(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, hold=None, 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'.

    pink()
        Set the colormap to "pink".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    plasma()
        Set the colormap to "plasma".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    plot(*args, **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(x, y, fmt='o', tz=None, xdate=True, ydate=False, hold=None, 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'.

    plotfile(fname, cols=(0,), plotfuncs=None, comments='#', skiprows=0, checkrows=5, delimiter=',', names=None, subplots=True, newfig=True, **kwargs)
        Plot the data in a file.

        *cols* is a sequence of column identifiers to plot.  An identifier
        is either an int or a string.  If it is an int, it indicates the
        column number.  If it is a string, it indicates the column header.
        matplotlib will make column headers lower case, replace spaces with
        underscores, and remove all illegal characters; so ``'Adj Close*'``
        will have name ``'adj_close'``.

        - If len(*cols*) == 1, only that column will be plotted on the *y* axis.

        - If len(*cols*) > 1, the first element will be an identifier for
          data for the *x* axis and the remaining elements will be the
          column indexes for multiple subplots if *subplots* is *True*
          (the default), or for lines in a single subplot if *subplots*
          is *False*.

        *plotfuncs*, if not *None*, is a dictionary mapping identifier to
        an :class:`~matplotlib.axes.Axes` plotting function as a string.
        Default is 'plot', other choices are 'semilogy', 'fill', 'bar',
        etc.  You must use the same type of identifier in the *cols*
        vector as you use in the *plotfuncs* dictionary, e.g., integer
        column numbers in both or column names in both. If *subplots*
        is *False*, then including any function such as 'semilogy'
        that changes the axis scaling will set the scaling for all
        columns.

        *comments*, *skiprows*, *checkrows*, *delimiter*, and *names*
        are all passed on to :func:`matplotlib.pylab.csv2rec` to
        load the data into a record array.

        If *newfig* is *True*, the plot always will be made in a new figure;
        if *False*, it will be made in the current figure if one exists,
        else in a new figure.

        kwargs are passed on to plotting functions.

        Example usage::

          # plot the 2nd and 4th column against the 1st in two subplots
          plotfile(fname, (0,1,3))

          # plot using column names; specify an alternate plot type for volume
          plotfile(fname, ('date', 'volume', 'adj_close'),
                                        plotfuncs={'volume': 'semilogy'})

        Note: plotfile is intended as a convenience for quickly plotting
        data from flat files; it is not intended as an alternative
        interface to general plotting with pyplot or matplotlib.

    plotting()
        ============================ ======================================================================================================================================================================================
        Function                     Description
        ============================ ======================================================================================================================================================================================
        `acorr`                      Plot the autocorrelation of *x*.
        `angle_spectrum`             Plot the angle spectrum.
        `annotate`                   Annotate the point ``xy`` with text ``s``.
        `arrow`                      Add an arrow to the axes.
        `autoscale`                  Autoscale the axis view to the data (toggle).
        `axes`                       Add an axes to the current figure and make it the current axes.
        `axhline`                    Add a horizontal line across the axis.
        `axhspan`                    Add a horizontal span (rectangle) across the axis.
        `axis`                       Convenience method to get or set axis properties.
        `axvline`                    Add a vertical line across the axes.
        `axvspan`                    Add a vertical span (rectangle) across the axes.
        `bar`                        Make a bar plot.
        `barbs`                      Plot a 2-D field of barbs.
        `barh`                       Make a horizontal bar plot.
        `box`                        Turn the axes box on or off.
        `boxplot`                    Make a box and whisker plot.
        `broken_barh`                Plot a horizontal sequence of rectangles.
        `cla`                        Clear the current axes.
        `clabel`                     Label a contour plot.
        `clf`                        Clear the current figure.
        `clim`                       Set the color limits of the current image.
        `close`                      Close a figure window.
        `cohere`                     Plot the coherence between *x* and *y*.
        `colorbar`                   Add a colorbar to a plot.
        `contour`                    Plot contours.
        `contourf`                   Plot contours.
        `csd`                        Plot the cross-spectral density.
        `delaxes`                    Remove the given `Axes` *ax* from the current figure.
        `draw`                       Redraw the current figure.
        `errorbar`                   Plot y versus x as lines and/or markers with attached errorbars.
        `eventplot`                  Plot identical parallel lines at the given positions.
        `figimage`                   Adds a non-resampled image to the figure.
        `figlegend`                  Place a legend in the figure.
        `fignum_exists`
        `figtext`                    Add text to figure.
        `figure`                     Creates a new figure.
        `fill`                       Plot filled polygons.
        `fill_between`               Fill the area between two horizontal curves.
        `fill_betweenx`              Fill the area between two vertical curves.
        `findobj`                    Find artist objects.
        `gca`                        Get the current :class:`~matplotlib.axes.Axes` instance on the     current figure matching the given keyword args, or create one.
        `gcf`                        Get a reference to the current figure.
        `gci`                        Get the current colorable artist.
        `get_figlabels`              Return a list of existing figure labels.
        `get_fignums`                Return a list of existing figure numbers.
        `grid`                       Turn the axes grids on or off.
        `hexbin`                     Make a hexagonal binning plot.
        `hist`                       Plot a histogram.
        `hist2d`                     Make a 2D histogram plot.
        `hlines`                     Plot horizontal lines at each *y* from *xmin* to *xmax*.
        `hold`                       ..
        `imread`                     Read an image from a file into an array.
        `imsave`                     Save an array as in image file.
        `imshow`                     Display an image on the axes.
        `install_repl_displayhook`   Install a repl display hook so that any stale figure are automatically     redrawn when control is returned to the repl.
        `ioff`                       Turn interactive mode off.
        `ion`                        Turn interactive mode on.
        `ishold`                     ..
        `isinteractive`              Return status of interactive mode.
        `legend`                     Places a legend on the axes.
        `locator_params`             Control behavior of tick locators.
        `loglog`                     Make a plot with log scaling on both the x and y axis.
        `magnitude_spectrum`         Plot the magnitude spectrum.
        `margins`                    Set or retrieve autoscaling margins.
        `matshow`                    Display an array as a matrix in a new figure window.
        `minorticks_off`             Remove minor ticks from the current plot.
        `minorticks_on`              Display minor ticks on the current plot.
        `over`                       ..
        `pause`                      Pause for *interval* seconds.
        `pcolor`                     Create a pseudocolor plot of a 2-D array.
        `pcolormesh`                 Plot a quadrilateral mesh.
        `phase_spectrum`             Plot the phase spectrum.
        `pie`                        Plot a pie chart.
        `plot`                       Plot y versus x as lines and/or markers.
        `plot_date`                  Plot data that contains dates.
        `plotfile`                   Plot the data in a file.
        `polar`                      Make a polar plot.
        `psd`                        Plot the power spectral density.
        `quiver`                     Plot a 2-D field of arrows.
        `quiverkey`                  Add a key to a quiver plot.
        `rc`                         Set the current rc params.
        `rc_context`                 Return a context manager for managing rc settings.
        `rcdefaults`                 Restore the rc params from Matplotlib's internal defaults.
        `rgrids`                     Get or set the radial gridlines on a polar plot.
        `savefig`                    Save the current figure.
        `sca`                        Set the current Axes instance to *ax*.
        `scatter`                    A scatter plot of *y* vs *x* with varying marker size and/or color.
        `sci`                        Set the current image.
        `semilogx`                   Make a plot with log scaling on the x axis.
        `semilogy`                   Make a plot with log scaling on the y axis.
        `set_cmap`                   Set the default colormap.
        `setp`                       Set a property on an artist object.
        `show`                       Display a figure.
        `specgram`                   Plot a spectrogram.
        `spectral`                   Set the colormap to "spectral".
        `spy`                        Plot the sparsity pattern on a 2-D array.
        `stackplot`                  Draws a stacked area plot.
        `stem`                       Create a stem plot.
        `step`                       Make a step plot.
        `streamplot`                 Draws streamlines of a vector flow.
        `subplot`                    Return a subplot axes at the given grid position.
        `subplot2grid`               Create an axis at specific location inside a regular grid.
        `subplot_tool`               Launch a subplot tool window for a figure.
        `subplots`                   Create a figure and a set of subplots      This utility wrapper makes it convenient to create common layouts of     subplots, including the enclosing figure object, in a single call.
        `subplots_adjust`            Tune the subplot layout.
        `suptitle`                   Add a centered title to the figure.
        `switch_backend`             Switch the default backend.
        `table`                      Add a table to the current axes.
        `text`                       Add text to the axes.
        `thetagrids`                 Get or set the theta locations of the gridlines in a polar plot.
        `tick_params`                Change the appearance of ticks, tick labels, and gridlines.
        `ticklabel_format`           Change the `~matplotlib.ticker.ScalarFormatter` used by default for linear axes.
        `tight_layout`               Automatically adjust subplot parameters to give specified padding.
        `title`                      Set a title of the current axes.
        `tricontour`                 Draw contours on an unstructured triangular grid.
        `tricontourf`                Draw contours on an unstructured triangular grid.
        `tripcolor`                  Create a pseudocolor plot of an unstructured triangular grid.
        `triplot`                    Draw a unstructured triangular grid as lines and/or markers.
        `twinx`                      Make a second axes that shares the *x*-axis.
        `twiny`                      Make a second axes that shares the *y*-axis.
        `uninstall_repl_displayhook` Uninstalls the matplotlib display hook.
        `violinplot`                 Make a violin plot.
        `vlines`                     Plot vertical lines.
        `xcorr`                      Plot the cross correlation between *x* and *y*.
        `xkcd`                       Turns on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.
        `xlabel`                     Set the x-axis label of the current axes.
        `xlim`                       Get or set the x limits of the current axes.
        `xscale`                     Set the scaling of the x-axis.
        `xticks`                     Get or set the current tick locations and labels of the x-axis.
        `ylabel`                     Set the y-axis label of the current axes.
        `ylim`                       Get or set the y-limits of the current axes.
        `yscale`                     Set the scaling of the y-axis.
        `yticks`                     Get or set the current tick locations and labels of the y-axis.
        ============================ ======================================================================================================================================================================================

    polar(*args, **kwargs)
        Make a polar plot.

        call signature::

          polar(theta, r, **kwargs)

        Multiple *theta*, *r* arguments are supported, with format
        strings, as in :func:`~matplotlib.pyplot.plot`.

    prism()
        Set the colormap to "prism".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    psd(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, hold=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'.

    quiver(*args, **kw)
        Plot a 2-D field of arrows.

        Call signatures::

          quiver(U, V, **kw)
          quiver(U, V, C, **kw)
          quiver(X, Y, U, V, **kw)
          quiver(X, Y, U, V, C, **kw)

        *U* and *V* are the arrow data, *X* and *Y* set the location of the
        arrows, and *C* sets the color of the arrows. These arguments may be 1-D or
        2-D arrays or sequences.

        If *X* and *Y* are absent, they will be generated as a uniform grid.
        If *U* and *V* are 2-D arrays and *X* and *Y* are 1-D, and if ``len(X)`` and
        ``len(Y)`` match the column and row dimensions of *U*, then *X* and *Y* will be
        expanded with :func:`numpy.meshgrid`.

        The default settings auto-scales the length of the arrows to a reasonable size.
        To change this behavior see the *scale* and *scale_units* kwargs.

        The defaults give a slightly swept-back arrow; to make the head a
        triangle, make *headaxislength* the same as *headlength*. To make the
        arrow more pointed, reduce *headwidth* or increase *headlength* and
        *headaxislength*. To make the head smaller relative to the shaft,
        scale down all the head parameters. You will probably do best to leave
        minshaft alone.

        *linewidths* and *edgecolors* can be used to customize the arrow
        outlines.

        Parameters
        ----------
        X : 1D or 2D array, sequence, optional
            The x coordinates of the arrow locations
        Y : 1D or 2D array, sequence, optional
            The y coordinates of the arrow locations
        U : 1D or 2D array or masked array, sequence
            The x components of the arrow vectors
        V : 1D or 2D array or masked array, sequence
            The y components of the arrow vectors
        C : 1D or 2D array, sequence, optional
            The arrow colors
        units : [ 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y' | 'xy' ]
            The arrow dimensions (except for *length*) are measured in multiples of
            this unit.

            'width' or 'height': the width or height of the axis

            'dots' or 'inches': pixels or inches, based on the figure dpi

            'x', 'y', or 'xy': respectively *X*, *Y*, or :math:`\sqrt{X^2 + Y^2}`
            in data units

            The arrows scale differently depending on the units.  For
            'x' or 'y', the arrows get larger as one zooms in; for other
            units, the arrow size is independent of the zoom state.  For
            'width or 'height', the arrow size increases with the width and
            height of the axes, respectively, when the window is resized;
            for 'dots' or 'inches', resizing does not change the arrows.
        angles : [ 'uv' | 'xy' ], array, optional
            Method for determining the angle of the arrows. Default is 'uv'.

            'uv': the arrow axis aspect ratio is 1 so that
            if *U*==*V* the orientation of the arrow on the plot is 45 degrees
            counter-clockwise from the horizontal axis (positive to the right).

            'xy': arrows point from (x,y) to (x+u, y+v).
            Use this for plotting a gradient field, for example.

            Alternatively, arbitrary angles may be specified as an array
            of values in degrees, counter-clockwise from the horizontal axis.

            Note: inverting a data axis will correspondingly invert the
            arrows only with ``angles='xy'``.
        scale : None, float, optional
            Number of data units per arrow length unit, e.g., m/s per plot width; a
            smaller scale parameter makes the arrow longer. Default is *None*.

            If *None*, a simple autoscaling algorithm is used, based on the average
            vector length and the number of vectors. The arrow length unit is given by
            the *scale_units* parameter
        scale_units : [ 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y' | 'xy' ], None, optional
            If the *scale* kwarg is *None*, the arrow length unit. Default is *None*.

            e.g. *scale_units* is 'inches', *scale* is 2.0, and
            ``(u,v) = (1,0)``, then the vector will be 0.5 inches long.

            If *scale_units* is 'width'/'height', then the vector will be half the
            width/height of the axes.

            If *scale_units* is 'x' then the vector will be 0.5 x-axis
            units. To plot vectors in the x-y plane, with u and v having
            the same units as x and y, use
            ``angles='xy', scale_units='xy', scale=1``.
        width : scalar, optional
            Shaft width in arrow units; default depends on choice of units,
            above, and number of vectors; a typical starting value is about
            0.005 times the width of the plot.
        headwidth : scalar, optional
            Head width as multiple of shaft width, default is 3
        headlength : scalar, optional
            Head length as multiple of shaft width, default is 5
        headaxislength : scalar, optional
            Head length at shaft intersection, default is 4.5
        minshaft : scalar, optional
            Length below which arrow scales, in units of head length. Do not
            set this to less than 1, or small arrows will look terrible!
            Default is 1
        minlength : scalar, optional
            Minimum length as a multiple of shaft width; if an arrow length
            is less than this, plot a dot (hexagon) of this diameter instead.
            Default is 1.
        pivot : [ 'tail' | 'mid' | 'middle' | 'tip' ], optional
            The part of the arrow that is at the grid point; the arrow rotates
            about this point, hence the name *pivot*.
        color : [ color | color sequence ], optional
            This is a synonym for the
            :class:`~matplotlib.collections.PolyCollection` facecolor kwarg.
            If *C* has been set, *color* has no effect.

        Notes
        -----
        Additional :class:`~matplotlib.collections.PolyCollection`
        keyword arguments:

          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

        See Also
        --------
        quiverkey : Add a key to a quiver plot

    quiverkey(*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.

    rc(*args, **kwargs)
        Set the current rc params.  Group is the grouping for the rc, e.g.,
        for ``lines.linewidth`` the group is ``lines``, for
        ``axes.facecolor``, the group is ``axes``, and so on.  Group may
        also be a list or tuple of group names, e.g., (*xtick*, *ytick*).
        *kwargs* is a dictionary attribute name/value pairs, e.g.,::

          rc('lines', linewidth=2, color='r')

        sets the current rc params and is equivalent to::

          rcParams['lines.linewidth'] = 2
          rcParams['lines.color'] = 'r'

        The following aliases are available to save typing for interactive
        users:

        =====   =================
        Alias   Property
        =====   =================
        'lw'    'linewidth'
        'ls'    'linestyle'
        'c'     'color'
        'fc'    'facecolor'
        'ec'    'edgecolor'
        'mew'   'markeredgewidth'
        'aa'    'antialiased'
        =====   =================

        Thus you could abbreviate the above rc command as::

              rc('lines', lw=2, c='r')

        Note you can use python's kwargs dictionary facility to store
        dictionaries of default parameters.  e.g., you can customize the
        font rc as follows::

          font = {'family' : 'monospace',
                  'weight' : 'bold',
                  'size'   : 'larger'}

          rc('font', **font)  # pass in the font dict as kwargs

        This enables you to easily switch between several configurations.  Use
        ``matplotlib.style.use('default')`` or :func:`~matplotlib.rcdefaults` to
        restore the default rc params after changes.

    rc_context(rc=None, fname=None)
        Return a context manager for managing rc settings.

        This allows one to do::

            with mpl.rc_context(fname='screen.rc'):
                plt.plot(x, a)
                with mpl.rc_context(fname='print.rc'):
                    plt.plot(x, b)
                plt.plot(x, c)

        The 'a' vs 'x' and 'c' vs 'x' plots would have settings from
        'screen.rc', while the 'b' vs 'x' plot would have settings from
        'print.rc'.

        A dictionary can also be passed to the context manager::

            with mpl.rc_context(rc={'text.usetex': True}, fname='screen.rc'):
                plt.plot(x, a)

        The 'rc' dictionary takes precedence over the settings loaded from
        'fname'.  Passing a dictionary only is also valid. For example a
        common usage is::

            with mpl.rc_context(rc={'interactive': False}):
                fig, ax = plt.subplots()
                ax.plot(range(3), range(3))
                fig.savefig('A.png', format='png')
                plt.close(fig)

    rcdefaults()
        Restore the rc params from Matplotlib's internal defaults.

        See Also
        --------
        rc_file_defaults :
            Restore the rc params from the rc file originally loaded by Matplotlib.
        matplotlib.style.use :
            Use a specific style file.  Call ``style.use('default')`` to restore
            the default style.

    rgrids(*args, **kwargs)
        Get or set the radial gridlines on a polar plot.

        call signatures::

          lines, labels = rgrids()
          lines, labels = rgrids(radii, labels=None, angle=22.5, **kwargs)

        When called with no arguments, :func:`rgrid` simply returns the
        tuple (*lines*, *labels*), where *lines* is an array of radial
        gridlines (:class:`~matplotlib.lines.Line2D` instances) and
        *labels* is an array of tick labels
        (:class:`~matplotlib.text.Text` instances). When called with
        arguments, the labels will appear at the specified radial
        distances and angles.

        *labels*, if not *None*, is a len(*radii*) list of strings of the
        labels to use at each angle.

        If *labels* is None, the rformatter will be used

        Examples::

          # set the locations of the radial gridlines and labels
          lines, labels = rgrids( (0.25, 0.5, 1.0) )

          # set the locations and labels of the radial gridlines and labels
          lines, labels = rgrids( (0.25, 0.5, 1.0), ('Tom', 'Dick', 'Harry' )

    savefig(*args, **kwargs)
        Save the current figure.

        Call signature::

          savefig(fname, dpi=None, facecolor='w', edgecolor='w',
                  orientation='portrait', papertype=None, format=None,
                  transparent=False, bbox_inches=None, pad_inches=0.1,
                  frameon=None)

        The output formats available depend on the backend being used.

        Parameters
        ----------

        fname : str or file-like object
            A string containing a path to a filename, or a Python
            file-like object, or possibly some backend-dependent object
            such as :class:`~matplotlib.backends.backend_pdf.PdfPages`.

            If *format* is *None* and *fname* is a string, the output
            format is deduced from the extension of the filename. If
            the filename has no extension, the value of the rc parameter
            ``savefig.format`` is used.

            If *fname* is not a string, remember to specify *format* to
            ensure that the correct backend is used.

        Other Parameters
        ----------------

        dpi : [ *None* | scalar > 0 | 'figure']
            The resolution in dots per inch.  If *None* it will default to
            the value ``savefig.dpi`` in the matplotlibrc file. If 'figure'
            it will set the dpi to be the value of the figure.

        facecolor : color spec or None, optional
            the facecolor of the figure; if None, defaults to savefig.facecolor

        edgecolor : color spec or None, optional
            the edgecolor of the figure; if None, defaults to savefig.edgecolor

        orientation : {'landscape', 'portrait'}
            not supported on all backends; currently only on postscript output

        papertype : str
            One of 'letter', 'legal', 'executive', 'ledger', 'a0' through
            'a10', 'b0' through 'b10'. Only supported for postscript
            output.

        format : str
            One of the file extensions supported by the active
            backend.  Most backends support png, pdf, ps, eps and svg.

        transparent : bool
            If *True*, the axes patches will all be transparent; the
            figure patch will also be transparent unless facecolor
            and/or edgecolor are specified via kwargs.
            This is useful, for example, for displaying
            a plot on top of a colored background on a web page.  The
            transparency of these patches will be restored to their
            original values upon exit of this function.

        frameon : bool
            If *True*, the figure patch will be colored, if *False*, the
            figure background will be transparent.  If not provided, the
            rcParam 'savefig.frameon' will be used.

        bbox_inches : str or `~matplotlib.transforms.Bbox`, optional
            Bbox in inches. Only the given portion of the figure is
            saved. If 'tight', try to figure out the tight bbox of
            the figure. If None, use savefig.bbox

        pad_inches : scalar, optional
            Amount of padding around the figure when bbox_inches is
            'tight'. If None, use savefig.pad_inches

        bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional
            A list of extra artists that will be considered when the
            tight bbox is calculated.

    sca(ax)
        Set the current Axes instance to *ax*.

        The current Figure is updated to the parent of *ax*.

    scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, hold=None, data=None, **kwargs)
        A scatter plot of *y* vs *x* with varying marker size and/or color.

        Parameters
        ----------
        x, y : array_like, shape (n, )
            The data positions.

        s : scalar or array_like, shape (n, ), optional
            The marker size in points**2.
            Default is ``rcParams['lines.markersize'] ** 2``.

        c : color, sequence, or sequence of color, optional, default: 'b'
            The marker color. Possible values:

            - A single color format string.
            - A sequence of color specifications of length n.
            - A sequence of n numbers to be mapped to colors using *cmap* and
              *norm*.
            - A 2-D array in which the rows are RGB or RGBA.

            Note that *c* should not be a single numeric RGB or RGBA sequence
            because that is indistinguishable from an array of values to be
            colormapped. If you want to specify the same RGB or RGBA value for
            all points, use a 2-D array with a single row.

        marker : `~matplotlib.markers.MarkerStyle`, optional, default: 'o'
            The marker style. *marker* can be either an instance of the class
            or the text shorthand for a particular marker.
            See `~matplotlib.markers` for more information marker styles.

        cmap : `~matplotlib.colors.Colormap`, optional, default: None
            A `.Colormap` instance or registered colormap name. *cmap* is only
            used if *c* is an array of floats. If ``None``, defaults to rc
            ``image.cmap``.

        norm : `~matplotlib.colors.Normalize`, optional, default: None
            A `.Normalize` instance is used to scale luminance data to 0, 1.
            *norm* is only used if *c* is an array of floats. If *None*, use
            the default `.colors.Normalize`.

        vmin, vmax : scalar, optional, default: None
            *vmin* and *vmax* are used in conjunction with *norm* to normalize
            luminance data. If None, the respective min and max of the color
            array is used. *vmin* and *vmax* are ignored if you pass a *norm*
            instance.

        alpha : scalar, optional, default: None
            The alpha blending value, between 0 (transparent) and 1 (opaque).

        linewidths : scalar or array_like, optional, default: None
            The linewidth of the marker edges. Note: The default *edgecolors*
            is 'face'. You may want to change this as well.
            If *None*, defaults to rcParams ``lines.linewidth``.

        verts : sequence of (x, y), optional
            If *marker* is *None*, these vertices will be used to construct
            the marker.  The center of the marker is located at (0, 0) in
            normalized units.  The overall marker is rescaled by *s*.

        edgecolors : color or sequence of color, optional, default: 'face'
            The edge color of the marker. Possible values:

            - 'face': The edge color will always be the same as the face color.
            - 'none': No patch boundary will be drawn.
            - A matplotib color.

            For non-filled markers, the *edgecolors* kwarg is ignored and
            forced to 'face' internally.

        Returns
        -------
        paths : `~matplotlib.collections.PathCollection`

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.collections.Collection` properties

        See Also
        --------
        plot : To plot scatter plots when markers are identical in size and
            color.

        Notes
        -----

        * The `.plot` function will be faster for scatterplots where markers
          don't vary in size or color.

        * Any or all of *x*, *y*, *s*, and *c* may be masked arrays, in which
          case all masks will be combined and only unmasked points will be
          plotted.

        * Fundamentally, scatter works with 1-D arrays; *x*, *y*, *s*, and *c*
          may be input as 2-D arrays, but within scatter they will be
          flattened. The exception is *c*, which will be flattened only if its
          size matches the size of *x* and *y*.

        .. 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: 'c', 'color', 'edgecolors', 'facecolor', 'facecolors', 'linewidths', 's', 'x', 'y'.

    sci(im)
        Set the current image.  This image will be the target of colormap
        commands like :func:`~matplotlib.pyplot.jet`,
        :func:`~matplotlib.pyplot.hot` or
        :func:`~matplotlib.pyplot.clim`).  The current image is an
        attribute of the current axes.

    semilogx(*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(*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_cmap(cmap)
        Set the default colormap.  Applies to the current image if any.
        See help(colormaps) for more information.

        *cmap* must be a :class:`~matplotlib.colors.Colormap` instance, or
        the name of a registered colormap.

        See :func:`matplotlib.cm.register_cmap` and
        :func:`matplotlib.cm.get_cmap`.

    setp(*args, **kwargs)
        Set a property on an artist object.

        matplotlib supports the use of :func:`setp` ("set property") and
        :func:`getp` to set and get object properties, as well as to do
        introspection on the object.  For example, to set the linestyle of a
        line to be dashed, you can do::

          >>> line, = plot([1,2,3])
          >>> setp(line, linestyle='--')

        If you want to know the valid types of arguments, you can provide
        the name of the property you want to set without a value::

          >>> setp(line, 'linestyle')
              linestyle: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]

        If you want to see all the properties that can be set, and their
        possible values, you can do::

          >>> setp(line)
              ... long output listing omitted

        You may specify another output file to `setp` if `sys.stdout` is not
        acceptable for some reason using the `file` keyword-only argument::

          >>> with fopen('output.log') as f:
          >>>     setp(line, file=f)

        :func:`setp` operates on a single instance or a iterable of
        instances. If you are in query mode introspecting the possible
        values, only the first instance in the sequence is used. When
        actually setting values, all the instances will be set.  e.g.,
        suppose you have a list of two lines, the following will make both
        lines thicker and red::

          >>> x = arange(0,1.0,0.01)
          >>> y1 = sin(2*pi*x)
          >>> y2 = sin(4*pi*x)
          >>> lines = plot(x, y1, x, y2)
          >>> setp(lines, linewidth=2, color='r')

        :func:`setp` works with the MATLAB style string/value pairs or
        with python kwargs.  For example, the following are equivalent::

          >>> setp(lines, 'linewidth', 2, 'color', 'r')  # MATLAB style
          >>> setp(lines, linewidth=2, color='r')        # python style

    show(*args, **kw)
        Display a figure.
        When running in ipython with its pylab mode, display all
        figures and return to the ipython prompt.

        In non-interactive mode, display all figures and block until
        the figures have been closed; in interactive mode it has no
        effect unless figures were created prior to a change from
        non-interactive to interactive mode (not recommended).  In
        that case it displays the figures but does not block.

        A single experimental keyword argument, *block*, may be
        set to True or False to override the blocking behavior
        described above.

    specgram(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, cmap=None, xextent=None, pad_to=None, sides=None, scale_by_freq=None, mode=None, scale=None, vmin=None, vmax=None, hold=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'.

    spectral()
        Set the colormap to "spectral".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    spring()
        Set the colormap to "spring".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    spy(Z, precision=0, marker=None, markersize=None, aspect='equal', **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(x, *args, **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(*args, **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(x, y, *args, **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'.

    streamplot(x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=None, start_points=None, maxlength=4.0, integration_direction='both', hold=None, data=None)
        Draws streamlines of a vector flow.

        *x*, *y* : 1d arrays
            an *evenly spaced* grid.
        *u*, *v* : 2d arrays
            x and y-velocities. Number of rows should match length of y, and
            the number of columns should match x.
        *density* : float or 2-tuple
            Controls the closeness of streamlines. When `density = 1`, the domain
            is divided into a 30x30 grid---*density* linearly scales this grid.
            Each cell in the grid can have, at most, one traversing streamline.
            For different densities in each direction, use [density_x, density_y].
        *linewidth* : numeric or 2d array
            vary linewidth when given a 2d array with the same shape as velocities.
        *color* : matplotlib color code, or 2d array
            Streamline color. When given an array with the same shape as
            velocities, *color* values are converted to colors using *cmap*.
        *cmap* : :class:`~matplotlib.colors.Colormap`
            Colormap used to plot streamlines and arrows. Only necessary when using
            an array input for *color*.
        *norm* : :class:`~matplotlib.colors.Normalize`
            Normalize object used to scale luminance data to 0, 1. If None, stretch
            (min, max) to (0, 1). Only necessary when *color* is an array.
        *arrowsize* : float
            Factor scale arrow size.
        *arrowstyle* : str
            Arrow style specification.
            See :class:`~matplotlib.patches.FancyArrowPatch`.
        *minlength* : float
            Minimum length of streamline in axes coordinates.
        *start_points*: Nx2 array
            Coordinates of starting points for the streamlines.
            In data coordinates, the same as the ``x`` and ``y`` arrays.
        *zorder* : int
            any number
        *maxlength* : float
            Maximum length of streamline in axes coordinates.
        *integration_direction* : ['forward', 'backward', 'both']
            Integrate the streamline in forward, backward or both directions.

        Returns:

            *stream_container* : StreamplotSet
                Container object with attributes

                    - lines: `matplotlib.collections.LineCollection` of streamlines

                    - arrows: collection of `matplotlib.patches.FancyArrowPatch`
                      objects representing arrows half-way along stream
                      lines.

                This container will probably change in the future to allow changes
                to the colormap, alpha, etc. for both lines and arrows, but these
                changes should be backward compatible.

    subplot(*args, **kwargs)
        Return a subplot axes at the given grid position.

        Call signature::

           subplot(nrows, ncols, index, **kwargs)

        In the current figure, create and return an `.Axes`, at position *index*
        of a (virtual) grid of *nrows* by *ncols* axes.  Indexes go from 1 to
        ``nrows * ncols``, incrementing in row-major order.

        If *nrows*, *ncols* and *index* are all less than 10, they can also be
        given as a single, concatenated, three-digit number.

        For example, ``subplot(2, 3, 3)`` and ``subplot(233)`` both create an
        `.Axes` at the top right corner of the current figure, occupying half of
        the figure height and a third of the figure width.

        .. note::

           Creating a subplot will delete any pre-existing subplot that overlaps
           with it beyond sharing a boundary::

              import matplotlib.pyplot as plt
              # plot a line, implicitly creating a subplot(111)
              plt.plot([1,2,3])
              # now create a subplot which represents the top plot of a grid
              # with 2 rows and 1 column. Since this subplot will overlap the
              # first, the plot (and its axes) previously created, will be removed
              plt.subplot(211)
              plt.plot(range(12))
              plt.subplot(212, facecolor='y') # creates 2nd subplot with yellow background

           If you do not want this behavior, use the
           :meth:`~matplotlib.figure.Figure.add_subplot` method or the
           :func:`~matplotlib.pyplot.axes` function instead.

        Keyword arguments:

          *facecolor*:
            The background color of the subplot, which can be any valid
            color specifier.  See :mod:`matplotlib.colors` for more
            information.

          *polar*:
            A boolean flag indicating whether the subplot plot should be
            a polar projection.  Defaults to *False*.

          *projection*:
            A string giving the name of a custom projection to be used
            for the subplot. This projection must have been previously
            registered. See :mod:`matplotlib.projections`.

        .. seealso::

            :func:`~matplotlib.pyplot.axes`
                For additional information on :func:`axes` and
                :func:`subplot` keyword arguments.

            :file:`gallery/pie_and_polar_charts/polar_scatter.py`
                For an example

        **Example:**

        .. plot:: gallery/subplots_axes_and_figures/subplot.py

    subplot2grid(shape, loc, rowspan=1, colspan=1, fig=None, **kwargs)
        Create an axis at specific location inside a regular grid.

        Parameters
        ----------
        shape : sequence of 2 ints
            Shape of grid in which to place axis.
            First entry is number of rows, second entry is number of columns.

        loc : sequence of 2 ints
            Location to place axis within grid.
            First entry is row number, second entry is column number.

        rowspan : int
            Number of rows for the axis to span to the right.

        colspan : int
            Number of columns for the axis to span downwards.

        fig : `Figure`, optional
            Figure to place axis in. Defaults to current figure.

        **kwargs
            Additional keyword arguments are handed to `add_subplot`.

        Notes
        -----
        The following call ::

            subplot2grid(shape, loc, rowspan=1, colspan=1)

        is identical to ::

            gridspec=GridSpec(shape[0], shape[1])
            subplotspec=gridspec.new_subplotspec(loc, rowspan, colspan)
            subplot(subplotspec)

    subplot_tool(targetfig=None)
        Launch a subplot tool window for a figure.

        A :class:`matplotlib.widgets.SubplotTool` instance is returned.

    subplots(nrows=1, ncols=1, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None, **fig_kw)
        Create a figure and a set of subplots

        This utility wrapper makes it convenient to create common layouts of
        subplots, including the enclosing figure object, in a single call.

        Parameters
        ----------
        nrows, ncols : int, optional, default: 1
            Number of rows/columns of the subplot grid.

        sharex, sharey : bool or {'none', 'all', 'row', 'col'}, default: False
            Controls sharing of properties among x (`sharex`) or y (`sharey`)
            axes:

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

            When subplots have a shared x-axis along a column, only the x tick
            labels of the bottom subplot are visible.  Similarly, when subplots
            have a shared y-axis along a row, only the y tick labels of the first
            column subplot are visible.

        squeeze : bool, optional, default: True
            - If True, extra dimensions are squeezed out from the returned Axes
              object:

                - if only one subplot is constructed (nrows=ncols=1), the
                  resulting single Axes object is returned as a scalar.
                - for Nx1 or 1xN subplots, the returned object is a 1D numpy
                  object array of Axes objects are returned as numpy 1D arrays.
                - for NxM, subplots with N>1 and M>1 are returned as a 2D arrays.

            - If False, no squeezing at all is done: the returned Axes object is
              always a 2D array containing Axes instances, even if it ends up
              being 1x1.

        subplot_kw : dict, optional
            Dict with keywords passed to the
            :meth:`~matplotlib.figure.Figure.add_subplot` call used to create each
            subplot.

        gridspec_kw : dict, optional
            Dict with keywords passed to the
            :class:`~matplotlib.gridspec.GridSpec` constructor used to create the
            grid the subplots are placed on.

        **fig_kw :
            All additional keyword arguments are passed to the :func:`figure` call.

        Returns
        -------
        fig : :class:`matplotlib.figure.Figure` object

        ax : Axes object or array of Axes objects.

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

        Examples
        --------
        First create some toy data:

        >>> x = np.linspace(0, 2*np.pi, 400)
        >>> y = np.sin(x**2)

        Creates just a figure and only one subplot

        >>> fig, ax = plt.subplots()
        >>> ax.plot(x, y)
        >>> ax.set_title('Simple plot')

        Creates two subplots and unpacks the output array immediately

        >>> f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
        >>> ax1.plot(x, y)
        >>> ax1.set_title('Sharing Y axis')
        >>> ax2.scatter(x, y)

        Creates four polar axes, and accesses them through the returned array

        >>> fig, axes = plt.subplots(2, 2, subplot_kw=dict(polar=True))
        >>> axes[0, 0].plot(x, y)
        >>> axes[1, 1].scatter(x, y)

        Share a X axis with each column of subplots

        >>> plt.subplots(2, 2, sharex='col')

        Share a Y axis with each row of subplots

        >>> plt.subplots(2, 2, sharey='row')

        Share both X and Y axes with all subplots

        >>> plt.subplots(2, 2, sharex='all', sharey='all')

        Note that this is the same as

        >>> plt.subplots(2, 2, sharex=True, sharey=True)

        See Also
        --------
        figure
        subplot

    subplots_adjust(*args, **kwargs)
        Tune the subplot layout.

        call signature::

          subplots_adjust(left=None, bottom=None, right=None, top=None,
                          wspace=None, hspace=None)

        The parameter meanings (and suggested defaults) are::

          left  = 0.125  # the left side of the subplots of the figure
          right = 0.9    # the right side of the subplots of the figure
          bottom = 0.1   # the bottom of the subplots of the figure
          top = 0.9      # the top of the subplots of the figure
          wspace = 0.2   # the amount of width reserved for space between subplots,
                         # expressed as a fraction of the average axis width
          hspace = 0.2   # the amount of height reserved for space between subplots,
                         # expressed as a fraction of the average axis height

        The actual defaults are controlled by the rc file

    summer()
        Set the colormap to "summer".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    suptitle(*args, **kwargs)
        Add a centered title to the figure.

        kwargs are :class:`matplotlib.text.Text` properties.  Using figure
        coordinates, the defaults are:

          x : 0.5
            The x location of the text in figure coords

          y : 0.98
            The y location of the text in figure coords

          horizontalalignment : 'center'
            The horizontal alignment of the text

          verticalalignment : 'top'
            The vertical alignment of the text

        If the `fontproperties` keyword argument is given then the
        rcParams defaults for `fontsize` (`figure.titlesize`) and
        `fontweight` (`figure.titleweight`) will be ignored in favour
        of the `FontProperties` defaults.

        A :class:`matplotlib.text.Text` instance is returned.

        Example::

          fig.suptitle('this is the figure title', fontsize=12)

    switch_backend(newbackend)
        Switch the default backend.  This feature is **experimental**, and
        is only expected to work switching to an image backend.  e.g., if
        you have a bunch of PostScript scripts that you want to run from
        an interactive ipython session, you may want to switch to the PS
        backend before running them to avoid having a bunch of GUI windows
        popup.  If you try to interactively switch from one GUI backend to
        another, you will explode.

        Calling this command will close all open windows.

    table(**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(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))

    thetagrids(*args, **kwargs)
        Get or set the theta locations of the gridlines in a polar plot.

        If no arguments are passed, return a tuple (*lines*, *labels*)
        where *lines* is an array of radial gridlines
        (:class:`~matplotlib.lines.Line2D` instances) and *labels* is an
        array of tick labels (:class:`~matplotlib.text.Text` instances)::

          lines, labels = thetagrids()

        Otherwise the syntax is::

          lines, labels = thetagrids(angles, labels=None, fmt='%d', frac = 1.1)

        set the angles at which to place the theta grids (these gridlines
        are equal along the theta dimension).

        *angles* is in degrees.

        *labels*, if not *None*, is a len(angles) list of strings of the
        labels to use at each angle.

        If *labels* is *None*, the labels will be ``fmt%angle``.

        *frac* is the fraction of the polar axes radius at which to place
        the label (1 is the edge). e.g., 1.05 is outside the axes and 0.95
        is inside the axes.

        Return value is a list of tuples (*lines*, *labels*):

          - *lines* are :class:`~matplotlib.lines.Line2D` instances

          - *labels* are :class:`~matplotlib.text.Text` instances.

        Note that on input, the *labels* argument is a list of strings,
        and on output it is a list of :class:`~matplotlib.text.Text`
        instances.

        Examples::

          # set the locations of the radial gridlines and labels
          lines, labels = thetagrids( range(45,360,90) )

          # set the locations and labels of the radial gridlines and labels
          lines, labels = thetagrids( range(45,360,90), ('NE', 'NW', 'SW','SE') )

    tick_params(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(**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.

    tight_layout(pad=1.08, h_pad=None, w_pad=None, rect=None)
        Automatically adjust subplot parameters to give specified padding.

        Parameters
        ----------
        pad : float
            padding between the figure edge and the edges of subplots, as a fraction of the font-size.
        h_pad, w_pad : float
            padding (height/width) between edges of adjacent subplots.
            Defaults to `pad_inches`.
        rect : if rect is given, it is interpreted as a rectangle
            (left, bottom, right, top) in the normalized figure
            coordinate that the whole subplots area (including
            labels) will fit into. Default is (0, 0, 1, 1).

    title(s, *args, **kwargs)
        Set a title of the current 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.

        .. seealso::
            See :func:`~matplotlib.pyplot.text` for adding text
            to the current axes

        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'

        Returns
        -------
        text : :class:`~matplotlib.text.Text`
            The matplotlib text instance representing the title

        Other parameters
        ----------------
        kwargs : text properties
            Other keyword arguments are text properties, see
            :class:`~matplotlib.text.Text` for a list of valid text
            properties.

    tricontour(*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(*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(*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(*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

    twinx(ax=None)
        Make a second axes that shares the *x*-axis.  The new axes will
        overlay *ax* (or the current axes if *ax* is *None*).  The ticks
        for *ax2* will be placed on the right, and the *ax2* instance is
        returned.

        .. seealso::

           :file:`examples/api_examples/two_scales.py`
              For an example

    twiny(ax=None)
        Make a second axes that shares the *y*-axis.  The new axis will
        overlay *ax* (or the current axes if *ax* is *None*).  The ticks
        for *ax2* will be placed on the top, and the *ax2* instance is
        returned.

    uninstall_repl_displayhook()
        Uninstalls the matplotlib display hook.

        .. warning

           Need IPython >= 2 for this to work.  For IPython < 2 will raise a
           ``NotImplementedError``

        .. warning

           If you are using vanilla python and have installed another
           display hook this will reset ``sys.displayhook`` to what ever
           function was there when matplotlib installed it's displayhook,
           possibly discarding your changes.

    violinplot(dataset, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False, points=100, bw_method=None, hold=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'.

    viridis()
        Set the colormap to "viridis".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    vlines(x, ymin, ymax, colors='k', linestyles='solid', label='', hold=None, 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'.

    waitforbuttonpress(*args, **kwargs)
        Blocking call to interact with the figure.

        This will return True is a key was pressed, False if a mouse
        button was pressed and None if *timeout* was reached without
        either being pressed.

        If *timeout* is negative, does not timeout.

    winter()
        Set the colormap to "winter".

        This changes the default colormap as well as the colormap of the current
        image if there is one. See ``help(colormaps)`` for more information.

    xcorr(x, y, normed=True, detrend=<function detrend_none at 0x0000000007CC2598>, usevlines=True, maxlags=10, hold=None, 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'.

    xkcd(scale=1, length=100, randomness=2)
        Turns on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.
        This will only have effect on things drawn after this function is
        called.

        For best results, the "Humor Sans" font should be installed: it is
        not included with matplotlib.

        Parameters
        ----------
        scale : float, optional
            The amplitude of the wiggle perpendicular to the source line.
        length : float, optional
            The length of the wiggle along the line.
        randomness : float, optional
            The scale factor by which the length is shrunken or expanded.

        Notes
        -----
        This function works by a number of rcParams, so it will probably
        override others you have set before.

        If you want the effects of this function to be temporary, it can
        be used as a context manager, for example::

            with plt.xkcd():
                # This figure will be in XKCD-style
                fig1 = plt.figure()
                # ...

            # This figure will be in regular style
            fig2 = plt.figure()

    xlabel(s, *args, **kwargs)
        Set the x-axis label of the current axes.

        Call signature::

            xlabel(label, fontdict=None, labelpad=None, **kwargs)

        This is the pyplot equivalent of calling `.set_xlabel` on the current axes.
        See there for a full parameter description.

    xlim(*args, **kwargs)
        Get or set the x limits of the current axes.

        Call signatures::

            xmin, xmax = xlim()  # return the current xlim
            xlim((xmin, xmax))   # set the xlim to xmin, xmax
            xlim(xmin, xmax)     # set the xlim to xmin, xmax

        If you do not specify args, you can pass *xmin* or *xmax* as kwargs, i.e.::

            xlim(xmax=3)  # adjust the max leaving min unchanged
            xlim(xmin=1)  # adjust the min leaving max unchanged

        Setting limits turns autoscaling off for the x-axis.

        Returns
        -------
        xmin, xmax
            A tuple of the new x-axis limits.

        Notes
        -----
        Calling this function with no arguments (e.g. ``xlim()``) is the pyplot
        equivalent of calling `~.Axes.get_xlim` on the current axes.
        Calling this function with arguments is the pyplot equivalent of calling
        `~.Axes.set_xlim` on the current axes. All arguments are passed though.

    xscale(*args, **kwargs)
        Set the scaling of the x-axis.

        Call signature::

            xscale(scale, **kwargs)

        Parameters
        ----------
        scale : ['linear' | 'log' | 'logit' | 'symlog']
            The scaling type.
        **kwargs
            Additional parameters depend on *scale*. See Notes.

        Notes
        -----
        This is the pyplot equivalent of calling `~.Axes.set_xscale` on the
        current axes.

        Different keywords may be accepted, depending on the scale:

            'linear'

            'log'

                *basex*/*basey*:
                   The base of the logarithm

                *nonposx*/*nonposy*: ['mask' | 'clip' ]
                  non-positive values in *x* or *y* can be masked as
                  invalid, or clipped to a very small positive number

                *subsx*/*subsy*:
                   Where to place the subticks between each major tick.
                   Should be a sequence of integers.  For example, in a log10
                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``

                   will place 8 logarithmically spaced minor ticks between
                   each major tick.

            'logit'

                *nonpos*: ['mask' | 'clip' ]
                  values beyond ]0, 1[ can be masked as invalid, or clipped to a number
                  very close to 0 or 1

            'symlog'

                *basex*/*basey*:
                   The base of the logarithm

                *linthreshx*/*linthreshy*:
                  A single float which defines the range (-*x*, *x*), within
                  which the plot is linear. This avoids having the plot go to
                  infinity around zero.

                *subsx*/*subsy*:
                   Where to place the subticks between each major tick.
                   Should be a sequence of integers.  For example, in a log10
                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``

                   will place 8 logarithmically spaced minor ticks between
                   each major tick.

                *linscalex*/*linscaley*:
                   This allows the linear range (-*linthresh* to *linthresh*)
                   to be stretched relative to the logarithmic range.  Its
                   value is the number of decades to use for each half of the
                   linear range.  For example, when *linscale* == 1.0 (the
                   default), the space used for the positive and negative
                   halves of the linear range will be equal to one decade in
                   the logarithmic range.

    xticks(*args, **kwargs)
        Get or set the current tick locations and labels of the x-axis.

        Call signatures::

            locs, labels = xticks()           # Get locations and labels

            xticks(locs, [labels], **kwargs)  # Set locations and labels

        Parameters
        ----------
        locs : array_like
            A list of positions at which ticks should be placed. You can pass an
            empty list to disable xticks.

        labels : array_like, optional
            A list of explicit labels to place at the given *locs*.

        **kwargs
            :class:`.Text` properties can be used to control the appearance of
            the labels.

        Returns
        -------
        locs
            An array of label locations.
        labels
            A list of `.Text` objects.

        Notes
        -----
        Calling this function with no arguments (e.g. ``xticks()``) is the pyplot
        equivalent of calling `~.Axes.get_xticks` and `~.Axes.get_xticklabels` on
        the current axes.
        Calling this function with arguments is the pyplot equivalent of calling
        `~.Axes.set_xticks` and `~.Axes.set_xticklabels` on the current axes.

        Examples
        --------
        Get the current locations and labels:

            >>> locs, labels = xticks()

        Set label locations:

            >>> xticks(np.arange(0, 1, step=0.2))

        Set text labels:

            >>> xticks(np.arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue'))

        Set text labels and properties:

            >>> xticks(np.arange(12), calendar.month_name[1:13], rotation=20)

        Disable xticks:

            >>> xticks([])

    ylabel(s, *args, **kwargs)
        Set the y-axis label of the current axes.

        Call signature::

            ylabel(label, fontdict=None, labelpad=None, **kwargs)

        This is the pyplot equivalent of calling `.set_ylabel` on the current axes.
        See there for a full parameter description.

    ylim(*args, **kwargs)
        Get or set the y-limits of the current axes.

        Call signatures::

            ymin, ymax = ylim()  # return the current ylim
            ylim((ymin, ymax))   # set the ylim to ymin, ymax
            ylim(ymin, ymax)     # set the ylim to ymin, ymax

        If you do not specify args, you can alternatively pass *ymin* or *ymax* as
        kwargs, i.e.::

            ylim(ymax=3)  # adjust the max leaving min unchanged
            ylim(ymin=1)  # adjust the min leaving max unchanged

        Setting limits turns autoscaling off for the y-axis.

        Returns
        -------
        ymin, ymax
            A tuple of the new y-axis limits.

        Notes
        -----
        Calling this function with no arguments (e.g. ``ylim()``) is the pyplot
        equivalent of calling `~.Axes.get_ylim` on the current axes.
        Calling this function with arguments is the pyplot equivalent of calling
        `~.Axes.set_ylim` on the current axes. All arguments are passed though.

    yscale(*args, **kwargs)
        Set the scaling of the y-axis.

        Call signature::

            yscale(scale, **kwargs)

        Parameters
        ----------
        scale : ['linear' | 'log' | 'logit' | 'symlog']
            The scaling type.
        **kwargs
            Additional parameters depend on *scale*. See Notes.

        Notes
        -----
        This is the pyplot equivalent of calling `~.Axes.set_yscale` on the
        current axes.

        Different keywords may be accepted, depending on the scale:

            'linear'

            'log'

                *basex*/*basey*:
                   The base of the logarithm

                *nonposx*/*nonposy*: ['mask' | 'clip' ]
                  non-positive values in *x* or *y* can be masked as
                  invalid, or clipped to a very small positive number

                *subsx*/*subsy*:
                   Where to place the subticks between each major tick.
                   Should be a sequence of integers.  For example, in a log10
                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``

                   will place 8 logarithmically spaced minor ticks between
                   each major tick.

            'logit'

                *nonpos*: ['mask' | 'clip' ]
                  values beyond ]0, 1[ can be masked as invalid, or clipped to a number
                  very close to 0 or 1

            'symlog'

                *basex*/*basey*:
                   The base of the logarithm

                *linthreshx*/*linthreshy*:
                  A single float which defines the range (-*x*, *x*), within
                  which the plot is linear. This avoids having the plot go to
                  infinity around zero.

                *subsx*/*subsy*:
                   Where to place the subticks between each major tick.
                   Should be a sequence of integers.  For example, in a log10
                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``

                   will place 8 logarithmically spaced minor ticks between
                   each major tick.

                *linscalex*/*linscaley*:
                   This allows the linear range (-*linthresh* to *linthresh*)
                   to be stretched relative to the logarithmic range.  Its
                   value is the number of decades to use for each half of the
                   linear range.  For example, when *linscale* == 1.0 (the
                   default), the space used for the positive and negative
                   halves of the linear range will be equal to one decade in
                   the logarithmic range.

    yticks(*args, **kwargs)
        Get or set the current tick locations and labels of the y-axis.

        Call signatures::

            locs, labels = yticks()           # Get locations and labels

            yticks(locs, [labels], **kwargs)  # Set locations and labels

        Parameters
        ----------
        locs : array_like
            A list of positions at which ticks should be placed. You can pass an
            empty list to disable yticks.

        labels : array_like, optional
            A list of explicit labels to place at the given *locs*.

        **kwargs
            :class:`.Text` properties can be used to control the appearance of
            the labels.

        Returns
        -------
        locs
            An array of label locations.
        labels
            A list of `.Text` objects.

        Notes
        -----
        Calling this function with no arguments (e.g. ``yticks()``) is the pyplot
        equivalent of calling `~.Axes.get_yticks` and `~.Axes.get_yticklabels` on
        the current axes.
        Calling this function with arguments is the pyplot equivalent of calling
        `~.Axes.set_yticks` and `~.Axes.set_yticklabels` on the current axes.

        Examples
        --------
        Get the current locations and labels:

            >>> locs, labels = yticks()

        Set label locations:

            >>> yticks(np.arange(0, 1, step=0.2))

        Set text labels:

            >>> yticks(np.arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue'))

        Set text labels and properties:

            >>> yticks(np.arange(12), calendar.month_name[1:13], rotation=45)

        Disable yticks:

            >>> yticks([])

DATA
    absolute_import = _Feature((2, 5, 0, 'alpha', 1), (3, 0, 0, 'alpha', 0...
    division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192...
    print_function = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0)...
    rcParams = RcParams({'_internal.classic_mode': False,
         ...nor.widt...
    rcParamsDefault = RcParams({'_internal.classic_mode': False,
         ...n...
    unicode_literals = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', ...

FILE
    c:\users\duo\anaconda3\lib\site-packages\matplotlib\pyplot.py

</code>