Bug
Links
def hexbin(self, x, y, C=None, *, gridsize=100, bins=None, xscale='linear', yscale='linear', extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='face', reduce_C_function=<function mean at 0x0000020DE89D1D70>, mincnt=None, marginals=False, colorizer=None, 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. In the
*y*-direction, counting is done along vertically aligned
hexagons, not along the zig-zag chains of hexagons; see the
following illustration.
.. plot::
import numpy
import matplotlib.pyplot as plt
np.random.seed(19680801)
n= 300
x = np.random.standard_normal(n)
y = np.random.standard_normal(n)
fig, ax = plt.subplots(figsize=(4, 4))
h = ax.hexbin(x, y, gridsize=(5, 3))
hx, hy = h.get_offsets().T
ax.plot(hx[24::3], hy[24::3], 'ro-')
ax.plot(hx[-3:], hy[-3:], 'ro-')
ax.set_title('gridsize=(5, 3)')
ax.axis('off')
To get approximately regular hexagons, choose
:math:`n_x = \sqrt{3}\,n_y`.
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 colormap.
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 at least *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 : 4-tuple of float, default: *None*
The limits of the bins (xmin, xmax, ymin, ymax).
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).
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 in data coordinates.
- `.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 scalar data
to colors.
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.
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).
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 :rc:`patch.linewidth`.
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.amax`: value taken from the largest point
By default will only reduce cells with at least 1 point because some
reduction functions (such as `numpy.amax`) will error/warn with empty
input. Changing *mincnt* will adjust the cutoff, and if set to 0 will
pass empty input to the reduction function.
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*.
data : indexable object, optional
If given, the following parameters also accept a string ``s``, which is
interpreted as ``data[s]`` if ``s`` is a key in ``data``:
*x*, *y*, *C*
**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 and two offsets from the bottom left corner of the image
alpha: array-like or scalar or None
animated: bool
antialiased or aa or antialiaseds: bool or list of bools
array: array-like or None
capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}
clim: (vmin: float, vmax: float)
clip_box: `~matplotlib.transforms.BboxBase` or None
clip_on: bool
clip_path: Patch or (Path, Transform) or None
cmap: `.Colormap` or str or None
color: :mpltype:`color` or list of RGBA tuples
edgecolor or ec or edgecolors: :mpltype:`color` or list of :mpltype:`color` or 'face'
facecolor or facecolors or fc: :mpltype:`color` or list of :mpltype:`color`
figure: `~matplotlib.figure.Figure` or `~matplotlib.figure.SubFigure`
gid: str
hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
hatch_linewidth: unknown
in_layout: bool
joinstyle: `.JoinStyle` or {'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
mouseover: bool
norm: `.Normalize` or str or None
offset_transform or transOffset: `.Transform`
offsets: (N, 2) or (2,) array-like
path_effects: list of `.AbstractPathEffect`
paths: list of array-like
picker: None or bool or float or callable
pickradius: float
rasterized: bool
sizes: `numpy.ndarray` or None
sketch_params: (scale: float, length: float, randomness: float)
snap: bool or None
transform: `~matplotlib.transforms.Transform`
url: str
urls: list of str or None
verts: list of array-like
verts_and_codes: unknown
visible: bool
zorder: float
See Also
--------
hist2d : 2D histogram rectangular bins
Améliorations / Corrections
Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.
Emplacement :
Description des améliorations :