# Notebook from sarim-Sikander/Visualization-Notebook
Path: matplotlib.ipynb

<code>
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from numpy.random import randn, randint_____no_output_____%matplotlib inline_____no_output_____x = np.linspace(1,10,20)_____no_output_____x_____no_output_____y = randint(1,50, 20)_____no_output_____y_____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, *, data=None, **kwargs)
        Plot the autocorrelation of *x*.

        Parameters
        ----------
        x : array-like

        detrend : callable, default: `.mlab.detrend_none` (no detrending)
            A detrending function applied to *x*.  It must have the
            signature ::

                detrend(x: np.ndarray) -> np.ndarray

        normed : bool, default: True
            If ``True``, input vectors are normalised to unit length.

        usevlines : bool, default: True
            Determines the plot style.

            If ``True``, vertical lines are plotted from 0 to the acorr value
            using `.Axes.vlines`. Additionally, a horizontal line is plotted
            at y=0 using `.Axes.axhline`.

            If ``False``, markers are plotted at the acorr values using
            `.Axes.plot`.

        maxlags : int, default: 10
            Number of lags to show. If ``None``, will return all
            ``2 * len(x) - 1`` lags.

        Returns
        -------
        lags : array (length ``2*maxlags+1``)
            The lag vector.
        c : array  (length ``2*maxlags+1``)
            The 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 : `.Line2D` property, optional
            The linestyle for plotting the data points.
            Only used if *usevlines* is ``False``.

        marker : str, default: 'o'
            The marker for plotting the data points.
            Only used if *usevlines* is ``False``.

        **kwargs
            Additional parameters are passed to `.Axes.vlines` and
            `.Axes.axhline` if *usevlines* is ``True``; otherwise they are
            passed to `.Axes.plot`.

        Notes
        -----
        The cross correlation is performed with `numpy.correlate` with
        ``mode = "full"``.

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    angle_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)
        Plot the angle spectrum.

        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 : float, default: 2
            The sampling frequency (samples per time unit).  It is used to calculate
            the Fourier frequencies, *freqs*, in cycles per time unit.

        window : callable or ndarray, default: `.window_hanning`
            A function or a vector of length *NFFT*.  To create window vectors see
            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
            function is passed as the argument, it must take a data segment as an
            argument and return the windowed version of the segment.

        sides : {'default', 'onesided', 'twosided'}, optional
            Which sides of the spectrum to return. 'default' is one-sided for real
            data and two-sided for complex data. 'onesided' forces the return of a
            one-sided spectrum, while 'twosided' forces two-sided.

        pad_to : int, optional
            The number of points to which the data segment is padded when performing
            the FFT.  While not increasing the actual resolution of the spectrum (the
            minimum distance between resolvable peaks), this can give more points in
            the plot, allowing for more detail. This corresponds to the *n* parameter
            in the call to fft().  The default is None, which sets *pad_to* equal to
            the length of the input signal (i.e. no padding).

        Fc : int, default: 0
            The center frequency of *x*, which offsets the x extents of the
            plot to reflect the frequency range used when a signal is acquired
            and then filtered and downsampled to baseband.

        Returns
        -------
        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 : `~matplotlib.lines.Line2D`
            The line created by this function.

        Other Parameters
        ----------------
        **kwargs
            Keyword arguments control the `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        magnitude_spectrum
            Plots the magnitudes of the corresponding frequencies.
        phase_spectrum
            Plots the unwrapped version of this function.
        specgram
            Can plot the angle spectrum of segments within the signal in a
            colormap.

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    annotate(text, xy, *args, **kwargs)
        Annotate the point *xy* with text *text*.

        In the simplest form, the text is placed at *xy*.

        Optionally, the text can be displayed in another position *xytext*.
        An arrow pointing from the text to the annotated point *xy* can then
        be added by defining *arrowprops*.

        Parameters
        ----------
        text : str
            The text of the annotation.  *s* is a deprecated synonym for this
            parameter.

        xy : (float, float)
            The point *(x, y)* to annotate. The coordinate system is determined
            by *xycoords*.

        xytext : (float, float), default: *xy*
            The position *(x, y)* to place the text at. The coordinate system
            is determined by *textcoords*.

        xycoords : str or `.Artist` or `.Transform` or callable or (float, float), default: 'data'

            The coordinate system that *xy* is given in. The following types
            of values are supported:

            - One of the following strings:

              =================   =============================================
              Value               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
              =================   =============================================

            - An `.Artist`: *xy* is interpreted as a fraction of the artist's
              `~matplotlib.transforms.Bbox`. E.g. *(0, 0)* would be the lower
              left corner of the bounding box and *(0.5, 1)* would be the
              center top of the bounding box.

            - A `.Transform` to transform *xy* to screen coordinates.

            - A function with one of the following signatures::

                def transform(renderer) -> Bbox
                def transform(renderer) -> Transform

              where *renderer* is a `.RendererBase` subclass.

              The result of the function is interpreted like the `.Artist` and
              `.Transform` cases above.

            - A tuple *(xcoords, ycoords)* specifying separate coordinate
              systems for *x* and *y*. *xcoords* and *ycoords* must each be
              of one of the above described types.

            See :ref:`plotting-guide-annotation` for more details.

        textcoords : str or `.Artist` or `.Transform` or callable or (float, float), default: value of *xycoords*
            The coordinate system that *xytext* is given in.

            All *xycoords* values are valid as well as the following
            strings:

            =================   =========================================
            Value               Description
            =================   =========================================
            'offset points'     Offset (in points) from the *xy* value
            'offset pixels'     Offset (in pixels) from the *xy* value
            =================   =========================================

        arrowprops : dict, optional
            The properties used to draw a `.FancyArrowPatch` arrow between the
            positions *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 *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, i.e. no arrow is drawn.

        annotation_clip : bool or None, default: None
            Whether to draw the annotation when the annotation point *xy* is
            outside the axes area.

            - If *True*, the annotation will only be drawn when *xy* is
              within the axes.
            - If *False*, the annotation will always be drawn.
            - If *None*, the annotation will only be drawn when *xy* is
              within the axes and *xycoords* is 'data'.

        **kwargs
            Additional kwargs are passed to `~matplotlib.text.Text`.

        Returns
        -------
        `.Annotation`

        See Also
        --------
        :ref:`plotting-guide-annotation`

    arrow(x, y, dx, dy, **kwargs)
        Add an arrow to the axes.

        This draws an arrow from ``(x, y)`` to ``(x+dx, y+dy)``.

        Parameters
        ----------
        x, y : float
            The x and y coordinates of the arrow base.

        dx, dy : float
            The length of the arrow along x and y direction.

        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.

        **kwargs
            `.Patch` properties:

            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: unknown
            capstyle: {'butt', 'round', 'projecting'}
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color: color
            contains: unknown
            edgecolor or ec: color or None or 'auto'
            facecolor or fc: color or None
            figure: `.Figure`
            fill: bool
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float or None
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            visible: bool
            zorder: float

        Returns
        -------
        `.FancyArrow`
            The created `.FancyArrow` object.

        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, default: True
            True turns autoscaling on, False turns it off.
            None leaves the autoscaling state unchanged.
        axis : {'both', 'x', 'y'}, default: 'both'
            Which axis to operate on.
        tight : bool or None, default: None
            If True, first set the margins to zero.  Then, this argument is
            forwarded to `autoscale_view` (regardless of its value); see the
            description of its behavior there.

    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.

        Call signatures::

            plt.axes()
            plt.axes(rect, projection=None, polar=False, **kwargs)
            plt.axes(ax)

        Parameters
        ----------
        arg : None or 4-tuple
            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.

        projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', 'rectilinear', str}, optional
            The projection type of the `~.axes.Axes`. *str* is the name of
            a custom projection, see `~matplotlib.projections`. The default
            None results in a 'rectilinear' projection.

        polar : bool, default: False
            If True, equivalent to projection='polar'.

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

        label : str
            A label for the returned axes.

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

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

            Properties:
            adjustable: {'box', 'datalim'}
            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
            alpha: float or None
            anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}
            animated: bool
            aspect: {'auto'} or num
            autoscale_on: bool
            autoscalex_on: bool
            autoscaley_on: bool
            axes_locator: Callable[[Axes, Renderer], Bbox]
            axisbelow: bool or 'line'
            box_aspect: None, or a number
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            contains: unknown
            facecolor or fc: color
            figure: `.Figure`
            frame_on: bool
            gid: str
            in_layout: bool
            label: object
            navigate: bool
            navigate_mode: unknown
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`
            prop_cycle: unknown
            rasterization_zorder: float or None
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            title: str
            transform: `.Transform`
            url: str
            visible: bool
            xbound: unknown
            xlabel: str
            xlim: (bottom: float, top: float)
            xmargin: float greater than -0.5
            xscale: {"linear", "log", "symlog", "logit", ...}
            xticklabels: unknown
            xticks: unknown
            ybound: unknown
            ylabel: str
            ylim: (bottom: float, top: float)
            ymargin: float greater than -0.5
            yscale: {"linear", "log", "symlog", "logit", ...}
            yticklabels: unknown
            yticks: unknown
            zorder: float

        Notes
        -----
        If the figure already has a axes with key (*args*,
        *kwargs*) then it will simply make that axes current and
        return it.  This behavior is deprecated. Meanwhile, if you do
        not want this behavior (i.e., you want to force the creation of a
        new axes), you must use a unique set of args and kwargs.  The axes
        *label* attribute has been exposed for this purpose: if you want
        two axes that are otherwise identical to be added to the figure,
        make sure you give them unique labels.

        See Also
        --------
        .Figure.add_axes
        .pyplot.subplot
        .Figure.add_subplot
        .Figure.subplots
        .pyplot.subplots

        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, **kwargs)
        Add a horizontal line across the axis.

        Parameters
        ----------
        y : float, default: 0
            y position in data coordinates of the horizontal line.

        xmin : float, default: 0
            Should be between 0 and 1, 0 being the far left of the plot, 1 the
            far right of the plot.

        xmax : float, default: 1
            Should be between 0 and 1, 0 being the far left of the plot, 1 the
            far right of the plot.

        Returns
        -------
        `~matplotlib.lines.Line2D`

        Other Parameters
        ----------------
        **kwargs
            Valid keyword arguments are `.Line2D` properties, with the
            exception of 'transform':

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            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.
        axline : Add a line with an arbitrary slope.

        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, **kwargs)
        Add a horizontal span (rectangle) across the axis.

        The rectangle spans from *ymin* to *ymax* vertically, and, by default,
        the whole x-axis horizontally.  The x-span can be set using *xmin*
        (default: 0) and *xmax* (default: 1) which are in axis units; e.g.
        ``xmin = 0.5`` always refers to the middle of the x-axis regardless of
        the limits set by `~.Axes.set_xlim`.

        Parameters
        ----------
        ymin : float
            Lower y-coordinate of the span, in data units.
        ymax : float
            Upper y-coordinate of the span, in data units.
        xmin : float, default: 0
            Lower x-coordinate of the span, in x-axis (0-1) units.
        xmax : float, default: 1
            Upper x-coordinate of the span, in x-axis (0-1) units.

        Returns
        -------
        `~matplotlib.patches.Polygon`
            Horizontal span (rectangle) from (xmin, ymin) to (xmax, ymax).

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.patches.Polygon` properties

        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: unknown
            capstyle: {'butt', 'round', 'projecting'}
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color: color
            contains: unknown
            edgecolor or ec: color or None or 'auto'
            facecolor or fc: color or None
            figure: `.Figure`
            fill: bool
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float or None
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            visible: bool
            zorder: float

        See Also
        --------
        axvspan : Add a vertical span across the axes.

    axis(*args, emit=True, **kwargs)
        Convenience method to get or set some axis properties.

        Call signatures::

          xmin, xmax, ymin, ymax = axis()
          xmin, xmax, ymin, ymax = axis([xmin, xmax, ymin, ymax])
          xmin, xmax, ymin, ymax = axis(option)
          xmin, xmax, ymin, ymax = axis(**kwargs)

        Parameters
        ----------
        xmin, xmax, ymin, ymax : float, optional
            The axis limits to be set.  This can also be achieved using ::

                ax.set(xlim=(xmin, xmax), ylim=(ymin, ymax))

        option : bool or str
            If a bool, turns axis lines and labels on or off. If a string,
            possible values are:

            ======== ==========================================================
            Value    Description
            ======== ==========================================================
            'on'     Turn on axis lines and labels. Same as ``True``.
            'off'    Turn off axis lines and labels. Same as ``False``.
            'equal'  Set equal scaling (i.e., make circles circular) by
                     changing axis limits. This is the same as
                     ``ax.set_aspect('equal', adjustable='datalim')``.
                     Explicit data limits may not be respected in this case.
            'scaled' Set equal scaling (i.e., make circles circular) by
                     changing dimensions of the plot box. This is the same as
                     ``ax.set_aspect('equal', adjustable='box', anchor='C')``.
                     Additionally, further autoscaling will be disabled.
            'tight'  Set limits just large enough to show all data, then
                     disable further autoscaling.
            'auto'   Automatic scaling (fill plot box with data).
            'image'  'scaled' with axis limits equal to data limits.
            'square' Square plot; similar to 'scaled', but initially forcing
                     ``xmax-xmin == ymax-ymin``.
            ======== ==========================================================

        emit : bool, default: True
            Whether observers are notified of the axis limit change.
            This option is passed on to `~.Axes.set_xlim` and
            `~.Axes.set_ylim`.

        Returns
        -------
        xmin, xmax, ymin, ymax : float
            The axis limits.

        See Also
        --------
        matplotlib.axes.Axes.set_xlim
        matplotlib.axes.Axes.set_ylim

    axline(xy1, xy2=None, *, slope=None, **kwargs)
        Add an infinitely long straight line.

        The line can be defined either by two points *xy1* and *xy2*, or
        by one point *xy1* and a *slope*.

        This draws a straight line "on the screen", regardless of the x and y
        scales, and is thus also suitable for drawing exponential decays in
        semilog plots, power laws in loglog plots, etc. However, *slope*
        should only be used with linear scales; It has no clear meaning for
        all other scales, and thus the behavior is undefined. Please specify
        the line using the points *xy1*, *xy2* for non-linear scales.

        Parameters
        ----------
        xy1, xy2 : (float, float)
            Points for the line to pass through.
            Either *xy2* or *slope* has to be given.
        slope : float, optional
            The slope of the line. Either *xy2* or *slope* has to be given.

        Returns
        -------
        `.Line2D`

        Other Parameters
        ----------------
        **kwargs
            Valid kwargs are `.Line2D` properties, with the exception of
            'transform':

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        axhline : for horizontal lines
        axvline : for vertical lines

        Examples
        --------
        Draw a thick red line passing through (0, 0) and (1, 1)::

            >>> axline((0, 0), (1, 1), linewidth=4, color='r')

    axvline(x=0, ymin=0, ymax=1, **kwargs)
        Add a vertical line across the axes.

        Parameters
        ----------
        x : float, default: 0
            x position in data coordinates of the vertical line.

        ymin : float, default: 0
            Should be between 0 and 1, 0 being the bottom of the plot, 1 the
            top of the plot.

        ymax : float, default: 1
            Should be between 0 and 1, 0 being the bottom of the plot, 1 the
            top of the plot.

        Returns
        -------
        `~matplotlib.lines.Line2D`

        Other Parameters
        ----------------
        **kwargs
            Valid keyword arguments are `.Line2D` properties, with the
            exception of 'transform':

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        vlines : Add vertical lines in data coordinates.
        axvspan : Add a vertical span (rectangle) across the axis.
        axline : Add a line with an arbitrary slope.

        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)

    axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs)
        Add a vertical span (rectangle) across the axes.

        The rectangle spans from *xmin* to *xmax* horizontally, and, by
        default, the whole y-axis vertically.  The y-span can be set using
        *ymin* (default: 0) and *ymax* (default: 1) which are in axis units;
        e.g. ``ymin = 0.5`` always refers to the middle of the y-axis
        regardless of the limits set by `~.Axes.set_ylim`.

        Parameters
        ----------
        xmin : float
            Lower x-coordinate of the span, in data units.
        xmax : float
            Upper x-coordinate of the span, in data units.
        ymin : float, default: 0
            Lower y-coordinate of the span, in y-axis units (0-1).
        ymax : float, default: 1
            Upper y-coordinate of the span, in y-axis units (0-1).

        Returns
        -------
        `~matplotlib.patches.Polygon`
            Vertical span (rectangle) from (xmin, ymin) to (xmax, ymax).

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.patches.Polygon` properties

        %(Polygon)s

        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(x, height, width=0.8, bottom=None, *, align='center', data=None, **kwargs)
        Make a bar plot.

        The bars are positioned at *x* with the given *align*\ment. Their
        dimensions are given by *height* and *width*. The vertical baseline
        is *bottom* (default 0).

        Many parameters can take either a single value applying to all bars
        or a sequence of values, one for each bar.

        Parameters
        ----------
        x : float or array-like
            The x coordinates of the bars. See also *align* for the
            alignment of the bars to the coordinates.

        height : float or array-like
            The height(s) of the bars.

        width : float or array-like, default: 0.8
            The width(s) of the bars.

        bottom : float or array-like, default: 0
            The y coordinate(s) of the bars bases.

        align : {'center', 'edge'}, 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 : color or list of color, optional
            The colors of the bar faces.

        edgecolor : color or list of color, optional
            The colors of the bar edges.

        linewidth : float or array-like, optional
            Width of the bar edge(s). If 0, don't draw edges.

        tick_label : str or list of str, optional
            The tick labels of the bars.
            Default: None (Use default numeric labels.)

        xerr, yerr : float 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. First row
              contains the lower errors, the second row contains the upper
              errors.
            - *None*: No errorbar. (Default)

            See :doc:`/gallery/statistics/errorbar_features`
            for an example on the usage of ``xerr`` and ``yerr``.

        ecolor : color or list of color, default: 'black'
            The line color of the errorbars.

        capsize : float, default: :rc:`errorbar.capsize`
           The length of the error bar caps in points.

        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, default: False
            If *True*, set the y-axis to be log scale.

        **kwargs : `.Rectangle` properties

        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: unknown
            capstyle: {'butt', 'round', 'projecting'}
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color: color
            contains: unknown
            edgecolor or ec: color or None or 'auto'
            facecolor or fc: color or None
            figure: `.Figure`
            fill: bool
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float or None
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            visible: bool
            zorder: float

        See Also
        --------
        barh: Plot a horizontal bar plot.

        Notes
        -----
        Stacked bars can be achieved by passing individual *bottom* values per
        bar. See :doc:`/gallery/lines_bars_and_markers/bar_stacked`.

        .. note::
            In addition to the above described arguments, this function can take
            a *data* keyword argument. If such a *data* argument is given,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    barbs(*args, data=None, **kw)
        Plot a 2D field of barbs.

        Call signature::

          barbs([X, Y], U, V, [C], **kw)

        Where *X*, *Y* define the barb locations, *U*, *V* define the barb
        directions, and *C* optionally sets the color.

        All arguments may be 1D or 2D. *U*, *V*, *C* may be masked arrays, but masked
        *X*, *Y* are not supported at present.

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

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

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

        See also https://en.wikipedia.org/wiki/Wind_barb.

        Parameters
        ----------
        X, Y : 1D or 2D array-like, optional
            The x and y coordinates of the barb locations. See *pivot* for how the
            barbs are drawn to the x, y positions.

            If not given, they will be generated as a uniform integer meshgrid based
            on the dimensions of *U* and *V*.

            If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D
            using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``
            must match the column and row dimensions of *U* and *V*.

        U, V : 1D or 2D array-like
            The x and y components of the barb shaft.

        C : 1D or 2D array-like, optional
            Numeric data that defines the barb colors by colormapping via *norm* and
            *cmap*.

            This does not support explicit colors. If you want to set colors directly,
            use *barbcolor* instead.

        length : float, default: 7
            Length of the barb in points; the other parts of the barb
            are scaled against this.

        pivot : {'tip', 'middle'} or float, default: 'tip'
            The part of the arrow that is anchored to the *X*, *Y* grid. The barb
            rotates about this point. This can also be a number, which shifts the
            start of the barb that many points away from grid point.

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

        flagcolor : color or color sequence
            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 : dict, optional
            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 : bool, default: False
            Whether the empty barbs (circles) that are drawn should be filled with
            the flag color.  If they are not filled, the center is transparent.

        rounding : bool, default: True
            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.

        barb_increments : dict, optional
            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 : bool or array-like of bool, default: False
            Whether the lines and flags should point opposite to normal.
            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).

            A single value is applied to all barbs. Individual barbs can be flipped by
            passing a bool array of the same size as *U* and *V*.

        Returns
        -------
        barbs : `~matplotlib.quiver.Barbs`

        Other Parameters
        ----------------
        **kwargs
            The barbs can further be customized using `.PolyCollection` keyword
            arguments:

            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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

        Notes
        -----

        .. note::
            In addition to the above described arguments, this function can take
            a *data* keyword argument. If such a *data* argument is given,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    barh(y, width, height=0.8, left=None, *, align='center', **kwargs)
        Make a horizontal bar plot.

        The bars are positioned at *y* with the given *align*\ment. Their
        dimensions are given by *width* and *height*. The horizontal baseline
        is *left* (default 0).

        Many parameters can take either a single value applying to all bars
        or a sequence of values, one for each bar.

        Parameters
        ----------
        y : float or array-like
            The y coordinates of the bars. See also *align* for the
            alignment of the bars to the coordinates.

        width : float or array-like
            The width(s) of the bars.

        height : float or array-like, default: 0.8
            The heights of the bars.

        left : float or array-like, default: 0
            The x coordinates of the left sides of the bars.

        align : {'center', 'edge'}, 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 : color or list of color, optional
            The colors of the bar faces.

        edgecolor : color or list of color, optional
            The colors of the bar edges.

        linewidth : float or array-like, optional
            Width of the bar edge(s). If 0, don't draw edges.

        tick_label : str or list of str, optional
            The tick labels of the bars.
            Default: None (Use default numeric labels.)

        xerr, yerr : float 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. First row
              contains the lower errors, the second row contains the upper
              errors.
            - *None*: No errorbar. (default)

            See :doc:`/gallery/statistics/errorbar_features`
            for an example on the usage of ``xerr`` and ``yerr``.

        ecolor : color or list of color, default: 'black'
            The line color of the errorbars.

        capsize : float, default: :rc:`errorbar.capsize`
           The length of the error bar caps in points.

        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, default: False
            If ``True``, set the x-axis to be log scale.

        **kwargs : `.Rectangle` properties

        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: unknown
            capstyle: {'butt', 'round', 'projecting'}
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color: color
            contains: unknown
            edgecolor or ec: color or None or 'auto'
            facecolor or fc: color or None
            figure: `.Figure`
            fill: bool
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float or None
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            visible: bool
            zorder: float

        See Also
        --------
        bar: Plot a vertical bar plot.

        Notes
        -----
        Stacked bars can be achieved by passing individual *left* values per
        bar. See
        :doc:`/gallery/lines_bars_and_markers/horizontal_barchart_distribution`
        .

    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 on the current axes.

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

        See Also
        --------
        :meth:`matplotlib.axes.Axes.set_frame_on`
        :meth:`matplotlib.axes.Axes.get_frame_on`

    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_ticks=True, autorange=False, zorder=None, *, data=None)
        Make a box and whisker plot.

        Make a box and whisker plot for each column of *x* or each
        vector in sequence *x*.  The box extends from the lower to
        upper quartile values of the data, with a line at the median.
        The whiskers extend from the box to show the range of the
        data.  Flier points are those past the end of the whiskers.

        Parameters
        ----------
        x : Array or a sequence of vectors.
            The input data.

        notch : bool, default: False
            Whether to draw a noteched box plot (`True`), or a rectangular box
            plot (`False`).  The notches represent the confidence interval (CI)
            around the median.  The documentation for *bootstrap* describes 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.  An empty string ('') hides
            the fliers.  If `None`, then the fliers default to 'b+'.  More
            control is provided by the *flierprops* parameter.

        vert : bool, default: True
            If `True`, draws vertical boxes.
            If `False`, draw horizontal boxes.

        whis : float or (float, float), default: 1.5
            The position of the whiskers.

            If a float, the lower whisker is at the lowest datum above
            ``Q1 - whis*(Q3-Q1)``, and the upper whisker at the highest datum
            below ``Q3 + whis*(Q3-Q1)``, where Q1 and Q3 are the first and
            third quartiles.  The default value of ``whis = 1.5`` corresponds
            to Tukey's original definition of boxplots.

            If a pair of floats, they indicate the percentiles at which to
            draw the whiskers (e.g., (5, 95)).  In particular, setting this to
            (0, 100) results in whiskers covering the whole range of the data.
            "range" is a deprecated synonym for (0, 100).

            In the edge case where ``Q1 == Q3``, *whis* is automatically set
            to (0, 100) (cover the whole range of the data) if *autorange* is
            True.

            Beyond the whiskers, data are considered outliers and are plotted
            as individual points.

        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
            A 1D array-like of length ``len(x)``.  Each entry that is not
            `None` forces the value of the median for the corresponding
            dataset.  For entries that are `None`, the medians are computed
            by Matplotlib as normal.

        conf_intervals : array-like, optional
            A 2D array-like of shape ``(len(x), 2)``.  Each entry that is not
            None forces the location of the corresponding notch (which is
            only drawn if *notch* is `True`).  For entries that are `None`,
            the notches are computed by the method specified by the other
            parameters (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 : float 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, default: False
            If `False` produces boxes with the Line2D artist. Otherwise,
            boxes and drawn with Patch artists.

        labels : sequence, optional
            Labels for each dataset (one per dataset).

        manage_ticks : bool, default: True
            If True, the tick locations and labels will be adjusted to match
            the boxplot positions.

        autorange : bool, default: False
            When `True` and the data are distributed such that the 25th and
            75th percentiles are equal, *whis* is set to (0, 100) such
            that the whisker ends are at the minimum and maximum of the data.

        meanline : bool, default: False
            If `True` (and *showmeans* is `True`), will try to render the
            mean as a line spanning the full width of the box according to
            *meanprops* (see below).  Not recommended if *shownotches* is also
            True.  Otherwise, means will be shown as points.

        zorder : float, default: ``Line2D.zorder = 2``
            Sets the zorder of the boxplot.

        Returns
        -------
        dict
          A dictionary mapping each component of the boxplot to a list
          of the `.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.

        Other Parameters
        ----------------
        showcaps : bool, default: True
            Show the caps on the ends of whiskers.
        showbox : bool, default: True
            Show the central box.
        showfliers : bool, default: True
            Show the outliers beyond the caps.
        showmeans : bool, default: False
            Show the arithmetic means.
        capprops : dict, default: None
            The style of the caps.
        boxprops : dict, default: None
            The style of the box.
        whiskerprops : dict, default: None
            The style of the whiskers.
        flierprops : dict, default: None
            The style of the fliers.
        medianprops : dict, default: None
            The style of the median.
        meanprops : dict, default: None
            The style of the mean.

        Notes
        -----

        .. note::
            In addition to the above described arguments, this function can take
            a *data* keyword argument. If such a *data* argument is given,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    broken_barh(xranges, yrange, *, data=None, **kwargs)
        Plot a horizontal sequence of rectangles.

        A rectangle is drawn for each element of *xranges*. All rectangles
        have the same vertical position and size defined by *yrange*.

        This is a convenience function for instantiating a
        `.BrokenBarHCollection`, adding it to the axes and autoscaling the
        view.

        Parameters
        ----------
        xranges : sequence of tuples (*xmin*, *xwidth*)
            The x-positions and extends of the rectangles. For each tuple
            (*xmin*, *xwidth*) a rectangle is drawn from *xmin* to *xmin* +
            *xwidth*.
        yrange : (*ymin*, *yheight*)
            The y-position and extend for all the rectangles.

        Returns
        -------
        `~.collections.BrokenBarHCollection`

        Other Parameters
        ----------------
        **kwargs : `.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:

            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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

        Notes
        -----

        .. note::
            In addition to the above described arguments, this function can take
            a *data* keyword argument. If such a *data* argument is given,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    cla()
        Clear the current axes.

    clabel(CS, levels=None, **kwargs)
        Label a contour plot.

        Adds labels to line contours in given `.ContourSet`.

        Parameters
        ----------
        CS : `~.ContourSet` instance
            Line contours to label.

        levels : array-like, optional
            A list of level values, that should be labeled. The list must be
            a subset of ``CS.levels``. If not given, all levels are labeled.

        **kwargs
            All other parameters are documented in `~.ContourLabeler.clabel`.

    clf()
        Clear the current figure.

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

        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
        `~.ScalarMappable.set_clim` on every image, for example::

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

    close(fig=None)
        Close a figure window.

        Parameters
        ----------
        fig : None or int or str or `.Figure`
            The figure to close. There are a number of ways to specify this:

            - *None*: the current figure
            - `.Figure`: the given `.Figure` instance
            - ``int``: a figure number
            - ``str``: a figure name
            - 'all': all figures

    cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend=<function detrend_none at 0x0000025DCD922430>, window=<function window_hanning at 0x0000025DCD9220D0>, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, *, data=None, **kwargs)
        Plot the coherence between *x* and *y*.

        Plot the coherence between *x* and *y*.  Coherence is the
        normalized cross spectral density:

        .. math::

          C_{xy} = \frac{|P_{xy}|^2}{P_{xx}P_{yy}}

        Parameters
        ----------
        Fs : float, default: 2
            The sampling frequency (samples per time unit).  It is used to calculate
            the Fourier frequencies, *freqs*, in cycles per time unit.

        window : callable or ndarray, default: `.window_hanning`
            A function or a vector of length *NFFT*.  To create window vectors see
            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
            function is passed as the argument, it must take a data segment as an
            argument and return the windowed version of the segment.

        sides : {'default', 'onesided', 'twosided'}, optional
            Which sides of the spectrum to return. 'default' is one-sided for real
            data and two-sided for complex data. 'onesided' forces the return of a
            one-sided spectrum, while 'twosided' forces two-sided.

        pad_to : int, optional
            The number of points to which the data segment is padded when performing
            the FFT.  This can be different from *NFFT*, which specifies the number
            of data points used.  While not increasing the actual resolution of the
            spectrum (the minimum distance between resolvable peaks), this can give
            more points in the plot, allowing for more detail. This corresponds to
            the *n* parameter in the call to fft(). The default is None, which sets
            *pad_to* equal to *NFFT*

        NFFT : int, default: 256
            The number of data points used in each block for the FFT.  A power 2 is
            most efficient.  This should *NOT* be used to get zero padding, or the
            scaling of the result will be incorrect; use *pad_to* for this instead.

        detrend : {'none', 'mean', 'linear'} or callable, default 'none'
            The function applied to each segment before fft-ing, designed to remove
            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter
            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`
            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,
            but you can use a custom function as well.  You can also use a string to
            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls
            `.detrend_mean`. 'linear' calls `.detrend_linear`.

        scale_by_freq : bool, default: True
            Whether the resulting density values should be scaled by the scaling
            frequency, which gives density in units of Hz^-1.  This allows for
            integration over the returned frequency values.  The default is True for
            MATLAB compatibility.

        noverlap : int, default: 0 (no overlap)
            The number of points of overlap between blocks.

        Fc : int, default: 0
            The center frequency of *x*, which offsets the x extents of the
            plot to reflect the frequency range used when a signal is acquired
            and then filtered and downsampled to baseband.

        Returns
        -------
        Cxy : 1-D array
            The coherence vector.

        freqs : 1-D array
            The frequencies for the elements in *Cxy*.

        Other Parameters
        ----------------
        **kwargs
            Keyword arguments control the `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        References
        ----------
        Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,
        John Wiley & Sons (1986)

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    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 `~.Figure.colorbar` method::

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

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

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

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

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

        ax : `~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 :mod:`~.gridspec` module.

        Returns
        -------
        colorbar : `~matplotlib.colorbar.Colorbar`
            See also its base class, `~matplotlib.colorbar.ColorbarBase`.

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

          axes properties:

            fraction : float, default: 0.15
                Fraction of original axes to use for colorbar.
            shrink : float, default: 1.0
                Fraction by which to multiply the size of the colorbar.
            aspect : float, default: 20
                Ratio of long to short dimensions.

            pad : float, default: 0.05 if vertical, 0.15 if horizontal
                Fraction of original axes between colorbar and new image axes.
            anchor : (float, float), optional
                The anchor point of the colorbar axes.
                Defaults to (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal.
            panchor : (float, float), or *False*, optional
                The anchor point of the colorbar parent axes. If *False*, the parent
                axes' anchor will be unchanged.
                Defaults to (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal.

          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* or list of ticks or Locator
                          If None, ticks are determined automatically from the
                          input.
            *format*      None or str or Formatter
                          If None, `~.ticker.ScalarFormatter` is used.
                          If a format string is given, e.g., '%.3f', that is used.
                          An alternative `~.ticker.Formatter` may be given instead.
            *drawedges*   bool
                          Whether to draw lines at color boundaries.
            *label*       str
                          The label on the colorbar's long axis.
            ============  ====================================================

            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 `~.contour.ContourSet`, its *extend* kwarg is included
        automatically.

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

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

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

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

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

    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
          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
        <https://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, `.ListedColormap` is used,
        not `.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
          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
          ============  =======================================================

        A set of cyclic color maps:

          ================  =================================================
          Colormap          Description
          ================  =================================================
          hsv               red-yellow-green-cyan-blue-magenta-red, formed by
                            changing the hue component in the HSV color space
          twilight          perceptually uniform shades of
                            white-blue-black-red-white
          twilight_shifted  perceptually uniform shades of
                            black-blue-white-red-black
          ================  =================================================

        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
          turbo         Spectral map (purple-blue-green-yellow-orange-red) with
                        a bright center and darker endpoints. A smoother
                        alternative to jet.
          ============= =======================================================

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

        .. rubric:: Footnotes

        .. [#] Rainbow colormaps, ``jet`` in particular, are considered a poor
          choice for scientific visualization by many researchers: `Rainbow Color
          Map (Still) Considered Harmful
          <https://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

    connect(s, func)
        Bind function *func* to event *s*.

        Parameters
        ----------
        s : str
            One of the following events ids:

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

        func : callable
            The callback function to be executed, which must have the
            signature::

                def func(event: Event) -> Any

            For the location events (button and key press/release), if the
            mouse is over the axes, the ``inaxes`` attribute of the event will
            be set to the `~matplotlib.axes.Axes` the event occurs is over, and
            additionally, the variables ``xdata`` and ``ydata`` attributes will
            be set to the mouse location in data coordinates.  See `.KeyEvent`
            and `.MouseEvent` for more info.

        Returns
        -------
        cid
            A connection id that can be used with
            `.FigureCanvasBase.mpl_disconnect`.

        Examples
        --------
        ::

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

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

    contour(*args, data=None, **kwargs)
        Plot contours.

        Call signature::

            contour([X, Y,] Z, [levels], **kwargs)

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

        Parameters
        ----------
        X, Y : array-like, optional
            The coordinates of the values in *Z*.

            *X* and *Y* must both be 2-D with the same shape as *Z* (e.g.
            created via `numpy.meshgrid`), or they must both be 1-D such
            that ``len(X) == M`` is the number of columns in *Z* and
            ``len(Y) == N`` is the number of rows in *Z*.

            If not given, they are assumed to be integer indices, i.e.
            ``X = range(M)``, ``Y = range(N)``.

        Z : array-like(N, M)
            The height values over which the contour is drawn.

        levels : int or array-like, optional
            Determines the number and positions of the contour lines / regions.

            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries
            to automatically choose no more than *n+1* "nice" contour levels
            between *vmin* and *vmax*.

            If array-like, draw contour lines at the specified levels.
            The values must be in increasing order.

        Returns
        -------
        `~.contour.QuadContourSet`

        Other Parameters
        ----------------
        corner_mask : bool, default: :rc:`contour.corner_mask`
            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.

        colors : color string or sequence of colors, optional
            The colors of the levels, i.e. the lines for `.contour` and the
            areas for `.contourf`.

            The sequence is cycled for the levels in ascending order. If the
            sequence is shorter than the number of levels, it's repeated.

            As a shortcut, single color strings may be used in place of
            one-element lists, i.e. ``'red'`` instead of ``['red']`` to color
            all levels with the same color. This shortcut does only work for
            color strings, not for other ways of specifying colors.

            By default (value *None*), the colormap specified by *cmap*
            will be used.

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

        cmap : str or `.Colormap`, default: :rc:`image.cmap`
            A `.Colormap` instance or registered colormap name. The colormap
            maps the level values to colors.

            If both *colors* and *cmap* are given, an error is raised.

        norm : `~matplotlib.colors.Normalize`, optional
            If a colormap is used, the `.Normalize` instance scales the level
            values to the canonical colormap range [0, 1] for mapping to
            colors. If not given, the default linear scaling is used.

        vmin, vmax : float, optional
            If not *None*, either or both of these values will be supplied to
            the `.Normalize` instance, overriding the default color scaling
            based on *levels*.

        origin : {*None*, 'upper', 'lower', 'image'}, default: None
            Determines the orientation and exact position of *Z* by specifying
            the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*
            are not given.

            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.
            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.
            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left
              corner.
            - 'image': Use the value from :rc:`image.origin`.

        extent : (x0, x1, y0, y1), optional
            If *origin* is not *None*, then *extent* is interpreted as in
            `.imshow`: it gives the outer pixel boundaries. In this case, the
            position of Z[0, 0] is the center of the pixel, not a corner. If
            *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],
            and (*x1*, *y1*) is the position of Z[-1, -1].

            This argument is ignored if *X* and *Y* are specified in the call
            to contour.

        locator : ticker.Locator subclass, optional
            The locator is used to determine the contour levels if they
            are not given explicitly via *levels*.
            Defaults to `~.ticker.MaxNLocator`.

        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'
            Determines the ``contourf``-coloring of values that are outside the
            *levels* range.

            If 'neither', values outside the *levels* range are not colored.
            If 'min', 'max' or 'both', color the values below, above or below
            and above the *levels* range.

            Values below ``min(levels)`` and above ``max(levels)`` are mapped
            to the under/over values of the `.Colormap`. Note that most
            colormaps do not have dedicated colors for these by default, so
            that the over and under values are the edge values of the colormap.
            You may want to set these values explicitly using
            `.Colormap.set_under` and `.Colormap.set_over`.

            .. note::

                An existing `.QuadContourSet` does not get notified if
                properties of its colormap are changed. Therefore, an explicit
                call `.QuadContourSet.changed()` is needed after modifying the
                colormap. The explicit call can be left out, if a colorbar is
                assigned to the `.QuadContourSet` because it internally calls
                `.QuadContourSet.changed()`.

            Example::

                x = np.arange(1, 10)
                y = x.reshape(-1, 1)
                h = x * y

                cs = plt.contourf(h, levels=[10, 30, 50],
                    colors=['#808080', '#A0A0A0', '#C0C0C0'], extend='both')
                cs.cmap.set_over('red')
                cs.cmap.set_under('blue')
                cs.changed()

        xunits, yunits : registered units, optional
            Override axis units by specifying an instance of a
            :class:`matplotlib.units.ConversionInterface`.

        antialiased : bool, optional
            Enable antialiasing, overriding the defaults.  For
            filled contours, the default is *True*.  For line contours,
            it is taken from :rc:`lines.antialiased`.

        nchunk : int >= 0, optional
            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*.

        linewidths : float or array-like, default: :rc:`contour.linewidth`
            *Only applies to* `.contour`.

            The line width of the contour lines.

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

            If a sequence, the levels in ascending order will be plotted with
            the linewidths in the order specified.

            If None, this falls back to :rc:`lines.linewidth`.

        linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional
            *Only applies to* `.contour`.

            If *linestyles* is *None*, the default is 'solid' unless the lines
            are monochrome.  In that case, negative contours will take their
            linestyle from :rc:`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.

        hatches : List[str], optional
            *Only applies to* `.contourf`.

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

        Notes
        -----
        1. `.contourf` differs from the MATLAB version in that it does not draw
           the polygon edges. To draw edges, add line contours with calls to
           `.contour`.

        2. `.contourf` fills intervals that are closed at the top; that is, for
           boundaries *z1* and *z2*, the filled region is::

              z1 < Z <= z2

           except for the lowest interval, which is closed on both sides (i.e.
           it includes the lowest value).

    contourf(*args, data=None, **kwargs)
        Plot contours.

        Call signature::

            contour([X, Y,] Z, [levels], **kwargs)

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

        Parameters
        ----------
        X, Y : array-like, optional
            The coordinates of the values in *Z*.

            *X* and *Y* must both be 2-D with the same shape as *Z* (e.g.
            created via `numpy.meshgrid`), or they must both be 1-D such
            that ``len(X) == M`` is the number of columns in *Z* and
            ``len(Y) == N`` is the number of rows in *Z*.

            If not given, they are assumed to be integer indices, i.e.
            ``X = range(M)``, ``Y = range(N)``.

        Z : array-like(N, M)
            The height values over which the contour is drawn.

        levels : int or array-like, optional
            Determines the number and positions of the contour lines / regions.

            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries
            to automatically choose no more than *n+1* "nice" contour levels
            between *vmin* and *vmax*.

            If array-like, draw contour lines at the specified levels.
            The values must be in increasing order.

        Returns
        -------
        `~.contour.QuadContourSet`

        Other Parameters
        ----------------
        corner_mask : bool, default: :rc:`contour.corner_mask`
            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.

        colors : color string or sequence of colors, optional
            The colors of the levels, i.e. the lines for `.contour` and the
            areas for `.contourf`.

            The sequence is cycled for the levels in ascending order. If the
            sequence is shorter than the number of levels, it's repeated.

            As a shortcut, single color strings may be used in place of
            one-element lists, i.e. ``'red'`` instead of ``['red']`` to color
            all levels with the same color. This shortcut does only work for
            color strings, not for other ways of specifying colors.

            By default (value *None*), the colormap specified by *cmap*
            will be used.

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

        cmap : str or `.Colormap`, default: :rc:`image.cmap`
            A `.Colormap` instance or registered colormap name. The colormap
            maps the level values to colors.

            If both *colors* and *cmap* are given, an error is raised.

        norm : `~matplotlib.colors.Normalize`, optional
            If a colormap is used, the `.Normalize` instance scales the level
            values to the canonical colormap range [0, 1] for mapping to
            colors. If not given, the default linear scaling is used.

        vmin, vmax : float, optional
            If not *None*, either or both of these values will be supplied to
            the `.Normalize` instance, overriding the default color scaling
            based on *levels*.

        origin : {*None*, 'upper', 'lower', 'image'}, default: None
            Determines the orientation and exact position of *Z* by specifying
            the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*
            are not given.

            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.
            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.
            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left
              corner.
            - 'image': Use the value from :rc:`image.origin`.

        extent : (x0, x1, y0, y1), optional
            If *origin* is not *None*, then *extent* is interpreted as in
            `.imshow`: it gives the outer pixel boundaries. In this case, the
            position of Z[0, 0] is the center of the pixel, not a corner. If
            *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],
            and (*x1*, *y1*) is the position of Z[-1, -1].

            This argument is ignored if *X* and *Y* are specified in the call
            to contour.

        locator : ticker.Locator subclass, optional
            The locator is used to determine the contour levels if they
            are not given explicitly via *levels*.
            Defaults to `~.ticker.MaxNLocator`.

        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'
            Determines the ``contourf``-coloring of values that are outside the
            *levels* range.

            If 'neither', values outside the *levels* range are not colored.
            If 'min', 'max' or 'both', color the values below, above or below
            and above the *levels* range.

            Values below ``min(levels)`` and above ``max(levels)`` are mapped
            to the under/over values of the `.Colormap`. Note that most
            colormaps do not have dedicated colors for these by default, so
            that the over and under values are the edge values of the colormap.
            You may want to set these values explicitly using
            `.Colormap.set_under` and `.Colormap.set_over`.

            .. note::

                An existing `.QuadContourSet` does not get notified if
                properties of its colormap are changed. Therefore, an explicit
                call `.QuadContourSet.changed()` is needed after modifying the
                colormap. The explicit call can be left out, if a colorbar is
                assigned to the `.QuadContourSet` because it internally calls
                `.QuadContourSet.changed()`.

            Example::

                x = np.arange(1, 10)
                y = x.reshape(-1, 1)
                h = x * y

                cs = plt.contourf(h, levels=[10, 30, 50],
                    colors=['#808080', '#A0A0A0', '#C0C0C0'], extend='both')
                cs.cmap.set_over('red')
                cs.cmap.set_under('blue')
                cs.changed()

        xunits, yunits : registered units, optional
            Override axis units by specifying an instance of a
            :class:`matplotlib.units.ConversionInterface`.

        antialiased : bool, optional
            Enable antialiasing, overriding the defaults.  For
            filled contours, the default is *True*.  For line contours,
            it is taken from :rc:`lines.antialiased`.

        nchunk : int >= 0, optional
            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*.

        linewidths : float or array-like, default: :rc:`contour.linewidth`
            *Only applies to* `.contour`.

            The line width of the contour lines.

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

            If a sequence, the levels in ascending order will be plotted with
            the linewidths in the order specified.

            If None, this falls back to :rc:`lines.linewidth`.

        linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional
            *Only applies to* `.contour`.

            If *linestyles* is *None*, the default is 'solid' unless the lines
            are monochrome.  In that case, negative contours will take their
            linestyle from :rc:`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.

        hatches : List[str], optional
            *Only applies to* `.contourf`.

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

        Notes
        -----
        1. `.contourf` differs from the MATLAB version in that it does not draw
           the polygon edges. To draw edges, add line contours with calls to
           `.contour`.

        2. `.contourf` fills intervals that are closed at the top; that is, for
           boundaries *z1* and *z2*, the filled region is::

              z1 < Z <= z2

           except for the lowest interval, which is closed on both sides (i.e.
           it includes the lowest value).

    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, *, data=None, **kwargs)
        Plot the cross-spectral density.

        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 : float, default: 2
            The sampling frequency (samples per time unit).  It is used to calculate
            the Fourier frequencies, *freqs*, in cycles per time unit.

        window : callable or ndarray, default: `.window_hanning`
            A function or a vector of length *NFFT*.  To create window vectors see
            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
            function is passed as the argument, it must take a data segment as an
            argument and return the windowed version of the segment.

        sides : {'default', 'onesided', 'twosided'}, optional
            Which sides of the spectrum to return. 'default' is one-sided for real
            data and two-sided for complex data. 'onesided' forces the return of a
            one-sided spectrum, while 'twosided' forces two-sided.

        pad_to : int, optional
            The number of points to which the data segment is padded when performing
            the FFT.  This can be different from *NFFT*, which specifies the number
            of data points used.  While not increasing the actual resolution of the
            spectrum (the minimum distance between resolvable peaks), this can give
            more points in the plot, allowing for more detail. This corresponds to
            the *n* parameter in the call to fft(). The default is None, which sets
            *pad_to* equal to *NFFT*

        NFFT : int, default: 256
            The number of data points used in each block for the FFT.  A power 2 is
            most efficient.  This should *NOT* be used to get zero padding, or the
            scaling of the result will be incorrect; use *pad_to* for this instead.

        detrend : {'none', 'mean', 'linear'} or callable, default 'none'
            The function applied to each segment before fft-ing, designed to remove
            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter
            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`
            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,
            but you can use a custom function as well.  You can also use a string to
            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls
            `.detrend_mean`. 'linear' calls `.detrend_linear`.

        scale_by_freq : bool, default: True
            Whether the resulting density values should be scaled by the scaling
            frequency, which gives density in units of Hz^-1.  This allows for
            integration over the returned frequency values.  The default is True for
            MATLAB compatibility.

        noverlap : int, default: 0 (no overlap)
            The number of points of overlap between segments.

        Fc : int, default: 0
            The center frequency of *x*, which offsets the x extents of the
            plot to reflect the frequency range used when a signal is acquired
            and then filtered and downsampled to baseband.

        return_line : bool, default: False
            Whether to include the line object plotted in the returned values.

        Returns
        -------
        Pxy : 1-D array
            The values for the cross spectrum :math:`P_{xy}` before scaling
            (complex valued).

        freqs : 1-D array
            The frequencies corresponding to the elements in *Pxy*.

        line : `~matplotlib.lines.Line2D`
            The line created by this function.
            Only returned if *return_line* is True.

        Other Parameters
        ----------------
        **kwargs
            Keyword arguments control the `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        psd : is equivalent to setting ``y = x``.

        Notes
        -----
        For plotting, the power is plotted as
        :math:`10 \log_{10}(P_{xy})` for decibels, though :math:`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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    delaxes(ax=None)
        Remove an `~.axes.Axes` (defaulting to the current axes) from its figure.

    disconnect(cid)
        Disconnect the callback with id *cid*.

        Examples
        --------
        ::

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

        This is equivalent to calling ``fig.canvas.draw_idle()``, where ``fig`` is
        the current figure.

    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, *, 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 : float or array-like
            The data positions.

        xerr, yerr : float 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 bar. First row
              contains the lower errors, the second row contains the upper
              errors.
            - *None*: No errorbar.

            Note that all error arrays should have *positive* values.

            See :doc:`/gallery/statistics/errorbar_features`
            for an example on the usage of ``xerr`` and ``yerr``.

        fmt : str, 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 : color, default: None
            The color of the errorbar lines.  If None, use the color of the
            line connecting the markers.

        elinewidth : float, default: None
            The linewidth of the errorbar lines. If None, the linewidth of
            the current style is used.

        capsize : float, default: :rc:`errorbar.capsize`
            The length of the error bar caps in points.

        capthick : float, 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, default: False
            If True, will plot the errorbars above the plot
            symbols. Default is below.

        lolims, uplims, xlolims, xuplims : bool, default: False
            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 scalars, or array-likes of
            the same length as *xerr* and *yerr*.  To use limits with inverted
            axes, `~.Axes.set_xlim` or `~.Axes.set_ylim` must be called before
            :meth:`errorbar`.  Note the tricky parameter names: setting e.g.
            *lolims* to True means that the y-value is a *lower* limit of the
            True value, so, only an *upward*-pointing arrow will be drawn!

        errorevery : int or (int, int), default: 1
            draws error bars on a subset of the data. *errorevery* =N draws
            error bars on the points (x[::N], y[::N]).
            *errorevery* =(start, N) draws error bars on the points
            (x[start::N], y[start::N]). e.g. errorevery=(6, 3)
            adds error bars to the data at (x[6], x[9], x[12], x[15], ...).
            Used to avoid overlapping error bars when two series share x-axis
            values.

        Returns
        -------
        `.ErrorbarContainer`
            The container contains:

            - plotline: `.Line2D` instance of x, y plot markers and/or line.
            - caplines: A tuple of `.Line2D` instances of the error bar caps.
            - barlinecols: A tuple of `.LineCollection` with the horizontal and
              vertical error ranges.

        Other Parameters
        ----------------
        **kwargs
            All other keyword arguments are passed on to the `~.Axes.plot` call
            drawing 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 `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*, *xerr*, *yerr*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    eventplot(positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, linestyles='solid', *, data=None, **kwargs)
        Plot identical parallel lines at the given positions.

        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 : array-like or list of array-like
            A 1D array-like defines the positions of one sequence of events.

            Multiple groups of events may be passed as a list of array-likes.
            Each group can be styled independently by passing lists of values
            to *lineoffsets*, *linelengths*, *linewidths*, *colors* and
            *linestyles*.

            Note that *positions* can be a 2D array, but in practice different
            event groups usually have different counts so that one will use a
            list of different-length arrays rather than a 2D array.

        orientation : {'horizontal', 'vertical'}, default: 'horizontal'
            The direction of the event sequence:

            - 'horizontal': the events are arranged horizontally.
              The indicator lines are vertical.
            - 'vertical': the events are arranged vertically.
              The indicator lines are horizontal.

        lineoffsets : float or array-like, default: 1
            The offset of the center of the lines from the origin, in the
            direction orthogonal to *orientation*.

            If *positions* is 2D, this can be a sequence with length matching
            the length of *positions*.

        linelengths : float or array-like, default: 1
            The total height of the lines (i.e. the lines stretches from
            ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).

            If *positions* is 2D, this can be a sequence with length matching
            the length of *positions*.

        linewidths : float or array-like, default: :rc:`lines.linewidth`
            The line width(s) of the event lines, in points.

            If *positions* is 2D, this can be a sequence with length matching
            the length of *positions*.

        colors : color or list of colors, default: :rc:`lines.color`
            The color(s) of the event lines.

            If *positions* is 2D, this can be a sequence with length matching
            the length of *positions*.

        linestyles : str or tuple or list of such values, default: 'solid'
            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.

            If *positions* is 2D, this can be a sequence with length matching
            the length of *positions*.

        **kwargs
            Other keyword arguments are line collection properties.  See
            `.LineCollection` for a list of the valid properties.

        Returns
        -------
        list of `.EventCollection`
            The `.EventCollection` 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *positions*, *lineoffsets*, *linelengths*, *linewidths*, *colors*, *linestyles*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    figimage(X, xo=0, yo=0, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, origin=None, resize=False, **kwargs)
        Add a non-resampled image to the figure.

        The image is attached to the lower or upper left corner depending on
        *origin*.

        Parameters
        ----------
        X
            The image data. This is an array of one of the following shapes:

            - MxN: luminance (grayscale) values
            - MxNx3: RGB values
            - MxNx4: RGBA values

        xo, yo : int
            The *x*/*y* image offset in pixels.

        alpha : None or float
            The alpha blending value.

        norm : `matplotlib.colors.Normalize`
            A `.Normalize` instance to map the luminance to the
            interval [0, 1].

        cmap : str or `matplotlib.colors.Colormap`, default: :rc:`image.cmap`
            The colormap to use.

        vmin, vmax : float
            If *norm* is not given, these values set the data limits for the
            colormap.

        origin : {'upper', 'lower'}, default: :rc:`image.origin`
            Indicates where the [0, 0] index of the array is in the upper left
            or lower left corner of the axes.

        resize : bool
            If *True*, resize the figure to match the given image size.

        Returns
        -------
        `matplotlib.image.FigureImage`

        Other Parameters
        ----------------
        **kwargs
            Additional kwargs are `.Artist` kwargs passed on to `.FigureImage`.

        Notes
        -----
        figimage complements the axes image (`~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
        `~matplotlib.axes.Axes` with extent [0, 0, 1, 1].

        Examples
        --------
        ::

            f = plt.figure()
            nx = int(f.get_figwidth() * f.dpi)
            ny = int(f.get_figheight() * f.dpi)
            data = np.random.random((ny, nx))
            f.figimage(data)
            plt.show()

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

        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'),
              loc='upper right')

        These can also be specified by keyword::

          figlegend(
              handles=(line1, line2, line3),
              labels=('label1', 'label2', 'label3'),
              loc='upper right')

        Parameters
        ----------
        handles : list 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 : list of str, optional
            A list of labels to show next to the artists.
            Use this together with *handles*, if you need full control on what
            is shown in the legend and the automatic mechanism described above
            is not sufficient.

        Returns
        -------
        `~matplotlib.legend.Legend`

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

        loc : str or pair of floats, default: :rc:`legend.loc` ('best' for axes, 'upper right' for figures)
            The location of the legend.

            The strings
            ``'upper left', 'upper right', 'lower left', 'lower right'``
            place the legend at the corresponding corner of the axes/figure.

            The strings
            ``'upper center', 'lower center', 'center left', 'center right'``
            place the legend at the center of the corresponding edge of the
            axes/figure.

            The string ``'center'`` places the legend at the center of the axes/figure.

            The string ``'best'`` places the legend at the location, among the nine
            locations defined so far, with the minimum overlap with other drawn
            artists.  This option can be quite slow for plots with large amounts of
            data; your plotting speed may benefit from providing a specific location.

            The location can also be a 2-tuple giving the coordinates of the lower-left
            corner of the legend in axes coordinates (in which case *bbox_to_anchor*
            will be ignored).

            For back-compatibility, ``'center right'`` (but no other location) can also
            be spelled ``'right'``, and each "string" locations can also be given as a
            numeric value:

                ===============   =============
                Location String   Location Code
                ===============   =============
                'best'            0
                'upper right'     1
                'upper left'      2
                'lower left'      3
                'lower right'     4
                'right'           5
                'center left'     6
                'center right'    7
                'lower center'    8
                'upper center'    9
                'center'          10
                ===============   =============

        bbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats
            Box that is used to position the legend in conjunction with *loc*.
            Defaults to `axes.bbox` (if called as a method to `.Axes.legend`) or
            `figure.bbox` (if `.Figure.legend`).  This argument allows arbitrary
            placement of the legend.

            Bbox coordinates are interpreted in the coordinate system given by
            *bbox_transform*, with the default transform
            Axes or Figure coordinates, depending on which ``legend`` is called.

            If a 4-tuple or `.BboxBase` is given, then it specifies the bbox
            ``(x, y, width, height)`` that the legend is placed in.
            To put the legend in the best location in the bottom right
            quadrant of the axes (or figure)::

                loc='best', bbox_to_anchor=(0.5, 0., 0.5, 0.5)

            A 2-tuple ``(x, y)`` places the corner of the legend specified by *loc* at
            x, y.  For example, to put the legend's upper right-hand corner in the
            center of the axes (or figure) the following keywords can be used::

                loc='upper right', bbox_to_anchor=(0.5, 0.5)

        ncol : int, default: 1
            The number of columns that the legend has.

        prop : None or `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 {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}
            The font size of the legend. If the value is numeric the size will be the
            absolute font size in points. String values are relative to the current
            default font size. This argument is only used if *prop* is not specified.

        labelcolor : str or list
            Sets the color of the text in the legend. Can be a valid color string
            (for example, 'red'), or a list of color strings. The labelcolor can
            also be made to match the color of the line or marker using 'linecolor',
            'markerfacecolor' (or 'mfc'), or 'markeredgecolor' (or 'mec').

        numpoints : int, default: :rc:`legend.numpoints`
            The number of marker points in the legend when creating a legend
            entry for a `.Line2D` (line).

        scatterpoints : int, default: :rc:`legend.scatterpoints`
            The number of marker points in the legend when creating
            a legend entry for a `.PathCollection` (scatter plot).

        scatteryoffsets : iterable of floats, default: ``[0.375, 0.5, 0.3125]``
            The vertical offset (relative to the font size) for the markers
            created for a scatter plot legend entry. 0.0 is at the base the
            legend text, and 1.0 is at the top. To draw all markers at the
            same height, set to ``[0.5]``.

        markerscale : float, default: :rc:`legend.markerscale`
            The relative size of legend markers compared with the originally
            drawn ones.

        markerfirst : bool, default: True
            If *True*, legend marker is placed to the left of the legend label.
            If *False*, legend marker is placed to the right of the legend label.

        frameon : bool, default: :rc:`legend.frameon`
            Whether the legend should be drawn on a patch (frame).

        fancybox : bool, default: :rc:`legend.fancybox`
            Whether round edges should be enabled around the `~.FancyBboxPatch` which
            makes up the legend's background.

        shadow : bool, default: :rc:`legend.shadow`
            Whether to draw a shadow behind the legend.

        framealpha : float, default: :rc:`legend.framealpha`
            The alpha transparency of the legend's background.
            If *shadow* is activated and *framealpha* is ``None``, the default value is
            ignored.

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

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

        mode : {"expand", None}
            If *mode* is set to ``"expand"`` the legend will be horizontally
            expanded to fill the axes area (or *bbox_to_anchor* if defines
            the legend's size).

        bbox_transform : None or `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``).

        title_fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default: :rc:`legend.title_fontsize`
            The font size of the legend's title.

        borderpad : float, default: :rc:`legend.borderpad`
            The fractional whitespace inside the legend border, in font-size units.

        labelspacing : float, default: :rc:`legend.labelspacing`
            The vertical space between the legend entries, in font-size units.

        handlelength : float, default: :rc:`legend.handlelength`
            The length of the legend handles, in font-size units.

        handletextpad : float, default: :rc:`legend.handletextpad`
            The pad between the legend handle and text, in font-size units.

        borderaxespad : float, default: :rc:`legend.borderaxespad`
            The pad between the axes and legend border, in font-size units.

        columnspacing : float, default: :rc:`legend.columnspacing`
            The spacing between columns, in font-size units.

        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 `matplotlib.legend.Legend.get_legend_handler_map`.

        Notes
        -----
        Some artists are not supported by this function.  See
        :doc:`/tutorials/intermediate/legend_guide` for details.

    fignum_exists(num)
        Return whether the figure with the given id exists.

    figtext(x, y, s, fontdict=None, **kwargs)
        Add text to figure.

        Parameters
        ----------
        x, y : float
            The position to place the text. By default, this is in figure
            coordinates, floats in [0, 1]. The coordinate system can be changed
            using the *transform* keyword.

        s : str
            The text string.

        fontdict : dict, optional
            A dictionary to override the default text properties. If not given,
            the defaults are determined by :rc:`font.*`. Properties passed as
            *kwargs* override the corresponding ones given in *fontdict*.

        Returns
        -------
        `~.text.Text`

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.text.Text` properties
            Other miscellaneous text parameters.

            Properties:
            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
            alpha: float or None
            animated: bool
            backgroundcolor: color
            bbox: dict with properties for `.patches.FancyBboxPatch`
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            figure: `.Figure`
            fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}
            fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`
            fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}
            fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}
            fontstyle or style: {'normal', 'italic', 'oblique'}
            fontvariant or variant: {'normal', 'small-caps'}
            fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}
            gid: str
            horizontalalignment or ha: {'center', 'right', 'left'}
            in_layout: bool
            label: object
            linespacing: float (multiple of font size)
            multialignment or ma: {'left', 'right', 'center'}
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            position: (float, float)
            rasterized: bool or None
            rotation: float or {'vertical', 'horizontal'}
            rotation_mode: {None, 'default', 'anchor'}
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            text: object
            transform: `.Transform`
            url: str
            usetex: bool or None
            verticalalignment or va: {'center', 'top', 'bottom', 'baseline', 'center_baseline'}
            visible: bool
            wrap: bool
            x: float
            y: float
            zorder: float

        See Also
        --------
        .Axes.text
        .pyplot.text

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

        Parameters
        ----------
        num : int or str, optional
            A unique identifier for the figure.

            If a figure with that identifier already exists, this figure is made
            active and returned. An integer refers to the ``Figure.number``
            attribute, a string refers to the figure label.

            If there is no figure with the identifier or *num* is not given, a new
            figure is created, made active and returned.  If *num* is an int, it
            will be used for the ``Figure.number`` attribute, otherwise, an
            auto-generated integer value is used (starting at 1 and incremented
            for each new figure). If *num* is a string, the figure label and the
            window title is set to this value.

        figsize : (float, float), default: :rc:`figure.figsize`
            Width, height in inches.

        dpi : float, default: :rc:`figure.dpi`
            The resolution of the figure in dots-per-inch.

        facecolor : color, default: :rc:`figure.facecolor`
            The background color.

        edgecolor : color, default: :rc:`figure.edgecolor`
            The border color.

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

        FigureClass : subclass of `~matplotlib.figure.Figure`
            Optionally use a custom `.Figure` instance.

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

        tight_layout : bool or dict, default: :rc:`figure.autolayout`
            If ``False`` use *subplotpars*. If ``True`` adjust subplot
            parameters using `.tight_layout` with default padding.
            When providing a dict containing the keys ``pad``, ``w_pad``,
            ``h_pad``, and ``rect``, the default `.tight_layout` paddings
            will be overridden.

        constrained_layout : bool, default: :rc:`figure.constrained_layout.use`
            If ``True`` use constrained layout to adjust positioning of plot
            elements.  Like ``tight_layout``, but designed to be more
            flexible.  See
            :doc:`/tutorials/intermediate/constrainedlayout_guide`
            for examples.  (Note: does not work with `add_subplot` or
            `~.pyplot.subplot2grid`.)

        **kwargs : optional
            See `~.matplotlib.figure.Figure` for other possible arguments.

        Returns
        -------
        `~matplotlib.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 pyplot interface. Additional kwargs will be
            passed to the `.Figure` init function.

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

        `~matplotlib.rcParams` defines the default values, which can be modified
        in the matplotlibrc file.

    fill(*args, data=None, **kwargs)
        Plot filled polygons.

        Parameters
        ----------
        *args : sequence of x, y, [color]
            Each polygon is defined by the lists of *x* and *y* positions of
            its nodes, optionally followed by 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

        data : indexable object, optional
            An object with labelled data. If given, provide the label names to
            plot in *x* and *y*, e.g.::

                ax.fill("time", "signal",
                        data={"time": [0, 1, 2], "signal": [0, 1, 0]})

        Returns
        -------
        list of `~matplotlib.patches.Polygon`

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.patches.Polygon` properties

        Notes
        -----
        Use :meth:`fill_between` if you would like to fill the region between
        two curves.

    fill_between(x, y1, y2=0, where=None, interpolate=False, step=None, *, data=None, **kwargs)
        Fill the area between two horizontal curves.

        The curves are defined by the points (*x*, *y1*) and (*x*,
        *y2*).  This creates one or multiple polygons describing the filled
        area.

        You may exclude some horizontal sections from filling using *where*.

        By default, the edges connect the given points directly.  Use *step*
        if the filling should be a step function, i.e. constant in between
        *x*.

        Parameters
        ----------
        x : array (length N)
            The x coordinates of the nodes defining the curves.

        y1 : array (length N) or scalar
            The y coordinates of the nodes defining the first curve.

        y2 : array (length N) or scalar, default: 0
            The y coordinates of the nodes defining the second curve.

        where : array of bool (length N), optional
            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, default: False
            This option is only relevant 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 intersection are
            simply clipped.

            Setting *interpolate* to *True* will calculate the actual
            intersection 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.

        Returns
        -------
        `.PolyCollection`
            A `.PolyCollection` containing the plotted polygons.

        Other Parameters
        ----------------
        **kwargs
            All other keyword arguments are passed on to `.PolyCollection`.
            They control the `.Polygon` properties:

            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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

        See Also
        --------
        fill_between : Fill between two sets of y-values.
        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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y1*, *y2*, *where*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    fill_betweenx(y, x1, x2=0, where=None, step=None, interpolate=False, *, data=None, **kwargs)
        Fill the area between two vertical curves.

        The curves are defined by the points (*y*, *x1*) and (*y*,
        *x2*).  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, default: 0
            The x coordinates of the nodes defining the second curve.

        where : array of bool (length N), optional
            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, default: False
            This option is only relevant 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 intersection are
            simply clipped.

            Setting *interpolate* to *True* will calculate the actual
            intersection 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.

        Returns
        -------
        `.PolyCollection`
            A `.PolyCollection` containing the plotted polygons.

        Other Parameters
        ----------------
        **kwargs
            All other keyword arguments are passed on to `.PolyCollection`.
            They control the `.Polygon` properties:

            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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

        See Also
        --------
        fill_between : Fill between two sets of y-values.
        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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *y*, *x1*, *x2*, *where*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    findobj(o=None, match=None, include_self=True)
        Find artist objects.

        Recursively find all `.Artist` instances contained in the artist.

        Parameters
        ----------
        match
            A filter criterion for the matches. This can be

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

        include_self : bool
            Include *self* in the list to be checked for a match.

        Returns
        -------
        list of `.Artist`

    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 axes, creating one if necessary.

        The following kwargs are supported for ensuring the returned axes
        adheres to the given projection etc., and for axes creation if
        the active axes does not exist:

        Properties:
            adjustable: {'box', 'datalim'}
            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
            alpha: float or None
            anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}
            animated: bool
            aspect: {'auto'} or num
            autoscale_on: bool
            autoscalex_on: bool
            autoscaley_on: bool
            axes_locator: Callable[[Axes, Renderer], Bbox]
            axisbelow: bool or 'line'
            box_aspect: None, or a number
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            contains: unknown
            facecolor or fc: color
            figure: `.Figure`
            frame_on: bool
            gid: str
            in_layout: bool
            label: object
            navigate: bool
            navigate_mode: unknown
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`
            prop_cycle: unknown
            rasterization_zorder: float or None
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            title: str
            transform: `.Transform`
            url: str
            visible: bool
            xbound: unknown
            xlabel: str
            xlim: (bottom: float, top: float)
            xmargin: float greater than -0.5
            xscale: {"linear", "log", "symlog", "logit", ...}
            xticklabels: unknown
            xticks: unknown
            ybound: unknown
            ylabel: str
            ylim: (bottom: float, top: float)
            ymargin: float greater than -0.5
            yscale: {"linear", "log", "symlog", "logit", ...}
            yticklabels: unknown
            yticks: unknown
            zorder: float

    gcf()
        Get the current figure.

        If no current figure exists, a new one is created using
        `~.pyplot.figure()`.

    gci()
        Get the current colorable artist.

        Specifically, returns the current `.ScalarMappable` instance (`.Image`
        created by `imshow` or `figimage`, `.Collection` created by `pcolor` or
        `scatter`, etc.), or *None* if no such instance has been defined.

        The current image is an attribute of the current axes, or the nearest
        earlier axes in the current figure that contains an image.

        Notes
        -----
        Historically, the only colorable artists were images; hence the name
        ``gci`` (get current image).

    get(obj, *args, **kwargs)
        Return the value of an object's *property*, or print all of them.

        Parameters
        ----------
        obj : `.Artist`
            The queried artist; e.g., a `.Line2D`, a `.Text`, or an `~.axes.Axes`.

        property : str or None, default: None
            If *property* is 'somename', this function returns
            ``obj.get_somename()``.

            If is is None (or unset), it *prints* all gettable properties from
            *obj*.  Many properties have aliases for shorter typing, e.g. 'lw' is
            an alias for 'linewidth'.  In the output, aliases and full property
            names will be listed as:

              property or alias = value

            e.g.:

              linewidth or lw = 2

    get_current_fig_manager()
        Return the figure manager of the current figure.

        The figure manager is a container for the actual backend-depended window
        that displays the figure on screen.

        If if no current figure exists, a new one is created an its figure
        manager is returned.

        Returns
        -------
        `.FigureManagerBase` or backend-dependent subclass thereof

    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.

    getp(obj, *args, **kwargs)
        Return the value of an object's *property*, or print all of them.

        Parameters
        ----------
        obj : `.Artist`
            The queried artist; e.g., a `.Line2D`, a `.Text`, or an `~.axes.Axes`.

        property : str or None, default: None
            If *property* is 'somename', this function returns
            ``obj.get_somename()``.

            If is is None (or unset), it *prints* all gettable properties from
            *obj*.  Many properties have aliases for shorter typing, e.g. 'lw' is
            an alias for 'linewidth'.  In the output, aliases and full property
            names will be listed as:

              property or alias = value

            e.g.:

              linewidth or lw = 2

    ginput(n=1, timeout=30, show_clicks=True, mouse_add=<MouseButton.LEFT: 1>, mouse_pop=<MouseButton.RIGHT: 3>, mouse_stop=<MouseButton.MIDDLE: 2>)
        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.

        There are three possible interactions:

        - Add a point.
        - Remove the most recently added point.
        - Stop the interaction and return the points added so far.

        The actions are assigned to mouse buttons via the arguments
        *mouse_add*, *mouse_pop* and *mouse_stop*.

        Parameters
        ----------
        n : int, default: 1
            Number of mouse clicks to accumulate. If negative, accumulate
            clicks until the input is terminated manually.
        timeout : float, default: 30 seconds
            Number of seconds to wait before timing out. If zero or negative
            will never timeout.
        show_clicks : bool, default: True
            If True, show a red cross at the location of each click.
        mouse_add : `.MouseButton` or None, default: `.MouseButton.LEFT`
            Mouse button used to add points.
        mouse_pop : `.MouseButton` or None, default: `.MouseButton.RIGHT`
            Mouse button used to remove the most recently added point.
        mouse_stop : `.MouseButton` or None, default: `.MouseButton.MIDDLE`
            Mouse button used to stop input.

        Returns
        -------
        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)
        Configure the grid lines.

        Parameters
        ----------
        b : bool or None, optional
            Whether to show the grid lines. If any *kwargs* are supplied,
            it is assumed you want the grid on and *b* will be set to True.

            If *b* is *None* and there are no *kwargs*, this toggles the
            visibility of the lines.

        which : {'major', 'minor', 'both'}, optional
            The grid lines to apply the changes on.

        axis : {'both', 'x', 'y'}, optional
            The axis to apply the changes on.

        **kwargs : `.Line2D` properties
            Define the line properties of the grid, e.g.::

                grid(color='r', linestyle='-', linewidth=2)

            Valid keyword arguments are:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        Notes
        -----
        The axis is drawn as a unit, so the effective zorder for drawing the
        grid is determined by the zorder of each axis, not by the zorder of the
        `.Line2D` objects comprising the grid.  Therefore, to set grid zorder,
        use `.set_axisbelow` or, for more control, call the
        `~.Artist.set_zorder` method of each axis.

    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 0x0000025DCBBBB5E0>, mincnt=None, marginals=False, *, data=None, **kwargs)
        Make a 2D hexagonal binning plot of points *x*, *y*.

        If *C* is *None*, the value of the hexagon is determined by the number
        of points in the hexagon. Otherwise, *C* specifies values at the
        coordinate (x[i], y[i]). For each hexagon, these values are reduced
        using *reduce_C_function*.

        Parameters
        ----------
        x, y : array-like
            The data positions. *x* and *y* must be of the same length.

        C : array-like, optional
            If given, these values are accumulated in the bins. Otherwise,
            every point has a value of 1. Must be of the same length as *x*
            and *y*.

        gridsize : int or (int, int), default: 100
            If a single int, the number of hexagons in the *x*-direction.
            The number of hexagons in the *y*-direction is chosen such that
            the hexagons are approximately regular.

            Alternatively, if a tuple (*nx*, *ny*), the number of hexagons
            in the *x*-direction and the *y*-direction.

        bins : 'log' or int or sequence, default: None
            Discretization of the hexagon values.

            - If *None*, no binning is applied; the color of each hexagon
              directly corresponds to its count value.
            - If 'log', use a logarithmic scale for the color map.
              Internally, :math:`log_{10}(i+1)` is used to determine the
              hexagon color. This is equivalent to ``norm=LogNorm()``.
            - If an integer, divide the counts in the specified number
              of bins, and color the hexagons accordingly.
            - If a sequence of values, the values of the lower bound of
              the bins to be used.

        xscale : {'linear', 'log'}, default: 'linear'
            Use a linear or log10 scale on the horizontal axis.

        yscale : {'linear', 'log'}, default: 'linear'
            Use a linear or log10 scale on the vertical axis.

        mincnt : int > 0, default: *None*
            If not *None*, only display cells with more than *mincnt*
            number of points in the cell.

        marginals : bool, default: *False*
            If marginals is *True*, plot the marginal density as
            colormapped rectangles along the bottom of the x-axis and
            left of the y-axis.

        extent : float, default: *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).

        Returns
        -------
        `~matplotlib.collections.PolyCollection`
            A `.PolyCollection` defining the hexagonal bins.

            - `.PolyCollection.get_offsets` contains a Mx2 array containing
              the x, y positions of the M hexagon centers.
            - `.PolyCollection.get_array` contains the values of the M
              hexagons.

            If *marginals* is *True*, horizontal
            bar and vertical bar (both PolyCollections) will be attached
            to the return collection as attributes *hbar* and *vbar*.

        Other Parameters
        ----------------
        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
            The Colormap instance or registered colormap name used to map
            the bin values to colors.

        norm : `~matplotlib.colors.Normalize`, optional
            The Normalize instance scales the bin values to the canonical
            colormap range [0, 1] for mapping to colors. By default, the data
            range is mapped to the colorbar range using linear scaling.

        vmin, vmax : float, default: None
            The colorbar range. If *None*, suitable min/max values are
            automatically chosen by the `~.Normalize` instance (defaults to
            the respective min/max values of the bins in case of the default
            linear scaling).
            It is deprecated to use *vmin*/*vmax* when *norm* is given.

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

        linewidths : float, default: *None*
            If *None*, defaults to 1.0.

        edgecolors : {'face', 'none', *None*} or color, default: 'face'
            The color of the hexagon edges. Possible values are:

            - 'face': Draw the edges in the same color as the fill color.
            - 'none': No edges are drawn. This can sometimes lead to unsightly
              unpainted pixels between the hexagons.
            - *None*: Draw outlines in the default color.
            - An explicit color.

        reduce_C_function : callable, default: `numpy.mean`
            The function to aggregate *C* within the bins. It is ignored if
            *C* is not given. This must have the signature::

                def reduce_C_function(C: array) -> float

            Commonly used functions are:

            - `numpy.mean`: average of the points
            - `numpy.sum`: integral of the point values
            - `numpy.max`: value taken from the largest point

        **kwargs : `~matplotlib.collections.PolyCollection` properties
            All other keyword arguments are passed on to `.PolyCollection`:

            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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    hist(x, bins=None, range=None, density=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, *, data=None, **kwargs)
        Plot a histogram.

        Compute and draw the histogram of *x*.  The return value is a tuple
        (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*,
        *patches1*, ...]) if the input contains multiple data.  See the
        documentation of the *weights* parameter to draw a histogram of
        already-binned data.

        Multiple data can be provided via *x* as a list of datasets
        of potentially different length ([*x0*, *x1*, ...]), or as
        a 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.

        The *bins*, *range*, *weights*, and *density* parameters behave as in
        `numpy.histogram`.

        Parameters
        ----------
        x : (n,) array or sequence of (n,) arrays
            Input values, this takes either a single array or a sequence of
            arrays which are not required to be of the same length.

        bins : int or sequence or str, default: :rc:`hist.bins`
            If *bins* is an integer, it defines the number of equal-width bins
            in the range.

            If *bins* is a sequence, it defines the bin edges, including the
            left edge of the first bin and the right edge of the last bin;
            in this case, bins may be unequally spaced.  All but the last
            (righthand-most) bin is half-open.  In other words, if *bins* is::

                [1, 2, 3, 4]

            then the first bin is ``[1, 2)`` (including 1, but excluding 2) and
            the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which
            *includes* 4.

            If *bins* is a string, it is one of the binning strategies
            supported by `numpy.histogram_bin_edges`: 'auto', 'fd', 'doane',
            'scott', 'stone', 'rice', 'sturges', or 'sqrt'.

        range : tuple or None, default: None
            The lower and upper range of the bins. Lower and upper outliers
            are ignored. If not provided, *range* is ``(x.min(), x.max())``.
            Range has no effect if *bins* is a sequence.

            If *bins* is a sequence or *range* is specified, autoscaling
            is based on the specified bin range instead of the
            range of x.

        density : bool, default: False
            If ``True``, draw and return a probability density: each bin
            will display the bin's raw count divided by the total number of
            counts *and the bin width*
            (``density = counts / (sum(counts) * np.diff(bins))``),
            so that the area under the histogram integrates to 1
            (``np.sum(density * np.diff(bins)) == 1``).

            If *stacked* is also ``True``, the sum of the histograms is
            normalized to 1.

        weights : (n,) array-like or None, default: None
            An array of weights, of the same shape as *x*.  Each value in
            *x* only contributes its associated weight towards the bin count
            (instead of 1).  If *density* is ``True``, the weights are
            normalized, so that the integral of the density over the range
            remains 1.

            This parameter can be used to draw a histogram of data that has
            already been binned, e.g. using `numpy.histogram` (by treating each
            bin as a single point with a weight equal to its count) ::

                counts, bins = np.histogram(data)
                plt.hist(bins[:-1], bins, weights=counts)

            (or you may alternatively use `~.bar()`).

        cumulative : bool or -1, default: False
            If ``True``, then a histogram is computed where each bin gives the
            counts in that bin plus all bins for smaller values. The last bin
            gives the total number of datapoints.

            If *density* is also ``True`` then the histogram is normalized such
            that the last bin equals 1.

            If *cumulative* is a number less than 0 (e.g., -1), the direction
            of accumulation is reversed.  In this case, if *density* is also
            ``True``, then the histogram is normalized such that the first bin
            equals 1.

        bottom : array-like, scalar, or None, default: None
            Location of the bottom of each bin, ie. bins are drawn from
            ``bottom`` to ``bottom + hist(x, bins)`` If a scalar, the bottom
            of each bin is shifted by the same amount. If an array, each bin
            is shifted independently and the length of bottom must match the
            number of bins. If None, defaults to 0.

        histtype : {'bar', 'barstacked', 'step', 'stepfilled'}, default: 'bar'
            The type of histogram to draw.

            - 'bar' is a traditional bar-type histogram.  If multiple data
              are given the bars are arranged side by side.
            - 'barstacked' is a bar-type histogram where multiple
              data are stacked on top of each other.
            - 'step' generates a lineplot that is by default unfilled.
            - 'stepfilled' generates a lineplot that is by default filled.

        align : {'left', 'mid', 'right'}, default: 'mid'
            The horizontal alignment of the histogram bars.

            - 'left': bars are centered on the left bin edges.
            - 'mid': bars are centered between the bin edges.
            - 'right': bars are centered on the right bin edges.

        orientation : {'vertical', 'horizontal'}, default: 'vertical'
            If 'horizontal', `~.Axes.barh` will be used for bar-type histograms
            and the *bottom* kwarg will be the left edges.

        rwidth : float or None, default: None
            The relative width of the bars as a fraction of the bin width.  If
            ``None``, automatically compute the width.

            Ignored if *histtype* is 'step' or 'stepfilled'.

        log : bool, default: False
            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.

        color : color or array-like of colors or None, default: None
            Color or sequence of colors, one per dataset.  Default (``None``)
            uses the standard line color sequence.

        label : str or None, default: None
            String, or sequence of strings to match multiple datasets.  Bar
            charts yield multiple patches per dataset, but only the first gets
            the label, so that `~.Axes.legend` will work as expected.

        stacked : bool, default: False
            If ``True``, multiple data are stacked on top of each other If
            ``False`` multiple data are arranged side by side if histtype is
            'bar' or on top of each other if histtype is 'step'

        Returns
        -------
        n : array or list of arrays
            The values of the histogram bins. See *density* and *weights* for a
            description of the possible semantics.  If input *x* is an array,
            then this is an array of length *nbins*. If input is a sequence of
            arrays ``[data1, data2, ...]``, then this is a list of arrays with
            the values of the histograms for each of the arrays in the same
            order.  The dtype of the array *n* (or of its element arrays) will
            always be float even if no weighting or normalization is used.

        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 : `.BarContainer` or list of a single `.Polygon` or list of such objects
            Container of individual artists used to create the histogram
            or list of such containers if there are multiple input datasets.

        Other Parameters
        ----------------
        **kwargs
            `~matplotlib.patches.Patch` properties

        See Also
        --------
        hist2d : 2D histograms

        Notes
        -----
        For large numbers of bins (>1000), 'step' and 'stepfilled' can be
        significantly faster than 'bar' and 'barstacked'.

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *weights*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    hist2d(x, y, bins=10, range=None, density=False, weights=None, cmin=None, cmax=None, *, data=None, **kwargs)
        Make a 2D histogram plot.

        Parameters
        ----------
        x, y : array-like, shape (n, )
            Input values

        bins : None or int or [int, int] or array-like or [array, array]

            The bin specification:

            - If int, the number of bins for the two dimensions
              (nx=ny=bins).
            - If ``[int, int]``, the number of bins in each dimension
              (nx, ny = bins).
            - If array-like, the bin edges for the two dimensions
              (x_edges=y_edges=bins).
            - If ``[array, array]``, the bin edges in each dimension
              (x_edges, y_edges = bins).

            The default value is 10.

        range : array-like shape(2, 2), optional
            The leftmost and rightmost edges of the bins along each dimension
            (if not specified explicitly in the bins parameters): ``[[xmin,
            xmax], [ymin, ymax]]``. All values outside of this range will be
            considered outliers and not tallied in the histogram.

        density : bool, default: False
            Normalize histogram.  See the documentation for the *density*
            parameter of `~.Axes.hist` for more details.

        weights : array-like, shape (n, ), optional
            An array of values w_i weighing each sample (x_i, y_i).

        cmin, cmax : float, default: None
            All bins that has count less than *cmin* or more than *cmax* will
            not be displayed (set to NaN before passing to imshow) and these
            count values in the return value count histogram will also be set
            to nan upon return.

        Returns
        -------
        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 : `~.matplotlib.collections.QuadMesh`

        Other Parameters
        ----------------
        cmap : Colormap or str, optional
            A `.colors.Colormap` instance.  If not set, use rc settings.

        norm : Normalize, optional
            A `.colors.Normalize` instance is used to
            scale luminance data to ``[0, 1]``. If not set, defaults to
            `.colors.Normalize()`.

        vmin/vmax : None or scalar, optional
            Arguments passed to the `~.colors.Normalize` instance.

        alpha : ``0 <= scalar <= 1`` or ``None``, optional
            The alpha blending value.

        **kwargs
            Additional parameters are passed along to the
            `~.Axes.pcolormesh` method and `~matplotlib.collections.QuadMesh`
            constructor.

        See Also
        --------
        hist : 1D histogram plotting

        Notes
        -----
        - Currently ``hist2d`` calculates its own axis limits, and any limits
          previously set are ignored.
        - Rendering the histogram with a logarithmic color scale is
          accomplished by passing a `.colors.LogNorm` instance to the *norm*
          keyword argument. Likewise, power-law normalization (similar
          in effect to gamma correction) can be accomplished with
          `.colors.PowerNorm`.

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*, *weights*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    hlines(y, xmin, xmax, colors=None, linestyles='solid', label='', *, data=None, **kwargs)
        Plot horizontal lines at each *y* from *xmin* to *xmax*.

        Parameters
        ----------
        y : float or array-like
            y-indexes where to plot the lines.

        xmin, xmax : float or array-like
            Respective beginning and end of each line. If scalars are
            provided, all lines will have same length.

        colors : list of colors, default: :rc:`lines.color`

        linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional

        label : str, default: ''

        Returns
        -------
        `~matplotlib.collections.LineCollection`

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

        See Also
        --------
        vlines : vertical lines
        axhline: horizontal line across the axes

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *y*, *xmin*, *xmax*, *colors*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    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(fname, format=None)
        Read an image from a file into an array.

        Parameters
        ----------
        fname : str or file-like
            The image file to read: a filename, a URL or a file-like object opened
            in read-binary mode.
        format : str, optional
            The image file format assumed for reading the data. If not
            given, the format is deduced from the filename.  If nothing can
            be deduced, PNG is tried.

        Returns
        -------
        `numpy.array`
            The image data. The returned array has shape

            - (M, N) for grayscale images.
            - (M, N, 3) for RGB images.
            - (M, N, 4) for RGBA images.

    imsave(fname, arr, **kwargs)
        Save an array as an image file.

        Parameters
        ----------
        fname : str or path-like or file-like
            A path or a file-like object to store the image in.
            If *format* is not set, then the output format is inferred from the
            extension of *fname*, if any, and from :rc:`savefig.format` otherwise.
            If *format* is set, it determines the output format.
        arr : array-like
            The image data. The shape can be one of
            MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA).
        vmin, vmax : float, optional
            *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 : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
            A Colormap instance or registered colormap name. The colormap
            maps scalar data to colors. It is ignored for RGB(A) data.
        format : str, optional
            The file format, e.g. 'png', 'pdf', 'svg', ...  The behavior when this
            is unset is documented under *fname*.
        origin : {'upper', 'lower'}, default: :rc:`image.origin`
            Indicates whether the ``(0, 0)`` index of the array is in the upper
            left or lower left corner of the axes.
        dpi : float
            The DPI to store in the metadata of the file.  This does not affect the
            resolution of the output image.  Depending on file format, this may be
            rounded to the nearest integer.
        metadata : dict, optional
            Metadata in the image file.  The supported keys depend on the output
            format, see the documentation of the respective backends for more
            information.
        pil_kwargs : dict, optional
            Keyword arguments passed to `PIL.Image.Image.save`.  If the 'pnginfo'
            key is present, it completely overrides *metadata*, including the
            default 'Software' key.

    imshow(X, cmap=None, norm=None, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, *, filternorm=True, filterrad=4.0, resample=None, url=None, data=None, **kwargs)
        Display data as an image, i.e., on a 2D regular raster.

        The input may either be actual RGB(A) data, or 2D scalar data, which
        will be rendered as a pseudocolor image. For displaying a grayscale
        image set up the color mapping using the parameters
        ``cmap='gray', vmin=0, vmax=255``.

        The number of pixels used to render an image is set by the axes size
        and the *dpi* of the figure. This can lead to aliasing artifacts when
        the image is resampled because the displayed image size will usually
        not match the size of *X* (see
        :doc:`/gallery/images_contours_and_fields/image_antialiasing`).
        The resampling can be controlled via the *interpolation* parameter
        and/or :rc:`image.interpolation`.

        Parameters
        ----------
        X : array-like or PIL image
            The image data. Supported array shapes are:

            - (M, N): an image with scalar data. The values are mapped to
              colors using normalization and a colormap. See parameters *norm*,
              *cmap*, *vmin*, *vmax*.
            - (M, N, 3): an image with RGB values (0-1 float or 0-255 int).
            - (M, N, 4): an image with RGBA values (0-1 float or 0-255 int),
              i.e. including transparency.

            The first two dimensions (M, N) define the rows and columns of
            the image.

            Out-of-range RGB(A) values are clipped.

        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
            The Colormap instance or registered colormap name used to map
            scalar data to colors. This parameter is ignored for RGB(A) data.

        norm : `~matplotlib.colors.Normalize`, optional
            The `.Normalize` instance used to scale scalar data to the [0, 1]
            range before mapping to colors using *cmap*. By default, a linear
            scaling mapping the lowest value to 0 and the highest to 1 is used.
            This parameter is ignored for RGB(A) data.

        aspect : {'equal', 'auto'} or float, default: :rc:`image.aspect`
            The aspect ratio of the axes.  This parameter is particularly
            relevant for images since it determines whether data pixels are
            square.

            This parameter is a shortcut for explicitly calling
            `.Axes.set_aspect`. See there for further details.

            - 'equal': Ensures an aspect ratio of 1. Pixels will be square
              (unless pixel sizes are explicitly made non-square in data
              coordinates using *extent*).
            - 'auto': The axes is kept fixed and the aspect is adjusted so
              that the data fit in the axes. In general, this will result in
              non-square pixels.

        interpolation : str, default: :rc:`image.interpolation`
            The interpolation method used.

            Supported values are 'none', 'antialiased', 'nearest', 'bilinear',
            'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite',
            'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell',
            'sinc', 'lanczos'.

            If *interpolation* is 'none', then no interpolation is performed
            on the Agg, ps, pdf and svg backends. Other backends will fall back
            to 'nearest'. Note that most SVG renderers perform interpolation at
            rendering and that the default interpolation method they implement
            may differ.

            If *interpolation* is the default 'antialiased', then 'nearest'
            interpolation is used if the image is upsampled by more than a
            factor of three (i.e. the number of display pixels is at least
            three times the size of the data array).  If the upsampling rate is
            smaller than 3, or the image is downsampled, then 'hanning'
            interpolation is used to act as an anti-aliasing filter, unless the
            image happens to be upsampled by exactly a factor of two or one.

            See
            :doc:`/gallery/images_contours_and_fields/interpolation_methods`
            for an overview of the supported interpolation methods, and
            :doc:`/gallery/images_contours_and_fields/image_antialiasing` for
            a discussion of image antialiasing.

            Some interpolation methods require an additional radius parameter,
            which can be set by *filterrad*. Additionally, the antigrain image
            resize filter is controlled by the parameter *filternorm*.

        alpha : float or array-like, optional
            The alpha blending value, between 0 (transparent) and 1 (opaque).
            If *alpha* is an array, the alpha blending values are applied pixel
            by pixel, and *alpha* must have the same shape as *X*.

        vmin, vmax : float, optional
            When using scalar data and no explicit *norm*, *vmin* and *vmax*
            define the data range that the colormap covers. By default,
            the colormap covers the complete value range of the supplied
            data. It is deprecated to use *vmin*/*vmax* when *norm* is given.

        origin : {'upper', 'lower'}, default: :rc:`image.origin`
            Place the [0, 0] index of the array in the upper left or lower
            left corner of the axes. The convention (the default) 'upper' is
            typically used for matrices and images.

            Note that the vertical axes points upward for 'lower'
            but downward for 'upper'.

            See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for
            examples and a more detailed description.

        extent : floats (left, right, bottom, top), optional
            The bounding box in data coordinates that the image will fill.
            The image is stretched individually along x and y to fill the box.

            The default extent is determined by the following conditions.
            Pixels have unit size in data coordinates. Their centers are on
            integer coordinates, and their center coordinates range from 0 to
            columns-1 horizontally and from 0 to rows-1 vertically.

            Note that the direction of the vertical axis and thus the default
            values for top and bottom depend on *origin*:

            - For ``origin == 'upper'`` the default is
              ``(-0.5, numcols-0.5, numrows-0.5, -0.5)``.
            - For ``origin == 'lower'`` the default is
              ``(-0.5, numcols-0.5, -0.5, numrows-0.5)``.

            See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for
            examples and a more detailed description.

        filternorm : bool, default: True
            A parameter for the antigrain image resize filter (see the
            antigrain documentation).  If *filternorm* is set, the filter
            normalizes integer values and corrects the rounding errors. It
            doesn't do anything with the source floating point values, it
            corrects only integers according to the rule of 1.0 which means
            that any sum of pixel weights must be equal to 1.0.  So, the
            filter function must produce a graph of the proper shape.

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

        resample : bool, default: :rc:`image.resample`
            When *True*, use a full resampling method.  When *False*, only
            resample when the output image is larger than the input image.

        url : str, optional
            Set the url of the created `.AxesImage`. See `.Artist.set_url`.

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

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.artist.Artist` properties
            These parameters are passed on to the constructor of the
            `.AxesImage` artist.

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

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

        There are two common representations for RGB images with an alpha
        channel:

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

        `~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,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    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 both with IPython and with vanilla python shells.

    ioff()
        Turn the interactive mode off.

        See Also
        --------
        ion : enable interactive mode
        isinteractive : query current state

        show : show windows (and maybe block)
        pause : show windows, run GUI event loop, and block for a time

    ion()
        Turn the interactive mode on.

        See Also
        --------
        ioff : disable interactive mode
        isinteractive : query current state

        show : show windows (and maybe block)
        pause : show windows, run GUI event loop, and block for a time

    isinteractive()
        Return if pyplot is in "interactive mode" or not.

        If in interactive mode then:

          - newly created figures will be shown immediately
          - figures will automatically redraw on change
          - `.pyplot.show` will not block by default

        If not in interactive mode then:

          - newly created figures and changes to figures will
            not be reflected until explicitly asked to be
          - `.pyplot.show` will block by default

        See Also
        --------
        ion : enable interactive mode
        ioff : disable interactive mode

        show : show windows (and maybe block)
        pause : show windows, run GUI event loop, and block for a time

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

        Specific lines can be excluded from the automatic legend element
        selection by defining a label starting with an underscore.
        This is default for all artists, so calling `.Axes.legend` without
        any arguments and without setting the labels manually will result in
        no legend being drawn.

        **2. 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 : list of str, optional
            A list of labels to show next to the artists.
            Use this together with *handles*, if you need full control on what
            is shown in the legend and the automatic mechanism described above
            is not sufficient.

        Returns
        -------
        `~matplotlib.legend.Legend`

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

        loc : str or pair of floats, default: :rc:`legend.loc` ('best' for axes, 'upper right' for figures)
            The location of the legend.

            The strings
            ``'upper left', 'upper right', 'lower left', 'lower right'``
            place the legend at the corresponding corner of the axes/figure.

            The strings
            ``'upper center', 'lower center', 'center left', 'center right'``
            place the legend at the center of the corresponding edge of the
            axes/figure.

            The string ``'center'`` places the legend at the center of the axes/figure.

            The string ``'best'`` places the legend at the location, among the nine
            locations defined so far, with the minimum overlap with other drawn
            artists.  This option can be quite slow for plots with large amounts of
            data; your plotting speed may benefit from providing a specific location.

            The location can also be a 2-tuple giving the coordinates of the lower-left
            corner of the legend in axes coordinates (in which case *bbox_to_anchor*
            will be ignored).

            For back-compatibility, ``'center right'`` (but no other location) can also
            be spelled ``'right'``, and each "string" locations can also be given as a
            numeric value:

                ===============   =============
                Location String   Location Code
                ===============   =============
                'best'            0
                'upper right'     1
                'upper left'      2
                'lower left'      3
                'lower right'     4
                'right'           5
                'center left'     6
                'center right'    7
                'lower center'    8
                'upper center'    9
                'center'          10
                ===============   =============

        bbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats
            Box that is used to position the legend in conjunction with *loc*.
            Defaults to `axes.bbox` (if called as a method to `.Axes.legend`) or
            `figure.bbox` (if `.Figure.legend`).  This argument allows arbitrary
            placement of the legend.

            Bbox coordinates are interpreted in the coordinate system given by
            *bbox_transform*, with the default transform
            Axes or Figure coordinates, depending on which ``legend`` is called.

            If a 4-tuple or `.BboxBase` is given, then it specifies the bbox
            ``(x, y, width, height)`` that the legend is placed in.
            To put the legend in the best location in the bottom right
            quadrant of the axes (or figure)::

                loc='best', bbox_to_anchor=(0.5, 0., 0.5, 0.5)

            A 2-tuple ``(x, y)`` places the corner of the legend specified by *loc* at
            x, y.  For example, to put the legend's upper right-hand corner in the
            center of the axes (or figure) the following keywords can be used::

                loc='upper right', bbox_to_anchor=(0.5, 0.5)

        ncol : int, default: 1
            The number of columns that the legend has.

        prop : None or `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 {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}
            The font size of the legend. If the value is numeric the size will be the
            absolute font size in points. String values are relative to the current
            default font size. This argument is only used if *prop* is not specified.

        labelcolor : str or list
            Sets the color of the text in the legend. Can be a valid color string
            (for example, 'red'), or a list of color strings. The labelcolor can
            also be made to match the color of the line or marker using 'linecolor',
            'markerfacecolor' (or 'mfc'), or 'markeredgecolor' (or 'mec').

        numpoints : int, default: :rc:`legend.numpoints`
            The number of marker points in the legend when creating a legend
            entry for a `.Line2D` (line).

        scatterpoints : int, default: :rc:`legend.scatterpoints`
            The number of marker points in the legend when creating
            a legend entry for a `.PathCollection` (scatter plot).

        scatteryoffsets : iterable of floats, default: ``[0.375, 0.5, 0.3125]``
            The vertical offset (relative to the font size) for the markers
            created for a scatter plot legend entry. 0.0 is at the base the
            legend text, and 1.0 is at the top. To draw all markers at the
            same height, set to ``[0.5]``.

        markerscale : float, default: :rc:`legend.markerscale`
            The relative size of legend markers compared with the originally
            drawn ones.

        markerfirst : bool, default: True
            If *True*, legend marker is placed to the left of the legend label.
            If *False*, legend marker is placed to the right of the legend label.

        frameon : bool, default: :rc:`legend.frameon`
            Whether the legend should be drawn on a patch (frame).

        fancybox : bool, default: :rc:`legend.fancybox`
            Whether round edges should be enabled around the `~.FancyBboxPatch` which
            makes up the legend's background.

        shadow : bool, default: :rc:`legend.shadow`
            Whether to draw a shadow behind the legend.

        framealpha : float, default: :rc:`legend.framealpha`
            The alpha transparency of the legend's background.
            If *shadow* is activated and *framealpha* is ``None``, the default value is
            ignored.

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

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

        mode : {"expand", None}
            If *mode* is set to ``"expand"`` the legend will be horizontally
            expanded to fill the axes area (or *bbox_to_anchor* if defines
            the legend's size).

        bbox_transform : None or `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``).

        title_fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default: :rc:`legend.title_fontsize`
            The font size of the legend's title.

        borderpad : float, default: :rc:`legend.borderpad`
            The fractional whitespace inside the legend border, in font-size units.

        labelspacing : float, default: :rc:`legend.labelspacing`
            The vertical space between the legend entries, in font-size units.

        handlelength : float, default: :rc:`legend.handlelength`
            The length of the legend handles, in font-size units.

        handletextpad : float, default: :rc:`legend.handletextpad`
            The pad between the legend handle and text, in font-size units.

        borderaxespad : float, default: :rc:`legend.borderaxespad`
            The pad between the axes and legend border, in font-size units.

        columnspacing : float, default: :rc:`legend.columnspacing`
            The spacing between columns, in font-size units.

        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 `matplotlib.legend.Legend.get_legend_handler_map`.

        Notes
        -----
        Some artists are not supported by this function.  See
        :doc:`/tutorials/intermediate/legend_guide` for details.

        Examples
        --------
        .. plot:: gallery/text_labels_and_annotations/legend.py

    locator_params(axis='both', tight=None, **kwargs)
        Control behavior of major tick locators.

        Because the locator is involved in autoscaling, `~.Axes.autoscale_view`
        is called automatically after the parameters are changed.

        Parameters
        ----------
        axis : {'both', 'x', 'y'}, default: 'both'
            The axis on which to operate.

        tight : bool or None, optional
            Parameter passed to `~.Axes.autoscale_view`.
            Default is None, for no change.

        Other Parameters
        ----------------
        **kwargs
            Remaining keyword arguments are passed to directly to the
            ``set_params()`` method of the locator. Supported keywords depend
            on the type of the locator. See for example
            `~.ticker.MaxNLocator.set_params` for the `.ticker.MaxNLocator`
            used by default for linear axes.

        Examples
        --------
        When plotting small subplots, one might want to reduce the maximum
        number of ticks and use tight bounds, for example::

            ax.locator_params(tight=True, nbins=4)

    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 *base*, *subs* and *nonpositive* control the
        x/y-axis properties. They are just forwarded to `.Axes.set_xscale` and
        `.Axes.set_yscale`. To use different properties on the x-axis and the
        y-axis, use e.g.
        ``ax.set_xscale("log", base=10); ax.set_yscale("log", base=2)``.

        Parameters
        ----------
        base : float, default: 10
            Base of the logarithm.

        subs : sequence, optional
            The location of the minor ticks. If *None*, reasonable locations
            are automatically chosen depending on the number of decades in the
            plot. See `.Axes.set_xscale`/`.Axes.set_yscale` for details.

        nonpositive : {'mask', 'clip'}, default: 'mask'
            Non-positive values can be masked as invalid, or clipped to a very
            small positive number.

        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, *, data=None, **kwargs)
        Plot the magnitude spectrum.

        Compute the magnitude spectrum of *x*.  Data is padded to a
        length of *pad_to* and the windowing function *window* is applied to
        the signal.

        Parameters
        ----------
        x : 1-D array or sequence
            Array or sequence containing the data.

        Fs : float, default: 2
            The sampling frequency (samples per time unit).  It is used to calculate
            the Fourier frequencies, *freqs*, in cycles per time unit.

        window : callable or ndarray, default: `.window_hanning`
            A function or a vector of length *NFFT*.  To create window vectors see
            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
            function is passed as the argument, it must take a data segment as an
            argument and return the windowed version of the segment.

        sides : {'default', 'onesided', 'twosided'}, optional
            Which sides of the spectrum to return. 'default' is one-sided for real
            data and two-sided for complex data. 'onesided' forces the return of a
            one-sided spectrum, while 'twosided' forces two-sided.

        pad_to : int, optional
            The number of points to which the data segment is padded when performing
            the FFT.  While not increasing the actual resolution of the spectrum (the
            minimum distance between resolvable peaks), this can give more points in
            the plot, allowing for more detail. This corresponds to the *n* parameter
            in the call to fft().  The default is None, which sets *pad_to* equal to
            the length of the input signal (i.e. no padding).

        scale : {'default', 'linear', 'dB'}
            The scaling of the values in the *spec*.  'linear' is no scaling.
            'dB' returns the values in dB scale, i.e., the dB amplitude
            (20 * log10). 'default' is 'linear'.

        Fc : int, default: 0
            The center frequency of *x*, which offsets the x extents of the
            plot to reflect the frequency range used when a signal is acquired
            and then filtered and downsampled to baseband.

        Returns
        -------
        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 : `~matplotlib.lines.Line2D`
            The line created by this function.

        Other Parameters
        ----------------
        **kwargs
            Keyword arguments control the `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        psd
            Plots the power spectral density.
        angle_spectrum
            Plots the angles of the corresponding frequencies.
        phase_spectrum
            Plots the phase (unwrapped angle) of the corresponding frequencies.
        specgram
            Can plot the magnitude spectrum of segments within the signal in a
            colormap.

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    margins(*margins, x=None, y=None, tight=True)
        Set or retrieve autoscaling margins.

        The padding added to each limit of the axes is the *margin*
        times the data interval. All input parameters must be floats
        within the range [0, 1]. Passing both positional and keyword
        arguments is invalid and will raise a TypeError. If no
        arguments (positional or otherwise) are provided, the current
        margins will remain in place and simply be returned.

        Specifying any margin changes only the autoscaling; for example,
        if *xmargin* is not None, then *xmargin* times the X data
        interval will be added to each end of that interval before
        it is used in autoscaling.

        Parameters
        ----------
        *margins : float, optional
            If a single positional argument is provided, it specifies
            both margins of the x-axis and y-axis limits. If two
            positional arguments are provided, they will be interpreted
            as *xmargin*, *ymargin*. If setting the margin on a single
            axis is desired, use the keyword arguments described below.

        x, y : float, optional
            Specific margin values for the x-axis and y-axis,
            respectively. These cannot be used with positional
            arguments, but can be used individually to alter on e.g.,
            only the y-axis.

        tight : bool or None, default: True
            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.  Set *tight* to *None* will preserve
            the previous setting.

        Returns
        -------
        xmargin, ymargin : float

        Notes
        -----
        If a previously used Axes method such as :meth:`pcolor` has set
        :attr:`use_sticky_edges` to `True`, only the limits not set by
        the "sticky artists" will be modified. To force all of the
        margins to be set, set :attr:`use_sticky_edges` to `False`
        before calling :meth:`margins`.

    matshow(A, fignum=None, **kwargs)
        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.

        Parameters
        ----------
        A : array-like(M, N)
            The matrix to be displayed.

        fignum : None or int or False
            If *None*, create a new figure window with automatic numbering.

            If a nonzero integer, draw into the figure with the given number
            (create it if it does not exist).

            If 0, use the current axes (or create one if it does not exist).

            .. note::

               Because of how `.Axes.matshow` tries to set the figure aspect
               ratio to be the one of the array, strange things may happen if you
               reuse an existing figure.

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

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.axes.Axes.imshow` arguments

    minorticks_off()
        Remove minor ticks from the axes.

    minorticks_on()
        Display minor ticks on the axes.

        Displaying minor ticks may reduce performance; you may turn them off
        using `minorticks_off()` if drawing speed is a problem.

    new_figure_manager(num, *args, **kwargs)
        Create a new figure manager instance.

    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.

    pause(interval)
        Run the GUI event loop 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 use
        :mod:`matplotlib.animation`.

        If there is no active figure, sleep for *interval* seconds instead.

        See Also
        --------
        matplotlib.animation : Complex animation
        show : show figures and optional block forever

    pcolor(*args, shading=None, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, data=None, **kwargs)
        Create a pseudocolor plot with a non-regular rectangular grid.

        Call signature::

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

        *X* and *Y* can be used to specify the corners of the quadrilaterals.

        .. hint::

            ``pcolor()`` can be very slow for large arrays. In most
            cases you should use the similar but much faster
            `~.Axes.pcolormesh` instead. See
            :ref:`Differences between pcolor() and pcolormesh()
            <differences-pcolor-pcolormesh>` for a discussion of the
            differences.

        Parameters
        ----------
        C : array-like
            A scalar 2-D array. The values will be color-mapped.

        X, Y : array-like, optional
            The coordinates of the corners of quadrilaterals of a pcolormesh::

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

            Note that the column index corresponds to the x-coordinate, and
            the row index corresponds to y. For details, see the
            :ref:`Notes <axes-pcolormesh-grid-orientation>` section below.

            If ``shading='flat'`` the dimensions of *X* and *Y* should be one
            greater than those of *C*, and the quadrilateral is colored due
            to the value at ``C[i, j]``.  If *X*, *Y* and *C* have equal
            dimensions, a warning will be raised and the last row and column
            of *C* will be ignored.

            If ``shading='nearest'``, the dimensions of *X* and *Y* should be
            the same as those of *C* (if not, a ValueError will be raised). The
            color ``C[i, j]`` will be centered on ``(X[i, j], Y[i, j])``.

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

        shading : {'flat', 'nearest', 'auto'}, optional
            The fill style for the quadrilateral; defaults to 'flat' or
            :rc:`pcolor.shading`. Possible values:

            - 'flat': A solid color is used for each quad. The color of the
              quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by
              ``C[i, j]``. The dimensions of *X* and *Y* should be
              one greater than those of *C*; if they are the same as *C*,
              then a deprecation warning is raised, and the last row
              and column of *C* are dropped.
            - 'nearest': Each grid point will have a color centered on it,
              extending halfway between the adjacent grid centers.  The
              dimensions of *X* and *Y* must be the same as *C*.
            - 'auto': Choose 'flat' if dimensions of *X* and *Y* are one
              larger than *C*.  Choose 'nearest' if dimensions are the same.

            See :doc:`/gallery/images_contours_and_fields/pcolormesh_grids`
            for more description.

        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
            A Colormap instance or registered colormap name. The colormap
            maps the *C* values to colors.

        norm : `~matplotlib.colors.Normalize`, optional
            The Normalize instance scales the data values to the canonical
            colormap range [0, 1] for mapping to colors. By default, the data
            range is mapped to the colorbar range using linear scaling.

        vmin, vmax : float, default: None
            The colorbar range. If *None*, suitable min/max values are
            automatically chosen by the `~.Normalize` instance (defaults to
            the respective min/max values of *C* in case of the default linear
            scaling).
            It is deprecated to use *vmin*/*vmax* when *norm* is given.

        edgecolors : {'none', None, 'face', color, color sequence}, optional
            The color of the edges. Defaults to 'none'. Possible values:

            - 'none' or '': No edge.
            - *None*: :rc:`patch.edgecolor` will be used. Note that currently
              :rc:`patch.force_edgecolor` has to be True for this to work.
            - 'face': Use the adjacent face color.
            - A color or sequence of colors will set the edge color.

            The singular form *edgecolor* works as an alias.

        alpha : float, default: None
            The alpha blending value of the face color, between 0 (transparent)
            and 1 (opaque). Note: The edgecolor is currently not affected by
            this.

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

        Returns
        -------
        `matplotlib.collections.Collection`

        Other Parameters
        ----------------
        antialiaseds : bool, 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`.
            Stroking the edges may be preferred if *alpha* is 1, but will
            cause artifacts otherwise.

        **kwargs
            Additionally, the following arguments are allowed. They are passed
            along to the `~matplotlib.collections.PolyCollection` constructor:

        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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

        See Also
        --------
        pcolormesh : for an explanation of the differences between
            pcolor and pcolormesh.
        imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a
            faster alternative.

        Notes
        -----
        **Masked arrays**

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

        .. _axes-pcolor-grid-orientation:

        **Grid orientation**

        The grid orientation follows the standard matrix convention: An array
        *C* with shape (nrows, ncolumns) is plotted with the column number as
        *X* and the row number as *Y*.

        .. note::
            In addition to the above described arguments, this function can take
            a *data* keyword argument. If such a *data* argument is given,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    pcolormesh(*args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, shading=None, antialiased=False, data=None, **kwargs)
        Create a pseudocolor plot with a non-regular rectangular grid.

        Call signature::

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

        *X* and *Y* can be used to specify the corners of the quadrilaterals.

        .. hint::

           `~.Axes.pcolormesh` is similar to `~.Axes.pcolor`. It is much faster
           and preferred in most cases. For a detailed discussion on the
           differences see :ref:`Differences between pcolor() and pcolormesh()
           <differences-pcolor-pcolormesh>`.

        Parameters
        ----------
        C : array-like
            A scalar 2-D array. The values will be color-mapped.

        X, Y : array-like, optional
            The coordinates of the corners of quadrilaterals of a pcolormesh::

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

            Note that the column index corresponds to the x-coordinate, and
            the row index corresponds to y. For details, see the
            :ref:`Notes <axes-pcolormesh-grid-orientation>` section below.

            If ``shading='flat'`` the dimensions of *X* and *Y* should be one
            greater than those of *C*, and the quadrilateral is colored due
            to the value at ``C[i, j]``.  If *X*, *Y* and *C* have equal
            dimensions, a warning will be raised and the last row and column
            of *C* will be ignored.

            If ``shading='nearest'`` or ``'gouraud'``, the dimensions of *X*
            and *Y* should be the same as those of *C* (if not, a ValueError
            will be raised).  For ``'nearest'`` the color ``C[i, j]`` is
            centered on ``(X[i, j], Y[i, j])``.  For ``'gouraud'``, a smooth
            interpolation is caried out between the quadrilateral corners.

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

        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`
            A Colormap instance or registered colormap name. The colormap
            maps the *C* values to colors.

        norm : `~matplotlib.colors.Normalize`, optional
            The Normalize instance scales the data values to the canonical
            colormap range [0, 1] for mapping to colors. By default, the data
            range is mapped to the colorbar range using linear scaling.

        vmin, vmax : float, default: None
            The colorbar range. If *None*, suitable min/max values are
            automatically chosen by the `~.Normalize` instance (defaults to
            the respective min/max values of *C* in case of the default linear
            scaling).
            It is deprecated to use *vmin*/*vmax* when *norm* is given.

        edgecolors : {'none', None, 'face', color, color sequence}, optional
            The color of the edges. Defaults to 'none'. Possible values:

            - 'none' or '': No edge.
            - *None*: :rc:`patch.edgecolor` will be used. Note that currently
              :rc:`patch.force_edgecolor` has to be True for this to work.
            - 'face': Use the adjacent face color.
            - A color or sequence of colors will set the edge color.

            The singular form *edgecolor* works as an alias.

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

        shading : {'flat', 'nearest', 'gouraud', 'auto'}, optional
            The fill style for the quadrilateral; defaults to
            'flat' or :rc:`pcolor.shading`. Possible values:

            - 'flat': A solid color is used for each quad. The color of the
              quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by
              ``C[i, j]``. The dimensions of *X* and *Y* should be
              one greater than those of *C*; if they are the same as *C*,
              then a deprecation warning is raised, and the last row
              and column of *C* are dropped.
            - 'nearest': Each grid point will have a color centered on it,
              extending halfway between the adjacent grid centers.  The
              dimensions of *X* and *Y* must be the same as *C*.
            - 'gouraud': Each quad will be Gouraud shaded: The color of the
              corners (i', j') are given by ``C[i', j']``. The color values of
              the area in between is interpolated from the corner values.
              The dimensions of *X* and *Y* must be the same as *C*. When
              Gouraud shading is used, *edgecolors* is ignored.
            - 'auto': Choose 'flat' if dimensions of *X* and *Y* are one
              larger than *C*.  Choose 'nearest' if dimensions are the same.

            See :doc:`/gallery/images_contours_and_fields/pcolormesh_grids`
            for more description.

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

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

        Other Parameters
        ----------------
        **kwargs
            Additionally, the following arguments are allowed. They are passed
            along to the `~matplotlib.collections.QuadMesh` constructor:

        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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

        See Also
        --------
        pcolor : An alternative implementation with slightly different
            features. For a detailed discussion on the differences see
            :ref:`Differences between pcolor() and pcolormesh()
            <differences-pcolor-pcolormesh>`.
        imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a
            faster alternative.

        Notes
        -----
        **Masked arrays**

        *C* may be a masked array. If ``C[i, j]`` is masked, the corresponding
        quadrilateral will be transparent. Masking of *X* and *Y* is not
        supported. Use `~.Axes.pcolor` if you need this functionality.

        .. _axes-pcolormesh-grid-orientation:

        **Grid orientation**

        The grid orientation follows the standard matrix convention: An array
        *C* with shape (nrows, ncolumns) is plotted with the column number as
        *X* and the row number as *Y*.

        .. _differences-pcolor-pcolormesh:

        **Differences between pcolor() and pcolormesh()**

        Both methods are used to create a pseudocolor plot of a 2-D array
        using quadrilaterals.

        The main difference lies in the created object and internal data
        handling:
        While `~.Axes.pcolor` returns a `.PolyCollection`, `~.Axes.pcolormesh`
        returns a `.QuadMesh`. The latter is more specialized for the given
        purpose and thus is faster. It should almost always be preferred.

        There is also a slight difference in the handling of masked arrays.
        Both `~.Axes.pcolor` and `~.Axes.pcolormesh` support masked arrays
        for *C*. However, only `~.Axes.pcolor` supports masked arrays for *X*
        and *Y*. The reason lies in the internal handling of the masked values.
        `~.Axes.pcolor` leaves out the respective polygons from the
        PolyCollection. `~.Axes.pcolormesh` sets the facecolor of the masked
        elements to transparent. You can see the difference when using
        edgecolors. While all edges are drawn irrespective of masking in a
        QuadMesh, the edge between two adjacent masked quadrilaterals in
        `~.Axes.pcolor` is not drawn as the corresponding polygons do not
        exist in the PolyCollection.

        Another difference is the support of Gouraud shading in
        `~.Axes.pcolormesh`, which is not available with `~.Axes.pcolor`.

        .. note::
            In addition to the above described arguments, this function can take
            a *data* keyword argument. If such a *data* argument is given,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    phase_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)
        Plot the phase spectrum.

        Compute the phase spectrum (unwrapped angle spectrum) of *x*.
        Data is padded to a length of *pad_to* and the windowing function
        *window* is applied to the signal.

        Parameters
        ----------
        x : 1-D array or sequence
            Array or sequence containing the data

        Fs : float, default: 2
            The sampling frequency (samples per time unit).  It is used to calculate
            the Fourier frequencies, *freqs*, in cycles per time unit.

        window : callable or ndarray, default: `.window_hanning`
            A function or a vector of length *NFFT*.  To create window vectors see
            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
            function is passed as the argument, it must take a data segment as an
            argument and return the windowed version of the segment.

        sides : {'default', 'onesided', 'twosided'}, optional
            Which sides of the spectrum to return. 'default' is one-sided for real
            data and two-sided for complex data. 'onesided' forces the return of a
            one-sided spectrum, while 'twosided' forces two-sided.

        pad_to : int, optional
            The number of points to which the data segment is padded when performing
            the FFT.  While not increasing the actual resolution of the spectrum (the
            minimum distance between resolvable peaks), this can give more points in
            the plot, allowing for more detail. This corresponds to the *n* parameter
            in the call to fft().  The default is None, which sets *pad_to* equal to
            the length of the input signal (i.e. no padding).

        Fc : int, default: 0
            The center frequency of *x*, which offsets the x extents of the
            plot to reflect the frequency range used when a signal is acquired
            and then filtered and downsampled to baseband.

        Returns
        -------
        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 : `~matplotlib.lines.Line2D`
            The line created by this function.

        Other Parameters
        ----------------
        **kwargs
            Keyword arguments control the `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        magnitude_spectrum
            Plots the magnitudes of the corresponding frequencies.
        angle_spectrum
            Plots the wrapped version of this function.
        specgram
            Can plot the phase spectrum of segments within the signal in a
            colormap.

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=0, radius=1, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, *, normalize=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 : 1D array-like
            The wedge sizes.

        explode : array-like, 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, default: None
            A sequence of strings providing the labels for each wedge

        colors : array-like, default: None
            A sequence of colors through which the pie chart will cycle.  If
            *None*, will use the colors in the currently active cycle.

        autopct : None or str or callable, default: None
            If not *None*, is a string or function used to label the wedges
            with their numeric value.  The label will be placed inside the
            wedge.  If it is a format string, the label will be ``fmt % pct``.
            If it is a function, it will be called.

        pctdistance : float, 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, default: False
            Draw a shadow beneath the pie.

        normalize: None or bool, default: None
            When *True*, always make a full pie by normalizing x so that
            ``sum(x) == 1``. *False* makes a partial pie if ``sum(x) <= 1``
            and raises a `ValueError` for ``sum(x) > 1``.

            When *None*, defaults to *True* if ``sum(x) >= 1`` and *False* if
            ``sum(x) < 1``.

            Please note that the previous default value of *None* is now
            deprecated, and the default will change to *True* in the next
            release. Please pass ``normalize=False`` explicitly if you want to
            draw a partial pie.

        labeldistance : float or None, default: 1.1
            The radial distance at which the pie labels are drawn.
            If set to ``None``, label are not drawn, but are stored for use in
            ``legend()``

        startangle : float, default: 0 degrees
            The angle by which the start of the pie is rotated,
            counterclockwise from the x-axis.

        radius : float, default: 1
            The radius of the pie.

        counterclock : bool, default: True
            Specify fractions direction, clockwise or counterclockwise.

        wedgeprops : dict, 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, default: None
            Dict of arguments to pass to the text objects.

        center : (float, float), default: (0, 0)
            The coordinates of the center of the chart.

        frame : bool, default: False
            Plot axes frame with the chart if true.

        rotatelabels : bool, default: False
            Rotate each label to the angle of the corresponding slice if true.

        Returns
        -------
        patches : list
            A sequence of `matplotlib.patches.Wedge` instances

        texts : list
            A list of the label `.Text` instances.

        autotexts : list
            A list of `.Text` instances for the numeric labels. This will only
            be returned if the parameter *autopct* is not *None*.

        Notes
        -----
        The pie chart will probably look best if the figure and axes are
        square, or the Axes aspect is equal.
        This method sets the aspect ratio of the axis to "equal".
        The axes aspect ratio can be controlled with `.Axes.set_aspect`.

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *explode*, *labels*, *colors*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    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, scalex=True, scaley=True, data=None, **kwargs)
        Plot y versus x as lines and/or markers.

        Call signatures::

            plot([x], y, [fmt], *, data=None, **kwargs)
            plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)

        The coordinates of the points or line nodes are given by *x*, *y*.

        The optional parameter *fmt* is a convenient way for defining basic
        formatting like color, marker and linestyle. It's a shortcut string
        notation described in the *Notes* section below.

        >>> plot(x, y)        # plot x and y using default line style and color
        >>> plot(x, y, 'bo')  # plot x and y using blue circle markers
        >>> plot(y)           # plot y using x as index array 0..N-1
        >>> plot(y, 'r+')     # ditto, but with red plusses

        You can use `.Line2D` properties as keyword arguments for more
        control on the appearance. Line properties and *fmt* can be mixed.
        The following two calls yield identical results:

        >>> plot(x, y, 'go--', linewidth=2, markersize=12)
        >>> plot(x, y, color='green', marker='o', linestyle='dashed',
        ...      linewidth=2, markersize=12)

        When conflicting with *fmt*, keyword arguments take precedence.

        **Plotting labelled data**

        There's a convenient way for plotting objects with labelled data (i.e.
        data that can be accessed by index ``obj['y']``). Instead of giving
        the data in *x* and *y*, you can provide the object in the *data*
        parameter and just give the labels for *x* and *y*::

        >>> plot('xlabel', 'ylabel', data=obj)

        All indexable objects are supported. This could e.g. be a `dict`, a
        `pandas.DataFrame` or a structured numpy array.

        **Plotting multiple sets of data**

        There are various ways to plot multiple sets of data.

        - The most straight forward way is just to call `plot` multiple times.
          Example:

          >>> plot(x1, y1, 'bo')
          >>> plot(x2, y2, 'go')

        - 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
        :rc:`axes.prop_cycle`.

        Parameters
        ----------
        x, y : array-like or scalar
            The horizontal / vertical coordinates of the data points.
            *x* values are optional and default to ``range(len(y))``.

            Commonly, these parameters are 1D arrays.

            They can also be scalars, or two-dimensional (in that case, the
            columns represent separate data sets).

            These arguments cannot be passed as keywords.

        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.

            This argument cannot be passed as keyword.

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

        Returns
        -------
        list of `.Line2D`
            A list of lines representing the plotted data.

        Other Parameters
        ----------------
        scalex, scaley : bool, default: True
            These parameters determine 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 call, the kwargs
            apply to all those lines.

            Here is a list of available `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        scatter : XY scatter plot with markers of varying size and/or color (
            sometimes also called bubble chart).

        Notes
        -----
        **Format Strings**

        A format string consists of a part for color, marker and line::

            fmt = '[marker][line][color]'

        Each of them is optional. If not provided, the value from the style
        cycle is used. Exception: If ``line`` is given, but no ``marker``,
        the data will be a line without markers.

        Other combinations such as ``[color][marker][line]`` are also
        supported, but note that their parsing may be ambiguous.

        **Markers**

        =============    ===============================
        character        description
        =============    ===============================
        ``'.'``          point marker
        ``','``          pixel marker
        ``'o'``          circle marker
        ``'v'``          triangle_down marker
        ``'^'``          triangle_up marker
        ``'<'``          triangle_left marker
        ``'>'``          triangle_right marker
        ``'1'``          tri_down marker
        ``'2'``          tri_up marker
        ``'3'``          tri_left marker
        ``'4'``          tri_right marker
        ``'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
            'or'   # red circles
            '-g'   # green solid line
            '--'   # dashed line with default color
            '^k:'  # black triangle_up markers connected by a dotted line

        **Colors**

        The supported color abbreviations are the single letter codes

        =============    ===============================
        character        color
        =============    ===============================
        ``'b'``          blue
        ``'g'``          green
        ``'r'``          red
        ``'c'``          cyan
        ``'m'``          magenta
        ``'y'``          yellow
        ``'k'``          black
        ``'w'``          white
        =============    ===============================

        and the ``'CN'`` colors that index into the default property cycle.

        If the color is the only part of the format string, you can
        additionally use any  `matplotlib.colors` spec, e.g. full names
        (``'green'``) or hex strings (``'#008000'``).

    plot_date(x, y, fmt='o', tz=None, xdate=True, ydate=False, *, data=None, **kwargs)
        Plot data that contains dates.

        Similar to `.plot`, this plots *y* vs. *x* as lines or markers.
        However, the axis labels are formatted as dates depending on *xdate*
        and *ydate*.

        Parameters
        ----------
        x, y : array-like
            The coordinates of the data points. If *xdate* or *ydate* is
            *True*, the respective values *x* or *y* are interpreted as
            :ref:`Matplotlib dates <date-format>`.

        fmt : str, optional
            The plot format string. For details, see the corresponding
            parameter in `.plot`.

        tz : timezone string or `datetime.tzinfo`, default: :rc:`timezone`
            The time zone to use in labeling dates.

        xdate : bool, default: True
            If *True*, the *x*-axis will be interpreted as Matplotlib dates.

        ydate : bool, 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 `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        matplotlib.dates : Helper functions on dates.
        matplotlib.dates.date2num : Convert dates to num.
        matplotlib.dates.num2date : Convert num to dates.
        matplotlib.dates.drange : Create an equally spaced sequence of dates.

        Notes
        -----
        If you are using custom date tickers and formatters, it may be
        necessary to set the formatters/locators after the call to
        `.plot_date`. `.plot_date` will set the default tick locator to
        `.AutoDateLocator` (if the tick locator is not already set to a
        `.DateLocator` instance) and the default tick formatter to
        `.AutoDateFormatter` (if the tick formatter is not already set to a
        `.DateFormatter` instance).

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    plotting()
        ============================ ====================================================================================================================
        Function                     Description
        ============================ ====================================================================================================================
        `acorr`                      Plot the autocorrelation of *x*.
        `angle_spectrum`             Plot the angle spectrum.
        `annotate`                   Annotate the point *xy* with text *text*.
        `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 some axis properties.
        `axline`                     Add an infinitely long straight line.
        `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 2D field of barbs.
        `barh`                       Make a horizontal bar plot.
        `box`                        Turn the axes box on or off on the current axes.
        `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 an `~.axes.Axes` (defaulting to the current axes) from its 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`                   Add a non-resampled image to the figure.
        `figlegend`                  Place a legend on the figure.
        `fignum_exists`              Return whether the figure with the given id exists.
        `figtext`                    Add text to figure.
        `figure`                     Create a new figure, or activate an existing 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 axes, creating one if necessary.
        `gcf`                        Get the current figure.
        `gci`                        Get the current colorable artist.
        `get`                        Return the value of an object's *property*, or print all of them.
        `get_figlabels`              Return a list of existing figure labels.
        `get_fignums`                Return a list of existing figure numbers.
        `getp`                       Return the value of an object's *property*, or print all of them.
        `grid`                       Configure the grid lines.
        `hexbin`                     Make a 2D hexagonal binning plot of points *x*, *y*.
        `hist`                       Plot a histogram.
        `hist2d`                     Make a 2D histogram plot.
        `hlines`                     Plot horizontal lines at each *y* from *xmin* to *xmax*.
        `imread`                     Read an image from a file into an array.
        `imsave`                     Save an array as an image file.
        `imshow`                     Display data as an image, i.e., on a 2D regular raster.
        `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 the interactive mode off.
        `ion`                        Turn the interactive mode on.
        `isinteractive`              Return if pyplot is in "interactive mode" or not.
        `legend`                     Place a legend on the axes.
        `locator_params`             Control behavior of major 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 axes.
        `minorticks_on`              Display minor ticks on the axes.
        `new_figure_manager`         Create a new figure manager instance.
        `pause`                      Run the GUI event loop for *interval* seconds.
        `pcolor`                     Create a pseudocolor plot with a non-regular rectangular grid.
        `pcolormesh`                 Create a pseudocolor plot with a non-regular rectangular grid.
        `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.
        `polar`                      Make a polar plot.
        `psd`                        Plot the power spectral density.
        `quiver`                     Plot a 2D field of arrows.
        `quiverkey`                  Add a key to a quiver plot.
        `rc`                         Set the current `.rcParams`.
        `rc_context`                 Return a context manager for temporarily changing rcParams.
        `rcdefaults`                 Restore the `.rcParams` from Matplotlib's internal default style.
        `rgrids`                     Get or set the radial gridlines on the current polar plot.
        `savefig`                    Save the current figure.
        `sca`                        Set the current Axes to *ax* and the current Figure to the parent of *ax*.
        `scatter`                    A scatter plot of *y* vs.
        `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, and applies it to the current image if any.
        `setp`                       Set a property on an artist object.
        `show`                       Display all open figures.
        `specgram`                   Plot a spectrogram.
        `spy`                        Plot the sparsity pattern of a 2D array.
        `stackplot`                  Draw a stacked area plot.
        `stem`                       Create a stem plot.
        `step`                       Make a step plot.
        `streamplot`                 Draw streamlines of a vector flow.
        `subplot`                    Add a subplot to the current figure.
        `subplot2grid`               Create a subplot at a specific location inside a regular grid.
        `subplot_mosaic`             Build a layout of Axes based on ASCII art or nested lists.
        `subplot_tool`               Launch a subplot tool window for a figure.
        `subplots`                   Create a figure and a set of subplots.
        `subplots_adjust`            Adjust the subplot layout parameters.
        `suptitle`                   Add a centered title to the figure.
        `switch_backend`             Close all open figures and set the Matplotlib backend.
        `table`                      Add a table to an `~.axes.Axes`.
        `text`                       Add text to the axes.
        `thetagrids`                 Get or set the theta gridlines on the current polar plot.
        `tick_params`                Change the appearance of ticks, tick labels, and gridlines.
        `ticklabel_format`           Configure the `.ScalarFormatter` used by default for linear axes.
        `tight_layout`               Adjust the padding between and around subplots.
        `title`                      Set a title for the axes.
        `tricontour`                 Draw contour lines on an unstructured triangular grid.
        `tricontourf`                Draw contour regions 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 and return a second axes that shares the *x*-axis.
        `twiny`                      Make and return a second axes that shares the *y*-axis.
        `uninstall_repl_displayhook` Uninstall the matplotlib display hook.
        `violinplot`                 Make a violin plot.
        `vlines`                     Plot vertical lines.
        `xcorr`                      Plot the cross correlation between *x* and *y*.
        `xkcd`                       Turn on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.
        `xlabel`                     Set the label for the x-axis.
        `xlim`                       Get or set the x limits of the current axes.
        `xscale`                     Set the x-axis scale.
        `xticks`                     Get or set the current tick locations and labels of the x-axis.
        `ylabel`                     Set the label for the y-axis.
        `ylim`                       Get or set the y-limits of the current axes.
        `yscale`                     Set the y-axis scale.
        `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
        `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, *, data=None, **kwargs)
        Plot the power spectral density.

        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 : float, default: 2
            The sampling frequency (samples per time unit).  It is used to calculate
            the Fourier frequencies, *freqs*, in cycles per time unit.

        window : callable or ndarray, default: `.window_hanning`
            A function or a vector of length *NFFT*.  To create window vectors see
            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
            function is passed as the argument, it must take a data segment as an
            argument and return the windowed version of the segment.

        sides : {'default', 'onesided', 'twosided'}, optional
            Which sides of the spectrum to return. 'default' is one-sided for real
            data and two-sided for complex data. 'onesided' forces the return of a
            one-sided spectrum, while 'twosided' forces two-sided.

        pad_to : int, optional
            The number of points to which the data segment is padded when performing
            the FFT.  This can be different from *NFFT*, which specifies the number
            of data points used.  While not increasing the actual resolution of the
            spectrum (the minimum distance between resolvable peaks), this can give
            more points in the plot, allowing for more detail. This corresponds to
            the *n* parameter in the call to fft(). The default is None, which sets
            *pad_to* equal to *NFFT*

        NFFT : int, default: 256
            The number of data points used in each block for the FFT.  A power 2 is
            most efficient.  This should *NOT* be used to get zero padding, or the
            scaling of the result will be incorrect; use *pad_to* for this instead.

        detrend : {'none', 'mean', 'linear'} or callable, default 'none'
            The function applied to each segment before fft-ing, designed to remove
            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter
            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`
            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,
            but you can use a custom function as well.  You can also use a string to
            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls
            `.detrend_mean`. 'linear' calls `.detrend_linear`.

        scale_by_freq : bool, default: True
            Whether the resulting density values should be scaled by the scaling
            frequency, which gives density in units of Hz^-1.  This allows for
            integration over the returned frequency values.  The default is True for
            MATLAB compatibility.

        noverlap : int, default: 0 (no overlap)
            The number of points of overlap between segments.

        Fc : int, default: 0
            The center frequency of *x*, which offsets the x extents of the
            plot to reflect the frequency range used when a signal is acquired
            and then filtered and downsampled to baseband.

        return_line : bool, default: False
            Whether to include the line object plotted in the returned values.

        Returns
        -------
        Pxx : 1-D array
            The values for the power spectrum :math:`P_{xx}` before scaling
            (real valued).

        freqs : 1-D array
            The frequencies corresponding to the elements in *Pxx*.

        line : `~matplotlib.lines.Line2D`
            The line created by this function.
            Only returned if *return_line* is True.

        Other Parameters
        ----------------
        **kwargs
            Keyword arguments control the `.Line2D` properties:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

        See Also
        --------
        specgram
            Differs in the default overlap; in not returning the mean of the
            segment periodograms; in returning the times of the segments; and
            in plotting a colormap instead of a line.
        magnitude_spectrum
            Plots the magnitude spectrum.
        csd
            Plots the spectral density between two signals.

        Notes
        -----
        For plotting, the power is plotted as
        :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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    quiver(*args, data=None, **kw)
        Plot a 2D field of arrows.

        Call signature::

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

        *X*, *Y* define the arrow locations, *U*, *V* define the arrow directions, and
        *C* optionally sets the color.

        **Arrow size**

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

        **Arrow shape**

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

        **Arrow outline**

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

        Parameters
        ----------
        X, Y : 1D or 2D array-like, optional
            The x and y coordinates of the arrow locations.

            If not given, they will be generated as a uniform integer meshgrid based
            on the dimensions of *U* and *V*.

            If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D
            using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``
            must match the column and row dimensions of *U* and *V*.

        U, V : 1D or 2D array-like
            The x and y direction components of the arrow vectors.

            They must have the same number of elements, matching the number of arrow
            locations. *U* and *V* may be masked. Only locations unmasked in
            *U*, *V*, and *C* will be drawn.

        C : 1D or 2D array-like, optional
            Numeric data that defines the arrow colors by colormapping via *norm* and
            *cmap*.

            This does not support explicit colors. If you want to set colors directly,
            use *color* instead.  The size of *C* must match the number of arrow
            locations.

        units : {'width', 'height', 'dots', 'inches', 'x', 'y' 'xy'}, default: 'width'
            The arrow dimensions (except for *length*) are measured in multiples of
            this unit.

            The following values are supported:

            - 'width', 'height': The width or height of the axis.
            - 'dots', 'inches': Pixels or inches based on the figure dpi.
            - 'x', 'y', 'xy': *X*, *Y* or :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'} or array-like, default: 'uv'
            Method for determining the angle of the arrows.

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

              Use this if the arrows symbolize a quantity that is not based on
              *X*, *Y* data coordinates.

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

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

              In this case *U*, *V* is only used to determine the length of the
              arrows.

            Note: inverting a data axis will correspondingly invert the
            arrows only with ``angles='xy'``.

        scale : 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'}, optional
            If the *scale* kwarg is *None*, the arrow length unit. Default is *None*.

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

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

            If *scale_units* is 'x' then the vector will be 0.5 x-axis
            units. To plot vectors in the x-y plane, with u and v having
            the same units as x and y, use
            ``angles='xy', scale_units='xy', scale=1``.

        width : float, 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 : float, default: 3
            Head width as multiple of shaft width.

        headlength : float, default: 5
            Head length as multiple of shaft width.

        headaxislength : float, default: 4.5
            Head length at shaft intersection.

        minshaft : float, default: 1
            Length below which arrow scales, in units of head length. Do not
            set this to less than 1, or small arrows will look terrible!

        minlength : float, default: 1
            Minimum length as a multiple of shaft width; if an arrow length
            is less than this, plot a dot (hexagon) of this diameter instead.

        pivot : {'tail', 'mid', 'middle', 'tip'}, default: 'tail'
            The part of the arrow that is anchored to the *X*, *Y* grid. The arrow
            rotates about this point.

            'mid' is a synonym for 'middle'.

        color : color or color sequence, optional
            Explicit color(s) for the arrows. If *C* has been set, *color* has no
            effect.

            This is a synonym for the `~.PolyCollection` *facecolor* parameter.

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.collections.PolyCollection` properties, optional
            All other keyword arguments are passed on to `.PolyCollection`:

            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 or antialiaseds: bool or list of bools
            array: ndarray
            capstyle: {'butt', 'round', 'projecting'}
            clim: (vmin: float, vmax: float)
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            cmap: `.Colormap` or str or None
            color: color or list of rgba tuples
            contains: unknown
            edgecolor or ec or edgecolors: color or list of colors or 'face'
            facecolor or facecolors or fc: color or list of colors
            figure: `.Figure`
            gid: str
            hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
            in_layout: bool
            joinstyle: {'miter', 'round', 'bevel'}
            label: object
            linestyle or dashes or linestyles or ls: str or tuple or list thereof
            linewidth or linewidths or lw: float or list of floats
            norm: `.Normalize` or None
            offset_position: unknown
            offsets: array-like (N, 2) or (2,)
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            pickradius: unknown
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            urls: list of str or None
            visible: bool
            zorder: float

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

    quiverkey(Q, X, Y, U, label, **kw)
        Add a key to a quiver plot.

        The positioning of the key depends on *X*, *Y*, *coordinates*, and
        *labelpos*.  If *labelpos* is 'N' or 'S', *X*, *Y* give the position of
        the middle of the key arrow.  If *labelpos* is 'E', *X*, *Y* positions
        the head, and if *labelpos* is 'W', *X*, *Y* positions the tail; in
        either of these two cases, *X*, *Y* is somewhere in the middle of the
        arrow+label key object.

        Parameters
        ----------
        Q : `matplotlib.quiver.Quiver`
            A `.Quiver` object as returned by a call to `~.Axes.quiver()`.
        X, Y : float
            The location of the key.
        U : float
            The length of the key.
        label : str
            The key label (e.g., length and units of the key).
        angle : float, default: 0
            The angle of the key arrow, in degrees anti-clockwise from the
            x-axis.
        coordinates : {'axes', 'figure', 'data', 'inches'}, default: 'axes'
            Coordinate system and units for *X*, *Y*: 'axes' and 'figure' are
            normalized coordinate systems with (0, 0) in the lower left and
            (1, 1) in the upper right; 'data' are the axes data coordinates
            (used for the locations of the vectors in the quiver plot itself);
            'inches' is position in the figure in inches, with (0, 0) at the
            lower left corner.
        color : 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 : float, default: 0.1
            Distance in inches between the arrow and the label.
        labelcolor : color, default: :rc:`text.color`
            Label color.
        fontproperties : dict, optional
            A dictionary with keyword arguments accepted by the
            `~matplotlib.font_manager.FontProperties` initializer:
            *family*, *style*, *variant*, *size*, *weight*.
        **kwargs
            Any additional keyword arguments are used to override vector
            properties taken from *Q*.

    rc(group, **kwargs)
        Set the current `.rcParams`.  *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 `.rcParams` 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 call 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 `.rcParams` after changes.

        Notes
        -----
        Similar functionality is available by using the normal dict interface, i.e.
        ``rcParams.update({"lines.linewidth": 2, ...})`` (but ``rcParams.update``
        does not support abbreviations or grouping).

    rc_context(rc=None, fname=None)
        Return a context manager for temporarily changing rcParams.

        Parameters
        ----------
        rc : dict
            The rcParams to temporarily set.
        fname : str or path-like
            A file with Matplotlib rc settings. If both *fname* and *rc* are given,
            settings from *rc* take precedence.

        See Also
        --------
        :ref:`customizing-with-matplotlibrc-files`

        Examples
        --------
        Passing explicit values via a dict::

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

        Loading settings from a file::

             with mpl.rc_context(fname='print.rc'):
                 plt.plot(x, y)  # uses 'print.rc'

    rcdefaults()
        Restore the `.rcParams` from Matplotlib's internal default style.

        Style-blacklisted `.rcParams` (defined in
        `matplotlib.style.core.STYLE_BLACKLIST`) are not updated.

        See Also
        --------
        matplotlib.rc_file_defaults
            Restore the `.rcParams` 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(radii=None, labels=None, angle=None, fmt=None, **kwargs)
        Get or set the radial gridlines on the current polar plot.

        Call signatures::

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

        When called with no arguments, `.rgrids` simply returns the tuple
        (*lines*, *labels*). When called with arguments, the labels will
        appear at the specified radial distances and angle.

        Parameters
        ----------
        radii : tuple with floats
            The radii for the radial gridlines

        labels : tuple with strings or None
            The labels to use at each radial gridline. The
            `matplotlib.ticker.ScalarFormatter` will be used if None.

        angle : float
            The angular position of the radius labels in degrees.

        fmt : str or None
            Format string used in `matplotlib.ticker.FormatStrFormatter`.
            For example '%f'.

        Returns
        -------
        lines : list of `.lines.Line2D`
            The radial gridlines.

        labels : list of `.text.Text`
            The tick labels.

        Other Parameters
        ----------------
        **kwargs
            *kwargs* are optional `~.Text` properties for the labels.

        See Also
        --------
        .pyplot.thetagrids
        .projections.polar.PolarAxes.set_rgrids
        .Axis.get_gridlines
        .Axis.get_ticklabels

        Examples
        --------
        ::

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

          # set the locations and labels of the radial gridlines
          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, metadata=None)

        The available output formats depend on the backend being used.

        Parameters
        ----------
        fname : str or path-like or file-like
            A path, or a Python file-like object, or
            possibly some backend-dependent object such as
            `matplotlib.backends.backend_pdf.PdfPages`.

            If *format* is set, it determines the output format, and the file
            is saved as *fname*.  Note that *fname* is used verbatim, and there
            is no attempt to make the extension, if any, of *fname* match
            *format*, and no extension is appended.

            If *format* is not set, then the format is inferred from the
            extension of *fname*, if there is one.  If *format* is not
            set and *fname* has no extension, then the file is saved with
            :rc:`savefig.format` and the appropriate extension is appended to
            *fname*.

        Other Parameters
        ----------------
        dpi : float or 'figure', default: :rc:`savefig.dpi`
            The resolution in dots per inch.  If 'figure', use the figure's
            dpi value.

        quality : int, default: :rc:`savefig.jpeg_quality`
            Applicable only if *format* is 'jpg' or 'jpeg', ignored otherwise.

            The image quality, on a scale from 1 (worst) to 95 (best).
            Values above 95 should be avoided; 100 disables portions of
            the JPEG compression algorithm, and results in large files
            with hardly any gain in image quality.

            This parameter is deprecated.

        optimize : bool, default: False
            Applicable only if *format* is 'jpg' or 'jpeg', ignored otherwise.

            Whether the encoder should make an extra pass over the image
            in order to select optimal encoder settings.

            This parameter is deprecated.

        progressive : bool, default: False
            Applicable only if *format* is 'jpg' or 'jpeg', ignored otherwise.

            Whether the image should be stored as a progressive JPEG file.

            This parameter is deprecated.

        facecolor : color or 'auto', default: :rc:`savefig.facecolor`
            The facecolor of the figure.  If 'auto', use the current figure
            facecolor.

        edgecolor : color or 'auto', default: :rc:`savefig.edgecolor`
            The edgecolor of the figure.  If 'auto', use the current figure
            edgecolor.

        orientation : {'landscape', 'portrait'}
            Currently only supported by the postscript backend.

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

        format : str
            The file format, e.g. 'png', 'pdf', 'svg', ... The behavior when
            this is unset is documented under *fname*.

        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.

        bbox_inches : str or `.Bbox`, default: :rc:`savefig.bbox`
            Bounding box in inches: only the given portion of the figure is
            saved.  If 'tight', try to figure out the tight bbox of the figure.

        pad_inches : float, default: :rc:`savefig.pad_inches`
            Amount of padding around the figure when bbox_inches is 'tight'.

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

        backend : str, optional
            Use a non-default backend to render the file, e.g. to render a
            png file with the "cairo" backend rather than the default "agg",
            or a pdf file with the "pgf" backend rather than the default
            "pdf".  Note that the default backend is normally sufficient.  See
            :ref:`the-builtin-backends` for a list of valid backends for each
            file format.  Custom backends can be referenced as "module://...".

        metadata : dict, optional
            Key/value pairs to store in the image metadata. The supported keys
            and defaults depend on the image format and backend:

            - 'png' with Agg backend: See the parameter ``metadata`` of
              `~.FigureCanvasAgg.print_png`.
            - 'pdf' with pdf backend: See the parameter ``metadata`` of
              `~.backend_pdf.PdfPages`.
            - 'svg' with svg backend: See the parameter ``metadata`` of
              `~.FigureCanvasSVG.print_svg`.
            - 'eps' and 'ps' with PS backend: Only 'Creator' is supported.

        pil_kwargs : dict, optional
            Additional keyword arguments that are passed to
            `PIL.Image.Image.save` when saving the figure.

    sca(ax)
        Set the current Axes to *ax* and the current Figure 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=<deprecated parameter>, edgecolors=None, *, plotnonfinite=False, data=None, **kwargs)
        A scatter plot of *y* vs. *x* with varying marker size and/or color.

        Parameters
        ----------
        x, y : float or array-like, shape (n, )
            The data positions.

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

        c : array-like or list of colors or color, optional
            The marker colors. Possible values:

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

            Note that *c* should not be a single numeric RGB or RGBA sequence
            because that is indistinguishable from an array of values to be
            colormapped. If you want to specify the same RGB or RGBA value for
            all points, use a 2-D array with a single row.  Otherwise, value-
            matching will have precedence in case of a size matching with *x*
            and *y*.

            If you wish to specify a single color for all points
            prefer the *color* keyword argument.

            Defaults to `None`. In that case the marker color is determined
            by the value of *color*, *facecolor* or *facecolors*. In case
            those are not specified or `None`, the marker color is determined
            by the next color of the ``Axes``' current "shape and fill" color
            cycle. This cycle defaults to :rc:`axes.prop_cycle`.

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

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

        norm : `~matplotlib.colors.Normalize`, default: None
            If *c* is an array of floats, *norm* is used to scale the color
            data, *c*, in the range 0 to 1, in order to map into the colormap
            *cmap*.
            If *None*, use the default `.colors.Normalize`.

        vmin, vmax : float, default: None
            *vmin* and *vmax* are used in conjunction with the default norm to
            map the color array *c* to the colormap *cmap*. If None, the
            respective min and max of the color array is used.
            It is deprecated to use *vmin*/*vmax* when *norm* is given.

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

        linewidths : float or array-like, default: :rc:`lines.linewidth`
            The linewidth of the marker edges. Note: The default *edgecolors*
            is 'face'. You may want to change this as well.

        edgecolors : {'face', 'none', *None*} or color or sequence of color, default: :rc:`scatter.edgecolors`
            The edge color of the marker. Possible values:

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

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

        plotnonfinite : bool, default: False
            Set to plot points with nonfinite *c*, in conjunction with
            `~matplotlib.colors.Colormap.set_bad`.

        Returns
        -------
        `~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 N-D arrays, but within scatter they will be
          flattened. The exception is *c*, which will be flattened only if its
          size matches the size of *x* and *y*.

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*, *s*, *linewidths*, *edgecolors*, *c*, *facecolor*, *facecolors*, *color*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    sci(im)
        Set the current image.

        This image will be the target of colormap functions like
        `~.pyplot.viridis`, and other functions such as `~.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 *base*, *subs*, and *nonpositive* control the
        x-axis properties. They are just forwarded to `.Axes.set_xscale`.

        Parameters
        ----------
        base : float, default: 10
            Base of the x logarithm.

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

        nonpositive : {'mask', 'clip'}, 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 *base*, *subs*, and *nonpositive* control the
        y-axis properties. They are just forwarded to `.Axes.set_yscale`.

        Parameters
        ----------
        base : float, default: 10
            Base of the y logarithm.

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

        nonpositive : {'mask', 'clip'}, 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, and applies it to the current image if any.

        Parameters
        ----------
        cmap : `~matplotlib.colors.Colormap` or str
            A colormap instance or the name of a registered colormap.

        See Also
        --------
        colormaps
        matplotlib.cm.register_cmap
        matplotlib.cm.get_cmap

    setp(obj, *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: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}

        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

        By default `setp` prints to `sys.stdout`, but this can be modified 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.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(close=None, block=None)
        Display all open figures.

        In non-interactive mode, *block* defaults to True.  All figures
        will display and show will not return until all windows are closed.
        If there are no figures, return immediately.

        In interactive mode *block* defaults to False.  This will ensure
        that all of the figures are shown and this function immediately returns.

        Parameters
        ----------
        block : bool, optional

            If `True` block and run the GUI main loop until all windows
            are closed.

            If `False` ensure that all windows are displayed and return
            immediately.  In this case, you are responsible for ensuring
            that the event loop is running to have responsive figures.

        See Also
        --------
        ion : enable interactive mode
        ioff : disable interactive mode

    specgram(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, cmap=None, xextent=None, pad_to=None, sides=None, scale_by_freq=None, mode=None, scale=None, vmin=None, vmax=None, *, data=None, **kwargs)
        Plot a spectrogram.

        Compute and plot a spectrogram of data in *x*.  Data are split into
        *NFFT* length segments and the spectrum of each section is
        computed.  The windowing function *window* is applied to each
        segment, and the amount of overlap of each segment is
        specified with *noverlap*. The spectrogram is plotted as a colormap
        (using imshow).

        Parameters
        ----------
        x : 1-D array or sequence
            Array or sequence containing the data.

        Fs : float, default: 2
            The sampling frequency (samples per time unit).  It is used to calculate
            the Fourier frequencies, *freqs*, in cycles per time unit.

        window : callable or ndarray, default: `.window_hanning`
            A function or a vector of length *NFFT*.  To create window vectors see
            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a
            function is passed as the argument, it must take a data segment as an
            argument and return the windowed version of the segment.

        sides : {'default', 'onesided', 'twosided'}, optional
            Which sides of the spectrum to return. 'default' is one-sided for real
            data and two-sided for complex data. 'onesided' forces the return of a
            one-sided spectrum, while 'twosided' forces two-sided.

        pad_to : int, optional
            The number of points to which the data segment is padded when performing
            the FFT.  This can be different from *NFFT*, which specifies the number
            of data points used.  While not increasing the actual resolution of the
            spectrum (the minimum distance between resolvable peaks), this can give
            more points in the plot, allowing for more detail. This corresponds to
            the *n* parameter in the call to fft(). The default is None, which sets
            *pad_to* equal to *NFFT*

        NFFT : int, default: 256
            The number of data points used in each block for the FFT.  A power 2 is
            most efficient.  This should *NOT* be used to get zero padding, or the
            scaling of the result will be incorrect; use *pad_to* for this instead.

        detrend : {'none', 'mean', 'linear'} or callable, default 'none'
            The function applied to each segment before fft-ing, designed to remove
            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter
            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`
            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,
            but you can use a custom function as well.  You can also use a string to
            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls
            `.detrend_mean`. 'linear' calls `.detrend_linear`.

        scale_by_freq : bool, default: True
            Whether the resulting density values should be scaled by the scaling
            frequency, which gives density in units of Hz^-1.  This allows for
            integration over the returned frequency values.  The default is True for
            MATLAB compatibility.

        mode : {'default', 'psd', 'magnitude', 'angle', 'phase'}
            What sort of spectrum to use.  Default is 'psd', which takes the
            power spectral density.  'magnitude' returns the magnitude
            spectrum.  'angle' returns the phase spectrum without unwrapping.
            'phase' returns the phase spectrum with unwrapping.

        noverlap : int
            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 : int, default: 0
            The center frequency of *x*, which offsets the x extents of the
            plot to reflect the frequency range used when a signal is acquired
            and then filtered and downsampled to baseband.

        cmap : `.Colormap`, default: :rc:`image.cmap`

        xextent : *None* or (xmin, xmax)
            The image extent along the x-axis. The default sets *xmin* to the
            left border of the first bin (*spectrum* column) and *xmax* to the
            right border of the last bin. Note that for *noverlap>0* the width
            of the bins is smaller than those of the segments.

        **kwargs
            Additional keyword arguments are passed on to `~.axes.Axes.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 : `.AxesImage`
            The image created by imshow containing the spectrogram.

        See Also
        --------
        psd
            Differs in the default overlap; in returning the mean of the
            segment periodograms; in not returning times; and in generating a
            line plot instead of colormap.
        magnitude_spectrum
            A single spectrum, similar to having a single segment when *mode*
            is 'magnitude'. Plots a line instead of a colormap.
        angle_spectrum
            A single spectrum, similar to having a single segment when *mode*
            is 'angle'. Plots a line instead of a colormap.
        phase_spectrum
            A single spectrum, similar to having a single segment when *mode*
            is 'phase'. Plots a line instead of a colormap.

        Notes
        -----
        The parameters *detrend* and *scale_by_freq* do only apply when *mode*
        is set to 'psd'.

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    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', origin='upper', **kwargs)
        Plot the sparsity pattern of a 2D array.

        This visualizes the non-zero values of the array.

        Two plotting styles are available: image and marker. Both
        are available for full arrays, but only the marker style
        works for `scipy.sparse.spmatrix` instances.

        **Image style**

        If *marker* and *markersize* are *None*, `~.Axes.imshow` is used. Any
        extra remaining keyword arguments are passed to this method.

        **Marker style**

        If *Z* is a `scipy.sparse.spmatrix` or *marker* or *markersize* are
        *None*, a `.Line2D` object will be returned with the value of marker
        determining the marker type, and any remaining keyword arguments
        passed to `~.Axes.plot`.

        Parameters
        ----------
        Z : array-like (M, N)
            The array to be plotted.

        precision : float or 'present', default: 0
            If *precision* is 0, any non-zero value will be plotted. Otherwise,
            values of :math:`|Z| > precision` will be plotted.

            For `scipy.sparse.spmatrix` instances, you can also
            pass 'present'. In this case any value present in the array
            will be plotted, even if it is identically zero.

        aspect : {'equal', 'auto', None} or float, default: 'equal'
            The aspect ratio of the axes.  This parameter is particularly
            relevant for images since it determines whether data pixels are
            square.

            This parameter is a shortcut for explicitly calling
            `.Axes.set_aspect`. See there for further details.

            - 'equal': Ensures an aspect ratio of 1. Pixels will be square.
            - 'auto': The axes is kept fixed and the aspect is adjusted so
              that the data fit in the axes. In general, this will result in
              non-square pixels.
            - *None*: Use :rc:`image.aspect`.

        origin : {'upper', 'lower'}, default: :rc:`image.origin`
            Place the [0, 0] index of the array in the upper left or lower left
            corner of the axes. The convention 'upper' is typically used for
            matrices and images.

        Returns
        -------
        `~matplotlib.image.AxesImage` or `.Line2D`
            The return type depends on the plotting style (see above).

        Other Parameters
        ----------------
        **kwargs
            The supported additional parameters depend on the plotting style.

            For the image style, you can pass the following additional
            parameters of `~.Axes.imshow`:

            - *cmap*
            - *alpha*
            - *url*
            - any `.Artist` properties (passed on to the `.AxesImage`)

            For the marker style, you can pass any `.Line2D` property except
            for *linestyle*:

            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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            dash_capstyle: {'butt', 'round', 'projecting'}
            dash_joinstyle: {'miter', 'round', 'bevel'}
            dashes: sequence of floats (on/off ink in points) or (None, None)
            data: (2, N) array or two 1D arrays
            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
            figure: `.Figure`
            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}
            gid: str
            in_layout: bool
            label: object
            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            linewidth or lw: float
            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`
            markeredgecolor or mec: color
            markeredgewidth or mew: float
            markerfacecolor or mfc: color
            markerfacecoloralt or mfcalt: color
            markersize or ms: float
            markevery: None or int or (int, int) or slice or List[int] or float or (float, float) or List[bool]
            path_effects: `.AbstractPathEffect`
            picker: unknown
            pickradius: float
            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: `matplotlib.transforms.Transform`
            url: str
            visible: bool
            xdata: 1D array
            ydata: 1D array
            zorder: float

    stackplot(x, *args, labels=(), colors=None, baseline='zero', data=None, **kwargs)
        Draw 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.

        Notes
        -----

        .. note::
            In addition to the above described arguments, this function can take
            a *data* keyword argument. If such a *data* argument is given,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    stem(*args, linefmt=None, markerfmt=None, basefmt=None, bottom=0, label=None, use_line_collection=True, data=None)
        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 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, default: 'C3-' ('C2-' in classic mode)
            A format string defining the properties of the baseline.

        bottom : float, default: 0
            The y-position of the baseline.

        label : str, default: None
            The label to use for the stems in legends.

        use_line_collection : bool, default: True
            If ``True``, store and plot the stem lines as a
            `~.collections.LineCollection` instead of individual lines, which
            significantly increases performance.  If ``False``, defaults to the
            old behavior of using a list of `.Line2D` objects.  This parameter
            may be deprecated in the future.

        Returns
        -------
        `.StemContainer`
            The container may be treated like a tuple
            (*markerline*, *stemlines*, *baseline*)

        Notes
        -----
        .. seealso::
            The MATLAB function
            `stem <https://www.mathworks.com/help/matlab/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,
            every other argument can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception).

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    step(x, y, *args, where='pre', data=None, **kwargs)
        Make a step plot.

        Call signatures::

            step(x, y, [fmt], *, data=None, where='pre', **kwargs)
            step(x, y, [fmt], x2, y2, [fmt2], ..., *, where='pre', **kwargs)

        This is just a thin wrapper around `.plot` which changes some
        formatting options. Most of the concepts and parameters of plot can be
        used here as well.

        Parameters
        ----------
        x : array-like
            1-D sequence of x positions. It is assumed, but not checked, that
            it is uniformly increasing.

        y : array-like
            1-D sequence of y levels.

        fmt : str, optional
            A format string, e.g. 'g' for a green line. See `.plot` for a more
            detailed description.

            Note: While full format strings are accepted, it is recommended to
            only specify the color. Line styles are currently ignored (use
            the keyword argument *linestyle* instead). Markers are accepted
            and plotted on the given positions, however, this is a rarely
            needed feature for step plots.

        data : indexable object, optional
            An object with labelled data. If given, provide the label names to
            plot in *x* and *y*.

        where : {'pre', 'post', 'mid'}, 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]

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

        Parameters
        ----------
        x, y : 1D arrays
            An evenly spaced grid.
        u, v : 2D arrays
            *x* and *y*-velocities. The number of rows and columns must match
            the length of *y* and *x*, respectively.
        density : float or (float, float)
            Controls the closeness of streamlines. When ``density = 1``, the domain
            is divided into a 30x30 grid. *density* linearly scales this grid.
            Each cell in the grid can have, at most, one traversing streamline.
            For different densities in each direction, use a tuple
            (density_x, density_y).
        linewidth : float or 2D array
            The width of the stream lines. With a 2D array the line width can be
            varied across the grid. The array must have the same shape as *u*
            and *v*.
        color : color or 2D array
            The streamline color. If given an array, its values are converted to
            colors using *cmap* and *norm*.  The array must have the same shape
            as *u* and *v*.
        cmap : `~matplotlib.colors.Colormap`
            Colormap used to plot streamlines and arrows. This is only used if
            *color* is an array.
        norm : `~matplotlib.colors.Normalize`
            Normalize object used to scale luminance data to 0, 1. If ``None``,
            stretch (min, max) to (0, 1). This is only used if *color* is an array.
        arrowsize : float
            Scaling factor for the arrow size.
        arrowstyle : str
            Arrow style specification.
            See `~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 coordinates as the *x* and *y* arrays).
        zorder : int
            The zorder of the stream lines and arrows.
            Artists with lower zorder values are drawn first.
        maxlength : float
            Maximum length of streamline in axes coordinates.
        integration_direction : {'forward', 'backward', 'both'}, default: 'both'
            Integrate the streamline in forward, backward or both directions.

        Returns
        -------
        StreamplotSet
            Container object with attributes

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

            - ``arrows``: `.PatchCollection` containing `.FancyArrowPatch`
              objects representing the arrows half-way along stream lines.

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

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*, *u*, *v*, *start_points*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    subplot(*args, **kwargs)
        Add a subplot to the current figure.

        Wrapper of `.Figure.add_subplot` with a difference in behavior
        explained in the notes section.

        Call signatures::

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

        Parameters
        ----------
        *args : int, (int, int, *index*), or `.SubplotSpec`, default: (1, 1, 1)
            The position of the subplot described by one of

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

        projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', 'rectilinear', str}, optional
            The projection type of the subplot (`~.axes.Axes`). *str* is the name
            of a custom projection, see `~matplotlib.projections`. The default
            None results in a 'rectilinear' projection.

        polar : bool, default: False
            If True, equivalent to projection='polar'.

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

        label : str
            A label for the returned axes.

        Returns
        -------
        `.axes.SubplotBase`, or another subclass of `~.axes.Axes`

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

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

            Properties:
            adjustable: {'box', 'datalim'}
            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
            alpha: float or None
            anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}
            animated: bool
            aspect: {'auto'} or num
            autoscale_on: bool
            autoscalex_on: bool
            autoscaley_on: bool
            axes_locator: Callable[[Axes, Renderer], Bbox]
            axisbelow: bool or 'line'
            box_aspect: None, or a number
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            contains: unknown
            facecolor or fc: color
            figure: `.Figure`
            frame_on: bool
            gid: str
            in_layout: bool
            label: object
            navigate: bool
            navigate_mode: unknown
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`
            prop_cycle: unknown
            rasterization_zorder: float or None
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            title: str
            transform: `.Transform`
            url: str
            visible: bool
            xbound: unknown
            xlabel: str
            xlim: (bottom: float, top: float)
            xmargin: float greater than -0.5
            xscale: {"linear", "log", "symlog", "logit", ...}
            xticklabels: unknown
            xticks: unknown
            ybound: unknown
            ylabel: str
            ylim: (bottom: float, top: float)
            ymargin: float greater than -0.5
            yscale: {"linear", "log", "symlog", "logit", ...}
            yticklabels: unknown
            yticks: unknown
            zorder: float

        Notes
        -----
        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)

        If you do not want this behavior, use the `.Figure.add_subplot` method
        or the `.pyplot.axes` function instead.

        If the figure already has a subplot with key (*args*,
        *kwargs*) then it will simply make that subplot current and
        return it.  This behavior is deprecated. Meanwhile, if you do
        not want this behavior (i.e., you want to force the creation of a
        new subplot), you must use a unique set of args and kwargs.  The axes
        *label* attribute has been exposed for this purpose: if you want
        two subplots that are otherwise identical to be added to the figure,
        make sure you give them unique labels.

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

        See Also
        --------
        .Figure.add_subplot
        .pyplot.subplots
        .pyplot.axes
        .Figure.subplots

        Examples
        --------
        ::

            plt.subplot(221)

            # equivalent but more general
            ax1=plt.subplot(2, 2, 1)

            # add a subplot with no frame
            ax2=plt.subplot(222, frameon=False)

            # add a polar subplot
            plt.subplot(223, projection='polar')

            # add a red subplot that shares the x-axis with ax1
            plt.subplot(224, sharex=ax1, facecolor='red')

            # delete ax2 from the figure
            plt.delaxes(ax2)

            # add ax2 to the figure again
            plt.subplot(ax2)

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

        Parameters
        ----------
        shape : (int, int)
            Number of rows and of columns of the grid in which to place axis.
        loc : (int, int)
            Row number and column number of the axis location within the grid.
        rowspan : int, default: 1
            Number of rows for the axis to span to the right.
        colspan : int, default: 1
            Number of columns for the axis to span downwards.
        fig : `.Figure`, optional
            Figure to place the subplot in. Defaults to the current figure.
        **kwargs
            Additional keyword arguments are handed to `~.Figure.add_subplot`.

        Returns
        -------
        `.axes.SubplotBase`, or another subclass of `~.axes.Axes`

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

        Notes
        -----
        The following call ::

            ax = subplot2grid((nrows, ncols), (row, col), rowspan, colspan)

        is identical to ::

            fig = gcf()
            gs = fig.add_gridspec(nrows, ncols)
            ax = fig.add_subplot(gs[row:row+rowspan, col:col+colspan])

    subplot_mosaic(layout, *, subplot_kw=None, gridspec_kw=None, empty_sentinel='.', **fig_kw)
        Build a layout of Axes based on ASCII art or nested lists.

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

        .. note ::

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

        Parameters
        ----------
        layout : list of list of {hashable or nested} or str

            A visual layout of how you want your Axes to be arranged
            labeled as strings.  For example ::

               x = [['A panel', 'A panel', 'edge'],
                    ['C panel', '.',       'edge']]

            Produces 4 axes:

            - 'A panel' which is 1 row high and spans the first two columns
            - 'edge' which is 2 rows high and is on the right edge
            - 'C panel' which in 1 row and 1 column wide in the bottom left
            - a blank space 1 row and 1 column wide in the bottom center

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

            If input is a str, then it must be of the form ::

              '''
              AAE
              C.E
              '''

            where each character is a column and each line is a row.
            This only allows only single character Axes labels and does
            not allow nesting but is very terse.

        subplot_kw : dict, optional
            Dictionary with keywords passed to the `.Figure.add_subplot` call
            used to create each subplot.

        gridspec_kw : dict, optional
            Dictionary with keywords passed to the `.GridSpec` constructor used
            to create the grid the subplots are placed on.

        empty_sentinel : object, optional
            Entry in the layout to mean "leave this space empty".  Defaults
            to ``'.'``. Note, if *layout* is a string, it is processed via
            `inspect.cleandoc` to remove leading white space, which may
            interfere with using white-space as the empty sentinel.

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

        Returns
        -------
        fig : `~.figure.Figure`
           The new figure

        dict[label, Axes]
           A dictionary mapping the labels to the Axes objects.

    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, 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 created. Similarly, when subplots
            have a shared y-axis along a row, only the y tick labels of the first
            column subplot are created. To later turn other subplots' ticklabels
            on, use `~matplotlib.axes.Axes.tick_params`.

        squeeze : bool, default: True
            - If True, extra dimensions are squeezed out from the returned
              array of `~matplotlib.axes.Axes`:

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

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

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

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

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

        Returns
        -------
        fig : `~.figure.Figure`

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

            Typical idioms for handling the return value are::

                # using the variable ax for single a Axes
                fig, ax = plt.subplots()

                # using the variable axs for multiple Axes
                fig, axs = plt.subplots(2, 2)

                # using tuple unpacking for multiple Axes
                fig, (ax1, ax2) = plt.subplot(1, 2)
                fig, ((ax1, ax2), (ax3, ax4)) = plt.subplot(2, 2)

            The names ``ax`` and pluralized ``axs`` are preferred over ``axes``
            because for the latter it's not clear if it refers to a single
            `~.axes.Axes` instance or a collection of these.

        See Also
        --------
        .pyplot.figure
        .pyplot.subplot
        .pyplot.axes
        .Figure.subplots
        .Figure.add_subplot

        Examples
        --------
        ::

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

            # Create just a figure and only one subplot
            fig, ax = plt.subplots()
            ax.plot(x, y)
            ax.set_title('Simple plot')

            # Create two subplots and unpack 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)

            # Create four polar axes and access them through the returned array
            fig, axs = plt.subplots(2, 2, subplot_kw=dict(polar=True))
            axs[0, 0].plot(x, y)
            axs[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)

            # Create figure number 10 with a single subplot
            # and clears it if it already exists.
            fig, ax = plt.subplots(num=10, clear=True)

    subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=None)
        Adjust the subplot layout parameters.

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

        Parameters
        ----------
        left : float, optional
            The position of the left edge of the subplots,
            as a fraction of the figure width.
        right : float, optional
            The position of the right edge of the subplots,
            as a fraction of the figure width.
        bottom : float, optional
            The position of the bottom edge of the subplots,
            as a fraction of the figure height.
        top : float, optional
            The position of the top edge of the subplots,
            as a fraction of the figure height.
        wspace : float, optional
            The width of the padding between subplots,
            as a fraction of the average axes width.
        hspace : float, optional
            The height of the padding between subplots,
            as a fraction of the average axes height.

    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(t, **kwargs)
        Add a centered title to the figure.

        Parameters
        ----------
        t : str
            The title text.

        x : float, default 0.5
            The x location of the text in figure coordinates.

        y : float, default 0.98
            The y location of the text in figure coordinates.

        horizontalalignment, ha : {'center', 'left', right'}, default: 'center'
            The horizontal alignment of the text relative to (*x*, *y*).

        verticalalignment, va : {'top', 'center', 'bottom', 'baseline'}, default: 'top'
            The vertical alignment of the text relative to (*x*, *y*).

        fontsize, size : default: :rc:`figure.titlesize`
            The font size of the text. See `.Text.set_size` for possible
            values.

        fontweight, weight : default: :rc:`figure.titleweight`
            The font weight of the text. See `.Text.set_weight` for possible
            values.

        Returns
        -------
        text
            The `.Text` instance of the title.

        Other Parameters
        ----------------
        fontproperties : None or dict, optional
            A dict of font properties. If *fontproperties* is given the
            default values for font size and weight are taken from the
            `.FontProperties` defaults. :rc:`figure.titlesize` and
            :rc:`figure.titleweight` are ignored in this case.

        **kwargs
            Additional kwargs are `matplotlib.text.Text` properties.

        Examples
        --------
        >>> fig.suptitle('This is the figure title', fontsize=12)

    switch_backend(newbackend)
        Close all open figures and set the Matplotlib backend.

        The argument is case-insensitive.  Switching to an interactive backend is
        possible only if no event loop for another interactive backend has started.
        Switching to and from non-interactive backends is always possible.

        Parameters
        ----------
        newbackend : str
            The name of the backend to use.

    table(cellText=None, cellColours=None, cellLoc='right', colWidths=None, rowLabels=None, rowColours=None, rowLoc='left', colLabels=None, colColours=None, colLoc='center', loc='bottom', bbox=None, edges='closed', **kwargs)
        Add a table to an `~.axes.Axes`.

        At least one of *cellText* or *cellColours* must be specified. These
        parameters must be 2D lists, in which the outer lists define the rows and
        the inner list define the column values per row. Each row must have the
        same number of elements.

        The table can optionally have row and column headers, which are configured
        using *rowLabels*, *rowColours*, *rowLoc* and *colLabels*, *colColours*,
        *colLoc* respectively.

        For finer grained control over tables, use the `.Table` class and add it to
        the axes with `.Axes.add_table`.

        Parameters
        ----------
        cellText : 2D list of str, optional
            The texts to place into the table cells.

            *Note*: Line breaks in the strings are currently not accounted for and
            will result in the text exceeding the cell boundaries.

        cellColours : 2D list of colors, optional
            The background colors of the cells.

        cellLoc : {'left', 'center', 'right'}, default: 'right'
            The alignment of the text within the cells.

        colWidths : list of float, optional
            The column widths in units of the axes. If not given, all columns will
            have a width of *1 / ncols*.

        rowLabels : list of str, optional
            The text of the row header cells.

        rowColours : list of colors, optional
            The colors of the row header cells.

        rowLoc : {'left', 'center', 'right'}, default: 'left'
            The text alignment of the row header cells.

        colLabels : list of str, optional
            The text of the column header cells.

        colColours : list of colors, optional
            The colors of the column header cells.

        colLoc : {'left', 'center', 'right'}, default: 'left'
            The text alignment of the column header cells.

        loc : str, optional
            The position of the cell with respect to *ax*. This must be one of
            the `~.Table.codes`.

        bbox : `.Bbox`, optional
            A bounding box to draw the table into. If this is not *None*, this
            overrides *loc*.

        edges : substring of 'BRTL' or {'open', 'closed', 'horizontal', 'vertical'}
            The cell edges to be drawn with a line. See also
            `~.Cell.visible_edges`.

        Returns
        -------
        `~matplotlib.table.Table`
            The created table.

        Other Parameters
        ----------------
        **kwargs
            `.Table` properties.

        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
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            contains: unknown
            figure: `.Figure`
            fontsize: float
            gid: str
            in_layout: bool
            label: object
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            rasterized: bool or None
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            transform: `.Transform`
            url: str
            visible: bool
            zorder: float

    text(x, y, s, fontdict=None, **kwargs)
        Add text to the axes.

        Add the text *s* to the axes at location *x*, *y* in data coordinates.

        Parameters
        ----------
        x, y : float
            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 : dict, default: None
            A dictionary to override the default text properties. If fontdict
            is None, the defaults are determined by `.rcParams`.

        Returns
        -------
        `.Text`
            The created `.Text` instance.

        Other Parameters
        ----------------
        **kwargs : `~matplotlib.text.Text` properties.
            Other miscellaneous text parameters.

            Properties:
            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
            alpha: float or None
            animated: bool
            backgroundcolor: color
            bbox: dict with properties for `.patches.FancyBboxPatch`
            clip_box: `.Bbox`
            clip_on: bool
            clip_path: Patch or (Path, Transform) or None
            color or c: color
            contains: unknown
            figure: `.Figure`
            fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}
            fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`
            fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}
            fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}
            fontstyle or style: {'normal', 'italic', 'oblique'}
            fontvariant or variant: {'normal', 'small-caps'}
            fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}
            gid: str
            horizontalalignment or ha: {'center', 'right', 'left'}
            in_layout: bool
            label: object
            linespacing: float (multiple of font size)
            multialignment or ma: {'left', 'right', 'center'}
            path_effects: `.AbstractPathEffect`
            picker: None or bool or callable
            position: (float, float)
            rasterized: bool or None
            rotation: float or {'vertical', 'horizontal'}
            rotation_mode: {None, 'default', 'anchor'}
            sketch_params: (scale: float, length: float, randomness: float)
            snap: bool or None
            text: object
            transform: `.Transform`
            url: str
            usetex: bool or None
            verticalalignment or va: {'center', 'top', 'bottom', 'baseline', 'center_baseline'}
            visible: bool
            wrap: bool
            x: float
            y: float
            zorder: float

        Examples
        --------
        Individual keyword arguments can be used to override any given
        parameter::

            >>> text(x, y, s, fontsize=12)

        The default transform specifies that text is in data coords,
        alternatively, you can specify text in axis coords ((0, 0) is
        lower-left and (1, 1) is upper-right).  The example below places
        text in the center of the axes::

            >>> text(0.5, 0.5, 'matplotlib', horizontalalignment='center',
            ...      verticalalignment='center', transform=ax.transAxes)

        You can put a rectangular box around the text instance (e.g., to
        set a background color) by using the keyword *bbox*.  *bbox* is
        a dictionary of `~matplotlib.patches.Rectangle`
        properties.  For example::

            >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))

    thetagrids(angles=None, labels=None, fmt=None, **kwargs)
        Get or set the theta gridlines on the current polar plot.

        Call signatures::

         lines, labels = thetagrids()
         lines, labels = thetagrids(angles, labels=None, fmt=None, **kwargs)

        When called with no arguments, `.thetagrids` simply returns the tuple
        (*lines*, *labels*). When called with arguments, the labels will
        appear at the specified angles.

        Parameters
        ----------
        angles : tuple with floats, degrees
            The angles of the theta gridlines.

        labels : tuple with strings or None
            The labels to use at each radial gridline. The
            `.projections.polar.ThetaFormatter` will be used if None.

        fmt : str or None
            Format string used in `matplotlib.ticker.FormatStrFormatter`.
            For example '%f'. Note that the angle in radians will be used.

        Returns
        -------
        lines : list of `.lines.Line2D`
            The theta gridlines.

        labels : list of `.text.Text`
            The tick labels.

        Other Parameters
        ----------------
        **kwargs
            *kwargs* are optional `~.Text` properties for the labels.

        See Also
        --------
        .pyplot.rgrids
        .projections.polar.PolarAxes.set_thetagrids
        .Axis.get_gridlines
        .Axis.get_ticklabels

        Examples
        --------
        ::

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

          # set the locations and labels of the angular gridlines
          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.

        Tick properties that are not explicitly set using the keyword
        arguments remain unchanged unless *reset* is True.

        Parameters
        ----------
        axis : {'x', 'y', 'both'}, default: 'both'
            The axis to which the parameters are applied.
        which : {'major', 'minor', 'both'}, default: 'major'
            The group of ticks to which the parameters are applied.
        reset : bool, default: False
            Whether to reset the ticks to defaults before updating them.

        Other Parameters
        ----------------
        direction : {'in', 'out', 'inout'}
            Puts ticks inside the axes, outside the axes, or both.
        length : float
            Tick length in points.
        width : float
            Tick width in points.
        color : color
            Tick color.
        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.
        colors : color
            Tick color and label color.
        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
            Gridline color.
        grid_alpha : float
            Transparency of gridlines: 0 (transparent) to 1 (opaque).
        grid_linewidth : float
            Width of gridlines in points.
        grid_linestyle : str
            Any valid `.Line2D` line style spec.

        Examples
        --------
        ::

            ax.tick_params(direction='out', length=6, width=2, colors='r',
                           grid_color='r', grid_alpha=0.5)

        This will make all major ticks be red, pointing out of the box,
        and with dimensions 6 points by 2 points.  Tick labels will
        also be red.  Gridlines will be red and translucent.

    ticklabel_format(*, axis='both', style='', scilimits=None, useOffset=None, useLocale=None, useMathText=None)
        Configure the `.ScalarFormatter` used by default for linear axes.

        If a parameter is not set, the corresponding property of the formatter
        is left unchanged.

        Parameters
        ----------
        axis : {'x', 'y', 'both'}, default: 'both'
            The axes to configure.  Only major ticks are affected.

        style : {'sci', 'scientific', 'plain'}
            Whether to use scientific notation.
            The formatter default is to use scientific notation.

        scilimits : pair of ints (m, n)
            Scientific notation is used only for numbers outside the range
            10\ :sup:`m` to 10\ :sup:`n` (and only if the formatter is
            configured to use scientific notation at all).  Use (0, 0) to
            include all numbers.  Use (m, m) where m != 0 to fix the order of
            magnitude to 10\ :sup:`m`.
            The formatter default is :rc:`axes.formatter.limits`.

        useOffset : bool or float
            If True, the offset is calculated as needed.
            If False, no offset is used.
            If a numeric value, it sets the offset.
            The formatter default is :rc:`axes.formatter.useoffset`.

        useLocale : bool
            Whether to format the number using the current locale or using the
            C (English) locale.  This affects e.g. the decimal separator.  The
            formatter default is :rc:`axes.formatter.use_locale`.

        useMathText : bool
            Render the offset and scientific notation in mathtext.
            The formatter default is :rc:`axes.formatter.use_mathtext`.

        Raises
        ------
        AttributeError
            If the current formatter is not a `.ScalarFormatter`.

    tight_layout(*, pad=1.08, h_pad=None, w_pad=None, rect=None)
        Adjust the padding between and around subplots.

        Parameters
        ----------
        pad : float, default: 1.08
            Padding between the figure edge and the edges of subplots,
            as a fraction of the font size.
        h_pad, w_pad : float, default: *pad*
            Padding (height/width) between edges of adjacent subplots,
            as a fraction of the font size.
        rect : tuple (left, bottom, right, top), default: (0, 0, 1, 1)
            A rectangle in normalized figure coordinates into which the whole
            subplots area (including labels) will fit.

    title(label, fontdict=None, loc=None, pad=None, *, y=None, **kwargs)
        Set a title for the axes.

        Set one of the three available axes titles. The available titles
        are positioned above the axes in the center, flush with the left
        edge, and flush with the right edge.

        Parameters
        ----------
        label : str
            Text to use for the title

        fontdict : dict
            A dictionary controlling the appearance of the title text,
            the default *fontdict* is::

               {'fontsize': rcParams['axes.titlesize'],
                'fontweight': rcParams['axes.titleweight'],
                'color': rcParams['axes.titlecolor'],
                'verticalalignment': 'baseline',
                'horizontalalignment': loc}

        loc : {'center', 'left', 'right'}, default: :rc:`axes.titlelocation`
            Which title to set.

        y : float, default: :rc:`axes.titley`
            Vertical axes loation for the title (1.0 is the top).  If
            None (the default), y is determined automatically to avoid
            decorators on the axes.

        pad : float, default: :rc:`axes.titlepad`
            The offset of the title from the top of the axes, in points.

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

        Other Parameters
        ----------------
        **kwargs : `.Text` properties
            Other keyword arguments are text properties, see `.Text` for a list
            of valid text properties.

    tricontour(*args, **kwargs)
        Draw contour lines on an unstructured triangular grid.

        The triangulation can be specified in one of two ways; either ::

            tricontour(triangulation, ...)

        where *triangulation* is a `.Triangulation` object, or ::

            tricontour(x, y, ...)
            tricontour(x, y, triangles, ...)
            tricontour(x, y, triangles=triangles, ...)
            tricontour(x, y, mask=mask, ...)
            tricontour(x, y, triangles, mask=mask, ...)

        in which case a `.Triangulation` object will be created.  See that class'
        docstring for an explanation of these cases.

        The remaining arguments may be::

            tricontour(..., Z)

        where *Z* is the array of values to contour, one per point in the
        triangulation.  The level values are chosen automatically.

        ::

            tricontour(..., Z, levels)

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

        ::

            tricontour(..., Z, levels)

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

        ::

            tricontour(Z, **kwargs)

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

        Parameters
        ----------
        triangulation : `.Triangulation`, optional
            The unstructured triangular grid.

            If specified, then *x*, *y*, *triangles*, and *mask* are not accepted.

        x, y : array-like, optional
            The coordinates of the values in *Z*.

        triangles : int array-like of shape (ntri, 3), optional
            For each triangle, the indices of the three points that make up the
            triangle, ordered in an anticlockwise manner.  If not specified, the
            Delaunay triangulation is calculated.

        mask : bool array-like of shape (ntri), optional
            Which triangles are masked out.

        Z : array-like(N, M)
            The height values over which the contour is drawn.

        levels : int or array-like, optional
            Determines the number and positions of the contour lines / regions.

            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to
            automatically choose no more than *n+1* "nice" contour levels between
            *vmin* and *vmax*.

            If array-like, draw contour lines at the specified levels.  The values must
            be in increasing order.

        Returns
        -------
        `~matplotlib.tri.TriContourSet`

        Other Parameters
        ----------------
        colors : color string or sequence of colors, optional
            The colors of the levels, i.e., the contour lines.

            The sequence is cycled for the levels in ascending order. If the sequence
            is shorter than the number of levels, it's repeated.

            As a shortcut, single color strings may be used in place of one-element
            lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the
            same color. This shortcut does only work for color strings, not for other
            ways of specifying colors.

            By default (value *None*), the colormap specified by *cmap* will be used.

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

        cmap : str or `.Colormap`, default: :rc:`image.cmap`
            A `.Colormap` instance or registered colormap name. The colormap maps the
            level values to colors.

            If both *colors* and *cmap* are given, an error is raised.

        norm : `~matplotlib.colors.Normalize`, optional
            If a colormap is used, the `.Normalize` instance scales the level values to
            the canonical colormap range [0, 1] for mapping to colors. If not given,
            the default linear scaling is used.

        origin : {*None*, 'upper', 'lower', 'image'}, default: None
            Determines the orientation and exact position of *Z* by specifying the
            position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y* are not given.

            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.
            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.
            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.
            - 'image': Use the value from :rc:`image.origin`.

        extent : (x0, x1, y0, y1), optional
            If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it
            gives the outer pixel boundaries. In this case, the position of Z[0, 0] is
            the center of the pixel, not a corner. If *origin* is *None*, then
            (*x0*, *y0*) is the position of Z[0, 0], and (*x1*, *y1*) is the position
            of Z[-1, -1].

            This argument is ignored if *X* and *Y* are specified in the call to
            contour.

        locator : ticker.Locator subclass, optional
            The locator is used to determine the contour levels if they are not given
            explicitly via *levels*.
            Defaults to `~.ticker.MaxNLocator`.

        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'
            Determines the ``tricontour``-coloring of values that are outside the
            *levels* range.

            If 'neither', values outside the *levels* range are not colored.  If 'min',
            'max' or 'both', color the values below, above or below and above the
            *levels* range.

            Values below ``min(levels)`` and above ``max(levels)`` are mapped to the
            under/over values of the `.Colormap`. Note that most colormaps do not have
            dedicated colors for these by default, so that the over and under values
            are the edge values of the colormap.  You may want to set these values
            explicitly using `.Colormap.set_under` and `.Colormap.set_over`.

            .. note::

                An existing `.TriContourSet` does not get notified if properties of its
                colormap are changed. Therefore, an explicit call to
                `.ContourSet.changed()` is needed after modifying the colormap. The
                explicit call can be left out, if a colorbar is assigned to the
                `.TriContourSet` because it internally calls `.ContourSet.changed()`.

        xunits, yunits : registered units, optional
            Override axis units by specifying an instance of a
            :class:`matplotlib.units.ConversionInterface`.

        linewidths : float or array-like, default: :rc:`contour.linewidth`
            The line width of the contour lines.

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

            If a sequence, the levels in ascending order will be plotted with
            the linewidths in the order specified.

            If None, this falls back to :rc:`lines.linewidth`.

        linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional
            If *linestyles* is *None*, the default is 'solid' unless the lines are
            monochrome.  In that case, negative contours will take their linestyle
            from :rc:`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.

    tricontourf(*args, **kwargs)
        Draw contour regions on an unstructured triangular grid.

        The triangulation can be specified in one of two ways; either ::

            tricontourf(triangulation, ...)

        where *triangulation* is a `.Triangulation` object, or ::

            tricontourf(x, y, ...)
            tricontourf(x, y, triangles, ...)
            tricontourf(x, y, triangles=triangles, ...)
            tricontourf(x, y, mask=mask, ...)
            tricontourf(x, y, triangles, mask=mask, ...)

        in which case a `.Triangulation` object will be created.  See that class'
        docstring for an explanation of these cases.

        The remaining arguments may be::

            tricontourf(..., Z)

        where *Z* is the array of values to contour, one per point in the
        triangulation.  The level values are chosen automatically.

        ::

            tricontourf(..., Z, levels)

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

        ::

            tricontourf(..., Z, levels)

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

        ::

            tricontourf(Z, **kwargs)

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

        Parameters
        ----------
        triangulation : `.Triangulation`, optional
            The unstructured triangular grid.

            If specified, then *x*, *y*, *triangles*, and *mask* are not accepted.

        x, y : array-like, optional
            The coordinates of the values in *Z*.

        triangles : int array-like of shape (ntri, 3), optional
            For each triangle, the indices of the three points that make up the
            triangle, ordered in an anticlockwise manner.  If not specified, the
            Delaunay triangulation is calculated.

        mask : bool array-like of shape (ntri), optional
            Which triangles are masked out.

        Z : array-like(N, M)
            The height values over which the contour is drawn.

        levels : int or array-like, optional
            Determines the number and positions of the contour lines / regions.

            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to
            automatically choose no more than *n+1* "nice" contour levels between
            *vmin* and *vmax*.

            If array-like, draw contour lines at the specified levels.  The values must
            be in increasing order.

        Returns
        -------
        `~matplotlib.tri.TriContourSet`

        Other Parameters
        ----------------
        colors : color string or sequence of colors, optional
            The colors of the levels, i.e., the contour regions.

            The sequence is cycled for the levels in ascending order. If the sequence
            is shorter than the number of levels, it's repeated.

            As a shortcut, single color strings may be used in place of one-element
            lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the
            same color. This shortcut does only work for color strings, not for other
            ways of specifying colors.

            By default (value *None*), the colormap specified by *cmap* will be used.

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

        cmap : str or `.Colormap`, default: :rc:`image.cmap`
            A `.Colormap` instance or registered colormap name. The colormap maps the
            level values to colors.

            If both *colors* and *cmap* are given, an error is raised.

        norm : `~matplotlib.colors.Normalize`, optional
            If a colormap is used, the `.Normalize` instance scales the level values to
            the canonical colormap range [0, 1] for mapping to colors. If not given,
            the default linear scaling is used.

        origin : {*None*, 'upper', 'lower', 'image'}, default: None
            Determines the orientation and exact position of *Z* by specifying the
            position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y* are not given.

            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.
            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.
            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.
            - 'image': Use the value from :rc:`image.origin`.

        extent : (x0, x1, y0, y1), optional
            If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it
            gives the outer pixel boundaries. In this case, the position of Z[0, 0] is
            the center of the pixel, not a corner. If *origin* is *None*, then
            (*x0*, *y0*) is the position of Z[0, 0], and (*x1*, *y1*) is the position
            of Z[-1, -1].

            This argument is ignored if *X* and *Y* are specified in the call to
            contour.

        locator : ticker.Locator subclass, optional
            The locator is used to determine the contour levels if they are not given
            explicitly via *levels*.
            Defaults to `~.ticker.MaxNLocator`.

        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'
            Determines the ``tricontourf``-coloring of values that are outside the
            *levels* range.

            If 'neither', values outside the *levels* range are not colored.  If 'min',
            'max' or 'both', color the values below, above or below and above the
            *levels* range.

            Values below ``min(levels)`` and above ``max(levels)`` are mapped to the
            under/over values of the `.Colormap`. Note that most colormaps do not have
            dedicated colors for these by default, so that the over and under values
            are the edge values of the colormap.  You may want to set these values
            explicitly using `.Colormap.set_under` and `.Colormap.set_over`.

            .. note::

                An existing `.TriContourSet` does not get notified if properties of its
                colormap are changed. Therefore, an explicit call to
                `.ContourSet.changed()` is needed after modifying the colormap. The
                explicit call can be left out, if a colorbar is assigned to the
                `.TriContourSet` because it internally calls `.ContourSet.changed()`.

        xunits, yunits : registered units, optional
            Override axis units by specifying an instance of a
            :class:`matplotlib.units.ConversionInterface`.

        antialiased : bool, default: True
            Whether to use antialiasing.

        Notes
        -----
        `.tricontourf` fills intervals that are closed at the top; that is, for
        boundaries *z1* and *z2*, the filled region is::

            z1 < Z <= z2

        except for the lowest interval, which is closed on both sides (i.e. it
        includes the lowest value).

    tripcolor(*args, alpha=1.0, norm=None, cmap=None, vmin=None, vmax=None, shading='flat', facecolors=None, **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 `.Triangulation` object, or

        ::

          tripcolor(x, y, ...)
          tripcolor(x, y, triangles, ...)
          tripcolor(x, y, triangles=triangles, ...)
          tripcolor(x, y, mask=mask, ...)
          tripcolor(x, y, triangles, mask=mask, ...)

        in which case a Triangulation object will be created.  See `.Triangulation`
        for a explanation of these possibilities.

        The next argument must be *C*, the array of color values, either
        one per point in the triangulation if color values are defined at
        points, or one per triangle in the triangulation if color values
        are defined at triangles. If there are the same number of points
        and triangles in the triangulation it is assumed that color
        values are defined at points; to force the use of color values at
        triangles use the kwarg ``facecolors=C`` instead of just ``C``.

        *shading* may be 'flat' (the default) or 'gouraud'. If *shading*
        is 'flat' and C values are defined at points, the color values
        used for each triangle are from the mean C of the triangle's
        three points. If *shading* is 'gouraud' then color values must be
        defined at points.

        The remaining kwargs are the same as for `~.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 `.Triangulation` object, or

        ::

          triplot(x, y, ...)
          triplot(x, y, triangles, ...)
          triplot(x, y, triangles=triangles, ...)
          triplot(x, y, mask=mask, ...)
          triplot(x, y, triangles, mask=mask, ...)

        in which case a Triangulation object will be created.  See `.Triangulation`
        for a explanation of these possibilities.

        The remaining args and kwargs are the same as for `~.Axes.plot`.

        Returns
        -------
        lines : `~matplotlib.lines.Line2D`
            The drawn triangles edges.
        markers : `~matplotlib.lines.Line2D`
            The drawn marker nodes.

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

        Examples
        --------
        :doc:`/gallery/subplots_axes_and_figures/two_scales`

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

        Examples
        --------
        :doc:`/gallery/subplots_axes_and_figures/two_scales`

    uninstall_repl_displayhook()
        Uninstall 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, quantiles=None, points=100, bw_method=None, *, data=None)
        Make a violin plot.

        Make a violin plot for each column of *dataset* or each vector in
        sequence *dataset*.  Each filled area extends to represent the
        entire data range, with optional lines at the mean, the median,
        the minimum, the maximum, and user-specified quantiles.

        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.

        quantiles : array-like, default: None
          If not None, set a list of floats in interval [0, 1] for each violin,
          which stands for the quantiles that will be rendered for that
          violin.

        points : int, 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
        -------
        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 `~.collections.PolyCollection`
            instances containing the filled area of each violin.

          - ``cmeans``: A `~.collections.LineCollection` instance that marks
            the mean values of each of the violin's distribution.

          - ``cmins``: A `~.collections.LineCollection` instance that marks
            the bottom of each violin's distribution.

          - ``cmaxes``: A `~.collections.LineCollection` instance that marks
            the top of each violin's distribution.

          - ``cbars``: A `~.collections.LineCollection` instance that marks
            the centers of each violin's distribution.

          - ``cmedians``: A `~.collections.LineCollection` instance that
            marks the median values of each of the violin's distribution.

          - ``cquantiles``: A `~.collections.LineCollection` instance created
            to identify the quantile values of each of the violin's
            distribution.

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *dataset*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    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=None, linestyles='solid', label='', *, data=None, **kwargs)
        Plot vertical lines.

        Plot vertical lines at each *x* from *ymin* to *ymax*.

        Parameters
        ----------
        x : float or array-like
            x-indexes where to plot the lines.

        ymin, ymax : float or array-like
            Respective beginning and end of each line. If scalars are
            provided, all lines will have same length.

        colors : list of colors, default: :rc:`lines.color`

        linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional

        label : str, default: ''

        Returns
        -------
        `~matplotlib.collections.LineCollection`

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

        See Also
        --------
        hlines : horizontal lines
        axvline: vertical line across the axes

        Notes
        -----

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *ymin*, *ymax*, *colors*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    waitforbuttonpress(timeout=-1)
        Blocking call to interact with the figure.

        Wait for user input and return True if a key was pressed, False if a
        mouse button was pressed and None if no input was given within
        *timeout* seconds.  Negative values deactivate *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 0x0000025DCD922430>, usevlines=True, maxlags=10, *, data=None, **kwargs)
        Plot the cross correlation between *x* and *y*.

        The correlation with lag k is defined as
        :math:`\sum_n x[n+k] \cdot y^*[n]`, where :math:`y^*` is the complex
        conjugate of :math:`y`.

        Parameters
        ----------
        x, y : array-like of length n

        detrend : callable, default: `.mlab.detrend_none` (no detrending)
            A detrending function applied to *x* and *y*.  It must have the
            signature ::

                detrend(x: np.ndarray) -> np.ndarray

        normed : bool, default: True
            If ``True``, input vectors are normalised to unit length.

        usevlines : bool, default: True
            Determines the plot style.

            If ``True``, vertical lines are plotted from 0 to the xcorr value
            using `.Axes.vlines`. Additionally, a horizontal line is plotted
            at y=0 using `.Axes.axhline`.

            If ``False``, markers are plotted at the xcorr values using
            `.Axes.plot`.

        maxlags : int, default: 10
            Number of lags to show. If None, will return all ``2 * len(x) - 1``
            lags.

        Returns
        -------
        lags : array (length ``2*maxlags+1``)
            The lag vector.
        c : array  (length ``2*maxlags+1``)
            The 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 : `.Line2D` property, optional
            The linestyle for plotting the data points.
            Only used if *usevlines* is ``False``.

        marker : str, default: 'o'
            The marker for plotting the data points.
            Only used if *usevlines* is ``False``.

        **kwargs
            Additional parameters are passed to `.Axes.vlines` and
            `.Axes.axhline` if *usevlines* is ``True``; otherwise they are
            passed to `.Axes.plot`.

        Notes
        -----
        The cross correlation is performed with `numpy.correlate` with
        ``mode = "full"``.

        .. 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 can also be string ``s``, which is
            interpreted as ``data[s]`` (unless this raises an exception):
            *x*, *y*.

            Objects passed as **data** must support item access (``data[s]``) and
            membership test (``s in data``).

    xkcd(scale=1, length=100, randomness=2)
        Turn 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(xlabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)
        Set the label for the x-axis.

        Parameters
        ----------
        xlabel : str
            The label text.

        labelpad : float, default: None
            Spacing in points from the axes bounding box including ticks
            and tick labels.

        loc : {'left', 'center', 'right'}, default: :rc:`xaxis.labellocation`
            The label position. This is a high-level alternative for passing
            parameters *x* and *horizontalalignment*.

        Other Parameters
        ----------------
        **kwargs : `.Text` properties
            `.Text` properties control the appearance of the label.

        See Also
        --------
        text : Documents the properties supported by `.Text`.

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

        Call signatures::

            left, right = xlim()  # return the current xlim
            xlim((left, right))   # set the xlim to left, right
            xlim(left, right)     # set the xlim to left, right

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

            xlim(right=3)  # adjust the right leaving left unchanged
            xlim(left=1)  # adjust the left leaving right unchanged

        Setting limits turns autoscaling off for the x-axis.

        Returns
        -------
        left, right
            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(value, **kwargs)
        Set the x-axis scale.

        Parameters
        ----------
        value : {"linear", "log", "symlog", "logit", ...}
            The axis scale type to apply.

        **kwargs
            Different keyword arguments are accepted, depending on the scale.
            See the respective class keyword arguments:

            - `matplotlib.scale.LinearScale`
            - `matplotlib.scale.LogScale`
            - `matplotlib.scale.SymmetricalLogScale`
            - `matplotlib.scale.LogitScale`

        Notes
        -----
        By default, Matplotlib supports the above mentioned scales.
        Additionally, custom scales may be registered using
        `matplotlib.scale.register_scale`. These scales can then also
        be used here.

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

        Pass no arguments to return the current values without modifying them.

        Parameters
        ----------
        ticks : array-like, optional
            The list of xtick locations.  Passing an empty list removes all xticks.
        labels : array-like, optional
            The labels to place at the given *ticks* locations.  This argument can
            only be passed if *ticks* is passed as well.
        **kwargs
            `.Text` properties can be used to control the appearance of the labels.

        Returns
        -------
        locs
            The list of xtick locations.
        labels
            The list of xlabel `.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
        --------
        >>> locs, labels = xticks()  # Get the current locations and labels.
        >>> xticks(np.arange(0, 1, step=0.2))  # Set label locations.
        >>> xticks(np.arange(3), ['Tom', 'Dick', 'Sue'])  # Set text labels.
        >>> xticks([0, 1, 2], ['January', 'February', 'March'],
        ...        rotation=20)  # Set text labels and properties.
        >>> xticks([])  # Disable xticks.

    ylabel(ylabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)
        Set the label for the y-axis.

        Parameters
        ----------
        ylabel : str
            The label text.

        labelpad : float, default: None
            Spacing in points from the axes bounding box including ticks
            and tick labels.

        loc : {'bottom', 'center', 'top'}, default: :rc:`yaxis.labellocation`
            The label position. This is a high-level alternative for passing
            parameters *y* and *horizontalalignment*.

        Other Parameters
        ----------------
        **kwargs : `.Text` properties
            `.Text` properties control the appearance of the label.

        See Also
        --------
        text : Documents the properties supported by `.Text`.

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

        Call signatures::

            bottom, top = ylim()  # return the current ylim
            ylim((bottom, top))   # set the ylim to bottom, top
            ylim(bottom, top)     # set the ylim to bottom, top

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

            ylim(top=3)  # adjust the top leaving bottom unchanged
            ylim(bottom=1)  # adjust the bottom leaving top unchanged

        Setting limits turns autoscaling off for the y-axis.

        Returns
        -------
        bottom, top
            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(value, **kwargs)
        Set the y-axis scale.

        Parameters
        ----------
        value : {"linear", "log", "symlog", "logit", ...}
            The axis scale type to apply.

        **kwargs
            Different keyword arguments are accepted, depending on the scale.
            See the respective class keyword arguments:

            - `matplotlib.scale.LinearScale`
            - `matplotlib.scale.LogScale`
            - `matplotlib.scale.SymmetricalLogScale`
            - `matplotlib.scale.LogitScale`

        Notes
        -----
        By default, Matplotlib supports the above mentioned scales.
        Additionally, custom scales may be registered using
        `matplotlib.scale.register_scale`. These scales can then also
        be used here.

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

        Pass no arguments to return the current values without modifying them.

        Parameters
        ----------
        ticks : array-like, optional
            The list of ytick locations.  Passing an empty list removes all yticks.
        labels : array-like, optional
            The labels to place at the given *ticks* locations.  This argument can
            only be passed if *ticks* is passed as well.
        **kwargs
            `.Text` properties can be used to control the appearance of the labels.

        Returns
        -------
        locs
            The list of ytick locations.
        labels
            The list of ylabel `.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
        --------
        >>> locs, labels = yticks()  # Get the current locations and labels.
        >>> yticks(np.arange(0, 1, step=0.2))  # Set label locations.
        >>> yticks(np.arange(3), ['Tom', 'Dick', 'Sue'])  # Set text labels.
        >>> yticks([0, 1, 2], ['January', 'February', 'March'],
        ...        rotation=45)  # Set text labels and properties.
        >>> yticks([])  # Disable yticks.

