【Python】matplotlib

24541 ワード
Python

>>> help(matplotlib) 
>>> help(matplotlib)
Help on package matplotlib:

NAME
    matplotlib - An object-oriented plotting library.

DESCRIPTION
    A procedural interface is provided by the companion pyplot module,
    which may be imported directly, e.g.::
    
        import matplotlib.pyplot as plt
    
    or using ipython::
    
        ipython
    
    at your terminal, followed by::
    
        In [1]: %matplotlib
        In [2]: import matplotlib.pyplot as plt
    
    at the ipython shell prompt.
    
    For the most part, direct use of the object-oriented library is encouraged when
    programming; pyplot is primarily for working interactively.  The exceptions are
    the pyplot functions `.pyplot.figure`, `.pyplot.subplot`, `.pyplot.subplots`,
    and `.pyplot.savefig`, which can greatly simplify scripting.
    
    Modules include:
    
        :mod:`matplotlib.axes`
            The `~.axes.Axes` class.  Most pyplot functions are wrappers for
            `~.axes.Axes` methods.  The axes module is the highest level of OO
            access to the library.
    
        :mod:`matplotlib.figure`
            The `.Figure` class.
    
        :mod:`matplotlib.artist`
            The `.Artist` base class for all classes that draw things.
    
        :mod:`matplotlib.lines`
            The `.Line2D` class for drawing lines and markers.
    
        :mod:`matplotlib.patches`
            Classes for drawing polygons.
    
        :mod:`matplotlib.text`
            The `.Text` and `.Annotation` classes.
    
        :mod:`matplotlib.image`
            The `.AxesImage` and `.FigureImage` classes.
    
        :mod:`matplotlib.collections`
            Classes for efficient drawing of groups of lines or polygons.
    
        :mod:`matplotlib.colors`
            Color specifications and making colormaps.
    
        :mod:`matplotlib.cm`
            Colormaps, and the `.ScalarMappable` mixin class for providing color
            mapping functionality to other classes.
    
        :mod:`matplotlib.ticker`
            Calculation of tick mark locations and formatting of tick labels.
    
        :mod:`matplotlib.backends`
            A subpackage with modules for various GUI libraries and output formats.
    
    The base matplotlib namespace includes:
    
        `~matplotlib.rcParams`
            Default configuration settings; their defaults may be overridden using
            a :file:`matplotlibrc` file.
    
        `~matplotlib.use`
            Setting the Matplotlib backend.  This should be called before any
            figure is created, because it is not possible to switch between
            different GUI backends after that.
    
    Matplotlib was initially written by John D. Hunter (1968-2012) and is now
    developed and maintained by a host of others.
    
    Occasionally the internal documentation (python docstrings) will refer
    to MATLAB®, a registered trademark of The MathWorks, Inc.

PACKAGE CONTENTS
    _animation_data
    _cm
    _cm_listed
    _color_data
    _constrained_layout
    _contour
    _image
    _internal_utils
    _layoutbox
    _mathtext_data
    _path
    _pylab_helpers
    _qhull
    _text_layout
    _tri
    _ttconv
    _version
    afm
    animation
    artist
    axes (package)
    axis
    backend_bases
    backend_managers
    backend_tools
    backends (package)
    bezier
    blocking_input
    category
    cbook (package)
    cm
    collections
    colorbar
    colors
    compat (package)
    container
    contour
    dates
    docstring
    dviread
    figure
    font_manager
    fontconfig_pattern
    ft2font
    gridspec
    hatch
    image
    legend
    legend_handler
    lines
    markers
    mathtext
    mlab
    offsetbox
    patches
    path
    patheffects
    projections (package)
    pylab
    pyplot
    quiver
    rcsetup
    sankey
    scale
    sphinxext (package)
    spines
    stackplot
    streamplot
    style (package)
    table
    testing (package)
    tests (package)
    texmanager
    text
    textpath
    ticker
    tight_bbox
    tight_layout
    transforms
    tri (package)
    ttconv
    type1font
    units
    widgets

