Permalink
Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.
Sign up| # Note: The first part of this file can be modified in place, but the latter | |
| # part is autogenerated by the boilerplate.py script. | |
| """ | |
| `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. | |
| """ | |
| import importlib | |
| import inspect | |
| import logging | |
| from numbers import Number | |
| import re | |
| import sys | |
| import time | |
| import warnings | |
| from cycler import cycler | |
| import matplotlib | |
| import matplotlib.colorbar | |
| import matplotlib.image | |
| from matplotlib import rcsetup, style | |
| from matplotlib import _pylab_helpers, interactive | |
| from matplotlib import cbook | |
| from matplotlib.cbook import dedent, deprecated, silent_list, warn_deprecated | |
| from matplotlib import docstring | |
| from matplotlib.backend_bases import FigureCanvasBase | |
| from matplotlib.figure import Figure, figaspect | |
| from matplotlib.gridspec import GridSpec | |
| from matplotlib import rcParams, rcParamsDefault, get_backend, rcParamsOrig | |
| from matplotlib import rc_context | |
| from matplotlib.rcsetup import interactive_bk as _interactive_bk | |
| from matplotlib.artist import getp, get, Artist | |
| from matplotlib.artist import setp as _setp | |
| from matplotlib.axes import Axes, Subplot | |
| from matplotlib.projections import PolarAxes | |
| from matplotlib import mlab # for _csv2rec, detrend_none, window_hanning | |
| from matplotlib.scale import get_scale_docs, get_scale_names | |
| from matplotlib import cm | |
| from matplotlib.cm import get_cmap, register_cmap | |
| import numpy as np | |
| # We may not need the following imports here: | |
| from matplotlib.colors import Normalize | |
| from matplotlib.lines import Line2D | |
| from matplotlib.text import Text, Annotation | |
| from matplotlib.patches import Polygon, Rectangle, Circle, Arrow | |
| from matplotlib.widgets import SubplotTool, Button, Slider, Widget | |
| from .ticker import TickHelper, Formatter, FixedFormatter, NullFormatter,\ | |
| FuncFormatter, FormatStrFormatter, ScalarFormatter,\ | |
| LogFormatter, LogFormatterExponent, LogFormatterMathtext,\ | |
| Locator, IndexLocator, FixedLocator, NullLocator,\ | |
| LinearLocator, LogLocator, AutoLocator, MultipleLocator,\ | |
| MaxNLocator | |
| from matplotlib.backends import pylab_setup, _get_running_interactive_framework | |
| _log = logging.getLogger(__name__) | |
| ## Global ## | |
| _IP_REGISTERED = None | |
| _INSTALL_FIG_OBSERVER = False | |
| def 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. | |
| """ | |
| global _IP_REGISTERED | |
| global _INSTALL_FIG_OBSERVER | |
| class _NotIPython(Exception): | |
| pass | |
| # see if we have IPython hooks around, if use them | |
| try: | |
| if 'IPython' in sys.modules: | |
| from IPython import get_ipython | |
| ip = get_ipython() | |
| if ip is None: | |
| raise _NotIPython() | |
| if _IP_REGISTERED: | |
| return | |
| def post_execute(): | |
| if matplotlib.is_interactive(): | |
| draw_all() | |
| # IPython >= 2 | |
| try: | |
| ip.events.register('post_execute', post_execute) | |
| except AttributeError: | |
| # IPython 1.x | |
| ip.register_post_execute(post_execute) | |
| _IP_REGISTERED = post_execute | |
| _INSTALL_FIG_OBSERVER = False | |
| # trigger IPython's eventloop integration, if available | |
| from IPython.core.pylabtools import backend2gui | |
| ipython_gui_name = backend2gui.get(get_backend()) | |
| if ipython_gui_name: | |
| ip.enable_gui(ipython_gui_name) | |
| else: | |
| _INSTALL_FIG_OBSERVER = True | |
| # import failed or ipython is not running | |
| except (ImportError, _NotIPython): | |
| _INSTALL_FIG_OBSERVER = True | |
| def 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. | |
| """ | |
| global _IP_REGISTERED | |
| global _INSTALL_FIG_OBSERVER | |
| if _IP_REGISTERED: | |
| from IPython import get_ipython | |
| ip = get_ipython() | |
| try: | |
| ip.events.unregister('post_execute', _IP_REGISTERED) | |
| except AttributeError: | |
| raise NotImplementedError("Can not unregister events " | |
| "in IPython < 2.0") | |
| _IP_REGISTERED = None | |
| if _INSTALL_FIG_OBSERVER: | |
| _INSTALL_FIG_OBSERVER = False | |
| draw_all = _pylab_helpers.Gcf.draw_all | |
| @docstring.copy(Artist.findobj) | |
| def findobj(o=None, match=None, include_self=True): | |
| if o is None: | |
| o = gcf() | |
| return o.findobj(match, include_self=include_self) | |
| def 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. | |
| """ | |
| close("all") | |
| if newbackend is rcsetup._auto_backend_sentinel: | |
| # Don't try to fallback on the cairo-based backends as they each have | |
| # an additional dependency (pycairo) over the agg-based backend, and | |
| # are of worse quality. | |
| for candidate in ["macosx", "qt5agg", "qt4agg", "gtk3agg", "tkagg", | |
| "wxagg", "agg"]: | |
| try: | |
| switch_backend(candidate) | |
| except ImportError: | |
| continue | |
| else: | |
| rcParamsOrig['backend'] = candidate | |
| return | |
| backend_name = ( | |
| newbackend[9:] if newbackend.startswith("module://") | |
| else "matplotlib.backends.backend_{}".format(newbackend.lower())) | |
| backend_mod = importlib.import_module(backend_name) | |
| Backend = type( | |
| "Backend", (matplotlib.backends._Backend,), vars(backend_mod)) | |
| _log.debug("Loaded backend %s version %s.", | |
| newbackend, Backend.backend_version) | |
| required_framework = Backend.required_interactive_framework | |
| if required_framework is not None: | |
| current_framework = \ | |
| matplotlib.backends._get_running_interactive_framework() | |
| if (current_framework and required_framework | |
| and current_framework != required_framework): | |
| raise ImportError( | |
| "Cannot load backend {!r} which requires the {!r} interactive " | |
| "framework, as {!r} is currently running".format( | |
| newbackend, required_framework, current_framework)) | |
| rcParams['backend'] = rcParamsDefault['backend'] = newbackend | |
| global _backend_mod, new_figure_manager, draw_if_interactive, _show | |
| _backend_mod = backend_mod | |
| new_figure_manager = Backend.new_figure_manager | |
| draw_if_interactive = Backend.draw_if_interactive | |
| _show = Backend.show | |
| # Need to keep a global reference to the backend for compatibility reasons. | |
| # See https://github.com/matplotlib/matplotlib/issues/6092 | |
| matplotlib.backends.backend = newbackend | |
| def show(*args, **kw): | |
| """ | |
| Display a figure. | |
| When running in ipython with its pylab mode, display all | |
| figures and return to the ipython prompt. | |
| In non-interactive mode, display all figures and block until | |
| the figures have been closed; in interactive mode it has no | |
| effect unless figures were created prior to a change from | |
| non-interactive to interactive mode (not recommended). In | |
| that case it displays the figures but does not block. | |
| A single experimental keyword argument, *block*, may be | |
| set to True or False to override the blocking behavior | |
| described above. | |
| """ | |
| global _show | |
| return _show(*args, **kw) | |
| def isinteractive(): | |
| """Return the status of interactive mode.""" | |
| return matplotlib.is_interactive() | |
| def ioff(): | |
| """Turn the interactive mode off.""" | |
| matplotlib.interactive(False) | |
| uninstall_repl_displayhook() | |
| def ion(): | |
| """Turn the interactive mode on.""" | |
| matplotlib.interactive(True) | |
| install_repl_displayhook() | |
| def pause(interval): | |
| """ | |
| Pause for *interval* seconds. | |
| If there is an active figure, it will be updated and displayed before the | |
| pause, and the GUI event loop (if any) will run during the pause. | |
| This can be used for crude animation. For more complex animation, see | |
| :mod:`matplotlib.animation`. | |
| Notes | |
| ----- | |
| This function is experimental; its behavior may be changed or extended in a | |
| future release. | |
| """ | |
| manager = _pylab_helpers.Gcf.get_active() | |
| if manager is not None: | |
| canvas = manager.canvas | |
| if canvas.figure.stale: | |
| canvas.draw_idle() | |
| show(block=False) | |
| canvas.start_event_loop(interval) | |
| else: | |
| time.sleep(interval) | |
| @docstring.copy(matplotlib.rc) | |
| def rc(group, **kwargs): | |
| matplotlib.rc(group, **kwargs) | |
| @docstring.copy(matplotlib.rc_context) | |
| def rc_context(rc=None, fname=None): | |
| return matplotlib.rc_context(rc, fname) | |
| @docstring.copy(matplotlib.rcdefaults) | |
| def rcdefaults(): | |
| matplotlib.rcdefaults() | |
| if matplotlib.is_interactive(): | |
| draw_all() | |
| ## Current image ## | |
| def gci(): | |
| """ | |
| Get the current colorable artist. Specifically, returns the | |
| current :class:`~matplotlib.cm.ScalarMappable` instance (image or | |
| patch collection), or *None* if no images or patch collections | |
| have been defined. The commands :func:`~matplotlib.pyplot.imshow` | |
| and :func:`~matplotlib.pyplot.figimage` create | |
| :class:`~matplotlib.image.Image` instances, and the commands | |
| :func:`~matplotlib.pyplot.pcolor` and | |
| :func:`~matplotlib.pyplot.scatter` create | |
| :class:`~matplotlib.collections.Collection` instances. The | |
| current image is an attribute of the current axes, or the nearest | |
| earlier axes in the current figure that contains an image. | |
| """ | |
| return gcf()._gci() | |
| ## Any Artist ## | |
| # (getp is simply imported) | |
| @docstring.copy(_setp) | |
| def setp(obj, *args, **kwargs): | |
| return _setp(obj, *args, **kwargs) | |
| def 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() | |
| """ | |
| if rcParams['text.usetex']: | |
| raise RuntimeError( | |
| "xkcd mode is not compatible with text.usetex = True") | |
| from matplotlib import patheffects | |
| return rc_context({ | |
| 'font.family': ['xkcd', 'Humor Sans', 'Comic Sans MS'], | |
| 'font.size': 14.0, | |
| 'path.sketch': (scale, length, randomness), | |
| 'path.effects': [patheffects.withStroke(linewidth=4, foreground="w")], | |
| 'axes.linewidth': 1.5, | |
| 'lines.linewidth': 2.0, | |
| 'figure.facecolor': 'white', | |
| 'grid.linewidth': 0.0, | |
| 'axes.grid': False, | |
| 'axes.unicode_minus': False, | |
| 'axes.edgecolor': 'black', | |
| 'xtick.major.size': 8, | |
| 'xtick.major.width': 3, | |
| 'ytick.major.size': 8, | |
| 'ytick.major.width': 3, | |
| }) | |
| ## Figures ## | |
| def figure(num=None, # autoincrement if None, else integer from 1-N | |
| figsize=None, # defaults to rc figure.figsize | |
| dpi=None, # defaults to rc figure.dpi | |
| facecolor=None, # defaults to rc figure.facecolor | |
| edgecolor=None, # defaults to rc figure.edgecolor | |
| frameon=True, | |
| FigureClass=Figure, | |
| clear=False, | |
| **kwargs | |
| ): | |
| """ | |
| Create a new figure. | |
| Parameters | |
| ---------- | |
| num : integer or string, optional, default: None | |
| If not provided, a new figure will be created, and the figure number | |
| will be incremented. The figure objects holds this number in a `number` | |
| attribute. | |
| If num is provided, and a figure with this id already exists, make | |
| it active, and returns a reference to it. If this figure does not | |
| exists, create it and returns it. | |
| If num is a string, the window title will be set to this figure's | |
| `num`. | |
| figsize : (float, float), optional, default: None | |
| width, height in inches. If not provided, defaults to | |
| :rc:`figure.figsize` = ``[6.4, 4.8]``. | |
| dpi : integer, optional, default: None | |
| resolution of the figure. If not provided, defaults to | |
| :rc:`figure.dpi` = ``100``. | |
| facecolor : color spec | |
| the background color. If not provided, defaults to | |
| :rc:`figure.facecolor` = ``'w'``. | |
| edgecolor : color spec | |
| the border color. If not provided, defaults to | |
| :rc:`figure.edgecolor` = ``'w'``. | |
| frameon : bool, optional, default: True | |
| If False, suppress drawing the figure frame. | |
| FigureClass : subclass of `~matplotlib.figure.Figure` | |
| Optionally use a custom `.Figure` instance. | |
| clear : bool, optional, default: False | |
| If True and the figure already exists, then it is cleared. | |
| Returns | |
| ------- | |
| figure : `~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 | |
| :func:`.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. | |
| """ | |
| if figsize is None: | |
| figsize = rcParams['figure.figsize'] | |
| if dpi is None: | |
| dpi = rcParams['figure.dpi'] | |
| if facecolor is None: | |
| facecolor = rcParams['figure.facecolor'] | |
| if edgecolor is None: | |
| edgecolor = rcParams['figure.edgecolor'] | |
| allnums = get_fignums() | |
| next_num = max(allnums) + 1 if allnums else 1 | |
| figLabel = '' | |
| if num is None: | |
| num = next_num | |
| elif isinstance(num, str): | |
| figLabel = num | |
| allLabels = get_figlabels() | |
| if figLabel not in allLabels: | |
| if figLabel == 'all': | |
| cbook._warn_external( | |
| "close('all') closes all existing figures") | |
| num = next_num | |
| else: | |
| inum = allLabels.index(figLabel) | |
| num = allnums[inum] | |
| else: | |
| num = int(num) # crude validation of num argument | |
| figManager = _pylab_helpers.Gcf.get_fig_manager(num) | |
| if figManager is None: | |
| max_open_warning = rcParams['figure.max_open_warning'] | |
| if len(allnums) >= max_open_warning >= 1: | |
| cbook._warn_external( | |
| "More than %d figures have been opened. Figures " | |
| "created through the pyplot interface " | |
| "(`matplotlib.pyplot.figure`) are retained until " | |
| "explicitly closed and may consume too much memory. " | |
| "(To control this warning, see the rcParam " | |
| "`figure.max_open_warning`)." % | |
| max_open_warning, RuntimeWarning) | |
| if get_backend().lower() == 'ps': | |
| dpi = 72 | |
| figManager = new_figure_manager(num, figsize=figsize, | |
| dpi=dpi, | |
| facecolor=facecolor, | |
| edgecolor=edgecolor, | |
| frameon=frameon, | |
| FigureClass=FigureClass, | |
| **kwargs) | |
| if figLabel: | |
| figManager.set_window_title(figLabel) | |
| figManager.canvas.figure.set_label(figLabel) | |
| # make this figure current on button press event | |
| def make_active(event): | |
| _pylab_helpers.Gcf.set_active(figManager) | |
| cid = figManager.canvas.mpl_connect('button_press_event', make_active) | |
| figManager._cidgcf = cid | |
| _pylab_helpers.Gcf.set_active(figManager) | |
| fig = figManager.canvas.figure | |
| fig.number = num | |
| # make sure backends (inline) that we don't ship that expect this | |
| # to be called in plotting commands to make the figure call show | |
| # still work. There is probably a better way to do this in the | |
| # FigureManager base class. | |
| if matplotlib.is_interactive(): | |
| draw_if_interactive() | |
| if _INSTALL_FIG_OBSERVER: | |
| fig.stale_callback = _auto_draw_if_interactive | |
| if clear: | |
| figManager.canvas.figure.clear() | |
| return figManager.canvas.figure | |
| def _auto_draw_if_interactive(fig, val): | |
| """ | |
| This is an internal helper function for making sure that auto-redrawing | |
| works as intended in the plain python repl. | |
| Parameters | |
| ---------- | |
| fig : Figure | |
| A figure object which is assumed to be associated with a canvas | |
| """ | |
| if val and matplotlib.is_interactive() and not fig.canvas.is_saving(): | |
| fig.canvas.draw_idle() | |
| def gcf(): | |
| """Get a reference to the current figure.""" | |
| figManager = _pylab_helpers.Gcf.get_active() | |
| if figManager is not None: | |
| return figManager.canvas.figure | |
| else: | |
| return figure() | |
| def fignum_exists(num): | |
| """Return whether the figure with the given id exists.""" | |
| return _pylab_helpers.Gcf.has_fignum(num) or num in get_figlabels() | |
| def get_fignums(): | |
| """Return a list of existing figure numbers.""" | |
| return sorted(_pylab_helpers.Gcf.figs) | |
| def get_figlabels(): | |
| """Return a list of existing figure labels.""" | |
| figManagers = _pylab_helpers.Gcf.get_all_fig_managers() | |
| figManagers.sort(key=lambda m: m.num) | |
| return [m.canvas.figure.get_label() for m in figManagers] | |
| def get_current_fig_manager(): | |
| """ | |
| Return the figure manager of the active figure. | |
| If there is currently no active figure, a new one is created. | |
| """ | |
| figManager = _pylab_helpers.Gcf.get_active() | |
| if figManager is None: | |
| gcf() # creates an active figure as a side effect | |
| figManager = _pylab_helpers.Gcf.get_active() | |
| return figManager | |
| @docstring.copy(FigureCanvasBase.mpl_connect) | |
| def connect(s, func): | |
| return get_current_fig_manager().canvas.mpl_connect(s, func) | |
| @docstring.copy(FigureCanvasBase.mpl_disconnect) | |
| def disconnect(cid): | |
| return get_current_fig_manager().canvas.mpl_disconnect(cid) | |
| def 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 | |
| """ | |
| if fig is None: | |
| figManager = _pylab_helpers.Gcf.get_active() | |
| if figManager is None: | |
| return | |
| else: | |
| _pylab_helpers.Gcf.destroy(figManager.num) | |
| elif fig == 'all': | |
| _pylab_helpers.Gcf.destroy_all() | |
| elif isinstance(fig, int): | |
| _pylab_helpers.Gcf.destroy(fig) | |
| elif hasattr(fig, 'int'): | |
| # if we are dealing with a type UUID, we | |
| # can use its integer representation | |
| _pylab_helpers.Gcf.destroy(fig.int) | |
| elif isinstance(fig, str): | |
| allLabels = get_figlabels() | |
| if fig in allLabels: | |
| num = get_fignums()[allLabels.index(fig)] | |
| _pylab_helpers.Gcf.destroy(num) | |
| elif isinstance(fig, Figure): | |
| _pylab_helpers.Gcf.destroy_fig(fig) | |
| else: | |
| raise TypeError("close() argument must be a Figure, an int, a string, " | |
| "or None, not '%s'") | |
| def clf(): | |
| """Clear the current figure.""" | |
| gcf().clf() | |
| def draw(): | |
| """Redraw the current figure. | |
| This is used to update a figure that has been altered, but not | |
| automatically re-drawn. If interactive mode is on (:func:`.ion()`), this | |
| should be only rarely needed, but there may be ways to modify the state of | |
| a figure without marking it as `stale`. Please report these cases as | |
| bugs. | |
| A more object-oriented alternative, given any | |
| :class:`~matplotlib.figure.Figure` instance, :attr:`fig`, that | |
| was created using a :mod:`~matplotlib.pyplot` function, is:: | |
| fig.canvas.draw_idle() | |
| """ | |
| get_current_fig_manager().canvas.draw_idle() | |
| @docstring.copy(Figure.savefig) | |
| def savefig(*args, **kwargs): | |
| fig = gcf() | |
| res = fig.savefig(*args, **kwargs) | |
| fig.canvas.draw_idle() # need this if 'transparent=True' to reset colors | |
| return res | |
| @docstring.copy(Figure.ginput) | |
| def ginput(*args, **kwargs): | |
| """ | |
| Blocking call to interact with the figure. | |
| This will wait for *n* clicks from the user and return a list of the | |
| coordinates of each click. | |
| If *timeout* is negative, does not timeout. | |
| """ | |
| return gcf().ginput(*args, **kwargs) | |
| @docstring.copy(Figure.waitforbuttonpress) | |
| def waitforbuttonpress(*args, **kwargs): | |
| """ | |
| Blocking call to interact with the figure. | |
| This will wait for *n* key or mouse clicks from the user and | |
| return a list containing True's for keyboard clicks and False's | |
| for mouse clicks. | |
| If *timeout* is negative, does not timeout. | |
| """ | |
| return gcf().waitforbuttonpress(*args, **kwargs) | |
| ## Putting things in figures ## | |
| @docstring.copy(Figure.text) | |
| def figtext(x, y, s, *args, **kwargs): | |
| return gcf().text(x, y, s, *args, **kwargs) | |
| @docstring.copy(Figure.suptitle) | |
| def suptitle(t, **kwargs): | |
| return gcf().suptitle(t, **kwargs) | |
| @docstring.copy(Figure.figimage) | |
| def figimage(*args, **kwargs): | |
| return gcf().figimage(*args, **kwargs) | |
| def figlegend(*args, **kwargs): | |
| return gcf().legend(*args, **kwargs) | |
| if Figure.legend.__doc__: | |
| figlegend.__doc__ = Figure.legend.__doc__.replace("legend(", "figlegend(") | |
| ## Axes ## | |
| @docstring.dedent_interpd | |
| def 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, 4-tuple, Axes } | |
| The exact behavior of this function depends on the type: | |
| - *None*: A new full window axes is added using | |
| ``subplot(111, **kwargs)`` | |
| - 4-tuple of floats *rect* = ``[left, bottom, width, height]``. | |
| A new axes is added with dimensions *rect* in normalized | |
| (0, 1) units using `~.Figure.add_axes` on the current figure. | |
| - `~.axes.Axes`: This is equivalent to `.pyplot.sca`. | |
| It sets the current axes to *arg*. Note: This implicitly | |
| changes the current figure to the parent of *arg*. | |
| .. note:: The use of an `.axes.Axes` as an argument is deprecated | |
| and will be removed in v3.0. Please use `.pyplot.sca` | |
| instead. | |
| projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', \ | |
| 'polar', 'rectilinear', str}, optional | |
| The projection type of the `~.axes.Axes`. *str* is the name of | |
| a costum projection, see `~matplotlib.projections`. The default | |
| None results in a 'rectilinear' projection. | |
| polar : boolean, optional | |
| 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. | |
| 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. | |
| %(Axes)s | |
| Returns | |
| ------- | |
| axes : `~.axes.Axes` (or a subclass of `~.axes.Axes`) | |
| The returned axes class depends on the projection used. It is | |
| `~.axes.Axes` if rectilinear projection are used and | |
| `.projections.polar.PolarAxes` if polar projection | |
| are used. | |
| 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') | |
| """ | |
| if arg is None: | |
| return subplot(111, **kwargs) | |
| else: | |
| return gcf().add_axes(arg, **kwargs) | |
| def delaxes(ax=None): | |
| """ | |
| Remove the `Axes` *ax* (defaulting to the current axes) from its figure. | |
| A KeyError is raised if the axes doesn't exist. | |
| """ | |
| if ax is None: | |
| ax = gca() | |
| ax.figure.delaxes(ax) | |
| def sca(ax): | |
| """ | |
| Set the current Axes instance to *ax*. | |
| The current Figure is updated to the parent of *ax*. | |
| """ | |
| managers = _pylab_helpers.Gcf.get_all_fig_managers() | |
| for m in managers: | |
| if ax in m.canvas.figure.axes: | |
| _pylab_helpers.Gcf.set_active(m) | |
| m.canvas.figure.sca(ax) | |
| return | |
| raise ValueError("Axes instance argument was not found in a figure") | |
| def gca(**kwargs): | |
| """ | |
| Get the current :class:`~matplotlib.axes.Axes` instance on the | |
| current figure matching the given keyword args, or create one. | |
| Examples | |
| -------- | |
| To get the current polar axes on the current figure:: | |
| plt.gca(projection='polar') | |
| If the current axes doesn't exist, or isn't a polar one, the appropriate | |
| axes will be created and then returned. | |
| See Also | |
| -------- | |
| matplotlib.figure.Figure.gca : The figure's gca method. | |
| """ | |
| return gcf().gca(**kwargs) | |
| ## More ways of creating axes ## | |
| @docstring.dedent_interpd | |
| def 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(ax) | |
| Parameters | |
| ---------- | |
| *args | |
| Either a 3-digit integer or three separate integers | |
| describing the position of the subplot. If the three | |
| integers are *nrows*, *ncols*, and *index* in order, 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. | |
| *pos* is a three digit integer, where the first digit is the | |
| number of rows, the second the number of columns, and the third | |
| the index of the subplot. i.e. fig.add_subplot(235) is the same as | |
| fig.add_subplot(2, 3, 5). Note that all integers must be less than | |
| 10 for this form to work. | |
| projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', \ | |
| 'polar', 'rectilinear', str}, optional | |
| The projection type of the subplot (`~.axes.Axes`). *str* is the name | |
| of a costum projection, see `~matplotlib.projections`. The default | |
| None results in a 'rectilinear' projection. | |
| polar : boolean, optional | |
| 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. | |
| Other Parameters | |
| ---------------- | |
| **kwargs | |
| This method also takes the keyword arguments for | |
| the returned axes base class. 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. | |
| %(Axes)s | |
| Returns | |
| ------- | |
| axes : an `.axes.SubplotBase` subclass of `~.axes.Axes` (or a 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 | |
| are used and `.projections.polar.PolarAxes` if polar projection | |
| are used. The returned axes is then a subplot subclass of the | |
| base class. | |
| 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) | |
| """ | |
| # if subplot called without arguments, create subplot(1,1,1) | |
| if len(args) == 0: | |
| args = (1, 1, 1) | |
| # This check was added because it is very easy to type | |
| # subplot(1, 2, False) when subplots(1, 2, False) was intended | |
| # (sharex=False, that is). In most cases, no error will | |
| # ever occur, but mysterious behavior can result because what was | |
| # intended to be the sharex argument is instead treated as a | |
| # subplot index for subplot() | |
| if len(args) >= 3 and isinstance(args[2], bool): | |
| cbook._warn_external("The subplot index argument to subplot() appears " | |
| "to be a boolean. Did you intend to use " | |
| "subplots()?") | |
| fig = gcf() | |
| a = fig.add_subplot(*args, **kwargs) | |
| bbox = a.bbox | |
| byebye = [] | |
| for other in fig.axes: | |
| if other == a: | |
| continue | |
| if bbox.fully_overlaps(other.bbox): | |
| byebye.append(other) | |
| for ax in byebye: | |
| delaxes(ax) | |
| return a | |
| def subplots(nrows=1, ncols=1, sharex=False, sharey=False, squeeze=True, | |
| subplot_kw=None, gridspec_kw=None, **fig_kw): | |
| """ | |
| Create a figure and a set of subplots. | |
| This utility wrapper makes it convenient to create common layouts of | |
| subplots, including the enclosing figure object, in a single call. | |
| Parameters | |
| ---------- | |
| nrows, ncols : int, optional, default: 1 | |
| Number of rows/columns of the subplot grid. | |
| sharex, sharey : bool or {'none', 'all', 'row', 'col'}, default: False | |
| Controls sharing of properties among x (`sharex`) or y (`sharey`) | |
| axes: | |
| - True or 'all': x- or y-axis will be shared among all | |
| subplots. | |
| - False or 'none': each subplot x- or y-axis will be | |
| independent. | |
| - 'row': each subplot row will share an x- or y-axis. | |
| - 'col': each subplot column will share an x- or y-axis. | |
| When subplots have a shared x-axis along a column, only the x tick | |
| labels of the bottom subplot are 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, optional, 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. | |
| num : integer or string, optional, default: None | |
| A `.pyplot.figure` keyword that sets the figure number or label. | |
| 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` object or array of Axes objects. | |
| *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. | |
| Examples | |
| -------- | |
| :: | |
| # First create some toy data: | |
| x = np.linspace(0, 2*np.pi, 400) | |
| y = np.sin(x**2) | |
| # Creates just a figure and only one subplot | |
| fig, ax = plt.subplots() | |
| ax.plot(x, y) | |
| ax.set_title('Simple plot') | |
| # Creates two subplots and unpacks the output array immediately | |
| f, (ax1, ax2) = plt.subplots(1, 2, sharey=True) | |
| ax1.plot(x, y) | |
| ax1.set_title('Sharing Y axis') | |
| ax2.scatter(x, y) | |
| # Creates four polar axes, and accesses them through the returned array | |
| fig, axes = plt.subplots(2, 2, subplot_kw=dict(polar=True)) | |
| axes[0, 0].plot(x, y) | |
| axes[1, 1].scatter(x, y) | |
| # Share a X axis with each column of subplots | |
| plt.subplots(2, 2, sharex='col') | |
| # Share a Y axis with each row of subplots | |
| plt.subplots(2, 2, sharey='row') | |
| # Share both X and Y axes with all subplots | |
| plt.subplots(2, 2, sharex='all', sharey='all') | |
| # Note that this is the same as | |
| plt.subplots(2, 2, sharex=True, sharey=True) | |
| # Creates figure number 10 with a single subplot | |
| # and clears it if it already exists. | |
| fig, ax=plt.subplots(num=10, clear=True) | |
| See Also | |
| -------- | |
| .pyplot.figure | |
| .pyplot.subplot | |
| .pyplot.axes | |
| .Figure.subplots | |
| .Figure.add_subplot | |
| """ | |
| fig = figure(**fig_kw) | |
| axs = fig.subplots(nrows=nrows, ncols=ncols, sharex=sharex, sharey=sharey, | |
| squeeze=squeeze, subplot_kw=subplot_kw, | |
| gridspec_kw=gridspec_kw) | |
| return fig, axs | |
| def subplot2grid(shape, loc, rowspan=1, colspan=1, fig=None, **kwargs): | |
| """ | |
| Create an axis at specific location inside a regular grid. | |
| Parameters | |
| ---------- | |
| shape : sequence of 2 ints | |
| Shape of grid in which to place axis. | |
| First entry is number of rows, second entry is number of columns. | |
| loc : sequence of 2 ints | |
| Location to place axis within grid. | |
| First entry is row number, second entry is column number. | |
| rowspan : int | |
| Number of rows for the axis to span to the right. | |
| colspan : int | |
| Number of columns for the axis to span downwards. | |
| fig : `Figure`, optional | |
| Figure to place axis in. Defaults to current figure. | |
| **kwargs | |
| Additional keyword arguments are handed to `add_subplot`. | |
| Notes | |
| ----- | |
| The following call :: | |
| subplot2grid(shape, loc, rowspan=1, colspan=1) | |
| is identical to :: | |
| gridspec=GridSpec(shape[0], shape[1]) | |
| subplotspec=gridspec.new_subplotspec(loc, rowspan, colspan) | |
| subplot(subplotspec) | |
| """ | |
| if fig is None: | |
| fig = gcf() | |
| s1, s2 = shape | |
| subplotspec = GridSpec(s1, s2).new_subplotspec(loc, | |
| rowspan=rowspan, | |
| colspan=colspan) | |
| a = fig.add_subplot(subplotspec, **kwargs) | |
| bbox = a.bbox | |
| byebye = [] | |
| for other in fig.axes: | |
| if other == a: | |
| continue | |
| if bbox.fully_overlaps(other.bbox): | |
| byebye.append(other) | |
| for ax in byebye: | |
| delaxes(ax) | |
| return a | |
| def twinx(ax=None): | |
| """ | |
| Make a second axes that shares the *x*-axis. The new axes will | |
| overlay *ax* (or the current axes if *ax* is *None*). The ticks | |
| for *ax2* will be placed on the right, and the *ax2* instance is | |
| returned. | |
| .. seealso:: | |
| :doc:`/gallery/subplots_axes_and_figures/two_scales` | |
| """ | |
| if ax is None: | |
| ax = gca() | |
| ax1 = ax.twinx() | |
| return ax1 | |
| def twiny(ax=None): | |
| """ | |
| Make a second axes that shares the *y*-axis. The new axis will | |
| overlay *ax* (or the current axes if *ax* is *None*). The ticks | |
| for *ax2* will be placed on the top, and the *ax2* instance is | |
| returned. | |
| """ | |
| if ax is None: | |
| ax = gca() | |
| ax1 = ax.twiny() | |
| return ax1 | |
| def subplots_adjust(left=None, bottom=None, right=None, top=None, | |
| wspace=None, hspace=None): | |
| """ | |
| Tune the subplot layout. | |
| The parameter meanings (and suggested defaults) are:: | |
| left = 0.125 # the left side of the subplots of the figure | |
| right = 0.9 # the right side of the subplots of the figure | |
| bottom = 0.1 # the bottom of the subplots of the figure | |
| top = 0.9 # the top of the subplots of the figure | |
| wspace = 0.2 # the amount of width reserved for space between subplots, | |
| # expressed as a fraction of the average axis width | |
| hspace = 0.2 # the amount of height reserved for space between subplots, | |
| # expressed as a fraction of the average axis height | |
| The actual defaults are controlled by the rc file | |
| """ | |
| fig = gcf() | |
| fig.subplots_adjust(left, bottom, right, top, wspace, hspace) | |
| def subplot_tool(targetfig=None): | |
| """ | |
| Launch a subplot tool window for a figure. | |
| A :class:`matplotlib.widgets.SubplotTool` instance is returned. | |
| """ | |
| tbar = rcParams['toolbar'] # turn off navigation toolbar for the toolfig | |
| rcParams['toolbar'] = 'None' | |
| if targetfig is None: | |
| manager = get_current_fig_manager() | |
| targetfig = manager.canvas.figure | |
| else: | |
| # find the manager for this figure | |
| for manager in _pylab_helpers.Gcf._activeQue: | |
| if manager.canvas.figure == targetfig: | |
| break | |
| else: | |
| raise RuntimeError('Could not find manager for targetfig') | |
| toolfig = figure(figsize=(6, 3)) | |
| toolfig.subplots_adjust(top=0.9) | |
| ret = SubplotTool(targetfig, toolfig) | |
| rcParams['toolbar'] = tbar | |
| _pylab_helpers.Gcf.set_active(manager) # restore the current figure | |
| return ret | |
| def tight_layout(pad=1.08, h_pad=None, w_pad=None, rect=None): | |
| """ | |
| Automatically adjust subplot parameters to give specified padding. | |
| Parameters | |
| ---------- | |
| pad : float | |
| Padding between the figure edge and the edges of subplots, | |
| as a fraction of the font size. | |
| h_pad, w_pad : float, optional | |
| Padding (height/width) between edges of adjacent subplots, | |
| as a fraction of the font size. Defaults to *pad*. | |
| rect : tuple (left, bottom, right, top), optional | |
| A rectangle (left, bottom, right, top) in the normalized | |
| figure coordinate that the whole subplots area (including | |
| labels) will fit into. Default is (0, 0, 1, 1). | |
| """ | |
| gcf().tight_layout(pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect) | |
| def 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` | |
| """ | |
| ax = gca() | |
| if on is None: | |
| on = not ax.get_frame_on() | |
| ax.set_frame_on(on) | |
| ## Axis ## | |
| def 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. | |
| """ | |
| ax = gca() | |
| if not args and not kwargs: | |
| return ax.get_xlim() | |
| ret = ax.set_xlim(*args, **kwargs) | |
| return ret | |
| def 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. | |
| """ | |
| ax = gca() | |
| if not args and not kwargs: | |
| return ax.get_ylim() | |
| ret = ax.set_ylim(*args, **kwargs) | |
| return ret | |
| def xticks(ticks=None, labels=None, **kwargs): | |
| """ | |
| Get or set the current tick locations and labels of the x-axis. | |
| Call signatures:: | |
| locs, labels = xticks() # Get locations and labels | |
| xticks(ticks, [labels], **kwargs) # Set locations and labels | |
| Parameters | |
| ---------- | |
| ticks : array_like | |
| A list of positions at which ticks should be placed. You can pass an | |
| empty list to disable xticks. | |
| labels : array_like, optional | |
| A list of explicit labels to place at the given *locs*. | |
| **kwargs | |
| :class:`.Text` properties can be used to control the appearance of | |
| the labels. | |
| Returns | |
| ------- | |
| locs | |
| An array of label locations. | |
| labels | |
| A list of `.Text` objects. | |
| Notes | |
| ----- | |
| Calling this function with no arguments (e.g. ``xticks()``) is the pyplot | |
| equivalent of calling `~.Axes.get_xticks` and `~.Axes.get_xticklabels` on | |
| the current axes. | |
| Calling this function with arguments is the pyplot equivalent of calling | |
| `~.Axes.set_xticks` and `~.Axes.set_xticklabels` on the current axes. | |
| Examples | |
| -------- | |
| Get the current locations and labels: | |
| >>> locs, labels = xticks() | |
| Set label locations: | |
| >>> xticks(np.arange(0, 1, step=0.2)) | |
| Set text labels: | |
| >>> xticks(np.arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue')) | |
| Set text labels and properties: | |
| >>> xticks(np.arange(12), calendar.month_name[1:13], rotation=20) | |
| Disable xticks: | |
| >>> xticks([]) | |
| """ | |
| ax = gca() | |
| if ticks is None and labels is None: | |
| locs = ax.get_xticks() | |
| labels = ax.get_xticklabels() | |
| elif labels is None: | |
| locs = ax.set_xticks(ticks) | |
| labels = ax.get_xticklabels() | |
| else: | |
| locs = ax.set_xticks(ticks) | |
| labels = ax.set_xticklabels(labels, **kwargs) | |
| for l in labels: | |
| l.update(kwargs) | |
| return locs, silent_list('Text xticklabel', labels) | |
| def yticks(ticks=None, labels=None, **kwargs): | |
| """ | |
| Get or set the current tick locations and labels of the y-axis. | |
| Call signatures:: | |
| locs, labels = yticks() # Get locations and labels | |
| yticks(ticks, [labels], **kwargs) # Set locations and labels | |
| Parameters | |
| ---------- | |
| ticks : array_like | |
| A list of positions at which ticks should be placed. You can pass an | |
| empty list to disable yticks. | |
| labels : array_like, optional | |
| A list of explicit labels to place at the given *locs*. | |
| **kwargs | |
| :class:`.Text` properties can be used to control the appearance of | |
| the labels. | |
| Returns | |
| ------- | |
| locs | |
| An array of label locations. | |
| labels | |
| A list of `.Text` objects. | |
| Notes | |
| ----- | |
| Calling this function with no arguments (e.g. ``yticks()``) is the pyplot | |
| equivalent of calling `~.Axes.get_yticks` and `~.Axes.get_yticklabels` on | |
| the current axes. | |
| Calling this function with arguments is the pyplot equivalent of calling | |
| `~.Axes.set_yticks` and `~.Axes.set_yticklabels` on the current axes. | |
| Examples | |
| -------- | |
| Get the current locations and labels: | |
| >>> locs, labels = yticks() | |
| Set label locations: | |
| >>> yticks(np.arange(0, 1, step=0.2)) | |
| Set text labels: | |
| >>> yticks(np.arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue')) | |
| Set text labels and properties: | |
| >>> yticks(np.arange(12), calendar.month_name[1:13], rotation=45) | |
| Disable yticks: | |
| >>> yticks([]) | |
| """ | |
| ax = gca() | |
| if ticks is None and labels is None: | |
| locs = ax.get_yticks() | |
| labels = ax.get_yticklabels() | |
| elif labels is None: | |
| locs = ax.set_yticks(ticks) | |
| labels = ax.get_yticklabels() | |
| else: | |
| locs = ax.set_yticks(ticks) | |
| labels = ax.set_yticklabels(labels, **kwargs) | |
| for l in labels: | |
| l.update(kwargs) | |
| return locs, silent_list('Text yticklabel', labels) | |
| def rgrids(*args, **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, labels : list of `.lines.Line2D`, list of `.text.Text` | |
| *lines* are the radial gridlines and *labels* are the tick labels. | |
| Other Parameters | |
| ---------------- | |
| **kwargs | |
| *kwargs* are optional `~.Text` properties for the labels. | |
| 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' )) | |
| See Also | |
| -------- | |
| .pyplot.thetagrids | |
| .projections.polar.PolarAxes.set_rgrids | |
| .Axis.get_gridlines | |
| .Axis.get_ticklabels | |
| """ | |
| ax = gca() | |
| if not isinstance(ax, PolarAxes): | |
| raise RuntimeError('rgrids only defined for polar axes') | |
| if len(args) == 0: | |
| lines = ax.yaxis.get_gridlines() | |
| labels = ax.yaxis.get_ticklabels() | |
| else: | |
| lines, labels = ax.set_rgrids(*args, **kwargs) | |
| return (silent_list('Line2D rgridline', lines), | |
| silent_list('Text rgridlabel', labels)) | |
| def thetagrids(*args, **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, labels : list of `.lines.Line2D`, list of `.text.Text` | |
| *lines* are the theta gridlines and *labels* are the tick labels. | |
| Other Parameters | |
| ---------------- | |
| **kwargs | |
| *kwargs* are optional `~.Text` properties for the labels. | |
| 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') ) | |
| See Also | |
| -------- | |
| .pyplot.rgrids | |
| .projections.polar.PolarAxes.set_thetagrids | |
| .Axis.get_gridlines | |
| .Axis.get_ticklabels | |
| """ | |
| ax = gca() | |
| if not isinstance(ax, PolarAxes): | |
| raise RuntimeError('thetagrids only defined for polar axes') | |
| if len(args) == 0: | |
| lines = ax.xaxis.get_ticklines() | |
| labels = ax.xaxis.get_ticklabels() | |
| else: | |
| lines, labels = ax.set_thetagrids(*args, **kwargs) | |
| return (silent_list('Line2D thetagridline', lines), | |
| silent_list('Text thetagridlabel', labels)) | |
| ## Plotting Info ## | |
| def plotting(): | |
| pass | |
| def get_plot_commands(): | |
| """ | |
| Get a sorted list of all of the plotting commands. | |
| """ | |
| # This works by searching for all functions in this module and removing | |
| # a few hard-coded exclusions, as well as all of the colormap-setting | |
| # functions, and anything marked as private with a preceding underscore. | |
| exclude = {'colormaps', 'colors', 'connect', 'disconnect', | |
| 'get_plot_commands', 'get_current_fig_manager', 'ginput', | |
| 'plotting', 'waitforbuttonpress'} | |
| exclude |= set(colormaps()) | |
| this_module = inspect.getmodule(get_plot_commands) | |
| return sorted( | |
| name for name, obj in globals().items() | |
| if not name.startswith('_') and name not in exclude | |
| and inspect.isfunction(obj) | |
| and inspect.getmodule(obj) is this_module) | |
| def 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 | |
| <http://colorbrewer2.org>`_ color specifications and designs developed by | |
| Cynthia Brewer: | |
| ColorBrewer Diverging (luminance is highest at the midpoint, and | |
| decreases towards differently-colored endpoints): | |
| ======== =================================== | |
| Colormap Description | |
| ======== =================================== | |
| BrBG brown, white, blue-green | |
| PiYG pink, white, yellow-green | |
| PRGn purple, white, green | |
| PuOr orange, white, purple | |
| RdBu red, white, blue | |
| RdGy red, white, gray | |
| RdYlBu red, yellow, blue | |
| RdYlGn red, yellow, green | |
| Spectral red, orange, yellow, green, blue | |
| ======== =================================== | |
| ColorBrewer Sequential (luminance decreases monotonically): | |
| ======== ==================================== | |
| Colormap Description | |
| ======== ==================================== | |
| Blues white to dark blue | |
| BuGn white, light blue, dark green | |
| BuPu white, light blue, dark purple | |
| GnBu white, light green, dark blue | |
| Greens white to dark green | |
| Greys white to black (not linear) | |
| Oranges white, orange, dark brown | |
| OrRd white, orange, dark red | |
| PuBu white, light purple, dark blue | |
| PuBuGn white, light purple, dark green | |
| PuRd white, light purple, dark red | |
| Purples white to dark purple | |
| RdPu white, pink, dark purple | |
| Reds white to dark red | |
| YlGn light yellow, dark green | |
| YlGnBu light yellow, light green, dark blue | |
| YlOrBr light yellow, orange, dark brown | |
| YlOrRd light yellow, orange, dark red | |
| ======== ==================================== | |
| ColorBrewer Qualitative: | |
| (For plotting nominal data, :class:`ListedColormap` is used, | |
| not :class:`LinearSegmentedColormap`. Different sets of colors are | |
| recommended for different numbers of categories.) | |
| * Accent | |
| * Dark2 | |
| * Paired | |
| * Pastel1 | |
| * Pastel2 | |
| * Set1 | |
| * Set2 | |
| * Set3 | |
| A set of colormaps derived from those of the same name provided | |
| with Matlab are also included: | |
| ========= ======================================================= | |
| Colormap Description | |
| ========= ======================================================= | |
| autumn sequential linearly-increasing shades of red-orange-yellow | |
| bone sequential increasing black-white color map with | |
| a tinge of blue, to emulate X-ray film | |
| cool linearly-decreasing shades of cyan-magenta | |
| copper sequential increasing shades of black-copper | |
| flag repetitive red-white-blue-black pattern (not cyclic at | |
| endpoints) | |
| gray sequential linearly-increasing black-to-white | |
| grayscale | |
| hot sequential black-red-yellow-white, to emulate blackbody | |
| radiation from an object at increasing temperatures | |
| 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 | |
| ============= ======================================================= | |
| 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 | |
| <http://ieeexplore.ieee.org/document/4118486/?arnumber=4118486>`_ | |
| .. [#] Resembles "BkBlAqGrYeOrReViWh200" from NCAR Command | |
| Language. See `Color Table Gallery | |
| <https://www.ncl.ucar.edu/Document/Graphics/color_table_gallery.shtml>`_ | |
| .. [#] See `Diverging Color Maps for Scientific Visualization | |
| <http://www.kennethmoreland.com/color-maps/>`_ by Kenneth Moreland. | |
| .. [#] See `A Color Map for Effective Black-and-White Rendering of | |
| Color-Scale Images | |
| <https://www.mathworks.com/matlabcentral/fileexchange/2662-cmrmap-m>`_ | |
| by Carey Rappaport | |
| """ | |
| return sorted(cm.cmap_d) | |
| def _setup_pyplot_info_docstrings(): | |
| """ | |
| Generates the plotting docstring. | |
| These must be done after the entire module is imported, so it is | |
| called from the end of this module, which is generated by | |
| boilerplate.py. | |
| """ | |
| commands = get_plot_commands() | |
| first_sentence = re.compile(r"(?:\s*).+?\.(?:\s+|$)", flags=re.DOTALL) | |
| # Collect the first sentence of the docstring for all of the | |
| # plotting commands. | |
| rows = [] | |
| max_name = len("Function") | |
| max_summary = len("Description") | |
| for name in commands: | |
| doc = globals()[name].__doc__ | |
| summary = '' | |
| if doc is not None: | |
| match = first_sentence.match(doc) | |
| if match is not None: | |
| summary = inspect.cleandoc(match.group(0)).replace('\n', ' ') | |
| name = '`%s`' % name | |
| rows.append([name, summary]) | |
| max_name = max(max_name, len(name)) | |
| max_summary = max(max_summary, len(summary)) | |
| separator = '=' * max_name + ' ' + '=' * max_summary | |
| lines = [ | |
| separator, | |
| '{:{}} {:{}}'.format('Function', max_name, 'Description', max_summary), | |
| separator, | |
| ] + [ | |
| '{:{}} {:{}}'.format(name, max_name, summary, max_summary) | |
| for name, summary in rows | |
| ] + [ | |
| separator, | |
| ] | |
| plotting.__doc__ = '\n'.join(lines) | |
| ## Plotting part 1: manually generated functions and wrappers ## | |
| def colorbar(mappable=None, cax=None, ax=None, **kw): | |
| if mappable is None: | |
| mappable = gci() | |
| if mappable is None: | |
| raise RuntimeError('No mappable was found to use for colorbar ' | |
| 'creation. First define a mappable such as ' | |
| 'an image (with imshow) or a contour set (' | |
| 'with contourf).') | |
| if ax is None: | |
| ax = gca() | |
| ret = gcf().colorbar(mappable, cax=cax, ax=ax, **kw) | |
| return ret | |
| colorbar.__doc__ = matplotlib.colorbar.colorbar_doc | |
| def clim(vmin=None, vmax=None): | |
| """ | |
| Set the color limits of the current image. | |
| To apply clim to all axes images do:: | |
| clim(0, 0.5) | |
| If either *vmin* or *vmax* is None, the image min/max respectively | |
| will be used for color scaling. | |
| If you want to set the clim of multiple images, | |
| use, for example:: | |
| for im in gca().get_images(): | |
| im.set_clim(0, 0.05) | |
| """ | |
| im = gci() | |
| if im is None: | |
| raise RuntimeError('You must first define an image, e.g., with imshow') | |
| im.set_clim(vmin, vmax) | |
| def set_cmap(cmap): | |
| """ | |
| Set the default colormap. Applies to the current image if any. | |
| See help(colormaps) for more information. | |
| *cmap* must be a :class:`~matplotlib.colors.Colormap` instance, or | |
| the name of a registered colormap. | |
| See :func:`matplotlib.cm.register_cmap` and | |
| :func:`matplotlib.cm.get_cmap`. | |
| """ | |
| cmap = cm.get_cmap(cmap) | |
| rc('image', cmap=cmap.name) | |
| im = gci() | |
| if im is not None: | |
| im.set_cmap(cmap) | |
| @docstring.copy(matplotlib.image.imread) | |
| def imread(fname, format=None): | |
| return matplotlib.image.imread(fname, format) | |
| @docstring.copy(matplotlib.image.imsave) | |
| def imsave(fname, arr, **kwargs): | |
| return matplotlib.image.imsave(fname, arr, **kwargs) | |
| def 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 | |
| ------- | |
| image : `~matplotlib.image.AxesImage` | |
| Other Parameters | |
| ---------------- | |
| **kwargs : `~matplotlib.axes.Axes.imshow` arguments | |
| """ | |
| A = np.asanyarray(A) | |
| if fignum == 0: | |
| ax = gca() | |
| else: | |
| # Extract actual aspect ratio of array and make appropriately sized | |
| # figure. | |
| fig = figure(fignum, figsize=figaspect(A)) | |
| ax = fig.add_axes([0.15, 0.09, 0.775, 0.775]) | |
| im = ax.matshow(A, **kwargs) | |
| sci(im) | |
| return im | |
| def polar(*args, **kwargs): | |
| """ | |
| Make a polar plot. | |
| call signature:: | |
| polar(theta, r, **kwargs) | |
| Multiple *theta*, *r* arguments are supported, with format | |
| strings, as in :func:`~matplotlib.pyplot.plot`. | |
| """ | |
| # If an axis already exists, check if it has a polar projection | |
| if gcf().get_axes(): | |
| if not isinstance(gca(), PolarAxes): | |
| cbook._warn_external('Trying to create polar plot on an axis ' | |
| 'that does not have a polar projection.') | |
| ax = gca(polar=True) | |
| ret = ax.plot(*args, **kwargs) | |
| return ret | |
| def plotfile(fname, cols=(0,), plotfuncs=None, | |
| comments='#', skiprows=0, checkrows=5, delimiter=',', | |
| names=None, subplots=True, newfig=True, **kwargs): | |
| """ | |
| Plot the data in a file. | |
| *cols* is a sequence of column identifiers to plot. An identifier | |
| is either an int or a string. If it is an int, it indicates the | |
| column number. If it is a string, it indicates the column header. | |
| matplotlib will make column headers lower case, replace spaces with | |
| underscores, and remove all illegal characters; so ``'Adj Close*'`` | |
| will have name ``'adj_close'``. | |
| - If len(*cols*) == 1, only that column will be plotted on the *y* axis. | |
| - If len(*cols*) > 1, the first element will be an identifier for | |
| data for the *x* axis and the remaining elements will be the | |
| column indexes for multiple subplots if *subplots* is *True* | |
| (the default), or for lines in a single subplot if *subplots* | |
| is *False*. | |
| *plotfuncs*, if not *None*, is a dictionary mapping identifier to | |
| an :class:`~matplotlib.axes.Axes` plotting function as a string. | |
| Default is 'plot', other choices are 'semilogy', 'fill', 'bar', | |
| etc. You must use the same type of identifier in the *cols* | |
| vector as you use in the *plotfuncs* dictionary, e.g., integer | |
| column numbers in both or column names in both. If *subplots* | |
| is *False*, then including any function such as 'semilogy' | |
| that changes the axis scaling will set the scaling for all | |
| columns. | |
| - *comments*: the character used to indicate the start of a comment | |
| in the file, or *None* to switch off the removal of comments | |
| - *skiprows*: is the number of rows from the top to skip | |
| - *checkrows*: is the number of rows to check to validate the column | |
| data type. When set to zero all rows are validated. | |
| - *delimiter*: is the character(s) separating row items | |
| - *names*: if not None, is a list of header names. In this case, no | |
| header will be read from the file | |
| If *newfig* is *True*, the plot always will be made in a new figure; | |
| if *False*, it will be made in the current figure if one exists, | |
| else in a new figure. | |
| kwargs are passed on to plotting functions. | |
| Example usage:: | |
| # plot the 2nd and 4th column against the 1st in two subplots | |
| plotfile(fname, (0,1,3)) | |
| # plot using column names; specify an alternate plot type for volume | |
| plotfile(fname, ('date', 'volume', 'adj_close'), | |
| plotfuncs={'volume': 'semilogy'}) | |
| Note: plotfile is intended as a convenience for quickly plotting | |
| data from flat files; it is not intended as an alternative | |
| interface to general plotting with pyplot or matplotlib. | |
| """ | |
| if newfig: | |
| fig = figure() | |
| else: | |
| fig = gcf() | |
| if len(cols) < 1: | |
| raise ValueError('must have at least one column of data') | |
| if plotfuncs is None: | |
| plotfuncs = {} | |
| from matplotlib.cbook import MatplotlibDeprecationWarning | |
| with warnings.catch_warnings(): | |
| warnings.simplefilter('ignore', MatplotlibDeprecationWarning) | |
| r = mlab._csv2rec(fname, comments=comments, skiprows=skiprows, | |
| checkrows=checkrows, delimiter=delimiter, | |
| names=names) | |
| def getname_val(identifier): | |
| 'return the name and column data for identifier' | |
| if isinstance(identifier, str): | |
| return identifier, r[identifier] | |
| elif isinstance(identifier, Number): | |
| name = r.dtype.names[int(identifier)] | |
| return name, r[name] | |
| else: | |
| raise TypeError('identifier must be a string or integer') | |
| xname, x = getname_val(cols[0]) | |
| ynamelist = [] | |
| if len(cols) == 1: | |
| ax1 = fig.add_subplot(1, 1, 1) | |
| funcname = plotfuncs.get(cols[0], 'plot') | |
| func = getattr(ax1, funcname) | |
| func(x, **kwargs) | |
| ax1.set_ylabel(xname) | |
| else: | |
| N = len(cols) | |
| for i in range(1, N): | |
| if subplots: | |
| if i == 1: | |
| ax = ax1 = fig.add_subplot(N - 1, 1, i) | |
| else: | |
| ax = fig.add_subplot(N - 1, 1, i, sharex=ax1) | |
| elif i == 1: | |
| ax = fig.add_subplot(1, 1, 1) | |
| yname, y = getname_val(cols[i]) | |
| ynamelist.append(yname) | |
| funcname = plotfuncs.get(cols[i], 'plot') | |
| func = getattr(ax, funcname) | |
| func(x, y, **kwargs) | |
| if subplots: | |
| ax.set_ylabel(yname) | |
| if ax.is_last_row(): | |
| ax.set_xlabel(xname) | |
| else: | |
| ax.set_xlabel('') | |
| if not subplots: | |
| ax.legend(ynamelist) | |
| if xname == 'date': | |
| fig.autofmt_xdate() | |
| # If rcParams['backend_fallback'] is true, and an interactive backend is | |
| # requested, ignore rcParams['backend'] and force selection of a backend that | |
| # is compatible with the current running interactive framework. | |
| if (rcParams["backend_fallback"] | |
| and dict.__getitem__(rcParams, "backend") in _interactive_bk | |
| and _get_running_interactive_framework()): | |
| dict.__setitem__(rcParams, "backend", rcsetup._auto_backend_sentinel) | |
| # Set up the backend. | |
| switch_backend(rcParams["backend"]) | |
| # Just to be safe. Interactive mode can be turned on without | |
| # calling `plt.ion()` so register it again here. | |
| # This is safe because multiple calls to `install_repl_displayhook` | |
| # are no-ops and the registered function respect `mpl.is_interactive()` | |
| # to determine if they should trigger a draw. | |
| install_repl_displayhook() | |
| ################# REMAINING CONTENT GENERATED BY boilerplate.py ############## | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.acorr) | |
| def acorr(x, *, data=None, **kwargs): | |
| return gca().acorr( | |
| x, **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.angle_spectrum) | |
| def angle_spectrum( | |
| x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, | |
| data=None, **kwargs): | |
| return gca().angle_spectrum( | |
| x, Fs=Fs, Fc=Fc, window=window, pad_to=pad_to, sides=sides, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.annotate) | |
| def annotate(s, xy, *args, **kwargs): | |
| return gca().annotate(s, xy, *args, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.arrow) | |
| def arrow(x, y, dx, dy, **kwargs): | |
| return gca().arrow(x, y, dx, dy, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.autoscale) | |
| def autoscale(enable=True, axis='both', tight=None): | |
| return gca().autoscale(enable=enable, axis=axis, tight=tight) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.axhline) | |
| def axhline(y=0, xmin=0, xmax=1, **kwargs): | |
| return gca().axhline(y=y, xmin=xmin, xmax=xmax, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.axhspan) | |
| def axhspan(ymin, ymax, xmin=0, xmax=1, **kwargs): | |
| return gca().axhspan(ymin, ymax, xmin=xmin, xmax=xmax, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.axis) | |
| def axis(*v, **kwargs): | |
| return gca().axis(*v, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.axvline) | |
| def axvline(x=0, ymin=0, ymax=1, **kwargs): | |
| return gca().axvline(x=x, ymin=ymin, ymax=ymax, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.axvspan) | |
| def axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs): | |
| return gca().axvspan(xmin, xmax, ymin=ymin, ymax=ymax, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.bar) | |
| def bar( | |
| x, height, width=0.8, bottom=None, *, align='center', | |
| data=None, **kwargs): | |
| return gca().bar( | |
| x, height, width=width, bottom=bottom, align=align, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.barbs) | |
| def barbs(*args, data=None, **kw): | |
| return gca().barbs( | |
| *args, **({"data": data} if data is not None else {}), **kw) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.barh) | |
| def barh(y, width, height=0.8, left=None, *, align='center', **kwargs): | |
| return gca().barh( | |
| y, width, height=height, left=left, align=align, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.boxplot) | |
| def boxplot( | |
| x, notch=None, sym=None, vert=None, whis=None, | |
| positions=None, widths=None, patch_artist=None, | |
| bootstrap=None, usermedians=None, conf_intervals=None, | |
| meanline=None, showmeans=None, showcaps=None, showbox=None, | |
| showfliers=None, boxprops=None, labels=None, flierprops=None, | |
| medianprops=None, meanprops=None, capprops=None, | |
| whiskerprops=None, manage_xticks=True, autorange=False, | |
| zorder=None, *, data=None): | |
| return gca().boxplot( | |
| x, notch=notch, sym=sym, vert=vert, whis=whis, | |
| positions=positions, widths=widths, patch_artist=patch_artist, | |
| bootstrap=bootstrap, usermedians=usermedians, | |
| conf_intervals=conf_intervals, meanline=meanline, | |
| showmeans=showmeans, showcaps=showcaps, showbox=showbox, | |
| showfliers=showfliers, boxprops=boxprops, labels=labels, | |
| flierprops=flierprops, medianprops=medianprops, | |
| meanprops=meanprops, capprops=capprops, | |
| whiskerprops=whiskerprops, manage_xticks=manage_xticks, | |
| autorange=autorange, zorder=zorder, **({"data": data} if data | |
| is not None else {})) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.broken_barh) | |
| def broken_barh(xranges, yrange, *, data=None, **kwargs): | |
| return gca().broken_barh( | |
| xranges, yrange, **({"data": data} if data is not None else | |
| {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.cla) | |
| def cla(): | |
| return gca().cla() | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.clabel) | |
| def clabel(CS, *args, **kwargs): | |
| return gca().clabel(CS, *args, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.cohere) | |
| def cohere( | |
| x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none, | |
| window=mlab.window_hanning, noverlap=0, pad_to=None, | |
| sides='default', scale_by_freq=None, *, data=None, **kwargs): | |
| return gca().cohere( | |
| x, y, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, | |
| noverlap=noverlap, pad_to=pad_to, sides=sides, | |
| scale_by_freq=scale_by_freq, **({"data": data} if data is not | |
| None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.contour) | |
| def contour(*args, data=None, **kwargs): | |
| __ret = gca().contour( | |
| *args, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| if __ret._A is not None: sci(__ret) # noqa | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.contourf) | |
| def contourf(*args, data=None, **kwargs): | |
| __ret = gca().contourf( | |
| *args, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| if __ret._A is not None: sci(__ret) # noqa | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.csd) | |
| def 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): | |
| return gca().csd( | |
| x, y, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, | |
| noverlap=noverlap, pad_to=pad_to, sides=sides, | |
| scale_by_freq=scale_by_freq, return_line=return_line, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.errorbar) | |
| def 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): | |
| return gca().errorbar( | |
| x, y, yerr=yerr, xerr=xerr, fmt=fmt, ecolor=ecolor, | |
| elinewidth=elinewidth, capsize=capsize, barsabove=barsabove, | |
| lolims=lolims, uplims=uplims, xlolims=xlolims, | |
| xuplims=xuplims, errorevery=errorevery, capthick=capthick, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.eventplot) | |
| def eventplot( | |
| positions, orientation='horizontal', lineoffsets=1, | |
| linelengths=1, linewidths=None, colors=None, | |
| linestyles='solid', *, data=None, **kwargs): | |
| return gca().eventplot( | |
| positions, orientation=orientation, lineoffsets=lineoffsets, | |
| linelengths=linelengths, linewidths=linewidths, colors=colors, | |
| linestyles=linestyles, **({"data": data} if data is not None | |
| else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.fill) | |
| def fill(*args, data=None, **kwargs): | |
| return gca().fill( | |
| *args, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.fill_between) | |
| def fill_between( | |
| x, y1, y2=0, where=None, interpolate=False, step=None, *, | |
| data=None, **kwargs): | |
| return gca().fill_between( | |
| x, y1, y2=y2, where=where, interpolate=interpolate, step=step, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.fill_betweenx) | |
| def fill_betweenx( | |
| y, x1, x2=0, where=None, step=None, interpolate=False, *, | |
| data=None, **kwargs): | |
| return gca().fill_betweenx( | |
| y, x1, x2=x2, where=where, step=step, interpolate=interpolate, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.grid) | |
| def grid(b=None, which='major', axis='both', **kwargs): | |
| return gca().grid(b=b, which=which, axis=axis, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.hexbin) | |
| def 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=np.mean, mincnt=None, marginals=False, *, | |
| data=None, **kwargs): | |
| __ret = gca().hexbin( | |
| x, y, C=C, gridsize=gridsize, bins=bins, xscale=xscale, | |
| yscale=yscale, extent=extent, cmap=cmap, norm=norm, vmin=vmin, | |
| vmax=vmax, alpha=alpha, linewidths=linewidths, | |
| edgecolors=edgecolors, reduce_C_function=reduce_C_function, | |
| mincnt=mincnt, marginals=marginals, **({"data": data} if data | |
| is not None else {}), **kwargs) | |
| sci(__ret) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.hist) | |
| def hist( | |
| x, bins=None, range=None, density=None, weights=None, | |
| cumulative=False, bottom=None, histtype='bar', align='mid', | |
| orientation='vertical', rwidth=None, log=False, color=None, | |
| label=None, stacked=False, normed=None, *, data=None, | |
| **kwargs): | |
| return gca().hist( | |
| x, bins=bins, range=range, density=density, weights=weights, | |
| cumulative=cumulative, bottom=bottom, histtype=histtype, | |
| align=align, orientation=orientation, rwidth=rwidth, log=log, | |
| color=color, label=label, stacked=stacked, normed=normed, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.hist2d) | |
| def hist2d( | |
| x, y, bins=10, range=None, density=False, weights=None, | |
| cmin=None, cmax=None, *, data=None, **kwargs): | |
| __ret = gca().hist2d( | |
| x, y, bins=bins, range=range, density=density, | |
| weights=weights, cmin=cmin, cmax=cmax, **({"data": data} if | |
| data is not None else {}), **kwargs) | |
| sci(__ret[-1]) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.hlines) | |
| def hlines( | |
| y, xmin, xmax, colors='k', linestyles='solid', label='', *, | |
| data=None, **kwargs): | |
| return gca().hlines( | |
| y, xmin, xmax, colors=colors, linestyles=linestyles, | |
| label=label, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.imshow) | |
| def imshow( | |
| X, cmap=None, norm=None, aspect=None, interpolation=None, | |
| alpha=None, vmin=None, vmax=None, origin=None, extent=None, | |
| shape=None, filternorm=1, filterrad=4.0, imlim=None, | |
| resample=None, url=None, *, data=None, **kwargs): | |
| __ret = gca().imshow( | |
| X, cmap=cmap, norm=norm, aspect=aspect, | |
| interpolation=interpolation, alpha=alpha, vmin=vmin, | |
| vmax=vmax, origin=origin, extent=extent, shape=shape, | |
| filternorm=filternorm, filterrad=filterrad, imlim=imlim, | |
| resample=resample, url=url, **({"data": data} if data is not | |
| None else {}), **kwargs) | |
| sci(__ret) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.legend) | |
| def legend(*args, **kwargs): | |
| return gca().legend(*args, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.locator_params) | |
| def locator_params(axis='both', tight=None, **kwargs): | |
| return gca().locator_params(axis=axis, tight=tight, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.loglog) | |
| def loglog(*args, **kwargs): | |
| return gca().loglog(*args, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.magnitude_spectrum) | |
| def magnitude_spectrum( | |
| x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, | |
| scale=None, *, data=None, **kwargs): | |
| return gca().magnitude_spectrum( | |
| x, Fs=Fs, Fc=Fc, window=window, pad_to=pad_to, sides=sides, | |
| scale=scale, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.margins) | |
| def margins(*margins, x=None, y=None, tight=True): | |
| return gca().margins(*margins, x=x, y=y, tight=tight) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.minorticks_off) | |
| def minorticks_off(): | |
| return gca().minorticks_off() | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.minorticks_on) | |
| def minorticks_on(): | |
| return gca().minorticks_on() | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.pcolor) | |
| def pcolor( | |
| *args, alpha=None, norm=None, cmap=None, vmin=None, | |
| vmax=None, data=None, **kwargs): | |
| __ret = gca().pcolor( | |
| *args, alpha=alpha, norm=norm, cmap=cmap, vmin=vmin, | |
| vmax=vmax, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| sci(__ret) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.pcolormesh) | |
| def pcolormesh( | |
| *args, alpha=None, norm=None, cmap=None, vmin=None, | |
| vmax=None, shading='flat', antialiased=False, data=None, | |
| **kwargs): | |
| __ret = gca().pcolormesh( | |
| *args, alpha=alpha, norm=norm, cmap=cmap, vmin=vmin, | |
| vmax=vmax, shading=shading, antialiased=antialiased, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| sci(__ret) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.phase_spectrum) | |
| def phase_spectrum( | |
| x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, | |
| data=None, **kwargs): | |
| return gca().phase_spectrum( | |
| x, Fs=Fs, Fc=Fc, window=window, pad_to=pad_to, sides=sides, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.pie) | |
| def pie( | |
| x, explode=None, labels=None, colors=None, autopct=None, | |
| pctdistance=0.6, shadow=False, labeldistance=1.1, | |
| startangle=None, radius=None, counterclock=True, | |
| wedgeprops=None, textprops=None, center=(0, 0), frame=False, | |
| rotatelabels=False, *, data=None): | |
| return gca().pie( | |
| x, explode=explode, labels=labels, colors=colors, | |
| autopct=autopct, pctdistance=pctdistance, shadow=shadow, | |
| labeldistance=labeldistance, startangle=startangle, | |
| radius=radius, counterclock=counterclock, | |
| wedgeprops=wedgeprops, textprops=textprops, center=center, | |
| frame=frame, rotatelabels=rotatelabels, **({"data": data} if | |
| data is not None else {})) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.plot) | |
| def plot(*args, scalex=True, scaley=True, data=None, **kwargs): | |
| return gca().plot( | |
| *args, scalex=scalex, scaley=scaley, **({"data": data} if data | |
| is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.plot_date) | |
| def plot_date( | |
| x, y, fmt='o', tz=None, xdate=True, ydate=False, *, | |
| data=None, **kwargs): | |
| return gca().plot_date( | |
| x, y, fmt=fmt, tz=tz, xdate=xdate, ydate=ydate, **({"data": | |
| data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.psd) | |
| def 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): | |
| return gca().psd( | |
| x, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, | |
| noverlap=noverlap, pad_to=pad_to, sides=sides, | |
| scale_by_freq=scale_by_freq, return_line=return_line, | |
| **({"data": data} if data is not None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.quiver) | |
| def quiver(*args, data=None, **kw): | |
| __ret = gca().quiver( | |
| *args, **({"data": data} if data is not None else {}), **kw) | |
| sci(__ret) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.quiverkey) | |
| def quiverkey(Q, X, Y, U, label, **kw): | |
| return gca().quiverkey(Q, X, Y, U, label, **kw) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.scatter) | |
| def scatter( | |
| x, y, s=None, c=None, marker=None, cmap=None, norm=None, | |
| vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, | |
| edgecolors=None, *, plotnonfinite=False, data=None, **kwargs): | |
| __ret = gca().scatter( | |
| x, y, s=s, c=c, marker=marker, cmap=cmap, norm=norm, | |
| vmin=vmin, vmax=vmax, alpha=alpha, linewidths=linewidths, | |
| verts=verts, edgecolors=edgecolors, | |
| plotnonfinite=plotnonfinite, **({"data": data} if data is not | |
| None else {}), **kwargs) | |
| sci(__ret) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.semilogx) | |
| def semilogx(*args, **kwargs): | |
| return gca().semilogx(*args, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.semilogy) | |
| def semilogy(*args, **kwargs): | |
| return gca().semilogy(*args, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.specgram) | |
| def 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): | |
| __ret = gca().specgram( | |
| x, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, | |
| noverlap=noverlap, cmap=cmap, xextent=xextent, pad_to=pad_to, | |
| sides=sides, scale_by_freq=scale_by_freq, mode=mode, | |
| scale=scale, vmin=vmin, vmax=vmax, **({"data": data} if data | |
| is not None else {}), **kwargs) | |
| sci(__ret[-1]) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.spy) | |
| def spy( | |
| Z, precision=0, marker=None, markersize=None, aspect='equal', | |
| origin='upper', **kwargs): | |
| __ret = gca().spy( | |
| Z, precision=precision, marker=marker, markersize=markersize, | |
| aspect=aspect, origin=origin, **kwargs) | |
| if isinstance(__ret, cm.ScalarMappable): sci(__ret) # noqa | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.stackplot) | |
| def stackplot(x, *args, data=None, **kwargs): | |
| return gca().stackplot( | |
| x, *args, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.stem) | |
| def stem( | |
| *args, linefmt=None, markerfmt=None, basefmt=None, bottom=0, | |
| label=None, data=None): | |
| return gca().stem( | |
| *args, linefmt=linefmt, markerfmt=markerfmt, basefmt=basefmt, | |
| bottom=bottom, label=label, **({"data": data} if data is not | |
| None else {})) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.step) | |
| def step(x, y, *args, where='pre', data=None, **kwargs): | |
| return gca().step( | |
| x, y, *args, where=where, **({"data": data} if data is not | |
| None else {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.streamplot) | |
| def 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): | |
| __ret = gca().streamplot( | |
| x, y, u, v, density=density, linewidth=linewidth, color=color, | |
| cmap=cmap, norm=norm, arrowsize=arrowsize, | |
| arrowstyle=arrowstyle, minlength=minlength, | |
| transform=transform, zorder=zorder, start_points=start_points, | |
| maxlength=maxlength, | |
| integration_direction=integration_direction, **({"data": data} | |
| if data is not None else {})) | |
| sci(__ret.lines) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.table) | |
| def 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): | |
| return gca().table( | |
| cellText=cellText, cellColours=cellColours, cellLoc=cellLoc, | |
| colWidths=colWidths, rowLabels=rowLabels, | |
| rowColours=rowColours, rowLoc=rowLoc, colLabels=colLabels, | |
| colColours=colColours, colLoc=colLoc, loc=loc, bbox=bbox, | |
| edges=edges, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.text) | |
| def text(x, y, s, fontdict=None, withdash=False, **kwargs): | |
| return gca().text(x, y, s, fontdict=fontdict, withdash=withdash, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.tick_params) | |
| def tick_params(axis='both', **kwargs): | |
| return gca().tick_params(axis=axis, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.ticklabel_format) | |
| def ticklabel_format( | |
| *, axis='both', style='', scilimits=None, useOffset=None, | |
| useLocale=None, useMathText=None): | |
| return gca().ticklabel_format( | |
| axis=axis, style=style, scilimits=scilimits, | |
| useOffset=useOffset, useLocale=useLocale, | |
| useMathText=useMathText) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.tricontour) | |
| def tricontour(*args, **kwargs): | |
| __ret = gca().tricontour(*args, **kwargs) | |
| if __ret._A is not None: sci(__ret) # noqa | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.tricontourf) | |
| def tricontourf(*args, **kwargs): | |
| __ret = gca().tricontourf(*args, **kwargs) | |
| if __ret._A is not None: sci(__ret) # noqa | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.tripcolor) | |
| def tripcolor(*args, **kwargs): | |
| __ret = gca().tripcolor(*args, **kwargs) | |
| sci(__ret) | |
| return __ret | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.triplot) | |
| def triplot(*args, **kwargs): | |
| return gca().triplot(*args, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.violinplot) | |
| def violinplot( | |
| dataset, positions=None, vert=True, widths=0.5, | |
| showmeans=False, showextrema=True, showmedians=False, | |
| points=100, bw_method=None, *, data=None): | |
| return gca().violinplot( | |
| dataset, positions=positions, vert=vert, widths=widths, | |
| showmeans=showmeans, showextrema=showextrema, | |
| showmedians=showmedians, points=points, bw_method=bw_method, | |
| **({"data": data} if data is not None else {})) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.vlines) | |
| def vlines( | |
| x, ymin, ymax, colors='k', linestyles='solid', label='', *, | |
| data=None, **kwargs): | |
| return gca().vlines( | |
| x, ymin, ymax, colors=colors, linestyles=linestyles, | |
| label=label, **({"data": data} if data is not None else {}), | |
| **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.xcorr) | |
| def xcorr( | |
| x, y, normed=True, detrend=mlab.detrend_none, usevlines=True, | |
| maxlags=10, *, data=None, **kwargs): | |
| return gca().xcorr( | |
| x, y, normed=normed, detrend=detrend, usevlines=usevlines, | |
| maxlags=maxlags, **({"data": data} if data is not None else | |
| {}), **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes._sci) | |
| def sci(im): | |
| return gca()._sci(im) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.set_title) | |
| def title(label, fontdict=None, loc='center', pad=None, **kwargs): | |
| return gca().set_title( | |
| label, fontdict=fontdict, loc=loc, pad=pad, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.set_xlabel) | |
| def xlabel(xlabel, fontdict=None, labelpad=None, **kwargs): | |
| return gca().set_xlabel( | |
| xlabel, fontdict=fontdict, labelpad=labelpad, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.set_ylabel) | |
| def ylabel(ylabel, fontdict=None, labelpad=None, **kwargs): | |
| return gca().set_ylabel( | |
| ylabel, fontdict=fontdict, labelpad=labelpad, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.set_xscale) | |
| def xscale(value, **kwargs): | |
| return gca().set_xscale(value, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| @docstring.copy(Axes.set_yscale) | |
| def yscale(value, **kwargs): | |
| return gca().set_yscale(value, **kwargs) | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("autumn") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("bone") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("cool") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("copper") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("flag") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("gray") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("hot") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("hsv") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("jet") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("pink") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("prism") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("spring") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("summer") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("winter") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("magma") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("inferno") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("plasma") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("viridis") | |
| # Autogenerated by boilerplate.py. Do not edit as changes will be lost. | |
| def 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. | |
| """ | |
| set_cmap("nipy_spectral") | |
| _setup_pyplot_info_docstrings() |