| acorr(x: 'ArrayLike', *, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray, LineCollection | Line2D, Line2D | None]' |
Plot the autocorrelation of *x*. [extrait de acorr.__doc__] |
| angle_spectrum(x: 'ArrayLike', *, Fs: 'float | None' = None, Fc: 'int | None' = None, window: 'Callable[[ArrayLike], ArrayLike] | ArrayLike | None' = None, pad_to: 'int | None' = None, sides: "Literal['default', 'onesided', 'twosided'] | None" = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray, Line2D]' |
Plot the angle spectrum. [extrait de angle_spectrum.__doc__] |
| annotate(text: 'str', xy: 'tuple[float, float]', xytext: 'tuple[float, float] | None' = None, xycoords: 'CoordsType' = 'data', textcoords: 'CoordsType | None' = None, arrowprops: 'dict[str, Any] | None' = None, annotation_clip: 'bool | None' = None, **kwargs) -> 'Annotation' |
Annotate the point *xy* with text *text*. [extrait de annotate.__doc__] |
| arrow(x: 'float', y: 'float', dx: 'float', dy: 'float', **kwargs) -> 'FancyArrow' |
Add an arrow to the Axes. [extrait de arrow.__doc__] |
| autoscale(enable: 'bool' = True, axis: "Literal['both', 'x', 'y']" = 'both', tight: 'bool | None' = None) -> 'None' |
Autoscale the axis view to the data (toggle). [extrait de autoscale.__doc__] |
| autumn() -> 'None' |
|
| axes(arg: 'None | tuple[float, float, float, float]' = None, **kwargs) -> 'matplotlib.axes.Axes' |
Add an Axes to the current figure and make it the current Axes. [extrait de axes.__doc__] |
| axhline(y: 'float' = 0, xmin: 'float' = 0, xmax: 'float' = 1, **kwargs) -> 'Line2D' |
Add a horizontal line spanning the whole or fraction of the Axes. [extrait de axhline.__doc__] |
| axhspan(ymin: 'float', ymax: 'float', xmin: 'float' = 0, xmax: 'float' = 1, **kwargs) -> 'Rectangle' |
Add a horizontal span (rectangle) across the Axes. [extrait de axhspan.__doc__] |
| axis(arg: 'tuple[float, float, float, float] | bool | str | None' = None, /, *, emit: 'bool' = True, **kwargs) -> 'tuple[float, float, float, float]' |
Convenience method to get or set some axis properties. [extrait de axis.__doc__] |
| axline(xy1: 'tuple[float, float]', xy2: 'tuple[float, float] | None' = None, *, slope: 'float | None' = None, **kwargs) -> 'AxLine' |
Add an infinitely long straight line. [extrait de axline.__doc__] |
| axvline(x: 'float' = 0, ymin: 'float' = 0, ymax: 'float' = 1, **kwargs) -> 'Line2D' |
Add a vertical line spanning the whole or fraction of the Axes. [extrait de axvline.__doc__] |
| axvspan(xmin: 'float', xmax: 'float', ymin: 'float' = 0, ymax: 'float' = 1, **kwargs) -> 'Rectangle' |
Add a vertical span (rectangle) across the Axes. [extrait de axvspan.__doc__] |
| bar(x: 'float | ArrayLike', height: 'float | ArrayLike', width: 'float | ArrayLike' = 0.8, bottom: 'float | ArrayLike | None' = None, *, align: "Literal['center', 'edge']" = 'center', data=None, **kwargs) -> 'BarContainer' |
Make a bar plot. [extrait de bar.__doc__] |
| bar_label(container: 'BarContainer', labels: 'ArrayLike | None' = None, *, fmt: 'str | Callable[[float], str]' = '%g', label_type: "Literal['center', 'edge']" = 'edge', padding: 'float' = 0, **kwargs) -> 'list[Annotation]' |
Label a bar plot. [extrait de bar_label.__doc__] |
| barbs(*args, data=None, **kwargs) -> 'Barbs' |
Plot a 2D field of wind barbs. [extrait de barbs.__doc__] |
| barh(y: 'float | ArrayLike', width: 'float | ArrayLike', height: 'float | ArrayLike' = 0.8, left: 'float | ArrayLike | None' = None, *, align: "Literal['center', 'edge']" = 'center', data=None, **kwargs) -> 'BarContainer' |
Make a horizontal bar plot. [extrait de barh.__doc__] |
| bone() -> 'None' |
|
| box(on: 'bool | None' = None) -> 'None' |
|
| boxplot(x: 'ArrayLike | Sequence[ArrayLike]', *, notch: 'bool | None' = None, sym: 'str | None' = None, vert: 'bool | None' = None, orientation: "Literal['vertical', 'horizontal']" = 'vertical', whis: 'float | tuple[float, float] | None' = None, positions: 'ArrayLike | None' = None, widths: 'float | ArrayLike | None' = None, patch_artist: 'bool | None' = None, bootstrap: 'int | None' = None, usermedians: 'ArrayLike | None' = None, conf_intervals: 'ArrayLike | None' = None, meanline: 'bool | None' = None, showmeans: 'bool | None' = None, showcaps: 'bool | None' = None, showbox: 'bool | None' = None, showfliers: 'bool | None' = None, boxprops: 'dict[str, Any] | None' = None, tick_labels: 'Sequence[str] | None' = None, flierprops: 'dict[str, Any] | None' = None, medianprops: 'dict[str, Any] | None' = None, meanprops: 'dict[str, Any] | None' = None, capprops: 'dict[str, Any] | None' = None, whiskerprops: 'dict[str, Any] | None' = None, manage_ticks: 'bool' = True, autorange: 'bool' = False, zorder: 'float | None' = None, capwidths: 'float | ArrayLike | None' = None, label: 'Sequence[str] | None' = None, data=None) -> 'dict[str, Any]' |
Draw a box and whisker plot. [extrait de boxplot.__doc__] |
| broken_barh(xranges: 'Sequence[tuple[float, float]]', yrange: 'tuple[float, float]', *, data=None, **kwargs) -> 'PolyCollection' |
Plot a horizontal sequence of rectangles. [extrait de broken_barh.__doc__] |
| cast(typ, val) |
Cast a value to a type. [extrait de cast.__doc__] |
| cla() -> 'None' |
Clear the current Axes. [extrait de cla.__doc__] |
| clabel(CS: 'ContourSet', levels: 'ArrayLike | None' = None, **kwargs) -> 'list[Text]' |
Label a contour plot. [extrait de clabel.__doc__] |
| clf() -> 'None' |
Clear the current figure. [extrait de clf.__doc__] |
| clim(vmin: 'float | None' = None, vmax: 'float | None' = None) -> 'None' |
|
| close(fig: "None | int | str | Figure | Literal['all']" = None) -> 'None' |
|
| cohere(x: 'ArrayLike', y: 'ArrayLike', *, NFFT: 'int' = 256, Fs: 'float' = 2, Fc: 'int' = 0, detrend: "Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike]" = <function detrend_none at 0x0000020D9ABF6660>, window: 'Callable[[ArrayLike], ArrayLike] | ArrayLike' = <function window_hanning at 0x0000020D9ABF63E0>, noverlap: 'int' = 0, pad_to: 'int | None' = None, sides: "Literal['default', 'onesided', 'twosided']" = 'default', scale_by_freq: 'bool | None' = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray]' |
Plot the coherence between *x* and *y*. [extrait de cohere.__doc__] |
| colorbar(mappable: 'ScalarMappable | ColorizingArtist | None' = None, cax: 'matplotlib.axes.Axes | None' = None, ax: 'matplotlib.axes.Axes | Iterable[matplotlib.axes.Axes] | None' = None, **kwargs) -> 'Colorbar' |
Add a colorbar to a plot. [extrait de colorbar.__doc__] |
| colormaps() |
|
| connect(s: 'str', func: 'Callable[[Event], Any]') -> 'int' |
Bind function *func* to event *s*. [extrait de connect.__doc__] |
| contour(*args, data=None, **kwargs) -> 'QuadContourSet' |
Plot contour lines. [extrait de contour.__doc__] |
| contourf(*args, data=None, **kwargs) -> 'QuadContourSet' |
Plot filled contours. [extrait de contourf.__doc__] |
| cool() -> 'None' |
|
| copper() -> 'None' |
|
| csd(x: 'ArrayLike', y: 'ArrayLike', *, NFFT: 'int | None' = None, Fs: 'float | None' = None, Fc: 'int | None' = None, detrend: "Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike] | None" = None, window: 'Callable[[ArrayLike], ArrayLike] | ArrayLike | None' = None, noverlap: 'int | None' = None, pad_to: 'int | None' = None, sides: "Literal['default', 'onesided', 'twosided'] | None" = None, scale_by_freq: 'bool | None' = None, return_line: 'bool | None' = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, Line2D]' |
Plot the cross-spectral density. [extrait de csd.__doc__] |
| cycler(*args, **kwargs) |
|
| delaxes(ax: 'matplotlib.axes.Axes | None' = None) -> 'None' |
|
| disconnect(cid: 'int') -> 'None' |
Disconnect the callback with id *cid*. [extrait de disconnect.__doc__] |
| draw() -> 'None' |
|
| draw_all(force=False) |
|
| draw_if_interactive() |
|
| ecdf(x: 'ArrayLike', weights: 'ArrayLike | None' = None, *, complementary: 'bool' = False, orientation: "Literal['vertical', 'horizonatal']" = 'vertical', compress: 'bool' = False, data=None, **kwargs) -> 'Line2D' |
Compute and plot the empirical cumulative distribution function of *x*. [extrait de ecdf.__doc__] |
| errorbar(x: 'float | ArrayLike', y: 'float | ArrayLike', yerr: 'float | ArrayLike | None' = None, xerr: 'float | ArrayLike | None' = None, fmt: 'str' = '', *, ecolor: 'ColorType | None' = None, elinewidth: 'float | None' = None, capsize: 'float | None' = None, barsabove: 'bool' = False, lolims: 'bool | ArrayLike' = False, uplims: 'bool | ArrayLike' = False, xlolims: 'bool | ArrayLike' = False, xuplims: 'bool | ArrayLike' = False, errorevery: 'int | tuple[int, int]' = 1, capthick: 'float | None' = None, data=None, **kwargs) -> 'ErrorbarContainer' |
Plot y versus x as lines and/or markers with attached errorbars. [extrait de errorbar.__doc__] |
| eventplot(positions: 'ArrayLike | Sequence[ArrayLike]', *, orientation: "Literal['horizontal', 'vertical']" = 'horizontal', lineoffsets: 'float | Sequence[float]' = 1, linelengths: 'float | Sequence[float]' = 1, linewidths: 'float | Sequence[float] | None' = None, colors: 'ColorType | Sequence[ColorType] | None' = None, alpha: 'float | Sequence[float] | None' = None, linestyles: 'LineStyleType | Sequence[LineStyleType]' = 'solid', data=None, **kwargs) -> 'EventCollection' |
Plot identical parallel lines at the given positions. [extrait de eventplot.__doc__] |
| figaspect(arg) |
|
| figimage(X: 'ArrayLike', xo: 'int' = 0, yo: 'int' = 0, alpha: 'float | None' = None, norm: 'str | Normalize | None' = None, cmap: 'str | Colormap | None' = None, vmin: 'float | None' = None, vmax: 'float | None' = None, origin: "Literal['upper', 'lower'] | None" = None, resize: 'bool' = False, *, colorizer: 'Colorizer | None' = None, **kwargs) -> 'FigureImage' |
Add a non-resampled image to the figure. [extrait de figimage.__doc__] |
| figlegend(*args, **kwargs) -> 'Legend' |
Place a legend on the figure. [extrait de figlegend.__doc__] |
| fignum_exists(num: 'int | str') -> 'bool' |
|
| figtext(x: 'float', y: 'float', s: 'str', fontdict: 'dict[str, Any] | None' = None, **kwargs) -> 'Text' |
Add text to figure. [extrait de figtext.__doc__] |
| figure(num: 'int | str | Figure | SubFigure | None' = None, figsize: 'tuple[float, float] | None' = None, dpi: 'float | None' = None, *, facecolor: 'ColorType | None' = None, edgecolor: 'ColorType | None' = None, frameon: 'bool' = True, FigureClass: 'type[Figure]' = <class 'matplotlib.figure.Figure'>, clear: 'bool' = False, **kwargs) -> 'Figure' |
|
| fill(*args, data=None, **kwargs) -> 'list[Polygon]' |
Plot filled polygons. [extrait de fill.__doc__] |
| fill_between(x: 'ArrayLike', y1: 'ArrayLike | float', y2: 'ArrayLike | float' = 0, where: 'Sequence[bool] | None' = None, interpolate: 'bool' = False, step: "Literal['pre', 'post', 'mid'] | None" = None, *, data=None, **kwargs) -> 'FillBetweenPolyCollection' |
Fill the area between two horizontal curves. [extrait de fill_between.__doc__] |
| fill_betweenx(y: 'ArrayLike', x1: 'ArrayLike | float', x2: 'ArrayLike | float' = 0, where: 'Sequence[bool] | None' = None, step: "Literal['pre', 'post', 'mid'] | None" = None, interpolate: 'bool' = False, *, data=None, **kwargs) -> 'FillBetweenPolyCollection' |
Fill the area between two vertical curves. [extrait de fill_betweenx.__doc__] |
| findobj(o: 'Artist | None' = None, match: 'Callable[[Artist], bool] | type[Artist] | None' = None, include_self: 'bool' = True) -> 'list[Artist]' |
|
| flag() -> 'None' |
|
| gca() -> 'Axes' |
Get the current Axes. [extrait de gca.__doc__] |
| gcf() -> 'Figure' |
|
| gci() -> 'ColorizingArtist | None' |
|
| get(obj, *args, **kwargs) |
Return the value of an `.Artist`'s *property*, or print all of them. [extrait de get.__doc__] |
| get_backend(*, auto_select=True) |
|
| get_cmap(name: 'Colormap | str | None' = None, lut: 'int | None' = None) -> 'Colormap' |
|
| get_current_fig_manager() -> 'FigureManagerBase | None' |
|
| get_figlabels() -> 'list[Any]' |
Return a list of existing figure labels. [extrait de get_figlabels.__doc__] |
| get_fignums() -> 'list[int]' |
Return a list of existing figure numbers. [extrait de get_fignums.__doc__] |
| get_plot_commands() -> 'list[str]' |
[*Deprecated*] Get a sorted list of all of the plotting commands. [extrait de get_plot_commands.__doc__] |
| get_scale_names() |
Return the names of the available scales. [extrait de get_scale_names.__doc__] |
| getp(obj, *args, **kwargs) |
Return the value of an `.Artist`'s *property*, or print all of them. [extrait de getp.__doc__] |
| ginput(n: 'int' = 1, timeout: 'float' = 30, show_clicks: 'bool' = True, mouse_add: 'MouseButton' = <MouseButton.LEFT: 1>, mouse_pop: 'MouseButton' = <MouseButton.RIGHT: 3>, mouse_stop: 'MouseButton' = <MouseButton.MIDDLE: 2>) -> 'list[tuple[int, int]]' |
Blocking call to interact with a figure. [extrait de ginput.__doc__] |
| gray() -> 'None' |
|
| grid(visible: 'bool | None' = None, which: "Literal['major', 'minor', 'both']" = 'major', axis: "Literal['both', 'x', 'y']" = 'both', **kwargs) -> 'None' |
Configure the grid lines. [extrait de grid.__doc__] |
| hexbin(x: 'ArrayLike', y: 'ArrayLike', C: 'ArrayLike | None' = None, *, gridsize: 'int | tuple[int, int]' = 100, bins: "Literal['log'] | int | Sequence[float] | None" = None, xscale: "Literal['linear', 'log']" = 'linear', yscale: "Literal['linear', 'log']" = 'linear', extent: 'tuple[float, float, float, float] | None' = None, cmap: 'str | Colormap | None' = None, norm: 'str | Normalize | None' = None, vmin: 'float | None' = None, vmax: 'float | None' = None, alpha: 'float | None' = None, linewidths: 'float | None' = None, edgecolors: "Literal['face', 'none'] | ColorType" = 'face', reduce_C_function: 'Callable[[np.ndarray | list[float]], float]' = <function mean at 0x0000020DE89D1D70>, mincnt: 'int | None' = None, marginals: 'bool' = False, colorizer: 'Colorizer | None' = None, data=None, **kwargs) -> 'PolyCollection' |
Make a 2D hexagonal binning plot of points *x*, *y*. [extrait de hexbin.__doc__] |
| hist(x: 'ArrayLike | Sequence[ArrayLike]', bins: 'int | Sequence[float] | str | None' = None, *, range: 'tuple[float, float] | None' = None, density: 'bool' = False, weights: 'ArrayLike | None' = None, cumulative: 'bool | float' = False, bottom: 'ArrayLike | float | None' = None, histtype: "Literal['bar', 'barstacked', 'step', 'stepfilled']" = 'bar', align: "Literal['left', 'mid', 'right']" = 'mid', orientation: "Literal['vertical', 'horizontal']" = 'vertical', rwidth: 'float | None' = None, log: 'bool' = False, color: 'ColorType | Sequence[ColorType] | None' = None, label: 'str | Sequence[str] | None' = None, stacked: 'bool' = False, data=None, **kwargs) -> 'tuple[np.ndarray | list[np.ndarray], np.ndarray, BarContainer | Polygon | list[BarContainer | Polygon]]' |
Compute and plot a histogram. [extrait de hist.__doc__] |
| hist2d(x: 'ArrayLike', y: 'ArrayLike', bins: 'None | int | tuple[int, int] | ArrayLike | tuple[ArrayLike, ArrayLike]' = 10, *, range: 'ArrayLike | None' = None, density: 'bool' = False, weights: 'ArrayLike | None' = None, cmin: 'float | None' = None, cmax: 'float | None' = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray, np.ndarray, QuadMesh]' |
Make a 2D histogram plot. [extrait de hist2d.__doc__] |
| hlines(y: 'float | ArrayLike', xmin: 'float | ArrayLike', xmax: 'float | ArrayLike', colors: 'ColorType | Sequence[ColorType] | None' = None, linestyles: 'LineStyleType' = 'solid', *, label: 'str' = '', data=None, **kwargs) -> 'LineCollection' |
Plot horizontal lines at each *y* from *xmin* to *xmax*. [extrait de hlines.__doc__] |
| hot() -> 'None' |
|
| hsv() -> 'None' |
|
| imread(fname: 'str | pathlib.Path | BinaryIO', format: 'str | None' = None) -> 'np.ndarray' |
Read an image from a file into an array. [extrait de imread.__doc__] |
| imsave(fname: 'str | os.PathLike | BinaryIO', arr: 'ArrayLike', **kwargs) -> 'None' |
Colormap and save an array as an image file. [extrait de imsave.__doc__] |
| imshow(X: 'ArrayLike | PIL.Image.Image', cmap: 'str | Colormap | None' = None, norm: 'str | Normalize | None' = None, *, aspect: "Literal['equal', 'auto'] | float | None" = None, interpolation: 'str | None' = None, alpha: 'float | ArrayLike | None' = None, vmin: 'float | None' = None, vmax: 'float | None' = None, colorizer: 'Colorizer | None' = None, origin: "Literal['upper', 'lower'] | None" = None, extent: 'tuple[float, float, float, float] | None' = None, interpolation_stage: "Literal['data', 'rgba', 'auto'] | None" = None, filternorm: 'bool' = True, filterrad: 'float' = 4.0, resample: 'bool | None' = None, url: 'str | None' = None, data=None, **kwargs) -> 'AxesImage' |
Display data as an image, i.e., on a 2D regular raster. [extrait de imshow.__doc__] |
| inferno() -> 'None' |
|
| install_repl_displayhook() -> 'None' |
|
| interactive(b) |
|
| ioff() -> 'AbstractContextManager' |
|
| ion() -> 'AbstractContextManager' |
|
| isinteractive() -> 'bool' |
|
| jet() -> 'None' |
|
| legend(*args, **kwargs) -> 'Legend' |
Place a legend on the Axes. [extrait de legend.__doc__] |
| locator_params(axis: "Literal['both', 'x', 'y']" = 'both', tight: 'bool | None' = None, **kwargs) -> 'None' |
Control behavior of major tick locators. [extrait de locator_params.__doc__] |
| loglog(*args, **kwargs) -> 'list[Line2D]' |
Make a plot with log scaling on both the x- and y-axis. [extrait de loglog.__doc__] |
| magma() -> 'None' |
|
| magnitude_spectrum(x: 'ArrayLike', *, Fs: 'float | None' = None, Fc: 'int | None' = None, window: 'Callable[[ArrayLike], ArrayLike] | ArrayLike | None' = None, pad_to: 'int | None' = None, sides: "Literal['default', 'onesided', 'twosided'] | None" = None, scale: "Literal['default', 'linear', 'dB'] | None" = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray, Line2D]' |
Plot the magnitude spectrum. [extrait de magnitude_spectrum.__doc__] |
| margins(*margins: 'float', x: 'float | None' = None, y: 'float | None' = None, tight: 'bool | None' = True) -> 'tuple[float, float] | None' |
Set or retrieve margins around the data for autoscaling axis limits. [extrait de margins.__doc__] |
| matshow(A: 'ArrayLike', fignum: 'None | int' = None, **kwargs) -> 'AxesImage' |
|
| minorticks_off() -> 'None' |
Remove minor ticks from the Axes. [extrait de minorticks_off.__doc__] |
| minorticks_on() -> 'None' |
Display minor ticks on the Axes. [extrait de minorticks_on.__doc__] |
| new_figure_manager(num, *args, **kwargs) |
Create a new figure manager instance. [extrait de new_figure_manager.__doc__] |
| nipy_spectral() -> 'None' |
|
| overload(func) |
Decorator for overloaded functions/methods. [extrait de overload.__doc__] |
| pause(interval: 'float') -> 'None' |
|
| pcolor(*args: 'ArrayLike', shading: "Literal['flat', 'nearest', 'auto'] | None" = None, alpha: 'float | None' = None, norm: 'str | Normalize | None' = None, cmap: 'str | Colormap | None' = None, vmin: 'float | None' = None, vmax: 'float | None' = None, colorizer: 'Colorizer | None' = None, data=None, **kwargs) -> 'Collection' |
Create a pseudocolor plot with a non-regular rectangular grid. [extrait de pcolor.__doc__] |
| pcolormesh(*args: 'ArrayLike', alpha: 'float | None' = None, norm: 'str | Normalize | None' = None, cmap: 'str | Colormap | None' = None, vmin: 'float | None' = None, vmax: 'float | None' = None, colorizer: 'Colorizer | None' = None, shading: "Literal['flat', 'nearest', 'gouraud', 'auto'] | None" = None, antialiased: 'bool' = False, data=None, **kwargs) -> 'QuadMesh' |
Create a pseudocolor plot with a non-regular rectangular grid. [extrait de pcolormesh.__doc__] |
| phase_spectrum(x: 'ArrayLike', *, Fs: 'float | None' = None, Fc: 'int | None' = None, window: 'Callable[[ArrayLike], ArrayLike] | ArrayLike | None' = None, pad_to: 'int | None' = None, sides: "Literal['default', 'onesided', 'twosided'] | None" = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray, Line2D]' |
Plot the phase spectrum. [extrait de phase_spectrum.__doc__] |
| pie(x: 'ArrayLike', *, explode: 'ArrayLike | None' = None, labels: 'Sequence[str] | None' = None, colors: 'ColorType | Sequence[ColorType] | None' = None, autopct: 'str | Callable[[float], str] | None' = None, pctdistance: 'float' = 0.6, shadow: 'bool' = False, labeldistance: 'float | None' = 1.1, startangle: 'float' = 0, radius: 'float' = 1, counterclock: 'bool' = True, wedgeprops: 'dict[str, Any] | None' = None, textprops: 'dict[str, Any] | None' = None, center: 'tuple[float, float]' = (0, 0), frame: 'bool' = False, rotatelabels: 'bool' = False, normalize: 'bool' = True, hatch: 'str | Sequence[str] | None' = None, data=None) -> 'tuple[list[Wedge], list[Text]] | tuple[list[Wedge], list[Text], list[Text]]' |
Plot a pie chart. [extrait de pie.__doc__] |
| pink() -> 'None' |
|
| plasma() -> 'None' |
|
| plot(*args: 'float | ArrayLike | str', scalex: 'bool' = True, scaley: 'bool' = True, data=None, **kwargs) -> 'list[Line2D]' |
Plot y versus x as lines and/or markers. [extrait de plot.__doc__] |
| plot_date(x: 'ArrayLike', y: 'ArrayLike', fmt: 'str' = 'o', tz: 'str | datetime.tzinfo | None' = None, xdate: 'bool' = True, ydate: 'bool' = False, *, data=None, **kwargs) -> 'list[Line2D]' |
[*Deprecated*] Plot coercing the axis to treat floats as dates. [extrait de plot_date.__doc__] |
| polar(*args, **kwargs) -> 'list[Line2D]' |
|
| prism() -> 'None' |
|
| psd(x: 'ArrayLike', *, NFFT: 'int | None' = None, Fs: 'float | None' = None, Fc: 'int | None' = None, detrend: "Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike] | None" = None, window: 'Callable[[ArrayLike], ArrayLike] | ArrayLike | None' = None, noverlap: 'int | None' = None, pad_to: 'int | None' = None, sides: "Literal['default', 'onesided', 'twosided'] | None" = None, scale_by_freq: 'bool | None' = None, return_line: 'bool | None' = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, Line2D]' |
Plot the power spectral density. [extrait de psd.__doc__] |
| quiver(*args, data=None, **kwargs) -> 'Quiver' |
Plot a 2D field of arrows. [extrait de quiver.__doc__] |
| quiverkey(Q: 'Quiver', X: 'float', Y: 'float', U: 'float', label: 'str', **kwargs) -> 'QuiverKey' |
Add a key to a quiver plot. [extrait de quiverkey.__doc__] |
| rc(group: 'str', **kwargs) -> 'None' |
Set the current `.rcParams`. *group* is the grouping for the rc, e.g., [extrait de rc.__doc__] |
| rc_context(rc: 'dict[str, Any] | None' = None, fname: 'str | pathlib.Path | os.PathLike | None' = None) -> 'AbstractContextManager[None]' |
Return a context manager for temporarily changing rcParams. [extrait de rc_context.__doc__] |
| rcdefaults() -> 'None' |
Restore the `.rcParams` from Matplotlib's internal default style. [extrait de rcdefaults.__doc__] |
| rgrids(radii: 'ArrayLike | None' = None, labels: 'Sequence[str | Text] | None' = None, angle: 'float | None' = None, fmt: 'str | None' = None, **kwargs) -> 'tuple[list[Line2D], list[Text]]' |
|
| savefig(*args, **kwargs) -> 'None' |
Save the current figure as an image or vector graphic to a file. [extrait de savefig.__doc__] |
| sca(ax: 'Axes') -> 'None' |
|
| scatter(x: 'float | ArrayLike', y: 'float | ArrayLike', s: 'float | ArrayLike | None' = None, c: 'ArrayLike | Sequence[ColorType] | ColorType | None' = None, *, marker: 'MarkerType | None' = None, cmap: 'str | Colormap | None' = None, norm: 'str | Normalize | None' = None, vmin: 'float | None' = None, vmax: 'float | None' = None, alpha: 'float | None' = None, linewidths: 'float | Sequence[float] | None' = None, edgecolors: "Literal['face', 'none'] | ColorType | Sequence[ColorType] | None" = None, colorizer: 'Colorizer | None' = None, plotnonfinite: 'bool' = False, data=None, **kwargs) -> 'PathCollection' |
A scatter plot of *y* vs. *x* with varying marker size and/or color. [extrait de scatter.__doc__] |
| sci(im: 'ColorizingArtist') -> 'None' |
|
| semilogx(*args, **kwargs) -> 'list[Line2D]' |
Make a plot with log scaling on the x-axis. [extrait de semilogx.__doc__] |
| semilogy(*args, **kwargs) -> 'list[Line2D]' |
Make a plot with log scaling on the y-axis. [extrait de semilogy.__doc__] |
| set_cmap(cmap: 'Colormap | str') -> 'None' |
|
| set_loglevel(*args, **kwargs) -> 'None' |
Configure Matplotlib's logging levels. [extrait de set_loglevel.__doc__] |
| setp(obj, *args, **kwargs) |
Set one or more properties on an `.Artist`, or list allowed values. [extrait de setp.__doc__] |
| show(*, block=None) |
|
| specgram(x: 'ArrayLike', *, NFFT: 'int | None' = None, Fs: 'float | None' = None, Fc: 'int | None' = None, detrend: "Literal['none', 'mean', 'linear'] | Callable[[ArrayLike], ArrayLike] | None" = None, window: 'Callable[[ArrayLike], ArrayLike] | ArrayLike | None' = None, noverlap: 'int | None' = None, cmap: 'str | Colormap | None' = None, xextent: 'tuple[float, float] | None' = None, pad_to: 'int | None' = None, sides: "Literal['default', 'onesided', 'twosided'] | None" = None, scale_by_freq: 'bool | None' = None, mode: "Literal['default', 'psd', 'magnitude', 'angle', 'phase'] | None" = None, scale: "Literal['default', 'linear', 'dB'] | None" = None, vmin: 'float | None' = None, vmax: 'float | None' = None, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray, np.ndarray, AxesImage]' |
Plot a spectrogram. [extrait de specgram.__doc__] |
| spring() -> 'None' |
|
| spy(Z: 'ArrayLike', *, precision: "float | Literal['present']" = 0, marker: 'str | None' = None, markersize: 'float | None' = None, aspect: "Literal['equal', 'auto'] | float | None" = 'equal', origin: "Literal['upper', 'lower']" = 'upper', **kwargs) -> 'AxesImage' |
Plot the sparsity pattern of a 2D array. [extrait de spy.__doc__] |
| stackplot(x, *args, labels=(), colors=None, hatch=None, baseline='zero', data=None, **kwargs) |
Draw a stacked area plot or a streamgraph. [extrait de stackplot.__doc__] |
| stairs(values: 'ArrayLike', edges: 'ArrayLike | None' = None, *, orientation: "Literal['vertical', 'horizontal']" = 'vertical', baseline: 'float | ArrayLike | None' = 0, fill: 'bool' = False, data=None, **kwargs) -> 'StepPatch' |
Draw a stepwise constant function as a line or a filled plot. [extrait de stairs.__doc__] |
| stem(*args: 'ArrayLike | str', linefmt: 'str | None' = None, markerfmt: 'str | None' = None, basefmt: 'str | None' = None, bottom: 'float' = 0, label: 'str | None' = None, orientation: "Literal['vertical', 'horizontal']" = 'vertical', data=None) -> 'StemContainer' |
Create a stem plot. [extrait de stem.__doc__] |
| step(x: 'ArrayLike', y: 'ArrayLike', *args, where: "Literal['pre', 'post', 'mid']" = 'pre', data=None, **kwargs) -> 'list[Line2D]' |
Make a step plot. [extrait de step.__doc__] |
| 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', broken_streamlines=True, *, data=None) |
Draw streamlines of a vector flow. [extrait de streamplot.__doc__] |
| subplot(*args, **kwargs) -> 'Axes' |
Add an Axes to the current figure or retrieve an existing Axes. [extrait de subplot.__doc__] |
| subplot2grid(shape: 'tuple[int, int]', loc: 'tuple[int, int]', rowspan: 'int' = 1, colspan: 'int' = 1, fig: 'Figure | None' = None, **kwargs) -> 'matplotlib.axes.Axes' |
|
| subplot_mosaic(mosaic: 'str | list[HashableList[_T]] | list[HashableList[Hashable]]', *, sharex: 'bool' = False, sharey: 'bool' = False, width_ratios: 'ArrayLike | None' = None, height_ratios: 'ArrayLike | None' = None, empty_sentinel: 'Any' = '.', subplot_kw: 'dict[str, Any] | None' = None, gridspec_kw: 'dict[str, Any] | None' = None, per_subplot_kw: 'dict[str | tuple[str, ...], dict[str, Any]] | dict[_T | tuple[_T, ...], dict[str, Any]] | dict[Hashable | tuple[Hashable, ...], dict[str, Any]] | None' = None, **fig_kw: 'Any') -> 'tuple[Figure, dict[str, matplotlib.axes.Axes]] | tuple[Figure, dict[_T, matplotlib.axes.Axes]] | tuple[Figure, dict[Hashable, matplotlib.axes.Axes]]' |
|
| subplot_tool(targetfig: 'Figure | None' = None) -> 'SubplotTool | None' |
|
| subplots(nrows: 'int' = 1, ncols: 'int' = 1, *, sharex: "bool | Literal['none', 'all', 'row', 'col']" = False, sharey: "bool | Literal['none', 'all', 'row', 'col']" = False, squeeze: 'bool' = True, width_ratios: 'Sequence[float] | None' = None, height_ratios: 'Sequence[float] | None' = None, subplot_kw: 'dict[str, Any] | None' = None, gridspec_kw: 'dict[str, Any] | None' = None, **fig_kw) -> 'tuple[Figure, Any]' |
|
| subplots_adjust(left: 'float | None' = None, bottom: 'float | None' = None, right: 'float | None' = None, top: 'float | None' = None, wspace: 'float | None' = None, hspace: 'float | None' = None) -> 'None' |
Adjust the subplot layout parameters. [extrait de subplots_adjust.__doc__] |
| summer() -> 'None' |
|
| suptitle(t: 'str', **kwargs) -> 'Text' |
Add a centered super title to the figure. [extrait de suptitle.__doc__] |
| switch_backend(newbackend: 'str') -> 'None' |
|
| 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`. [extrait de table.__doc__] |
| text(x: 'float', y: 'float', s: 'str', fontdict: 'dict[str, Any] | None' = None, **kwargs) -> 'Text' |
Add text to the Axes. [extrait de text.__doc__] |
| thetagrids(angles: 'ArrayLike | None' = None, labels: 'Sequence[str | Text] | None' = None, fmt: 'str | None' = None, **kwargs) -> 'tuple[list[Line2D], list[Text]]' |
|
| tick_params(axis: "Literal['both', 'x', 'y']" = 'both', **kwargs) -> 'None' |
Change the appearance of ticks, tick labels, and gridlines. [extrait de tick_params.__doc__] |
| ticklabel_format(*, axis: "Literal['both', 'x', 'y']" = 'both', style: "Literal['', 'sci', 'scientific', 'plain'] | None" = None, scilimits: 'tuple[int, int] | None' = None, useOffset: 'bool | float | None' = None, useLocale: 'bool | None' = None, useMathText: 'bool | None' = None) -> 'None' |
Configure the `.ScalarFormatter` used by default for linear Axes. [extrait de ticklabel_format.__doc__] |
| tight_layout(*, pad: 'float' = 1.08, h_pad: 'float | None' = None, w_pad: 'float | None' = None, rect: 'tuple[float, float, float, float] | None' = None) -> 'None' |
Adjust the padding between and around subplots. [extrait de tight_layout.__doc__] |
| title(label: 'str', fontdict: 'dict[str, Any] | None' = None, loc: "Literal['left', 'center', 'right'] | None" = None, pad: 'float | None' = None, *, y: 'float | None' = None, **kwargs) -> 'Text' |
Set a title for the Axes. [extrait de title.__doc__] |
| tricontour(*args, **kwargs) |
Draw contour lines on an unstructured triangular grid. [extrait de tricontour.__doc__] |
| tricontourf(*args, **kwargs) |
Draw contour regions on an unstructured triangular grid. [extrait de tricontourf.__doc__] |
| 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. [extrait de tripcolor.__doc__] |
| triplot(*args, **kwargs) |
Draw an unstructured triangular grid as lines and/or markers. [extrait de triplot.__doc__] |
| twinx(ax: 'matplotlib.axes.Axes | None' = None) -> '_AxesBase' |
|
| twiny(ax: 'matplotlib.axes.Axes | None' = None) -> '_AxesBase' |
|
| uninstall_repl_displayhook() -> 'None' |
Disconnect from the display hook of the current shell. [extrait de uninstall_repl_displayhook.__doc__] |
| violinplot(dataset: 'ArrayLike | Sequence[ArrayLike]', positions: 'ArrayLike | None' = None, *, vert: 'bool | None' = None, orientation: "Literal['vertical', 'horizontal']" = 'vertical', widths: 'float | ArrayLike' = 0.5, showmeans: 'bool' = False, showextrema: 'bool' = True, showmedians: 'bool' = False, quantiles: 'Sequence[float | Sequence[float]] | None' = None, points: 'int' = 100, bw_method: "Literal['scott', 'silverman'] | float | Callable[[GaussianKDE], float] | None" = None, side: "Literal['both', 'low', 'high']" = 'both', data=None) -> 'dict[str, Collection]' |
Make a violin plot. [extrait de violinplot.__doc__] |
| viridis() -> 'None' |
|
| vlines(x: 'float | ArrayLike', ymin: 'float | ArrayLike', ymax: 'float | ArrayLike', colors: 'ColorType | Sequence[ColorType] | None' = None, linestyles: 'LineStyleType' = 'solid', *, label: 'str' = '', data=None, **kwargs) -> 'LineCollection' |
Plot vertical lines at each *x* from *ymin* to *ymax*. [extrait de vlines.__doc__] |
| waitforbuttonpress(timeout: 'float' = -1) -> 'None | bool' |
Blocking call to interact with the figure. [extrait de waitforbuttonpress.__doc__] |
| winter() -> 'None' |
|
| xcorr(x: 'ArrayLike', y: 'ArrayLike', *, normed: 'bool' = True, detrend: 'Callable[[ArrayLike], ArrayLike]' = <function detrend_none at 0x0000020D9ABF6660>, usevlines: 'bool' = True, maxlags: 'int' = 10, data=None, **kwargs) -> 'tuple[np.ndarray, np.ndarray, LineCollection | Line2D, Line2D | None]' |
Plot the cross correlation between *x* and *y*. [extrait de xcorr.__doc__] |
| xkcd(scale: 'float' = 1, length: 'float' = 100, randomness: 'float' = 2) -> 'ExitStack' |
|
| xlabel(xlabel: 'str', fontdict: 'dict[str, Any] | None' = None, labelpad: 'float | None' = None, *, loc: "Literal['left', 'center', 'right'] | None" = None, **kwargs) -> 'Text' |
Set the label for the x-axis. [extrait de xlabel.__doc__] |
| xlim(*args, **kwargs) -> 'tuple[float, float]' |
|
| xscale(value: 'str | ScaleBase', **kwargs) -> 'None' |
Set the xaxis' scale. [extrait de xscale.__doc__] |
| xticks(ticks: 'ArrayLike | None' = None, labels: 'Sequence[str] | None' = None, *, minor: 'bool' = False, **kwargs) -> 'tuple[list[Tick] | np.ndarray, list[Text]]' |
|
| ylabel(ylabel: 'str', fontdict: 'dict[str, Any] | None' = None, labelpad: 'float | None' = None, *, loc: "Literal['bottom', 'center', 'top'] | None" = None, **kwargs) -> 'Text' |
Set the label for the y-axis. [extrait de ylabel.__doc__] |
| ylim(*args, **kwargs) -> 'tuple[float, float]' |
|
| yscale(value: 'str | ScaleBase', **kwargs) -> 'None' |
Set the yaxis' scale. [extrait de yscale.__doc__] |
| yticks(ticks: 'ArrayLike | None' = None, labels: 'Sequence[str] | None' = None, *, minor: 'bool' = False, **kwargs) -> 'tuple[list[Tick] | np.ndarray, list[Text]]' |
|
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 :