CLASSES
    builtins.FileNotFoundError(builtins.OSError)
        ExecutableNotFoundError
    builtins.dict(builtins.object)
        RcParams(collections.abc.MutableMapping, builtins.dict)
    collections.abc.MutableMapping(collections.abc.Mapping)
        RcParams(collections.abc.MutableMapping, builtins.dict)
    
    class ExecutableNotFoundError(builtins.FileNotFoundError)
     |  Error raised when an executable that Matplotlib optionally
     |  depends on can't be found.
     |  
     |  Method resolution order:
     |      ExecutableNotFoundError
     |      builtins.FileNotFoundError
     |      builtins.OSError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |  
     |  Data descriptors defined here:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.FileNotFoundError:
     |  
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.OSError:
     |  
     |  __reduce__(...)
     |      Helper for pickle.
     |  
     |  __str__(self, /)
     |      Return str(self).
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.OSError:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.OSError:
     |  
     |  characters_written
     |  
     |  errno
     |      POSIX exception code
     |  
     |  filename
     |      exception filename
     |  
     |  filename2
     |      second exception filename
     |  
     |  strerror
     |      exception strerror
     |  
     |  winerror
     |      Win32 exception code
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |  
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |  
     |  __setstate__(...)
     |  
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |  
     |  __cause__
     |      exception cause
     |  
     |  __context__
     |      exception context
     |  
     |  __dict__
     |  
     |  __suppress_context__
     |  
     |  __traceback__
     |  
     |  args
    
    class RcParams(collections.abc.MutableMapping, builtins.dict)
     |  RcParams(*args, **kwargs)
     |  
     |  A dictionary object including validation.
     |  
     |  Validating functions are defined and associated with rc parameters in
     |  :mod:`matplotlib.rcsetup`.
     |  
     |  See Also
     |  --------
     |  :ref:`customizing-with-matplotlibrc-files`
     |  
     |  Method resolution order:
     |      RcParams
     |      collections.abc.MutableMapping
     |      collections.abc.Mapping
     |      collections.abc.Collection
     |      collections.abc.Sized
     |      collections.abc.Iterable
     |      collections.abc.Container
     |      builtins.dict
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getitem__(self, key)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __init__(self, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __iter__(self)
     |      Yield sorted list of keys.
     |  
     |  __len__(self)
     |      Return len(self).
     |  
     |  __repr__(self)
     |      Return repr(self).
     |  
     |  __setitem__(self, key, val)
     |      Set self[key] to value.
     |  
     |  __str__(self)
     |      Return str(self).
     |  
     |  copy(self)
     |      D.copy() -> a shallow copy of D
     |  
     |  find_all(self, pattern)
     |      Return the subset of this RcParams dictionary whose keys match,
     |      using :func:`re.search`, the given ``pattern``.
     |      
     |      .. note::
     |      
     |          Changes to the returned dictionary are *not* propagated to
     |          the parent RcParams dictionary.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __abstractmethods__ = frozenset({'__delitem__'})
     |  
     |  validate = {'_internal.classic_mode': , 'agg.p...
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from collections.abc.MutableMapping:
     |  
     |  __delitem__(self, key)
     |  
     |  clear(self)
     |      D.clear() -> None.  Remove all items from D.
     |  
     |  pop(self, key, default=)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |      If key is not found, d is returned if given, otherwise KeyError is raised.
     |  
     |  popitem(self)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair
     |      as a 2-tuple; but raise KeyError if D is empty.
     |  
     |  setdefault(self, key, default=None)
     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
     |  
     |  update(*args, **kwds)
     |      D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
     |      If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
     |      If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
     |      In either case, this is followed by: for k, v in F.items(): D[k] = v
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from collections.abc.Mapping:
     |  
     |  __contains__(self, key)
     |  
     |  __eq__(self, other)
     |      Return self==value.
     |  
     |  get(self, key, default=None)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |  
     |  items(self)
     |      D.items() -> a set-like object providing a view on D's items
     |  
     |  keys(self)
     |      D.keys() -> a set-like object providing a view on D's keys
     |  
     |  values(self)
     |      D.values() -> an object providing a view on D's values
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from collections.abc.Mapping:
     |  
     |  __hash__ = None
     |  
     |  __reversed__ = None
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from collections.abc.Collection:
     |  
     |  __subclasshook__(C) from abc.ABCMeta
     |      Abstract classes can override this to customize issubclass().
     |      
     |      This is invoked early on by abc.ABCMeta.__subclasscheck__().
     |      It should return True, False or NotImplemented.  If it returns
     |      NotImplemented, the normal algorithm is used.  Otherwise, it
     |      overrides the normal algorithm (and the outcome is cached).
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.dict:
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __lt__(self, value, /)
     |      Return self size of D in memory, in bytes
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.dict:
     |  
     |  fromkeys(iterable, value=None, /) from abc.ABCMeta
     |      Create a new dictionary with keys from iterable and values set to value.
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.dict:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.

FUNCTIONS
    checkdep_ps_distiller(s)
        [*Deprecated*] 
        
        Notes
        -----
        .. deprecated:: 3.2
           \
    
    checkdep_usetex(s)
    
    compare_versions(a, b)
        [*Deprecated*] Return whether version *a* is greater than or equal to version *b*.
        
        Notes
        -----
        .. deprecated:: 3.2
    
    get_backend()
        Return the name of the current backend.
        
        See Also
        --------
        matplotlib.use
    
    get_cachedir()
        Return the string path of the cache directory.
        
        The procedure used to find the directory is the same as for
        _get_config_dir, except using ``$XDG_CACHE_HOME``/``$HOME/.cache`` instead.
    
    get_configdir()
        Return the string path of the the configuration directory.
        
        The directory is chosen as follows:
        
        1. If the MPLCONFIGDIR environment variable is supplied, choose that.
        2. On Linux, follow the XDG specification and look first in
           ``$XDG_CONFIG_HOME``, if defined, or ``$HOME/.config``.  On other
           platforms, choose ``$HOME/.matplotlib``.
        3. If the chosen directory exists and is writable, use that as the
           configuration directory.
        4. Else, create a temporary directory, and use it as the configuration
           directory.
    
    get_data_path(*, _from_rc=None)
        Return the path to Matplotlib data.
    
    get_home()
        [*Deprecated*] Return the user's home directory.
        
        If the user's home directory cannot be found, return None.
        
        Notes
        -----
        .. deprecated:: 3.2
    
    interactive(b)
        Set whether to redraw after every plotting command (e.g. `.pyplot.xlabel`).
    
    is_interactive()
        Return whether to redraw after every plotting command.
    
    is_url(filename)
        Return True if string is an http, ftp, or file URL path.
    
    matplotlib_fname()
        Get the location of the config file.
        
        The file location is determined in the following order
        
        - ``$PWD/matplotlibrc``
        - ``$MATPLOTLIBRC`` if it is not a directory
        - ``$MATPLOTLIBRC/matplotlibrc``
        - ``$MPLCONFIGDIR/matplotlibrc``
        - On Linux,
            - ``$XDG_CONFIG_HOME/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
              is defined)
            - or ``$HOME/.config/matplotlib/matplotlibrc`` (if ``$XDG_CONFIG_HOME``
              is not defined)
        - On other platforms,
          - ``$HOME/.matplotlib/matplotlibrc`` if ``$HOME`` is defined
        - Lastly, it looks in ``$MATPLOTLIBDATA/matplotlibrc``, which should always
          exist.
    
    rc(group, **kwargs)
        Set the current `.rcParams`.  *group* is the grouping for the rc, e.g.,
        for ``lines.linewidth`` the group is ``lines``, for
        ``axes.facecolor``, the group is ``axes``, and so on.  Group may
        also be a list or tuple of group names, e.g., (*xtick*, *ytick*).
        *kwargs* is a dictionary attribute name/value pairs, e.g.,::
        
          rc('lines', linewidth=2, color='r')
        
        sets the current `.rcParams` and is equivalent to::
        
          rcParams['lines.linewidth'] = 2
          rcParams['lines.color'] = 'r'
        
        The following aliases are available to save typing for interactive users:
        
        =====   =================
        Alias   Property
        =====   =================
        'lw'    'linewidth'
        'ls'    'linestyle'
        'c'     'color'
        'fc'    'facecolor'
        'ec'    'edgecolor'
        'mew'   'markeredgewidth'
        'aa'    'antialiased'
        =====   =================
        
        Thus you could abbreviate the above call as::
        
              rc('lines', lw=2, c='r')
        
        Note you can use python's kwargs dictionary facility to store
        dictionaries of default parameters.  e.g., you can customize the
        font rc as follows::
        
          font = {'family' : 'monospace',
                  'weight' : 'bold',
                  'size'   : 'larger'}
          rc('font', **font)  # pass in the font dict as kwargs
        
        This enables you to easily switch between several configurations.  Use
        ``matplotlib.style.use('default')`` or :func:`~matplotlib.rcdefaults` to
        restore the default `.rcParams` after changes.
        
        Notes
        -----
        Similar functionality is available by using the normal dict interface, i.e.
        ``rcParams.update({"lines.linewidth": 2, ...})`` (but ``rcParams.update``
        does not support abbreviations or grouping).
    
    rc_context(rc=None, fname=None)
        Return a context manager for temporarily changing rcParams.
        
        Parameters
        ----------
        rc : dict
            The rcParams to temporarily set.
        fname : str or path-like
            A file with Matplotlib rc settings. If both *fname* and *rc* are given,
            settings from *rc* take precedence.
        
        See Also
        --------
        :ref:`customizing-with-matplotlibrc-files`
        
        Examples
        --------
        Passing explicit values via a dict::
        
            with mpl.rc_context({'interactive': False}):
                fig, ax = plt.subplots()
                ax.plot(range(3), range(3))
                fig.savefig('example.png')
                plt.close(fig)
        
        Loading settings from a file::
        
             with mpl.rc_context(fname='print.rc'):
                 plt.plot(x, y)  # uses 'print.rc'
    
    rc_file(fname, *, use_default_template=True)
        Update `.rcParams` from file.
        
        Style-blacklisted `.rcParams` (defined in
        `matplotlib.style.core.STYLE_BLACKLIST`) are not updated.
        
        Parameters
        ----------
        fname : str or path-like
            A file with Matplotlib rc settings.
        
        use_default_template : bool
            If True, initialize with default parameters before updating with those
            in the given file. If False, the current configuration persists
            and only the parameters specified in the file are updated.
    
    rc_file_defaults()
        Restore the `.rcParams` from the original rc file loaded by Matplotlib.
        
        Style-blacklisted `.rcParams` (defined in
        `matplotlib.style.core.STYLE_BLACKLIST`) are not updated.
    
    rc_params(fail_on_error=False)
        Construct a `RcParams` instance from the default Matplotlib rc file.
    
    rc_params_from_file(fname, fail_on_error=False, use_default_template=True)
        Construct a `RcParams` from file *fname*.
        
        Parameters
        ----------
        fname : str or path-like
            A file with Matplotlib rc settings.
        fail_on_error : bool
            If True, raise an error when the parser fails to convert a parameter.
        use_default_template : bool
            If True, initialize with default parameters before updating with those
            in the given file. If False, the configuration class only contains the
            parameters specified in the file. (Useful for updating dicts.)
    
    rcdefaults()
        Restore the `.rcParams` from Matplotlib's internal default style.
        
        Style-blacklisted `.rcParams` (defined in
        `matplotlib.style.core.STYLE_BLACKLIST`) are not updated.
        
        See Also
        --------
        matplotlib.rc_file_defaults
            Restore the `.rcParams` from the rc file originally loaded by
            Matplotlib.
        matplotlib.style.use
            Use a specific style file.  Call ``style.use('default')`` to restore
            the default style.
    
    set_loglevel(level)
        Set Matplotlib's root logger and root logger handler level, creating
        the handler if it does not exist yet.
        
        Typically, one should call ``set_loglevel("info")`` or
        ``set_loglevel("debug")`` to get additional debugging information.
        
        Parameters
        ----------
        level : {"notset", "debug", "info", "warning", "error", "critical"}
            The log level of the handler.
        
        Notes
        -----
        The first time this function is called, an additional handler is attached
        to Matplotlib's root handler; this handler is reused every time and this
        function simply manipulates the logger and handler's level.
    
    test(verbosity=None, coverage=False, switch_backend_warn=, recursionlimit=, **kwargs)
        Run the matplotlib test suite.
    
    use(backend, *, force=True)
        Select the backend used for rendering and GUI integration.
        
        Parameters
        ----------
        backend : str
            The backend to switch to.  This can either be one of the standard
            backend names, which are case-insensitive:
        
            - interactive backends:
              GTK3Agg, GTK3Cairo, MacOSX, nbAgg,
              Qt4Agg, Qt4Cairo, Qt5Agg, Qt5Cairo,
              TkAgg, TkCairo, WebAgg, WX, WXAgg, WXCairo
        
            - non-interactive backends:
              agg, cairo, pdf, pgf, ps, svg, template
        
            or a string of the form: ``module://my.module.name``.
        
        force : bool, default: True
            If True (the default), raise an `ImportError` if the backend cannot be
            set up (either because it fails to import, or because an incompatible
            GUI interactive framework is already running); if False, ignore the
            failure.
        
        See Also
        --------
        :ref:`backends`
        matplotlib.get_backend

DATA
    URL_REGEX = re.compile('^http://|^https://|^ftp://|^file:')
    __bibtex__ = '@Article{Hunter:2007,
  Author    = {Hunter, J. ...ishe...
    defaultParams = {'_internal.classic_mode': [False,

Reverse String(Python)
DataURI, Blob, File, (Array)Bufferをざっくり知る。