DATA
    rcParams = RcParams({'_internal.classic_mode': False,
         ...nor.widt...
    rcParamsDefault = RcParams({'_internal.classic_mode': False,
         ...n...
    rcParamsOrig = RcParams({'_internal.classic_mode': False,
         ...nor....

FILE
    c:\users\sarim\anaconda3\envs\myenv\lib\site-packages\matplotlib\pyplot.py

plt.plot(y)_____no_output_____y = y.cumsum()_____no_output_____plt.plot(y)_____no_output_____plt.plot(x,y)_____no_output_____plt.plot(x,y, color='r', marker='*', linestyle='--')
plt.xlabel('values', fontsize=20, color='g')
plt.title('demo plot', fontsize=20, verticalalignment='baseline', loc='right',color='b')
plt.show()_____no_output_____x, y_____no_output_____plt.scatter(x,y,edgecolors='red')_____no_output_____b= [10,20,42,30,60]
a = ['a','b','c','d','e']_____no_output_____plt.bar(a,b,width = 0.5)_____no_output_____plt.hist(y, bins=30, histtype='bar', rwidth=0.8)_____no_output_____data = [np.random.normal(0, std, 100) for std in range(1,3)]_____no_output_____data[1]_____no_output_____plt.boxplot(data, notch=True, vert=True, patch_artist=True, showfliers=True)
plt.show()_____no_output_____x_____no_output_____y_____no_output_____y2 = x*y
y2_____no_output_____plt.plot(x ,y)
plt.plot(x, y2)_____no_output_____plt.subplot(1,2,1)
plt.plot(x, y)

plt.subplot(1,2,2)
plt.plot(x,y2)

plt.tight_layout()_____no_output_____fig = plt.figure()
ax1 = fig.add_axes([0,0,1,1])
ax2 = fig.add_axes([0.1,0.6,0.3,0.3])

ax1.plot(x, y, 'r')
ax1.set_xlabel('X')
ax1.set_ylabel('Y')
ax1.set_title('Y title')

ax2.plot(x, y2, 'g')
ax2.set_xlabel('X')
ax2.set_ylabel('Y')
ax2.set_title('Y2 title')_____no_output_____iris = sns.load_dataset('iris')_____no_output_____iris_____no_output_____plt.plot(iris['sepal_length'], iris['petal_length'])_____no_output_____plt.plot(iris['sepal_width'], iris['petal_width'])_____no_output_____plt.hist(iris['sepal_length'])_____no_output_____plt.subplot(1,2,1)
plt.boxplot(iris['sepal_length'])

plt.subplot(1,2,2)
plt.boxplot(iris['petal_length'])

plt.subplot(3,3,3)
iris.plot.scatter('sepal_length', 'petal_length')_____no_output_____fig = plt.figure()
ax1 = fig.add_axes([0,0,1,1])
ax2 = fig.add_axes([0.1,0.7,0.3,0.3])

ax1.plot(iris['sepal_length'], iris['petal_length'], 'r')

ax2.plot(iris['sepal_width'], iris['petal_width'], 'g')_____no_output_____fig, ax = plt.subplots(1,2, figsize=(12,4))

ax[0].plot(x, y, x, y2)

ax[1].plot(x, y**2, 'k')_____no_output_____a = ['cat', 'dogs', 'frog', 'lion']
value = np.array([[40, 20, 14, 57]])
value = value.flatten()_____no_output_____fig, ax = plt.subplots(figsize=(4,4), dpi = 100)
explode = [0.1, 0,0,0]
ax.pie(value, labels=a, shadow= True, explode = explode, startangle=90, autopct='%1.1f', rotatelabels=True)
plt.show()_____no_output_____fig, ax = plt.subplots(dpi = 100)
value = np.array([[60,30],[73,12],[32, 87]])
value_sum = value.sum(axis=1)
value_flat = value.flatten()
size=0.3
cmap = plt.get_cmap('tab20c')
outer_colors = cmap(np.arange(3)*4)
inner_colors = cmap(np.arange(6)*3)

ax.pie(value_sum, radius=1, colors = outer_colors,
      wedgeprops= dict(width=size, edgecolor='w'))
ax.pie(value_flat, radius=1-size, colors = inner_colors,
      wedgeprops= dict(width=size, edgecolor='w'))
_____no_output_____fig, ax = plt.subplots(1,1, figsize=(4,4))

cmap = plt.get_cmap('tab20c')
color = cmap(np.arange(4)*3)

ax = plt.pie(value, labels=a, colors= color, autopct='%.2f')_____no_output_____
</code>