Vous êtes un professionnel et vous avez besoin d'une formation ? Machine Learning
avec Scikit-Learn Voir le programme détaillé

Classe « Axes »

Méthode matplotlib.axes.Axes.pcolorfast

Signature de la méthode pcolorfast

def pcolorfast(self, *args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, colorizer=None, data=None, **kwargs) 

Description

help(Axes.pcolorfast)

Create a pseudocolor plot with a non-regular rectangular grid.

Call signature::

    ax.pcolorfast([X, Y], C, /, **kwargs)

The arguments *X*, *Y*, *C* are positional-only.

This method is similar to `~.Axes.pcolor` and `~.Axes.pcolormesh`.
It's designed to provide the fastest pcolor-type plotting with the
Agg backend. To achieve this, it uses different algorithms internally
depending on the complexity of the input grid (regular rectangular,
non-regular rectangular or arbitrary quadrilateral).

.. warning::

    This method is experimental. Compared to `~.Axes.pcolor` or
    `~.Axes.pcolormesh` it has some limitations:

    - It supports only flat shading (no outlines)
    - It lacks support for log scaling of the axes.
    - It does not have a pyplot wrapper.

Parameters
----------
C : array-like
    The image data. Supported array shapes are:

    - (M, N): an image with scalar data.  Color-mapping is controlled
      by *cmap*, *norm*, *vmin*, and *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.

    This parameter can only be passed positionally.

X, Y : tuple or array-like, default: ``(0, N)``, ``(0, M)``
    *X* and *Y* are used to specify the coordinates of the
    quadrilaterals. There are different ways to do this:

    - Use tuples ``X=(xmin, xmax)`` and ``Y=(ymin, ymax)`` to define
      a *uniform rectangular grid*.

      The tuples define the outer edges of the grid. All individual
      quadrilaterals will be of the same size. This is the fastest
      version.

    - Use 1D arrays *X*, *Y* to specify a *non-uniform rectangular
      grid*.

      In this case *X* and *Y* have to be monotonic 1D arrays of length
      *N+1* and *M+1*, specifying the x and y boundaries of the cells.

      The speed is intermediate. Note: The grid is checked, and if
      found to be uniform the fast version is used.

    - Use 2D arrays *X*, *Y* if you need an *arbitrary quadrilateral
      grid* (i.e. if the quadrilaterals are not rectangular).

      In this case *X* and *Y* are 2D arrays with shape (M + 1, N + 1),
      specifying the x and y coordinates of the corners of the colored
      quadrilaterals.

      This is the most general, but the slowest to render.  It may
      produce faster and more compact output using ps, pdf, and
      svg backends, however.

    These arguments can only be passed positionally.

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 if *C* is RGB(A).

norm : str or `~matplotlib.colors.Normalize`, optional
    The normalization method used to scale scalar data to the [0, 1] range
    before mapping to colors using *cmap*. By default, a linear scaling is
    used, mapping the lowest value to 0 and the highest to 1.

    If given, this can be one of the following:

    - An instance of `.Normalize` or one of its subclasses
      (see :ref:`colormapnorms`).
    - A scale name, i.e. one of "linear", "log", "symlog", "logit", etc.  For a
      list of available scales, call `matplotlib.scale.get_scale_names()`.
      In that case, a suitable `.Normalize` subclass is dynamically generated
      and instantiated.

    This parameter is ignored if *C* is RGB(A).

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 an error to use
    *vmin*/*vmax* when a *norm* instance is given (but using a `str` *norm*
    name together with *vmin*/*vmax* is acceptable).

    This parameter is ignored if *C* is RGB(A).

colorizer : `~matplotlib.colorizer.Colorizer` or None, default: None
    The Colorizer object used to map color to data. If None, a Colorizer
    object is created from a *norm* and *cmap*.

    This parameter is ignored if *C* is RGB(A).

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

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

Returns
-------
`.AxesImage` or `.PcolorImage` or `.QuadMesh`
    The return type depends on the type of grid:

    - `.AxesImage` for a regular rectangular grid.
    - `.PcolorImage` for a non-regular rectangular grid.
    - `.QuadMesh` for a non-rectangular grid.

Other Parameters
----------------
data : indexable object, optional
    If given, all parameters also accept a string ``s``, which is
    interpreted as ``data[s]`` if ``s`` is a key in ``data``.

**kwargs
    Supported additional parameters depend on the type of grid.
    See return types of *image* for further description.

Vous êtes un professionnel et vous avez besoin d'une formation ? Programmation Python
Les compléments Voir le programme détaillé