matplotlib API Reference
Full documentation for matplotlib (3.9.2)
matplotlib.ExecutableNotFoundError
Python Library Documentation: class ExecutableNotFoundError in module matplotlib 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 | | ---------------------------------------------------------------------- | 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) class method of builtins.OSError | 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: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | 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
matplotlib.MatplotlibDeprecationWarning
Python Library Documentation: class MatplotlibDeprecationWarning in module matplotlib._api.deprecation class MatplotlibDeprecationWarning(builtins.DeprecationWarning) | A class for issuing deprecation warnings for Matplotlib users. | | Method resolution order: | MatplotlibDeprecationWarning | builtins.DeprecationWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.DeprecationWarning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.DeprecationWarning: | | __new__(*args, **kwargs) class method of builtins.DeprecationWarning | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | 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
matplotlib.MutableMapping
Python Library Documentation: class MutableMapping in module collections.abc
class MutableMapping(Mapping)
| A MutableMapping is a generic container for associating
| key/value pairs.
|
| This class provides concrete generic implementations of all
| methods except for __getitem__, __setitem__, __delitem__,
| __iter__, and __len__.
|
| Method resolution order:
| MutableMapping
| Mapping
| Collection
| Sized
| Iterable
| Container
| builtins.object
|
| Methods defined here:
|
| __delitem__(self, key)
|
| __setitem__(self, key, value)
|
| clear(self)
| D.clear() -> None. Remove all items from D.
|
| pop(self, key, default=<object object at 0x00000245A78981F0>)
| 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(self, other=(), /, **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
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__delitem__', '__getitem__', '__iter...
|
| ----------------------------------------------------------------------
| Methods inherited from Mapping:
|
| __contains__(self, key)
|
| __eq__(self, other)
| Return self==value.
|
| __getitem__(self, key)
|
| 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 Mapping:
|
| __hash__ = None
|
| __reversed__ = None
|
| ----------------------------------------------------------------------
| Class methods inherited from Collection:
|
| __subclasshook__(C)
| 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 Sized:
|
| __len__(self)
|
| ----------------------------------------------------------------------
| Methods inherited from Iterable:
|
| __iter__(self)
|
| ----------------------------------------------------------------------
| Class methods inherited from Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
matplotlib.Parameter
Python Library Documentation: class Parameter in module inspect class Parameter(builtins.object) | Parameter(name, kind, *, default, annotation) | | Represents a parameter in a function signature. | | Has the following public attributes: | | * name : str | The name of the parameter as a string. | * default : object | The default value for the parameter if specified. If the | parameter has no default value, this attribute is set to | `Parameter.empty`. | * annotation | The annotation for the parameter if specified. If the | parameter has no annotation, this attribute is set to | `Parameter.empty`. | * kind : str | Describes how argument values are bound to the parameter. | Possible values: `Parameter.POSITIONAL_ONLY`, | `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`, | `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`. | | Methods defined here: | | __eq__(self, other) | Return self==value. | | __hash__(self) | Return hash(self). | | __init__(self, name, kind, *, default, annotation) | Initialize self. See help(type(self)) for accurate signature. | | __reduce__(self) | Helper for pickle. | | __repr__(self) | Return repr(self). | | __setstate__(self, state) | | __str__(self) | Return str(self). | | replace(self, *, name=<class 'inspect._void'>, kind=<class 'inspect._void'>, annotation=<class 'inspect._void'>, default=<class 'inspect._void'>) | Creates a customized copy of the Parameter. | | ---------------------------------------------------------------------- | Readonly properties defined here: | | annotation | | default | | kind | | name | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | KEYWORD_ONLY = <_ParameterKind.KEYWORD_ONLY: 3> | | POSITIONAL_ONLY = <_ParameterKind.POSITIONAL_ONLY: 0> | | POSITIONAL_OR_KEYWORD = <_ParameterKind.POSITIONAL_OR_KEYWORD: 1> | | VAR_KEYWORD = <_ParameterKind.VAR_KEYWORD: 4> | | VAR_POSITIONAL = <_ParameterKind.VAR_POSITIONAL: 2> | | empty = <class 'inspect._empty'> | Marker object for Signature.empty and Parameter.empty.
matplotlib.Path
Python Library Documentation: class Path in module pathlib
class Path(PurePath)
| Path(*args, **kwargs)
|
| PurePath subclass that can make system calls.
|
| Path represents a filesystem path but unlike PurePath, also offers
| methods to do system calls on path objects. Depending on your system,
| instantiating a Path will return either a PosixPath or a WindowsPath
| object. You can also instantiate a PosixPath or WindowsPath directly,
| but cannot instantiate a WindowsPath on a POSIX system or vice versa.
|
| Method resolution order:
| Path
| PurePath
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
|
| __exit__(self, t, v, tb)
|
| __init__(self, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| absolute(self)
| Return an absolute version of this path by prepending the current
| working directory. No normalization or symlink resolution is performed.
|
| Use resolve() to get the canonical path to a file.
|
| chmod(self, mode, *, follow_symlinks=True)
| Change the permissions of the path, like os.chmod().
|
| exists(self, *, follow_symlinks=True)
| Whether this path exists.
|
| This method normally follows symlinks; to check whether a symlink exists,
| add the argument follow_symlinks=False.
|
| expanduser(self)
| Return a new path with expanded ~ and ~user constructs
| (as returned by os.path.expanduser)
|
| glob(self, pattern, *, case_sensitive=None)
| Iterate over this subtree and yield all existing files (of any
| kind, including directories) matching the given relative pattern.
|
| group(self)
| Return the group name of the file gid.
|
| hardlink_to(self, target)
| Make this path a hard link pointing to the same file as *target*.
|
| Note the order of arguments (self, target) is the reverse of os.link's.
|
| is_block_device(self)
| Whether this path is a block device.
|
| is_char_device(self)
| Whether this path is a character device.
|
| is_dir(self)
| Whether this path is a directory.
|
| is_fifo(self)
| Whether this path is a FIFO.
|
| is_file(self)
| Whether this path is a regular file (also True for symlinks pointing
| to regular files).
|
| is_junction(self)
| Whether this path is a junction.
|
| is_mount(self)
| Check if this path is a mount point
|
| is_socket(self)
| Whether this path is a socket.
|
| is_symlink(self)
| Whether this path is a symbolic link.
|
| iterdir(self)
| Yield path objects of the directory contents.
|
| The children are yielded in arbitrary order, and the
| special entries '.' and '..' are not included.
|
| lchmod(self, mode)
| Like chmod(), except if the path points to a symlink, the symlink's
| permissions are changed, rather than its target's.
|
| lstat(self)
| Like stat(), except if the path points to a symlink, the symlink's
| status information is returned, rather than its target's.
|
| mkdir(self, mode=511, parents=False, exist_ok=False)
| Create a new directory at this given path.
|
| open(self, mode='r', buffering=-1, encoding=None, errors=None, newline=None)
| Open the file pointed to by this path and return a file object, as
| the built-in open() function does.
|
| owner(self)
| Return the login name of the file owner.
|
| read_bytes(self)
| Open the file in bytes mode, read it, and close the file.
|
| read_text(self, encoding=None, errors=None)
| Open the file in text mode, read it, and close the file.
|
| readlink(self)
| Return the path to which the symbolic link points.
|
| rename(self, target)
| Rename this path to the target path.
|
| The target path may be absolute or relative. Relative paths are
| interpreted relative to the current working directory, *not* the
| directory of the Path object.
|
| Returns the new Path instance pointing to the target path.
|
| replace(self, target)
| Rename this path to the target path, overwriting if that path exists.
|
| The target path may be absolute or relative. Relative paths are
| interpreted relative to the current working directory, *not* the
| directory of the Path object.
|
| Returns the new Path instance pointing to the target path.
|
| resolve(self, strict=False)
| Make the path absolute, resolving all symlinks on the way and also
| normalizing it.
|
| rglob(self, pattern, *, case_sensitive=None)
| Recursively yield all existing files (of any kind, including
| directories) matching the given relative pattern, anywhere in
| this subtree.
|
| rmdir(self)
| Remove this directory. The directory must be empty.
|
| samefile(self, other_path)
| Return whether other_path is the same or not as this file
| (as returned by os.path.samefile()).
|
| stat(self, *, follow_symlinks=True)
| Return the result of the stat() system call on this path, like
| os.stat() does.
|
| symlink_to(self, target, target_is_directory=False)
| Make this path a symlink pointing to the target path.
| Note the order of arguments (link, target) is the reverse of os.symlink.
|
| touch(self, mode=438, exist_ok=True)
| Create this file with the given access mode, if it doesn't exist.
|
| unlink(self, missing_ok=False)
| Remove this file or link.
| If the path is a directory, use rmdir() instead.
|
| walk(self, top_down=True, on_error=None, follow_symlinks=False)
| Walk the directory tree from this directory, similar to os.walk().
|
| write_bytes(self, data)
| Open the file in bytes mode, write to it, and close the file.
|
| write_text(self, data, encoding=None, errors=None, newline=None)
| Open the file in text mode, write to it, and close the file.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| cwd()
| Return a new path pointing to the current working directory.
|
| home()
| Return a new path pointing to the user's home directory (as
| returned by os.path.expanduser('~')).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, *args, **kwargs)
| Construct a PurePath from one or several strings and or existing
| PurePath objects. The strings and path objects are combined so as
| to yield a canonicalized path, which is incorporated into the
| new PurePath object.
|
| ----------------------------------------------------------------------
| Methods inherited from PurePath:
|
| __bytes__(self)
| Return the bytes representation of the path. This is only
| recommended to use under Unix.
|
| __eq__(self, other)
| Return self==value.
|
| __fspath__(self)
|
| __ge__(self, other)
| Return self>=value.
|
| __gt__(self, other)
| Return self>value.
|
| __hash__(self)
| Return hash(self).
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __reduce__(self)
| Helper for pickle.
|
| __repr__(self)
| Return repr(self).
|
| __rtruediv__(self, key)
|
| __str__(self)
| Return the string representation of the path, suitable for
| passing to system calls.
|
| __truediv__(self, key)
|
| as_posix(self)
| Return the string representation of the path with forward (/)
| slashes.
|
| as_uri(self)
| Return the path as a 'file' URI.
|
| is_absolute(self)
| True if the path is absolute (has both a root and, if applicable,
| a drive).
|
| is_relative_to(self, other, /, *_deprecated)
| Return True if the path is relative to another path or False.
|
| is_reserved(self)
| Return True if the path contains one of the special names reserved
| by the system, if any.
|
| joinpath(self, *pathsegments)
| Combine this path with one or several arguments, and return a
| new path representing either a subpath (if all arguments are relative
| paths) or a totally different path (if one of the arguments is
| anchored).
|
| match(self, path_pattern, *, case_sensitive=None)
| Return True if this path matches the given pattern.
|
| relative_to(self, other, /, *_deprecated, walk_up=False)
| Return the relative path to another path identified by the passed
| arguments. If the operation is not possible (because this is not
| related to the other path), raise ValueError.
|
| The *walk_up* parameter controls whether `..` may be used to resolve
| the path.
|
| with_name(self, name)
| Return a new path with the file name changed.
|
| with_segments(self, *pathsegments)
| Construct a new path object from any number of path-like objects.
| Subclasses may override this method to customize how new path objects
| are created from methods like `iterdir()`.
|
| with_stem(self, stem)
| Return a new path with the stem changed.
|
| with_suffix(self, suffix)
| Return a new path with the file suffix changed. If the path
| has no suffix, add given suffix. If the given suffix is an empty
| string, remove the suffix from the path.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from PurePath:
|
| anchor
| The concatenation of the drive and root, or ''.
|
| drive
| The drive prefix (letter or UNC path), if any.
|
| name
| The final path component, if any.
|
| parent
| The logical parent of the path.
|
| parents
| A sequence of this path's logical parents.
|
| parts
| An object providing sequence-like access to the
| components in the filesystem path.
|
| root
| The root of the path, if any.
|
| stem
| The final path component, minus its last suffix.
|
| suffix
| The final component's last suffix, if any.
|
| This includes the leading period. For example: '.txt'
|
| suffixes
| A list of the final component's suffixes, if any.
|
| These include the leading periods. For example: ['.tar', '.gz']
matplotlib.RcParams
Python Library Documentation: class RcParams in module matplotlib
class RcParams(collections.abc.MutableMapping, builtins.dict)
| RcParams(*args, **kwargs)
|
| A dict-like key-value store for config parameters, including validation.
|
| Validating functions are defined and associated with rc parameters in
| :mod:`matplotlib.rcsetup`.
|
| The list of rcParams is:
|
| - _internal.classic_mode
| - agg.path.chunksize
| - animation.bitrate
| - animation.codec
| - animation.convert_args
| - animation.convert_path
| - animation.embed_limit
| - animation.ffmpeg_args
| - animation.ffmpeg_path
| - animation.frame_format
| - animation.html
| - animation.writer
| - axes.autolimit_mode
| - axes.axisbelow
| - axes.edgecolor
| - axes.facecolor
| - axes.formatter.limits
| - axes.formatter.min_exponent
| - axes.formatter.offset_threshold
| - axes.formatter.use_locale
| - axes.formatter.use_mathtext
| - axes.formatter.useoffset
| - axes.grid
| - axes.grid.axis
| - axes.grid.which
| - axes.labelcolor
| - axes.labelpad
| - axes.labelsize
| - axes.labelweight
| - axes.linewidth
| - axes.prop_cycle
| - axes.spines.bottom
| - axes.spines.left
| - axes.spines.right
| - axes.spines.top
| - axes.titlecolor
| - axes.titlelocation
| - axes.titlepad
| - axes.titlesize
| - axes.titleweight
| - axes.titley
| - axes.unicode_minus
| - axes.xmargin
| - axes.ymargin
| - axes.zmargin
| - axes3d.automargin
| - axes3d.grid
| - axes3d.xaxis.panecolor
| - axes3d.yaxis.panecolor
| - axes3d.zaxis.panecolor
| - backend
| - backend_fallback
| - boxplot.bootstrap
| - boxplot.boxprops.color
| - boxplot.boxprops.linestyle
| - boxplot.boxprops.linewidth
| - boxplot.capprops.color
| - boxplot.capprops.linestyle
| - boxplot.capprops.linewidth
| - boxplot.flierprops.color
| - boxplot.flierprops.linestyle
| - boxplot.flierprops.linewidth
| - boxplot.flierprops.marker
| - boxplot.flierprops.markeredgecolor
| - boxplot.flierprops.markeredgewidth
| - boxplot.flierprops.markerfacecolor
| - boxplot.flierprops.markersize
| - boxplot.meanline
| - boxplot.meanprops.color
| - boxplot.meanprops.linestyle
| - boxplot.meanprops.linewidth
| - boxplot.meanprops.marker
| - boxplot.meanprops.markeredgecolor
| - boxplot.meanprops.markerfacecolor
| - boxplot.meanprops.markersize
| - boxplot.medianprops.color
| - boxplot.medianprops.linestyle
| - boxplot.medianprops.linewidth
| - boxplot.notch
| - boxplot.patchartist
| - boxplot.showbox
| - boxplot.showcaps
| - boxplot.showfliers
| - boxplot.showmeans
| - boxplot.vertical
| - boxplot.whiskerprops.color
| - boxplot.whiskerprops.linestyle
| - boxplot.whiskerprops.linewidth
| - boxplot.whiskers
| - contour.algorithm
| - contour.corner_mask
| - contour.linewidth
| - contour.negative_linestyle
| - date.autoformatter.day
| - date.autoformatter.hour
| - date.autoformatter.microsecond
| - date.autoformatter.minute
| - date.autoformatter.month
| - date.autoformatter.second
| - date.autoformatter.year
| - date.converter
| - date.epoch
| - date.interval_multiples
| - docstring.hardcopy
| - errorbar.capsize
| - figure.autolayout
| - figure.constrained_layout.h_pad
| - figure.constrained_layout.hspace
| - figure.constrained_layout.use
| - figure.constrained_layout.w_pad
| - figure.constrained_layout.wspace
| - figure.dpi
| - figure.edgecolor
| - figure.facecolor
| - figure.figsize
| - figure.frameon
| - figure.hooks
| - figure.labelsize
| - figure.labelweight
| - figure.max_open_warning
| - figure.raise_window
| - figure.subplot.bottom
| - figure.subplot.hspace
| - figure.subplot.left
| - figure.subplot.right
| - figure.subplot.top
| - figure.subplot.wspace
| - figure.titlesize
| - figure.titleweight
| - font.cursive
| - font.family
| - font.fantasy
| - font.monospace
| - font.sans-serif
| - font.serif
| - font.size
| - font.stretch
| - font.style
| - font.variant
| - font.weight
| - grid.alpha
| - grid.color
| - grid.linestyle
| - grid.linewidth
| - hatch.color
| - hatch.linewidth
| - hist.bins
| - image.aspect
| - image.cmap
| - image.composite_image
| - image.interpolation
| - image.interpolation_stage
| - image.lut
| - image.origin
| - image.resample
| - interactive
| - keymap.back
| - keymap.copy
| - keymap.forward
| - keymap.fullscreen
| - keymap.grid
| - keymap.grid_minor
| - keymap.help
| - keymap.home
| - keymap.pan
| - keymap.quit
| - keymap.quit_all
| - keymap.save
| - keymap.xscale
| - keymap.yscale
| - keymap.zoom
| - legend.borderaxespad
| - legend.borderpad
| - legend.columnspacing
| - legend.edgecolor
| - legend.facecolor
| - legend.fancybox
| - legend.fontsize
| - legend.framealpha
| - legend.frameon
| - legend.handleheight
| - legend.handlelength
| - legend.handletextpad
| - legend.labelcolor
| - legend.labelspacing
| - legend.loc
| - legend.markerscale
| - legend.numpoints
| - legend.scatterpoints
| - legend.shadow
| - legend.title_fontsize
| - lines.antialiased
| - lines.color
| - lines.dash_capstyle
| - lines.dash_joinstyle
| - lines.dashdot_pattern
| - lines.dashed_pattern
| - lines.dotted_pattern
| - lines.linestyle
| - lines.linewidth
| - lines.marker
| - lines.markeredgecolor
| - lines.markeredgewidth
| - lines.markerfacecolor
| - lines.markersize
| - lines.scale_dashes
| - lines.solid_capstyle
| - lines.solid_joinstyle
| - macosx.window_mode
| - markers.fillstyle
| - mathtext.bf
| - mathtext.bfit
| - mathtext.cal
| - mathtext.default
| - mathtext.fallback
| - mathtext.fontset
| - mathtext.it
| - mathtext.rm
| - mathtext.sf
| - mathtext.tt
| - patch.antialiased
| - patch.edgecolor
| - patch.facecolor
| - patch.force_edgecolor
| - patch.linewidth
| - path.effects
| - path.simplify
| - path.simplify_threshold
| - path.sketch
| - path.snap
| - pcolor.shading
| - pcolormesh.snap
| - pdf.compression
| - pdf.fonttype
| - pdf.inheritcolor
| - pdf.use14corefonts
| - pgf.preamble
| - pgf.rcfonts
| - pgf.texsystem
| - polaraxes.grid
| - ps.distiller.res
| - ps.fonttype
| - ps.papersize
| - ps.useafm
| - ps.usedistiller
| - savefig.bbox
| - savefig.directory
| - savefig.dpi
| - savefig.edgecolor
| - savefig.facecolor
| - savefig.format
| - savefig.orientation
| - savefig.pad_inches
| - savefig.transparent
| - scatter.edgecolors
| - scatter.marker
| - svg.fonttype
| - svg.hashsalt
| - svg.image_inline
| - text.antialiased
| - text.color
| - text.hinting
| - text.hinting_factor
| - text.kerning_factor
| - text.latex.preamble
| - text.parse_math
| - text.usetex
| - timezone
| - tk.window_focus
| - toolbar
| - webagg.address
| - webagg.open_in_browser
| - webagg.port
| - webagg.port_retries
| - xaxis.labellocation
| - xtick.alignment
| - xtick.bottom
| - xtick.color
| - xtick.direction
| - xtick.labelbottom
| - xtick.labelcolor
| - xtick.labelsize
| - xtick.labeltop
| - xtick.major.bottom
| - xtick.major.pad
| - xtick.major.size
| - xtick.major.top
| - xtick.major.width
| - xtick.minor.bottom
| - xtick.minor.ndivs
| - xtick.minor.pad
| - xtick.minor.size
| - xtick.minor.top
| - xtick.minor.visible
| - xtick.minor.width
| - xtick.top
| - yaxis.labellocation
| - ytick.alignment
| - ytick.color
| - ytick.direction
| - ytick.labelcolor
| - ytick.labelleft
| - ytick.labelright
| - ytick.labelsize
| - ytick.left
| - ytick.major.left
| - ytick.major.pad
| - ytick.major.right
| - ytick.major.size
| - ytick.major.width
| - ytick.minor.left
| - ytick.minor.ndivs
| - ytick.minor.pad
| - ytick.minor.right
| - ytick.minor.size
| - ytick.minor.visible
| - ytick.minor.width
| - ytick.right
|
| 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)
| Return self[key].
|
| __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)
| Copy this RcParams instance.
|
| 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
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__delitem__'})
|
| validate = {'_internal.classic_mode': <function validate_bool>, '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=<object object at 0x00000245A78981F0>)
| 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(self, other=(), /, **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)
| 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).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __ror__(self, value, /)
| Return value|self.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
matplotlib.atexit
Python Library Documentation: built-in module atexit
NAME
atexit
DESCRIPTION
allow programmer to define multiple exit functions to be executed
upon normal program termination.
Two public functions, register and unregister, are defined.
FUNCTIONS
register(...)
register(func, *args, **kwargs) -> func
Register a function to be executed upon normal program termination
func - function to be called at exit
args - optional arguments to pass to func
kwargs - optional keyword arguments to pass to func
func is returned to facilitate usage as a decorator.
unregister(...)
unregister(func) -> None
Unregister an exit function which was previously registered using
atexit.register
func - function to be unregistered
FILE
(built-in)
matplotlib.backends
Python Library Documentation: package matplotlib.backends in matplotlib
NAME
matplotlib.backends
PACKAGE CONTENTS
_backend_agg
_backend_gtk
_backend_pdf_ps
_backend_tk
_tkagg
backend_agg
backend_cairo
backend_gtk3
backend_gtk3agg
backend_gtk3cairo
backend_gtk4
backend_gtk4agg
backend_gtk4cairo
backend_macosx
backend_mixed
backend_nbagg
backend_pdf
backend_pgf
backend_ps
backend_qt
backend_qt5
backend_qt5agg
backend_qt5cairo
backend_qtagg
backend_qtcairo
backend_svg
backend_template
backend_tkagg
backend_tkcairo
backend_webagg
backend_webagg_core
backend_wx
backend_wxagg
backend_wxcairo
qt_compat
qt_editor (package)
registry
DATA
backend_registry = <matplotlib.backends.registry.BackendRegistry objec...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\backends\__init__.py
matplotlib.bezier
Python Library Documentation: module matplotlib.bezier in matplotlib
NAME
matplotlib.bezier - A module providing some utility functions regarding Bézier path manipulation.
CLASSES
builtins.ValueError(builtins.Exception)
NonIntersectingPathException
builtins.object
BezierSegment
class BezierSegment(builtins.object)
| BezierSegment(control_points)
|
| A d-dimensional Bézier segment.
|
| Parameters
| ----------
| control_points : (N, d) array
| Location of the *N* control points.
|
| Methods defined here:
|
| __call__(self, t)
| Evaluate the Bézier curve at point(s) *t* in [0, 1].
|
| Parameters
| ----------
| t : (k,) array-like
| Points at which to evaluate the curve.
|
| Returns
| -------
| (k, d) array
| Value of the curve for each point in *t*.
|
| __init__(self, control_points)
| Initialize self. See help(type(self)) for accurate signature.
|
| axis_aligned_extrema(self)
| Return the dimension and location of the curve's interior extrema.
|
| The extrema are the points along the curve where one of its partial
| derivatives is zero.
|
| Returns
| -------
| dims : array of int
| Index :math:`i` of the partial derivative which is zero at each
| interior extrema.
| dzeros : array of float
| Of same size as dims. The :math:`t` such that :math:`d/dx_i B(t) =
| 0`
|
| point_at_t(self, t)
| Evaluate the curve at a single point, returning a tuple of *d* floats.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| control_points
| The control points of the curve.
|
| degree
| Degree of the polynomial. One less the number of control points.
|
| dimension
| The dimension of the curve.
|
| polynomial_coefficients
| The polynomial coefficients of the Bézier curve.
|
| .. warning:: Follows opposite convention from `numpy.polyval`.
|
| Returns
| -------
| (n+1, d) array
| Coefficients after expanding in polynomial basis, where :math:`n`
| is the degree of the Bézier curve and :math:`d` its dimension.
| These are the numbers (:math:`C_j`) such that the curve can be
| written :math:`\sum_{j=0}^n C_j t^j`.
|
| Notes
| -----
| The coefficients are calculated as
|
| .. math::
|
| {n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i
|
| where :math:`P_i` are the control points of the curve.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class NonIntersectingPathException(builtins.ValueError)
| Method resolution order:
| NonIntersectingPathException
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.ValueError:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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
FUNCTIONS
check_if_parallel(dx1, dy1, dx2, dy2, tolerance=1e-05)
Check if two lines are parallel.
Parameters
----------
dx1, dy1, dx2, dy2 : float
The gradients *dy*/*dx* of the two lines.
tolerance : float
The angular tolerance in radians up to which the lines are considered
parallel.
Returns
-------
is_parallel
- 1 if two lines are parallel in same direction.
- -1 if two lines are parallel in opposite direction.
- False otherwise.
find_bezier_t_intersecting_with_closedpath(bezier_point_at_t, inside_closedpath, t0=0.0, t1=1.0, tolerance=0.01)
Find the intersection of the Bézier curve with a closed path.
The intersection point *t* is approximated by two parameters *t0*, *t1*
such that *t0* <= *t* <= *t1*.
Search starts from *t0* and *t1* and uses a simple bisecting algorithm
therefore one of the end points must be inside the path while the other
doesn't. The search stops when the distance of the points parametrized by
*t0* and *t1* gets smaller than the given *tolerance*.
Parameters
----------
bezier_point_at_t : callable
A function returning x, y coordinates of the Bézier at parameter *t*.
It must have the signature::
bezier_point_at_t(t: float) -> tuple[float, float]
inside_closedpath : callable
A function returning True if a given point (x, y) is inside the
closed path. It must have the signature::
inside_closedpath(point: tuple[float, float]) -> bool
t0, t1 : float
Start parameters for the search.
tolerance : float
Maximal allowed distance between the final points.
Returns
-------
t0, t1 : float
The Bézier path parameters.
find_control_points(c1x, c1y, mmx, mmy, c2x, c2y)
Find control points of the Bézier curve passing through (*c1x*, *c1y*),
(*mmx*, *mmy*), and (*c2x*, *c2y*), at parametric values 0, 0.5, and 1.
get_cos_sin(x0, y0, x1, y1)
get_intersection(cx1, cy1, cos_t1, sin_t1, cx2, cy2, cos_t2, sin_t2)
Return the intersection between the line through (*cx1*, *cy1*) at angle
*t1* and the line through (*cx2*, *cy2*) at angle *t2*.
get_normal_points(cx, cy, cos_t, sin_t, length)
For a line passing through (*cx*, *cy*) and having an angle *t*, return
locations of the two points located along its perpendicular line at the
distance of *length*.
get_parallels(bezier2, width)
Given the quadratic Bézier control points *bezier2*, returns
control points of quadratic Bézier lines roughly parallel to given
one separated by *width*.
inside_circle(cx, cy, r)
Return a function that checks whether a point is in a circle with center
(*cx*, *cy*) and radius *r*.
The returned function has the signature::
f(xy: tuple[float, float]) -> bool
make_wedged_bezier2(bezier2, width, w1=1.0, wm=0.5, w2=0.0)
Being similar to `get_parallels`, returns control points of two quadratic
Bézier lines having a width roughly parallel to given one separated by
*width*.
split_bezier_intersecting_with_closedpath(bezier, inside_closedpath, tolerance=0.01)
Split a Bézier curve into two at the intersection with a closed path.
Parameters
----------
bezier : (N, 2) array-like
Control points of the Bézier segment. See `.BezierSegment`.
inside_closedpath : callable
A function returning True if a given point (x, y) is inside the
closed path. See also `.find_bezier_t_intersecting_with_closedpath`.
tolerance : float
The tolerance for the intersection. See also
`.find_bezier_t_intersecting_with_closedpath`.
Returns
-------
left, right
Lists of control points for the two Bézier segments.
split_de_casteljau(beta, t)
Split a Bézier segment defined by its control points *beta* into two
separate segments divided at *t* and return their control points.
split_path_inout(path, inside, tolerance=0.01, reorder_inout=False)
Divide a path into two segments at the point where ``inside(x, y)`` becomes
False.
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\bezier.py
matplotlib.cbook
Python Library Documentation: module matplotlib.cbook in matplotlib
NAME
matplotlib.cbook
DESCRIPTION
A collection of utility functions and classes. Originally, many
(but not all) were from the Python Cookbook -- hence the name cbook.
CLASSES
builtins.list(builtins.object)
silent_list
builtins.object
CallbackRegistry
Grouper
GrouperView
Stack
class CallbackRegistry(builtins.object)
| CallbackRegistry(exception_handler=<function _exception_printer at 0x00000245A8664FE0>, *, signals=None)
|
| Handle registering, processing, blocking, and disconnecting
| for a set of signals and callbacks:
|
| >>> def oneat(x):
| ... print('eat', x)
| >>> def ondrink(x):
| ... print('drink', x)
|
| >>> from matplotlib.cbook import CallbackRegistry
| >>> callbacks = CallbackRegistry()
|
| >>> id_eat = callbacks.connect('eat', oneat)
| >>> id_drink = callbacks.connect('drink', ondrink)
|
| >>> callbacks.process('drink', 123)
| drink 123
| >>> callbacks.process('eat', 456)
| eat 456
| >>> callbacks.process('be merry', 456) # nothing will be called
|
| >>> callbacks.disconnect(id_eat)
| >>> callbacks.process('eat', 456) # nothing will be called
|
| >>> with callbacks.blocked(signal='drink'):
| ... callbacks.process('drink', 123) # nothing will be called
| >>> callbacks.process('drink', 123)
| drink 123
|
| In practice, one should always disconnect all callbacks when they are
| no longer needed to avoid dangling references (and thus memory leaks).
| However, real code in Matplotlib rarely does so, and due to its design,
| it is rather difficult to place this kind of code. To get around this,
| and prevent this class of memory leaks, we instead store weak references
| to bound methods only, so when the destination object needs to die, the
| CallbackRegistry won't keep it alive.
|
| Parameters
| ----------
| exception_handler : callable, optional
| If not None, *exception_handler* must be a function that takes an
| `Exception` as single parameter. It gets called with any `Exception`
| raised by the callbacks during `CallbackRegistry.process`, and may
| either re-raise the exception or handle it in another manner.
|
| The default handler prints the exception (with `traceback.print_exc`) if
| an interactive event loop is running; it re-raises the exception if no
| interactive event loop is running.
|
| signals : list, optional
| If not None, *signals* is a list of signals that this registry handles:
| attempting to `process` or to `connect` to a signal not in the list
| throws a `ValueError`. The default, None, does not restrict the
| handled signals.
|
| Methods defined here:
|
| __getstate__(self)
| Helper for pickle.
|
| __init__(self, exception_handler=<function _exception_printer at 0x00000245A8664FE0>, *, signals=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __setstate__(self, state)
|
| blocked(self, *, signal=None)
| Block callback signals from being processed.
|
| A context manager to temporarily block/disable callback signals
| from being processed by the registered listeners.
|
| Parameters
| ----------
| signal : str, optional
| The callback signal to block. The default is to block all signals.
|
| connect(self, signal, func)
| Register *func* to be called when signal *signal* is generated.
|
| disconnect(self, cid)
| Disconnect the callback registered with callback id *cid*.
|
| No error is raised if such a callback does not exist.
|
| process(self, s, *args, **kwargs)
| Process signal *s*.
|
| All of the functions registered to receive callbacks on *s* will be
| called with ``*args`` and ``**kwargs``.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Grouper(builtins.object)
| Grouper(init=())
|
| A disjoint-set data structure.
|
| Objects can be joined using :meth:`join`, tested for connectedness
| using :meth:`joined`, and all disjoint sets can be retrieved by
| using the object as an iterator.
|
| The objects being joined must be hashable and weak-referenceable.
|
| Examples
| --------
| >>> from matplotlib.cbook import Grouper
| >>> class Foo:
| ... def __init__(self, s):
| ... self.s = s
| ... def __repr__(self):
| ... return self.s
| ...
| >>> a, b, c, d, e, f = [Foo(x) for x in 'abcdef']
| >>> grp = Grouper()
| >>> grp.join(a, b)
| >>> grp.join(b, c)
| >>> grp.join(d, e)
| >>> list(grp)
| [[a, b, c], [d, e]]
| >>> grp.joined(a, b)
| True
| >>> grp.joined(a, c)
| True
| >>> grp.joined(a, d)
| False
|
| Methods defined here:
|
| __contains__(self, item)
|
| __getstate__(self)
| Helper for pickle.
|
| __init__(self, init=())
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self)
| Iterate over each of the disjoint sets as a list.
|
| The iterator is invalid if interleaved with calls to join().
|
| __setstate__(self, state)
|
| clean(self)
| [*Deprecated*] Clean dead weak references from the dictionary.
|
| Notes
| -----
| .. deprecated:: 3.8
| Use none, you no longer need to clean a Grouper instead.
|
| get_siblings(self, a)
| Return all of the items joined with *a*, including itself.
|
| join(self, a, *args)
| Join given arguments into the same set. Accepts one or more arguments.
|
| joined(self, a, b)
| Return whether *a* and *b* are members of the same set.
|
| remove(self, a)
| Remove *a* from the grouper, doing nothing if it is not there.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class GrouperView(builtins.object)
| GrouperView(grouper)
|
| Immutable view over a `.Grouper`.
|
| Methods defined here:
|
| __contains__(self, item)
|
| __init__(self, grouper)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self)
|
| get_siblings(self, a)
|
| joined(self, a, b)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Stack(builtins.object)
| Stack(default=None)
|
| [*Deprecated*] Stack of elements with a movable cursor.
|
| Mimics home/back/forward in a web browser.
|
| Notes
| -----
| .. deprecated:: 3.8
|
| Methods defined here:
|
| __call__(self)
| Return the current element, or None.
|
| __getitem__(self, ind)
|
| __init__(self, default=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __len__(self)
|
| back(self)
| Move the position back and return the current element.
|
| bubble(self, o)
| Raise all references of *o* to the top of the stack, and return it.
|
| Raises
| ------
| ValueError
| If *o* is not in the stack.
|
| clear(self)
| Empty the stack.
|
| empty(self)
| Return whether the stack is empty.
|
| forward(self)
| Move the position forward and return the current element.
|
| home(self)
| Push the first element onto the top of the stack.
|
| The first element is returned.
|
| push(self, o)
| Push *o* to the stack at current position. Discard all later elements.
|
| *o* is returned.
|
| remove(self, o)
| Remove *o* from the stack.
|
| Raises
| ------
| ValueError
| If *o* is not in the stack.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class silent_list(builtins.list)
| silent_list(type, seq=None)
|
| A list with a short ``repr()``.
|
| This is meant to be used for a homogeneous list of artists, so that they
| don't cause long, meaningless output.
|
| Instead of ::
|
| [<matplotlib.lines.Line2D object at 0x7f5749fed3c8>,
| <matplotlib.lines.Line2D object at 0x7f5749fed4e0>,
| <matplotlib.lines.Line2D object at 0x7f5758016550>]
|
| one will get ::
|
| <a list of 3 Line2D objects>
|
| If ``self.type`` is None, the type name is obtained from the first item in
| the list (if any).
|
| Method resolution order:
| silent_list
| builtins.list
| builtins.object
|
| Methods defined here:
|
| __init__(self, type, seq=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.list:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, index, /)
| Return self[index].
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reversed__(self, /)
| Return a reverse iterator over the list.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(self, /)
| Return the size of the list in memory, in bytes.
|
| append(self, object, /)
| Append object to the end of the list.
|
| clear(self, /)
| Remove all items from list.
|
| copy(self, /)
| Return a shallow copy of the list.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| extend(self, iterable, /)
| Extend list by appending elements from the iterable.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| insert(self, index, object, /)
| Insert object before index.
|
| pop(self, index=-1, /)
| Remove and return item at index (default last).
|
| Raises IndexError if list is empty or index is out of range.
|
| remove(self, value, /)
| Remove first occurrence of value.
|
| Raises ValueError if the value is not present.
|
| reverse(self, /)
| Reverse *IN PLACE*.
|
| sort(self, /, *, key=None, reverse=False)
| Sort the list in ascending order and return None.
|
| The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
| order of two equal elements is maintained).
|
| If a key function is given, apply it once to each list item and sort them,
| ascending or descending, according to their function values.
|
| The reverse flag can be set to sort in descending order.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.list:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.list:
|
| __new__(*args, **kwargs) class method of builtins.list
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.list:
|
| __hash__ = None
FUNCTIONS
boxplot_stats(X, whis=1.5, bootstrap=None, labels=None, autorange=False)
Return a list of dictionaries of statistics used to draw a series of box
and whisker plots using `~.Axes.bxp`.
Parameters
----------
X : array-like
Data that will be represented in the boxplots. Should have 2 or
fewer dimensions.
whis : float or (float, float), default: 1.5
The position of the whiskers.
If a float, the lower whisker is at the lowest datum above
``Q1 - whis*(Q3-Q1)``, and the upper whisker at the highest datum below
``Q3 + whis*(Q3-Q1)``, where Q1 and Q3 are the first and third
quartiles. The default value of ``whis = 1.5`` corresponds to Tukey's
original definition of boxplots.
If a pair of floats, they indicate the percentiles at which to draw the
whiskers (e.g., (5, 95)). In particular, setting this to (0, 100)
results in whiskers covering the whole range of the data.
In the edge case where ``Q1 == Q3``, *whis* is automatically set to
(0, 100) (cover the whole range of the data) if *autorange* is True.
Beyond the whiskers, data are considered outliers and are plotted as
individual points.
bootstrap : int, optional
Number of times the confidence intervals around the median
should be bootstrapped (percentile method).
labels : list of str, optional
Labels for each dataset. Length must be compatible with
dimensions of *X*.
autorange : bool, optional (False)
When `True` and the data are distributed such that the 25th and 75th
percentiles are equal, ``whis`` is set to (0, 100) such that the
whisker ends are at the minimum and maximum of the data.
Returns
-------
list of dict
A list of dictionaries containing the results for each column
of data. Keys of each dictionary are the following:
======== ===================================
Key Value Description
======== ===================================
label tick label for the boxplot
mean arithmetic mean value
med 50th percentile
q1 first quartile (25th percentile)
q3 third quartile (75th percentile)
iqr interquartile range
cilo lower notch around the median
cihi upper notch around the median
whislo end of the lower whisker
whishi end of the upper whisker
fliers outliers
======== ===================================
Notes
-----
Non-bootstrapping approach to confidence interval uses Gaussian-based
asymptotic approximation:
.. math::
\mathrm{med} \pm 1.57 \times \frac{\mathrm{iqr}}{\sqrt{N}}
General approach from:
McGill, R., Tukey, J.W., and Larsen, W.A. (1978) "Variations of
Boxplots", The American Statistician, 32:12-16.
contiguous_regions(mask)
Return a list of (ind0, ind1) such that ``mask[ind0:ind1].all()`` is
True and we cover all such regions.
delete_masked_points(*args)
Find all masked and/or non-finite points in a set of arguments,
and return the arguments with only the unmasked points remaining.
Arguments can be in any of 5 categories:
1) 1-D masked arrays
2) 1-D ndarrays
3) ndarrays with more than one dimension
4) other non-string iterables
5) anything else
The first argument must be in one of the first four categories;
any argument with a length differing from that of the first
argument (and hence anything in category 5) then will be
passed through unchanged.
Masks are obtained from all arguments of the correct length
in categories 1, 2, and 4; a point is bad if masked in a masked
array or if it is a nan or inf. No attempt is made to
extract a mask from categories 2, 3, and 4 if `numpy.isfinite`
does not yield a Boolean array.
All input arguments that are not passed unchanged are returned
as ndarrays after removing the points or rows corresponding to
masks in any of the arguments.
A vastly simpler version of this function was originally
written as a helper for Axes.scatter().
file_requires_unicode(x)
Return whether the given writable file-like object requires Unicode to be
written to it.
flatten(seq, scalarp=<function is_scalar_or_string at 0x00000245B0178400>)
Return a generator of flattened nested containers.
For example:
>>> from matplotlib.cbook import flatten
>>> l = (('John', ['Hunter']), (1, 23), [[([42, (5, 23)], )]])
>>> print(list(flatten(l)))
['John', 'Hunter', 1, 23, 42, 5, 23]
By: Composite of Holger Krekel and Luther Blissett
From: https://code.activestate.com/recipes/121294/
and Recipe 1.12 in cookbook
get_sample_data(fname, asfileobj=True, *, np_load=<deprecated parameter>)
Return a sample data file. *fname* is a path relative to the
:file:`mpl-data/sample_data` directory. If *asfileobj* is `True`
return a file object, otherwise just a file path.
Sample data files are stored in the 'mpl-data/sample_data' directory within
the Matplotlib package.
If the filename ends in .gz, the file is implicitly ungzipped. If the
filename ends with .npy or .npz, and *asfileobj* is `True`, the file is
loaded with `numpy.load`.
index_of(y)
A helper function to create reasonable x values for the given *y*.
This is used for plotting (x, y) if x values are not explicitly given.
First try ``y.index`` (assuming *y* is a `pandas.Series`), if that
fails, use ``range(len(y))``.
This will be extended in the future to deal with more types of
labeled data.
Parameters
----------
y : float or array-like
Returns
-------
x, y : ndarray
The x and y values to plot.
is_math_text(s)
Return whether the string *s* contains math expressions.
This is done by checking whether *s* contains an even number of
non-escaped dollar signs.
is_scalar_or_string(val)
Return whether the given object is a scalar or string like.
is_writable_file_like(obj)
Return whether *obj* looks like a file object with a *write* method.
normalize_kwargs(kw, alias_mapping=None)
Helper function to normalize kwarg inputs.
Parameters
----------
kw : dict or None
A dict of keyword arguments. None is explicitly supported and treated
as an empty dict, to support functions with an optional parameter of
the form ``props=None``.
alias_mapping : dict or Artist subclass or Artist instance, optional
A mapping between a canonical name to a list of aliases, in order of
precedence from lowest to highest.
If the canonical value is not in the list it is assumed to have the
highest priority.
If an Artist subclass or instance is passed, use its properties alias
mapping.
Raises
------
TypeError
To match what Python raises if invalid arguments/keyword arguments are
passed to a callable.
open_file_cm(path_or_file, mode='r', encoding=None)
Pass through file objects and context-manage path-likes.
print_cycles(objects, outstream=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1252'>, show_progress=False)
Print loops of cyclic references in the given *objects*.
It is often useful to pass in ``gc.garbage`` to find the cycles that are
preventing some objects from being garbage collected.
Parameters
----------
objects
A list of objects to find cycles in.
outstream
The stream for output.
show_progress : bool
If True, print the number of objects reached as they are found.
pts_to_midstep(x, *args)
Convert continuous line to mid-steps.
Given a set of ``N`` points convert to ``2N`` points which when connected
linearly give a step function which changes values at the middle of the
intervals.
Parameters
----------
x : array
The x location of the steps. May be empty.
y1, ..., yp : array
y arrays to be turned into steps; all must be the same length as
``x``.
Returns
-------
array
The x and y values converted to steps in the same order as the input;
can be unpacked as ``x_out, y1_out, ..., yp_out``. If the input is
length ``N``, each of these arrays will be length ``2N``.
Examples
--------
>>> x_s, y1_s, y2_s = pts_to_midstep(x, y1, y2)
pts_to_poststep(x, *args)
Convert continuous line to post-steps.
Given a set of ``N`` points convert to ``2N + 1`` points, which when
connected linearly give a step function which changes values at the end of
the intervals.
Parameters
----------
x : array
The x location of the steps. May be empty.
y1, ..., yp : array
y arrays to be turned into steps; all must be the same length as ``x``.
Returns
-------
array
The x and y values converted to steps in the same order as the input;
can be unpacked as ``x_out, y1_out, ..., yp_out``. If the input is
length ``N``, each of these arrays will be length ``2N + 1``. For
``N=0``, the length will be 0.
Examples
--------
>>> x_s, y1_s, y2_s = pts_to_poststep(x, y1, y2)
pts_to_prestep(x, *args)
Convert continuous line to pre-steps.
Given a set of ``N`` points, convert to ``2N - 1`` points, which when
connected linearly give a step function which changes values at the
beginning of the intervals.
Parameters
----------
x : array
The x location of the steps. May be empty.
y1, ..., yp : array
y arrays to be turned into steps; all must be the same length as ``x``.
Returns
-------
array
The x and y values converted to steps in the same order as the input;
can be unpacked as ``x_out, y1_out, ..., yp_out``. If the input is
length ``N``, each of these arrays will be length ``2N + 1``. For
``N=0``, the length will be 0.
Examples
--------
>>> x_s, y1_s, y2_s = pts_to_prestep(x, y1, y2)
safe_first_element(obj)
Return the first element in *obj*.
This is a type-independent way of obtaining the first element,
supporting both index access and the iterator protocol.
safe_masked_invalid(x, copy=False)
sanitize_sequence(data)
Convert dictview objects to list. Other inputs are returned unchanged.
simple_linear_interpolation(a, steps)
Resample an array with ``steps - 1`` points between original point pairs.
Along each column of *a*, ``(steps - 1)`` points are introduced between
each original values; the values are linearly interpolated.
Parameters
----------
a : array, shape (n, ...)
steps : int
Returns
-------
array
shape ``((n - 1) * steps + 1, ...)``
strip_math(s)
Remove latex formatting from mathtext.
Only handles fully math and fully non-math strings.
to_filehandle(fname, flag='r', return_opened=False, encoding=None)
Convert a path to an open file handle or pass-through a file-like object.
Consider using `open_file_cm` instead, as it allows one to properly close
newly created file objects more easily.
Parameters
----------
fname : str or path-like or file-like
If `str` or `os.PathLike`, the file is opened using the flags specified
by *flag* and *encoding*. If a file-like object, it is passed through.
flag : str, default: 'r'
Passed as the *mode* argument to `open` when *fname* is `str` or
`os.PathLike`; ignored if *fname* is file-like.
return_opened : bool, default: False
If True, return both the file object and a boolean indicating whether
this was a new file (that the caller needs to close). If False, return
only the new file.
encoding : str or None, default: None
Passed as the *mode* argument to `open` when *fname* is `str` or
`os.PathLike`; ignored if *fname* is file-like.
Returns
-------
fh : file-like
opened : bool
*opened* is only returned if *return_opened* is True.
violin_stats(X, method, points=100, quantiles=None)
Return a list of dictionaries of data which can be used to draw a series
of violin plots.
See the ``Returns`` section below to view the required keys of the
dictionary.
Users can skip this function and pass a user-defined set of dictionaries
with the same keys to `~.axes.Axes.violinplot` instead of using Matplotlib
to do the calculations. See the *Returns* section below for the keys
that must be present in the dictionaries.
Parameters
----------
X : array-like
Sample data that will be used to produce the gaussian kernel density
estimates. Must have 2 or fewer dimensions.
method : callable
The method used to calculate the kernel density estimate for each
column of data. When called via ``method(v, coords)``, it should
return a vector of the values of the KDE evaluated at the values
specified in coords.
points : int, default: 100
Defines the number of points to evaluate each of the gaussian kernel
density estimates at.
quantiles : array-like, default: None
Defines (if not None) a list of floats in interval [0, 1] for each
column of data, which represents the quantiles that will be rendered
for that column of data. Must have 2 or fewer dimensions. 1D array will
be treated as a singleton list containing them.
Returns
-------
list of dict
A list of dictionaries containing the results for each column of data.
The dictionaries contain at least the following:
- coords: A list of scalars containing the coordinates this particular
kernel density estimate was evaluated at.
- vals: A list of scalars containing the values of the kernel density
estimate at each of the coordinates given in *coords*.
- mean: The mean value for this column of data.
- median: The median value for this column of data.
- min: The minimum value for this column of data.
- max: The maximum value for this column of data.
- quantiles: The quantile values for this column of data.
DATA
STEP_LOOKUP_MAP = {'default': <function <lambda>>, 'steps': <function ...
ls_mapper = {'-': 'solid', '--': 'dashed', '-.': 'dashdot', ':': 'dott...
ls_mapper_r = {'dashdot': '-.', 'dashed': '--', 'dotted': ':', 'solid'...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\cbook.py
matplotlib.cm
Python Library Documentation: module matplotlib.cm in matplotlib
NAME
matplotlib.cm - Builtin colormaps, colormap handling utilities, and the `ScalarMappable` mixin.
DESCRIPTION
.. seealso::
:doc:`/gallery/color/colormap_reference` for a list of builtin colormaps.
:ref:`colormap-manipulation` for examples of how to make
colormaps.
:ref:`colormaps` an in-depth discussion of choosing
colormaps.
:ref:`colormapnorms` for more details about data normalization.
CLASSES
builtins.object
ScalarMappable
collections.abc.Mapping(collections.abc.Collection)
ColormapRegistry
class ColormapRegistry(collections.abc.Mapping)
| ColormapRegistry(cmaps)
|
| Container for colormaps that are known to Matplotlib by name.
|
| The universal registry instance is `matplotlib.colormaps`. There should be
| no need for users to instantiate `.ColormapRegistry` themselves.
|
| Read access uses a dict-like interface mapping names to `.Colormap`\s::
|
| import matplotlib as mpl
| cmap = mpl.colormaps['viridis']
|
| Returned `.Colormap`\s are copies, so that their modification does not
| change the global definition of the colormap.
|
| Additional colormaps can be added via `.ColormapRegistry.register`::
|
| mpl.colormaps.register(my_colormap)
|
| To get a list of all registered colormaps, you can do::
|
| from matplotlib import colormaps
| list(colormaps)
|
| Method resolution order:
| ColormapRegistry
| collections.abc.Mapping
| collections.abc.Collection
| collections.abc.Sized
| collections.abc.Iterable
| collections.abc.Container
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return a list of the registered colormap names.
|
| This exists only for backward-compatibility in `.pyplot` which had a
| ``plt.colormaps()`` method. The recommended way to get this list is
| now ``list(colormaps)``.
|
| __getitem__(self, item)
|
| __init__(self, cmaps)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self)
|
| __len__(self)
|
| __str__(self)
| Return str(self).
|
| get_cmap(self, cmap)
| Return a color map specified through *cmap*.
|
| Parameters
| ----------
| cmap : str or `~matplotlib.colors.Colormap` or None
|
| - if a `.Colormap`, return it
| - if a string, look it up in ``mpl.colormaps``
| - if None, return the Colormap defined in :rc:`image.cmap`
|
| Returns
| -------
| Colormap
|
| register(self, cmap, *, name=None, force=False)
| Register a new colormap.
|
| The colormap name can then be used as a string argument to any ``cmap``
| parameter in Matplotlib. It is also available in ``pyplot.get_cmap``.
|
| The colormap registry stores a copy of the given colormap, so that
| future changes to the original colormap instance do not affect the
| registered colormap. Think of this as the registry taking a snapshot
| of the colormap at registration.
|
| Parameters
| ----------
| cmap : matplotlib.colors.Colormap
| The colormap to register.
|
| name : str, optional
| The name for the colormap. If not given, ``cmap.name`` is used.
|
| force : bool, default: False
| If False, a ValueError is raised if trying to overwrite an already
| registered name. True supports overwriting registered colormaps
| other than the builtin colormaps.
|
| unregister(self, name)
| Remove a colormap from the registry.
|
| You cannot remove built-in colormaps.
|
| If the named colormap is not registered, returns with no error, raises
| if you try to de-register a default colormap.
|
| .. warning::
|
| Colormap names are currently a shared namespace that may be used
| by multiple packages. Use `unregister` only if you know you
| have registered that name before. In particular, do not
| unregister just in case to clean the name before registering a
| new colormap.
|
| Parameters
| ----------
| name : str
| The name of the colormap to be removed.
|
| Raises
| ------
| ValueError
| If you try to remove a default built-in colormap.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| 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)
| 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).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
class ScalarMappable(builtins.object)
| ScalarMappable(norm=None, cmap=None)
|
| A mixin class to map scalar data to RGBA.
|
| The ScalarMappable applies data normalization before returning RGBA colors
| from the given colormap.
|
| Methods defined here:
|
| __init__(self, norm=None, cmap=None)
| Parameters
| ----------
| norm : `.Normalize` (or subclass thereof) or str or None
| The normalizing object which scales data, typically into the
| interval ``[0, 1]``.
| If a `str`, a `.Normalize` subclass is dynamically generated based
| on the scale with the corresponding name.
| If *None*, *norm* defaults to a *colors.Normalize* object which
| initializes its scaling based on the first data processed.
| cmap : str or `~matplotlib.colors.Colormap`
| The colormap used to map normalized data values to RGBA colors.
|
| autoscale(self)
| Autoscale the scalar limits on the norm instance using the
| current array
|
| autoscale_None(self)
| Autoscale the scalar limits on the norm instance using the
| current array, changing only limits that are None
|
| changed(self)
| Call this whenever the mappable is changed to notify all the
| callbackSM listeners to the 'changed' signal.
|
| get_alpha(self)
| Returns
| -------
| float
| Always returns 1.
|
| get_array(self)
| Return the array of values, that are mapped to colors.
|
| The base class `.ScalarMappable` does not make any assumptions on
| the dimensionality and shape of the array.
|
| get_clim(self)
| Return the values (min, max) that are mapped to the colormap limits.
|
| get_cmap(self)
| Return the `.Colormap` instance.
|
| set_array(self, A)
| Set the value array from array-like *A*.
|
| Parameters
| ----------
| A : array-like or None
| The values that are mapped to colors.
|
| The base class `.ScalarMappable` does not make any assumptions on
| the dimensionality and shape of the value array *A*.
|
| set_clim(self, vmin=None, vmax=None)
| Set the norm limits for image scaling.
|
| Parameters
| ----------
| vmin, vmax : float
| The limits.
|
| The limits may also be passed as a tuple (*vmin*, *vmax*) as a
| single positional argument.
|
| .. ACCEPTS: (vmin: float, vmax: float)
|
| set_cmap(self, cmap)
| Set the colormap for luminance data.
|
| Parameters
| ----------
| cmap : `.Colormap` or str or None
|
| set_norm(self, norm)
| Set the normalization instance.
|
| Parameters
| ----------
| norm : `.Normalize` or str or None
|
| Notes
| -----
| If there are any colorbars using the mappable for this norm, setting
| the norm of the mappable will reset the norm, locator, and formatters
| on the colorbar to default.
|
| to_rgba(self, x, alpha=None, bytes=False, norm=True)
| Return a normalized RGBA array corresponding to *x*.
|
| In the normal case, *x* is a 1D or 2D sequence of scalars, and
| the corresponding `~numpy.ndarray` of RGBA values will be returned,
| based on the norm and colormap set for this ScalarMappable.
|
| There is one special case, for handling images that are already
| RGB or RGBA, such as might have been read from an image file.
| If *x* is an `~numpy.ndarray` with 3 dimensions,
| and the last dimension is either 3 or 4, then it will be
| treated as an RGB or RGBA array, and no mapping will be done.
| The array can be `~numpy.uint8`, or it can be floats with
| values in the 0-1 range; otherwise a ValueError will be raised.
| Any NaNs or masked elements will be set to 0 alpha.
| If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
| will be used to fill in the transparency. If the last dimension
| is 4, the *alpha* kwarg is ignored; it does not
| replace the preexisting alpha. A ValueError will be raised
| if the third dimension is other than 3 or 4.
|
| In either case, if *bytes* is *False* (default), the RGBA
| array will be floats in the 0-1 range; if it is *True*,
| the returned RGBA array will be `~numpy.uint8` in the 0 to 255 range.
|
| If norm is False, no normalization of the input data is
| performed, and it is assumed to be in the range (0-1).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| norm
FUNCTIONS
get_cmap(name=None, lut=None)
[*Deprecated*] Get a colormap instance, defaulting to rc values if *name* is None.
Parameters
----------
name : `~matplotlib.colors.Colormap` or str or None, default: None
If a `.Colormap` instance, it will be returned. Otherwise, the name of
a colormap known to Matplotlib, which will be resampled by *lut*. The
default, None, means :rc:`image.cmap`.
lut : int or None, default: None
If *name* is not already a Colormap instance and *lut* is not None, the
colormap will be resampled to have *lut* entries in the lookup table.
Returns
-------
Colormap
Notes
-----
.. deprecated:: 3.7
Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.
DATA
Accent = <matplotlib.colors.ListedColormap object>
Accent_r = <matplotlib.colors.ListedColormap object>
Blues = <matplotlib.colors.LinearSegmentedColormap object>
Blues_r = <matplotlib.colors.LinearSegmentedColormap object>
BrBG = <matplotlib.colors.LinearSegmentedColormap object>
BrBG_r = <matplotlib.colors.LinearSegmentedColormap object>
BuGn = <matplotlib.colors.LinearSegmentedColormap object>
BuGn_r = <matplotlib.colors.LinearSegmentedColormap object>
BuPu = <matplotlib.colors.LinearSegmentedColormap object>
BuPu_r = <matplotlib.colors.LinearSegmentedColormap object>
CMRmap = <matplotlib.colors.LinearSegmentedColormap object>
CMRmap_r = <matplotlib.colors.LinearSegmentedColormap object>
Dark2 = <matplotlib.colors.ListedColormap object>
Dark2_r = <matplotlib.colors.ListedColormap object>
GnBu = <matplotlib.colors.LinearSegmentedColormap object>
GnBu_r = <matplotlib.colors.LinearSegmentedColormap object>
Grays = <matplotlib.colors.LinearSegmentedColormap object>
Greens = <matplotlib.colors.LinearSegmentedColormap object>
Greens_r = <matplotlib.colors.LinearSegmentedColormap object>
Greys = <matplotlib.colors.LinearSegmentedColormap object>
Greys_r = <matplotlib.colors.LinearSegmentedColormap object>
OrRd = <matplotlib.colors.LinearSegmentedColormap object>
OrRd_r = <matplotlib.colors.LinearSegmentedColormap object>
Oranges = <matplotlib.colors.LinearSegmentedColormap object>
Oranges_r = <matplotlib.colors.LinearSegmentedColormap object>
PRGn = <matplotlib.colors.LinearSegmentedColormap object>
PRGn_r = <matplotlib.colors.LinearSegmentedColormap object>
Paired = <matplotlib.colors.ListedColormap object>
Paired_r = <matplotlib.colors.ListedColormap object>
Pastel1 = <matplotlib.colors.ListedColormap object>
Pastel1_r = <matplotlib.colors.ListedColormap object>
Pastel2 = <matplotlib.colors.ListedColormap object>
Pastel2_r = <matplotlib.colors.ListedColormap object>
PiYG = <matplotlib.colors.LinearSegmentedColormap object>
PiYG_r = <matplotlib.colors.LinearSegmentedColormap object>
PuBu = <matplotlib.colors.LinearSegmentedColormap object>
PuBuGn = <matplotlib.colors.LinearSegmentedColormap object>
PuBuGn_r = <matplotlib.colors.LinearSegmentedColormap object>
PuBu_r = <matplotlib.colors.LinearSegmentedColormap object>
PuOr = <matplotlib.colors.LinearSegmentedColormap object>
PuOr_r = <matplotlib.colors.LinearSegmentedColormap object>
PuRd = <matplotlib.colors.LinearSegmentedColormap object>
PuRd_r = <matplotlib.colors.LinearSegmentedColormap object>
Purples = <matplotlib.colors.LinearSegmentedColormap object>
Purples_r = <matplotlib.colors.LinearSegmentedColormap object>
RdBu = <matplotlib.colors.LinearSegmentedColormap object>
RdBu_r = <matplotlib.colors.LinearSegmentedColormap object>
RdGy = <matplotlib.colors.LinearSegmentedColormap object>
RdGy_r = <matplotlib.colors.LinearSegmentedColormap object>
RdPu = <matplotlib.colors.LinearSegmentedColormap object>
RdPu_r = <matplotlib.colors.LinearSegmentedColormap object>
RdYlBu = <matplotlib.colors.LinearSegmentedColormap object>
RdYlBu_r = <matplotlib.colors.LinearSegmentedColormap object>
RdYlGn = <matplotlib.colors.LinearSegmentedColormap object>
RdYlGn_r = <matplotlib.colors.LinearSegmentedColormap object>
Reds = <matplotlib.colors.LinearSegmentedColormap object>
Reds_r = <matplotlib.colors.LinearSegmentedColormap object>
Set1 = <matplotlib.colors.ListedColormap object>
Set1_r = <matplotlib.colors.ListedColormap object>
Set2 = <matplotlib.colors.ListedColormap object>
Set2_r = <matplotlib.colors.ListedColormap object>
Set3 = <matplotlib.colors.ListedColormap object>
Set3_r = <matplotlib.colors.ListedColormap object>
Spectral = <matplotlib.colors.LinearSegmentedColormap object>
Spectral_r = <matplotlib.colors.LinearSegmentedColormap object>
Wistia = <matplotlib.colors.LinearSegmentedColormap object>
Wistia_r = <matplotlib.colors.LinearSegmentedColormap object>
YlGn = <matplotlib.colors.LinearSegmentedColormap object>
YlGnBu = <matplotlib.colors.LinearSegmentedColormap object>
YlGnBu_r = <matplotlib.colors.LinearSegmentedColormap object>
YlGn_r = <matplotlib.colors.LinearSegmentedColormap object>
YlOrBr = <matplotlib.colors.LinearSegmentedColormap object>
YlOrBr_r = <matplotlib.colors.LinearSegmentedColormap object>
YlOrRd = <matplotlib.colors.LinearSegmentedColormap object>
YlOrRd_r = <matplotlib.colors.LinearSegmentedColormap object>
afmhot = <matplotlib.colors.LinearSegmentedColormap object>
afmhot_r = <matplotlib.colors.LinearSegmentedColormap object>
autumn = <matplotlib.colors.LinearSegmentedColormap object>
autumn_r = <matplotlib.colors.LinearSegmentedColormap object>
binary = <matplotlib.colors.LinearSegmentedColormap object>
binary_r = <matplotlib.colors.LinearSegmentedColormap object>
bone = <matplotlib.colors.LinearSegmentedColormap object>
bone_r = <matplotlib.colors.LinearSegmentedColormap object>
brg = <matplotlib.colors.LinearSegmentedColormap object>
brg_r = <matplotlib.colors.LinearSegmentedColormap object>
bwr = <matplotlib.colors.LinearSegmentedColormap object>
bwr_r = <matplotlib.colors.LinearSegmentedColormap object>
cividis = <matplotlib.colors.ListedColormap object>
cividis_r = <matplotlib.colors.ListedColormap object>
cmaps_listed = {'cividis': <matplotlib.colors.ListedColormap object>, ...
cool = <matplotlib.colors.LinearSegmentedColormap object>
cool_r = <matplotlib.colors.LinearSegmentedColormap object>
coolwarm = <matplotlib.colors.LinearSegmentedColormap object>
coolwarm_r = <matplotlib.colors.LinearSegmentedColormap object>
copper = <matplotlib.colors.LinearSegmentedColormap object>
copper_r = <matplotlib.colors.LinearSegmentedColormap object>
cubehelix = <matplotlib.colors.LinearSegmentedColormap object>
cubehelix_r = <matplotlib.colors.LinearSegmentedColormap object>
datad = {'Accent': {'listed': ((0.4980392156862745, 0.788235294117647,...
flag = <matplotlib.colors.LinearSegmentedColormap object>
flag_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_earth = <matplotlib.colors.LinearSegmentedColormap object>
gist_earth_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_gray = <matplotlib.colors.LinearSegmentedColormap object>
gist_gray_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_grey = <matplotlib.colors.LinearSegmentedColormap object>
gist_heat = <matplotlib.colors.LinearSegmentedColormap object>
gist_heat_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_ncar = <matplotlib.colors.LinearSegmentedColormap object>
gist_ncar_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_rainbow = <matplotlib.colors.LinearSegmentedColormap object>
gist_rainbow_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_stern = <matplotlib.colors.LinearSegmentedColormap object>
gist_stern_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_yarg = <matplotlib.colors.LinearSegmentedColormap object>
gist_yarg_r = <matplotlib.colors.LinearSegmentedColormap object>
gist_yerg = <matplotlib.colors.LinearSegmentedColormap object>
gnuplot = <matplotlib.colors.LinearSegmentedColormap object>
gnuplot2 = <matplotlib.colors.LinearSegmentedColormap object>
gnuplot2_r = <matplotlib.colors.LinearSegmentedColormap object>
gnuplot_r = <matplotlib.colors.LinearSegmentedColormap object>
gray = <matplotlib.colors.LinearSegmentedColormap object>
gray_r = <matplotlib.colors.LinearSegmentedColormap object>
grey = <matplotlib.colors.LinearSegmentedColormap object>
hot = <matplotlib.colors.LinearSegmentedColormap object>
hot_r = <matplotlib.colors.LinearSegmentedColormap object>
hsv = <matplotlib.colors.LinearSegmentedColormap object>
hsv_r = <matplotlib.colors.LinearSegmentedColormap object>
inferno = <matplotlib.colors.ListedColormap object>
inferno_r = <matplotlib.colors.ListedColormap object>
jet = <matplotlib.colors.LinearSegmentedColormap object>
jet_r = <matplotlib.colors.LinearSegmentedColormap object>
magma = <matplotlib.colors.ListedColormap object>
magma_r = <matplotlib.colors.ListedColormap object>
nipy_spectral = <matplotlib.colors.LinearSegmentedColormap object>
nipy_spectral_r = <matplotlib.colors.LinearSegmentedColormap object>
ocean = <matplotlib.colors.LinearSegmentedColormap object>
ocean_r = <matplotlib.colors.LinearSegmentedColormap object>
pink = <matplotlib.colors.LinearSegmentedColormap object>
pink_r = <matplotlib.colors.LinearSegmentedColormap object>
plasma = <matplotlib.colors.ListedColormap object>
plasma_r = <matplotlib.colors.ListedColormap object>
prism = <matplotlib.colors.LinearSegmentedColormap object>
prism_r = <matplotlib.colors.LinearSegmentedColormap object>
rainbow = <matplotlib.colors.LinearSegmentedColormap object>
rainbow_r = <matplotlib.colors.LinearSegmentedColormap object>
seismic = <matplotlib.colors.LinearSegmentedColormap object>
seismic_r = <matplotlib.colors.LinearSegmentedColormap object>
spring = <matplotlib.colors.LinearSegmentedColormap object>
spring_r = <matplotlib.colors.LinearSegmentedColormap object>
summer = <matplotlib.colors.LinearSegmentedColormap object>
summer_r = <matplotlib.colors.LinearSegmentedColormap object>
tab10 = <matplotlib.colors.ListedColormap object>
tab10_r = <matplotlib.colors.ListedColormap object>
tab20 = <matplotlib.colors.ListedColormap object>
tab20_r = <matplotlib.colors.ListedColormap object>
tab20b = <matplotlib.colors.ListedColormap object>
tab20b_r = <matplotlib.colors.ListedColormap object>
tab20c = <matplotlib.colors.ListedColormap object>
tab20c_r = <matplotlib.colors.ListedColormap object>
terrain = <matplotlib.colors.LinearSegmentedColormap object>
terrain_r = <matplotlib.colors.LinearSegmentedColormap object>
turbo = <matplotlib.colors.ListedColormap object>
turbo_r = <matplotlib.colors.ListedColormap object>
twilight = <matplotlib.colors.ListedColormap object>
twilight_r = <matplotlib.colors.ListedColormap object>
twilight_shifted = <matplotlib.colors.ListedColormap object>
twilight_shifted_r = <matplotlib.colors.ListedColormap object>
viridis = <matplotlib.colors.ListedColormap object>
viridis_r = <matplotlib.colors.ListedColormap object>
winter = <matplotlib.colors.LinearSegmentedColormap object>
winter_r = <matplotlib.colors.LinearSegmentedColormap object>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\cm.py
matplotlib.color_sequences
Python Library Documentation: ColorSequenceRegistry in module matplotlib.colors object
class ColorSequenceRegistry(collections.abc.Mapping)
| Container for sequences of colors that are known to Matplotlib by name.
|
| The universal registry instance is `matplotlib.color_sequences`. There
| should be no need for users to instantiate `.ColorSequenceRegistry`
| themselves.
|
| Read access uses a dict-like interface mapping names to lists of colors::
|
| import matplotlib as mpl
| cmap = mpl.color_sequences['tab10']
|
| The returned lists are copies, so that their modification does not change
| the global definition of the color sequence.
|
| Additional color sequences can be added via
| `.ColorSequenceRegistry.register`::
|
| mpl.color_sequences.register('rgb', ['r', 'g', 'b'])
|
| Method resolution order:
| ColorSequenceRegistry
| collections.abc.Mapping
| collections.abc.Collection
| collections.abc.Sized
| collections.abc.Iterable
| collections.abc.Container
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, item)
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self)
|
| __len__(self)
|
| __str__(self)
| Return str(self).
|
| register(self, name, color_list)
| Register a new color sequence.
|
| The color sequence registry stores a copy of the given *color_list*, so
| that future changes to the original list do not affect the registered
| color sequence. Think of this as the registry taking a snapshot
| of *color_list* at registration.
|
| Parameters
| ----------
| name : str
| The name for the color sequence.
|
| color_list : list of :mpltype:`color`
| An iterable returning valid Matplotlib colors when iterating over.
| Note however that the returned color sequence will always be a
| list regardless of the input type.
|
| unregister(self, name)
| Remove a sequence from the registry.
|
| You cannot remove built-in color sequences.
|
| If the name is not registered, returns with no error.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| 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)
| 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).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
matplotlib.colormaps
Python Library Documentation: ColormapRegistry in module matplotlib.cm object class ColormapRegistry(collections.abc.Mapping) | ColormapRegistry(cmaps) | | Container for colormaps that are known to Matplotlib by name. | | The universal registry instance is `matplotlib.colormaps`. There should be | no need for users to instantiate `.ColormapRegistry` themselves. | | Read access uses a dict-like interface mapping names to `.Colormap`\s:: | | import matplotlib as mpl | cmap = mpl.colormaps['viridis'] | | Returned `.Colormap`\s are copies, so that their modification does not | change the global definition of the colormap. | | Additional colormaps can be added via `.ColormapRegistry.register`:: | | mpl.colormaps.register(my_colormap) | | To get a list of all registered colormaps, you can do:: | | from matplotlib import colormaps | list(colormaps) | | Method resolution order: | ColormapRegistry | collections.abc.Mapping | collections.abc.Collection | collections.abc.Sized | collections.abc.Iterable | collections.abc.Container | builtins.object | | Methods defined here: | | __call__(self) | Return a list of the registered colormap names. | | This exists only for backward-compatibility in `.pyplot` which had a | ``plt.colormaps()`` method. The recommended way to get this list is | now ``list(colormaps)``. | | __getitem__(self, item) | | __init__(self, cmaps) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self) | | __len__(self) | | __str__(self) | Return str(self). | | get_cmap(self, cmap) | Return a color map specified through *cmap*. | | Parameters | ---------- | cmap : str or `~matplotlib.colors.Colormap` or None | | - if a `.Colormap`, return it | - if a string, look it up in ``mpl.colormaps`` | - if None, return the Colormap defined in :rc:`image.cmap` | | Returns | ------- | Colormap | | register(self, cmap, *, name=None, force=False) | Register a new colormap. | | The colormap name can then be used as a string argument to any ``cmap`` | parameter in Matplotlib. It is also available in ``pyplot.get_cmap``. | | The colormap registry stores a copy of the given colormap, so that | future changes to the original colormap instance do not affect the | registered colormap. Think of this as the registry taking a snapshot | of the colormap at registration. | | Parameters | ---------- | cmap : matplotlib.colors.Colormap | The colormap to register. | | name : str, optional | The name for the colormap. If not given, ``cmap.name`` is used. | | force : bool, default: False | If False, a ValueError is raised if trying to overwrite an already | registered name. True supports overwriting registered colormaps | other than the builtin colormaps. | | unregister(self, name) | Remove a colormap from the registry. | | You cannot remove built-in colormaps. | | If the named colormap is not registered, returns with no error, raises | if you try to de-register a default colormap. | | .. warning:: | | Colormap names are currently a shared namespace that may be used | by multiple packages. Use `unregister` only if you know you | have registered that name before. In particular, do not | unregister just in case to clean the name before registering a | new colormap. | | Parameters | ---------- | name : str | The name of the colormap to be removed. | | Raises | ------ | ValueError | If you try to remove a default built-in colormap. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __abstractmethods__ = frozenset() | | ---------------------------------------------------------------------- | 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) | 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). | | ---------------------------------------------------------------------- | Class methods inherited from collections.abc.Iterable: | | __class_getitem__ = GenericAlias(...) | Represent a PEP 585 generic type | | E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
matplotlib.colors
Python Library Documentation: module matplotlib.colors in matplotlib
NAME
matplotlib.colors - A module for converting numbers or color arguments to *RGB* or *RGBA*.
DESCRIPTION
*RGB* and *RGBA* are sequences of, respectively, 3 or 4 floats in the
range 0-1.
This module includes functions and classes for color specification conversions,
and for mapping numbers to colors in a 1-D array of colors called a colormap.
Mapping data onto colors using a colormap typically involves two steps: a data
array is first mapped onto the range 0-1 using a subclass of `Normalize`,
then this number is mapped to a color using a subclass of `Colormap`. Two
subclasses of `Colormap` provided here: `LinearSegmentedColormap`, which uses
piecewise-linear interpolation to define colormaps, and `ListedColormap`, which
makes a colormap from a list of colors.
.. seealso::
:ref:`colormap-manipulation` for examples of how to
make colormaps and
:ref:`colormaps` for a list of built-in colormaps.
:ref:`colormapnorms` for more details about data
normalization
More colormaps are available at palettable_.
The module also provides functions for checking whether an object can be
interpreted as a color (`is_color_like`), for converting such an object
to an RGBA tuple (`to_rgba`) or to an HTML-like hex string in the
"#rrggbb" format (`to_hex`), and a sequence of colors to an (n, 4)
RGBA array (`to_rgba_array`). Caching is used for efficiency.
Colors that Matplotlib recognizes are listed at
:ref:`colors_def`.
.. _palettable: https://jiffyclub.github.io/palettable/
.. _xkcd color survey: https://xkcd.com/color/rgb/
CLASSES
builtins.object
ColorConverter
Colormap
LinearSegmentedColormap
ListedColormap
LightSource
Normalize
BoundaryNorm
CenteredNorm
LogNorm
NoNorm
PowerNorm
TwoSlopeNorm
collections.abc.Mapping(collections.abc.Collection)
ColorSequenceRegistry
AsinhNorm(Normalize)
AsinhNorm
FuncNorm(Normalize)
FuncNorm
SymLogNorm(Normalize)
SymLogNorm
class AsinhNorm(AsinhNorm)
| AsinhNorm(linear_width=1, vmin=None, vmax=None, clip=False)
|
| The inverse hyperbolic sine scale is approximately linear near
| the origin, but becomes logarithmic for larger positive
| or negative values. Unlike the `SymLogNorm`, the transition between
| these linear and logarithmic regions is smooth, which may reduce
| the risk of visual artifacts.
|
| .. note::
|
| This API is provisional and may be revised in the future
| based on early user feedback.
|
| Parameters
| ----------
| linear_width : float, default: 1
| The effective width of the linear region, beyond which
| the transformation becomes asymptotically logarithmic
|
| Method resolution order:
| AsinhNorm
| AsinhNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None) from _make_norm_from_scale.<locals>.Norm
|
| __init__(self, linear_width=1, vmin=None, vmax=None, clip=False) from _make_norm_from_scale.<locals>.Norm
|
| __reduce__(self) from _make_norm_from_scale.<locals>.Norm
|
| autoscale_None(self, A) from _make_norm_from_scale.<locals>.Norm
|
| inverse(self, value) from _make_norm_from_scale.<locals>.Norm
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AsinhNorm:
|
| linear_width
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class BoundaryNorm(Normalize)
| BoundaryNorm(boundaries, ncolors, clip=False, *, extend='neither')
|
| Generate a colormap index based on discrete intervals.
|
| Unlike `Normalize` or `LogNorm`, `BoundaryNorm` maps values to integers
| instead of to the interval 0-1.
|
| Method resolution order:
| BoundaryNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None)
| This method behaves similarly to `.Normalize.__call__`, except that it
| returns integers or arrays of int16.
|
| __init__(self, boundaries, ncolors, clip=False, *, extend='neither')
| Parameters
| ----------
| boundaries : array-like
| Monotonically increasing sequence of at least 2 bin edges: data
| falling in the n-th bin will be mapped to the n-th color.
|
| ncolors : int
| Number of colors in the colormap to be used.
|
| clip : bool, optional
| If clip is ``True``, out of range values are mapped to 0 if they
| are below ``boundaries[0]`` or mapped to ``ncolors - 1`` if they
| are above ``boundaries[-1]``.
|
| If clip is ``False``, out of range values are mapped to -1 if
| they are below ``boundaries[0]`` or mapped to *ncolors* if they are
| above ``boundaries[-1]``. These are then converted to valid indices
| by `Colormap.__call__`.
|
| extend : {'neither', 'both', 'min', 'max'}, default: 'neither'
| Extend the number of bins to include one or both of the
| regions beyond the boundaries. For example, if ``extend``
| is 'min', then the color to which the region between the first
| pair of boundaries is mapped will be distinct from the first
| color in the colormap, and by default a
| `~matplotlib.colorbar.Colorbar` will be drawn with
| the triangle extension on the left or lower end.
|
| Notes
| -----
| If there are fewer bins (including extensions) than colors, then the
| color index is chosen by linearly interpolating the ``[0, nbins - 1]``
| range onto the ``[0, ncolors - 1]`` range, effectively skipping some
| colors in the middle of the colormap.
|
| inverse(self, value)
| Raises
| ------
| ValueError
| BoundaryNorm is not invertible, so calling this method will always
| raise an error
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| autoscale_None(self, A)
| If *vmin* or *vmax* are not set, use the min/max of *A* to set them.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class CenteredNorm(Normalize)
| CenteredNorm(vcenter=0, halfrange=None, clip=False)
|
| Method resolution order:
| CenteredNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __init__(self, vcenter=0, halfrange=None, clip=False)
| Normalize symmetrical data around a center (0 by default).
|
| Unlike `TwoSlopeNorm`, `CenteredNorm` applies an equal rate of change
| around the center.
|
| Useful when mapping symmetrical data around a conceptual center
| e.g., data that range from -2 to 4, with 0 as the midpoint, and
| with equal rates of change around that midpoint.
|
| Parameters
| ----------
| vcenter : float, default: 0
| The data value that defines ``0.5`` in the normalization.
| halfrange : float, optional
| The range of data values that defines a range of ``0.5`` in the
| normalization, so that *vcenter* - *halfrange* is ``0.0`` and
| *vcenter* + *halfrange* is ``1.0`` in the normalization.
| Defaults to the largest absolute difference to *vcenter* for
| the values in the dataset.
| clip : bool, default: False
| Determines the behavior for mapping values outside the range
| ``[vmin, vmax]``.
|
| If clipping is off, values outside the range ``[vmin, vmax]`` are
| also transformed, resulting in values outside ``[0, 1]``. This
| behavior is usually desirable, as colormaps can mark these *under*
| and *over* values with specific colors.
|
| If clipping is on, values below *vmin* are mapped to 0 and values
| above *vmax* are mapped to 1. Such values become indistinguishable
| from regular boundary values, which may cause misinterpretation of
| the data.
|
| Examples
| --------
| This maps data values -2 to 0.25, 0 to 0.5, and 4 to 1.0
| (assuming equal rates of change above and below 0.0):
|
| >>> import matplotlib.colors as mcolors
| >>> norm = mcolors.CenteredNorm(halfrange=4.0)
| >>> data = [-2., 0., 4.]
| >>> norm(data)
| array([0.25, 0.5 , 1. ])
|
| autoscale(self, A)
| Set *halfrange* to ``max(abs(A-vcenter))``, then set *vmin* and *vmax*.
|
| autoscale_None(self, A)
| Set *vmin* and *vmax*.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| halfrange
|
| vcenter
|
| vmax
|
| vmin
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| __call__(self, value, clip=None)
| Normalize the data and return the normalized data.
|
| Parameters
| ----------
| value
| Data to normalize.
| clip : bool, optional
| See the description of the parameter *clip* in `.Normalize`.
|
| If ``None``, defaults to ``self.clip`` (which defaults to
| ``False``).
|
| Notes
| -----
| If not already initialized, ``self.vmin`` and ``self.vmax`` are
| initialized using ``self.autoscale_None(value)``.
|
| inverse(self, value)
| Maps the normalized value (i.e., index in the colormap) back to image
| data value.
|
| Parameters
| ----------
| value
| Normalized value.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
class ColorConverter(builtins.object)
| A class only kept for backwards compatibility.
|
| Its functionality is entirely provided by module-level functions.
|
| Static methods defined here:
|
| to_rgb(c)
| Convert *c* to an RGB color, silently dropping the alpha channel.
|
| to_rgba(c, alpha=None)
| Convert *c* to an RGBA color.
|
| Parameters
| ----------
| c : Matplotlib color or ``np.ma.masked``
|
| alpha : float, optional
| If *alpha* is given, force the alpha value of the returned RGBA tuple
| to *alpha*.
|
| If None, the alpha value from *c* is used. If *c* does not have an
| alpha channel, then alpha defaults to 1.
|
| *alpha* is ignored for the color value ``"none"`` (case-insensitive),
| which always maps to ``(0, 0, 0, 0)``.
|
| Returns
| -------
| tuple
| Tuple of floats ``(r, g, b, a)``, where each channel (red, green, blue,
| alpha) can assume values between 0 and 1.
|
| to_rgba_array(c, alpha=None)
| Convert *c* to a (n, 4) array of RGBA colors.
|
| Parameters
| ----------
| c : Matplotlib color or array of colors
| If *c* is a masked array, an `~numpy.ndarray` is returned with a
| (0, 0, 0, 0) row for each masked value or row in *c*.
|
| alpha : float or sequence of floats, optional
| If *alpha* is given, force the alpha value of the returned RGBA tuple
| to *alpha*.
|
| If None, the alpha value from *c* is used. If *c* does not have an
| alpha channel, then alpha defaults to 1.
|
| *alpha* is ignored for the color value ``"none"`` (case-insensitive),
| which always maps to ``(0, 0, 0, 0)``.
|
| If *alpha* is a sequence and *c* is a single color, *c* will be
| repeated to match the length of *alpha*.
|
| Returns
| -------
| array
| (n, 4) array of RGBA colors, where each channel (red, green, blue,
| alpha) can assume values between 0 and 1.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| cache = {('black', None): (0.0, 0.0, 0.0, 1.0), ('white', None): (1.0,...
|
| colors = {'xkcd:cloudy blue': '#acc2d9', 'xkcd:dark paste... (0.75, 0....
class ColorSequenceRegistry(collections.abc.Mapping)
| Container for sequences of colors that are known to Matplotlib by name.
|
| The universal registry instance is `matplotlib.color_sequences`. There
| should be no need for users to instantiate `.ColorSequenceRegistry`
| themselves.
|
| Read access uses a dict-like interface mapping names to lists of colors::
|
| import matplotlib as mpl
| cmap = mpl.color_sequences['tab10']
|
| The returned lists are copies, so that their modification does not change
| the global definition of the color sequence.
|
| Additional color sequences can be added via
| `.ColorSequenceRegistry.register`::
|
| mpl.color_sequences.register('rgb', ['r', 'g', 'b'])
|
| Method resolution order:
| ColorSequenceRegistry
| collections.abc.Mapping
| collections.abc.Collection
| collections.abc.Sized
| collections.abc.Iterable
| collections.abc.Container
| builtins.object
|
| Methods defined here:
|
| __getitem__(self, item)
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self)
|
| __len__(self)
|
| __str__(self)
| Return str(self).
|
| register(self, name, color_list)
| Register a new color sequence.
|
| The color sequence registry stores a copy of the given *color_list*, so
| that future changes to the original list do not affect the registered
| color sequence. Think of this as the registry taking a snapshot
| of *color_list* at registration.
|
| Parameters
| ----------
| name : str
| The name for the color sequence.
|
| color_list : list of :mpltype:`color`
| An iterable returning valid Matplotlib colors when iterating over.
| Note however that the returned color sequence will always be a
| list regardless of the input type.
|
| unregister(self, name)
| Remove a sequence from the registry.
|
| You cannot remove built-in color sequences.
|
| If the name is not registered, returns with no error.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| 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)
| 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).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
class Colormap(builtins.object)
| Colormap(name, N=256)
|
| Baseclass for all scalar to RGBA mappings.
|
| Typically, Colormap instances are used to convert data values (floats)
| from the interval ``[0, 1]`` to the RGBA color that the respective
| Colormap represents. For scaling of data into the ``[0, 1]`` interval see
| `matplotlib.colors.Normalize`. Subclasses of `matplotlib.cm.ScalarMappable`
| make heavy use of this ``data -> normalize -> map-to-color`` processing
| chain.
|
| Methods defined here:
|
| __call__(self, X, alpha=None, bytes=False)
| Parameters
| ----------
| X : float or int, `~numpy.ndarray` or scalar
| The data value(s) to convert to RGBA.
| For floats, *X* should be in the interval ``[0.0, 1.0]`` to
| return the RGBA values ``X*100`` percent along the Colormap line.
| For integers, *X* should be in the interval ``[0, Colormap.N)`` to
| return RGBA values *indexed* from the Colormap with index ``X``.
| alpha : float or array-like or None
| Alpha must be a scalar between 0 and 1, a sequence of such
| floats with shape matching X, or None.
| bytes : bool
| If False (default), the returned RGBA values will be floats in the
| interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s in the
| interval ``[0, 255]``.
|
| Returns
| -------
| Tuple of RGBA values if X is scalar, otherwise an array of
| RGBA values with a shape of ``X.shape + (4, )``.
|
| __copy__(self)
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, name, N=256)
| Parameters
| ----------
| name : str
| The name of the colormap.
| N : int
| The number of RGB quantization levels.
|
| copy(self)
| Return a copy of the colormap.
|
| get_bad(self)
| Get the color for masked values.
|
| get_over(self)
| Get the color for high out-of-range values.
|
| get_under(self)
| Get the color for low out-of-range values.
|
| is_gray(self)
| Return whether the colormap is grayscale.
|
| resampled(self, lutsize)
| Return a new colormap with *lutsize* entries.
|
| reversed(self, name=None)
| Return a reversed instance of the Colormap.
|
| .. note:: This function is not implemented for the base class.
|
| Parameters
| ----------
| name : str, optional
| The name for the reversed colormap. If None, the
| name is set to ``self.name + "_r"``.
|
| See Also
| --------
| LinearSegmentedColormap.reversed
| ListedColormap.reversed
|
| set_bad(self, color='k', alpha=None)
| Set the color for masked values.
|
| set_extremes(self, *, bad=None, under=None, over=None)
| Set the colors for masked (*bad*) values and, when ``norm.clip =
| False``, low (*under*) and high (*over*) out-of-range values.
|
| set_over(self, color='k', alpha=None)
| Set the color for high out-of-range values.
|
| set_under(self, color='k', alpha=None)
| Set the color for low out-of-range values.
|
| with_extremes(self, *, bad=None, under=None, over=None)
| Return a copy of the colormap, for which the colors for masked (*bad*)
| values and, when ``norm.clip = False``, low (*under*) and high (*over*)
| out-of-range values, have been set accordingly.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
class FuncNorm(FuncNorm)
| FuncNorm(functions, vmin=None, vmax=None, clip=False)
|
| Arbitrary normalization using functions for the forward and inverse.
|
| Parameters
| ----------
| functions : (callable, callable)
| two-tuple of the forward and inverse functions for the normalization.
| The forward function must be monotonic.
|
| Both functions must have the signature ::
|
| def forward(values: array-like) -> array-like
|
| vmin, vmax : float or None
| If *vmin* and/or *vmax* is not given, they are initialized from the
| minimum and maximum value, respectively, of the first input
| processed; i.e., ``__call__(A)`` calls ``autoscale_None(A)``.
|
| clip : bool, default: False
| Determines the behavior for mapping values outside the range
| ``[vmin, vmax]``.
|
| If clipping is off, values outside the range ``[vmin, vmax]`` are also
| transformed by the function, resulting in values outside ``[0, 1]``.
| This behavior is usually desirable, as colormaps can mark these *under*
| and *over* values with specific colors.
|
| If clipping is on, values below *vmin* are mapped to 0 and values above
| *vmax* are mapped to 1. Such values become indistinguishable from
| regular boundary values, which may cause misinterpretation of the data.
|
| Method resolution order:
| FuncNorm
| FuncNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None) from _make_norm_from_scale.<locals>.Norm
|
| __init__(self, functions, vmin=None, vmax=None, clip=False) from _make_norm_from_scale.<locals>.Norm
|
| __reduce__(self) from _make_norm_from_scale.<locals>.Norm
|
| autoscale_None(self, A) from _make_norm_from_scale.<locals>.Norm
|
| inverse(self, value) from _make_norm_from_scale.<locals>.Norm
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class LightSource(builtins.object)
| LightSource(azdeg=315, altdeg=45, hsv_min_val=0, hsv_max_val=1, hsv_min_sat=1, hsv_max_sat=0)
|
| Create a light source coming from the specified azimuth and elevation.
| Angles are in degrees, with the azimuth measured
| clockwise from north and elevation up from the zero plane of the surface.
|
| `shade` is used to produce "shaded" RGB values for a data array.
| `shade_rgb` can be used to combine an RGB image with an elevation map.
| `hillshade` produces an illumination map of a surface.
|
| Methods defined here:
|
| __init__(self, azdeg=315, altdeg=45, hsv_min_val=0, hsv_max_val=1, hsv_min_sat=1, hsv_max_sat=0)
| Specify the azimuth (measured clockwise from south) and altitude
| (measured up from the plane of the surface) of the light source
| in degrees.
|
| Parameters
| ----------
| azdeg : float, default: 315 degrees (from the northwest)
| The azimuth (0-360, degrees clockwise from North) of the light
| source.
| altdeg : float, default: 45 degrees
| The altitude (0-90, degrees up from horizontal) of the light
| source.
| hsv_min_val : number, default: 0
| The minimum value ("v" in "hsv") that the *intensity* map can shift the
| output image to.
| hsv_max_val : number, default: 1
| The maximum value ("v" in "hsv") that the *intensity* map can shift the
| output image to.
| hsv_min_sat : number, default: 1
| The minimum saturation value that the *intensity* map can shift the output
| image to.
| hsv_max_sat : number, default: 0
| The maximum saturation value that the *intensity* map can shift the output
| image to.
|
| Notes
| -----
| For backwards compatibility, the parameters *hsv_min_val*,
| *hsv_max_val*, *hsv_min_sat*, and *hsv_max_sat* may be supplied at
| initialization as well. However, these parameters will only be used if
| "blend_mode='hsv'" is passed into `shade` or `shade_rgb`.
| See the documentation for `blend_hsv` for more details.
|
| blend_hsv(self, rgb, intensity, hsv_max_sat=None, hsv_max_val=None, hsv_min_val=None, hsv_min_sat=None)
| Take the input data array, convert to HSV values in the given colormap,
| then adjust those color values to give the impression of a shaded
| relief map with a specified light source. RGBA values are returned,
| which can then be used to plot the shaded image with imshow.
|
| The color of the resulting image will be darkened by moving the (s, v)
| values (in HSV colorspace) toward (hsv_min_sat, hsv_min_val) in the
| shaded regions, or lightened by sliding (s, v) toward (hsv_max_sat,
| hsv_max_val) in regions that are illuminated. The default extremes are
| chose so that completely shaded points are nearly black (s = 1, v = 0)
| and completely illuminated points are nearly white (s = 0, v = 1).
|
| Parameters
| ----------
| rgb : `~numpy.ndarray`
| An (M, N, 3) RGB array of floats ranging from 0 to 1 (color image).
| intensity : `~numpy.ndarray`
| An (M, N, 1) array of floats ranging from 0 to 1 (grayscale image).
| hsv_max_sat : number, optional
| The maximum saturation value that the *intensity* map can shift the output
| image to. If not provided, use the value provided upon initialization.
| hsv_min_sat : number, optional
| The minimum saturation value that the *intensity* map can shift the output
| image to. If not provided, use the value provided upon initialization.
| hsv_max_val : number, optional
| The maximum value ("v" in "hsv") that the *intensity* map can shift the
| output image to. If not provided, use the value provided upon
| initialization.
| hsv_min_val : number, optional
| The minimum value ("v" in "hsv") that the *intensity* map can shift the
| output image to. If not provided, use the value provided upon
| initialization.
|
| Returns
| -------
| `~numpy.ndarray`
| An (M, N, 3) RGB array representing the combined images.
|
| blend_overlay(self, rgb, intensity)
| Combine an RGB image with an intensity map using "overlay" blending.
|
| Parameters
| ----------
| rgb : `~numpy.ndarray`
| An (M, N, 3) RGB array of floats ranging from 0 to 1 (color image).
| intensity : `~numpy.ndarray`
| An (M, N, 1) array of floats ranging from 0 to 1 (grayscale image).
|
| Returns
| -------
| ndarray
| An (M, N, 3) RGB array representing the combined images.
|
| blend_soft_light(self, rgb, intensity)
| Combine an RGB image with an intensity map using "soft light" blending,
| using the "pegtop" formula.
|
| Parameters
| ----------
| rgb : `~numpy.ndarray`
| An (M, N, 3) RGB array of floats ranging from 0 to 1 (color image).
| intensity : `~numpy.ndarray`
| An (M, N, 1) array of floats ranging from 0 to 1 (grayscale image).
|
| Returns
| -------
| `~numpy.ndarray`
| An (M, N, 3) RGB array representing the combined images.
|
| hillshade(self, elevation, vert_exag=1, dx=1, dy=1, fraction=1.0)
| Calculate the illumination intensity for a surface using the defined
| azimuth and elevation for the light source.
|
| This computes the normal vectors for the surface, and then passes them
| on to `shade_normals`
|
| Parameters
| ----------
| elevation : 2D array-like
| The height values used to generate an illumination map
| vert_exag : number, optional
| The amount to exaggerate the elevation values by when calculating
| illumination. This can be used either to correct for differences in
| units between the x-y coordinate system and the elevation
| coordinate system (e.g. decimal degrees vs. meters) or to
| exaggerate or de-emphasize topographic effects.
| dx : number, optional
| The x-spacing (columns) of the input *elevation* grid.
| dy : number, optional
| The y-spacing (rows) of the input *elevation* grid.
| fraction : number, optional
| Increases or decreases the contrast of the hillshade. Values
| greater than one will cause intermediate values to move closer to
| full illumination or shadow (and clipping any values that move
| beyond 0 or 1). Note that this is not visually or mathematically
| the same as vertical exaggeration.
|
| Returns
| -------
| `~numpy.ndarray`
| A 2D array of illumination values between 0-1, where 0 is
| completely in shadow and 1 is completely illuminated.
|
| shade(self, data, cmap, norm=None, blend_mode='overlay', vmin=None, vmax=None, vert_exag=1, dx=1, dy=1, fraction=1, **kwargs)
| Combine colormapped data values with an illumination intensity map
| (a.k.a. "hillshade") of the values.
|
| Parameters
| ----------
| data : 2D array-like
| The height values used to generate a shaded map.
| cmap : `~matplotlib.colors.Colormap`
| The colormap used to color the *data* array. Note that this must be
| a `~matplotlib.colors.Colormap` instance. For example, rather than
| passing in ``cmap='gist_earth'``, use
| ``cmap=plt.get_cmap('gist_earth')`` instead.
| norm : `~matplotlib.colors.Normalize` instance, optional
| The normalization used to scale values before colormapping. If
| None, the input will be linearly scaled between its min and max.
| blend_mode : {'hsv', 'overlay', 'soft'} or callable, optional
| The type of blending used to combine the colormapped data
| values with the illumination intensity. Default is
| "overlay". Note that for most topographic surfaces,
| "overlay" or "soft" appear more visually realistic. If a
| user-defined function is supplied, it is expected to
| combine an (M, N, 3) RGB array of floats (ranging 0 to 1) with
| an (M, N, 1) hillshade array (also 0 to 1). (Call signature
| ``func(rgb, illum, **kwargs)``) Additional kwargs supplied
| to this function will be passed on to the *blend_mode*
| function.
| vmin : float or None, optional
| The minimum value used in colormapping *data*. If *None* the
| minimum value in *data* is used. If *norm* is specified, then this
| argument will be ignored.
| vmax : float or None, optional
| The maximum value used in colormapping *data*. If *None* the
| maximum value in *data* is used. If *norm* is specified, then this
| argument will be ignored.
| vert_exag : number, optional
| The amount to exaggerate the elevation values by when calculating
| illumination. This can be used either to correct for differences in
| units between the x-y coordinate system and the elevation
| coordinate system (e.g. decimal degrees vs. meters) or to
| exaggerate or de-emphasize topography.
| dx : number, optional
| The x-spacing (columns) of the input *elevation* grid.
| dy : number, optional
| The y-spacing (rows) of the input *elevation* grid.
| fraction : number, optional
| Increases or decreases the contrast of the hillshade. Values
| greater than one will cause intermediate values to move closer to
| full illumination or shadow (and clipping any values that move
| beyond 0 or 1). Note that this is not visually or mathematically
| the same as vertical exaggeration.
| **kwargs
| Additional kwargs are passed on to the *blend_mode* function.
|
| Returns
| -------
| `~numpy.ndarray`
| An (M, N, 4) array of floats ranging between 0-1.
|
| shade_normals(self, normals, fraction=1.0)
| Calculate the illumination intensity for the normal vectors of a
| surface using the defined azimuth and elevation for the light source.
|
| Imagine an artificial sun placed at infinity in some azimuth and
| elevation position illuminating our surface. The parts of the surface
| that slope toward the sun should brighten while those sides facing away
| should become darker.
|
| Parameters
| ----------
| fraction : number, optional
| Increases or decreases the contrast of the hillshade. Values
| greater than one will cause intermediate values to move closer to
| full illumination or shadow (and clipping any values that move
| beyond 0 or 1). Note that this is not visually or mathematically
| the same as vertical exaggeration.
|
| Returns
| -------
| `~numpy.ndarray`
| A 2D array of illumination values between 0-1, where 0 is
| completely in shadow and 1 is completely illuminated.
|
| shade_rgb(self, rgb, elevation, fraction=1.0, blend_mode='hsv', vert_exag=1, dx=1, dy=1, **kwargs)
| Use this light source to adjust the colors of the *rgb* input array to
| give the impression of a shaded relief map with the given *elevation*.
|
| Parameters
| ----------
| rgb : array-like
| An (M, N, 3) RGB array, assumed to be in the range of 0 to 1.
| elevation : array-like
| An (M, N) array of the height values used to generate a shaded map.
| fraction : number
| Increases or decreases the contrast of the hillshade. Values
| greater than one will cause intermediate values to move closer to
| full illumination or shadow (and clipping any values that move
| beyond 0 or 1). Note that this is not visually or mathematically
| the same as vertical exaggeration.
| blend_mode : {'hsv', 'overlay', 'soft'} or callable, optional
| The type of blending used to combine the colormapped data values
| with the illumination intensity. For backwards compatibility, this
| defaults to "hsv". Note that for most topographic surfaces,
| "overlay" or "soft" appear more visually realistic. If a
| user-defined function is supplied, it is expected to combine an
| (M, N, 3) RGB array of floats (ranging 0 to 1) with an (M, N, 1)
| hillshade array (also 0 to 1). (Call signature
| ``func(rgb, illum, **kwargs)``)
| Additional kwargs supplied to this function will be passed on to
| the *blend_mode* function.
| vert_exag : number, optional
| The amount to exaggerate the elevation values by when calculating
| illumination. This can be used either to correct for differences in
| units between the x-y coordinate system and the elevation
| coordinate system (e.g. decimal degrees vs. meters) or to
| exaggerate or de-emphasize topography.
| dx : number, optional
| The x-spacing (columns) of the input *elevation* grid.
| dy : number, optional
| The y-spacing (rows) of the input *elevation* grid.
| **kwargs
| Additional kwargs are passed on to the *blend_mode* function.
|
| Returns
| -------
| `~numpy.ndarray`
| An (m, n, 3) array of floats ranging between 0-1.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| direction
| The unit vector direction towards the light source.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LinearSegmentedColormap(Colormap)
| LinearSegmentedColormap(name, segmentdata, N=256, gamma=1.0)
|
| Colormap objects based on lookup tables using linear segments.
|
| The lookup table is generated using linear interpolation for each
| primary color, with the 0-1 domain divided into any number of
| segments.
|
| Method resolution order:
| LinearSegmentedColormap
| Colormap
| builtins.object
|
| Methods defined here:
|
| __init__(self, name, segmentdata, N=256, gamma=1.0)
| Create colormap from linear mapping segments
|
| segmentdata argument is a dictionary with a red, green and blue
| entries. Each entry should be a list of *x*, *y0*, *y1* tuples,
| forming rows in a table. Entries for alpha are optional.
|
| Example: suppose you want red to increase from 0 to 1 over
| the bottom half, green to do the same over the middle half,
| and blue over the top half. Then you would use::
|
| cdict = {'red': [(0.0, 0.0, 0.0),
| (0.5, 1.0, 1.0),
| (1.0, 1.0, 1.0)],
|
| 'green': [(0.0, 0.0, 0.0),
| (0.25, 0.0, 0.0),
| (0.75, 1.0, 1.0),
| (1.0, 1.0, 1.0)],
|
| 'blue': [(0.0, 0.0, 0.0),
| (0.5, 0.0, 0.0),
| (1.0, 1.0, 1.0)]}
|
| Each row in the table for a given color is a sequence of
| *x*, *y0*, *y1* tuples. In each sequence, *x* must increase
| monotonically from 0 to 1. For any input value *z* falling
| between *x[i]* and *x[i+1]*, the output value of a given color
| will be linearly interpolated between *y1[i]* and *y0[i+1]*::
|
| row i: x y0 y1
| /
| /
| row i+1: x y0 y1
|
| Hence y0 in the first row and y1 in the last row are never used.
|
| See Also
| --------
| LinearSegmentedColormap.from_list
| Static method; factory function for generating a smoothly-varying
| LinearSegmentedColormap.
|
| resampled(self, lutsize)
| Return a new colormap with *lutsize* entries.
|
| reversed(self, name=None)
| Return a reversed instance of the Colormap.
|
| Parameters
| ----------
| name : str, optional
| The name for the reversed colormap. If None, the
| name is set to ``self.name + "_r"``.
|
| Returns
| -------
| LinearSegmentedColormap
| The reversed colormap.
|
| set_gamma(self, gamma)
| Set a new gamma value and regenerate colormap.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| from_list(name, colors, N=256, gamma=1.0)
| Create a `LinearSegmentedColormap` from a list of colors.
|
| Parameters
| ----------
| name : str
| The name of the colormap.
| colors : list of :mpltype:`color` or list of (value, color)
| If only colors are given, they are equidistantly mapped from the
| range :math:`[0, 1]`; i.e. 0 maps to ``colors[0]`` and 1 maps to
| ``colors[-1]``.
| If (value, color) pairs are given, the mapping is from *value*
| to *color*. This can be used to divide the range unevenly.
| N : int
| The number of RGB quantization levels.
| gamma : float
|
| ----------------------------------------------------------------------
| Methods inherited from Colormap:
|
| __call__(self, X, alpha=None, bytes=False)
| Parameters
| ----------
| X : float or int, `~numpy.ndarray` or scalar
| The data value(s) to convert to RGBA.
| For floats, *X* should be in the interval ``[0.0, 1.0]`` to
| return the RGBA values ``X*100`` percent along the Colormap line.
| For integers, *X* should be in the interval ``[0, Colormap.N)`` to
| return RGBA values *indexed* from the Colormap with index ``X``.
| alpha : float or array-like or None
| Alpha must be a scalar between 0 and 1, a sequence of such
| floats with shape matching X, or None.
| bytes : bool
| If False (default), the returned RGBA values will be floats in the
| interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s in the
| interval ``[0, 255]``.
|
| Returns
| -------
| Tuple of RGBA values if X is scalar, otherwise an array of
| RGBA values with a shape of ``X.shape + (4, )``.
|
| __copy__(self)
|
| __eq__(self, other)
| Return self==value.
|
| copy(self)
| Return a copy of the colormap.
|
| get_bad(self)
| Get the color for masked values.
|
| get_over(self)
| Get the color for high out-of-range values.
|
| get_under(self)
| Get the color for low out-of-range values.
|
| is_gray(self)
| Return whether the colormap is grayscale.
|
| set_bad(self, color='k', alpha=None)
| Set the color for masked values.
|
| set_extremes(self, *, bad=None, under=None, over=None)
| Set the colors for masked (*bad*) values and, when ``norm.clip =
| False``, low (*under*) and high (*over*) out-of-range values.
|
| set_over(self, color='k', alpha=None)
| Set the color for high out-of-range values.
|
| set_under(self, color='k', alpha=None)
| Set the color for low out-of-range values.
|
| with_extremes(self, *, bad=None, under=None, over=None)
| Return a copy of the colormap, for which the colors for masked (*bad*)
| values and, when ``norm.clip = False``, low (*under*) and high (*over*)
| out-of-range values, have been set accordingly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Colormap:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Colormap:
|
| __hash__ = None
class ListedColormap(Colormap)
| ListedColormap(colors, name='from_list', N=None)
|
| Colormap object generated from a list of colors.
|
| This may be most useful when indexing directly into a colormap,
| but it can also be used to generate special colormaps for ordinary
| mapping.
|
| Parameters
| ----------
| colors : list, array
| Sequence of Matplotlib color specifications (color names or RGB(A)
| values).
| name : str, optional
| String to identify the colormap.
| N : int, optional
| Number of entries in the map. The default is *None*, in which case
| there is one colormap entry for each element in the list of colors.
| If ::
|
| N < len(colors)
|
| the list will be truncated at *N*. If ::
|
| N > len(colors)
|
| the list will be extended by repetition.
|
| Method resolution order:
| ListedColormap
| Colormap
| builtins.object
|
| Methods defined here:
|
| __init__(self, colors, name='from_list', N=None)
| Parameters
| ----------
| name : str
| The name of the colormap.
| N : int
| The number of RGB quantization levels.
|
| resampled(self, lutsize)
| Return a new colormap with *lutsize* entries.
|
| reversed(self, name=None)
| Return a reversed instance of the Colormap.
|
| Parameters
| ----------
| name : str, optional
| The name for the reversed colormap. If None, the
| name is set to ``self.name + "_r"``.
|
| Returns
| -------
| ListedColormap
| A reversed instance of the colormap.
|
| ----------------------------------------------------------------------
| Methods inherited from Colormap:
|
| __call__(self, X, alpha=None, bytes=False)
| Parameters
| ----------
| X : float or int, `~numpy.ndarray` or scalar
| The data value(s) to convert to RGBA.
| For floats, *X* should be in the interval ``[0.0, 1.0]`` to
| return the RGBA values ``X*100`` percent along the Colormap line.
| For integers, *X* should be in the interval ``[0, Colormap.N)`` to
| return RGBA values *indexed* from the Colormap with index ``X``.
| alpha : float or array-like or None
| Alpha must be a scalar between 0 and 1, a sequence of such
| floats with shape matching X, or None.
| bytes : bool
| If False (default), the returned RGBA values will be floats in the
| interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s in the
| interval ``[0, 255]``.
|
| Returns
| -------
| Tuple of RGBA values if X is scalar, otherwise an array of
| RGBA values with a shape of ``X.shape + (4, )``.
|
| __copy__(self)
|
| __eq__(self, other)
| Return self==value.
|
| copy(self)
| Return a copy of the colormap.
|
| get_bad(self)
| Get the color for masked values.
|
| get_over(self)
| Get the color for high out-of-range values.
|
| get_under(self)
| Get the color for low out-of-range values.
|
| is_gray(self)
| Return whether the colormap is grayscale.
|
| set_bad(self, color='k', alpha=None)
| Set the color for masked values.
|
| set_extremes(self, *, bad=None, under=None, over=None)
| Set the colors for masked (*bad*) values and, when ``norm.clip =
| False``, low (*under*) and high (*over*) out-of-range values.
|
| set_over(self, color='k', alpha=None)
| Set the color for high out-of-range values.
|
| set_under(self, color='k', alpha=None)
| Set the color for low out-of-range values.
|
| with_extremes(self, *, bad=None, under=None, over=None)
| Return a copy of the colormap, for which the colors for masked (*bad*)
| values and, when ``norm.clip = False``, low (*under*) and high (*over*)
| out-of-range values, have been set accordingly.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Colormap:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Colormap:
|
| __hash__ = None
class LogNorm(Normalize)
| LogNorm(vmin=None, vmax=None, clip=False)
|
| Normalize a given value to the 0-1 range on a log scale.
|
| Method resolution order:
| LogNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None) from _make_norm_from_scale.<locals>.Norm
|
| __init__(self, vmin=None, vmax=None, clip=False) from _make_norm_from_scale.<locals>.Norm
|
| __reduce__(self) from _make_norm_from_scale.<locals>.Norm
|
| autoscale_None(self, A) from _make_norm_from_scale.<locals>.Norm
|
| inverse(self, value) from _make_norm_from_scale.<locals>.Norm
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class NoNorm(Normalize)
| NoNorm(vmin=None, vmax=None, clip=False)
|
| Dummy replacement for `Normalize`, for the case where we want to use
| indices directly in a `~matplotlib.cm.ScalarMappable`.
|
| Method resolution order:
| NoNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None)
| Normalize the data and return the normalized data.
|
| Parameters
| ----------
| value
| Data to normalize.
| clip : bool, optional
| See the description of the parameter *clip* in `.Normalize`.
|
| If ``None``, defaults to ``self.clip`` (which defaults to
| ``False``).
|
| Notes
| -----
| If not already initialized, ``self.vmin`` and ``self.vmax`` are
| initialized using ``self.autoscale_None(value)``.
|
| inverse(self, value)
| Maps the normalized value (i.e., index in the colormap) back to image
| data value.
|
| Parameters
| ----------
| value
| Normalized value.
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| __init__(self, vmin=None, vmax=None, clip=False)
| Parameters
| ----------
| vmin, vmax : float or None
| Values within the range ``[vmin, vmax]`` from the input data will be
| linearly mapped to ``[0, 1]``. If either *vmin* or *vmax* is not
| provided, they default to the minimum and maximum values of the input,
| respectively.
|
| clip : bool, default: False
| Determines the behavior for mapping values outside the range
| ``[vmin, vmax]``.
|
| If clipping is off, values outside the range ``[vmin, vmax]`` are
| also transformed, resulting in values outside ``[0, 1]``. This
| behavior is usually desirable, as colormaps can mark these *under*
| and *over* values with specific colors.
|
| If clipping is on, values below *vmin* are mapped to 0 and values
| above *vmax* are mapped to 1. Such values become indistinguishable
| from regular boundary values, which may cause misinterpretation of
| the data.
|
| Notes
| -----
| If ``vmin == vmax``, input data will be mapped to 0.
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| autoscale_None(self, A)
| If *vmin* or *vmax* are not set, use the min/max of *A* to set them.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class Normalize(builtins.object)
| Normalize(vmin=None, vmax=None, clip=False)
|
| A class which, when called, maps values within the interval
| ``[vmin, vmax]`` linearly to the interval ``[0.0, 1.0]``. The mapping of
| values outside ``[vmin, vmax]`` depends on *clip*.
|
| Examples
| --------
| ::
|
| x = [-2, -1, 0, 1, 2]
|
| norm = mpl.colors.Normalize(vmin=-1, vmax=1, clip=False)
| norm(x) # [-0.5, 0., 0.5, 1., 1.5]
| norm = mpl.colors.Normalize(vmin=-1, vmax=1, clip=True)
| norm(x) # [0., 0., 0.5, 1., 1.]
|
| See Also
| --------
| :ref:`colormapnorms`
|
| Methods defined here:
|
| __call__(self, value, clip=None)
| Normalize the data and return the normalized data.
|
| Parameters
| ----------
| value
| Data to normalize.
| clip : bool, optional
| See the description of the parameter *clip* in `.Normalize`.
|
| If ``None``, defaults to ``self.clip`` (which defaults to
| ``False``).
|
| Notes
| -----
| If not already initialized, ``self.vmin`` and ``self.vmax`` are
| initialized using ``self.autoscale_None(value)``.
|
| __init__(self, vmin=None, vmax=None, clip=False)
| Parameters
| ----------
| vmin, vmax : float or None
| Values within the range ``[vmin, vmax]`` from the input data will be
| linearly mapped to ``[0, 1]``. If either *vmin* or *vmax* is not
| provided, they default to the minimum and maximum values of the input,
| respectively.
|
| clip : bool, default: False
| Determines the behavior for mapping values outside the range
| ``[vmin, vmax]``.
|
| If clipping is off, values outside the range ``[vmin, vmax]`` are
| also transformed, resulting in values outside ``[0, 1]``. This
| behavior is usually desirable, as colormaps can mark these *under*
| and *over* values with specific colors.
|
| If clipping is on, values below *vmin* are mapped to 0 and values
| above *vmax* are mapped to 1. Such values become indistinguishable
| from regular boundary values, which may cause misinterpretation of
| the data.
|
| Notes
| -----
| If ``vmin == vmax``, input data will be mapped to 0.
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| autoscale_None(self, A)
| If *vmin* or *vmax* are not set, use the min/max of *A* to set them.
|
| inverse(self, value)
| Maps the normalized value (i.e., index in the colormap) back to image
| data value.
|
| Parameters
| ----------
| value
| Normalized value.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class PowerNorm(Normalize)
| PowerNorm(gamma, vmin=None, vmax=None, clip=False)
|
| Linearly map a given value to the 0-1 range and then apply
| a power-law normalization over that range.
|
| Parameters
| ----------
| gamma : float
| Power law exponent.
| vmin, vmax : float or None
| If *vmin* and/or *vmax* is not given, they are initialized from the
| minimum and maximum value, respectively, of the first input
| processed; i.e., ``__call__(A)`` calls ``autoscale_None(A)``.
| clip : bool, default: False
| Determines the behavior for mapping values outside the range
| ``[vmin, vmax]``.
|
| If clipping is off, values above *vmax* are transformed by the power
| function, resulting in values above 1, and values below *vmin* are linearly
| transformed resulting in values below 0. This behavior is usually desirable, as
| colormaps can mark these *under* and *over* values with specific colors.
|
| If clipping is on, values below *vmin* are mapped to 0 and values above
| *vmax* are mapped to 1. Such values become indistinguishable from
| regular boundary values, which may cause misinterpretation of the data.
|
| Notes
| -----
| The normalization formula is
|
| .. math::
|
| \left ( \frac{x - v_{min}}{v_{max} - v_{min}} \right )^{\gamma}
|
| For input values below *vmin*, gamma is set to one.
|
| Method resolution order:
| PowerNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None)
| Normalize the data and return the normalized data.
|
| Parameters
| ----------
| value
| Data to normalize.
| clip : bool, optional
| See the description of the parameter *clip* in `.Normalize`.
|
| If ``None``, defaults to ``self.clip`` (which defaults to
| ``False``).
|
| Notes
| -----
| If not already initialized, ``self.vmin`` and ``self.vmax`` are
| initialized using ``self.autoscale_None(value)``.
|
| __init__(self, gamma, vmin=None, vmax=None, clip=False)
| Parameters
| ----------
| vmin, vmax : float or None
| Values within the range ``[vmin, vmax]`` from the input data will be
| linearly mapped to ``[0, 1]``. If either *vmin* or *vmax* is not
| provided, they default to the minimum and maximum values of the input,
| respectively.
|
| clip : bool, default: False
| Determines the behavior for mapping values outside the range
| ``[vmin, vmax]``.
|
| If clipping is off, values outside the range ``[vmin, vmax]`` are
| also transformed, resulting in values outside ``[0, 1]``. This
| behavior is usually desirable, as colormaps can mark these *under*
| and *over* values with specific colors.
|
| If clipping is on, values below *vmin* are mapped to 0 and values
| above *vmax* are mapped to 1. Such values become indistinguishable
| from regular boundary values, which may cause misinterpretation of
| the data.
|
| Notes
| -----
| If ``vmin == vmax``, input data will be mapped to 0.
|
| inverse(self, value)
| Maps the normalized value (i.e., index in the colormap) back to image
| data value.
|
| Parameters
| ----------
| value
| Normalized value.
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| autoscale_None(self, A)
| If *vmin* or *vmax* are not set, use the min/max of *A* to set them.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class SymLogNorm(SymLogNorm)
| SymLogNorm(linthresh, linscale=1.0, vmin=None, vmax=None, clip=False, *, base=10)
|
| The symmetrical logarithmic scale is logarithmic in both the
| positive and negative directions from the origin.
|
| Since the values close to zero tend toward infinity, there is a
| need to have a range around zero that is linear. The parameter
| *linthresh* allows the user to specify the size of this range
| (-*linthresh*, *linthresh*).
|
| Parameters
| ----------
| linthresh : float
| The range within which the plot is linear (to avoid having the plot
| go to infinity around zero).
| linscale : float, default: 1
| This allows the linear range (-*linthresh* to *linthresh*) to be
| stretched relative to the logarithmic range. Its value is the
| number of decades to use for each half of the linear range. For
| example, when *linscale* == 1.0 (the default), the space used for
| the positive and negative halves of the linear range will be equal
| to one decade in the logarithmic range.
| base : float, default: 10
|
| Method resolution order:
| SymLogNorm
| SymLogNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None) from _make_norm_from_scale.<locals>.Norm
|
| __init__(self, linthresh, linscale=1.0, vmin=None, vmax=None, clip=False, *, base=10) from _make_norm_from_scale.<locals>.Norm
|
| __reduce__(self) from _make_norm_from_scale.<locals>.Norm
|
| autoscale_None(self, A) from _make_norm_from_scale.<locals>.Norm
|
| inverse(self, value) from _make_norm_from_scale.<locals>.Norm
|
| ----------------------------------------------------------------------
| Data descriptors inherited from SymLogNorm:
|
| linthresh
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
class TwoSlopeNorm(Normalize)
| TwoSlopeNorm(vcenter, vmin=None, vmax=None)
|
| Method resolution order:
| TwoSlopeNorm
| Normalize
| builtins.object
|
| Methods defined here:
|
| __call__(self, value, clip=None)
| Map value to the interval [0, 1]. The *clip* argument is unused.
|
| __init__(self, vcenter, vmin=None, vmax=None)
| Normalize data with a set center.
|
| Useful when mapping data with an unequal rates of change around a
| conceptual center, e.g., data that range from -2 to 4, with 0 as
| the midpoint.
|
| Parameters
| ----------
| vcenter : float
| The data value that defines ``0.5`` in the normalization.
| vmin : float, optional
| The data value that defines ``0.0`` in the normalization.
| Defaults to the min value of the dataset.
| vmax : float, optional
| The data value that defines ``1.0`` in the normalization.
| Defaults to the max value of the dataset.
|
| Examples
| --------
| This maps data value -4000 to 0., 0 to 0.5, and +10000 to 1.0; data
| between is linearly interpolated::
|
| >>> import matplotlib.colors as mcolors
| >>> offset = mcolors.TwoSlopeNorm(vmin=-4000.,
| ... vcenter=0., vmax=10000)
| >>> data = [-4000., -2000., 0., 2500., 5000., 7500., 10000.]
| >>> offset(data)
| array([0., 0.25, 0.5, 0.625, 0.75, 0.875, 1.0])
|
| autoscale_None(self, A)
| Get vmin and vmax.
|
| If vcenter isn't in the range [vmin, vmax], either vmin or vmax
| is expanded so that vcenter lies in the middle of the modified range
| [vmin, vmax].
|
| inverse(self, value)
| Maps the normalized value (i.e., index in the colormap) back to image
| data value.
|
| Parameters
| ----------
| value
| Normalized value.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| vcenter
|
| ----------------------------------------------------------------------
| Methods inherited from Normalize:
|
| autoscale(self, A)
| Set *vmin*, *vmax* to min, max of *A*.
|
| scaled(self)
| Return whether *vmin* and *vmax* are both set.
|
| ----------------------------------------------------------------------
| Static methods inherited from Normalize:
|
| process_value(value)
| Homogenize the input *value* for easy and efficient normalization.
|
| *value* can be a scalar or sequence.
|
| Parameters
| ----------
| value
| Data to normalize.
|
| Returns
| -------
| result : masked array
| Masked array with the same shape as *value*.
| is_scalar : bool
| Whether *value* is a scalar.
|
| Notes
| -----
| Float dtypes are preserved; integer types with two bytes or smaller are
| converted to np.float32, and larger types are converted to np.float64.
| Preserving float32 when possible, and using in-place operations,
| greatly improves speed for large arrays.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Normalize:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| clip
|
| vmax
|
| vmin
FUNCTIONS
from_levels_and_colors(levels, colors, extend='neither')
A helper routine to generate a cmap and a norm instance which
behave similar to contourf's levels and colors arguments.
Parameters
----------
levels : sequence of numbers
The quantization levels used to construct the `BoundaryNorm`.
Value ``v`` is quantized to level ``i`` if ``lev[i] <= v < lev[i+1]``.
colors : sequence of colors
The fill color to use for each level. If *extend* is "neither" there
must be ``n_level - 1`` colors. For an *extend* of "min" or "max" add
one extra color, and for an *extend* of "both" add two colors.
extend : {'neither', 'min', 'max', 'both'}, optional
The behaviour when a value falls out of range of the given levels.
See `~.Axes.contourf` for details.
Returns
-------
cmap : `~matplotlib.colors.Colormap`
norm : `~matplotlib.colors.Normalize`
get_named_colors_mapping()
Return the global mapping of names to named colors.
hex2color = to_rgb(c)
Convert *c* to an RGB color, silently dropping the alpha channel.
hsv_to_rgb(hsv)
Convert HSV values to RGB.
Parameters
----------
hsv : (..., 3) array-like
All values assumed to be in range [0, 1]
Returns
-------
(..., 3) `~numpy.ndarray`
Colors converted to RGB values in range [0, 1]
is_color_like(c)
Return whether *c* can be interpreted as an RGB(A) color.
make_norm_from_scale(scale_cls, base_norm_cls=None, *, init=None)
Decorator for building a `.Normalize` subclass from a `~.scale.ScaleBase`
subclass.
After ::
@make_norm_from_scale(scale_cls)
class norm_cls(Normalize):
...
*norm_cls* is filled with methods so that normalization computations are
forwarded to *scale_cls* (i.e., *scale_cls* is the scale that would be used
for the colorbar of a mappable normalized with *norm_cls*).
If *init* is not passed, then the constructor signature of *norm_cls*
will be ``norm_cls(vmin=None, vmax=None, clip=False)``; these three
parameters will be forwarded to the base class (``Normalize.__init__``),
and a *scale_cls* object will be initialized with no arguments (other than
a dummy axis).
If the *scale_cls* constructor takes additional parameters, then *init*
should be passed to `make_norm_from_scale`. It is a callable which is
*only* used for its signature. First, this signature will become the
signature of *norm_cls*. Second, the *norm_cls* constructor will bind the
parameters passed to it using this signature, extract the bound *vmin*,
*vmax*, and *clip* values, pass those to ``Normalize.__init__``, and
forward the remaining bound values (including any defaults defined by the
signature) to the *scale_cls* constructor.
rgb2hex = to_hex(c, keep_alpha=False)
Convert *c* to a hex color.
Parameters
----------
c : :ref:`color <colors_def>` or `numpy.ma.masked`
keep_alpha : bool, default: False
If False, use the ``#rrggbb`` format, otherwise use ``#rrggbbaa``.
Returns
-------
str
``#rrggbb`` or ``#rrggbbaa`` hex color string
rgb_to_hsv(arr)
Convert an array of float RGB values (in the range [0, 1]) to HSV values.
Parameters
----------
arr : (..., 3) array-like
All values must be in the range [0, 1]
Returns
-------
(..., 3) `~numpy.ndarray`
Colors converted to HSV values in range [0, 1]
same_color(c1, c2)
Return whether the colors *c1* and *c2* are the same.
*c1*, *c2* can be single colors or lists/arrays of colors.
to_hex(c, keep_alpha=False)
Convert *c* to a hex color.
Parameters
----------
c : :ref:`color <colors_def>` or `numpy.ma.masked`
keep_alpha : bool, default: False
If False, use the ``#rrggbb`` format, otherwise use ``#rrggbbaa``.
Returns
-------
str
``#rrggbb`` or ``#rrggbbaa`` hex color string
to_rgb(c)
Convert *c* to an RGB color, silently dropping the alpha channel.
to_rgba(c, alpha=None)
Convert *c* to an RGBA color.
Parameters
----------
c : Matplotlib color or ``np.ma.masked``
alpha : float, optional
If *alpha* is given, force the alpha value of the returned RGBA tuple
to *alpha*.
If None, the alpha value from *c* is used. If *c* does not have an
alpha channel, then alpha defaults to 1.
*alpha* is ignored for the color value ``"none"`` (case-insensitive),
which always maps to ``(0, 0, 0, 0)``.
Returns
-------
tuple
Tuple of floats ``(r, g, b, a)``, where each channel (red, green, blue,
alpha) can assume values between 0 and 1.
to_rgba_array(c, alpha=None)
Convert *c* to a (n, 4) array of RGBA colors.
Parameters
----------
c : Matplotlib color or array of colors
If *c* is a masked array, an `~numpy.ndarray` is returned with a
(0, 0, 0, 0) row for each masked value or row in *c*.
alpha : float or sequence of floats, optional
If *alpha* is given, force the alpha value of the returned RGBA tuple
to *alpha*.
If None, the alpha value from *c* is used. If *c* does not have an
alpha channel, then alpha defaults to 1.
*alpha* is ignored for the color value ``"none"`` (case-insensitive),
which always maps to ``(0, 0, 0, 0)``.
If *alpha* is a sequence and *c* is a single color, *c* will be
repeated to match the length of *alpha*.
Returns
-------
array
(n, 4) array of RGBA colors, where each channel (red, green, blue,
alpha) can assume values between 0 and 1.
DATA
BASE_COLORS = {'b': (0, 0, 1), 'c': (0, 0.75, 0.75), 'g': (0, 0.5, 0),...
CSS4_COLORS = {'aliceblue': '#F0F8FF', 'antiquewhite': '#FAEBD7', 'aqu...
TABLEAU_COLORS = {'tab:blue': '#1f77b4', 'tab:brown': '#8c564b', 'tab:...
XKCD_COLORS = {'xkcd:acid green': '#8ffe09', 'xkcd:adobe': '#bd6c48', ...
cnames = {'aliceblue': '#F0F8FF', 'antiquewhite': '#FAEBD7', 'aqua': '...
colorConverter = <matplotlib.colors.ColorConverter object>
hexColorPattern = re.compile('\\A#[a-fA-F0-9]{6}\\Z')
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\colors.py
matplotlib.contextlib
Python Library Documentation: module contextlib
NAME
contextlib - Utilities for with-statement contexts. See PEP 343.
MODULE REFERENCE
https://docs.python.org/3.12/library/contextlib.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
CLASSES
abc.ABC(builtins.object)
AbstractAsyncContextManager
AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager)
aclosing
AbstractContextManager
ExitStack(_BaseExitStack, AbstractContextManager)
chdir
closing
nullcontext(AbstractContextManager, AbstractAsyncContextManager)
suppress
builtins.object
ContextDecorator
_BaseExitStack(builtins.object)
AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager)
ExitStack(_BaseExitStack, AbstractContextManager)
_RedirectStream(AbstractContextManager)
redirect_stderr
redirect_stdout
class AbstractAsyncContextManager(abc.ABC)
| An abstract base class for asynchronous context managers.
|
| Method resolution order:
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, exc_type, exc_value, traceback)
| Raise any exception triggered within the runtime context.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__aexit__'})
class AbstractContextManager(abc.ABC)
| An abstract base class for context managers.
|
| Method resolution order:
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exc_type, exc_value, traceback)
| Raise any exception triggered within the runtime context.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__exit__'})
class AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager)
| Async context manager for dynamic management of a stack of exit
| callbacks.
|
| For example:
| async with AsyncExitStack() as stack:
| connections = [await stack.enter_async_context(get_connection())
| for i in range(5)]
| # All opened connections will automatically be released at the
| # end of the async with statement, even if attempts to open a
| # connection later in the list raise an exception.
|
| Method resolution order:
| AsyncExitStack
| _BaseExitStack
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, *exc_details)
| Raise any exception triggered within the runtime context.
|
| async aclose(self)
| Immediately unwind the context stack.
|
| async enter_async_context(self, cm)
| Enters the supplied async context manager.
|
| If successful, also pushes its __aexit__ method as a callback and
| returns the result of the __aenter__ method.
|
| push_async_callback(self, callback, /, *args, **kwds)
| Registers an arbitrary coroutine function and arguments.
|
| Cannot suppress exceptions.
|
| push_async_exit(self, exit)
| Registers a coroutine function with the standard __aexit__ method
| signature.
|
| Can suppress exceptions the same way __aexit__ method can.
| Also accepts any object with an __aexit__ method (registering a call
| to the method instead of the object itself).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from _BaseExitStack:
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| callback(self, callback, /, *args, **kwds)
| Registers an arbitrary callback and arguments.
|
| Cannot suppress exceptions.
|
| enter_context(self, cm)
| Enters the supplied context manager.
|
| If successful, also pushes its __exit__ method as a callback and
| returns the result of the __enter__ method.
|
| pop_all(self)
| Preserve the context stack by transferring it to a new instance.
|
| push(self, exit)
| Registers a callback with the standard __exit__ method signature.
|
| Can suppress exceptions the same way __exit__ method can.
| Also accepts any object with an __exit__ method (registering a call
| to the method instead of the object itself).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _BaseExitStack:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractAsyncContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
class ContextDecorator(builtins.object)
| A base class or mixin that enables context managers to work as decorators.
|
| Methods defined here:
|
| __call__(self, func)
| Call self as a function.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ExitStack(_BaseExitStack, AbstractContextManager)
| Context manager for dynamic management of a stack of exit callbacks.
|
| For example:
| with ExitStack() as stack:
| files = [stack.enter_context(open(fname)) for fname in filenames]
| # All opened files will automatically be closed at the end of
| # the with statement, even if attempts to open files later
| # in the list raise an exception.
|
| Method resolution order:
| ExitStack
| _BaseExitStack
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *exc_details)
| Raise any exception triggered within the runtime context.
|
| close(self)
| Immediately unwind the context stack.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from _BaseExitStack:
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| callback(self, callback, /, *args, **kwds)
| Registers an arbitrary callback and arguments.
|
| Cannot suppress exceptions.
|
| enter_context(self, cm)
| Enters the supplied context manager.
|
| If successful, also pushes its __exit__ method as a callback and
| returns the result of the __enter__ method.
|
| pop_all(self)
| Preserve the context stack by transferring it to a new instance.
|
| push(self, exit)
| Registers a callback with the standard __exit__ method signature.
|
| Can suppress exceptions the same way __exit__ method can.
| Also accepts any object with an __exit__ method (registering a call
| to the method instead of the object itself).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _BaseExitStack:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
class aclosing(AbstractAsyncContextManager)
| aclosing(thing)
|
| Async context manager for safely finalizing an asynchronously cleaned-up
| resource such as an async generator, calling its ``aclose()`` method.
|
| Code like this:
|
| async with aclosing(<module>.fetch(<arguments>)) as agen:
| <block>
|
| is equivalent to this:
|
| agen = <module>.fetch(<arguments>)
| try:
| <block>
| finally:
| await agen.aclose()
|
| Method resolution order:
| aclosing
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, *exc_info)
| Raise any exception triggered within the runtime context.
|
| __init__(self, thing)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractAsyncContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractAsyncContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class chdir(AbstractContextManager)
| chdir(path)
|
| Non thread-safe context manager to change the current working directory.
|
| Method resolution order:
| chdir
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *excinfo)
| Raise any exception triggered within the runtime context.
|
| __init__(self, path)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class closing(AbstractContextManager)
| closing(thing)
|
| Context to automatically close something at the end of a block.
|
| Code like this:
|
| with closing(<module>.open(<arguments>)) as f:
| <block>
|
| is equivalent to this:
|
| f = <module>.open(<arguments>)
| try:
| <block>
| finally:
| f.close()
|
| Method resolution order:
| closing
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *exc_info)
| Raise any exception triggered within the runtime context.
|
| __init__(self, thing)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class nullcontext(AbstractContextManager, AbstractAsyncContextManager)
| nullcontext(enter_result=None)
|
| Context manager that does no additional processing.
|
| Used as a stand-in for a normal context manager, when a particular
| block of code is only sometimes used with a normal context manager:
|
| cm = optional_cm if condition else nullcontext()
| with cm:
| # Perform operation, using optional_cm if condition is True
|
| Method resolution order:
| nullcontext
| AbstractContextManager
| AbstractAsyncContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| async __aenter__(self)
| Return `self` upon entering the runtime context.
|
| async __aexit__(self, *excinfo)
| Raise any exception triggered within the runtime context.
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, *excinfo)
| Raise any exception triggered within the runtime context.
|
| __init__(self, enter_result=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class redirect_stderr(_RedirectStream)
| redirect_stderr(new_target)
|
| Context manager for temporarily redirecting stderr to another file.
|
| Method resolution order:
| redirect_stderr
| _RedirectStream
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from _RedirectStream:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exctype, excinst, exctb)
| Raise any exception triggered within the runtime context.
|
| __init__(self, new_target)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class redirect_stdout(_RedirectStream)
| redirect_stdout(new_target)
|
| Context manager for temporarily redirecting stdout to another file.
|
| # How to send help() to stderr
| with redirect_stdout(sys.stderr):
| help(dir)
|
| # How to write help() to a file
| with open('help.txt', 'w') as f:
| with redirect_stdout(f):
| help(pow)
|
| Method resolution order:
| redirect_stdout
| _RedirectStream
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from _RedirectStream:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exctype, excinst, exctb)
| Raise any exception triggered within the runtime context.
|
| __init__(self, new_target)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class suppress(AbstractContextManager)
| suppress(*exceptions)
|
| Context manager to suppress specified exceptions
|
| After the exception is suppressed, execution proceeds with the next
| statement following the with statement.
|
| with suppress(FileNotFoundError):
| os.remove(somefile)
| # Execution still resumes here if the file was already removed
|
| Method resolution order:
| suppress
| AbstractContextManager
| abc.ABC
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
| Return `self` upon entering the runtime context.
|
| __exit__(self, exctype, excinst, exctb)
| Raise any exception triggered within the runtime context.
|
| __init__(self, *exceptions)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Class methods inherited from AbstractContextManager:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| __subclasshook__(C)
| 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).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from AbstractContextManager:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
asynccontextmanager(func)
@asynccontextmanager decorator.
Typical usage:
@asynccontextmanager
async def some_async_generator(<arguments>):
<setup>
try:
yield <value>
finally:
<cleanup>
This makes this:
async with some_async_generator(<arguments>) as <variable>:
<body>
equivalent to this:
<setup>
try:
<variable> = <value>
<body>
finally:
<cleanup>
contextmanager(func)
@contextmanager decorator.
Typical usage:
@contextmanager
def some_generator(<arguments>):
<setup>
try:
yield <value>
finally:
<cleanup>
This makes this:
with some_generator(<arguments>) as <variable>:
<body>
equivalent to this:
<setup>
try:
<variable> = <value>
<body>
finally:
<cleanup>
DATA
__all__ = ['asynccontextmanager', 'contextmanager', 'closing', 'nullco...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\contextlib.py
matplotlib.cycler
Python Library Documentation: function cycler in module matplotlib.rcsetup
cycler(*args, **kwargs)
Create a `~cycler.Cycler` object much like :func:`cycler.cycler`,
but includes input validation.
Call signatures::
cycler(cycler)
cycler(label=values[, label2=values2[, ...]])
cycler(label, values)
Form 1 copies a given `~cycler.Cycler` object.
Form 2 creates a `~cycler.Cycler` which cycles over one or more
properties simultaneously. If multiple properties are given, their
value lists must have the same length.
Form 3 creates a `~cycler.Cycler` for a single property. This form
exists for compatibility with the original cycler. Its use is
discouraged in favor of the kwarg form, i.e. ``cycler(label=values)``.
Parameters
----------
cycler : Cycler
Copy constructor for Cycler.
label : str
The property key. Must be a valid `.Artist` property.
For example, 'color' or 'linestyle'. Aliases are allowed,
such as 'c' for 'color' and 'lw' for 'linewidth'.
values : iterable
Finite-length iterable of the property values. These values
are validated and will raise a ValueError if invalid.
Returns
-------
Cycler
A new :class:`~cycler.Cycler` for the given properties.
Examples
--------
Creating a cycler for a single property:
>>> c = cycler(color=['red', 'green', 'blue'])
Creating a cycler for simultaneously cycling over multiple properties
(e.g. red circle, green plus, blue cross):
>>> c = cycler(color=['red', 'green', 'blue'],
... marker=['o', '+', 'x'])
matplotlib.defaultParams
Python Library Documentation: dict object
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Built-in subclasses:
| StgDict
|
| Methods defined here:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the dict keys.
|
| __ror__(self, value, /)
| Return value|self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| popitem(self, /)
| Remove and return a (key, value) pair as a 2-tuple.
|
| Pairs are returned in LIFO (last-in, first-out) order.
| Raises KeyError if the dict is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
matplotlib.ft2font
Python Library Documentation: module matplotlib.ft2font in matplotlib
NAME
matplotlib.ft2font
CLASSES
builtins.object
FT2Font
FT2Image
class FT2Font(builtins.object)
| FT2Font(filename, hinting_factor=8, *, _fallback_list=None, _kerning_factor=0)
|
| Create a new FT2Font object.
|
| Parameters
| ----------
| filename : str or file-like
| The source of the font data in a format (ttf or ttc) that FreeType can read
|
| hinting_factor : int, optional
| Must be positive. Used to scale the hinting in the x-direction
| _fallback_list : list of FT2Font, optional
| A list of FT2Font objects used to find missing glyphs.
|
| .. warning::
| This API is both private and provisional: do not use it directly
|
| _kerning_factor : int, optional
| Used to adjust the degree of kerning.
|
| .. warning::
| This API is private: do not use it directly
|
| Attributes
| ----------
| num_faces : int
| Number of faces in file.
| face_flags, style_flags : int
| Face and style flags; see the ft2font constants.
| num_glyphs : int
| Number of glyphs in the face.
| family_name, style_name : str
| Face family and style name.
| num_fixed_sizes : int
| Number of bitmap in the face.
| scalable : bool
| Whether face is scalable; attributes after this one are only
| defined for scalable faces.
| bbox : tuple[int, int, int, int]
| Face global bounding box (xmin, ymin, xmax, ymax).
| units_per_EM : int
| Number of font units covered by the EM.
| ascender, descender : int
| Ascender and descender in 26.6 units.
| height : int
| Height in 26.6 units; used to compute a default line spacing
| (baseline-to-baseline distance).
| max_advance_width, max_advance_height : int
| Maximum horizontal and vertical cursor advance for all glyphs.
| underline_position, underline_thickness : int
| Vertical position and thickness of the underline bar.
| postscript_name : str
| PostScript name of the font.
|
| Methods defined here:
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| clear(self)
| Clear all the glyphs, reset for a new call to `.set_text`.
|
| draw_glyph_to_bitmap(self, image, x, y, glyph, antialiased=True)
| Draw a single glyph to the bitmap at pixel locations x, y
| Note it is your responsibility to set up the bitmap manually
| with ``set_bitmap_size(w, h)`` before this call is made.
|
| If you want automatic layout, use `.set_text` in combinations with
| `.draw_glyphs_to_bitmap`. This function is instead intended for people
| who want to render individual glyphs (e.g., returned by `.load_char`)
| at precise locations.
|
| draw_glyphs_to_bitmap(self, antialiased=True)
| Draw the glyphs that were loaded by `.set_text` to the bitmap.
| The bitmap size will be automatically set to include the glyphs.
|
| get_bitmap_offset(self)
| Get the (x, y) offset in 26.6 subpixels for the bitmap if ink hangs left or below (0, 0).
| Since Matplotlib only supports left-to-right text, y is always 0.
|
| get_char_index(self, codepoint)
| Return the glyph index corresponding to a character *codepoint*.
|
| get_charmap(self)
| Return a dict that maps the character codes of the selected charmap
| (Unicode by default) to their corresponding glyph indices.
|
| get_descent(self)
| Get the descent in 26.6 subpixels of the current string set by `.set_text`.
| The rotation of the string is accounted for. To get the descent
| in pixels, divide this value by 64.
|
| get_glyph_name(self, index)
| Retrieve the ASCII name of a given glyph *index* in a face.
|
| Due to Matplotlib's internal design, for fonts that do not contain glyph
| names (per FT_FACE_FLAG_GLYPH_NAMES), this returns a made-up name which
| does *not* roundtrip through `.get_name_index`.
|
| get_image(self)
| Return the underlying image buffer for this font object.
|
| get_kerning(self, left, right, mode)
| Get the kerning between *left* and *right* glyph indices.
| *mode* is a kerning mode constant:
|
| - KERNING_DEFAULT - Return scaled and grid-fitted kerning distances
| - KERNING_UNFITTED - Return scaled but un-grid-fitted kerning distances
| - KERNING_UNSCALED - Return the kerning vector in original font units
|
| get_name_index(self, name)
| Return the glyph index of a given glyph *name*.
| The glyph index 0 means 'undefined character code'.
|
| get_num_glyphs(self)
| Return the number of loaded glyphs.
|
| get_path(self)
| Get the path data from the currently loaded glyph as a tuple of vertices, codes.
|
| get_ps_font_info(self)
| Return the information in the PS Font Info structure.
|
| get_sfnt(self)
| Load the entire SFNT names table, as a dict whose keys are
| (platform-ID, ISO-encoding-scheme, language-code, and description)
| tuples.
|
| get_sfnt_table(self, name)
| Return one of the following SFNT tables: head, maxp, OS/2, hhea, vhea, post, or pclt.
|
| get_width_height(self)
| Get the width and height in 26.6 subpixels of the current string set by `.set_text`.
| The rotation of the string is accounted for. To get width and height
| in pixels, divide these values by 64.
|
| get_xys(self, antialiased=True)
| Get the xy locations of the current glyphs.
|
| .. deprecated:: 3.8
|
| load_char(self, charcode, flags=32)
| Load character with *charcode* in current fontfile and set glyph.
| *flags* can be a bitwise-or of the LOAD_XXX constants;
| the default value is LOAD_FORCE_AUTOHINT.
| Return value is a Glyph object, with attributes
|
| - width: glyph width
| - height: glyph height
| - bbox: the glyph bbox (xmin, ymin, xmax, ymax)
| - horiBearingX: left side bearing in horizontal layouts
| - horiBearingY: top side bearing in horizontal layouts
| - horiAdvance: advance width for horizontal layout
| - vertBearingX: left side bearing in vertical layouts
| - vertBearingY: top side bearing in vertical layouts
| - vertAdvance: advance height for vertical layout
|
| load_glyph(self, glyphindex, flags=32)
| Load character with *glyphindex* in current fontfile and set glyph.
| *flags* can be a bitwise-or of the LOAD_XXX constants;
| the default value is LOAD_FORCE_AUTOHINT.
| Return value is a Glyph object, with attributes
|
| - width: glyph width
| - height: glyph height
| - bbox: the glyph bbox (xmin, ymin, xmax, ymax)
| - horiBearingX: left side bearing in horizontal layouts
| - horiBearingY: top side bearing in horizontal layouts
| - horiAdvance: advance width for horizontal layout
| - vertBearingX: left side bearing in vertical layouts
| - vertBearingY: top side bearing in vertical layouts
| - vertAdvance: advance height for vertical layout
|
| select_charmap(self, i)
| Select a charmap by its FT_Encoding number.
|
| set_charmap(self, i)
| Make the i-th charmap current.
|
| set_size(self, ptsize, dpi)
| Set the point size and dpi of the text.
|
| set_text(self, string, angle=0.0, flags=32)
| Set the text *string* and *angle*.
| *flags* can be a bitwise-or of the LOAD_XXX constants;
| the default value is LOAD_FORCE_AUTOHINT.
| You must call this before `.draw_glyphs_to_bitmap`.
| A sequence of x,y positions is returned.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| ascender
|
| bbox
|
| descender
|
| face_flags
|
| family_name
|
| fname
|
| height
|
| max_advance_height
|
| max_advance_width
|
| num_charmaps
|
| num_faces
|
| num_fixed_sizes
|
| num_glyphs
|
| postscript_name
|
| scalable
|
| style_flags
|
| style_name
|
| underline_position
|
| underline_thickness
|
| units_per_EM
class FT2Image(builtins.object)
| Methods defined here:
|
| __buffer__(self, flags, /)
| Return a buffer object that exposes the underlying memory of the object.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| draw_rect(self, x0, y0, x1, y1)
| Draw an empty rectangle to the image.
|
| .. deprecated:: 3.8
|
| draw_rect_filled(self, x0, y0, x1, y1)
| Draw a filled rectangle to the image.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
DATA
BOLD = 2
EXTERNAL_STREAM = 1024
FAST_GLYPHS = 128
FIXED_SIZES = 2
FIXED_WIDTH = 4
GLYPH_NAMES = 512
HORIZONTAL = 16
ITALIC = 1
KERNING = 64
KERNING_DEFAULT = 0
KERNING_UNFITTED = 1
KERNING_UNSCALED = 2
LOAD_CROP_BITMAP = 64
LOAD_DEFAULT = 0
LOAD_FORCE_AUTOHINT = 32
LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH = 512
LOAD_IGNORE_TRANSFORM = 2048
LOAD_LINEAR_DESIGN = 8192
LOAD_MONOCHROME = 4096
LOAD_NO_AUTOHINT = 32768
LOAD_NO_BITMAP = 8
LOAD_NO_HINTING = 2
LOAD_NO_RECURSE = 1024
LOAD_NO_SCALE = 1
LOAD_PEDANTIC = 128
LOAD_RENDER = 4
LOAD_TARGET_LCD = 196608
LOAD_TARGET_LCD_V = 262144
LOAD_TARGET_LIGHT = 65536
LOAD_TARGET_MONO = 131072
LOAD_TARGET_NORMAL = 0
LOAD_VERTICAL_LAYOUT = 16
MULTIPLE_MASTERS = 256
SCALABLE = 1
SFNT = 8
VERTICAL = 32
__freetype_build_type__ = 'local'
__freetype_version__ = '2.6.1'
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\ft2font.cp312-win_amd64.pyd
matplotlib.functools
Python Library Documentation: module functools
NAME
functools - functools.py - Tools for working with functions and callable objects
MODULE REFERENCE
https://docs.python.org/3.12/library/functools.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
CLASSES
builtins.object
cached_property
partial
partialmethod
singledispatchmethod
class cached_property(builtins.object)
| cached_property(func)
|
| Methods defined here:
|
| __get__(self, instance, owner=None)
|
| __init__(self, func)
| Initialize self. See help(type(self)) for accurate signature.
|
| __set_name__(self, owner, name)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class partial(builtins.object)
| partial(func, *args, **keywords) - new function with partial application
| of the given arguments and keywords.
|
| Methods defined here:
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setattr__(self, name, value, /)
| Implement setattr(self, name, value).
|
| __setstate__(...)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
|
| __vectorcalloffset__
|
| args
| tuple of arguments to future partial calls
|
| func
| function object to use in future partial calls
|
| keywords
| dictionary of keyword arguments to future partial calls
class partialmethod(builtins.object)
| partialmethod(func, /, *args, **keywords)
|
| Method descriptor with partial application of the given arguments
| and keywords.
|
| Supports wrapping existing descriptors and handles non-descriptor
| callables as instance methods.
|
| Methods defined here:
|
| __get__(self, obj, cls=None)
|
| __init__(self, func, /, *args, **keywords)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| __isabstractmethod__
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class singledispatchmethod(builtins.object)
| singledispatchmethod(func)
|
| Single-dispatch generic method descriptor.
|
| Supports wrapping existing descriptors and handles non-descriptor
| callables as instance methods.
|
| Methods defined here:
|
| __get__(self, obj, cls=None)
|
| __init__(self, func)
| Initialize self. See help(type(self)) for accurate signature.
|
| register(self, cls, method=None)
| generic_method.register(cls, func) -> func
|
| Registers a new implementation for the given *cls* on a *generic_method*.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| __isabstractmethod__
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
cache(user_function, /)
Simple lightweight unbounded cache. Sometimes called "memoize".
cmp_to_key(mycmp)
Convert a cmp= function into a key= function.
mycmp
Function that compares two objects.
lru_cache(maxsize=128, typed=False)
Least-recently-used cache decorator.
If *maxsize* is set to None, the LRU features are disabled and the cache
can grow without bound.
If *typed* is True, arguments of different types will be cached separately.
For example, f(3.0) and f(3) will be treated as distinct calls with
distinct results.
Arguments to the cached function must be hashable.
View the cache statistics named tuple (hits, misses, maxsize, currsize)
with f.cache_info(). Clear the cache and statistics with f.cache_clear().
Access the underlying function with f.__wrapped__.
See: https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)
reduce(...)
reduce(function, iterable[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence
or iterable, from left to right, so as to reduce the iterable to a single
value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the iterable in the calculation, and serves as a default when the
iterable is empty.
singledispatch(func)
Single-dispatch generic function decorator.
Transforms a function into a generic function, which can have different
behaviours depending upon the type of its first argument. The decorated
function acts as the default implementation, and additional
implementations can be registered using the register() attribute of the
generic function.
total_ordering(cls)
Class decorator that fills in missing ordering methods
update_wrapper(wrapper, wrapped, assigned=('__module__', '__name__', '__qualname__', '__doc__', '__annotations__', '__type_params__'), updated=('__dict__',))
Update a wrapper function to look like the wrapped function
wrapper is the function to be updated
wrapped is the original function
assigned is a tuple naming the attributes assigned directly
from the wrapped function to the wrapper function (defaults to
functools.WRAPPER_ASSIGNMENTS)
updated is a tuple naming the attributes of the wrapper that
are updated with the corresponding attribute from the wrapped
function (defaults to functools.WRAPPER_UPDATES)
wraps(wrapped, assigned=('__module__', '__name__', '__qualname__', '__doc__', '__annotations__', '__type_params__'), updated=('__dict__',))
Decorator factory to apply update_wrapper() to a wrapper function
Returns a decorator that invokes update_wrapper() with the decorated
function as the wrapper argument and the arguments to wraps() as the
remaining arguments. Default arguments are as for update_wrapper().
This is a convenience function to simplify applying partial() to
update_wrapper().
DATA
WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__do...
WRAPPER_UPDATES = ('__dict__',)
__all__ = ['update_wrapper', 'wraps', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\functools.py
matplotlib.get_backend
Python Library Documentation: function get_backend in module matplotlib
get_backend()
Return the name of the current backend.
See Also
--------
matplotlib.use
matplotlib.get_cachedir
Python Library Documentation: function get_cachedir in module matplotlib
get_cachedir()
Return the string path of the cache directory.
The procedure used to find the directory is the same as for
`get_configdir`, except using ``$XDG_CACHE_HOME``/``$HOME/.cache`` instead.
matplotlib.get_configdir
Python Library Documentation: function get_configdir in module matplotlib
get_configdir()
Return the string path of 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.
matplotlib.get_data_path
Python Library Documentation: function get_data_path in module matplotlib
get_data_path()
Return the path to Matplotlib data.
matplotlib.importlib
Python Library Documentation: package importlib
NAME
importlib - A pure Python implementation of import.
MODULE REFERENCE
https://docs.python.org/3.12/library/importlib.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
PACKAGE CONTENTS
_abc
_bootstrap
_bootstrap_external
abc
machinery
metadata (package)
readers
resources (package)
simple
util
FUNCTIONS
__import__(name, globals=None, locals=None, fromlist=(), level=0)
Import a module.
The 'globals' argument is used to infer where the import is occurring from
to handle relative imports. The 'locals' argument is ignored. The
'fromlist' argument specifies what should exist as attributes on the module
being imported (e.g. ``from module import <fromlist>``). The 'level'
argument represents the package location to import from in a relative
import (e.g. ``from ..pkg import mod`` would have a 'level' of 2).
import_module(name, package=None)
Import a module.
The 'package' argument is required when performing a relative import. It
specifies the package to use as the anchor point from which to resolve the
relative import to an absolute import.
invalidate_caches()
Call the invalidate_caches() method on all meta path finders stored in
sys.meta_path (where implemented).
reload(module)
Reload the module and return it.
The module must have been successfully imported before.
DATA
__all__ = ['__import__', 'import_module', 'invalidate_caches', 'reload...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\importlib\__init__.py
matplotlib.inspect
Python Library Documentation: module inspect
NAME
inspect - Get useful information from live Python objects.
MODULE REFERENCE
https://docs.python.org/3.12/library/inspect.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module encapsulates the interface provided by the internal special
attributes (co_*, im_*, tb_*, etc.) in a friendlier fashion.
It also provides some help for examining source code and class layout.
Here are some of the useful functions provided by this module:
ismodule(), isclass(), ismethod(), isfunction(), isgeneratorfunction(),
isgenerator(), istraceback(), isframe(), iscode(), isbuiltin(),
isroutine() - check object types
getmembers() - get members of an object that satisfy a given condition
getfile(), getsourcefile(), getsource() - find an object's source code
getdoc(), getcomments() - get documentation on an object
getmodule() - determine the module that an object came from
getclasstree() - arrange classes so as to represent their hierarchy
getargvalues(), getcallargs() - get info about function arguments
getfullargspec() - same, with support for Python 3 features
formatargvalues() - format an argument spec
getouterframes(), getinnerframes() - get info about frames
currentframe() - get the current stack frame
stack(), trace() - get info about frames on the stack or in a traceback
signature() - get a Signature object for the callable
get_annotations() - safely compute an object's annotations
CLASSES
builtins.Exception(builtins.BaseException)
ClassFoundException
EndOfBlock
builtins.object
BlockFinder
BoundArguments
Parameter
Signature
builtins.tuple(builtins.object)
ArgInfo
Arguments
Attribute
ClosureVars
FullArgSpec
enum.IntFlag(builtins.int, enum.ReprEnum, enum.Flag)
BufferFlags
_FrameInfo(builtins.tuple)
FrameInfo
_Traceback(builtins.tuple)
Traceback
class ArgInfo(builtins.tuple)
| ArgInfo(args, varargs, keywords, locals)
|
| ArgInfo(args, varargs, keywords, locals)
|
| Method resolution order:
| ArgInfo
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.ArgInfo
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.ArgInfo
| Return a nicely formatted representation string
|
| _asdict(self) from collections.ArgInfo
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.ArgInfo
| Return a new ArgInfo object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.ArgInfo
| Make a new ArgInfo object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, args, varargs, keywords, locals) from namedtuple_ArgInfo.ArgInfo
| Create new instance of ArgInfo(args, varargs, keywords, locals)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| args
| Alias for field number 0
|
| varargs
| Alias for field number 1
|
| keywords
| Alias for field number 2
|
| locals
| Alias for field number 3
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('args', 'varargs', 'keywords', 'locals')
|
| _field_defaults = {}
|
| _fields = ('args', 'varargs', 'keywords', 'locals')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class Arguments(builtins.tuple)
| Arguments(args, varargs, varkw)
|
| Arguments(args, varargs, varkw)
|
| Method resolution order:
| Arguments
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.Arguments
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.Arguments
| Return a nicely formatted representation string
|
| _asdict(self) from collections.Arguments
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.Arguments
| Return a new Arguments object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.Arguments
| Make a new Arguments object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, args, varargs, varkw) from namedtuple_Arguments.Arguments
| Create new instance of Arguments(args, varargs, varkw)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| args
| Alias for field number 0
|
| varargs
| Alias for field number 1
|
| varkw
| Alias for field number 2
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('args', 'varargs', 'varkw')
|
| _field_defaults = {}
|
| _fields = ('args', 'varargs', 'varkw')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class Attribute(builtins.tuple)
| Attribute(name, kind, defining_class, object)
|
| Attribute(name, kind, defining_class, object)
|
| Method resolution order:
| Attribute
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.Attribute
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.Attribute
| Return a nicely formatted representation string
|
| _asdict(self) from collections.Attribute
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.Attribute
| Return a new Attribute object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.Attribute
| Make a new Attribute object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, name, kind, defining_class, object) from namedtuple_Attribute.Attribute
| Create new instance of Attribute(name, kind, defining_class, object)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
| Alias for field number 0
|
| kind
| Alias for field number 1
|
| defining_class
| Alias for field number 2
|
| object
| Alias for field number 3
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('name', 'kind', 'defining_class', 'object')
|
| _field_defaults = {}
|
| _fields = ('name', 'kind', 'defining_class', 'object')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class BlockFinder(builtins.object)
| Provide a tokeneater() method to detect the end of a code block.
|
| Methods defined here:
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| tokeneater(self, type, token, srowcol, erowcol, line)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class BoundArguments(builtins.object)
| BoundArguments(signature, arguments)
|
| Result of `Signature.bind` call. Holds the mapping of arguments
| to the function's parameters.
|
| Has the following public attributes:
|
| * arguments : dict
| An ordered mutable mapping of parameters' names to arguments' values.
| Does not contain arguments' default values.
| * signature : Signature
| The Signature object that created this instance.
| * args : tuple
| Tuple of positional arguments values.
| * kwargs : dict
| Dict of keyword arguments values.
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __getstate__(self)
| Helper for pickle.
|
| __init__(self, signature, arguments)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| __setstate__(self, state)
|
| apply_defaults(self)
| Set default values for missing arguments.
|
| For variable-positional arguments (*args) the default is an
| empty tuple.
|
| For variable-keyword arguments (**kwargs) the default is an
| empty dict.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| args
|
| kwargs
|
| signature
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| arguments
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
class BufferFlags(enum.IntFlag)
| BufferFlags(*values)
|
| Method resolution order:
| BufferFlags
| enum.IntFlag
| builtins.int
| enum.ReprEnum
| enum.Flag
| enum.Enum
| builtins.object
|
| Methods defined here:
|
| __and__(self, other) from enum.Flag
|
| __format__(self, format_spec, /) from builtins.int
| Convert to a string according to format_spec.
|
| __invert__(self) from enum.Flag
|
| __new__(cls, value) from enum.Enum
| Create and return a new object. See help(type) for accurate signature.
|
| __or__(self, other) from enum.Flag
| Return self|value.
|
| __rand__ = __and__(self, other)
|
| __ror__ = __or__(self, other)
|
| __rxor__ = __xor__(self, other)
|
| __xor__(self, other) from enum.Flag
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| FORMAT = <BufferFlags.FORMAT: 4>
|
| ND = <BufferFlags.ND: 8>
|
| READ = <BufferFlags.READ: 256>
|
| WRITABLE = <BufferFlags.WRITABLE: 1>
|
| WRITE = <BufferFlags.WRITE: 512>
|
| ----------------------------------------------------------------------
| Methods inherited from enum.IntFlag:
|
| __repr__(self) from enum.Flag
| Return repr(self).
|
| __str__ = __repr__(self, /) from builtins.int
| Return repr(self).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.int:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __ceil__(...)
| Ceiling of an Integral returns itself.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(...)
| Flooring an Integral returns itself.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __le__(self, value, /)
| Return self<=value.
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __round__(...)
| Rounding an Integral returns itself.
|
| Rounding with an ndigits argument also returns an integer.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __sizeof__(self, /)
| Returns size in memory, in bytes.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is equal to the original int.
|
| The ratio is in lowest terms and has a positive denominator.
|
| >>> (10).as_integer_ratio()
| (10, 1)
| >>> (-10).as_integer_ratio()
| (-10, 1)
| >>> (0).as_integer_ratio()
| (0, 1)
|
| bit_count(self, /)
| Number of ones in the binary representation of the absolute value of self.
|
| Also known as the population count.
|
| >>> bin(13)
| '0b1101'
| >>> (13).bit_count()
| 3
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| is_integer(self, /)
| Returns True. Exists for duck type compatibility with float.is_integer.
|
| to_bytes(self, /, length=1, byteorder='big', *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes. Default
| is length 1.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.int:
|
| from_bytes(bytes, byteorder='big', *, signed=False)
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.
| Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.int:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Flag:
|
| __contains__(self, other)
| Returns True if self has at least the same flags set as other.
|
| __iter__(self)
| Returns flags in definition order.
|
| __len__(self)
| Return the number of members (no aliases)
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Enum:
|
| __dir__(self)
| Returns public methods and other interesting attributes.
|
| __init__(self, *args, **kwds)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce_ex__(self, proto)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Static methods inherited from enum.EnumType:
|
| __getitem__(name)
| Return the member matching `name`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
class ClassFoundException(builtins.Exception)
| Method resolution order:
| ClassFoundException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 ClosureVars(builtins.tuple)
| ClosureVars(nonlocals, globals, builtins, unbound)
|
| ClosureVars(nonlocals, globals, builtins, unbound)
|
| Method resolution order:
| ClosureVars
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.ClosureVars
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.ClosureVars
| Return a nicely formatted representation string
|
| _asdict(self) from collections.ClosureVars
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.ClosureVars
| Return a new ClosureVars object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.ClosureVars
| Make a new ClosureVars object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, nonlocals, globals, builtins, unbound) from namedtuple_ClosureVars.ClosureVars
| Create new instance of ClosureVars(nonlocals, globals, builtins, unbound)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| nonlocals
| Alias for field number 0
|
| globals
| Alias for field number 1
|
| builtins
| Alias for field number 2
|
| unbound
| Alias for field number 3
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('nonlocals', 'globals', 'builtins', 'unbound')
|
| _field_defaults = {}
|
| _fields = ('nonlocals', 'globals', 'builtins', 'unbound')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class EndOfBlock(builtins.Exception)
| Method resolution order:
| EndOfBlock
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 FrameInfo(_FrameInfo)
| FrameInfo(frame, filename, lineno, function, code_context, index, *, positions=None)
|
| Method resolution order:
| FrameInfo
| _FrameInfo
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __repr__(self)
| Return a nicely formatted representation string
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, frame, filename, lineno, function, code_context, index, *, positions=None)
| Create new instance of _FrameInfo(frame, filename, lineno, function, code_context, index)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| ----------------------------------------------------------------------
| Methods inherited from _FrameInfo:
|
| __getnewargs__(self) from collections._FrameInfo
| Return self as a plain tuple. Used by copy and pickle.
|
| _asdict(self) from collections._FrameInfo
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections._FrameInfo
| Return a new _FrameInfo object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods inherited from _FrameInfo:
|
| _make(iterable) from collections._FrameInfo
| Make a new _FrameInfo object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _FrameInfo:
|
| frame
| Alias for field number 0
|
| filename
| Alias for field number 1
|
| lineno
| Alias for field number 2
|
| function
| Alias for field number 3
|
| code_context
| Alias for field number 4
|
| index
| Alias for field number 5
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from _FrameInfo:
|
| __match_args__ = ('frame', 'filename', 'lineno', 'function', 'code_con...
|
| _field_defaults = {}
|
| _fields = ('frame', 'filename', 'lineno', 'function', 'code_context', ...
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class FullArgSpec(builtins.tuple)
| FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)
|
| FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)
|
| Method resolution order:
| FullArgSpec
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __getnewargs__(self) from collections.FullArgSpec
| Return self as a plain tuple. Used by copy and pickle.
|
| __repr__(self) from collections.FullArgSpec
| Return a nicely formatted representation string
|
| _asdict(self) from collections.FullArgSpec
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections.FullArgSpec
| Return a new FullArgSpec object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| _make(iterable) from collections.FullArgSpec
| Make a new FullArgSpec object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(_cls, args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations) from namedtuple_FullArgSpec.FullArgSpec
| Create new instance of FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| args
| Alias for field number 0
|
| varargs
| Alias for field number 1
|
| varkw
| Alias for field number 2
|
| defaults
| Alias for field number 3
|
| kwonlyargs
| Alias for field number 4
|
| kwonlydefaults
| Alias for field number 5
|
| annotations
| Alias for field number 6
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('args', 'varargs', 'varkw', 'defaults', 'kwonlyargs'...
|
| _field_defaults = {}
|
| _fields = ('args', 'varargs', 'varkw', 'defaults', 'kwonlyargs', 'kwon...
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class Parameter(builtins.object)
| Parameter(name, kind, *, default, annotation)
|
| Represents a parameter in a function signature.
|
| Has the following public attributes:
|
| * name : str
| The name of the parameter as a string.
| * default : object
| The default value for the parameter if specified. If the
| parameter has no default value, this attribute is set to
| `Parameter.empty`.
| * annotation
| The annotation for the parameter if specified. If the
| parameter has no annotation, this attribute is set to
| `Parameter.empty`.
| * kind : str
| Describes how argument values are bound to the parameter.
| Possible values: `Parameter.POSITIONAL_ONLY`,
| `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`,
| `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`.
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __hash__(self)
| Return hash(self).
|
| __init__(self, name, kind, *, default, annotation)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(self)
| Helper for pickle.
|
| __repr__(self)
| Return repr(self).
|
| __setstate__(self, state)
|
| __str__(self)
| Return str(self).
|
| replace(self, *, name=<class 'inspect._void'>, kind=<class 'inspect._void'>, annotation=<class 'inspect._void'>, default=<class 'inspect._void'>)
| Creates a customized copy of the Parameter.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| annotation
|
| default
|
| kind
|
| name
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| KEYWORD_ONLY = <_ParameterKind.KEYWORD_ONLY: 3>
|
| POSITIONAL_ONLY = <_ParameterKind.POSITIONAL_ONLY: 0>
|
| POSITIONAL_OR_KEYWORD = <_ParameterKind.POSITIONAL_OR_KEYWORD: 1>
|
| VAR_KEYWORD = <_ParameterKind.VAR_KEYWORD: 4>
|
| VAR_POSITIONAL = <_ParameterKind.VAR_POSITIONAL: 2>
|
| empty = <class 'inspect._empty'>
| Marker object for Signature.empty and Parameter.empty.
class Signature(builtins.object)
| Signature(parameters=None, *, return_annotation, __validate_parameters__=True)
|
| A Signature object represents the overall signature of a function.
| It stores a Parameter object for each parameter accepted by the
| function, as well as information specific to the function itself.
|
| A Signature object has the following public attributes and methods:
|
| * parameters : OrderedDict
| An ordered mapping of parameters' names to the corresponding
| Parameter objects (keyword-only arguments are in the same order
| as listed in `code.co_varnames`).
| * return_annotation : object
| The annotation for the return type of the function if specified.
| If the function has no annotation for its return type, this
| attribute is set to `Signature.empty`.
| * bind(*args, **kwargs) -> BoundArguments
| Creates a mapping from positional and keyword arguments to
| parameters.
| * bind_partial(*args, **kwargs) -> BoundArguments
| Creates a partial mapping from positional and keyword arguments
| to parameters (simulating 'functools.partial' behavior.)
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __hash__(self)
| Return hash(self).
|
| __init__(self, parameters=None, *, return_annotation, __validate_parameters__=True)
| Constructs Signature from the given list of Parameter
| objects and 'return_annotation'. All arguments are optional.
|
| __reduce__(self)
| Helper for pickle.
|
| __repr__(self)
| Return repr(self).
|
| __setstate__(self, state)
|
| __str__(self)
| Return str(self).
|
| bind(self, /, *args, **kwargs)
| Get a BoundArguments object, that maps the passed `args`
| and `kwargs` to the function's signature. Raises `TypeError`
| if the passed arguments can not be bound.
|
| bind_partial(self, /, *args, **kwargs)
| Get a BoundArguments object, that partially maps the
| passed `args` and `kwargs` to the function's signature.
| Raises `TypeError` if the passed arguments can not be bound.
|
| replace(self, *, parameters=<class 'inspect._void'>, return_annotation=<class 'inspect._void'>)
| Creates a customized copy of the Signature.
| Pass 'parameters' and/or 'return_annotation' arguments
| to override them in the new copy.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_callable(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False)
| Constructs Signature for the given callable object.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| parameters
|
| return_annotation
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| empty = <class 'inspect._empty'>
| Marker object for Signature.empty and Parameter.empty.
class Traceback(_Traceback)
| Traceback(filename, lineno, function, code_context, index, *, positions=None)
|
| Method resolution order:
| Traceback
| _Traceback
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __repr__(self)
| Return a nicely formatted representation string
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, filename, lineno, function, code_context, index, *, positions=None)
| Create new instance of _Traceback(filename, lineno, function, code_context, index)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| ----------------------------------------------------------------------
| Methods inherited from _Traceback:
|
| __getnewargs__(self) from collections._Traceback
| Return self as a plain tuple. Used by copy and pickle.
|
| _asdict(self) from collections._Traceback
| Return a new dict which maps field names to their values.
|
| _replace(self, /, **kwds) from collections._Traceback
| Return a new _Traceback object replacing specified fields with new values
|
| ----------------------------------------------------------------------
| Class methods inherited from _Traceback:
|
| _make(iterable) from collections._Traceback
| Make a new _Traceback object from a sequence or iterable
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _Traceback:
|
| filename
| Alias for field number 0
|
| lineno
| Alias for field number 1
|
| function
| Alias for field number 2
|
| code_context
| Alias for field number 3
|
| index
| Alias for field number 4
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from _Traceback:
|
| __match_args__ = ('filename', 'lineno', 'function', 'code_context', 'i...
|
| _field_defaults = {}
|
| _fields = ('filename', 'lineno', 'function', 'code_context', 'index')
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
FUNCTIONS
classify_class_attrs(cls)
Return list of attribute-descriptor tuples.
For each name in dir(cls), the return list contains a 4-tuple
with these elements:
0. The name (a string).
1. The kind of attribute this is, one of these strings:
'class method' created via classmethod()
'static method' created via staticmethod()
'property' created via property()
'method' any other flavor of method or descriptor
'data' not a method
2. The class which defined this attribute (a class).
3. The object as obtained by calling getattr; if this fails, or if the
resulting object does not live anywhere in the class' mro (including
metaclasses) then the object is looked up in the defining class's
dict (found by walking the mro).
If one of the items in dir(cls) is stored in the metaclass it will now
be discovered and not have None be listed as the class in which it was
defined. Any items whose home class cannot be discovered are skipped.
cleandoc(doc)
Clean up indentation from docstrings.
Any whitespace that can be uniformly removed from the second line
onwards is removed.
currentframe()
Return the frame of the caller or None if this is not possible.
findsource(object)
Return the entire source file and starting line number for an object.
The argument may be a module, class, method, function, traceback, frame,
or code object. The source code is returned as a list of all the lines
in the file and the line number indexes a line in that list. An OSError
is raised if the source code cannot be retrieved.
formatannotation(annotation, base_module=None)
formatannotationrelativeto(object)
formatargvalues(args, varargs, varkw, locals, formatarg=<class 'str'>, formatvarargs=<function <lambda> at 0x00000245A805C9A0>, formatvarkw=<function <lambda> at 0x00000245A805CA40>, formatvalue=<function <lambda> at 0x00000245A805CAE0>)
Format an argument spec from the 4 values returned by getargvalues.
The first four arguments are (args, varargs, varkw, locals). The
next four arguments are the corresponding optional formatting functions
that are called to turn names and values into strings. The ninth
argument is an optional function to format the sequence of arguments.
get_annotations(obj, *, globals=None, locals=None, eval_str=False)
Compute the annotations dict for an object.
obj may be a callable, class, or module.
Passing in an object of any other type raises TypeError.
Returns a dict. get_annotations() returns a new dict every time
it's called; calling it twice on the same object will return two
different but equivalent dicts.
This function handles several details for you:
* If eval_str is true, values of type str will
be un-stringized using eval(). This is intended
for use with stringized annotations
("from __future__ import annotations").
* If obj doesn't have an annotations dict, returns an
empty dict. (Functions and methods always have an
annotations dict; classes, modules, and other types of
callables may not.)
* Ignores inherited annotations on classes. If a class
doesn't have its own annotations dict, returns an empty dict.
* All accesses to object members and dict values are done
using getattr() and dict.get() for safety.
* Always, always, always returns a freshly-created dict.
eval_str controls whether or not values of type str are replaced
with the result of calling eval() on those values:
* If eval_str is true, eval() is called on values of type str.
* If eval_str is false (the default), values of type str are unchanged.
globals and locals are passed in to eval(); see the documentation
for eval() for more information. If either globals or locals is
None, this function may replace that value with a context-specific
default, contingent on type(obj):
* If obj is a module, globals defaults to obj.__dict__.
* If obj is a class, globals defaults to
sys.modules[obj.__module__].__dict__ and locals
defaults to the obj class namespace.
* If obj is a callable, globals defaults to obj.__globals__,
although if obj is a wrapped function (using
functools.update_wrapper()) it is first unwrapped.
getabsfile(object, _filename=None)
Return an absolute path to the source or compiled file for an object.
The idea is for each object to have a unique origin, so this routine
normalizes the result as much as possible.
getargs(co)
Get information about the arguments accepted by a code object.
Three things are returned: (args, varargs, varkw), where
'args' is the list of argument names. Keyword-only arguments are
appended. 'varargs' and 'varkw' are the names of the * and **
arguments or None.
getargvalues(frame)
Get information about arguments passed into a particular frame.
A tuple of four things is returned: (args, varargs, varkw, locals).
'args' is a list of the argument names.
'varargs' and 'varkw' are the names of the * and ** arguments or None.
'locals' is the locals dictionary of the given frame.
getasyncgenlocals(agen)
Get the mapping of asynchronous generator local variables to their current
values.
A dict is returned, with the keys the local variable names and values the
bound values.
getasyncgenstate(agen)
Get current state of an asynchronous generator object.
Possible states are:
AGEN_CREATED: Waiting to start execution.
AGEN_RUNNING: Currently being executed by the interpreter.
AGEN_SUSPENDED: Currently suspended at a yield expression.
AGEN_CLOSED: Execution has completed.
getattr_static(obj, attr, default=<object object at 0x00000245A78987B0>)
Retrieve attributes without triggering dynamic lookup via the
descriptor protocol, __getattr__ or __getattribute__.
Note: this function may not be able to retrieve all attributes
that getattr can fetch (like dynamically created attributes)
and may find attributes that getattr can't (like descriptors
that raise AttributeError). It can also return descriptor objects
instead of instance members in some cases. See the
documentation for details.
getblock(lines)
Extract the block of code at the top of the given list of lines.
getcallargs(func, /, *positional, **named)
Get the mapping of arguments to values.
A dict is returned, with keys the function argument names (including the
names of the * and ** arguments, if any), and values the respective bound
values from 'positional' and 'named'.
getclasstree(classes, unique=False)
Arrange the given list of classes into a hierarchy of nested lists.
Where a nested list appears, it contains classes derived from the class
whose entry immediately precedes the list. Each entry is a 2-tuple
containing a class and a tuple of its base classes. If the 'unique'
argument is true, exactly one entry appears in the returned structure
for each class in the given list. Otherwise, classes using multiple
inheritance and their descendants will appear multiple times.
getclosurevars(func)
Get the mapping of free variables to their current values.
Returns a named tuple of dicts mapping the current nonlocal, global
and builtin references as seen by the body of the function. A final
set of unbound names that could not be resolved is also provided.
getcomments(object)
Get lines of comments immediately preceding an object's source code.
Returns None when source can't be found.
getcoroutinelocals(coroutine)
Get the mapping of coroutine local variables to their current values.
A dict is returned, with the keys the local variable names and values the
bound values.
getcoroutinestate(coroutine)
Get current state of a coroutine object.
Possible states are:
CORO_CREATED: Waiting to start execution.
CORO_RUNNING: Currently being executed by the interpreter.
CORO_SUSPENDED: Currently suspended at an await expression.
CORO_CLOSED: Execution has completed.
getdoc(object)
Get the documentation string for an object.
All tabs are expanded to spaces. To clean up docstrings that are
indented to line up with blocks of code, any whitespace than can be
uniformly removed from the second line onwards is removed.
getfile(object)
Work out which source or compiled file an object was defined in.
getframeinfo(frame, context=1)
Get information about a frame or traceback object.
A tuple of five things is returned: the filename, the line number of
the current line, the function name, a list of lines of context from
the source code, and the index of the current line within that list.
The optional second argument specifies the number of lines of context
to return, which are centered around the current line.
getfullargspec(func)
Get the names and default values of a callable object's parameters.
A tuple of seven things is returned:
(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations).
'args' is a list of the parameter names.
'varargs' and 'varkw' are the names of the * and ** parameters or None.
'defaults' is an n-tuple of the default values of the last n parameters.
'kwonlyargs' is a list of keyword-only parameter names.
'kwonlydefaults' is a dictionary mapping names from kwonlyargs to defaults.
'annotations' is a dictionary mapping parameter names to annotations.
Notable differences from inspect.signature():
- the "self" parameter is always reported, even for bound methods
- wrapper chains defined by __wrapped__ *not* unwrapped automatically
getgeneratorlocals(generator)
Get the mapping of generator local variables to their current values.
A dict is returned, with the keys the local variable names and values the
bound values.
getgeneratorstate(generator)
Get current state of a generator-iterator.
Possible states are:
GEN_CREATED: Waiting to start execution.
GEN_RUNNING: Currently being executed by the interpreter.
GEN_SUSPENDED: Currently suspended at a yield expression.
GEN_CLOSED: Execution has completed.
getinnerframes(tb, context=1)
Get a list of records for a traceback's frame and all lower frames.
Each record contains a frame object, filename, line number, function
name, a list of lines of context, and index within the context.
getlineno(frame)
Get the line number from a frame object, allowing for optimization.
getmembers(object, predicate=None)
Return all members of an object as (name, value) pairs sorted by name.
Optionally, only return members that satisfy a given predicate.
getmembers_static(object, predicate=None)
Return all members of an object as (name, value) pairs sorted by name
without triggering dynamic lookup via the descriptor protocol,
__getattr__ or __getattribute__. Optionally, only return members that
satisfy a given predicate.
Note: this function may not be able to retrieve all members
that getmembers can fetch (like dynamically created attributes)
and may find members that getmembers can't (like descriptors
that raise AttributeError). It can also return descriptor objects
instead of instance members in some cases.
getmodule(object, _filename=None)
Return the module an object was defined in, or None if not found.
getmodulename(path)
Return the module name for a given file, or None.
getmro(cls)
Return tuple of base classes (including cls) in method resolution order.
getouterframes(frame, context=1)
Get a list of records for a frame and all higher (calling) frames.
Each record contains a frame object, filename, line number, function
name, a list of lines of context, and index within the context.
getsource(object)
Return the text of the source code for an object.
The argument may be a module, class, method, function, traceback, frame,
or code object. The source code is returned as a single string. An
OSError is raised if the source code cannot be retrieved.
getsourcefile(object)
Return the filename that can be used to locate an object's source.
Return None if no way can be identified to get the source.
getsourcelines(object)
Return a list of source lines and starting line number for an object.
The argument may be a module, class, method, function, traceback, frame,
or code object. The source code is returned as a list of the lines
corresponding to the object and the line number indicates where in the
original source file the first line of code was found. An OSError is
raised if the source code cannot be retrieved.
indentsize(line)
Return the indent size, in spaces, at the start of a line of text.
isabstract(object)
Return true if the object is an abstract base class (ABC).
isasyncgen(object)
Return true if the object is an asynchronous generator.
isasyncgenfunction(obj)
Return true if the object is an asynchronous generator function.
Asynchronous generator functions are defined with "async def"
syntax and have "yield" expressions in their body.
isawaitable(object)
Return true if object can be passed to an ``await`` expression.
isbuiltin(object)
Return true if the object is a built-in function or method.
Built-in functions and methods provide these attributes:
__doc__ documentation string
__name__ original name of this function or method
__self__ instance to which a method is bound, or None
isclass(object)
Return true if the object is a class.
iscode(object)
Return true if the object is a code object.
Code objects provide these attributes:
co_argcount number of arguments (not including *, ** args
or keyword only arguments)
co_code string of raw compiled bytecode
co_cellvars tuple of names of cell variables
co_consts tuple of constants used in the bytecode
co_filename name of file in which this code object was created
co_firstlineno number of first line in Python source code
co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg
| 16=nested | 32=generator | 64=nofree | 128=coroutine
| 256=iterable_coroutine | 512=async_generator
co_freevars tuple of names of free variables
co_posonlyargcount number of positional only arguments
co_kwonlyargcount number of keyword only arguments (not including ** arg)
co_lnotab encoded mapping of line numbers to bytecode indices
co_name name with which this code object was defined
co_names tuple of names other than arguments and function locals
co_nlocals number of local variables
co_stacksize virtual machine stack space required
co_varnames tuple of names of arguments and local variables
iscoroutine(object)
Return true if the object is a coroutine.
iscoroutinefunction(obj)
Return true if the object is a coroutine function.
Coroutine functions are normally defined with "async def" syntax, but may
be marked via markcoroutinefunction.
isdatadescriptor(object)
Return true if the object is a data descriptor.
Data descriptors have a __set__ or a __delete__ attribute. Examples are
properties (defined in Python) and getsets and members (defined in C).
Typically, data descriptors will also have __name__ and __doc__ attributes
(properties, getsets, and members have both of these attributes), but this
is not guaranteed.
isframe(object)
Return true if the object is a frame object.
Frame objects provide these attributes:
f_back next outer frame object (this frame's caller)
f_builtins built-in namespace seen by this frame
f_code code object being executed in this frame
f_globals global namespace seen by this frame
f_lasti index of last attempted instruction in bytecode
f_lineno current line number in Python source code
f_locals local namespace seen by this frame
f_trace tracing function for this frame, or None
isfunction(object)
Return true if the object is a user-defined function.
Function objects provide these attributes:
__doc__ documentation string
__name__ name with which this function was defined
__code__ code object containing compiled function bytecode
__defaults__ tuple of any default values for arguments
__globals__ global namespace in which this function was defined
__annotations__ dict of parameter annotations
__kwdefaults__ dict of keyword only parameters with defaults
isgenerator(object)
Return true if the object is a generator.
Generator objects provide these attributes:
__iter__ defined to support iteration over container
close raises a new GeneratorExit exception inside the
generator to terminate the iteration
gi_code code object
gi_frame frame object or possibly None once the generator has
been exhausted
gi_running set to 1 when generator is executing, 0 otherwise
next return the next item from the container
send resumes the generator and "sends" a value that becomes
the result of the current yield-expression
throw used to raise an exception inside the generator
isgeneratorfunction(obj)
Return true if the object is a user-defined generator function.
Generator function objects provide the same attributes as functions.
See help(isfunction) for a list of attributes.
isgetsetdescriptor(object)
Return true if the object is a getset descriptor.
getset descriptors are specialized descriptors defined in extension
modules.
ismemberdescriptor(object)
Return true if the object is a member descriptor.
Member descriptors are specialized descriptors defined in extension
modules.
ismethod(object)
Return true if the object is an instance method.
ismethoddescriptor(object)
Return true if the object is a method descriptor.
But not if ismethod() or isclass() or isfunction() are true.
This is new in Python 2.2, and, for example, is true of int.__add__.
An object passing this test has a __get__ attribute but not a __set__
attribute, but beyond that the set of attributes varies. __name__ is
usually sensible, and __doc__ often is.
Methods implemented via descriptors that also pass one of the other
tests return false from the ismethoddescriptor() test, simply because
the other tests promise more -- you can, e.g., count on having the
__func__ attribute (etc) when an object passes ismethod().
ismethodwrapper(object)
Return true if the object is a method wrapper.
ismodule(object)
Return true if the object is a module.
isroutine(object)
Return true if the object is any kind of function or method.
istraceback(object)
Return true if the object is a traceback.
Traceback objects provide these attributes:
tb_frame frame object at this level
tb_lasti index of last attempted instruction in bytecode
tb_lineno current line number in Python source code
tb_next next inner traceback object (called by this level)
markcoroutinefunction(func)
Decorator to ensure callable is recognised as a coroutine function.
signature(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False)
Get a signature object for the passed callable.
stack(context=1)
Return a list of records for the stack above the caller's frame.
trace(context=1)
Return a list of records for the stack below the current exception.
unwrap(func, *, stop=None)
Get the object wrapped by *func*.
Follows the chain of :attr:`__wrapped__` attributes returning the last
object in the chain.
*stop* is an optional callback accepting an object in the wrapper chain
as its sole argument that allows the unwrapping to be terminated early if
the callback returns a true value. If the callback never returns a true
value, the last object in the chain is returned as usual. For example,
:func:`signature` uses this to stop unwrapping if any object in the
chain has a ``__signature__`` attribute defined.
:exc:`ValueError` is raised if a cycle is encountered.
walktree(classes, children, parent)
Recursive helper function for getclasstree().
DATA
AGEN_CLOSED = 'AGEN_CLOSED'
AGEN_CREATED = 'AGEN_CREATED'
AGEN_RUNNING = 'AGEN_RUNNING'
AGEN_SUSPENDED = 'AGEN_SUSPENDED'
CORO_CLOSED = 'CORO_CLOSED'
CORO_CREATED = 'CORO_CREATED'
CORO_RUNNING = 'CORO_RUNNING'
CORO_SUSPENDED = 'CORO_SUSPENDED'
CO_ASYNC_GENERATOR = 512
CO_COROUTINE = 128
CO_GENERATOR = 32
CO_ITERABLE_COROUTINE = 256
CO_NESTED = 16
CO_NEWLOCALS = 2
CO_NOFREE = 64
CO_OPTIMIZED = 1
CO_VARARGS = 4
CO_VARKEYWORDS = 8
GEN_CLOSED = 'GEN_CLOSED'
GEN_CREATED = 'GEN_CREATED'
GEN_RUNNING = 'GEN_RUNNING'
GEN_SUSPENDED = 'GEN_SUSPENDED'
TPFLAGS_IS_ABSTRACT = 1048576
__all__ = ['AGEN_CLOSED', 'AGEN_CREATED', 'AGEN_RUNNING', 'AGEN_SUSPEN...
AUTHOR
('Ka-Ping Yee <ping@lfw.org>', 'Yury Selivanov <yselivanov@sprymix.com>')
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\inspect.py
matplotlib.interactive
Python Library Documentation: function interactive in module matplotlib
interactive(b)
Set whether to redraw after every plotting command (e.g. `.pyplot.xlabel`).
matplotlib.is_interactive
Python Library Documentation: function is_interactive in module matplotlib
is_interactive()
Return whether to redraw after every plotting command.
.. note::
This function is only intended for use in backends. End users should
use `.pyplot.isinteractive` instead.
matplotlib.locale
Python Library Documentation: module locale
NAME
locale - Locale support module.
MODULE REFERENCE
https://docs.python.org/3.12/library/locale.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
The module provides low-level access to the C lib's locale APIs and adds high
level number formatting APIs as well as a locale aliasing engine to complement
these.
The aliasing engine includes support for many commonly used locale names and
maps them to values suitable for passing to the C lib's setlocale() function. It
also includes default encodings for all supported locale names.
CLASSES
builtins.Exception(builtins.BaseException)
Error
class Error(builtins.Exception)
| Method resolution order:
| Error
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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
FUNCTIONS
atof(string, func=<class 'float'>)
Parses a string as a float according to the locale settings.
atoi(string)
Converts a string to an integer according to the locale settings.
currency(val, symbol=True, grouping=False, international=False)
Formats val according to the currency settings
in the current locale.
format_string(f, val, grouping=False, monetary=False)
Formats a string in the same way that the % formatting would use,
but takes the current locale into account.
Grouping is applied if the third parameter is true.
Conversion uses monetary thousands separator and grouping strings if
forth parameter monetary is true.
getdefaultlocale(envvars=('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE'))
Tries to determine the default locale settings and returns
them as tuple (language code, encoding).
According to POSIX, a program which has not called
setlocale(LC_ALL, "") runs using the portable 'C' locale.
Calling setlocale(LC_ALL, "") lets it use the default locale as
defined by the LANG variable. Since we don't want to interfere
with the current locale setting we thus emulate the behavior
in the way described above.
To maintain compatibility with other platforms, not only the
LANG variable is tested, but a list of variables given as
envvars parameter. The first found to be defined will be
used. envvars defaults to the search path used in GNU gettext;
it must always contain the variable name 'LANG'.
Except for the code 'C', the language code corresponds to RFC
1766. code and encoding can be None in case the values cannot
be determined.
getencoding()
Get the current locale encoding.
getlocale(category=2)
Returns the current setting for the given locale category as
tuple (language code, encoding).
category may be one of the LC_* value except LC_ALL. It
defaults to LC_CTYPE.
Except for the code 'C', the language code corresponds to RFC
1766. code and encoding can be None in case the values cannot
be determined.
getpreferredencoding(do_setlocale=True)
Return the charset that the user is likely using.
localeconv()
Returns numeric and monetary locale-specific parameters.
normalize(localename)
Returns a normalized locale code for the given locale
name.
The returned locale code is formatted for use with
setlocale().
If normalization fails, the original name is returned
unchanged.
If the given encoding is not known, the function defaults to
the default encoding for the locale code just like setlocale()
does.
resetlocale(category=0)
Sets the locale for category to the default setting.
The default setting is determined by calling
getdefaultlocale(). category defaults to LC_ALL.
setlocale(category, locale=None)
Set the locale for the given category. The locale can be
a string, an iterable of two strings (language code and encoding),
or None.
Iterables are converted to strings using the locale aliasing
engine. Locale strings are passed directly to the C lib.
category may be given as one of the LC_* values.
str(val)
Convert float to string, taking the locale into account.
strcoll(os1, os2, /)
Compares two strings according to the locale.
strxfrm(string, /)
Return a string that can be used as a key for locale-aware comparisons.
DATA
CHAR_MAX = 127
LC_ALL = 0
LC_COLLATE = 1
LC_CTYPE = 2
LC_MONETARY = 3
LC_NUMERIC = 4
LC_TIME = 5
__all__ = ['getlocale', 'getdefaultlocale', 'getpreferredencoding', 'E...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\locale.py
matplotlib.logging
Python Library Documentation: package logging
NAME
logging
MODULE REFERENCE
https://docs.python.org/3.12/library/logging.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
Logging package for Python. Based on PEP 282 and comments thereto in
comp.lang.python.
Copyright (C) 2001-2022 Vinay Sajip. All Rights Reserved.
To use, simply 'import logging' and log away!
PACKAGE CONTENTS
config
handlers
CLASSES
builtins.object
BufferingFormatter
Filter
Formatter
LogRecord
LoggerAdapter
Filterer(builtins.object)
Handler
NullHandler
StreamHandler
FileHandler
Logger
class BufferingFormatter(builtins.object)
| BufferingFormatter(linefmt=None)
|
| A formatter suitable for formatting a number of records.
|
| Methods defined here:
|
| __init__(self, linefmt=None)
| Optionally specify a formatter which will be used to format each
| individual record.
|
| format(self, records)
| Format the specified records and return the result as a string.
|
| formatFooter(self, records)
| Return the footer string for the specified records.
|
| formatHeader(self, records)
| Return the header string for the specified records.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class FileHandler(StreamHandler)
| FileHandler(filename, mode='a', encoding=None, delay=False, errors=None)
|
| A handler class which writes formatted logging records to disk files.
|
| Method resolution order:
| FileHandler
| StreamHandler
| Handler
| Filterer
| builtins.object
|
| Methods defined here:
|
| __init__(self, filename, mode='a', encoding=None, delay=False, errors=None)
| Open the specified file and use it as the stream for logging.
|
| __repr__(self)
| Return repr(self).
|
| close(self)
| Closes the stream.
|
| emit(self, record)
| Emit a record.
|
| If the stream was not opened because 'delay' was specified in the
| constructor, open it before calling the superclass's emit.
|
| If stream is not open, current mode is 'w' and `_closed=True`, record
| will not be emitted (see Issue #42378).
|
| ----------------------------------------------------------------------
| Methods inherited from StreamHandler:
|
| flush(self)
| Flushes the stream.
|
| setStream(self, stream)
| Sets the StreamHandler's stream to the specified value,
| if it is different.
|
| Returns the old stream, if the stream was changed, or None
| if it wasn't.
|
| ----------------------------------------------------------------------
| Class methods inherited from StreamHandler:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from StreamHandler:
|
| terminator = '\n'
|
| ----------------------------------------------------------------------
| Methods inherited from Handler:
|
| acquire(self)
| Acquire the I/O thread lock.
|
| createLock(self)
| Acquire a thread lock for serializing access to the underlying I/O.
|
| format(self, record)
| Format the specified record.
|
| If a formatter is set, use it. Otherwise, use the default formatter
| for the module.
|
| get_name(self)
|
| handle(self, record)
| Conditionally emit the specified logging record.
|
| Emission depends on filters which may have been added to the handler.
| Wrap the actual emission of the record with acquisition/release of
| the I/O thread lock.
|
| Returns an instance of the log record that was emitted
| if it passed all filters, otherwise a false value is returned.
|
| handleError(self, record)
| Handle errors which occur during an emit() call.
|
| This method should be called from handlers when an exception is
| encountered during an emit() call. If raiseExceptions is false,
| exceptions get silently ignored. This is what is mostly wanted
| for a logging system - most users will not care about errors in
| the logging system, they are more interested in application errors.
| You could, however, replace this with a custom handler if you wish.
| The record which was being processed is passed in to this method.
|
| release(self)
| Release the I/O thread lock.
|
| setFormatter(self, fmt)
| Set the formatter for this handler.
|
| setLevel(self, level)
| Set the logging level of this handler. level must be an int or a str.
|
| set_name(self, name)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Handler:
|
| name
|
| ----------------------------------------------------------------------
| Methods inherited from Filterer:
|
| addFilter(self, filter)
| Add the specified filter to this handler.
|
| filter(self, record)
| Determine if a record is loggable by consulting all the filters.
|
| The default is to allow the record to be logged; any filter can veto
| this by returning a false value.
| If a filter attached to a handler returns a log record instance,
| then that instance is used in place of the original log record in
| any further processing of the event by that handler.
| If a filter returns any other true value, the original log record
| is used in any further processing of the event by that handler.
|
| If none of the filters return false values, this method returns
| a log record.
| If any of the filters return a false value, this method returns
| a false value.
|
| .. versionchanged:: 3.2
|
| Allow filters to be just callables.
|
| .. versionchanged:: 3.12
| Allow filters to return a LogRecord instead of
| modifying it in place.
|
| removeFilter(self, filter)
| Remove the specified filter from this handler.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Filterer:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Filter(builtins.object)
| Filter(name='')
|
| Filter instances are used to perform arbitrary filtering of LogRecords.
|
| Loggers and Handlers can optionally use Filter instances to filter
| records as desired. The base filter class only allows events which are
| below a certain point in the logger hierarchy. For example, a filter
| initialized with "A.B" will allow events logged by loggers "A.B",
| "A.B.C", "A.B.C.D", "A.B.D" etc. but not "A.BB", "B.A.B" etc. If
| initialized with the empty string, all events are passed.
|
| Methods defined here:
|
| __init__(self, name='')
| Initialize a filter.
|
| Initialize with the name of the logger which, together with its
| children, will have its events allowed through the filter. If no
| name is specified, allow every event.
|
| filter(self, record)
| Determine if the specified record is to be logged.
|
| Returns True if the record should be logged, or False otherwise.
| If deemed appropriate, the record may be modified in-place.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Formatter(builtins.object)
| Formatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)
|
| Formatter instances are used to convert a LogRecord to text.
|
| Formatters need to know how a LogRecord is constructed. They are
| responsible for converting a LogRecord to (usually) a string which can
| be interpreted by either a human or an external system. The base Formatter
| allows a formatting string to be specified. If none is supplied, the
| style-dependent default value, "%(message)s", "{message}", or
| "${message}", is used.
|
| The Formatter can be initialized with a format string which makes use of
| knowledge of the LogRecord attributes - e.g. the default value mentioned
| above makes use of the fact that the user's message and arguments are pre-
| formatted into a LogRecord's message attribute. Currently, the useful
| attributes in a LogRecord are described by:
|
| %(name)s Name of the logger (logging channel)
| %(levelno)s Numeric logging level for the message (DEBUG, INFO,
| WARNING, ERROR, CRITICAL)
| %(levelname)s Text logging level for the message ("DEBUG", "INFO",
| "WARNING", "ERROR", "CRITICAL")
| %(pathname)s Full pathname of the source file where the logging
| call was issued (if available)
| %(filename)s Filename portion of pathname
| %(module)s Module (name portion of filename)
| %(lineno)d Source line number where the logging call was issued
| (if available)
| %(funcName)s Function name
| %(created)f Time when the LogRecord was created (time.time()
| return value)
| %(asctime)s Textual time when the LogRecord was created
| %(msecs)d Millisecond portion of the creation time
| %(relativeCreated)d Time in milliseconds when the LogRecord was created,
| relative to the time the logging module was loaded
| (typically at application startup time)
| %(thread)d Thread ID (if available)
| %(threadName)s Thread name (if available)
| %(taskName)s Task name (if available)
| %(process)d Process ID (if available)
| %(message)s The result of record.getMessage(), computed just as
| the record is emitted
|
| Methods defined here:
|
| __init__(self, fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)
| Initialize the formatter with specified format strings.
|
| Initialize the formatter either with the specified format string, or a
| default as described above. Allow for specialized date formatting with
| the optional datefmt argument. If datefmt is omitted, you get an
| ISO8601-like (or RFC 3339-like) format.
|
| Use a style parameter of '%', '{' or '$' to specify that you want to
| use one of %-formatting, :meth:`str.format` (``{}``) formatting or
| :class:`string.Template` formatting in your format string.
|
| .. versionchanged:: 3.2
| Added the ``style`` parameter.
|
| format(self, record)
| Format the specified record as text.
|
| The record's attribute dictionary is used as the operand to a
| string formatting operation which yields the returned string.
| Before formatting the dictionary, a couple of preparatory steps
| are carried out. The message attribute of the record is computed
| using LogRecord.getMessage(). If the formatting string uses the
| time (as determined by a call to usesTime(), formatTime() is
| called to format the event time. If there is exception information,
| it is formatted using formatException() and appended to the message.
|
| formatException(self, ei)
| Format and return the specified exception information as a string.
|
| This default implementation just uses
| traceback.print_exception()
|
| formatMessage(self, record)
|
| formatStack(self, stack_info)
| This method is provided as an extension point for specialized
| formatting of stack information.
|
| The input data is a string as returned from a call to
| :func:`traceback.print_stack`, but with the last trailing newline
| removed.
|
| The base implementation just returns the value passed in.
|
| formatTime(self, record, datefmt=None)
| Return the creation time of the specified LogRecord as formatted text.
|
| This method should be called from format() by a formatter which
| wants to make use of a formatted time. This method can be overridden
| in formatters to provide for any specific requirement, but the
| basic behaviour is as follows: if datefmt (a string) is specified,
| it is used with time.strftime() to format the creation time of the
| record. Otherwise, an ISO8601-like (or RFC 3339-like) format is used.
| The resulting string is returned. This function uses a user-configurable
| function to convert the creation time to a tuple. By default,
| time.localtime() is used; to change this for a particular formatter
| instance, set the 'converter' attribute to a function with the same
| signature as time.localtime() or time.gmtime(). To change it for all
| formatters, for example if you want all logging times to be shown in GMT,
| set the 'converter' attribute in the Formatter class.
|
| usesTime(self)
| Check if the format uses the creation time of the record.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| converter = localtime(...)
| localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,
| tm_sec,tm_wday,tm_yday,tm_isdst)
|
| Convert seconds since the Epoch to a time tuple expressing local time.
| When 'seconds' is not passed in, convert the current time instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_msec_format = '%s,%03d'
|
| default_time_format = '%Y-%m-%d %H:%M:%S'
class Handler(Filterer)
| Handler(level=0)
|
| Handler instances dispatch logging events to specific destinations.
|
| The base handler class. Acts as a placeholder which defines the Handler
| interface. Handlers can optionally use Formatter instances to format
| records as desired. By default, no formatter is specified; in this case,
| the 'raw' message as determined by record.message is logged.
|
| Method resolution order:
| Handler
| Filterer
| builtins.object
|
| Methods defined here:
|
| __init__(self, level=0)
| Initializes the instance - basically setting the formatter to None
| and the filter list to empty.
|
| __repr__(self)
| Return repr(self).
|
| acquire(self)
| Acquire the I/O thread lock.
|
| close(self)
| Tidy up any resources used by the handler.
|
| This version removes the handler from an internal map of handlers,
| _handlers, which is used for handler lookup by name. Subclasses
| should ensure that this gets called from overridden close()
| methods.
|
| createLock(self)
| Acquire a thread lock for serializing access to the underlying I/O.
|
| emit(self, record)
| Do whatever it takes to actually log the specified logging record.
|
| This version is intended to be implemented by subclasses and so
| raises a NotImplementedError.
|
| flush(self)
| Ensure all logging output has been flushed.
|
| This version does nothing and is intended to be implemented by
| subclasses.
|
| format(self, record)
| Format the specified record.
|
| If a formatter is set, use it. Otherwise, use the default formatter
| for the module.
|
| get_name(self)
|
| handle(self, record)
| Conditionally emit the specified logging record.
|
| Emission depends on filters which may have been added to the handler.
| Wrap the actual emission of the record with acquisition/release of
| the I/O thread lock.
|
| Returns an instance of the log record that was emitted
| if it passed all filters, otherwise a false value is returned.
|
| handleError(self, record)
| Handle errors which occur during an emit() call.
|
| This method should be called from handlers when an exception is
| encountered during an emit() call. If raiseExceptions is false,
| exceptions get silently ignored. This is what is mostly wanted
| for a logging system - most users will not care about errors in
| the logging system, they are more interested in application errors.
| You could, however, replace this with a custom handler if you wish.
| The record which was being processed is passed in to this method.
|
| release(self)
| Release the I/O thread lock.
|
| setFormatter(self, fmt)
| Set the formatter for this handler.
|
| setLevel(self, level)
| Set the logging level of this handler. level must be an int or a str.
|
| set_name(self, name)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
|
| ----------------------------------------------------------------------
| Methods inherited from Filterer:
|
| addFilter(self, filter)
| Add the specified filter to this handler.
|
| filter(self, record)
| Determine if a record is loggable by consulting all the filters.
|
| The default is to allow the record to be logged; any filter can veto
| this by returning a false value.
| If a filter attached to a handler returns a log record instance,
| then that instance is used in place of the original log record in
| any further processing of the event by that handler.
| If a filter returns any other true value, the original log record
| is used in any further processing of the event by that handler.
|
| If none of the filters return false values, this method returns
| a log record.
| If any of the filters return a false value, this method returns
| a false value.
|
| .. versionchanged:: 3.2
|
| Allow filters to be just callables.
|
| .. versionchanged:: 3.12
| Allow filters to return a LogRecord instead of
| modifying it in place.
|
| removeFilter(self, filter)
| Remove the specified filter from this handler.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Filterer:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LogRecord(builtins.object)
| LogRecord(name, level, pathname, lineno, msg, args, exc_info, func=None, sinfo=None, **kwargs)
|
| A LogRecord instance represents an event being logged.
|
| LogRecord instances are created every time something is logged. They
| contain all the information pertinent to the event being logged. The
| main information passed in is in msg and args, which are combined
| using str(msg) % args to create the message field of the record. The
| record also includes information such as when the record was created,
| the source line where the logging call was made, and any exception
| information to be logged.
|
| Methods defined here:
|
| __init__(self, name, level, pathname, lineno, msg, args, exc_info, func=None, sinfo=None, **kwargs)
| Initialize a logging record with interesting information.
|
| __repr__(self)
| Return repr(self).
|
| getMessage(self)
| Return the message for this LogRecord.
|
| Return the message for this LogRecord after merging any user-supplied
| arguments with the message.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Logger(Filterer)
| Logger(name, level=0)
|
| Instances of the Logger class represent a single logging channel. A
| "logging channel" indicates an area of an application. Exactly how an
| "area" is defined is up to the application developer. Since an
| application can have any number of areas, logging channels are identified
| by a unique string. Application areas can be nested (e.g. an area
| of "input processing" might include sub-areas "read CSV files", "read
| XLS files" and "read Gnumeric files"). To cater for this natural nesting,
| channel names are organized into a namespace hierarchy where levels are
| separated by periods, much like the Java or Python package namespace. So
| in the instance given above, channel names might be "input" for the upper
| level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
| There is no arbitrary limit to the depth of nesting.
|
| Method resolution order:
| Logger
| Filterer
| builtins.object
|
| Methods defined here:
|
| __init__(self, name, level=0)
| Initialize the logger with a name and an optional level.
|
| __reduce__(self)
| Helper for pickle.
|
| __repr__(self)
| Return repr(self).
|
| addHandler(self, hdlr)
| Add the specified handler to this logger.
|
| callHandlers(self, record)
| Pass a record to all relevant handlers.
|
| Loop through all handlers for this logger and its parents in the
| logger hierarchy. If no handler was found, output a one-off error
| message to sys.stderr. Stop searching up the hierarchy whenever a
| logger with the "propagate" attribute set to zero is found - that
| will be the last logger whose handlers are called.
|
| critical(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'CRITICAL'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.critical("Houston, we have a %s", "major disaster", exc_info=True)
|
| debug(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'DEBUG'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.debug("Houston, we have a %s", "thorny problem", exc_info=True)
|
| error(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'ERROR'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.error("Houston, we have a %s", "major problem", exc_info=True)
|
| exception(self, msg, *args, exc_info=True, **kwargs)
| Convenience method for logging an ERROR with exception information.
|
| fatal(self, msg, *args, **kwargs)
| Don't use this method, use critical() instead.
|
| findCaller(self, stack_info=False, stacklevel=1)
| Find the stack frame of the caller so that we can note the source
| file name, line number and function name.
|
| getChild(self, suffix)
| Get a logger which is a descendant to this one.
|
| This is a convenience method, such that
|
| logging.getLogger('abc').getChild('def.ghi')
|
| is the same as
|
| logging.getLogger('abc.def.ghi')
|
| It's useful, for example, when the parent logger is named using
| __name__ rather than a literal string.
|
| getChildren(self)
|
| getEffectiveLevel(self)
| Get the effective level for this logger.
|
| Loop through this logger and its parents in the logger hierarchy,
| looking for a non-zero logging level. Return the first one found.
|
| handle(self, record)
| Call the handlers for the specified record.
|
| This method is used for unpickled records received from a socket, as
| well as those created locally. Logger-level filtering is applied.
|
| hasHandlers(self)
| See if this logger has any handlers configured.
|
| Loop through all handlers for this logger and its parents in the
| logger hierarchy. Return True if a handler was found, else False.
| Stop searching up the hierarchy whenever a logger with the "propagate"
| attribute set to zero is found - that will be the last logger which
| is checked for the existence of handlers.
|
| info(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'INFO'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.info("Houston, we have a %s", "notable problem", exc_info=True)
|
| isEnabledFor(self, level)
| Is this logger enabled for level 'level'?
|
| log(self, level, msg, *args, **kwargs)
| Log 'msg % args' with the integer severity 'level'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.log(level, "We have a %s", "mysterious problem", exc_info=True)
|
| makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None)
| A factory method which can be overridden in subclasses to create
| specialized LogRecords.
|
| removeHandler(self, hdlr)
| Remove the specified handler from this logger.
|
| setLevel(self, level)
| Set the logging level of this logger. level must be an int or a str.
|
| warn(self, msg, *args, **kwargs)
|
| warning(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'WARNING'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.warning("Houston, we have a %s", "bit of a problem", exc_info=True)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| manager = <logging.Manager object>
|
| root = <RootLogger root (WARNING)>
|
| ----------------------------------------------------------------------
| Methods inherited from Filterer:
|
| addFilter(self, filter)
| Add the specified filter to this handler.
|
| filter(self, record)
| Determine if a record is loggable by consulting all the filters.
|
| The default is to allow the record to be logged; any filter can veto
| this by returning a false value.
| If a filter attached to a handler returns a log record instance,
| then that instance is used in place of the original log record in
| any further processing of the event by that handler.
| If a filter returns any other true value, the original log record
| is used in any further processing of the event by that handler.
|
| If none of the filters return false values, this method returns
| a log record.
| If any of the filters return a false value, this method returns
| a false value.
|
| .. versionchanged:: 3.2
|
| Allow filters to be just callables.
|
| .. versionchanged:: 3.12
| Allow filters to return a LogRecord instead of
| modifying it in place.
|
| removeFilter(self, filter)
| Remove the specified filter from this handler.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Filterer:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LoggerAdapter(builtins.object)
| LoggerAdapter(logger, extra=None)
|
| An adapter for loggers which makes it easier to specify contextual
| information in logging output.
|
| Methods defined here:
|
| __init__(self, logger, extra=None)
| Initialize the adapter with a logger and a dict-like object which
| provides contextual information. This constructor signature allows
| easy stacking of LoggerAdapters, if so desired.
|
| You can effectively pass keyword arguments as shown in the
| following example:
|
| adapter = LoggerAdapter(someLogger, dict(p1=v1, p2="v2"))
|
| __repr__(self)
| Return repr(self).
|
| critical(self, msg, *args, **kwargs)
| Delegate a critical call to the underlying logger.
|
| debug(self, msg, *args, **kwargs)
| Delegate a debug call to the underlying logger.
|
| error(self, msg, *args, **kwargs)
| Delegate an error call to the underlying logger.
|
| exception(self, msg, *args, exc_info=True, **kwargs)
| Delegate an exception call to the underlying logger.
|
| getEffectiveLevel(self)
| Get the effective level for the underlying logger.
|
| hasHandlers(self)
| See if the underlying logger has any handlers.
|
| info(self, msg, *args, **kwargs)
| Delegate an info call to the underlying logger.
|
| isEnabledFor(self, level)
| Is this logger enabled for level 'level'?
|
| log(self, level, msg, *args, **kwargs)
| Delegate a log call to the underlying logger, after adding
| contextual information from this adapter instance.
|
| process(self, msg, kwargs)
| Process the logging message and keyword arguments passed in to
| a logging call to insert contextual information. You can either
| manipulate the message itself, the keyword args or both. Return
| the message and kwargs modified (or not) to suit your needs.
|
| Normally, you'll only need to override this one method in a
| LoggerAdapter subclass for your specific needs.
|
| setLevel(self, level)
| Set the specified level on the underlying logger.
|
| warn(self, msg, *args, **kwargs)
|
| warning(self, msg, *args, **kwargs)
| Delegate a warning call to the underlying logger.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| name
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| manager
class NullHandler(Handler)
| NullHandler(level=0)
|
| This handler does nothing. It's intended to be used to avoid the
| "No handlers could be found for logger XXX" one-off warning. This is
| important for library code, which may contain code to log events. If a user
| of the library does not configure logging, the one-off warning might be
| produced; to avoid this, the library developer simply needs to instantiate
| a NullHandler and add it to the top-level logger of the library module or
| package.
|
| Method resolution order:
| NullHandler
| Handler
| Filterer
| builtins.object
|
| Methods defined here:
|
| createLock(self)
| Acquire a thread lock for serializing access to the underlying I/O.
|
| emit(self, record)
| Stub.
|
| handle(self, record)
| Stub.
|
| ----------------------------------------------------------------------
| Methods inherited from Handler:
|
| __init__(self, level=0)
| Initializes the instance - basically setting the formatter to None
| and the filter list to empty.
|
| __repr__(self)
| Return repr(self).
|
| acquire(self)
| Acquire the I/O thread lock.
|
| close(self)
| Tidy up any resources used by the handler.
|
| This version removes the handler from an internal map of handlers,
| _handlers, which is used for handler lookup by name. Subclasses
| should ensure that this gets called from overridden close()
| methods.
|
| flush(self)
| Ensure all logging output has been flushed.
|
| This version does nothing and is intended to be implemented by
| subclasses.
|
| format(self, record)
| Format the specified record.
|
| If a formatter is set, use it. Otherwise, use the default formatter
| for the module.
|
| get_name(self)
|
| handleError(self, record)
| Handle errors which occur during an emit() call.
|
| This method should be called from handlers when an exception is
| encountered during an emit() call. If raiseExceptions is false,
| exceptions get silently ignored. This is what is mostly wanted
| for a logging system - most users will not care about errors in
| the logging system, they are more interested in application errors.
| You could, however, replace this with a custom handler if you wish.
| The record which was being processed is passed in to this method.
|
| release(self)
| Release the I/O thread lock.
|
| setFormatter(self, fmt)
| Set the formatter for this handler.
|
| setLevel(self, level)
| Set the logging level of this handler. level must be an int or a str.
|
| set_name(self, name)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Handler:
|
| name
|
| ----------------------------------------------------------------------
| Methods inherited from Filterer:
|
| addFilter(self, filter)
| Add the specified filter to this handler.
|
| filter(self, record)
| Determine if a record is loggable by consulting all the filters.
|
| The default is to allow the record to be logged; any filter can veto
| this by returning a false value.
| If a filter attached to a handler returns a log record instance,
| then that instance is used in place of the original log record in
| any further processing of the event by that handler.
| If a filter returns any other true value, the original log record
| is used in any further processing of the event by that handler.
|
| If none of the filters return false values, this method returns
| a log record.
| If any of the filters return a false value, this method returns
| a false value.
|
| .. versionchanged:: 3.2
|
| Allow filters to be just callables.
|
| .. versionchanged:: 3.12
| Allow filters to return a LogRecord instead of
| modifying it in place.
|
| removeFilter(self, filter)
| Remove the specified filter from this handler.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Filterer:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class StreamHandler(Handler)
| StreamHandler(stream=None)
|
| A handler class which writes logging records, appropriately formatted,
| to a stream. Note that this class does not close the stream, as
| sys.stdout or sys.stderr may be used.
|
| Method resolution order:
| StreamHandler
| Handler
| Filterer
| builtins.object
|
| Methods defined here:
|
| __init__(self, stream=None)
| Initialize the handler.
|
| If stream is not specified, sys.stderr is used.
|
| __repr__(self)
| Return repr(self).
|
| emit(self, record)
| Emit a record.
|
| If a formatter is specified, it is used to format the record.
| The record is then written to the stream with a trailing newline. If
| exception information is present, it is formatted using
| traceback.print_exception and appended to the stream. If the stream
| has an 'encoding' attribute, it is used to determine how to do the
| output to the stream.
|
| flush(self)
| Flushes the stream.
|
| setStream(self, stream)
| Sets the StreamHandler's stream to the specified value,
| if it is different.
|
| Returns the old stream, if the stream was changed, or None
| if it wasn't.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| terminator = '\n'
|
| ----------------------------------------------------------------------
| Methods inherited from Handler:
|
| acquire(self)
| Acquire the I/O thread lock.
|
| close(self)
| Tidy up any resources used by the handler.
|
| This version removes the handler from an internal map of handlers,
| _handlers, which is used for handler lookup by name. Subclasses
| should ensure that this gets called from overridden close()
| methods.
|
| createLock(self)
| Acquire a thread lock for serializing access to the underlying I/O.
|
| format(self, record)
| Format the specified record.
|
| If a formatter is set, use it. Otherwise, use the default formatter
| for the module.
|
| get_name(self)
|
| handle(self, record)
| Conditionally emit the specified logging record.
|
| Emission depends on filters which may have been added to the handler.
| Wrap the actual emission of the record with acquisition/release of
| the I/O thread lock.
|
| Returns an instance of the log record that was emitted
| if it passed all filters, otherwise a false value is returned.
|
| handleError(self, record)
| Handle errors which occur during an emit() call.
|
| This method should be called from handlers when an exception is
| encountered during an emit() call. If raiseExceptions is false,
| exceptions get silently ignored. This is what is mostly wanted
| for a logging system - most users will not care about errors in
| the logging system, they are more interested in application errors.
| You could, however, replace this with a custom handler if you wish.
| The record which was being processed is passed in to this method.
|
| release(self)
| Release the I/O thread lock.
|
| setFormatter(self, fmt)
| Set the formatter for this handler.
|
| setLevel(self, level)
| Set the logging level of this handler. level must be an int or a str.
|
| set_name(self, name)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Handler:
|
| name
|
| ----------------------------------------------------------------------
| Methods inherited from Filterer:
|
| addFilter(self, filter)
| Add the specified filter to this handler.
|
| filter(self, record)
| Determine if a record is loggable by consulting all the filters.
|
| The default is to allow the record to be logged; any filter can veto
| this by returning a false value.
| If a filter attached to a handler returns a log record instance,
| then that instance is used in place of the original log record in
| any further processing of the event by that handler.
| If a filter returns any other true value, the original log record
| is used in any further processing of the event by that handler.
|
| If none of the filters return false values, this method returns
| a log record.
| If any of the filters return a false value, this method returns
| a false value.
|
| .. versionchanged:: 3.2
|
| Allow filters to be just callables.
|
| .. versionchanged:: 3.12
| Allow filters to return a LogRecord instead of
| modifying it in place.
|
| removeFilter(self, filter)
| Remove the specified filter from this handler.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Filterer:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
addLevelName(level, levelName)
Associate 'levelName' with 'level'.
This is used when converting levels to text during message formatting.
basicConfig(**kwargs)
Do basic configuration for the logging system.
This function does nothing if the root logger already has handlers
configured, unless the keyword argument *force* is set to ``True``.
It is a convenience method intended for use by simple scripts
to do one-shot configuration of the logging package.
The default behaviour is to create a StreamHandler which writes to
sys.stderr, set a formatter using the BASIC_FORMAT format string, and
add the handler to the root logger.
A number of optional keyword arguments may be specified, which can alter
the default behaviour.
filename Specifies that a FileHandler be created, using the specified
filename, rather than a StreamHandler.
filemode Specifies the mode to open the file, if filename is specified
(if filemode is unspecified, it defaults to 'a').
format Use the specified format string for the handler.
datefmt Use the specified date/time format.
style If a format string is specified, use this to specify the
type of format string (possible values '%', '{', '$', for
%-formatting, :meth:`str.format` and :class:`string.Template`
- defaults to '%').
level Set the root logger level to the specified level.
stream Use the specified stream to initialize the StreamHandler. Note
that this argument is incompatible with 'filename' - if both
are present, 'stream' is ignored.
handlers If specified, this should be an iterable of already created
handlers, which will be added to the root logger. Any handler
in the list which does not have a formatter assigned will be
assigned the formatter created in this function.
force If this keyword is specified as true, any existing handlers
attached to the root logger are removed and closed, before
carrying out the configuration as specified by the other
arguments.
encoding If specified together with a filename, this encoding is passed to
the created FileHandler, causing it to be used when the file is
opened.
errors If specified together with a filename, this value is passed to the
created FileHandler, causing it to be used when the file is
opened in text mode. If not specified, the default value is
`backslashreplace`.
Note that you could specify a stream created using open(filename, mode)
rather than passing the filename and mode in. However, it should be
remembered that StreamHandler does not close its stream (since it may be
using sys.stdout or sys.stderr), whereas FileHandler closes its stream
when the handler is closed.
.. versionchanged:: 3.2
Added the ``style`` parameter.
.. versionchanged:: 3.3
Added the ``handlers`` parameter. A ``ValueError`` is now thrown for
incompatible arguments (e.g. ``handlers`` specified together with
``filename``/``filemode``, or ``filename``/``filemode`` specified
together with ``stream``, or ``handlers`` specified together with
``stream``.
.. versionchanged:: 3.8
Added the ``force`` parameter.
.. versionchanged:: 3.9
Added the ``encoding`` and ``errors`` parameters.
captureWarnings(capture)
If capture is true, redirect all warnings to the logging package.
If capture is False, ensure that warnings are not redirected to logging
but to their original destinations.
critical(msg, *args, **kwargs)
Log a message with severity 'CRITICAL' on the root logger. If the logger
has no handlers, call basicConfig() to add a console handler with a
pre-defined format.
debug(msg, *args, **kwargs)
Log a message with severity 'DEBUG' on the root logger. If the logger has
no handlers, call basicConfig() to add a console handler with a pre-defined
format.
disable(level=50)
Disable all logging calls of severity 'level' and below.
error(msg, *args, **kwargs)
Log a message with severity 'ERROR' on the root logger. If the logger has
no handlers, call basicConfig() to add a console handler with a pre-defined
format.
exception(msg, *args, exc_info=True, **kwargs)
Log a message with severity 'ERROR' on the root logger, with exception
information. If the logger has no handlers, basicConfig() is called to add
a console handler with a pre-defined format.
fatal(msg, *args, **kwargs)
Don't use this function, use critical() instead.
getHandlerByName(name)
Get a handler with the specified *name*, or None if there isn't one with
that name.
getHandlerNames()
Return all known handler names as an immutable set.
getLevelName(level)
Return the textual or numeric representation of logging level 'level'.
If the level is one of the predefined levels (CRITICAL, ERROR, WARNING,
INFO, DEBUG) then you get the corresponding string. If you have
associated levels with names using addLevelName then the name you have
associated with 'level' is returned.
If a numeric value corresponding to one of the defined levels is passed
in, the corresponding string representation is returned.
If a string representation of the level is passed in, the corresponding
numeric value is returned.
If no matching numeric or string value is passed in, the string
'Level %s' % level is returned.
getLevelNamesMapping()
getLogRecordFactory()
Return the factory to be used when instantiating a log record.
getLogger(name=None)
Return a logger with the specified name, creating it if necessary.
If no name is specified, return the root logger.
getLoggerClass()
Return the class to be used when instantiating a logger.
info(msg, *args, **kwargs)
Log a message with severity 'INFO' on the root logger. If the logger has
no handlers, call basicConfig() to add a console handler with a pre-defined
format.
log(level, msg, *args, **kwargs)
Log 'msg % args' with the integer severity 'level' on the root logger. If
the logger has no handlers, call basicConfig() to add a console handler
with a pre-defined format.
makeLogRecord(dict)
Make a LogRecord whose attributes are defined by the specified dictionary,
This function is useful for converting a logging event received over
a socket connection (which is sent as a dictionary) into a LogRecord
instance.
setLogRecordFactory(factory)
Set the factory to be used when instantiating a log record.
:param factory: A callable which will be called to instantiate
a log record.
setLoggerClass(klass)
Set the class to be used when instantiating a logger. The class should
define __init__() such that only a name argument is required, and the
__init__() should call Logger.__init__()
shutdown(handlerList=[<weakref at 0x00000245A85D0180; to '_StderrHandler' at 0x00000245A85C0C20>])
Perform any cleanup actions in the logging system (e.g. flushing
buffers).
Should be called at application exit.
warn(msg, *args, **kwargs)
warning(msg, *args, **kwargs)
Log a message with severity 'WARNING' on the root logger. If the logger has
no handlers, call basicConfig() to add a console handler with a pre-defined
format.
DATA
BASIC_FORMAT = '%(levelname)s:%(name)s:%(message)s'
CRITICAL = 50
DEBUG = 10
ERROR = 40
FATAL = 50
INFO = 20
NOTSET = 0
WARN = 30
WARNING = 30
__all__ = ['BASIC_FORMAT', 'BufferingFormatter', 'CRITICAL', 'DEBUG', ...
__status__ = 'production'
lastResort = <_StderrHandler <stderr> (WARNING)>
raiseExceptions = True
VERSION
0.5.1.2
DATE
07 February 2010
AUTHOR
Vinay Sajip <vinay_sajip@red-dove.com>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\logging\__init__.py
matplotlib.matplotlib_fname
Python Library Documentation: function matplotlib_fname in module matplotlib
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.
matplotlib.namedtuple
Python Library Documentation: function namedtuple in module collections
namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
Returns a new subclass of tuple with named fields.
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__ # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22) # instantiate with positional args or keywords
>>> p[0] + p[1] # indexable like a plain tuple
33
>>> x, y = p # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y # fields also accessible by name
33
>>> d = p._asdict() # convert to a dictionary
>>> d['x']
11
>>> Point(**d) # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)
matplotlib.os
Python Library Documentation: module os
NAME
os - OS routines for NT or Posix depending on what system we're on.
MODULE REFERENCE
https://docs.python.org/3.12/library/os.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This exports:
- all functions from posix or nt, e.g. unlink, stat, etc.
- os.path is either posixpath or ntpath
- os.name is either 'posix' or 'nt'
- os.curdir is a string representing the current directory (always '.')
- os.pardir is a string representing the parent directory (always '..')
- os.sep is the (or a most common) pathname separator ('/' or '\\')
- os.extsep is the extension separator (always '.')
- os.altsep is the alternate pathname separator (None or '/')
- os.pathsep is the component separator used in $PATH etc
- os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
- os.defpath is the default search path for executables
- os.devnull is the file path of the null device ('/dev/null', etc.)
Programs that import and use 'os' stand a better chance of being
portable between different platforms. Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
CLASSES
builtins.Exception(builtins.BaseException)
builtins.OSError
builtins.object
nt.DirEntry
builtins.tuple(builtins.object)
nt.times_result
nt.uname_result
stat_result
statvfs_result
terminal_size
class DirEntry(builtins.object)
| Methods defined here:
|
| __fspath__(self, /)
| Returns the path for the entry.
|
| __repr__(self, /)
| Return repr(self).
|
| inode(self, /)
| Return inode of the entry; cached per entry.
|
| is_dir(self, /, *, follow_symlinks=True)
| Return True if the entry is a directory; cached per entry.
|
| is_file(self, /, *, follow_symlinks=True)
| Return True if the entry is a file; cached per entry.
|
| is_junction(self, /)
| Return True if the entry is a junction; cached per entry.
|
| is_symlink(self, /)
| Return True if the entry is a symbolic link; cached per entry.
|
| stat(self, /, *, follow_symlinks=True)
| Return stat_result object for the entry; cached per entry.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| name
| the entry's base filename, relative to scandir() "path" argument
|
| path
| the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)
error = class OSError(Exception)
| Base class for I/O related errors.
|
| Method resolution order:
| OSError
| Exception
| BaseException
| object
|
| Built-in subclasses:
| BlockingIOError
| ChildProcessError
| ConnectionError
| FileExistsError
| ... and 7 other subclasses
|
| Methods defined here:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(...)
| Helper for pickle.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class stat_result(builtins.tuple)
| stat_result(iterable=(), /)
|
| stat_result: Result from stat, fstat, or lstat.
|
| This object may be accessed either as a tuple of
| (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
| or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.
|
| Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,
| or st_flags, they are available as attributes only.
|
| See os.stat for more information.
|
| Method resolution order:
| stat_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| st_atime
| time of last access
|
| st_atime_ns
| time of last access in nanoseconds
|
| st_birthtime
| time of creation
|
| st_birthtime_ns
| time of creation in nanoseconds
|
| st_ctime
| time of last change
|
| st_ctime_ns
| time of last change in nanoseconds
|
| st_dev
| device
|
| st_file_attributes
| Windows file attribute bits
|
| st_gid
| group ID of owner
|
| st_ino
| inode
|
| st_mode
| protection bits
|
| st_mtime
| time of last modification
|
| st_mtime_ns
| time of last modification in nanoseconds
|
| st_nlink
| number of hard links
|
| st_reparse_tag
| Windows reparse tag
|
| st_size
| total size, in bytes
|
| st_uid
| user ID of owner
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('st_mode', 'st_ino', 'st_dev', 'st_nlink', 'st_uid',...
|
| n_fields = 20
|
| n_sequence_fields = 10
|
| n_unnamed_fields = 3
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class statvfs_result(builtins.tuple)
| statvfs_result(iterable=(), /)
|
| statvfs_result: Result from statvfs or fstatvfs.
|
| This object may be accessed either as a tuple of
| (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),
| or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.
|
| See os.statvfs for more information.
|
| Method resolution order:
| statvfs_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| f_bavail
|
| f_bfree
|
| f_blocks
|
| f_bsize
|
| f_favail
|
| f_ffree
|
| f_files
|
| f_flag
|
| f_frsize
|
| f_fsid
|
| f_namemax
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bav...
|
| n_fields = 11
|
| n_sequence_fields = 10
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class terminal_size(builtins.tuple)
| terminal_size(iterable=(), /)
|
| A tuple of (columns, lines) for holding terminal window size
|
| Method resolution order:
| terminal_size
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| columns
| width of the terminal window in characters
|
| lines
| height of the terminal window in characters
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('columns', 'lines')
|
| n_fields = 2
|
| n_sequence_fields = 2
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class times_result(builtins.tuple)
| times_result(iterable=(), /)
|
| times_result: Result from os.times().
|
| This object may be accessed either as a tuple of
| (user, system, children_user, children_system, elapsed),
| or via the attributes user, system, children_user, children_system,
| and elapsed.
|
| See os.times for more information.
|
| Method resolution order:
| times_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| children_system
| system time of children
|
| children_user
| user time of children
|
| elapsed
| elapsed time since an arbitrary point in the past
|
| system
| system time
|
| user
| user time
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('user', 'system', 'children_user', 'children_system'...
|
| n_fields = 5
|
| n_sequence_fields = 5
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
class uname_result(builtins.tuple)
| uname_result(iterable=(), /)
|
| uname_result: Result from os.uname().
|
| This object may be accessed either as a tuple of
| (sysname, nodename, release, version, machine),
| or via the attributes sysname, nodename, release, version, and machine.
|
| See os.uname for more information.
|
| Method resolution order:
| uname_result
| builtins.tuple
| builtins.object
|
| Methods defined here:
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| machine
| hardware identifier
|
| nodename
| name of machine on network (implementation-defined)
|
| release
| operating system release
|
| sysname
| operating system name
|
| version
| operating system version
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __match_args__ = ('sysname', 'nodename', 'release', 'version', 'machin...
|
| n_fields = 5
|
| n_sequence_fields = 5
|
| n_unnamed_fields = 0
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.tuple:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.tuple:
|
| __class_getitem__(...)
| See PEP 585
FUNCTIONS
_exit(status)
Exit to the system with specified status, without normal exit processing.
abort()
Abort the interpreter immediately.
This function 'dumps core' or otherwise fails in the hardest way possible
on the hosting operating system. This function never returns.
access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)
Use the real uid/gid to test for access to a path.
path
Path to be tested; can be string, bytes, or a path-like object.
mode
Operating-system mode bitfield. Can be F_OK to test existence,
or the inclusive-OR of R_OK, W_OK, and X_OK.
dir_fd
If not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that
directory.
effective_ids
If True, access will use the effective uid/gid instead of
the real uid/gid.
follow_symlinks
If False, and the last element of the path is a symbolic link,
access will examine the symbolic link itself instead of the file
the link points to.
dir_fd, effective_ids, and follow_symlinks may not be implemented
on your platform. If they are unavailable, using them will raise a
NotImplementedError.
Note that most operations will use the effective uid/gid, therefore this
routine can be used in a suid/sgid environment to test if the invoking user
has the specified access to the path.
chdir(path)
Change the current working directory to the specified path.
path may always be specified as a string.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
chmod(path, mode, *, dir_fd=None, follow_symlinks=True)
Change the access permissions of a file.
path
Path to be modified. May always be specified as a str, bytes, or a path-like object.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
mode
Operating-system mode bitfield.
Be careful when using number literals for *mode*. The conventional UNIX notation for
numeric modes uses an octal base, which needs to be indicated with a ``0o`` prefix in
Python.
dir_fd
If not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that
directory.
follow_symlinks
If False, and the last element of the path is a symbolic link,
chmod will modify the symbolic link itself instead of the file
the link points to.
It is an error to use dir_fd or follow_symlinks when specifying path as
an open file descriptor.
dir_fd and follow_symlinks may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError.
close(fd)
Close a file descriptor.
closerange(fd_low, fd_high, /)
Closes all file descriptors in [fd_low, fd_high), ignoring errors.
cpu_count()
Return the number of CPUs in the system; return None if indeterminable.
This number is not equivalent to the number of CPUs the current process can
use. The number of usable CPUs can be obtained with
``len(os.sched_getaffinity(0))``
device_encoding(fd)
Return a string describing the encoding of a terminal's file descriptor.
The file descriptor must be attached to a terminal.
If the device is not a terminal, return None.
dup(fd, /)
Return a duplicate of a file descriptor.
dup2(fd, fd2, inheritable=True)
Duplicate file descriptor.
execl(file, *args)
execl(file, *args)
Execute the executable file with argument list args, replacing the
current process.
execle(file, *args)
execle(file, *args, env)
Execute the executable file with argument list args and
environment env, replacing the current process.
execlp(file, *args)
execlp(file, *args)
Execute the executable file (which is searched for along $PATH)
with argument list args, replacing the current process.
execlpe(file, *args)
execlpe(file, *args, env)
Execute the executable file (which is searched for along $PATH)
with argument list args and environment env, replacing the current
process.
execv(path, argv, /)
Execute an executable path with arguments, replacing current process.
path
Path of executable file.
argv
Tuple or list of strings.
execve(path, argv, env)
Execute an executable path with arguments, replacing current process.
path
Path of executable file.
argv
Tuple or list of strings.
env
Dictionary of strings mapping to strings.
execvp(file, args)
execvp(file, args)
Execute the executable file (which is searched for along $PATH)
with argument list args, replacing the current process.
args may be a list or tuple of strings.
execvpe(file, args, env)
execvpe(file, args, env)
Execute the executable file (which is searched for along $PATH)
with argument list args and environment env, replacing the
current process.
args may be a list or tuple of strings.
fdopen(fd, mode='r', buffering=-1, encoding=None, *args, **kwargs)
fsdecode(filename)
Decode filename (an os.PathLike, bytes, or str) from the filesystem
encoding with 'surrogateescape' error handler, return str unchanged. On
Windows, use 'strict' error handler if the file system encoding is
'mbcs' (which is the default encoding).
fsencode(filename)
Encode filename (an os.PathLike, bytes, or str) to the filesystem
encoding with 'surrogateescape' error handler, return bytes unchanged.
On Windows, use 'strict' error handler if the file system encoding is
'mbcs' (which is the default encoding).
fspath(path)
Return the file system path representation of the object.
If the object is str or bytes, then allow it to pass through as-is. If the
object defines __fspath__(), then return the result of that method. All other
types raise a TypeError.
fstat(fd)
Perform a stat system call on the given file descriptor.
Like stat(), but for an open file descriptor.
Equivalent to os.stat(fd).
fsync(fd)
Force write of fd to disk.
ftruncate(fd, length, /)
Truncate a file, specified by file descriptor, to a specific length.
get_blocking(fd, /)
Get the blocking mode of the file descriptor.
Return False if the O_NONBLOCK flag is set, True if the flag is cleared.
get_exec_path(env=None)
Returns the sequence of directories that will be searched for the
named executable (similar to a shell) when launching a process.
*env* must be an environment variable dict or None. If *env* is None,
os.environ will be used.
get_handle_inheritable(handle, /)
Get the close-on-exe flag of the specified file descriptor.
get_inheritable(fd, /)
Get the close-on-exe flag of the specified file descriptor.
get_terminal_size(...)
Return the size of the terminal window as (columns, lines).
The optional argument fd (default standard output) specifies
which file descriptor should be queried.
If the file descriptor is not connected to a terminal, an OSError
is thrown.
This function will only be defined if an implementation is
available for this system.
shutil.get_terminal_size is the high-level function which should
normally be used, os.get_terminal_size is the low-level implementation.
getcwd()
Return a unicode string representing the current working directory.
getcwdb()
Return a bytes string representing the current working directory.
getenv(key, default=None)
Get an environment variable, return None if it doesn't exist.
The optional second argument can specify an alternate default.
key, default and the result are str.
getlogin()
Return the actual login name.
getpid()
Return the current process id.
getppid()
Return the parent's process id.
If the parent process has already exited, Windows machines will still
return its id; others systems will return the id of the 'init' process (1).
isatty(fd, /)
Return True if the fd is connected to a terminal.
Return True if the file descriptor is an open file descriptor
connected to the slave end of a terminal.
kill(pid, signal, /)
Kill a process with a signal.
link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)
Create a hard link to a file.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
If follow_symlinks is False, and the last element of src is a symbolic
link, link will create a link to the symbolic link itself instead of the
file the link points to.
src_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your
platform. If they are unavailable, using them will raise a
NotImplementedError.
listdir(path=None)
Return a list containing the names of the files in the directory.
path can be specified as either str, bytes, or a path-like object. If path is bytes,
the filenames returned will also be bytes; in all other circumstances
the filenames returned will be str.
If path is None, uses the path='.'.
On some platforms, path may also be specified as an open file descriptor;\
the file descriptor must refer to a directory.
If this functionality is unavailable, using it raises NotImplementedError.
The list is in arbitrary order. It does not include the special
entries '.' and '..' even if they are present in the directory.
listdrives()
Return a list containing the names of drives in the system.
A drive name typically looks like 'C:\\'.
listmounts(volume)
Return a list containing mount points for a particular volume.
'volume' should be a GUID path as returned from os.listvolumes.
listvolumes()
Return a list containing the volumes in the system.
Volumes are typically represented as a GUID path.
lseek(fd, position, whence, /)
Set the position of a file descriptor. Return the new position.
fd
An open file descriptor, as returned by os.open().
position
Position, interpreted relative to 'whence'.
whence
The relative position to seek from. Valid values are:
- SEEK_SET: seek from the start of the file.
- SEEK_CUR: seek from the current file position.
- SEEK_END: seek from the end of the file.
The return value is the number of bytes relative to the beginning of the file.
lstat(path, *, dir_fd=None)
Perform a stat system call on the given path, without following symbolic links.
Like stat(), but do not follow symbolic links.
Equivalent to stat(path, follow_symlinks=False).
makedirs(name, mode=511, exist_ok=False)
makedirs(name [, mode=0o777][, exist_ok=False])
Super-mkdir; create a leaf directory and all intermediate ones. Works like
mkdir, except that any intermediate path segment (not just the rightmost)
will be created if it does not exist. If the target directory already
exists, raise an OSError if exist_ok is False. Otherwise no exception is
raised. This is recursive.
mkdir(path, mode=511, *, dir_fd=None)
Create a directory.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
The mode argument is ignored on Windows. Where it is used, the current umask
value is first masked out.
open(path, flags, mode=511, *, dir_fd=None)
Open a file for low level IO. Returns a file descriptor (integer).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
pipe()
Create a pipe.
Returns a tuple of two file descriptors:
(read_fd, write_fd)
popen(cmd, mode='r', buffering=-1)
putenv(name, value, /)
Change or add an environment variable.
read(fd, length, /)
Read from a file descriptor. Returns a bytes object.
readlink(path, *, dir_fd=None)
Return a string representing the path to which the symbolic link points.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform. If it is unavailable,
using it will raise a NotImplementedError.
remove(path, *, dir_fd=None)
Remove a file (same as unlink()).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
removedirs(name)
removedirs(name)
Super-rmdir; remove a leaf directory and all empty intermediate
ones. Works like rmdir except that, if the leaf directory is
successfully removed, directories corresponding to rightmost path
segments will be pruned away until either the whole path is
consumed or an error occurs. Errors during this latter phase are
ignored -- they generally mean that a directory was not empty.
rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
Rename a file or directory.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
src_dir_fd and dst_dir_fd, may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError.
renames(old, new)
renames(old, new)
Super-rename; create directories as necessary and delete any left
empty. Works like rename, except creation of any intermediate
directories needed to make the new pathname good is attempted
first. After the rename, directories corresponding to rightmost
path segments of the old name will be pruned until either the
whole path is consumed or a nonempty directory is found.
Note: this function can fail with the new directory structure made
if you lack permissions needed to unlink the leaf directory or
file.
replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
Rename a file or directory, overwriting the destination.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
src_dir_fd and dst_dir_fd, may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError.
rmdir(path, *, dir_fd=None)
Remove a directory.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
scandir(path=None)
Return an iterator of DirEntry objects for given path.
path can be specified as either str, bytes, or a path-like object. If path
is bytes, the names of yielded DirEntry objects will also be bytes; in
all other circumstances they will be str.
If path is None, uses the path='.'.
set_blocking(fd, blocking, /)
Set the blocking mode of the specified file descriptor.
Set the O_NONBLOCK flag if blocking is False,
clear the O_NONBLOCK flag otherwise.
set_handle_inheritable(handle, inheritable, /)
Set the inheritable flag of the specified handle.
set_inheritable(fd, inheritable, /)
Set the inheritable flag of the specified file descriptor.
spawnl(mode, file, *args)
spawnl(mode, file, *args) -> integer
Execute file with arguments from args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it.
spawnle(mode, file, *args)
spawnle(mode, file, *args, env) -> integer
Execute file with arguments from args in a subprocess with the
supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it.
spawnv(mode, path, argv, /)
Execute the program specified by path in a new process.
mode
Mode of process creation.
path
Path of executable file.
argv
Tuple or list of strings.
spawnve(mode, path, argv, env, /)
Execute the program specified by path in a new process.
mode
Mode of process creation.
path
Path of executable file.
argv
Tuple or list of strings.
env
Dictionary of strings mapping to strings.
startfile(...)
Start a file with its associated application.
When "operation" is not specified or "open", this acts like
double-clicking the file in Explorer, or giving the file name as an
argument to the DOS "start" command: the file is opened with whatever
application (if any) its extension is associated.
When another "operation" is given, it specifies what should be done with
the file. A typical operation is "print".
"arguments" is passed to the application, but should be omitted if the
file is a document.
"cwd" is the working directory for the operation. If "filepath" is
relative, it will be resolved against this directory. This argument
should usually be an absolute path.
"show_cmd" can be used to override the recommended visibility option.
See the Windows ShellExecute documentation for values.
startfile returns as soon as the associated application is launched.
There is no option to wait for the application to close, and no way
to retrieve the application's exit status.
The filepath is relative to the current directory. If you want to use
an absolute path, make sure the first character is not a slash ("/");
the underlying Win32 ShellExecute function doesn't work if it is.
stat(path, *, dir_fd=None, follow_symlinks=True)
Perform a stat system call on the given path.
path
Path to be examined; can be string, bytes, a path-like object or
open-file-descriptor int.
dir_fd
If not None, it should be a file descriptor open to a directory,
and path should be a relative string; path will then be relative to
that directory.
follow_symlinks
If False, and the last element of the path is a symbolic link,
stat will examine the symbolic link itself instead of the file
the link points to.
dir_fd and follow_symlinks may not be implemented
on your platform. If they are unavailable, using them will raise a
NotImplementedError.
It's an error to use dir_fd or follow_symlinks when specifying path as
an open file descriptor.
strerror(code, /)
Translate an error code to a message string.
symlink(src, dst, target_is_directory=False, *, dir_fd=None)
Create a symbolic link pointing to src named dst.
target_is_directory is required on Windows if the target is to be
interpreted as a directory. (On Windows, symlink requires
Windows 6.0 or greater, and raises a NotImplementedError otherwise.)
target_is_directory is ignored on non-Windows platforms.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
system(command)
Execute the command in a subshell.
times()
Return a collection containing process timing information.
The object returned behaves like a named tuple with these fields:
(utime, stime, cutime, cstime, elapsed_time)
All fields are floating-point numbers.
truncate(path, length)
Truncate a file, specified by path, to a specific length.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
umask(mask, /)
Set the current numeric umask and return the previous umask.
unlink(path, *, dir_fd=None)
Remove a file (same as remove()).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
unsetenv(name, /)
Delete an environment variable.
urandom(size, /)
Return a bytes object containing random bytes suitable for cryptographic use.
utime(...)
Set the access and modified time of path.
path may always be specified as a string.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
If times is not None, it must be a tuple (atime, mtime);
atime and mtime should be expressed as float seconds since the epoch.
If ns is specified, it must be a tuple (atime_ns, mtime_ns);
atime_ns and mtime_ns should be expressed as integer nanoseconds
since the epoch.
If times is None and ns is unspecified, utime uses the current time.
Specifying tuples for both times and ns is an error.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
If follow_symlinks is False, and the last element of the path is a symbolic
link, utime will modify the symbolic link itself instead of the file the
link points to.
It is an error to use dir_fd or follow_symlinks when specifying path
as an open file descriptor.
dir_fd and follow_symlinks may not be available on your platform.
If they are unavailable, using them will raise a NotImplementedError.
waitpid(pid, options, /)
Wait for completion of a given process.
Returns a tuple of information regarding the process:
(pid, status << 8)
The options argument is ignored on Windows.
waitstatus_to_exitcode(status)
Convert a wait status to an exit code.
On Unix:
* If WIFEXITED(status) is true, return WEXITSTATUS(status).
* If WIFSIGNALED(status) is true, return -WTERMSIG(status).
* Otherwise, raise a ValueError.
On Windows, return status shifted right by 8 bits.
On Unix, if the process is being traced or if waitpid() was called with
WUNTRACED option, the caller must first check if WIFSTOPPED(status) is true.
This function must not be called if WIFSTOPPED(status) is true.
walk(top, topdown=True, onerror=None, followlinks=False)
Directory tree generator.
For each directory in the directory tree rooted at top (including top
itself, but excluding '.' and '..'), yields a 3-tuple
dirpath, dirnames, filenames
dirpath is a string, the path to the directory. dirnames is a list of
the names of the subdirectories in dirpath (including symlinks to directories,
and excluding '.' and '..').
filenames is a list of the names of the non-directory files in dirpath.
Note that the names in the lists are just names, with no path components.
To get a full path (which begins with top) to a file or directory in
dirpath, do os.path.join(dirpath, name).
If optional arg 'topdown' is true or not specified, the triple for a
directory is generated before the triples for any of its subdirectories
(directories are generated top down). If topdown is false, the triple
for a directory is generated after the triples for all of its
subdirectories (directories are generated bottom up).
When topdown is true, the caller can modify the dirnames list in-place
(e.g., via del or slice assignment), and walk will only recurse into the
subdirectories whose names remain in dirnames; this can be used to prune the
search, or to impose a specific order of visiting. Modifying dirnames when
topdown is false has no effect on the behavior of os.walk(), since the
directories in dirnames have already been generated by the time dirnames
itself is generated. No matter the value of topdown, the list of
subdirectories is retrieved before the tuples for the directory and its
subdirectories are generated.
By default errors from the os.scandir() call are ignored. If
optional arg 'onerror' is specified, it should be a function; it
will be called with one argument, an OSError instance. It can
report the error to continue with the walk, or raise the exception
to abort the walk. Note that the filename is available as the
filename attribute of the exception object.
By default, os.walk does not follow symbolic links to subdirectories on
systems that support them. In order to get this functionality, set the
optional argument 'followlinks' to true.
Caution: if you pass a relative pathname for top, don't change the
current working directory between resumptions of walk. walk never
changes the current directory, and assumes that the client doesn't
either.
Example:
import os
from os.path import join, getsize
for root, dirs, files in os.walk('python/Lib/email'):
print(root, "consumes ")
print(sum(getsize(join(root, name)) for name in files), end=" ")
print("bytes in", len(files), "non-directory files")
if 'CVS' in dirs:
dirs.remove('CVS') # don't visit CVS directories
write(fd, data, /)
Write a bytes object to a file descriptor.
DATA
EX_OK = 0
F_OK = 0
O_APPEND = 8
O_BINARY = 32768
O_CREAT = 256
O_EXCL = 1024
O_NOINHERIT = 128
O_RANDOM = 16
O_RDONLY = 0
O_RDWR = 2
O_SEQUENTIAL = 32
O_SHORT_LIVED = 4096
O_TEMPORARY = 64
O_TEXT = 16384
O_TRUNC = 512
O_WRONLY = 1
P_DETACH = 4
P_NOWAIT = 1
P_NOWAITO = 3
P_OVERLAY = 2
P_WAIT = 0
R_OK = 4
SEEK_CUR = 1
SEEK_END = 2
SEEK_SET = 0
TMP_MAX = 2147483647
W_OK = 2
X_OK = 1
__all__ = ['altsep', 'curdir', 'pardir', 'sep', 'pathsep', 'linesep', ...
altsep = '/'
curdir = '.'
defpath = r'.;C:\bin'
devnull = 'nul'
environ = environ({'ALLUSERSPROFILE': 'C:\\ProgramData', '...undled\\l...
extsep = '.'
linesep = '\r\n'
name = 'nt'
pardir = '..'
pathsep = ';'
sep = r'\'
supports_bytes_environ = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\os.py
matplotlib.parse_version
Python Library Documentation: function parse in module packaging.version
parse(version: 'str') -> 'Version'
Parse the given version string.
>>> parse('1.0.dev1')
<Version('1.0.dev1')>
:param version: The version string to parse.
:raises InvalidVersion: When the version string is not a valid version.
matplotlib.path
Python Library Documentation: module matplotlib.path in matplotlib
NAME
matplotlib.path - A module for dealing with the polylines used throughout Matplotlib.
DESCRIPTION
The primary class for polyline handling in Matplotlib is `Path`. Almost all
vector drawing makes use of `Path`\s somewhere in the drawing pipeline.
Whilst a `Path` instance itself cannot be drawn, some `.Artist` subclasses,
such as `.PathPatch` and `.PathCollection`, can be used for convenient `Path`
visualisation.
CLASSES
builtins.object
Path
class Path(builtins.object)
| Path(vertices, codes=None, _interpolation_steps=1, closed=False, readonly=False)
|
| A series of possibly disconnected, possibly closed, line and curve
| segments.
|
| The underlying storage is made up of two parallel numpy arrays:
|
| - *vertices*: an (N, 2) float array of vertices
| - *codes*: an N-length `numpy.uint8` array of path codes, or None
|
| These two arrays always have the same length in the first
| dimension. For example, to represent a cubic curve, you must
| provide three vertices and three `CURVE4` codes.
|
| The code types are:
|
| - `STOP` : 1 vertex (ignored)
| A marker for the end of the entire path (currently not required and
| ignored)
|
| - `MOVETO` : 1 vertex
| Pick up the pen and move to the given vertex.
|
| - `LINETO` : 1 vertex
| Draw a line from the current position to the given vertex.
|
| - `CURVE3` : 1 control point, 1 endpoint
| Draw a quadratic Bézier curve from the current position, with the given
| control point, to the given end point.
|
| - `CURVE4` : 2 control points, 1 endpoint
| Draw a cubic Bézier curve from the current position, with the given
| control points, to the given end point.
|
| - `CLOSEPOLY` : 1 vertex (ignored)
| Draw a line segment to the start point of the current polyline.
|
| If *codes* is None, it is interpreted as a `MOVETO` followed by a series
| of `LINETO`.
|
| Users of Path objects should not access the vertices and codes arrays
| directly. Instead, they should use `iter_segments` or `cleaned` to get the
| vertex/code pairs. This helps, in particular, to consistently handle the
| case of *codes* being None.
|
| Some behavior of Path objects can be controlled by rcParams. See the
| rcParams whose keys start with 'path.'.
|
| .. note::
|
| The vertices and codes arrays should be treated as
| immutable -- there are a number of optimizations and assumptions
| made up front in the constructor that will not change when the
| data changes.
|
| Methods defined here:
|
| __deepcopy__(self, memo=None)
| Return a deepcopy of the `Path`. The `Path` will not be
| readonly, even if the source `Path` is.
|
| __init__(self, vertices, codes=None, _interpolation_steps=1, closed=False, readonly=False)
| Create a new path with the given vertices and codes.
|
| Parameters
| ----------
| vertices : (N, 2) array-like
| The path vertices, as an array, masked array or sequence of pairs.
| Masked values, if any, will be converted to NaNs, which are then
| handled correctly by the Agg PathIterator and other consumers of
| path data, such as :meth:`iter_segments`.
| codes : array-like or None, optional
| N-length array of integers representing the codes of the path.
| If not None, codes must be the same length as vertices.
| If None, *vertices* will be treated as a series of line segments.
| _interpolation_steps : int, optional
| Used as a hint to certain projections, such as Polar, that this
| path should be linearly interpolated immediately before drawing.
| This attribute is primarily an implementation detail and is not
| intended for public use.
| closed : bool, optional
| If *codes* is None and closed is True, vertices will be treated as
| line segments of a closed polygon. Note that the last vertex will
| then be ignored (as the corresponding code will be set to
| `CLOSEPOLY`).
| readonly : bool, optional
| Makes the path behave in an immutable way and sets the vertices
| and codes as read-only arrays.
|
| __len__(self)
|
| __repr__(self)
| Return repr(self).
|
| cleaned(self, transform=None, remove_nans=False, clip=None, *, simplify=False, curves=False, stroke_width=1.0, snap=False, sketch=None)
| Return a new `Path` with vertices and codes cleaned according to the
| parameters.
|
| See Also
| --------
| Path.iter_segments : for details of the keyword arguments.
|
| clip_to_bbox(self, bbox, inside=True)
| Clip the path to the given bounding box.
|
| The path must be made up of one or more closed polygons. This
| algorithm will not behave correctly for unclosed paths.
|
| If *inside* is `True`, clip to the inside of the box, otherwise
| to the outside of the box.
|
| contains_path(self, path, transform=None)
| Return whether this (closed) path completely contains the given path.
|
| If *transform* is not ``None``, the path will be transformed before
| checking for containment.
|
| contains_point(self, point, transform=None, radius=0.0)
| Return whether the area enclosed by the path contains the given point.
|
| The path is always treated as closed; i.e. if the last code is not
| `CLOSEPOLY` an implicit segment connecting the last vertex to the first
| vertex is assumed.
|
| Parameters
| ----------
| point : (float, float)
| The point (x, y) to check.
| transform : `~matplotlib.transforms.Transform`, optional
| If not ``None``, *point* will be compared to ``self`` transformed
| by *transform*; i.e. for a correct check, *transform* should
| transform the path into the coordinate system of *point*.
| radius : float, default: 0
| Additional margin on the path in coordinates of *point*.
| The path is extended tangentially by *radius/2*; i.e. if you would
| draw the path with a linewidth of *radius*, all points on the line
| would still be considered to be contained in the area. Conversely,
| negative values shrink the area: Points on the imaginary line
| will be considered outside the area.
|
| Returns
| -------
| bool
|
| Notes
| -----
| The current algorithm has some limitations:
|
| - The result is undefined for points exactly at the boundary
| (i.e. at the path shifted by *radius/2*).
| - The result is undefined if there is no enclosed area, i.e. all
| vertices are on a straight line.
| - If bounding lines start to cross each other due to *radius* shift,
| the result is not guaranteed to be correct.
|
| contains_points(self, points, transform=None, radius=0.0)
| Return whether the area enclosed by the path contains the given points.
|
| The path is always treated as closed; i.e. if the last code is not
| `CLOSEPOLY` an implicit segment connecting the last vertex to the first
| vertex is assumed.
|
| Parameters
| ----------
| points : (N, 2) array
| The points to check. Columns contain x and y values.
| transform : `~matplotlib.transforms.Transform`, optional
| If not ``None``, *points* will be compared to ``self`` transformed
| by *transform*; i.e. for a correct check, *transform* should
| transform the path into the coordinate system of *points*.
| radius : float, default: 0
| Additional margin on the path in coordinates of *points*.
| The path is extended tangentially by *radius/2*; i.e. if you would
| draw the path with a linewidth of *radius*, all points on the line
| would still be considered to be contained in the area. Conversely,
| negative values shrink the area: Points on the imaginary line
| will be considered outside the area.
|
| Returns
| -------
| length-N bool array
|
| Notes
| -----
| The current algorithm has some limitations:
|
| - The result is undefined for points exactly at the boundary
| (i.e. at the path shifted by *radius/2*).
| - The result is undefined if there is no enclosed area, i.e. all
| vertices are on a straight line.
| - If bounding lines start to cross each other due to *radius* shift,
| the result is not guaranteed to be correct.
|
| copy(self)
| Return a shallow copy of the `Path`, which will share the
| vertices and codes with the source `Path`.
|
| deepcopy = __deepcopy__(self, memo=None)
|
| get_extents(self, transform=None, **kwargs)
| Get Bbox of the path.
|
| Parameters
| ----------
| transform : `~matplotlib.transforms.Transform`, optional
| Transform to apply to path before computing extents, if any.
| **kwargs
| Forwarded to `.iter_bezier`.
|
| Returns
| -------
| matplotlib.transforms.Bbox
| The extents of the path Bbox([[xmin, ymin], [xmax, ymax]])
|
| interpolated(self, steps)
| Return a new path resampled to length N x *steps*.
|
| Codes other than `LINETO` are not handled correctly.
|
| intersects_bbox(self, bbox, filled=True)
| Return whether this path intersects a given `~.transforms.Bbox`.
|
| If *filled* is True, then this also returns True if the path completely
| encloses the `.Bbox` (i.e., the path is treated as filled).
|
| The bounding box is always considered filled.
|
| intersects_path(self, other, filled=True)
| Return whether if this path intersects another given path.
|
| If *filled* is True, then this also returns True if one path completely
| encloses the other (i.e., the paths are treated as filled).
|
| iter_bezier(self, **kwargs)
| Iterate over each Bézier curve (lines included) in a `Path`.
|
| Parameters
| ----------
| **kwargs
| Forwarded to `.iter_segments`.
|
| Yields
| ------
| B : `~matplotlib.bezier.BezierSegment`
| The Bézier curves that make up the current path. Note in particular
| that freestanding points are Bézier curves of order 0, and lines
| are Bézier curves of order 1 (with two control points).
| code : `~matplotlib.path.Path.code_type`
| The code describing what kind of curve is being returned.
| `MOVETO`, `LINETO`, `CURVE3`, and `CURVE4` correspond to
| Bézier curves with 1, 2, 3, and 4 control points (respectively).
| `CLOSEPOLY` is a `LINETO` with the control points correctly
| chosen based on the start/end points of the current stroke.
|
| iter_segments(self, transform=None, remove_nans=True, clip=None, snap=False, stroke_width=1.0, simplify=None, curves=True, sketch=None)
| Iterate over all curve segments in the path.
|
| Each iteration returns a pair ``(vertices, code)``, where ``vertices``
| is a sequence of 1-3 coordinate pairs, and ``code`` is a `Path` code.
|
| Additionally, this method can provide a number of standard cleanups and
| conversions to the path.
|
| Parameters
| ----------
| transform : None or :class:`~matplotlib.transforms.Transform`
| If not None, the given affine transformation will be applied to the
| path.
| remove_nans : bool, optional
| Whether to remove all NaNs from the path and skip over them using
| MOVETO commands.
| clip : None or (float, float, float, float), optional
| If not None, must be a four-tuple (x1, y1, x2, y2)
| defining a rectangle in which to clip the path.
| snap : None or bool, optional
| If True, snap all nodes to pixels; if False, don't snap them.
| If None, snap if the path contains only segments
| parallel to the x or y axes, and no more than 1024 of them.
| stroke_width : float, optional
| The width of the stroke being drawn (used for path snapping).
| simplify : None or bool, optional
| Whether to simplify the path by removing vertices
| that do not affect its appearance. If None, use the
| :attr:`should_simplify` attribute. See also :rc:`path.simplify`
| and :rc:`path.simplify_threshold`.
| curves : bool, optional
| If True, curve segments will be returned as curve segments.
| If False, all curves will be converted to line segments.
| sketch : None or sequence, optional
| If not None, must be a 3-tuple of the form
| (scale, length, randomness), representing the sketch parameters.
|
| to_polygons(self, transform=None, width=0, height=0, closed_only=True)
| Convert this path to a list of polygons or polylines. Each
| polygon/polyline is an (N, 2) array of vertices. In other words,
| each polygon has no `MOVETO` instructions or curves. This
| is useful for displaying in backends that do not support
| compound paths or Bézier curves.
|
| If *width* and *height* are both non-zero then the lines will
| be simplified so that vertices outside of (0, 0), (width,
| height) will be clipped.
|
| The resulting polygons will be simplified if the
| :attr:`Path.should_simplify` attribute of the path is `True`.
|
| If *closed_only* is `True` (default), only closed polygons,
| with the last point being the same as the first point, will be
| returned. Any unclosed polylines in the path will be
| explicitly closed. If *closed_only* is `False`, any unclosed
| polygons in the path will be returned as unclosed polygons,
| and the closed polygons will be returned explicitly closed by
| setting the last point to the same as the first point.
|
| transformed(self, transform)
| Return a transformed copy of the path.
|
| See Also
| --------
| matplotlib.transforms.TransformedPath
| A specialized path class that will cache the transformed result and
| automatically update when the transform changes.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| arc(theta1, theta2, n=None, is_wedge=False)
| Return a `Path` for the unit circle arc from angles *theta1* to
| *theta2* (in degrees).
|
| *theta2* is unwrapped to produce the shortest arc within 360 degrees.
| That is, if *theta2* > *theta1* + 360, the arc will be from *theta1* to
| *theta2* - 360 and not a full circle plus some extra overlap.
|
| If *n* is provided, it is the number of spline segments to make.
| If *n* is not provided, the number of spline segments is
| determined based on the delta between *theta1* and *theta2*.
|
| Masionobe, L. 2003. `Drawing an elliptical arc using
| polylines, quadratic or cubic Bezier curves
| <https://web.archive.org/web/20190318044212/http://www.spaceroots.org/documents/ellipse/index.html>`_.
|
| circle(center=(0.0, 0.0), radius=1.0, readonly=False)
| Return a `Path` representing a circle of a given radius and center.
|
| Parameters
| ----------
| center : (float, float), default: (0, 0)
| The center of the circle.
| radius : float, default: 1
| The radius of the circle.
| readonly : bool
| Whether the created path should have the "readonly" argument
| set when creating the Path instance.
|
| Notes
| -----
| The circle is approximated using 8 cubic Bézier curves, as described in
|
| Lancaster, Don. `Approximating a Circle or an Ellipse Using Four
| Bezier Cubic Splines <https://www.tinaja.com/glib/ellipse4.pdf>`_.
|
| make_compound_path(*args)
| Concatenate a list of `Path`\s into a single `Path`, removing all `STOP`\s.
|
| make_compound_path_from_polys(XY)
| Make a compound `Path` object to draw a number of polygons with equal
| numbers of sides.
|
| .. plot:: gallery/misc/histogram_path.py
|
| Parameters
| ----------
| XY : (numpolys, numsides, 2) array
|
| unit_circle()
| Return the readonly :class:`Path` of the unit circle.
|
| For most cases, :func:`Path.circle` will be what you want.
|
| unit_circle_righthalf()
| Return a `Path` of the right half of a unit circle.
|
| See `Path.circle` for the reference on the approximation used.
|
| unit_rectangle()
| Return a `Path` instance of the unit rectangle from (0, 0) to (1, 1).
|
| unit_regular_asterisk(numVertices)
| Return a :class:`Path` for a unit regular asterisk with the given
| numVertices and radius of 1.0, centered at (0, 0).
|
| unit_regular_polygon(numVertices)
| Return a :class:`Path` instance for a unit regular polygon with the
| given *numVertices* such that the circumscribing circle has radius 1.0,
| centered at (0, 0).
|
| unit_regular_star(numVertices, innerCircle=0.5)
| Return a :class:`Path` for a unit regular star with the given
| numVertices and radius of 1.0, centered at (0, 0).
|
| wedge(theta1, theta2, n=None)
| Return a `Path` for the unit circle wedge from angles *theta1* to
| *theta2* (in degrees).
|
| *theta2* is unwrapped to produce the shortest wedge within 360 degrees.
| That is, if *theta2* > *theta1* + 360, the wedge will be from *theta1*
| to *theta2* - 360 and not a full circle plus some extra overlap.
|
| If *n* is provided, it is the number of spline segments to make.
| If *n* is not provided, the number of spline segments is
| determined based on the delta between *theta1* and *theta2*.
|
| See `Path.arc` for the reference on the approximation used.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| hatch(hatchpattern, density=6)
| Given a hatch specifier, *hatchpattern*, generates a `Path` that
| can be used in a repeated hatching pattern. *density* is the
| number of lines per unit square.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| readonly
| `True` if the `Path` is read-only.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| codes
| The list of codes in the `Path` as a 1D array.
|
| Each code is one of `STOP`, `MOVETO`, `LINETO`, `CURVE3`, `CURVE4` or
| `CLOSEPOLY`. For codes that correspond to more than one vertex
| (`CURVE3` and `CURVE4`), that code will be repeated so that the length
| of `vertices` and `codes` is always the same.
|
| should_simplify
| `True` if the vertices array should be simplified.
|
| simplify_threshold
| The fraction of a pixel difference below which vertices will
| be simplified out.
|
| vertices
| The vertices of the `Path` as an (N, 2) array.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| CLOSEPOLY = np.uint8(79)
|
| CURVE3 = np.uint8(3)
|
| CURVE4 = np.uint8(4)
|
| LINETO = np.uint8(2)
|
| MOVETO = np.uint8(1)
|
| NUM_VERTICES_FOR_CODE = {np.uint8(0): 1, np.uint8(1): 1, np.uint8(2): ...
|
| STOP = np.uint8(0)
|
| code_type = <class 'numpy.uint8'>
| Unsigned integer type, compatible with C ``unsigned char``.
|
| :Character code: ``'B'``
| :Canonical name: `numpy.ubyte`
| :Alias on this platform (win32 AMD64): `numpy.uint8`: 8-bit unsigned integer (``0`` to ``255``).
FUNCTIONS
get_path_collection_extents(master_transform, paths, transforms, offsets, offset_transform)
Get bounding box of a `.PathCollection`\s internal objects.
That is, given a sequence of `Path`\s, `.Transform`\s objects, and offsets, as found
in a `.PathCollection`, return the bounding box that encapsulates all of them.
Parameters
----------
master_transform : `~matplotlib.transforms.Transform`
Global transformation applied to all paths.
paths : list of `Path`
transforms : list of `~matplotlib.transforms.Affine2DBase`
If non-empty, this overrides *master_transform*.
offsets : (N, 2) array-like
offset_transform : `~matplotlib.transforms.Affine2DBase`
Transform applied to the offsets before offsetting the path.
Notes
-----
The way that *paths*, *transforms* and *offsets* are combined follows the same
method as for collections: each is iterated over independently, so if you have 3
paths (A, B, C), 2 transforms (α, β) and 1 offset (O), their combinations are as
follows:
- (A, α, O)
- (B, β, O)
- (C, α, O)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\path.py
matplotlib.pprint
Python Library Documentation: module pprint
NAME
pprint - Support to pretty-print lists, tuples, & dictionaries recursively.
MODULE REFERENCE
https://docs.python.org/3.12/library/pprint.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
Very simple, but useful, especially in debugging data structures.
Classes
-------
PrettyPrinter()
Handle pretty-printing operations onto a stream using a configured
set of formatting parameters.
Functions
---------
pformat()
Format a Python object into a pretty-printed representation.
pprint()
Pretty-print a Python object to a stream [default is sys.stdout].
saferepr()
Generate a 'standard' repr()-like value, but protect against recursive
data structures.
CLASSES
builtins.object
PrettyPrinter
class PrettyPrinter(builtins.object)
| PrettyPrinter(indent=1, width=80, depth=None, stream=None, *, compact=False, sort_dicts=True, underscore_numbers=False)
|
| Methods defined here:
|
| __init__(self, indent=1, width=80, depth=None, stream=None, *, compact=False, sort_dicts=True, underscore_numbers=False)
| Handle pretty printing operations onto a stream using a set of
| configured parameters.
|
| indent
| Number of spaces to indent for each level of nesting.
|
| width
| Attempted maximum number of columns in the output.
|
| depth
| The maximum depth to print out nested structures.
|
| stream
| The desired output stream. If omitted (or false), the standard
| output stream available at construction will be used.
|
| compact
| If true, several items will be combined in one line.
|
| sort_dicts
| If true, dict keys are sorted.
|
| underscore_numbers
| If true, digit groups are separated with underscores.
|
| format(self, object, context, maxlevels, level)
| Format object for a specific context, returning a string
| and flags indicating whether the representation is 'readable'
| and whether the object represents a recursive construct.
|
| isreadable(self, object)
|
| isrecursive(self, object)
|
| pformat(self, object)
|
| pprint(self, object)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
isreadable(object)
Determine if saferepr(object) is readable by eval().
isrecursive(object)
Determine if object requires a recursive representation.
pformat(object, indent=1, width=80, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)
Format a Python object into a pretty-printed representation.
pp(object, *args, sort_dicts=False, **kwargs)
Pretty-print a Python object
pprint(object, stream=None, indent=1, width=80, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)
Pretty-print a Python object to a stream [default is sys.stdout].
saferepr(object)
Version of repr() which can handle recursive data structures.
DATA
__all__ = ['pprint', 'pformat', 'isreadable', 'isrecursive', 'saferepr...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\pprint.py
matplotlib.rc
Python Library Documentation: function rc in module matplotlib
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).
matplotlib.rcParams
Python Library Documentation: RcParams in module matplotlib object
class RcParams(collections.abc.MutableMapping, builtins.dict)
| RcParams(*args, **kwargs)
|
| A dict-like key-value store for config parameters, including validation.
|
| Validating functions are defined and associated with rc parameters in
| :mod:`matplotlib.rcsetup`.
|
| The list of rcParams is:
|
| - _internal.classic_mode
| - agg.path.chunksize
| - animation.bitrate
| - animation.codec
| - animation.convert_args
| - animation.convert_path
| - animation.embed_limit
| - animation.ffmpeg_args
| - animation.ffmpeg_path
| - animation.frame_format
| - animation.html
| - animation.writer
| - axes.autolimit_mode
| - axes.axisbelow
| - axes.edgecolor
| - axes.facecolor
| - axes.formatter.limits
| - axes.formatter.min_exponent
| - axes.formatter.offset_threshold
| - axes.formatter.use_locale
| - axes.formatter.use_mathtext
| - axes.formatter.useoffset
| - axes.grid
| - axes.grid.axis
| - axes.grid.which
| - axes.labelcolor
| - axes.labelpad
| - axes.labelsize
| - axes.labelweight
| - axes.linewidth
| - axes.prop_cycle
| - axes.spines.bottom
| - axes.spines.left
| - axes.spines.right
| - axes.spines.top
| - axes.titlecolor
| - axes.titlelocation
| - axes.titlepad
| - axes.titlesize
| - axes.titleweight
| - axes.titley
| - axes.unicode_minus
| - axes.xmargin
| - axes.ymargin
| - axes.zmargin
| - axes3d.automargin
| - axes3d.grid
| - axes3d.xaxis.panecolor
| - axes3d.yaxis.panecolor
| - axes3d.zaxis.panecolor
| - backend
| - backend_fallback
| - boxplot.bootstrap
| - boxplot.boxprops.color
| - boxplot.boxprops.linestyle
| - boxplot.boxprops.linewidth
| - boxplot.capprops.color
| - boxplot.capprops.linestyle
| - boxplot.capprops.linewidth
| - boxplot.flierprops.color
| - boxplot.flierprops.linestyle
| - boxplot.flierprops.linewidth
| - boxplot.flierprops.marker
| - boxplot.flierprops.markeredgecolor
| - boxplot.flierprops.markeredgewidth
| - boxplot.flierprops.markerfacecolor
| - boxplot.flierprops.markersize
| - boxplot.meanline
| - boxplot.meanprops.color
| - boxplot.meanprops.linestyle
| - boxplot.meanprops.linewidth
| - boxplot.meanprops.marker
| - boxplot.meanprops.markeredgecolor
| - boxplot.meanprops.markerfacecolor
| - boxplot.meanprops.markersize
| - boxplot.medianprops.color
| - boxplot.medianprops.linestyle
| - boxplot.medianprops.linewidth
| - boxplot.notch
| - boxplot.patchartist
| - boxplot.showbox
| - boxplot.showcaps
| - boxplot.showfliers
| - boxplot.showmeans
| - boxplot.vertical
| - boxplot.whiskerprops.color
| - boxplot.whiskerprops.linestyle
| - boxplot.whiskerprops.linewidth
| - boxplot.whiskers
| - contour.algorithm
| - contour.corner_mask
| - contour.linewidth
| - contour.negative_linestyle
| - date.autoformatter.day
| - date.autoformatter.hour
| - date.autoformatter.microsecond
| - date.autoformatter.minute
| - date.autoformatter.month
| - date.autoformatter.second
| - date.autoformatter.year
| - date.converter
| - date.epoch
| - date.interval_multiples
| - docstring.hardcopy
| - errorbar.capsize
| - figure.autolayout
| - figure.constrained_layout.h_pad
| - figure.constrained_layout.hspace
| - figure.constrained_layout.use
| - figure.constrained_layout.w_pad
| - figure.constrained_layout.wspace
| - figure.dpi
| - figure.edgecolor
| - figure.facecolor
| - figure.figsize
| - figure.frameon
| - figure.hooks
| - figure.labelsize
| - figure.labelweight
| - figure.max_open_warning
| - figure.raise_window
| - figure.subplot.bottom
| - figure.subplot.hspace
| - figure.subplot.left
| - figure.subplot.right
| - figure.subplot.top
| - figure.subplot.wspace
| - figure.titlesize
| - figure.titleweight
| - font.cursive
| - font.family
| - font.fantasy
| - font.monospace
| - font.sans-serif
| - font.serif
| - font.size
| - font.stretch
| - font.style
| - font.variant
| - font.weight
| - grid.alpha
| - grid.color
| - grid.linestyle
| - grid.linewidth
| - hatch.color
| - hatch.linewidth
| - hist.bins
| - image.aspect
| - image.cmap
| - image.composite_image
| - image.interpolation
| - image.interpolation_stage
| - image.lut
| - image.origin
| - image.resample
| - interactive
| - keymap.back
| - keymap.copy
| - keymap.forward
| - keymap.fullscreen
| - keymap.grid
| - keymap.grid_minor
| - keymap.help
| - keymap.home
| - keymap.pan
| - keymap.quit
| - keymap.quit_all
| - keymap.save
| - keymap.xscale
| - keymap.yscale
| - keymap.zoom
| - legend.borderaxespad
| - legend.borderpad
| - legend.columnspacing
| - legend.edgecolor
| - legend.facecolor
| - legend.fancybox
| - legend.fontsize
| - legend.framealpha
| - legend.frameon
| - legend.handleheight
| - legend.handlelength
| - legend.handletextpad
| - legend.labelcolor
| - legend.labelspacing
| - legend.loc
| - legend.markerscale
| - legend.numpoints
| - legend.scatterpoints
| - legend.shadow
| - legend.title_fontsize
| - lines.antialiased
| - lines.color
| - lines.dash_capstyle
| - lines.dash_joinstyle
| - lines.dashdot_pattern
| - lines.dashed_pattern
| - lines.dotted_pattern
| - lines.linestyle
| - lines.linewidth
| - lines.marker
| - lines.markeredgecolor
| - lines.markeredgewidth
| - lines.markerfacecolor
| - lines.markersize
| - lines.scale_dashes
| - lines.solid_capstyle
| - lines.solid_joinstyle
| - macosx.window_mode
| - markers.fillstyle
| - mathtext.bf
| - mathtext.bfit
| - mathtext.cal
| - mathtext.default
| - mathtext.fallback
| - mathtext.fontset
| - mathtext.it
| - mathtext.rm
| - mathtext.sf
| - mathtext.tt
| - patch.antialiased
| - patch.edgecolor
| - patch.facecolor
| - patch.force_edgecolor
| - patch.linewidth
| - path.effects
| - path.simplify
| - path.simplify_threshold
| - path.sketch
| - path.snap
| - pcolor.shading
| - pcolormesh.snap
| - pdf.compression
| - pdf.fonttype
| - pdf.inheritcolor
| - pdf.use14corefonts
| - pgf.preamble
| - pgf.rcfonts
| - pgf.texsystem
| - polaraxes.grid
| - ps.distiller.res
| - ps.fonttype
| - ps.papersize
| - ps.useafm
| - ps.usedistiller
| - savefig.bbox
| - savefig.directory
| - savefig.dpi
| - savefig.edgecolor
| - savefig.facecolor
| - savefig.format
| - savefig.orientation
| - savefig.pad_inches
| - savefig.transparent
| - scatter.edgecolors
| - scatter.marker
| - svg.fonttype
| - svg.hashsalt
| - svg.image_inline
| - text.antialiased
| - text.color
| - text.hinting
| - text.hinting_factor
| - text.kerning_factor
| - text.latex.preamble
| - text.parse_math
| - text.usetex
| - timezone
| - tk.window_focus
| - toolbar
| - webagg.address
| - webagg.open_in_browser
| - webagg.port
| - webagg.port_retries
| - xaxis.labellocation
| - xtick.alignment
| - xtick.bottom
| - xtick.color
| - xtick.direction
| - xtick.labelbottom
| - xtick.labelcolor
| - xtick.labelsize
| - xtick.labeltop
| - xtick.major.bottom
| - xtick.major.pad
| - xtick.major.size
| - xtick.major.top
| - xtick.major.width
| - xtick.minor.bottom
| - xtick.minor.ndivs
| - xtick.minor.pad
| - xtick.minor.size
| - xtick.minor.top
| - xtick.minor.visible
| - xtick.minor.width
| - xtick.top
| - yaxis.labellocation
| - ytick.alignment
| - ytick.color
| - ytick.direction
| - ytick.labelcolor
| - ytick.labelleft
| - ytick.labelright
| - ytick.labelsize
| - ytick.left
| - ytick.major.left
| - ytick.major.pad
| - ytick.major.right
| - ytick.major.size
| - ytick.major.width
| - ytick.minor.left
| - ytick.minor.ndivs
| - ytick.minor.pad
| - ytick.minor.right
| - ytick.minor.size
| - ytick.minor.visible
| - ytick.minor.width
| - ytick.right
|
| 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)
| Return self[key].
|
| __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)
| Copy this RcParams instance.
|
| 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
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__delitem__'})
|
| validate = {'_internal.classic_mode': <function validate_bool>, '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=<object object at 0x00000245A78981F0>)
| 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(self, other=(), /, **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)
| 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).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __ror__(self, value, /)
| Return value|self.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
matplotlib.rcParamsDefault
Python Library Documentation: RcParams in module matplotlib object
class RcParams(collections.abc.MutableMapping, builtins.dict)
| RcParams(*args, **kwargs)
|
| A dict-like key-value store for config parameters, including validation.
|
| Validating functions are defined and associated with rc parameters in
| :mod:`matplotlib.rcsetup`.
|
| The list of rcParams is:
|
| - _internal.classic_mode
| - agg.path.chunksize
| - animation.bitrate
| - animation.codec
| - animation.convert_args
| - animation.convert_path
| - animation.embed_limit
| - animation.ffmpeg_args
| - animation.ffmpeg_path
| - animation.frame_format
| - animation.html
| - animation.writer
| - axes.autolimit_mode
| - axes.axisbelow
| - axes.edgecolor
| - axes.facecolor
| - axes.formatter.limits
| - axes.formatter.min_exponent
| - axes.formatter.offset_threshold
| - axes.formatter.use_locale
| - axes.formatter.use_mathtext
| - axes.formatter.useoffset
| - axes.grid
| - axes.grid.axis
| - axes.grid.which
| - axes.labelcolor
| - axes.labelpad
| - axes.labelsize
| - axes.labelweight
| - axes.linewidth
| - axes.prop_cycle
| - axes.spines.bottom
| - axes.spines.left
| - axes.spines.right
| - axes.spines.top
| - axes.titlecolor
| - axes.titlelocation
| - axes.titlepad
| - axes.titlesize
| - axes.titleweight
| - axes.titley
| - axes.unicode_minus
| - axes.xmargin
| - axes.ymargin
| - axes.zmargin
| - axes3d.automargin
| - axes3d.grid
| - axes3d.xaxis.panecolor
| - axes3d.yaxis.panecolor
| - axes3d.zaxis.panecolor
| - backend
| - backend_fallback
| - boxplot.bootstrap
| - boxplot.boxprops.color
| - boxplot.boxprops.linestyle
| - boxplot.boxprops.linewidth
| - boxplot.capprops.color
| - boxplot.capprops.linestyle
| - boxplot.capprops.linewidth
| - boxplot.flierprops.color
| - boxplot.flierprops.linestyle
| - boxplot.flierprops.linewidth
| - boxplot.flierprops.marker
| - boxplot.flierprops.markeredgecolor
| - boxplot.flierprops.markeredgewidth
| - boxplot.flierprops.markerfacecolor
| - boxplot.flierprops.markersize
| - boxplot.meanline
| - boxplot.meanprops.color
| - boxplot.meanprops.linestyle
| - boxplot.meanprops.linewidth
| - boxplot.meanprops.marker
| - boxplot.meanprops.markeredgecolor
| - boxplot.meanprops.markerfacecolor
| - boxplot.meanprops.markersize
| - boxplot.medianprops.color
| - boxplot.medianprops.linestyle
| - boxplot.medianprops.linewidth
| - boxplot.notch
| - boxplot.patchartist
| - boxplot.showbox
| - boxplot.showcaps
| - boxplot.showfliers
| - boxplot.showmeans
| - boxplot.vertical
| - boxplot.whiskerprops.color
| - boxplot.whiskerprops.linestyle
| - boxplot.whiskerprops.linewidth
| - boxplot.whiskers
| - contour.algorithm
| - contour.corner_mask
| - contour.linewidth
| - contour.negative_linestyle
| - date.autoformatter.day
| - date.autoformatter.hour
| - date.autoformatter.microsecond
| - date.autoformatter.minute
| - date.autoformatter.month
| - date.autoformatter.second
| - date.autoformatter.year
| - date.converter
| - date.epoch
| - date.interval_multiples
| - docstring.hardcopy
| - errorbar.capsize
| - figure.autolayout
| - figure.constrained_layout.h_pad
| - figure.constrained_layout.hspace
| - figure.constrained_layout.use
| - figure.constrained_layout.w_pad
| - figure.constrained_layout.wspace
| - figure.dpi
| - figure.edgecolor
| - figure.facecolor
| - figure.figsize
| - figure.frameon
| - figure.hooks
| - figure.labelsize
| - figure.labelweight
| - figure.max_open_warning
| - figure.raise_window
| - figure.subplot.bottom
| - figure.subplot.hspace
| - figure.subplot.left
| - figure.subplot.right
| - figure.subplot.top
| - figure.subplot.wspace
| - figure.titlesize
| - figure.titleweight
| - font.cursive
| - font.family
| - font.fantasy
| - font.monospace
| - font.sans-serif
| - font.serif
| - font.size
| - font.stretch
| - font.style
| - font.variant
| - font.weight
| - grid.alpha
| - grid.color
| - grid.linestyle
| - grid.linewidth
| - hatch.color
| - hatch.linewidth
| - hist.bins
| - image.aspect
| - image.cmap
| - image.composite_image
| - image.interpolation
| - image.interpolation_stage
| - image.lut
| - image.origin
| - image.resample
| - interactive
| - keymap.back
| - keymap.copy
| - keymap.forward
| - keymap.fullscreen
| - keymap.grid
| - keymap.grid_minor
| - keymap.help
| - keymap.home
| - keymap.pan
| - keymap.quit
| - keymap.quit_all
| - keymap.save
| - keymap.xscale
| - keymap.yscale
| - keymap.zoom
| - legend.borderaxespad
| - legend.borderpad
| - legend.columnspacing
| - legend.edgecolor
| - legend.facecolor
| - legend.fancybox
| - legend.fontsize
| - legend.framealpha
| - legend.frameon
| - legend.handleheight
| - legend.handlelength
| - legend.handletextpad
| - legend.labelcolor
| - legend.labelspacing
| - legend.loc
| - legend.markerscale
| - legend.numpoints
| - legend.scatterpoints
| - legend.shadow
| - legend.title_fontsize
| - lines.antialiased
| - lines.color
| - lines.dash_capstyle
| - lines.dash_joinstyle
| - lines.dashdot_pattern
| - lines.dashed_pattern
| - lines.dotted_pattern
| - lines.linestyle
| - lines.linewidth
| - lines.marker
| - lines.markeredgecolor
| - lines.markeredgewidth
| - lines.markerfacecolor
| - lines.markersize
| - lines.scale_dashes
| - lines.solid_capstyle
| - lines.solid_joinstyle
| - macosx.window_mode
| - markers.fillstyle
| - mathtext.bf
| - mathtext.bfit
| - mathtext.cal
| - mathtext.default
| - mathtext.fallback
| - mathtext.fontset
| - mathtext.it
| - mathtext.rm
| - mathtext.sf
| - mathtext.tt
| - patch.antialiased
| - patch.edgecolor
| - patch.facecolor
| - patch.force_edgecolor
| - patch.linewidth
| - path.effects
| - path.simplify
| - path.simplify_threshold
| - path.sketch
| - path.snap
| - pcolor.shading
| - pcolormesh.snap
| - pdf.compression
| - pdf.fonttype
| - pdf.inheritcolor
| - pdf.use14corefonts
| - pgf.preamble
| - pgf.rcfonts
| - pgf.texsystem
| - polaraxes.grid
| - ps.distiller.res
| - ps.fonttype
| - ps.papersize
| - ps.useafm
| - ps.usedistiller
| - savefig.bbox
| - savefig.directory
| - savefig.dpi
| - savefig.edgecolor
| - savefig.facecolor
| - savefig.format
| - savefig.orientation
| - savefig.pad_inches
| - savefig.transparent
| - scatter.edgecolors
| - scatter.marker
| - svg.fonttype
| - svg.hashsalt
| - svg.image_inline
| - text.antialiased
| - text.color
| - text.hinting
| - text.hinting_factor
| - text.kerning_factor
| - text.latex.preamble
| - text.parse_math
| - text.usetex
| - timezone
| - tk.window_focus
| - toolbar
| - webagg.address
| - webagg.open_in_browser
| - webagg.port
| - webagg.port_retries
| - xaxis.labellocation
| - xtick.alignment
| - xtick.bottom
| - xtick.color
| - xtick.direction
| - xtick.labelbottom
| - xtick.labelcolor
| - xtick.labelsize
| - xtick.labeltop
| - xtick.major.bottom
| - xtick.major.pad
| - xtick.major.size
| - xtick.major.top
| - xtick.major.width
| - xtick.minor.bottom
| - xtick.minor.ndivs
| - xtick.minor.pad
| - xtick.minor.size
| - xtick.minor.top
| - xtick.minor.visible
| - xtick.minor.width
| - xtick.top
| - yaxis.labellocation
| - ytick.alignment
| - ytick.color
| - ytick.direction
| - ytick.labelcolor
| - ytick.labelleft
| - ytick.labelright
| - ytick.labelsize
| - ytick.left
| - ytick.major.left
| - ytick.major.pad
| - ytick.major.right
| - ytick.major.size
| - ytick.major.width
| - ytick.minor.left
| - ytick.minor.ndivs
| - ytick.minor.pad
| - ytick.minor.right
| - ytick.minor.size
| - ytick.minor.visible
| - ytick.minor.width
| - ytick.right
|
| 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)
| Return self[key].
|
| __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)
| Copy this RcParams instance.
|
| 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
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__delitem__'})
|
| validate = {'_internal.classic_mode': <function validate_bool>, '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=<object object at 0x00000245A78981F0>)
| 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(self, other=(), /, **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)
| 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).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __ror__(self, value, /)
| Return value|self.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
matplotlib.rcParamsOrig
Python Library Documentation: RcParams in module matplotlib object
class RcParams(collections.abc.MutableMapping, builtins.dict)
| RcParams(*args, **kwargs)
|
| A dict-like key-value store for config parameters, including validation.
|
| Validating functions are defined and associated with rc parameters in
| :mod:`matplotlib.rcsetup`.
|
| The list of rcParams is:
|
| - _internal.classic_mode
| - agg.path.chunksize
| - animation.bitrate
| - animation.codec
| - animation.convert_args
| - animation.convert_path
| - animation.embed_limit
| - animation.ffmpeg_args
| - animation.ffmpeg_path
| - animation.frame_format
| - animation.html
| - animation.writer
| - axes.autolimit_mode
| - axes.axisbelow
| - axes.edgecolor
| - axes.facecolor
| - axes.formatter.limits
| - axes.formatter.min_exponent
| - axes.formatter.offset_threshold
| - axes.formatter.use_locale
| - axes.formatter.use_mathtext
| - axes.formatter.useoffset
| - axes.grid
| - axes.grid.axis
| - axes.grid.which
| - axes.labelcolor
| - axes.labelpad
| - axes.labelsize
| - axes.labelweight
| - axes.linewidth
| - axes.prop_cycle
| - axes.spines.bottom
| - axes.spines.left
| - axes.spines.right
| - axes.spines.top
| - axes.titlecolor
| - axes.titlelocation
| - axes.titlepad
| - axes.titlesize
| - axes.titleweight
| - axes.titley
| - axes.unicode_minus
| - axes.xmargin
| - axes.ymargin
| - axes.zmargin
| - axes3d.automargin
| - axes3d.grid
| - axes3d.xaxis.panecolor
| - axes3d.yaxis.panecolor
| - axes3d.zaxis.panecolor
| - backend
| - backend_fallback
| - boxplot.bootstrap
| - boxplot.boxprops.color
| - boxplot.boxprops.linestyle
| - boxplot.boxprops.linewidth
| - boxplot.capprops.color
| - boxplot.capprops.linestyle
| - boxplot.capprops.linewidth
| - boxplot.flierprops.color
| - boxplot.flierprops.linestyle
| - boxplot.flierprops.linewidth
| - boxplot.flierprops.marker
| - boxplot.flierprops.markeredgecolor
| - boxplot.flierprops.markeredgewidth
| - boxplot.flierprops.markerfacecolor
| - boxplot.flierprops.markersize
| - boxplot.meanline
| - boxplot.meanprops.color
| - boxplot.meanprops.linestyle
| - boxplot.meanprops.linewidth
| - boxplot.meanprops.marker
| - boxplot.meanprops.markeredgecolor
| - boxplot.meanprops.markerfacecolor
| - boxplot.meanprops.markersize
| - boxplot.medianprops.color
| - boxplot.medianprops.linestyle
| - boxplot.medianprops.linewidth
| - boxplot.notch
| - boxplot.patchartist
| - boxplot.showbox
| - boxplot.showcaps
| - boxplot.showfliers
| - boxplot.showmeans
| - boxplot.vertical
| - boxplot.whiskerprops.color
| - boxplot.whiskerprops.linestyle
| - boxplot.whiskerprops.linewidth
| - boxplot.whiskers
| - contour.algorithm
| - contour.corner_mask
| - contour.linewidth
| - contour.negative_linestyle
| - date.autoformatter.day
| - date.autoformatter.hour
| - date.autoformatter.microsecond
| - date.autoformatter.minute
| - date.autoformatter.month
| - date.autoformatter.second
| - date.autoformatter.year
| - date.converter
| - date.epoch
| - date.interval_multiples
| - docstring.hardcopy
| - errorbar.capsize
| - figure.autolayout
| - figure.constrained_layout.h_pad
| - figure.constrained_layout.hspace
| - figure.constrained_layout.use
| - figure.constrained_layout.w_pad
| - figure.constrained_layout.wspace
| - figure.dpi
| - figure.edgecolor
| - figure.facecolor
| - figure.figsize
| - figure.frameon
| - figure.hooks
| - figure.labelsize
| - figure.labelweight
| - figure.max_open_warning
| - figure.raise_window
| - figure.subplot.bottom
| - figure.subplot.hspace
| - figure.subplot.left
| - figure.subplot.right
| - figure.subplot.top
| - figure.subplot.wspace
| - figure.titlesize
| - figure.titleweight
| - font.cursive
| - font.family
| - font.fantasy
| - font.monospace
| - font.sans-serif
| - font.serif
| - font.size
| - font.stretch
| - font.style
| - font.variant
| - font.weight
| - grid.alpha
| - grid.color
| - grid.linestyle
| - grid.linewidth
| - hatch.color
| - hatch.linewidth
| - hist.bins
| - image.aspect
| - image.cmap
| - image.composite_image
| - image.interpolation
| - image.interpolation_stage
| - image.lut
| - image.origin
| - image.resample
| - interactive
| - keymap.back
| - keymap.copy
| - keymap.forward
| - keymap.fullscreen
| - keymap.grid
| - keymap.grid_minor
| - keymap.help
| - keymap.home
| - keymap.pan
| - keymap.quit
| - keymap.quit_all
| - keymap.save
| - keymap.xscale
| - keymap.yscale
| - keymap.zoom
| - legend.borderaxespad
| - legend.borderpad
| - legend.columnspacing
| - legend.edgecolor
| - legend.facecolor
| - legend.fancybox
| - legend.fontsize
| - legend.framealpha
| - legend.frameon
| - legend.handleheight
| - legend.handlelength
| - legend.handletextpad
| - legend.labelcolor
| - legend.labelspacing
| - legend.loc
| - legend.markerscale
| - legend.numpoints
| - legend.scatterpoints
| - legend.shadow
| - legend.title_fontsize
| - lines.antialiased
| - lines.color
| - lines.dash_capstyle
| - lines.dash_joinstyle
| - lines.dashdot_pattern
| - lines.dashed_pattern
| - lines.dotted_pattern
| - lines.linestyle
| - lines.linewidth
| - lines.marker
| - lines.markeredgecolor
| - lines.markeredgewidth
| - lines.markerfacecolor
| - lines.markersize
| - lines.scale_dashes
| - lines.solid_capstyle
| - lines.solid_joinstyle
| - macosx.window_mode
| - markers.fillstyle
| - mathtext.bf
| - mathtext.bfit
| - mathtext.cal
| - mathtext.default
| - mathtext.fallback
| - mathtext.fontset
| - mathtext.it
| - mathtext.rm
| - mathtext.sf
| - mathtext.tt
| - patch.antialiased
| - patch.edgecolor
| - patch.facecolor
| - patch.force_edgecolor
| - patch.linewidth
| - path.effects
| - path.simplify
| - path.simplify_threshold
| - path.sketch
| - path.snap
| - pcolor.shading
| - pcolormesh.snap
| - pdf.compression
| - pdf.fonttype
| - pdf.inheritcolor
| - pdf.use14corefonts
| - pgf.preamble
| - pgf.rcfonts
| - pgf.texsystem
| - polaraxes.grid
| - ps.distiller.res
| - ps.fonttype
| - ps.papersize
| - ps.useafm
| - ps.usedistiller
| - savefig.bbox
| - savefig.directory
| - savefig.dpi
| - savefig.edgecolor
| - savefig.facecolor
| - savefig.format
| - savefig.orientation
| - savefig.pad_inches
| - savefig.transparent
| - scatter.edgecolors
| - scatter.marker
| - svg.fonttype
| - svg.hashsalt
| - svg.image_inline
| - text.antialiased
| - text.color
| - text.hinting
| - text.hinting_factor
| - text.kerning_factor
| - text.latex.preamble
| - text.parse_math
| - text.usetex
| - timezone
| - tk.window_focus
| - toolbar
| - webagg.address
| - webagg.open_in_browser
| - webagg.port
| - webagg.port_retries
| - xaxis.labellocation
| - xtick.alignment
| - xtick.bottom
| - xtick.color
| - xtick.direction
| - xtick.labelbottom
| - xtick.labelcolor
| - xtick.labelsize
| - xtick.labeltop
| - xtick.major.bottom
| - xtick.major.pad
| - xtick.major.size
| - xtick.major.top
| - xtick.major.width
| - xtick.minor.bottom
| - xtick.minor.ndivs
| - xtick.minor.pad
| - xtick.minor.size
| - xtick.minor.top
| - xtick.minor.visible
| - xtick.minor.width
| - xtick.top
| - yaxis.labellocation
| - ytick.alignment
| - ytick.color
| - ytick.direction
| - ytick.labelcolor
| - ytick.labelleft
| - ytick.labelright
| - ytick.labelsize
| - ytick.left
| - ytick.major.left
| - ytick.major.pad
| - ytick.major.right
| - ytick.major.size
| - ytick.major.width
| - ytick.minor.left
| - ytick.minor.ndivs
| - ytick.minor.pad
| - ytick.minor.right
| - ytick.minor.size
| - ytick.minor.visible
| - ytick.minor.width
| - ytick.right
|
| 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)
| Return self[key].
|
| __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)
| Copy this RcParams instance.
|
| 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
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'__delitem__'})
|
| validate = {'_internal.classic_mode': <function validate_bool>, '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=<object object at 0x00000245A78981F0>)
| 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(self, other=(), /, **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)
| 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).
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.abc.Iterable:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __ror__(self, value, /)
| Return value|self.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
matplotlib.rc_context
Python Library Documentation: function rc_context in module matplotlib
rc_context(rc=None, fname=None)
Return a context manager for temporarily changing rcParams.
The :rc:`backend` will not be reset by the context manager.
rcParams changed both through the context manager invocation and
in the body of the context will be reset on context exit.
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'
Setting in the context body::
with mpl.rc_context():
# will be reset
mpl.rcParams['lines.linewidth'] = 5
plt.plot(x, y)
matplotlib.rc_file
Python Library Documentation: function rc_file in module matplotlib
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.
matplotlib.rc_file_defaults
Python Library Documentation: function rc_file_defaults in module matplotlib
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.
matplotlib.rc_params
Python Library Documentation: function rc_params in module matplotlib
rc_params(fail_on_error=False)
Construct a `RcParams` instance from the default Matplotlib rc file.
matplotlib.rc_params_from_file
Python Library Documentation: function rc_params_from_file in module matplotlib
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.)
matplotlib.rcdefaults
Python Library Documentation: function rcdefaults in module matplotlib
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.
matplotlib.rcsetup
Python Library Documentation: module matplotlib.rcsetup in matplotlib
NAME
matplotlib.rcsetup
DESCRIPTION
The rcsetup module contains the validation code for customization using
Matplotlib's rc settings.
Each rc setting is assigned a function used to validate any attempted changes
to that setting. The validation functions are defined in the rcsetup module,
and are used to construct the rcParams global object which stores the settings
and is referenced throughout Matplotlib.
The default values of the rc settings are set in the default matplotlibrc file.
Any additions or deletions to the parameter set listed here should also be
propagated to the :file:`lib/matplotlib/mpl-data/matplotlibrc` in Matplotlib's
root source directory.
CLASSES
builtins.object
ValidateInStrings
class ValidateInStrings(builtins.object)
| ValidateInStrings(key, valid, ignorecase=False, *, _deprecated_since=None)
|
| Methods defined here:
|
| __call__(self, s)
| Call self as a function.
|
| __init__(self, key, valid, ignorecase=False, *, _deprecated_since=None)
| *valid* is a list of legal strings.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
cycler(*args, **kwargs)
Create a `~cycler.Cycler` object much like :func:`cycler.cycler`,
but includes input validation.
Call signatures::
cycler(cycler)
cycler(label=values[, label2=values2[, ...]])
cycler(label, values)
Form 1 copies a given `~cycler.Cycler` object.
Form 2 creates a `~cycler.Cycler` which cycles over one or more
properties simultaneously. If multiple properties are given, their
value lists must have the same length.
Form 3 creates a `~cycler.Cycler` for a single property. This form
exists for compatibility with the original cycler. Its use is
discouraged in favor of the kwarg form, i.e. ``cycler(label=values)``.
Parameters
----------
cycler : Cycler
Copy constructor for Cycler.
label : str
The property key. Must be a valid `.Artist` property.
For example, 'color' or 'linestyle'. Aliases are allowed,
such as 'c' for 'color' and 'lw' for 'linewidth'.
values : iterable
Finite-length iterable of the property values. These values
are validated and will raise a ValueError if invalid.
Returns
-------
Cycler
A new :class:`~cycler.Cycler` for the given properties.
Examples
--------
Creating a cycler for a single property:
>>> c = cycler(color=['red', 'green', 'blue'])
Creating a cycler for simultaneously cycling over multiple properties
(e.g. red circle, green plus, blue cross):
>>> c = cycler(color=['red', 'green', 'blue'],
... marker=['o', '+', 'x'])
reduce(...)
reduce(function, iterable[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence
or iterable, from left to right, so as to reduce the iterable to a single
value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the iterable in the calculation, and serves as a default when the
iterable is empty.
validate_any(s)
validate_anylist(s)
validate_aspect(s)
validate_axisbelow(s)
validate_backend(s)
validate_bbox(s)
validate_bool(b)
Convert b to ``bool`` or raise.
validate_color(s)
Return a valid color arg.
validate_color_for_prop_cycle(s)
validate_color_or_auto(s)
validate_color_or_inherit(s)
Return a valid color arg.
validate_colorlist(s)
return a list of colorspecs
validate_cycler(s)
Return a Cycler object from a string repr or the object itself.
validate_dashlist = validate_floatlistlist(s)
return a list of floats
validate_dpi(s)
Confirm s is string 'figure' or convert s to float or raise.
validate_fillstylelist = ValidateInStringsList(s)
validate_float(s)
validate_float_or_None(s)
validate_floatlist(s)
return a list of floats
validate_font_properties(s)
validate_fontsize(s)
validate_fontsize_None(s)
validate_fontsizelist(s)
validate_fontstretch(s)
validate_fonttype(s)
Confirm that this is a Postscript or PDF font type that we know how to
convert to.
validate_fontweight(s)
validate_hatch(s)
Validate a hatch pattern.
A hatch pattern string can have any sequence of the following
characters: ``\ / | - + * . x o O``.
validate_hatchlist(s)
Validate a hatch pattern.
A hatch pattern string can have any sequence of the following
characters: ``\ / | - + * . x o O``.
validate_hist_bins(s)
validate_int(s)
validate_int_or_None(s)
validate_markevery(s)
Validate the markevery property of a Line2D object.
Parameters
----------
s : None, int, (int, int), slice, float, (float, float), or list[int]
Returns
-------
None, int, (int, int), slice, float, (float, float), or list[int]
validate_markeverylist(s)
Validate the markevery property of a Line2D object.
Parameters
----------
s : None, int, (int, int), slice, float, (float, float), or list[int]
Returns
-------
None, int, (int, int), slice, float, (float, float), or list[int]
validate_ps_distiller(s)
validate_sketch(s)
validate_string = validate_str(s)
validate_string_or_None = validate_str_or_None(s)
validate_stringlist = validate_strlist(s)
return a list of strings
validate_whiskers(s)
DATA
backend_registry = <matplotlib.backends.registry.BackendRegistry objec...
defaultParams = {'_internal.classic_mode': [False, <function validate_...
ls_mapper = {'-': 'solid', '--': 'dashed', '-.': 'dashdot', ':': 'dott...
validate_fillstyle = <matplotlib.rcsetup.ValidateInStrings object>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\rcsetup.py
matplotlib.re
Python Library Documentation: package re
NAME
re - Support for regular expressions (RE).
MODULE REFERENCE
https://docs.python.org/3.12/library/re.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module provides regular expression matching operations similar to
those found in Perl. It supports both 8-bit and Unicode strings; both
the pattern and the strings being processed can contain null bytes and
characters outside the US ASCII range.
Regular expressions can contain both special and ordinary characters.
Most ordinary characters, like "A", "a", or "0", are the simplest
regular expressions; they simply match themselves. You can
concatenate ordinary characters, so last matches the string 'last'.
The special characters are:
"." Matches any character except a newline.
"^" Matches the start of the string.
"$" Matches the end of the string or just before the newline at
the end of the string.
"*" Matches 0 or more (greedy) repetitions of the preceding RE.
Greedy means that it will match as many repetitions as possible.
"+" Matches 1 or more (greedy) repetitions of the preceding RE.
"?" Matches 0 or 1 (greedy) of the preceding RE.
*?,+?,?? Non-greedy versions of the previous three special characters.
{m,n} Matches from m to n repetitions of the preceding RE.
{m,n}? Non-greedy version of the above.
"\\" Either escapes special characters or signals a special sequence.
[] Indicates a set of characters.
A "^" as the first character indicates a complementing set.
"|" A|B, creates an RE that will match either A or B.
(...) Matches the RE inside the parentheses.
The contents can be retrieved or matched later in the string.
(?aiLmsux) The letters set the corresponding flags defined below.
(?:...) Non-grouping version of regular parentheses.
(?P<name>...) The substring matched by the group is accessible by name.
(?P=name) Matches the text matched earlier by the group named name.
(?#...) A comment; ignored.
(?=...) Matches if ... matches next, but doesn't consume the string.
(?!...) Matches if ... doesn't match next.
(?<=...) Matches if preceded by ... (must be fixed length).
(?<!...) Matches if not preceded by ... (must be fixed length).
(?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
the (optional) no pattern otherwise.
The special sequences consist of "\\" and a character from the list
below. If the ordinary character is not on the list, then the
resulting RE will match the second character.
\number Matches the contents of the group of the same number.
\A Matches only at the start of the string.
\Z Matches only at the end of the string.
\b Matches the empty string, but only at the start or end of a word.
\B Matches the empty string, but not at the start or end of a word.
\d Matches any decimal digit; equivalent to the set [0-9] in
bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the whole
range of Unicode digits.
\D Matches any non-digit character; equivalent to [^\d].
\s Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the whole
range of Unicode whitespace characters.
\S Matches any non-whitespace character; equivalent to [^\s].
\w Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
in bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the
range of Unicode alphanumeric characters (letters plus digits
plus underscore).
With LOCALE, it will match the set [0-9_] plus characters defined
as letters for the current locale.
\W Matches the complement of \w.
\\ Matches a literal backslash.
This module exports the following functions:
match Match a regular expression pattern to the beginning of a string.
fullmatch Match a regular expression pattern to all of a string.
search Search a string for the presence of a pattern.
sub Substitute occurrences of a pattern found in a string.
subn Same as sub, but also return the number of substitutions made.
split Split a string by the occurrences of a pattern.
findall Find all occurrences of a pattern in a string.
finditer Return an iterator yielding a Match object for each match.
compile Compile a pattern into a Pattern object.
purge Clear the regular expression cache.
escape Backslash all non-alphanumerics in a string.
Each function other than purge and escape can take an optional 'flags' argument
consisting of one or more of the following module constants, joined by "|".
A, L, and U are mutually exclusive.
A ASCII For string patterns, make \w, \W, \b, \B, \d, \D
match the corresponding ASCII character categories
(rather than the whole Unicode categories, which is the
default).
For bytes patterns, this flag is the only available
behaviour and needn't be specified.
I IGNORECASE Perform case-insensitive matching.
L LOCALE Make \w, \W, \b, \B, dependent on the current locale.
M MULTILINE "^" matches the beginning of lines (after a newline)
as well as the string.
"$" matches the end of lines (before a newline) as well
as the end of the string.
S DOTALL "." matches any character at all, including the newline.
X VERBOSE Ignore whitespace and comments for nicer looking RE's.
U UNICODE For compatibility only. Ignored for string patterns (it
is the default), and forbidden for bytes patterns.
This module also defines an exception 'error'.
PACKAGE CONTENTS
_casefix
_compiler
_constants
_parser
CLASSES
builtins.Exception(builtins.BaseException)
error
builtins.object
Match
Pattern
enum.IntFlag(builtins.int, enum.ReprEnum, enum.Flag)
RegexFlag
class Match(builtins.object)
| The result of re.match() and re.search().
| Match objects always have a boolean value of True.
|
| Methods defined here:
|
| __copy__(self, /)
|
| __deepcopy__(self, memo, /)
|
| __getitem__(self, key, /)
| Return self[key].
|
| __repr__(self, /)
| Return repr(self).
|
| end(self, group=0, /)
| Return index of the end of the substring matched by group.
|
| expand(self, /, template)
| Return the string obtained by doing backslash substitution on the string template, as done by the sub() method.
|
| group(...)
| group([group1, ...]) -> str or tuple.
| Return subgroup(s) of the match by indices or names.
| For 0 returns the entire match.
|
| groupdict(self, /, default=None)
| Return a dictionary containing all the named subgroups of the match, keyed by the subgroup name.
|
| default
| Is used for groups that did not participate in the match.
|
| groups(self, /, default=None)
| Return a tuple containing all the subgroups of the match, from 1.
|
| default
| Is used for groups that did not participate in the match.
|
| span(self, group=0, /)
| For match object m, return the 2-tuple (m.start(group), m.end(group)).
|
| start(self, group=0, /)
| Return index of the start of the substring matched by group.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| endpos
| The index into the string beyond which the RE engine will not go.
|
| lastgroup
| The name of the last matched capturing group.
|
| lastindex
| The integer index of the last matched capturing group.
|
| pos
| The index into the string at which the RE engine started looking for a match.
|
| re
| The regular expression object.
|
| regs
|
| string
| The string passed to match() or search().
class Pattern(builtins.object)
| Compiled regular expression object.
|
| Methods defined here:
|
| __copy__(self, /)
|
| __deepcopy__(self, memo, /)
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| findall(self, /, string, pos=0, endpos=9223372036854775807)
| Return a list of all non-overlapping matches of pattern in string.
|
| finditer(self, /, string, pos=0, endpos=9223372036854775807)
| Return an iterator over all non-overlapping matches for the RE pattern in string.
|
| For each match, the iterator returns a match object.
|
| fullmatch(self, /, string, pos=0, endpos=9223372036854775807)
| Matches against all of the string.
|
| match(self, /, string, pos=0, endpos=9223372036854775807)
| Matches zero or more characters at the beginning of the string.
|
| scanner(self, /, string, pos=0, endpos=9223372036854775807)
|
| search(self, /, string, pos=0, endpos=9223372036854775807)
| Scan through string looking for a match, and return a corresponding match object instance.
|
| Return None if no position in the string matches.
|
| split(self, /, string, maxsplit=0)
| Split string by the occurrences of pattern.
|
| sub(self, /, repl, string, count=0)
| Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl.
|
| subn(self, /, repl, string, count=0)
| Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| flags
| The regex matching flags.
|
| groupindex
| A dictionary mapping group names to group numbers.
|
| groups
| The number of capturing groups in the pattern.
|
| pattern
| The pattern string from which the RE object was compiled.
class RegexFlag(enum.IntFlag)
| RegexFlag(*values)
|
| An enumeration.
|
| Method resolution order:
| RegexFlag
| enum.IntFlag
| builtins.int
| enum.ReprEnum
| enum.Flag
| enum.Enum
| builtins.object
|
| Methods defined here:
|
| __and__(self, other) from enum.Flag
|
| __format__(self, format_spec, /) from builtins.int
| Convert to a string according to format_spec.
|
| __invert__(self) from enum.Flag
|
| __new__(cls, value) from enum.Enum
| Create and return a new object. See help(type) for accurate signature.
|
| __or__(self, other) from enum.Flag
| Return self|value.
|
| __rand__ = __and__(self, other)
|
| __repr__ = global_flag_repr(self) from enum
| use module.flag_name instead of class.flag_name
|
| the module is the last module in case of a multi-module name
|
| __ror__ = __or__(self, other)
|
| __rxor__ = __xor__(self, other)
|
| __str__(self, /) from builtins.object
| Return str(self).
|
| __xor__(self, other) from enum.Flag
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| ASCII = re.ASCII
|
| DEBUG = re.DEBUG
|
| DOTALL = re.DOTALL
|
| IGNORECASE = re.IGNORECASE
|
| LOCALE = re.LOCALE
|
| MULTILINE = re.MULTILINE
|
| TEMPLATE = re.TEMPLATE
|
| UNICODE = re.UNICODE
|
| VERBOSE = re.VERBOSE
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.int:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __ceil__(...)
| Ceiling of an Integral returns itself.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(...)
| Flooring an Integral returns itself.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __le__(self, value, /)
| Return self<=value.
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __round__(...)
| Rounding an Integral returns itself.
|
| Rounding with an ndigits argument also returns an integer.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __sizeof__(self, /)
| Returns size in memory, in bytes.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is equal to the original int.
|
| The ratio is in lowest terms and has a positive denominator.
|
| >>> (10).as_integer_ratio()
| (10, 1)
| >>> (-10).as_integer_ratio()
| (-10, 1)
| >>> (0).as_integer_ratio()
| (0, 1)
|
| bit_count(self, /)
| Number of ones in the binary representation of the absolute value of self.
|
| Also known as the population count.
|
| >>> bin(13)
| '0b1101'
| >>> (13).bit_count()
| 3
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| is_integer(self, /)
| Returns True. Exists for duck type compatibility with float.is_integer.
|
| to_bytes(self, /, length=1, byteorder='big', *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes. Default
| is length 1.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.int:
|
| from_bytes(bytes, byteorder='big', *, signed=False)
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.
| Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.int:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Flag:
|
| __contains__(self, other)
| Returns True if self has at least the same flags set as other.
|
| __iter__(self)
| Returns flags in definition order.
|
| __len__(self)
| Return the number of members (no aliases)
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Enum:
|
| __dir__(self)
| Returns public methods and other interesting attributes.
|
| __init__(self, *args, **kwds)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce_ex__(self, proto)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Static methods inherited from enum.EnumType:
|
| __getitem__(name)
| Return the member matching `name`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
class error(builtins.Exception)
| error(msg, pattern=None, pos=None)
|
| Exception raised for invalid regular expressions.
|
| Attributes:
|
| msg: The unformatted error message
| pattern: The regular expression pattern
| pos: The index in the pattern where compilation failed (may be None)
| lineno: The line corresponding to pos (may be None)
| colno: The column corresponding to pos (may be None)
|
| Method resolution order:
| error
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, msg, pattern=None, pos=None) from re._constants.error
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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
FUNCTIONS
compile(pattern, flags=0)
Compile a regular expression pattern, returning a Pattern object.
escape(pattern)
Escape special characters in a string.
findall(pattern, string, flags=0)
Return a list of all non-overlapping matches in the string.
If one or more capturing groups are present in the pattern, return
a list of groups; this will be a list of tuples if the pattern
has more than one group.
Empty matches are included in the result.
finditer(pattern, string, flags=0)
Return an iterator over all non-overlapping matches in the
string. For each match, the iterator returns a Match object.
Empty matches are included in the result.
fullmatch(pattern, string, flags=0)
Try to apply the pattern to all of the string, returning
a Match object, or None if no match was found.
match(pattern, string, flags=0)
Try to apply the pattern at the start of the string, returning
a Match object, or None if no match was found.
purge()
Clear the regular expression caches
search(pattern, string, flags=0)
Scan through string looking for a match to the pattern, returning
a Match object, or None if no match was found.
split(pattern, string, maxsplit=0, flags=0)
Split the source string by the occurrences of the pattern,
returning a list containing the resulting substrings. If
capturing parentheses are used in pattern, then the text of all
groups in the pattern are also returned as part of the resulting
list. If maxsplit is nonzero, at most maxsplit splits occur,
and the remainder of the string is returned as the final element
of the list.
sub(pattern, repl, string, count=0, flags=0)
Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl. repl can be either a string or a callable;
if a string, backslash escapes in it are processed. If it is
a callable, it's passed the Match object and must return
a replacement string to be used.
subn(pattern, repl, string, count=0, flags=0)
Return a 2-tuple containing (new_string, number).
new_string is the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in the source
string by the replacement repl. number is the number of
substitutions that were made. repl can be either a string or a
callable; if a string, backslash escapes in it are processed.
If it is a callable, it's passed the Match object and must
return a replacement string to be used.
template(pattern, flags=0)
Compile a template pattern, returning a Pattern object, deprecated
DATA
A = re.ASCII
ASCII = re.ASCII
DOTALL = re.DOTALL
I = re.IGNORECASE
IGNORECASE = re.IGNORECASE
L = re.LOCALE
LOCALE = re.LOCALE
M = re.MULTILINE
MULTILINE = re.MULTILINE
NOFLAG = re.NOFLAG
S = re.DOTALL
U = re.UNICODE
UNICODE = re.UNICODE
VERBOSE = re.VERBOSE
X = re.VERBOSE
__all__ = ['match', 'fullmatch', 'search', 'sub', 'subn', 'split', 'fi...
VERSION
2.2.1
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\re\__init__.py
matplotlib.sanitize_sequence
Python Library Documentation: function sanitize_sequence in module matplotlib.cbook
sanitize_sequence(data)
Convert dictview objects to list. Other inputs are returned unchanged.
matplotlib.scale
Python Library Documentation: module matplotlib.scale in matplotlib
NAME
matplotlib.scale
DESCRIPTION
Scales define the distribution of data values on an axis, e.g. a log scaling.
They are defined as subclasses of `ScaleBase`.
See also `.axes.Axes.set_xscale` and the scales examples in the documentation.
See :doc:`/gallery/scales/custom_scale` for a full example of defining a custom
scale.
Matplotlib also supports non-separable transformations that operate on both
`~.axis.Axis` at the same time. They are known as projections, and defined in
`matplotlib.projections`.
CLASSES
builtins.object
ScaleBase
AsinhScale
FuncScale
LinearScale
LogScale
FuncScaleLog
LogitScale
SymmetricalLogScale
matplotlib.transforms.Transform(matplotlib.transforms.TransformNode)
AsinhTransform
FuncTransform
InvertedAsinhTransform
InvertedLogTransform
InvertedSymmetricalLogTransform
LogTransform
LogisticTransform
LogitTransform
SymmetricalLogTransform
class AsinhScale(ScaleBase)
| AsinhScale(axis, *, linear_width=1.0, base=10, subs='auto', **kwargs)
|
| A quasi-logarithmic scale based on the inverse hyperbolic sine (asinh)
|
| For values close to zero, this is essentially a linear scale,
| but for large magnitude values (either positive or negative)
| it is asymptotically logarithmic. The transition between these
| linear and logarithmic regimes is smooth, and has no discontinuities
| in the function gradient in contrast to
| the `.SymmetricalLogScale` ("symlog") scale.
|
| Specifically, the transformation of an axis coordinate :math:`a` is
| :math:`a \rightarrow a_0 \sinh^{-1} (a / a_0)` where :math:`a_0`
| is the effective width of the linear region of the transformation.
| In that region, the transformation is
| :math:`a \rightarrow a + \mathcal{O}(a^3)`.
| For large values of :math:`a` the transformation behaves as
| :math:`a \rightarrow a_0 \, \mathrm{sgn}(a) \ln |a| + \mathcal{O}(1)`.
|
| .. note::
|
| This API is provisional and may be revised in the future
| based on early user feedback.
|
| Method resolution order:
| AsinhScale
| ScaleBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, axis, *, linear_width=1.0, base=10, subs='auto', **kwargs)
| Parameters
| ----------
| linear_width : float, default: 1
| The scale parameter (elsewhere referred to as :math:`a_0`)
| defining the extent of the quasi-linear region,
| and the coordinate values beyond which the transformation
| becomes asymptotically logarithmic.
| base : int, default: 10
| The number base used for rounding tick locations
| on a logarithmic scale. If this is less than one,
| then rounding is to the nearest integer multiple
| of powers of ten.
| subs : sequence of int
| Multiples of the number base used for minor ticks.
| If set to 'auto', this will use built-in defaults,
| e.g. (2, 5) for base=10.
|
| get_transform(self)
| Return the `.Transform` object associated with this scale.
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| linear_width
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| auto_tick_multipliers = {3: (2,), 4: (2,), 5: (2,), 8: (2, 4), 10: (2,...
|
| name = 'asinh'
|
| ----------------------------------------------------------------------
| Methods inherited from ScaleBase:
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Return the range *vmin*, *vmax*, restricted to the
| domain supported by this scale (if any).
|
| *minpos* should be the minimum positive value in the data.
| This is used by log scales to determine a minimum value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ScaleBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class AsinhTransform(matplotlib.transforms.Transform)
| AsinhTransform(linear_width)
|
| Inverse hyperbolic-sine transformation used by `.AsinhScale`
|
| Method resolution order:
| AsinhTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, linear_width)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class FuncScale(ScaleBase)
| FuncScale(axis, functions)
|
| Provide an arbitrary scale with user-supplied function for the axis.
|
| Method resolution order:
| FuncScale
| ScaleBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, axis, functions)
| Parameters
| ----------
| axis : `~matplotlib.axis.Axis`
| The axis for the scale.
| functions : (callable, callable)
| two-tuple of the forward and inverse functions for the scale.
| The forward function must be monotonic.
|
| Both functions must have the signature::
|
| def forward(values: array-like) -> array-like
|
| get_transform(self)
| Return the `.FuncTransform` associated with this scale.
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| name = 'function'
|
| ----------------------------------------------------------------------
| Methods inherited from ScaleBase:
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Return the range *vmin*, *vmax*, restricted to the
| domain supported by this scale (if any).
|
| *minpos* should be the minimum positive value in the data.
| This is used by log scales to determine a minimum value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ScaleBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class FuncScaleLog(LogScale)
| FuncScaleLog(axis, functions, base=10)
|
| Provide an arbitrary scale with user-supplied function for the axis and
| then put on a logarithmic axes.
|
| Method resolution order:
| FuncScaleLog
| LogScale
| ScaleBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, axis, functions, base=10)
| Parameters
| ----------
| axis : `~matplotlib.axis.Axis`
| The axis for the scale.
| functions : (callable, callable)
| two-tuple of the forward and inverse functions for the scale.
| The forward function must be monotonic.
|
| Both functions must have the signature::
|
| def forward(values: array-like) -> array-like
|
| base : float, default: 10
| Logarithmic base of the scale.
|
| get_transform(self)
| Return the `.Transform` associated with this scale.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| base
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| name = 'functionlog'
|
| ----------------------------------------------------------------------
| Methods inherited from LogScale:
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Limit the domain to positive values.
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ScaleBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class FuncTransform(matplotlib.transforms.Transform)
| FuncTransform(forward, inverse)
|
| A simple transform that takes and arbitrary function for the
| forward and inverse transform.
|
| Method resolution order:
| FuncTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, forward, inverse)
| Parameters
| ----------
| forward : callable
| The forward function for the transform. This function must have
| an inverse and, for best behavior, be monotonic.
| It must have the signature::
|
| def forward(values: array-like) -> array-like
|
| inverse : callable
| The inverse of the forward function. Signature as ``forward``.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class InvertedAsinhTransform(matplotlib.transforms.Transform)
| InvertedAsinhTransform(linear_width)
|
| Hyperbolic sine transformation used by `.AsinhScale`
|
| Method resolution order:
| InvertedAsinhTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, linear_width)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class InvertedLogTransform(matplotlib.transforms.Transform)
| InvertedLogTransform(base)
|
| Method resolution order:
| InvertedLogTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, base)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __str__(self)
| Return str(self).
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class InvertedSymmetricalLogTransform(matplotlib.transforms.Transform)
| InvertedSymmetricalLogTransform(base, linthresh, linscale)
|
| Method resolution order:
| InvertedSymmetricalLogTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, base, linthresh, linscale)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class LinearScale(ScaleBase)
| LinearScale(axis)
|
| The default linear scale.
|
| Method resolution order:
| LinearScale
| ScaleBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, axis)
|
| get_transform(self)
| Return the transform for linear scaling, which is just the
| `~matplotlib.transforms.IdentityTransform`.
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| name = 'linear'
|
| ----------------------------------------------------------------------
| Methods inherited from ScaleBase:
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Return the range *vmin*, *vmax*, restricted to the
| domain supported by this scale (if any).
|
| *minpos* should be the minimum positive value in the data.
| This is used by log scales to determine a minimum value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ScaleBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LogScale(ScaleBase)
| LogScale(axis, *, base=10, subs=None, nonpositive='clip')
|
| A standard logarithmic scale. Care is taken to only plot positive values.
|
| Method resolution order:
| LogScale
| ScaleBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, axis, *, base=10, subs=None, nonpositive='clip')
| Parameters
| ----------
| axis : `~matplotlib.axis.Axis`
| The axis for the scale.
| base : float, default: 10
| The base of the logarithm.
| nonpositive : {'clip', 'mask'}, default: 'clip'
| Determines the behavior for non-positive values. They can either
| be masked as invalid, or clipped to a very small positive number.
| subs : sequence of int, default: None
| Where to place the subticks between each major tick. For example,
| in a log10 scale, ``[2, 3, 4, 5, 6, 7, 8, 9]`` will place 8
| logarithmically spaced minor ticks between each major tick.
|
| get_transform(self)
| Return the `.LogTransform` associated with this scale.
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Limit the domain to positive values.
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| base
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| name = 'log'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ScaleBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LogTransform(matplotlib.transforms.Transform)
| LogTransform(base, nonpositive='clip')
|
| Method resolution order:
| LogTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, base, nonpositive='clip')
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __str__(self)
| Return str(self).
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class LogisticTransform(matplotlib.transforms.Transform)
| LogisticTransform(nonpositive='mask')
|
| Method resolution order:
| LogisticTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, nonpositive='mask')
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __str__(self)
| Return str(self).
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| logistic transform (base 10)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class LogitScale(ScaleBase)
| LogitScale(axis, nonpositive='mask', *, one_half='\\frac{1}{2}', use_overline=False)
|
| Logit scale for data between zero and one, both excluded.
|
| This scale is similar to a log scale close to zero and to one, and almost
| linear around 0.5. It maps the interval ]0, 1[ onto ]-infty, +infty[.
|
| Method resolution order:
| LogitScale
| ScaleBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, axis, nonpositive='mask', *, one_half='\\frac{1}{2}', use_overline=False)
| Parameters
| ----------
| axis : `~matplotlib.axis.Axis`
| Currently unused.
| nonpositive : {'mask', 'clip'}
| Determines the behavior for values beyond the open interval ]0, 1[.
| They can either be masked as invalid, or clipped to a number very
| close to 0 or 1.
| use_overline : bool, default: False
| Indicate the usage of survival notation (\overline{x}) in place of
| standard notation (1-x) for probability close to one.
| one_half : str, default: r"\frac{1}{2}"
| The string used for ticks formatter to represent 1/2.
|
| get_transform(self)
| Return the `.LogitTransform` associated with this scale.
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Limit the domain to values between 0 and 1 (excluded).
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| name = 'logit'
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ScaleBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class LogitTransform(matplotlib.transforms.Transform)
| LogitTransform(nonpositive='mask')
|
| Method resolution order:
| LogitTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, nonpositive='mask')
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __str__(self)
| Return str(self).
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| logit transform (base 10), masked or clipped
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class ScaleBase(builtins.object)
| ScaleBase(axis)
|
| The base class for all scales.
|
| Scales are separable transformations, working on a single dimension.
|
| Subclasses should override
|
| :attr:`name`
| The scale's name.
| :meth:`get_transform`
| A method returning a `.Transform`, which converts data coordinates to
| scaled coordinates. This transform should be invertible, so that e.g.
| mouse positions can be converted back to data coordinates.
| :meth:`set_default_locators_and_formatters`
| A method that sets default locators and formatters for an `~.axis.Axis`
| that uses this scale.
| :meth:`limit_range_for_scale`
| An optional method that "fixes" the axis range to acceptable values,
| e.g. restricting log-scaled axes to positive values.
|
| Methods defined here:
|
| __init__(self, axis)
| Construct a new scale.
|
| Notes
| -----
| The following note is for scale implementers.
|
| For back-compatibility reasons, scales take an `~matplotlib.axis.Axis`
| object as first argument. However, this argument should not
| be used: a single scale object should be usable by multiple
| `~matplotlib.axis.Axis`\es at the same time.
|
| get_transform(self)
| Return the `.Transform` object associated with this scale.
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Return the range *vmin*, *vmax*, restricted to the
| domain supported by this scale (if any).
|
| *minpos* should be the minimum positive value in the data.
| This is used by log scales to determine a minimum value.
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class SymmetricalLogScale(ScaleBase)
| SymmetricalLogScale(axis, *, base=10, linthresh=2, subs=None, linscale=1)
|
| The symmetrical logarithmic scale is logarithmic in both the
| positive and negative directions from the origin.
|
| Since the values close to zero tend toward infinity, there is a
| need to have a range around zero that is linear. The parameter
| *linthresh* allows the user to specify the size of this range
| (-*linthresh*, *linthresh*).
|
| Parameters
| ----------
| base : float, default: 10
| The base of the logarithm.
|
| linthresh : float, default: 2
| Defines the range ``(-x, x)``, within which the plot is linear.
| This avoids having the plot go to infinity around zero.
|
| subs : sequence of int
| Where to place the subticks between each major tick.
| For example, in a log10 scale: ``[2, 3, 4, 5, 6, 7, 8, 9]`` will place
| 8 logarithmically spaced minor ticks between each major tick.
|
| linscale : float, optional
| This allows the linear range ``(-linthresh, linthresh)`` to be
| stretched relative to the logarithmic range. Its value is the number of
| decades to use for each half of the linear range. For example, when
| *linscale* == 1.0 (the default), the space used for the positive and
| negative halves of the linear range will be equal to one decade in
| the logarithmic range.
|
| Method resolution order:
| SymmetricalLogScale
| ScaleBase
| builtins.object
|
| Methods defined here:
|
| __init__(self, axis, *, base=10, linthresh=2, subs=None, linscale=1)
| Construct a new scale.
|
| Notes
| -----
| The following note is for scale implementers.
|
| For back-compatibility reasons, scales take an `~matplotlib.axis.Axis`
| object as first argument. However, this argument should not
| be used: a single scale object should be usable by multiple
| `~matplotlib.axis.Axis`\es at the same time.
|
| get_transform(self)
| Return the `.SymmetricalLogTransform` associated with this scale.
|
| set_default_locators_and_formatters(self, axis)
| Set the locators and formatters of *axis* to instances suitable for
| this scale.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| base
|
| linscale
|
| linthresh
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| name = 'symlog'
|
| ----------------------------------------------------------------------
| Methods inherited from ScaleBase:
|
| limit_range_for_scale(self, vmin, vmax, minpos)
| Return the range *vmin*, *vmax*, restricted to the
| domain supported by this scale (if any).
|
| *minpos* should be the minimum positive value in the data.
| This is used by log scales to determine a minimum value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ScaleBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class SymmetricalLogTransform(matplotlib.transforms.Transform)
| SymmetricalLogTransform(base, linthresh, linscale)
|
| Method resolution order:
| SymmetricalLogTransform
| matplotlib.transforms.Transform
| matplotlib.transforms.TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, base, linthresh, linscale)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 1
|
| is_separable = True
|
| output_dims = 1
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from matplotlib.transforms.Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from matplotlib.transforms.Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from matplotlib.transforms.TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from matplotlib.transforms.TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from matplotlib.transforms.TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
FUNCTIONS
get_scale_names()
Return the names of the available scales.
register_scale(scale_class)
Register a new kind of scale.
Parameters
----------
scale_class : subclass of `ScaleBase`
The scale to register.
scale_factory(scale, axis, **kwargs)
Return a scale class by name.
Parameters
----------
scale : {'asinh', 'function', 'functionlog', 'linear', 'log', 'logit', 'symlog'}
axis : `~matplotlib.axis.Axis`
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\scale.py
matplotlib.set_loglevel
Python Library Documentation: function set_loglevel in module matplotlib
set_loglevel(level)
Configure Matplotlib's logging levels.
Matplotlib uses the standard library `logging` framework under the root
logger 'matplotlib'. This is a helper function to:
- set Matplotlib's root logger level
- set the root logger handler's 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.
Users or applications that are installing their own logging handlers
may want to directly manipulate ``logging.getLogger('matplotlib')`` rather
than use this function.
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.
matplotlib.shutil
Python Library Documentation: module shutil
NAME
shutil - Utility functions for copying and archiving files and directory trees.
MODULE REFERENCE
https://docs.python.org/3.12/library/shutil.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
XXX The functions here don't copy the resource fork or other metadata on Mac.
CLASSES
builtins.OSError(builtins.Exception)
Error
SameFileError
ExecError
SpecialFileError
class Error(builtins.OSError)
| Method resolution order:
| Error
| builtins.OSError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(...)
| Helper for pickle.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| 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:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 ExecError(builtins.OSError)
| Raised when a command could not be executed
|
| Method resolution order:
| ExecError
| builtins.OSError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(...)
| Helper for pickle.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| 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:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 SameFileError(Error)
| Raised when source and destination are the same file.
|
| Method resolution order:
| SameFileError
| Error
| builtins.OSError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors inherited from Error:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(...)
| Helper for pickle.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| 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:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 SpecialFileError(builtins.OSError)
| Raised when trying to do a kind of operation (e.g. copying) which is
| not supported on a special file (e.g. a named pipe)
|
| Method resolution order:
| SpecialFileError
| builtins.OSError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(...)
| Helper for pickle.
|
| __str__(self, /)
| Return str(self).
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| 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:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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
FUNCTIONS
chown(path, user=None, group=None)
Change owner user and group of the given path.
user and group can be the uid/gid or the user/group names, and in that case,
they are converted to their respective uid/gid.
copy(src, dst, *, follow_symlinks=True)
Copy data and mode bits ("cp src dst"). Return the file's destination.
The destination may be a directory.
If follow_symlinks is false, symlinks won't be followed. This
resembles GNU's "cp -P src dst".
If source and destination are the same file, a SameFileError will be
raised.
copy2(src, dst, *, follow_symlinks=True)
Copy data and metadata. Return the file's destination.
Metadata is copied with copystat(). Please see the copystat function
for more information.
The destination may be a directory.
If follow_symlinks is false, symlinks won't be followed. This
resembles GNU's "cp -P src dst".
copyfile(src, dst, *, follow_symlinks=True)
Copy data from src to dst in the most efficient way possible.
If follow_symlinks is not set and src is a symbolic link, a new
symlink will be created instead of copying the file it points to.
copyfileobj(fsrc, fdst, length=0)
copy data from file-like object fsrc to file-like object fdst
copymode(src, dst, *, follow_symlinks=True)
Copy mode bits from src to dst.
If follow_symlinks is not set, symlinks aren't followed if and only
if both `src` and `dst` are symlinks. If `lchmod` isn't available
(e.g. Linux) this method does nothing.
copystat(src, dst, *, follow_symlinks=True)
Copy file metadata
Copy the permission bits, last access time, last modification time, and
flags from `src` to `dst`. On Linux, copystat() also copies the "extended
attributes" where possible. The file contents, owner, and group are
unaffected. `src` and `dst` are path-like objects or path names given as
strings.
If the optional flag `follow_symlinks` is not set, symlinks aren't
followed if and only if both `src` and `dst` are symlinks.
copytree(src, dst, symlinks=False, ignore=None, copy_function=<function copy2 at 0x00000245A8153880>, ignore_dangling_symlinks=False, dirs_exist_ok=False)
Recursively copy a directory tree and return the destination directory.
If exception(s) occur, an Error is raised with a list of reasons.
If the optional symlinks flag is true, symbolic links in the
source tree result in symbolic links in the destination tree; if
it is false, the contents of the files pointed to by symbolic
links are copied. If the file pointed to by the symlink doesn't
exist, an exception will be added in the list of errors raised in
an Error exception at the end of the copy process.
You can set the optional ignore_dangling_symlinks flag to true if you
want to silence this exception. Notice that this has no effect on
platforms that don't support os.symlink.
The optional ignore argument is a callable. If given, it
is called with the `src` parameter, which is the directory
being visited by copytree(), and `names` which is the list of
`src` contents, as returned by os.listdir():
callable(src, names) -> ignored_names
Since copytree() is called recursively, the callable will be
called once for each directory that is copied. It returns a
list of names relative to the `src` directory that should
not be copied.
The optional copy_function argument is a callable that will be used
to copy each file. It will be called with the source path and the
destination path as arguments. By default, copy2() is used, but any
function that supports the same signature (like copy()) can be used.
If dirs_exist_ok is false (the default) and `dst` already exists, a
`FileExistsError` is raised. If `dirs_exist_ok` is true, the copying
operation will continue if it encounters existing directories, and files
within the `dst` tree will be overwritten by corresponding files from the
`src` tree.
disk_usage(path)
Return disk usage statistics about the given path.
Returned values is a named tuple with attributes 'total', 'used' and
'free', which are the amount of total, used and free space, in bytes.
get_archive_formats()
Returns a list of supported formats for archiving and unarchiving.
Each element of the returned sequence is a tuple (name, description)
get_terminal_size(fallback=(80, 24))
Get the size of the terminal window.
For each of the two dimensions, the environment variable, COLUMNS
and LINES respectively, is checked. If the variable is defined and
the value is a positive integer, it is used.
When COLUMNS or LINES is not defined, which is the common case,
the terminal connected to sys.__stdout__ is queried
by invoking os.get_terminal_size.
If the terminal size cannot be successfully queried, either because
the system doesn't support querying, or because we are not
connected to a terminal, the value given in fallback parameter
is used. Fallback defaults to (80, 24) which is the default
size used by many terminal emulators.
The value returned is a named tuple of type os.terminal_size.
get_unpack_formats()
Returns a list of supported formats for unpacking.
Each element of the returned sequence is a tuple
(name, extensions, description)
ignore_patterns(*patterns)
Function that can be used as copytree() ignore parameter.
Patterns is a sequence of glob-style patterns
that are used to exclude files
make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=0, owner=None, group=None, logger=None)
Create an archive file (eg. zip or tar).
'base_name' is the name of the file to create, minus any format-specific
extension; 'format' is the archive format: one of "zip", "tar", "gztar",
"bztar", or "xztar". Or any other registered format.
'root_dir' is a directory that will be the root directory of the
archive; ie. we typically chdir into 'root_dir' before creating the
archive. 'base_dir' is the directory where we start archiving from;
ie. 'base_dir' will be the common prefix of all files and
directories in the archive. 'root_dir' and 'base_dir' both default
to the current directory. Returns the name of the archive file.
'owner' and 'group' are used when creating a tar archive. By default,
uses the current owner and group.
move(src, dst, copy_function=<function copy2 at 0x00000245A8153880>)
Recursively move a file or directory to another location. This is
similar to the Unix "mv" command. Return the file or directory's
destination.
If dst is an existing directory or a symlink to a directory, then src is
moved inside that directory. The destination path in that directory must
not already exist.
If dst already exists but is not a directory, it may be overwritten
depending on os.rename() semantics.
If the destination is on our current filesystem, then rename() is used.
Otherwise, src is copied to the destination and then removed. Symlinks are
recreated under the new name if os.rename() fails because of cross
filesystem renames.
The optional `copy_function` argument is a callable that will be used
to copy the source or it will be delegated to `copytree`.
By default, copy2() is used, but any function that supports the same
signature (like copy()) can be used.
A lot more could be done here... A look at a mv.c shows a lot of
the issues this implementation glosses over.
register_archive_format(name, function, extra_args=None, description='')
Registers an archive format.
name is the name of the format. function is the callable that will be
used to create archives. If provided, extra_args is a sequence of
(name, value) tuples that will be passed as arguments to the callable.
description can be provided to describe the format, and will be returned
by the get_archive_formats() function.
register_unpack_format(name, extensions, function, extra_args=None, description='')
Registers an unpack format.
`name` is the name of the format. `extensions` is a list of extensions
corresponding to the format.
`function` is the callable that will be
used to unpack archives. The callable will receive archives to unpack.
If it's unable to handle an archive, it needs to raise a ReadError
exception.
If provided, `extra_args` is a sequence of
(name, value) tuples that will be passed as arguments to the callable.
description can be provided to describe the format, and will be returned
by the get_unpack_formats() function.
rmtree(path, ignore_errors=False, onerror=None, *, onexc=None, dir_fd=None)
Recursively delete a directory tree.
If dir_fd is not None, it should be a file descriptor open to a directory;
path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
If ignore_errors is set, errors are ignored; otherwise, if onexc or
onerror is set, it is called to handle the error with arguments (func,
path, exc_info) where func is platform and implementation dependent;
path is the argument to that function that caused it to fail; and
the value of exc_info describes the exception. For onexc it is the
exception instance, and for onerror it is a tuple as returned by
sys.exc_info(). If ignore_errors is false and both onexc and
onerror are None, the exception is reraised.
onerror is deprecated and only remains for backwards compatibility.
If both onerror and onexc are set, onerror is ignored and onexc is used.
unpack_archive(filename, extract_dir=None, format=None, *, filter=None)
Unpack an archive.
`filename` is the name of the archive.
`extract_dir` is the name of the target directory, where the archive
is unpacked. If not provided, the current working directory is used.
`format` is the archive format: one of "zip", "tar", "gztar", "bztar",
or "xztar". Or any other registered format. If not provided,
unpack_archive will use the filename extension and see if an unpacker
was registered for that extension.
In case none is found, a ValueError is raised.
If `filter` is given, it is passed to the underlying
extraction function.
unregister_archive_format(name)
unregister_unpack_format(name)
Removes the pack format from the registry.
which(cmd, mode=1, path=None)
Given a command, mode, and a PATH string, return the path which
conforms to the given mode on the PATH, or None if there is no such
file.
`mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
of os.environ.get("PATH"), or can be overridden with a custom search
path.
DATA
__all__ = ['copyfileobj', 'copyfile', 'copymode', 'copystat', 'copy', ...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\shutil.py
matplotlib.subprocess
Python Library Documentation: module subprocess
NAME
subprocess - Subprocesses with accessible I/O streams
MODULE REFERENCE
https://docs.python.org/3.12/library/subprocess.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module allows you to spawn processes, connect to their
input/output/error pipes, and obtain their return codes.
For a complete description of this module see the Python documentation.
Main API
========
run(...): Runs a command, waits for it to complete, then returns a
CompletedProcess instance.
Popen(...): A class for flexibly executing a command in a new process
Constants
---------
DEVNULL: Special value that indicates that os.devnull should be used
PIPE: Special value that indicates a pipe should be created
STDOUT: Special value that indicates that stderr should go to stdout
Older API
=========
call(...): Runs a command, waits for it to complete, then returns
the return code.
check_call(...): Same as call() but raises CalledProcessError()
if return code is not 0
check_output(...): Same as check_call() but returns the contents of
stdout instead of a return code
getoutput(...): Runs a command in the shell, waits for it to complete,
then returns the output
getstatusoutput(...): Runs a command in the shell, waits for it to complete,
then returns a (exitcode, output) tuple
CLASSES
builtins.Exception(builtins.BaseException)
SubprocessError
CalledProcessError
TimeoutExpired
builtins.object
CompletedProcess
Popen
STARTUPINFO
class CalledProcessError(SubprocessError)
| CalledProcessError(returncode, cmd, output=None, stderr=None)
|
| Raised when run() is called with check=True and the process
| returns a non-zero exit status.
|
| Attributes:
| cmd, returncode, stdout, stderr, output
|
| Method resolution order:
| CalledProcessError
| SubprocessError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, returncode, cmd, output=None, stderr=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| stdout
| Alias for output attribute, to match stderr
|
| ----------------------------------------------------------------------
| Data descriptors inherited from SubprocessError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 CompletedProcess(builtins.object)
| CompletedProcess(args, returncode, stdout=None, stderr=None)
|
| A process that has finished running.
|
| This is returned by run().
|
| Attributes:
| args: The list or str args passed to run().
| returncode: The exit code of the process, negative for signals.
| stdout: The standard output (None if not captured).
| stderr: The standard error (None if not captured).
|
| Methods defined here:
|
| __init__(self, args, returncode, stdout=None, stderr=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| check_returncode(self)
| Raise CalledProcessError if the exit code is non-zero.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Popen(builtins.object)
| Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, user=None, group=None, extra_groups=None, encoding=None, errors=None, text=None, umask=-1, pipesize=-1, process_group=None)
|
| Execute a child program in a new process.
|
| For a complete description of the arguments see the Python documentation.
|
| Arguments:
| args: A string, or a sequence of program arguments.
|
| bufsize: supplied as the buffering argument to the open() function when
| creating the stdin/stdout/stderr pipe file objects
|
| executable: A replacement program to execute.
|
| stdin, stdout and stderr: These specify the executed programs' standard
| input, standard output and standard error file handles, respectively.
|
| preexec_fn: (POSIX only) An object to be called in the child process
| just before the child is executed.
|
| close_fds: Controls closing or inheriting of file descriptors.
|
| shell: If true, the command will be executed through the shell.
|
| cwd: Sets the current directory before the child is executed.
|
| env: Defines the environment variables for the new process.
|
| text: If true, decode stdin, stdout and stderr using the given encoding
| (if set) or the system default otherwise.
|
| universal_newlines: Alias of text, provided for backwards compatibility.
|
| startupinfo and creationflags (Windows only)
|
| restore_signals (POSIX only)
|
| start_new_session (POSIX only)
|
| process_group (POSIX only)
|
| group (POSIX only)
|
| extra_groups (POSIX only)
|
| user (POSIX only)
|
| umask (POSIX only)
|
| pass_fds (POSIX only)
|
| encoding and errors: Text mode encoding and error handling to use for
| file objects stdin, stdout and stderr.
|
| Attributes:
| stdin, stdout, stderr, pid, returncode
|
| Methods defined here:
|
| __del__(self, _maxsize=9223372036854775807, _warn=<built-in function warn>)
|
| __enter__(self)
|
| __exit__(self, exc_type, value, traceback)
|
| __init__(self, args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, user=None, group=None, extra_groups=None, encoding=None, errors=None, text=None, umask=-1, pipesize=-1, process_group=None)
| Create new Popen instance.
|
| __repr__(self)
| Return repr(self).
|
| communicate(self, input=None, timeout=None)
| Interact with process: Send data to stdin and close it.
| Read data from stdout and stderr, until end-of-file is
| reached. Wait for process to terminate.
|
| The optional "input" argument should be data to be sent to the
| child process, or None, if no data should be sent to the child.
| communicate() returns a tuple (stdout, stderr).
|
| By default, all communication is in bytes, and therefore any
| "input" should be bytes, and the (stdout, stderr) will be bytes.
| If in text mode (indicated by self.text_mode), any "input" should
| be a string, and (stdout, stderr) will be strings decoded
| according to locale encoding, or by "encoding" if set. Text mode
| is triggered by setting any of text, encoding, errors or
| universal_newlines.
|
| kill = terminate(self)
|
| poll(self)
| Check if child process has terminated. Set and return returncode
| attribute.
|
| send_signal(self, sig)
| Send a signal to the process.
|
| terminate(self)
| Terminates the process.
|
| wait(self, timeout=None)
| Wait for child process to terminate; returns self.returncode.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| universal_newlines
class STARTUPINFO(builtins.object)
| STARTUPINFO(*, dwFlags=0, hStdInput=None, hStdOutput=None, hStdError=None, wShowWindow=0, lpAttributeList=None)
|
| Methods defined here:
|
| __init__(self, *, dwFlags=0, hStdInput=None, hStdOutput=None, hStdError=None, wShowWindow=0, lpAttributeList=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| copy(self)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class SubprocessError(builtins.Exception)
| # Exception classes used by this module.
|
| Method resolution order:
| SubprocessError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 TimeoutExpired(SubprocessError)
| TimeoutExpired(cmd, timeout, output=None, stderr=None)
|
| This exception is raised when the timeout expires while waiting for a
| child process.
|
| Attributes:
| cmd, output, stdout, stderr, timeout
|
| Method resolution order:
| TimeoutExpired
| SubprocessError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, cmd, timeout, output=None, stderr=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| stdout
|
| ----------------------------------------------------------------------
| Data descriptors inherited from SubprocessError:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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
FUNCTIONS
call(*popenargs, timeout=None, **kwargs)
Run command with arguments. Wait for command to complete or
timeout, then return the returncode attribute.
The arguments are the same as for the Popen constructor. Example:
retcode = call(["ls", "-l"])
check_call(*popenargs, **kwargs)
Run command with arguments. Wait for command to complete. If
the exit code was zero then return, otherwise raise
CalledProcessError. The CalledProcessError object will have the
return code in the returncode attribute.
The arguments are the same as for the call function. Example:
check_call(["ls", "-l"])
check_output(*popenargs, timeout=None, **kwargs)
Run command with arguments and return its output.
If the exit code was non-zero it raises a CalledProcessError. The
CalledProcessError object will have the return code in the returncode
attribute and output in the output attribute.
The arguments are the same as for the Popen constructor. Example:
>>> check_output(["ls", "-l", "/dev/null"])
b'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
The stdout argument is not allowed as it is used internally.
To capture standard error in the result, use stderr=STDOUT.
>>> check_output(["/bin/sh", "-c",
... "ls -l non_existent_file ; exit 0"],
... stderr=STDOUT)
b'ls: non_existent_file: No such file or directory\n'
There is an additional optional argument, "input", allowing you to
pass a string to the subprocess's stdin. If you use this argument
you may not also use the Popen constructor's "stdin" argument, as
it too will be used internally. Example:
>>> check_output(["sed", "-e", "s/foo/bar/"],
... input=b"when in the course of fooman events\n")
b'when in the course of barman events\n'
By default, all communication is in bytes, and therefore any "input"
should be bytes, and the return value will be bytes. If in text mode,
any "input" should be a string, and the return value will be a string
decoded according to locale encoding, or by "encoding" if set. Text mode
is triggered by setting any of text, encoding, errors or universal_newlines.
getoutput(cmd, *, encoding=None, errors=None)
Return output (stdout or stderr) of executing cmd in a shell.
Like getstatusoutput(), except the exit status is ignored and the return
value is a string containing the command's output. Example:
>>> import subprocess
>>> subprocess.getoutput('ls /bin/ls')
'/bin/ls'
getstatusoutput(cmd, *, encoding=None, errors=None)
Return (exitcode, output) of executing cmd in a shell.
Execute the string 'cmd' in a shell with 'check_output' and
return a 2-tuple (status, output). The locale encoding is used
to decode the output and process newlines.
A trailing newline is stripped from the output.
The exit status for the command can be interpreted
according to the rules for the function 'wait'. Example:
>>> import subprocess
>>> subprocess.getstatusoutput('ls /bin/ls')
(0, '/bin/ls')
>>> subprocess.getstatusoutput('cat /bin/junk')
(1, 'cat: /bin/junk: No such file or directory')
>>> subprocess.getstatusoutput('/bin/junk')
(127, 'sh: /bin/junk: not found')
>>> subprocess.getstatusoutput('/bin/kill $$')
(-15, '')
run(*popenargs, input=None, capture_output=False, timeout=None, check=False, **kwargs)
Run command with arguments and return a CompletedProcess instance.
The returned instance will have attributes args, returncode, stdout and
stderr. By default, stdout and stderr are not captured, and those attributes
will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them,
or pass capture_output=True to capture both.
If check is True and the exit code was non-zero, it raises a
CalledProcessError. The CalledProcessError object will have the return code
in the returncode attribute, and output & stderr attributes if those streams
were captured.
If timeout is given, and the process takes too long, a TimeoutExpired
exception will be raised.
There is an optional argument "input", allowing you to
pass bytes or a string to the subprocess's stdin. If you use this argument
you may not also use the Popen constructor's "stdin" argument, as
it will be used internally.
By default, all communication is in bytes, and therefore any "input" should
be bytes, and the stdout and stderr will be bytes. If in text mode, any
"input" should be a string, and stdout and stderr will be strings decoded
according to locale encoding, or by "encoding" if set. Text mode is
triggered by setting any of text, encoding, errors or universal_newlines.
The other arguments are the same as for the Popen constructor.
DATA
ABOVE_NORMAL_PRIORITY_CLASS = 32768
BELOW_NORMAL_PRIORITY_CLASS = 16384
CREATE_BREAKAWAY_FROM_JOB = 16777216
CREATE_DEFAULT_ERROR_MODE = 67108864
CREATE_NEW_CONSOLE = 16
CREATE_NEW_PROCESS_GROUP = 512
CREATE_NO_WINDOW = 134217728
DETACHED_PROCESS = 8
DEVNULL = -3
HIGH_PRIORITY_CLASS = 128
IDLE_PRIORITY_CLASS = 64
NORMAL_PRIORITY_CLASS = 32
PIPE = -1
REALTIME_PRIORITY_CLASS = 256
STARTF_USESHOWWINDOW = 1
STARTF_USESTDHANDLES = 256
STDOUT = -2
STD_ERROR_HANDLE = 4294967284
STD_INPUT_HANDLE = 4294967286
STD_OUTPUT_HANDLE = 4294967285
SW_HIDE = 0
__all__ = ['Popen', 'PIPE', 'STDOUT', 'call', 'check_call', 'getstatus...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\subprocess.py
matplotlib.sys
Python Library Documentation: built-in module sys
NAME
sys
MODULE REFERENCE
https://docs.python.org/3.12/library/sys.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.
Dynamic objects:
argv -- command line arguments; argv[0] is the script pathname if known
path -- module search path; path[0] is the script directory, else ''
modules -- dictionary of loaded modules
displayhook -- called to show results in an interactive session
excepthook -- called to handle any uncaught exception other than SystemExit
To customize printing in an interactive session or to install a custom
top-level exception handler, assign other functions to replace these.
stdin -- standard input file object; used by input()
stdout -- standard output file object; used by print()
stderr -- standard error object; used for error messages
By assigning other file objects (or objects that behave like files)
to these, it is possible to redirect all of the interpreter's I/O.
last_exc - the last uncaught exception
Only available in an interactive session after a
traceback has been printed.
last_type -- type of last uncaught exception
last_value -- value of last uncaught exception
last_traceback -- traceback of last uncaught exception
These three are the (deprecated) legacy representation of last_exc.
Static objects:
builtin_module_names -- tuple of module names built into this interpreter
copyright -- copyright notice pertaining to this interpreter
exec_prefix -- prefix used to find the machine-specific Python library
executable -- absolute path of the executable binary of the Python interpreter
float_info -- a named tuple with information about the float implementation.
float_repr_style -- string indicating the style of repr() output for floats
hash_info -- a named tuple with information about the hash algorithm.
hexversion -- version information encoded as a single integer
implementation -- Python implementation information.
int_info -- a named tuple with information about the int implementation.
maxsize -- the largest supported length of containers.
maxunicode -- the value of the largest Unicode code point
platform -- platform identifier
prefix -- prefix used to find the Python library
thread_info -- a named tuple with information about the thread implementation.
version -- the version of this interpreter as a string
version_info -- version information as a named tuple
dllhandle -- [Windows only] integer handle of the Python DLL
winver -- [Windows only] version number of the Python DLL
_enablelegacywindowsfsencoding -- [Windows only]
__stdin__ -- the original stdin; don't touch!
__stdout__ -- the original stdout; don't touch!
__stderr__ -- the original stderr; don't touch!
__displayhook__ -- the original displayhook; don't touch!
__excepthook__ -- the original excepthook; don't touch!
Functions:
displayhook() -- print an object to the screen, and save it in builtins._
excepthook() -- print an exception and its traceback to sys.stderr
exception() -- return the current thread's active exception
exc_info() -- return information about the current thread's active exception
exit() -- exit the interpreter by raising SystemExit
getdlopenflags() -- returns flags to be used for dlopen() calls
getprofile() -- get the global profiling function
getrefcount() -- return the reference count for an object (plus one :-)
getrecursionlimit() -- return the max recursion depth for the interpreter
getsizeof() -- return the size of an object in bytes
gettrace() -- get the global debug tracing function
setdlopenflags() -- set the flags to be used for dlopen() calls
setprofile() -- set the global profiling function
setrecursionlimit() -- set the max recursion depth for the interpreter
settrace() -- set the global debug tracing function
SUBMODULES
monitoring
FUNCTIONS
__breakpointhook__ = breakpointhook(...)
breakpointhook(*args, **kws)
This hook function is called by built-in breakpoint().
__displayhook__ = displayhook(object, /)
Print an object to sys.stdout and also save it in builtins._
__excepthook__ = excepthook(exctype, value, traceback, /)
Handle an exception by displaying it with a traceback on sys.stderr.
__unraisablehook__ = unraisablehook(unraisable, /)
Handle an unraisable exception.
The unraisable argument has the following attributes:
* exc_type: Exception type.
* exc_value: Exception value, can be None.
* exc_traceback: Exception traceback, can be None.
* err_msg: Error message, can be None.
* object: Object causing the exception, can be None.
activate_stack_trampoline(backend, /)
Activate stack profiler trampoline *backend*.
addaudithook(hook)
Adds a new audit hook callback.
audit(...)
audit(event, *args)
Passes the event to any audit hooks that are attached.
breakpointhook(...)
breakpointhook(*args, **kws)
This hook function is called by built-in breakpoint().
call_tracing(func, args, /)
Call func(*args), while tracing is enabled.
The tracing state is saved, and restored afterwards. This is intended
to be called from a debugger from a checkpoint, to recursively debug
some other code.
deactivate_stack_trampoline()
Deactivate the current stack profiler trampoline backend.
If no stack profiler is activated, this function has no effect.
displayhook(object, /)
Print an object to sys.stdout and also save it in builtins._
exc_info()
Return current exception information: (type, value, traceback).
Return information about the most recent exception caught by an except
clause in the current stack frame or in an older stack frame.
excepthook(exctype, value, traceback, /)
Handle an exception by displaying it with a traceback on sys.stderr.
exception()
Return the current exception.
Return the most recent exception caught by an except clause
in the current stack frame or in an older stack frame, or None
if no such exception exists.
exit(status=None, /)
Exit the interpreter by raising SystemExit(status).
If the status is omitted or None, it defaults to zero (i.e., success).
If the status is an integer, it will be used as the system exit status.
If it is another kind of object, it will be printed and the system
exit status will be one (i.e., failure).
get_asyncgen_hooks()
Return the installed asynchronous generators hooks.
This returns a namedtuple of the form (firstiter, finalizer).
get_coroutine_origin_tracking_depth()
Check status of origin tracking for coroutine objects in this thread.
get_int_max_str_digits()
Return the maximum string digits limit for non-binary int<->str conversions.
getallocatedblocks()
Return the number of memory blocks currently allocated.
getdefaultencoding()
Return the current default encoding used by the Unicode implementation.
getfilesystemencodeerrors()
Return the error mode used Unicode to OS filename conversion.
getfilesystemencoding()
Return the encoding used to convert Unicode filenames to OS filenames.
getprofile()
Return the profiling function set with sys.setprofile.
See the profiler chapter in the library manual.
getrecursionlimit()
Return the current value of the recursion limit.
The recursion limit is the maximum depth of the Python interpreter
stack. This limit prevents infinite recursion from causing an overflow
of the C stack and crashing Python.
getrefcount(object, /)
Return the reference count of object.
The count returned is generally one higher than you might expect,
because it includes the (temporary) reference as an argument to
getrefcount().
getsizeof(...)
getsizeof(object [, default]) -> int
Return the size of object in bytes.
getswitchinterval()
Return the current thread switch interval; see sys.setswitchinterval().
gettrace()
Return the global debug tracing function set with sys.settrace.
See the debugger chapter in the library manual.
getunicodeinternedsize()
Return the number of elements of the unicode interned dictionary
getwindowsversion()
Return info about the running version of Windows as a named tuple.
The members are named: major, minor, build, platform, service_pack,
service_pack_major, service_pack_minor, suite_mask, product_type and
platform_version. For backward compatibility, only the first 5 items
are available by indexing. All elements are numbers, except
service_pack and platform_type which are strings, and platform_version
which is a 3-tuple. Platform is always 2. Product_type may be 1 for a
workstation, 2 for a domain controller, 3 for a server.
Platform_version is a 3-tuple containing a version number that is
intended for identifying the OS rather than feature detection.
intern(string, /)
``Intern'' the given string.
This enters the string in the (global) table of interned strings whose
purpose is to speed up dictionary lookups. Return the string itself or
the previously interned string object with the same value.
is_finalizing()
Return True if Python is exiting.
is_stack_trampoline_active()
Return *True* if a stack profiler trampoline is active.
set_asyncgen_hooks(...)
set_asyncgen_hooks([firstiter] [, finalizer])
Set a finalizer for async generators objects.
set_coroutine_origin_tracking_depth(depth)
Enable or disable origin tracking for coroutine objects in this thread.
Coroutine objects will track 'depth' frames of traceback information
about where they came from, available in their cr_origin attribute.
Set a depth of 0 to disable.
set_int_max_str_digits(maxdigits)
Set the maximum string digits limit for non-binary int<->str conversions.
setprofile(...)
setprofile(function)
Set the profiling function. It will be called on each function call
and return. See the profiler chapter in the library manual.
setrecursionlimit(limit, /)
Set the maximum depth of the Python interpreter stack to n.
This limit prevents infinite recursion from causing an overflow of the C
stack and crashing Python. The highest possible limit is platform-
dependent.
setswitchinterval(interval, /)
Set the ideal thread switching delay inside the Python interpreter.
The actual frequency of switching threads can be lower if the
interpreter executes long sequences of uninterruptible code
(this is implementation-specific and workload-dependent).
The parameter must represent the desired switching delay in seconds
A typical value is 0.005 (5 milliseconds).
settrace(...)
settrace(function)
Set the global debug tracing function. It will be called on each
function call. See the debugger chapter in the library manual.
unraisablehook(unraisable, /)
Handle an unraisable exception.
The unraisable argument has the following attributes:
* exc_type: Exception type.
* exc_value: Exception value, can be None.
* exc_traceback: Exception traceback, can be None.
* err_msg: Error message, can be None.
* object: Object causing the exception, can be None.
DATA
__stderr__ = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1...
__stdin__ = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8...
__stdout__ = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1...
api_version = 1013
argv = [r'f:\JoeyCodes\PyDocs\py_docs.py', '--worker', 'matplotlib', r...
base_exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Pyth...
base_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
builtin_module_names = ('_abc', '_ast', '_bisect', '_blake2', '_codecs...
byteorder = 'little'
copyright = 'Copyright (c) 2001-2023 Python Software Foundati...ematis...
dllhandle = 140727031824384
dont_write_bytecode = False
exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
executable = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
flags = sys.flags(debug=0, inspect=0, interactive=0, opt...ding=0, saf...
float_info = sys.float_info(max=1.7976931348623157e+308, max_...epsilo...
float_repr_style = 'short'
hash_info = sys.hash_info(width=64, modulus=2305843009213693...iphash1...
hexversion = 51119856
implementation = namespace(name='cpython', cache_tag='cpython-312...as...
int_info = sys.int_info(bits_per_digit=30, sizeof_digit=4, ..._str_dig...
maxsize = 9223372036854775807
maxunicode = 1114111
meta_path = [<_distutils_hack.DistutilsMetaFinder object>, <class '_fr...
modules = {'PIL': <module 'PIL' from 'C:\\Users\\Youse\\AppData\\L...P...
orig_argv = [r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
path = [r'f:\JoeyCodes\PyDocs', r'C:\Users\Youse\AppData\Local\Program...
path_hooks = [<class 'zipimport.zipimporter'>, <function FileFinder.pa...
path_importer_cache = {r'C:\Users\Youse\AppData\Local\Programs\Python\...
platform = 'win32'
platlibdir = 'DLLs'
prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312'
pycache_prefix = None
stderr = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1252'...
stdin = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
stdlib_module_names = frozenset({'__future__', '_abc', '_aix_support',...
stdout = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1252'...
thread_info = sys.thread_info(name='nt', lock=None, version=None)
version = '3.12.6 (tags/v3.12.6:a4a2d2b, Sep 6 2024, 20:11:23) [MSC v...
version_info = sys.version_info(major=3, minor=12, micro=6, releaselev...
warnoptions = []
winver = '3.12'
FILE
(built-in)
matplotlib.tempfile
Python Library Documentation: module tempfile
NAME
tempfile - Temporary files.
MODULE REFERENCE
https://docs.python.org/3.12/library/tempfile.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module provides generic, low- and high-level interfaces for
creating temporary files and directories. All of the interfaces
provided by this module can be used without fear of race conditions
except for 'mktemp'. 'mktemp' is subject to race conditions and
should not be used; it is provided for backward compatibility only.
The default path names are returned as str. If you supply bytes as
input, all return values will be in bytes. Ex:
>>> tempfile.mkstemp()
(4, '/tmp/tmptpu9nin8')
>>> tempfile.mkdtemp(suffix=b'')
b'/tmp/tmppbi8f0hy'
This module also provides some data items to the user:
TMP_MAX - maximum number of names that will be tried before
giving up.
tempdir - If this is set to a string before the first use of
any routine from this module, it will be considered as
another candidate location to store temporary files.
CLASSES
builtins.object
TemporaryDirectory
io.IOBase(_io._IOBase)
SpooledTemporaryFile
class SpooledTemporaryFile(io.IOBase)
| SpooledTemporaryFile(max_size=0, mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, dir=None, *, errors=None)
|
| Temporary file wrapper, specialized to switch from BytesIO
| or StringIO to a real file when it exceeds a certain size or
| when a fileno is needed.
|
| Method resolution order:
| SpooledTemporaryFile
| io.IOBase
| _io._IOBase
| builtins.object
|
| Methods defined here:
|
| __del__(self)
|
| __enter__(self)
| # Context management protocol
|
| __exit__(self, exc, value, tb)
|
| __init__(self, max_size=0, mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, dir=None, *, errors=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self)
| Implement iter(self).
|
| close(self)
| Flush and close the IO object.
|
| This method has no effect if the file is already closed.
|
| detach(self)
|
| fileno(self)
| Return underlying file descriptor if one exists.
|
| Raise OSError if the IO object does not use a file descriptor.
|
| flush(self)
| Flush write buffers, if applicable.
|
| This is not implemented for read-only and non-blocking streams.
|
| isatty(self)
| Return whether this is an 'interactive' stream.
|
| Return False if it can't be determined.
|
| read(self, *args)
|
| read1(self, *args)
|
| readable(self)
| Return whether object was opened for reading.
|
| If False, read() will raise OSError.
|
| readinto(self, b)
|
| readinto1(self, b)
|
| readline(self, *args)
| Read and return a line from the stream.
|
| If size is specified, at most size bytes will be read.
|
| The line terminator is always b'\n' for binary files; for text
| files, the newlines argument to open can be used to select the line
| terminator(s) recognized.
|
| readlines(self, *args)
| Return a list of lines from the stream.
|
| hint can be specified to control the number of lines read: no more
| lines will be read if the total size (in bytes/characters) of all
| lines so far exceeds hint.
|
| rollover(self)
|
| seek(self, *args)
| Change the stream position to the given byte offset.
|
| offset
| The stream position, relative to 'whence'.
| whence
| The relative position to seek from.
|
| The offset is interpreted relative to the position indicated by whence.
| Values for whence are:
|
| * os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive
| * os.SEEK_CUR or 1 -- current stream position; offset may be negative
| * os.SEEK_END or 2 -- end of stream; offset is usually negative
|
| Return the new absolute position.
|
| seekable(self)
| Return whether object supports random access.
|
| If False, seek(), tell() and truncate() will raise OSError.
| This method may need to do a test seek().
|
| tell(self)
| Return current stream position.
|
| truncate(self, size=None)
| Truncate file to size bytes.
|
| File pointer is left unchanged. Size defaults to the current IO position
| as reported by tell(). Return the new size.
|
| writable(self)
| Return whether object was opened for writing.
|
| If False, write() will raise OSError.
|
| write(self, s)
|
| writelines(self, iterable)
| Write a list of lines to stream.
|
| Line separators are not added, so it is usual for each of the
| lines provided to have a line separator at the end.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| closed
|
| encoding
|
| errors
|
| mode
|
| name
|
| newlines
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from _io._IOBase:
|
| __next__(self, /)
| Implement next(self).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _io._IOBase:
|
| __dict__
class TemporaryDirectory(builtins.object)
| TemporaryDirectory(suffix=None, prefix=None, dir=None, ignore_cleanup_errors=False, *, delete=True)
|
| Create and return a temporary directory. This has the same
| behavior as mkdtemp but can be used as a context manager. For
| example:
|
| with TemporaryDirectory() as tmpdir:
| ...
|
| Upon exiting the context, the directory and everything contained
| in it are removed (unless delete=False is passed or an exception
| is raised during cleanup and ignore_cleanup_errors is not True).
|
| Optional Arguments:
| suffix - A str suffix for the directory name. (see mkdtemp)
| prefix - A str prefix for the directory name. (see mkdtemp)
| dir - A directory to create this temp dir in. (see mkdtemp)
| ignore_cleanup_errors - False; ignore exceptions during cleanup?
| delete - True; whether the directory is automatically deleted.
|
| Methods defined here:
|
| __enter__(self)
|
| __exit__(self, exc, value, tb)
|
| __init__(self, suffix=None, prefix=None, dir=None, ignore_cleanup_errors=False, *, delete=True)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| cleanup(self)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__ = GenericAlias(...)
| Represent a PEP 585 generic type
|
| E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, dir=None, delete=True, *, errors=None, delete_on_close=True)
Create and return a temporary file.
Arguments:
'prefix', 'suffix', 'dir' -- as for mkstemp.
'mode' -- the mode argument to io.open (default "w+b").
'buffering' -- the buffer size argument to io.open (default -1).
'encoding' -- the encoding argument to io.open (default None)
'newline' -- the newline argument to io.open (default None)
'delete' -- whether the file is automatically deleted (default True).
'delete_on_close' -- if 'delete', whether the file is deleted on close
(default True) or otherwise either on context manager exit
(if context manager was used) or on object finalization. .
'errors' -- the errors argument to io.open (default None)
The file is created as mkstemp() would do it.
Returns an object with a file-like interface; the name of the file
is accessible as its 'name' attribute. The file will be automatically
deleted when it is closed unless the 'delete' argument is set to False.
On POSIX, NamedTemporaryFiles cannot be automatically deleted if
the creating process is terminated abruptly with a SIGKILL signal.
Windows can delete the file even in this case.
TemporaryFile = NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, newline=None, suffix=None, prefix=None, dir=None, delete=True, *, errors=None, delete_on_close=True)
Create and return a temporary file.
Arguments:
'prefix', 'suffix', 'dir' -- as for mkstemp.
'mode' -- the mode argument to io.open (default "w+b").
'buffering' -- the buffer size argument to io.open (default -1).
'encoding' -- the encoding argument to io.open (default None)
'newline' -- the newline argument to io.open (default None)
'delete' -- whether the file is automatically deleted (default True).
'delete_on_close' -- if 'delete', whether the file is deleted on close
(default True) or otherwise either on context manager exit
(if context manager was used) or on object finalization. .
'errors' -- the errors argument to io.open (default None)
The file is created as mkstemp() would do it.
Returns an object with a file-like interface; the name of the file
is accessible as its 'name' attribute. The file will be automatically
deleted when it is closed unless the 'delete' argument is set to False.
On POSIX, NamedTemporaryFiles cannot be automatically deleted if
the creating process is terminated abruptly with a SIGKILL signal.
Windows can delete the file even in this case.
gettempdir()
Returns tempfile.tempdir as str.
gettempdirb()
Returns tempfile.tempdir as bytes.
gettempprefix()
The default prefix for temporary directories as string.
gettempprefixb()
The default prefix for temporary directories as bytes.
mkdtemp(suffix=None, prefix=None, dir=None)
User-callable function to create and return a unique temporary
directory. The return value is the pathname of the directory.
Arguments are as for mkstemp, except that the 'text' argument is
not accepted.
The directory is readable, writable, and searchable only by the
creating user.
Caller is responsible for deleting the directory when done with it.
mkstemp(suffix=None, prefix=None, dir=None, text=False)
User-callable function to create and return a unique temporary
file. The return value is a pair (fd, name) where fd is the
file descriptor returned by os.open, and name is the filename.
If 'suffix' is not None, the file name will end with that suffix,
otherwise there will be no suffix.
If 'prefix' is not None, the file name will begin with that prefix,
otherwise a default prefix is used.
If 'dir' is not None, the file will be created in that directory,
otherwise a default directory is used.
If 'text' is specified and true, the file is opened in text
mode. Else (the default) the file is opened in binary mode.
If any of 'suffix', 'prefix' and 'dir' are not None, they must be the
same type. If they are bytes, the returned name will be bytes; str
otherwise.
The file is readable and writable only by the creating user ID.
If the operating system uses permission bits to indicate whether a
file is executable, the file is executable by no one. The file
descriptor is not inherited by children of this process.
Caller is responsible for deleting the file when done with it.
mktemp(suffix='', prefix='tmp', dir=None)
User-callable function to return a unique temporary file name. The
file is not created.
Arguments are similar to mkstemp, except that the 'text' argument is
not accepted, and suffix=None, prefix=None and bytes file names are not
supported.
THIS FUNCTION IS UNSAFE AND SHOULD NOT BE USED. The file name may
refer to a file that did not exist at some point, but by the time
you get around to creating it, someone else may have beaten you to
the punch.
DATA
TMP_MAX = 2147483647
__all__ = ['NamedTemporaryFile', 'TemporaryFile', 'SpooledTemporaryFil...
tempdir = None
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\tempfile.py
matplotlib.ticker
Python Library Documentation: module matplotlib.ticker in matplotlib
NAME
matplotlib.ticker
DESCRIPTION
Tick locating and formatting
============================
This module contains classes for configuring tick locating and formatting.
Generic tick locators and formatters are provided, as well as domain specific
custom ones.
Although the locators know nothing about major or minor ticks, they are used
by the Axis class to support major and minor tick locating and formatting.
.. _tick_locating:
.. _locators:
Tick locating
-------------
The Locator class is the base class for all tick locators. The locators
handle autoscaling of the view limits based on the data limits, and the
choosing of tick locations. A useful semi-automatic tick locator is
`MultipleLocator`. It is initialized with a base, e.g., 10, and it picks
axis limits and ticks that are multiples of that base.
The Locator subclasses defined here are:
======================= =======================================================
`AutoLocator` `MaxNLocator` with simple defaults. This is the default
tick locator for most plotting.
`MaxNLocator` Finds up to a max number of intervals with ticks at
nice locations.
`LinearLocator` Space ticks evenly from min to max.
`LogLocator` Space ticks logarithmically from min to max.
`MultipleLocator` Ticks and range are a multiple of base; either integer
or float.
`FixedLocator` Tick locations are fixed.
`IndexLocator` Locator for index plots (e.g., where
``x = range(len(y))``).
`NullLocator` No ticks.
`SymmetricalLogLocator` Locator for use with the symlog norm; works like
`LogLocator` for the part outside of the threshold and
adds 0 if inside the limits.
`AsinhLocator` Locator for use with the asinh norm, attempting to
space ticks approximately uniformly.
`LogitLocator` Locator for logit scaling.
`AutoMinorLocator` Locator for minor ticks when the axis is linear and the
major ticks are uniformly spaced. Subdivides the major
tick interval into a specified number of minor
intervals, defaulting to 4 or 5 depending on the major
interval.
======================= =======================================================
There are a number of locators specialized for date locations - see
the :mod:`.dates` module.
You can define your own locator by deriving from Locator. You must
override the ``__call__`` method, which returns a sequence of locations,
and you will probably want to override the autoscale method to set the
view limits from the data limits.
If you want to override the default locator, use one of the above or a custom
locator and pass it to the x- or y-axis instance. The relevant methods are::
ax.xaxis.set_major_locator(xmajor_locator)
ax.xaxis.set_minor_locator(xminor_locator)
ax.yaxis.set_major_locator(ymajor_locator)
ax.yaxis.set_minor_locator(yminor_locator)
The default minor locator is `NullLocator`, i.e., no minor ticks on by default.
.. note::
`Locator` instances should not be used with more than one
`~matplotlib.axis.Axis` or `~matplotlib.axes.Axes`. So instead of::
locator = MultipleLocator(5)
ax.xaxis.set_major_locator(locator)
ax2.xaxis.set_major_locator(locator)
do the following instead::
ax.xaxis.set_major_locator(MultipleLocator(5))
ax2.xaxis.set_major_locator(MultipleLocator(5))
.. _formatters:
Tick formatting
---------------
Tick formatting is controlled by classes derived from Formatter. The formatter
operates on a single tick value and returns a string to the axis.
========================= =====================================================
`NullFormatter` No labels on the ticks.
`FixedFormatter` Set the strings manually for the labels.
`FuncFormatter` User defined function sets the labels.
`StrMethodFormatter` Use string `format` method.
`FormatStrFormatter` Use an old-style sprintf format string.
`ScalarFormatter` Default formatter for scalars: autopick the format
string.
`LogFormatter` Formatter for log axes.
`LogFormatterExponent` Format values for log axis using
``exponent = log_base(value)``.
`LogFormatterMathtext` Format values for log axis using
``exponent = log_base(value)`` using Math text.
`LogFormatterSciNotation` Format values for log axis using scientific notation.
`LogitFormatter` Probability formatter.
`EngFormatter` Format labels in engineering notation.
`PercentFormatter` Format labels as a percentage.
========================= =====================================================
You can derive your own formatter from the Formatter base class by
simply overriding the ``__call__`` method. The formatter class has
access to the axis view and data limits.
To control the major and minor tick label formats, use one of the
following methods::
ax.xaxis.set_major_formatter(xmajor_formatter)
ax.xaxis.set_minor_formatter(xminor_formatter)
ax.yaxis.set_major_formatter(ymajor_formatter)
ax.yaxis.set_minor_formatter(yminor_formatter)
In addition to a `.Formatter` instance, `~.Axis.set_major_formatter` and
`~.Axis.set_minor_formatter` also accept a ``str`` or function. ``str`` input
will be internally replaced with an autogenerated `.StrMethodFormatter` with
the input ``str``. For function input, a `.FuncFormatter` with the input
function will be generated and used.
See :doc:`/gallery/ticks/major_minor_demo` for an example of setting major
and minor ticks. See the :mod:`matplotlib.dates` module for more information
and examples of using date locators and formatters.
CLASSES
builtins.object
TickHelper
Formatter
EngFormatter
FixedFormatter
FormatStrFormatter
FuncFormatter
LogFormatter
LogFormatterExponent
LogFormatterMathtext
LogFormatterSciNotation
LogitFormatter
NullFormatter
PercentFormatter
ScalarFormatter
StrMethodFormatter
Locator
AsinhLocator
AutoMinorLocator
FixedLocator
IndexLocator
LinearLocator
LogLocator
MaxNLocator
AutoLocator
LogitLocator
MultipleLocator
NullLocator
SymmetricalLogLocator
class AsinhLocator(Locator)
| AsinhLocator(linear_width, numticks=11, symthresh=0.2, base=10, subs=None)
|
| Place ticks spaced evenly on an inverse-sinh scale.
|
| Generally used with the `~.scale.AsinhScale` class.
|
| .. note::
|
| This API is provisional and may be revised in the future
| based on early user feedback.
|
| Method resolution order:
| AsinhLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, linear_width, numticks=11, symthresh=0.2, base=10, subs=None)
| Parameters
| ----------
| linear_width : float
| The scale parameter defining the extent
| of the quasi-linear region.
| numticks : int, default: 11
| The approximate number of major ticks that will fit
| along the entire axis
| symthresh : float, default: 0.2
| The fractional threshold beneath which data which covers
| a range that is approximately symmetric about zero
| will have ticks that are exactly symmetric.
| base : int, default: 10
| The number base used for rounding tick locations
| on a logarithmic scale. If this is less than one,
| then rounding is to the nearest integer multiple
| of powers of ten.
| subs : tuple, default: None
| Multiples of the number base, typically used
| for the minor ticks, e.g. (2, 5) when base=10.
|
| set_params(self, numticks=None, symthresh=None, base=None, subs=None)
| Set parameters within this locator.
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| view_limits(self, vmin, vmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class AutoLocator(MaxNLocator)
| Place evenly spaced ticks, with the step size and maximum number of ticks chosen
| automatically.
|
| This is a subclass of `~matplotlib.ticker.MaxNLocator`, with parameters
| *nbins = 'auto'* and *steps = [1, 2, 2.5, 5, 10]*.
|
| Method resolution order:
| AutoLocator
| MaxNLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __init__(self)
| To know the values of the non-public parameters, please have a
| look to the defaults of `~matplotlib.ticker.MaxNLocator`.
|
| ----------------------------------------------------------------------
| Methods inherited from MaxNLocator:
|
| __call__(self)
| Return the locations of the ticks.
|
| set_params(self, **kwargs)
| Set parameters for this locator.
|
| Parameters
| ----------
| nbins : int or 'auto', optional
| see `.MaxNLocator`
| steps : array-like, optional
| see `.MaxNLocator`
| integer : bool, optional
| see `.MaxNLocator`
| symmetric : bool, optional
| see `.MaxNLocator`
| prune : {'lower', 'upper', 'both', None}, optional
| see `.MaxNLocator`
| min_n_ticks : int, optional
| see `.MaxNLocator`
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| view_limits(self, dmin, dmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from MaxNLocator:
|
| default_params = {'integer': False, 'min_n_ticks': 2, 'nbins': 10, 'pr...
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class AutoMinorLocator(Locator)
| AutoMinorLocator(n=None)
|
| Place evenly spaced minor ticks, with the step size and maximum number of ticks
| chosen automatically.
|
| The Axis scale must be linear with evenly spaced major ticks .
|
| Method resolution order:
| AutoMinorLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, n=None)
| *n* is the number of subdivisions of the interval between
| major ticks; e.g., n=2 will place a single minor tick midway
| between major ticks.
|
| If *n* is omitted or None, the value stored in rcParams will be used.
| In case *n* is set to 'auto', it will be set to 4 or 5. If the distance
| between the major ticks equals 1, 2.5, 5 or 10 it can be perfectly
| divided in 5 equidistant sub-intervals with a length multiple of
| 0.05. Otherwise it is divided in 4 sub-intervals.
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| set_params(self, **kwargs)
| Do nothing, and raise a warning. Any locator class not supporting the
| set_params() function will call this.
|
| view_limits(self, vmin, vmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class EngFormatter(Formatter)
| EngFormatter(unit='', places=None, sep=' ', *, usetex=None, useMathText=None)
|
| Format axis values using engineering prefixes to represent powers
| of 1000, plus a specified unit, e.g., 10 MHz instead of 1e7.
|
| Method resolution order:
| EngFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| __init__(self, unit='', places=None, sep=' ', *, usetex=None, useMathText=None)
| Parameters
| ----------
| unit : str, default: ""
| Unit symbol to use, suitable for use with single-letter
| representations of powers of 1000. For example, 'Hz' or 'm'.
|
| places : int, default: None
| Precision with which to display the number, specified in
| digits after the decimal point (there will be between one
| and three digits before the decimal point). If it is None,
| the formatting falls back to the floating point format '%g',
| which displays up to 6 *significant* digits, i.e. the equivalent
| value for *places* varies between 0 and 5 (inclusive).
|
| sep : str, default: " "
| Separator used between the value and the prefix/unit. For
| example, one get '3.14 mV' if ``sep`` is " " (default) and
| '3.14mV' if ``sep`` is "". Besides the default behavior, some
| other useful options may be:
|
| * ``sep=""`` to append directly the prefix/unit to the value;
| * ``sep="\N{THIN SPACE}"`` (``U+2009``);
| * ``sep="\N{NARROW NO-BREAK SPACE}"`` (``U+202F``);
| * ``sep="\N{NO-BREAK SPACE}"`` (``U+00A0``).
|
| usetex : bool, default: :rc:`text.usetex`
| To enable/disable the use of TeX's math mode for rendering the
| numbers in the formatter.
|
| useMathText : bool, default: :rc:`axes.formatter.use_mathtext`
| To enable/disable the use mathtext for rendering the numbers in
| the formatter.
|
| format_eng(self, num)
| Format a number in engineering notation, appending a letter
| representing the power of 1000 of the original number.
| Some examples:
|
| >>> format_eng(0) # for self.places = 0
| '0'
|
| >>> format_eng(1000000) # for self.places = 1
| '1.0 M'
|
| >>> format_eng(-1e-6) # for self.places = 2
| '-1.00 µ'
|
| get_useMathText(self)
|
| get_usetex(self)
|
| set_useMathText(self, val)
|
| set_usetex(self, val)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| useMathText
|
| usetex
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| ENG_PREFIXES = {-30: 'q', -27: 'r', -24: 'y', -21: 'z', -18: 'a', -15:...
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class FixedFormatter(Formatter)
| FixedFormatter(seq)
|
| Return fixed strings for tick labels based only on position, not value.
|
| .. note::
| `.FixedFormatter` should only be used together with `.FixedLocator`.
| Otherwise, the labels may end up in unexpected positions.
|
| Method resolution order:
| FixedFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the label that matches the position, regardless of the value.
|
| For positions ``pos < len(seq)``, return ``seq[i]`` regardless of
| *x*. Otherwise return empty string. ``seq`` is the sequence of
| strings that this object was initialized with.
|
| __init__(self, seq)
| Set the sequence *seq* of strings that will be used for labels.
|
| get_offset(self)
|
| set_offset_string(self, ofs)
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class FixedLocator(Locator)
| FixedLocator(locs, nbins=None)
|
| Place ticks at a set of fixed values.
|
| If *nbins* is None ticks are placed at all values. Otherwise, the *locs* array of
| possible positions will be subsampled to keep the number of ticks <=
| :math:`nbins* +1`. The subsampling will be done to include the smallest absolute
| value; for example, if zero is included in the array of possibilities, then it of
| the chosen ticks.
|
| Method resolution order:
| FixedLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, locs, nbins=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| set_params(self, nbins=None)
| Set parameters within this locator.
|
| tick_values(self, vmin, vmax)
| Return the locations of the ticks.
|
| .. note::
|
| Because the values are fixed, vmin and vmax are not used in this
| method.
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| view_limits(self, vmin, vmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class FormatStrFormatter(Formatter)
| FormatStrFormatter(fmt)
|
| Use an old-style ('%' operator) format string to format the tick.
|
| The format string should have a single variable format (%) in it.
| It will be applied to the value (not the position) of the tick.
|
| Negative numeric values (e.g., -1) will use a dash, not a Unicode minus;
| use mathtext to get a Unicode minus by wrapping the format specifier with $
| (e.g. "$%g$").
|
| Method resolution order:
| FormatStrFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the formatted label string.
|
| Only the value *x* is formatted. The position is ignored.
|
| __init__(self, fmt)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class Formatter(TickHelper)
| Create a string based on a tick value and location.
|
| Method resolution order:
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class FuncFormatter(Formatter)
| FuncFormatter(func)
|
| Use a user-defined function for formatting.
|
| The function should take in two inputs (a tick value ``x`` and a
| position ``pos``), and return a string containing the corresponding
| tick label.
|
| Method resolution order:
| FuncFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the value of the user defined function.
|
| *x* and *pos* are passed through as-is.
|
| __init__(self, func)
| Initialize self. See help(type(self)) for accurate signature.
|
| get_offset(self)
|
| set_offset_string(self, ofs)
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class IndexLocator(Locator)
| IndexLocator(base, offset)
|
| Place ticks at every nth point plotted.
|
| IndexLocator assumes index plotting; i.e., that the ticks are placed at integer
| values in the range between 0 and len(data) inclusive.
|
| Method resolution order:
| IndexLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks
|
| __init__(self, base, offset)
| Place ticks every *base* data point, starting at *offset*.
|
| set_params(self, base=None, offset=None)
| Set parameters within this locator
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| view_limits(self, vmin, vmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LinearLocator(Locator)
| LinearLocator(numticks=None, presets=None)
|
| Place ticks at evenly spaced values.
|
| The first time this function is called it will try to set the
| number of ticks to make a nice tick partitioning. Thereafter, the
| number of ticks will be fixed so that interactive navigation will
| be nice
|
| Method resolution order:
| LinearLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, numticks=None, presets=None)
| Parameters
| ----------
| numticks : int or None, default None
| Number of ticks. If None, *numticks* = 11.
| presets : dict or None, default: None
| Dictionary mapping ``(vmin, vmax)`` to an array of locations.
| Overrides *numticks* if there is an entry for the current
| ``(vmin, vmax)``.
|
| set_params(self, numticks=None, presets=None)
| Set parameters within this locator.
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| view_limits(self, vmin, vmax)
| Try to choose the view limits intelligently.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| numticks
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class Locator(TickHelper)
| Determine tick locations.
|
| Note that the same locator should not be used across multiple
| `~matplotlib.axis.Axis` because the locator stores references to the Axis
| data and view limits.
|
| Method resolution order:
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| set_params(self, **kwargs)
| Do nothing, and raise a warning. Any locator class not supporting the
| set_params() function will call this.
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| view_limits(self, vmin, vmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LogFormatter(Formatter)
| LogFormatter(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
|
| Base class for formatting ticks on a log or symlog scale.
|
| It may be instantiated directly, or subclassed.
|
| Parameters
| ----------
| base : float, default: 10.
| Base of the logarithm used in all calculations.
|
| labelOnlyBase : bool, default: False
| If True, label ticks only at integer powers of base.
| This is normally True for major ticks and False for
| minor ticks.
|
| minor_thresholds : (subset, all), default: (1, 0.4)
| If labelOnlyBase is False, these two numbers control
| the labeling of ticks that are not at integer powers of
| base; normally these are the minor ticks. The controlling
| parameter is the log of the axis data range. In the typical
| case where base is 10 it is the number of decades spanned
| by the axis, so we can call it 'numdec'. If ``numdec <= all``,
| all minor ticks will be labeled. If ``all < numdec <= subset``,
| then only a subset of minor ticks will be labeled, so as to
| avoid crowding. If ``numdec > subset`` then no minor ticks will
| be labeled.
|
| linthresh : None or float, default: None
| If a symmetric log scale is in use, its ``linthresh``
| parameter must be supplied here.
|
| Notes
| -----
| The `set_locs` method must be called to enable the subsetting
| logic controlled by the ``minor_thresholds`` parameter.
|
| In some cases such as the colorbar, there is no distinction between
| major and minor ticks; the tick locations might be set manually,
| or by a locator that puts ticks at integer powers of base and
| at intermediate locations. For this situation, disable the
| minor_thresholds logic by using ``minor_thresholds=(np.inf, np.inf)``,
| so that all ticks will be labeled.
|
| To disable labeling of minor ticks when 'labelOnlyBase' is False,
| use ``minor_thresholds=(0, 0)``. This is the default for the
| "classic" style.
|
| Examples
| --------
| To label a subset of minor ticks when the view limits span up
| to 2 decades, and all of the ticks when zoomed in to 0.5 decades
| or less, use ``minor_thresholds=(2, 0.5)``.
|
| To label all minor ticks when the view limits span up to 1.5
| decades, use ``minor_thresholds=(1.5, 1.5)``.
|
| Method resolution order:
| LogFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| __init__(self, base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| set_base(self, base)
| Change the *base* for labeling.
|
| .. warning::
| Should always match the base used for :class:`LogLocator`
|
| set_label_minor(self, labelOnlyBase)
| Switch minor tick labeling on or off.
|
| Parameters
| ----------
| labelOnlyBase : bool
| If True, label ticks only at integer powers of base.
|
| set_locs(self, locs=None)
| Use axis view limits to control which ticks are labeled.
|
| The *locs* parameter is ignored in the present algorithm.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LogFormatterExponent(LogFormatter)
| LogFormatterExponent(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
|
| Format values for log axis using ``exponent = log_base(value)``.
|
| Method resolution order:
| LogFormatterExponent
| LogFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods inherited from LogFormatter:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| __init__(self, base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| set_base(self, base)
| Change the *base* for labeling.
|
| .. warning::
| Should always match the base used for :class:`LogLocator`
|
| set_label_minor(self, labelOnlyBase)
| Switch minor tick labeling on or off.
|
| Parameters
| ----------
| labelOnlyBase : bool
| If True, label ticks only at integer powers of base.
|
| set_locs(self, locs=None)
| Use axis view limits to control which ticks are labeled.
|
| The *locs* parameter is ignored in the present algorithm.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LogFormatterMathtext(LogFormatter)
| LogFormatterMathtext(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
|
| Format values for log axis using ``exponent = log_base(value)``.
|
| Method resolution order:
| LogFormatterMathtext
| LogFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| ----------------------------------------------------------------------
| Methods inherited from LogFormatter:
|
| __init__(self, base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| set_base(self, base)
| Change the *base* for labeling.
|
| .. warning::
| Should always match the base used for :class:`LogLocator`
|
| set_label_minor(self, labelOnlyBase)
| Switch minor tick labeling on or off.
|
| Parameters
| ----------
| labelOnlyBase : bool
| If True, label ticks only at integer powers of base.
|
| set_locs(self, locs=None)
| Use axis view limits to control which ticks are labeled.
|
| The *locs* parameter is ignored in the present algorithm.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LogFormatterSciNotation(LogFormatterMathtext)
| LogFormatterSciNotation(base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
|
| Format values following scientific notation in a logarithmic axis.
|
| Method resolution order:
| LogFormatterSciNotation
| LogFormatterMathtext
| LogFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods inherited from LogFormatterMathtext:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| ----------------------------------------------------------------------
| Methods inherited from LogFormatter:
|
| __init__(self, base=10.0, labelOnlyBase=False, minor_thresholds=None, linthresh=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| set_base(self, base)
| Change the *base* for labeling.
|
| .. warning::
| Should always match the base used for :class:`LogLocator`
|
| set_label_minor(self, labelOnlyBase)
| Switch minor tick labeling on or off.
|
| Parameters
| ----------
| labelOnlyBase : bool
| If True, label ticks only at integer powers of base.
|
| set_locs(self, locs=None)
| Use axis view limits to control which ticks are labeled.
|
| The *locs* parameter is ignored in the present algorithm.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LogLocator(Locator)
| LogLocator(base=10.0, subs=(1.0,), numdecs=<deprecated parameter>, numticks=None)
|
| Place logarithmically spaced ticks.
|
| Places ticks at the values ``subs[j] * base**i``.
|
| Method resolution order:
| LogLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, base=10.0, subs=(1.0,), numdecs=<deprecated parameter>, numticks=None)
| Parameters
| ----------
| base : float, default: 10.0
| The base of the log used, so major ticks are placed at ``base**n``, where
| ``n`` is an integer.
| subs : None or {'auto', 'all'} or sequence of float, default: (1.0,)
| Gives the multiples of integer powers of the base at which to place ticks.
| The default of ``(1.0, )`` places ticks only at integer powers of the base.
| Permitted string values are ``'auto'`` and ``'all'``. Both of these use an
| algorithm based on the axis view limits to determine whether and how to put
| ticks between integer powers of the base:
| - ``'auto'``: Ticks are placed only between integer powers.
| - ``'all'``: Ticks are placed between *and* at integer powers.
| - ``None``: Equivalent to ``'auto'``.
| numticks : None or int, default: None
| The maximum number of ticks to allow on a given axis. The default of
| ``None`` will try to choose intelligently as long as this Locator has
| already been assigned to an axis using `~.axis.Axis.get_tick_space`, but
| otherwise falls back to 9.
|
| nonsingular(self, vmin, vmax)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| set_params(self, base=None, subs=None, numdecs=<deprecated parameter>, numticks=None)
| Set parameters within this locator.
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| view_limits(self, vmin, vmax)
| Try to choose the view limits intelligently.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| numdecs
| [*Deprecated*]
|
| Notes
| -----
| .. deprecated:: 3.8
| This attribute has no effect.\
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LogitFormatter(Formatter)
| LogitFormatter(*, use_overline=False, one_half='\\frac{1}{2}', minor=False, minor_threshold=25, minor_number=6)
|
| Probability formatter (using Math text).
|
| Method resolution order:
| LogitFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| __init__(self, *, use_overline=False, one_half='\\frac{1}{2}', minor=False, minor_threshold=25, minor_number=6)
| Parameters
| ----------
| use_overline : bool, default: False
| If x > 1/2, with x = 1-v, indicate if x should be displayed as
| $\overline{v}$. The default is to display $1-v$.
|
| one_half : str, default: r"\frac{1}{2}"
| The string used to represent 1/2.
|
| minor : bool, default: False
| Indicate if the formatter is formatting minor ticks or not.
| Basically minor ticks are not labelled, except when only few ticks
| are provided, ticks with most space with neighbor ticks are
| labelled. See other parameters to change the default behavior.
|
| minor_threshold : int, default: 25
| Maximum number of locs for labelling some minor ticks. This
| parameter have no effect if minor is False.
|
| minor_number : int, default: 6
| Number of ticks which are labelled when the number of ticks is
| below the threshold.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| set_minor_number(self, minor_number)
| Set the number of minor ticks to label when some minor ticks are
| labelled.
|
| Parameters
| ----------
| minor_number : int
| Number of ticks which are labelled when the number of ticks is
| below the threshold.
|
| set_minor_threshold(self, minor_threshold)
| Set the threshold for labelling minors ticks.
|
| Parameters
| ----------
| minor_threshold : int
| Maximum number of locations for labelling some minor ticks. This
| parameter have no effect if minor is False.
|
| set_one_half(self, one_half)
| Set the way one half is displayed.
|
| one_half : str, default: r"\frac{1}{2}"
| The string used to represent 1/2.
|
| use_overline(self, use_overline)
| Switch display mode with overline for labelling p>1/2.
|
| Parameters
| ----------
| use_overline : bool, default: False
| If x > 1/2, with x = 1-v, indicate if x should be displayed as
| $\overline{v}$. The default is to display $1-v$.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class LogitLocator(MaxNLocator)
| LogitLocator(minor=False, *, nbins='auto')
|
| Place ticks spaced evenly on a logit scale.
|
| Method resolution order:
| LogitLocator
| MaxNLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __init__(self, minor=False, *, nbins='auto')
| Parameters
| ----------
| nbins : int or 'auto', optional
| Number of ticks. Only used if minor is False.
| minor : bool, default: False
| Indicate if this locator is for minor ticks or not.
|
| nonsingular(self, vmin, vmax)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| set_params(self, minor=None, **kwargs)
| Set parameters within this locator.
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| minor
|
| ----------------------------------------------------------------------
| Methods inherited from MaxNLocator:
|
| __call__(self)
| Return the locations of the ticks.
|
| view_limits(self, dmin, dmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from MaxNLocator:
|
| default_params = {'integer': False, 'min_n_ticks': 2, 'nbins': 10, 'pr...
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class MaxNLocator(Locator)
| MaxNLocator(nbins=None, **kwargs)
|
| Place evenly spaced ticks, with a cap on the total number of ticks.
|
| Finds nice tick locations with no more than :math:`nbins + 1` ticks being within the
| view limits. Locations beyond the limits are added to support autoscaling.
|
| Method resolution order:
| MaxNLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, nbins=None, **kwargs)
| Parameters
| ----------
| nbins : int or 'auto', default: 10
| Maximum number of intervals; one less than max number of
| ticks. If the string 'auto', the number of bins will be
| automatically determined based on the length of the axis.
|
| steps : array-like, optional
| Sequence of acceptable tick multiples, starting with 1 and
| ending with 10. For example, if ``steps=[1, 2, 4, 5, 10]``,
| ``20, 40, 60`` or ``0.4, 0.6, 0.8`` would be possible
| sets of ticks because they are multiples of 2.
| ``30, 60, 90`` would not be generated because 3 does not
| appear in this example list of steps.
|
| integer : bool, default: False
| If True, ticks will take only integer values, provided at least
| *min_n_ticks* integers are found within the view limits.
|
| symmetric : bool, default: False
| If True, autoscaling will result in a range symmetric about zero.
|
| prune : {'lower', 'upper', 'both', None}, default: None
| Remove the 'lower' tick, the 'upper' tick, or ticks on 'both' sides
| *if they fall exactly on an axis' edge* (this typically occurs when
| :rc:`axes.autolimit_mode` is 'round_numbers'). Removing such ticks
| is mostly useful for stacked or ganged plots, where the upper tick
| of an Axes overlaps with the lower tick of the axes above it.
|
| min_n_ticks : int, default: 2
| Relax *nbins* and *integer* constraints if necessary to obtain
| this minimum number of ticks.
|
| set_params(self, **kwargs)
| Set parameters for this locator.
|
| Parameters
| ----------
| nbins : int or 'auto', optional
| see `.MaxNLocator`
| steps : array-like, optional
| see `.MaxNLocator`
| integer : bool, optional
| see `.MaxNLocator`
| symmetric : bool, optional
| see `.MaxNLocator`
| prune : {'lower', 'upper', 'both', None}, optional
| see `.MaxNLocator`
| min_n_ticks : int, optional
| see `.MaxNLocator`
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| view_limits(self, dmin, dmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_params = {'integer': False, 'min_n_ticks': 2, 'nbins': 10, 'pr...
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class MultipleLocator(Locator)
| MultipleLocator(base=1.0, offset=0.0)
|
| Place ticks at every integer multiple of a base plus an offset.
|
| Method resolution order:
| MultipleLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, base=1.0, offset=0.0)
| Parameters
| ----------
| base : float > 0
| Interval between ticks.
| offset : float
| Value added to each multiple of *base*.
|
| .. versionadded:: 3.8
|
| set_params(self, base=None, offset=None)
| Set parameters within this locator.
|
| Parameters
| ----------
| base : float > 0
| Interval between ticks.
| offset : float
| Value added to each multiple of *base*.
|
| .. versionadded:: 3.8
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| view_limits(self, dmin, dmax)
| Set the view limits to the nearest tick values that contain the data.
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class NullFormatter(Formatter)
| Always return the empty string.
|
| Method resolution order:
| NullFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position pos.
| ``pos=None`` indicates an unspecified location.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class NullLocator(Locator)
| No ticks
|
| Method resolution order:
| NullLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| tick_values(self, vmin, vmax)
| Return the locations of the ticks.
|
| .. note::
|
| Because the values are Null, vmin and vmax are not used in this
| method.
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| set_params(self, **kwargs)
| Do nothing, and raise a warning. Any locator class not supporting the
| set_params() function will call this.
|
| view_limits(self, vmin, vmax)
| Select a scale for the range from vmin to vmax.
|
| Subclasses should override this method to change locator behaviour.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class PercentFormatter(Formatter)
| PercentFormatter(xmax=100, decimals=None, symbol='%', is_latex=False)
|
| Format numbers as a percentage.
|
| Parameters
| ----------
| xmax : float
| Determines how the number is converted into a percentage.
| *xmax* is the data value that corresponds to 100%.
| Percentages are computed as ``x / xmax * 100``. So if the data is
| already scaled to be percentages, *xmax* will be 100. Another common
| situation is where *xmax* is 1.0.
|
| decimals : None or int
| The number of decimal places to place after the point.
| If *None* (the default), the number will be computed automatically.
|
| symbol : str or None
| A string that will be appended to the label. It may be
| *None* or empty to indicate that no symbol should be used. LaTeX
| special characters are escaped in *symbol* whenever latex mode is
| enabled, unless *is_latex* is *True*.
|
| is_latex : bool
| If *False*, reserved LaTeX characters in *symbol* will be escaped.
|
| Method resolution order:
| PercentFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Format the tick as a percentage with the appropriate scaling.
|
| __init__(self, xmax=100, decimals=None, symbol='%', is_latex=False)
| Initialize self. See help(type(self)) for accurate signature.
|
| convert_to_pct(self, x)
|
| format_pct(self, x, display_range)
| Format the number as a percentage number with the correct
| number of decimals and adds the percent symbol, if any.
|
| If ``self.decimals`` is `None`, the number of digits after the
| decimal point is set based on the *display_range* of the axis
| as follows:
|
| ============= ======== =======================
| display_range decimals sample
| ============= ======== =======================
| >50 0 ``x = 34.5`` => 35%
| >5 1 ``x = 34.5`` => 34.5%
| >0.5 2 ``x = 34.5`` => 34.50%
| ... ... ...
| ============= ======== =======================
|
| This method will not be very good for tiny axis ranges or
| extremely large ones. It assumes that the values on the chart
| are percentages displayed on a reasonable scale.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| symbol
| The configured percent symbol as a string.
|
| If LaTeX is enabled via :rc:`text.usetex`, the special characters
| ``{'#', '$', '%', '&', '~', '_', '^', '\', '{', '}'}`` are
| automatically escaped in the string.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class ScalarFormatter(Formatter)
| ScalarFormatter(useOffset=None, useMathText=None, useLocale=None)
|
| Format tick values as a number.
|
| Parameters
| ----------
| useOffset : bool or float, default: :rc:`axes.formatter.useoffset`
| Whether to use offset notation. See `.set_useOffset`.
| useMathText : bool, default: :rc:`axes.formatter.use_mathtext`
| Whether to use fancy math formatting. See `.set_useMathText`.
| useLocale : bool, default: :rc:`axes.formatter.use_locale`.
| Whether to use locale settings for decimal sign and positive sign.
| See `.set_useLocale`.
|
| Notes
| -----
| In addition to the parameters above, the formatting of scientific vs.
| floating point representation can be configured via `.set_scientific`
| and `.set_powerlimits`).
|
| **Offset notation and scientific notation**
|
| Offset notation and scientific notation look quite similar at first sight.
| Both split some information from the formatted tick values and display it
| at the end of the axis.
|
| - The scientific notation splits up the order of magnitude, i.e. a
| multiplicative scaling factor, e.g. ``1e6``.
|
| - The offset notation separates an additive constant, e.g. ``+1e6``. The
| offset notation label is always prefixed with a ``+`` or ``-`` sign
| and is thus distinguishable from the order of magnitude label.
|
| The following plot with x limits ``1_000_000`` to ``1_000_010`` illustrates
| the different formatting. Note the labels at the right edge of the x axis.
|
| .. plot::
|
| lim = (1_000_000, 1_000_010)
|
| fig, (ax1, ax2, ax3) = plt.subplots(3, 1, gridspec_kw={'hspace': 2})
| ax1.set(title='offset_notation', xlim=lim)
| ax2.set(title='scientific notation', xlim=lim)
| ax2.xaxis.get_major_formatter().set_useOffset(False)
| ax3.set(title='floating point notation', xlim=lim)
| ax3.xaxis.get_major_formatter().set_useOffset(False)
| ax3.xaxis.get_major_formatter().set_scientific(False)
|
| Method resolution order:
| ScalarFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the format for tick value *x* at position *pos*.
|
| __init__(self, useOffset=None, useMathText=None, useLocale=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| get_offset(self)
| Return scientific notation, plus offset.
|
| get_useLocale(self)
| Return whether locale settings are used for formatting.
|
| See Also
| --------
| ScalarFormatter.set_useLocale
|
| get_useMathText(self)
| Return whether to use fancy math formatting.
|
| See Also
| --------
| ScalarFormatter.set_useMathText
|
| get_useOffset(self)
| Return whether automatic mode for offset notation is active.
|
| This returns True if ``set_useOffset(True)``; it returns False if an
| explicit offset was set, e.g. ``set_useOffset(1000)``.
|
| See Also
| --------
| ScalarFormatter.set_useOffset
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| set_powerlimits(self, lims)
| Set size thresholds for scientific notation.
|
| Parameters
| ----------
| lims : (int, int)
| A tuple *(min_exp, max_exp)* containing the powers of 10 that
| determine the switchover threshold. For a number representable as
| :math:`a \times 10^\mathrm{exp}` with :math:`1 <= |a| < 10`,
| scientific notation will be used if ``exp <= min_exp`` or
| ``exp >= max_exp``.
|
| The default limits are controlled by :rc:`axes.formatter.limits`.
|
| In particular numbers with *exp* equal to the thresholds are
| written in scientific notation.
|
| Typically, *min_exp* will be negative and *max_exp* will be
| positive.
|
| For example, ``formatter.set_powerlimits((-3, 4))`` will provide
| the following formatting:
| :math:`1 \times 10^{-3}, 9.9 \times 10^{-3}, 0.01,`
| :math:`9999, 1 \times 10^4`.
|
| See Also
| --------
| ScalarFormatter.set_scientific
|
| set_scientific(self, b)
| Turn scientific notation on or off.
|
| See Also
| --------
| ScalarFormatter.set_powerlimits
|
| set_useLocale(self, val)
| Set whether to use locale settings for decimal sign and positive sign.
|
| Parameters
| ----------
| val : bool or None
| *None* resets to :rc:`axes.formatter.use_locale`.
|
| set_useMathText(self, val)
| Set whether to use fancy math formatting.
|
| If active, scientific notation is formatted as :math:`1.2 \times 10^3`.
|
| Parameters
| ----------
| val : bool or None
| *None* resets to :rc:`axes.formatter.use_mathtext`.
|
| set_useOffset(self, val)
| Set whether to use offset notation.
|
| When formatting a set numbers whose value is large compared to their
| range, the formatter can separate an additive constant. This can
| shorten the formatted numbers so that they are less likely to overlap
| when drawn on an axis.
|
| Parameters
| ----------
| val : bool or float
| - If False, do not use offset notation.
| - If True (=automatic mode), use offset notation if it can make
| the residual numbers significantly shorter. The exact behavior
| is controlled by :rc:`axes.formatter.offset_threshold`.
| - If a number, force an offset of the given value.
|
| Examples
| --------
| With active offset notation, the values
|
| ``100_000, 100_002, 100_004, 100_006, 100_008``
|
| will be formatted as ``0, 2, 4, 6, 8`` plus an offset ``+1e5``, which
| is written to the edge of the axis.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| useLocale
| Return whether locale settings are used for formatting.
|
| See Also
| --------
| ScalarFormatter.set_useLocale
|
| useMathText
| Return whether to use fancy math formatting.
|
| See Also
| --------
| ScalarFormatter.set_useMathText
|
| useOffset
| Return whether automatic mode for offset notation is active.
|
| This returns True if ``set_useOffset(True)``; it returns False if an
| explicit offset was set, e.g. ``set_useOffset(1000)``.
|
| See Also
| --------
| ScalarFormatter.set_useOffset
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class StrMethodFormatter(Formatter)
| StrMethodFormatter(fmt)
|
| Use a new-style format string (as used by `str.format`) to format the tick.
|
| The field used for the tick value must be labeled *x* and the field used
| for the tick position must be labeled *pos*.
|
| The formatter will respect :rc:`axes.unicode_minus` when formatting
| negative numeric values.
|
| It is typically unnecessary to explicitly construct `.StrMethodFormatter`
| objects, as `~.Axis.set_major_formatter` directly accepts the format string
| itself.
|
| Method resolution order:
| StrMethodFormatter
| Formatter
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self, x, pos=None)
| Return the formatted label string.
|
| *x* and *pos* are passed to `str.format` as keyword arguments
| with those exact names.
|
| __init__(self, fmt)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from Formatter:
|
| format_data(self, value)
| Return the full string representation of the value with the
| position unspecified.
|
| format_data_short(self, value)
| Return a short string version of the tick value.
|
| Defaults to the position-independent long value.
|
| format_ticks(self, values)
| Return the tick labels for all the ticks at once.
|
| get_offset(self)
|
| set_locs(self, locs)
| Set the locations of the ticks.
|
| This method is called before computing the tick labels because some
| formatters need to know all tick locations to do so.
|
| ----------------------------------------------------------------------
| Static methods inherited from Formatter:
|
| fix_minus(s)
| Some classes may want to replace a hyphen for minus with the proper
| Unicode symbol (U+2212) for typographical correctness. This is a
| helper method to perform such a replacement when it is enabled via
| :rc:`axes.unicode_minus`.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Formatter:
|
| locs = []
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class SymmetricalLogLocator(Locator)
| SymmetricalLogLocator(transform=None, subs=None, linthresh=None, base=None)
|
| Place ticks spaced linearly near zero and spaced logarithmically beyond a threshold.
|
| Method resolution order:
| SymmetricalLogLocator
| Locator
| TickHelper
| builtins.object
|
| Methods defined here:
|
| __call__(self)
| Return the locations of the ticks.
|
| __init__(self, transform=None, subs=None, linthresh=None, base=None)
| Parameters
| ----------
| transform : `~.scale.SymmetricalLogTransform`, optional
| If set, defines the *base* and *linthresh* of the symlog transform.
| base, linthresh : float, optional
| The *base* and *linthresh* of the symlog transform, as documented
| for `.SymmetricalLogScale`. These parameters are only used if
| *transform* is not set.
| subs : sequence of float, default: [1]
| The multiples of integer powers of the base where ticks are placed,
| i.e., ticks are placed at
| ``[sub * base**i for i in ... for sub in subs]``.
|
| Notes
| -----
| Either *transform*, or both *base* and *linthresh*, must be given.
|
| set_params(self, subs=None, numticks=None)
| Set parameters within this locator.
|
| tick_values(self, vmin, vmax)
| Return the values of the located ticks given **vmin** and **vmax**.
|
| .. note::
| To get tick locations with the vmin and vmax values defined
| automatically for the associated ``axis`` simply call
| the Locator instance::
|
| >>> print(type(loc))
| <type 'Locator'>
| >>> print(loc())
| [1, 2, 3, 4]
|
| view_limits(self, vmin, vmax)
| Try to choose the view limits intelligently.
|
| ----------------------------------------------------------------------
| Methods inherited from Locator:
|
| nonsingular(self, v0, v1)
| Adjust a range as needed to avoid singularities.
|
| This method gets called during autoscaling, with ``(v0, v1)`` set to
| the data limits on the Axes if the Axes contains any data, or
| ``(-inf, +inf)`` if not.
|
| - If ``v0 == v1`` (possibly up to some floating point slop), this
| method returns an expanded interval around this value.
| - If ``(v0, v1) == (-inf, +inf)``, this method returns appropriate
| default view limits.
| - Otherwise, ``(v0, v1)`` is returned without modification.
|
| raise_if_exceeds(self, locs)
| Log at WARNING level if *locs* is longer than `Locator.MAXTICKS`.
|
| This is intended to be called immediately before returning *locs* from
| ``__call__`` to inform users in case their Locator returns a huge
| number of ticks, causing Matplotlib to run out of memory.
|
| The "strange" name of this method dates back to when it would raise an
| exception instead of emitting a log.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Locator:
|
| MAXTICKS = 1000
|
| ----------------------------------------------------------------------
| Methods inherited from TickHelper:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TickHelper:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TickHelper:
|
| axis = None
class TickHelper(builtins.object)
| Methods defined here:
|
| create_dummy_axis(self, **kwargs)
|
| set_axis(self, axis)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| axis = None
DATA
__all__ = ('TickHelper', 'Formatter', 'FixedFormatter', 'NullFormatter...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\ticker.py
matplotlib.transforms
Python Library Documentation: module matplotlib.transforms in matplotlib
NAME
matplotlib.transforms
DESCRIPTION
Matplotlib includes a framework for arbitrary geometric
transformations that is used determine the final position of all
elements drawn on the canvas.
Transforms are composed into trees of `TransformNode` objects
whose actual value depends on their children. When the contents of
children change, their parents are automatically invalidated. The
next time an invalidated transform is accessed, it is recomputed to
reflect those changes. This invalidation/caching approach prevents
unnecessary recomputations of transforms, and contributes to better
interactive performance.
For example, here is a graph of the transform tree used to plot data
to the graph:
.. image:: ../_static/transforms.png
The framework can be used for both affine and non-affine
transformations. However, for speed, we want to use the backend
renderers to perform affine transformations whenever possible.
Therefore, it is possible to perform just the affine or non-affine
part of a transformation on a set of data. The affine is always
assumed to occur after the non-affine. For any transform::
full transform == non-affine part + affine part
The backends are not expected to handle non-affine transformations
themselves.
See the tutorial :ref:`transforms_tutorial` for examples
of how to use transforms.
CLASSES
builtins.object
TransformNode
BboxBase
Bbox
LockableBbox
TransformedBbox
Transform
AffineBase
Affine2DBase
Affine2D
AffineDeltaTransform
BboxTransform
BboxTransformFrom
BboxTransformTo
BboxTransformToMaxOnly
BlendedAffine2D(_BlendedMixin, Affine2DBase)
CompositeAffine2D
IdentityTransform
ScaledTranslation
BlendedGenericTransform(_BlendedMixin, Transform)
CompositeGenericTransform
TransformWrapper
TransformedPath
TransformedPatchPath
_BlendedMixin(builtins.object)
BlendedAffine2D(_BlendedMixin, Affine2DBase)
BlendedGenericTransform(_BlendedMixin, Transform)
class Affine2D(Affine2DBase)
| Affine2D(matrix=None, **kwargs)
|
| A mutable 2D affine transformation.
|
| Method resolution order:
| Affine2D
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, matrix=None, **kwargs)
| Initialize an Affine transform from a 3x3 numpy float array::
|
| a c e
| b d f
| 0 0 1
|
| If *matrix* is None, initialize with the identity transform.
|
| __str__(self)
| Return str(self).
|
| clear(self)
| Reset the underlying matrix to the identity transform.
|
| get_matrix(self)
| Get the underlying transformation matrix as a 3x3 array::
|
| a c e
| b d f
| 0 0 1
|
| .
|
| rotate(self, theta)
| Add a rotation (in radians) to this transform in place.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| rotate_around(self, x, y, theta)
| Add a rotation (in radians) around the point (x, y) in place.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| rotate_deg(self, degrees)
| Add a rotation (in degrees) to this transform in place.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| rotate_deg_around(self, x, y, degrees)
| Add a rotation (in degrees) around the point (x, y) in place.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| scale(self, sx, sy=None)
| Add a scale in place.
|
| If *sy* is None, the same scale is applied in both the *x*- and
| *y*-directions.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| set(self, other)
| Set this transformation from the frozen copy of another
| `Affine2DBase` object.
|
| set_matrix(self, mtx)
| Set the underlying transformation matrix from a 3x3 array::
|
| a c e
| b d f
| 0 0 1
|
| .
|
| skew(self, xShear, yShear)
| Add a skew in place.
|
| *xShear* and *yShear* are the shear angles along the *x*- and
| *y*-axes, respectively, in radians.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| skew_deg(self, xShear, yShear)
| Add a skew in place.
|
| *xShear* and *yShear* are the shear angles along the *x*- and
| *y*-axes, respectively, in degrees.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| translate(self, tx, ty)
| Add a translation in place.
|
| Returns *self*, so this method can easily be chained with more
| calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
| and :meth:`scale`.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| from_values(a, b, c, d, e, f)
| Create a new Affine2D instance from the given values::
|
| a c e
| b d f
| 0 0 1
|
| .
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Affine2DBase:
|
| is_separable
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class Affine2DBase(AffineBase)
| Affine2DBase(*args, **kwargs)
|
| The base class of all 2D affine transformations.
|
| 2D affine transformations are performed using a 3x3 numpy array::
|
| a c e
| b d f
| 0 0 1
|
| This class provides the read-only interface. For a mutable 2D
| affine transformation, use `Affine2D`.
|
| Subclasses of this class will generally only need to override a
| constructor and `~.Transform.get_matrix` that generates a custom 3x3 matrix.
|
| Method resolution order:
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| is_separable
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, *args, **kwargs)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class AffineBase(Transform)
| AffineBase(*args, **kwargs)
|
| The base class of all affine transformations of any number of dimensions.
|
| Method resolution order:
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, *args, **kwargs)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Transform:
|
| has_inverse = False
|
| input_dims = None
|
| is_separable = False
|
| output_dims = None
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class AffineDeltaTransform(Affine2DBase)
| AffineDeltaTransform(transform, **kwargs)
|
| A transform wrapper for transforming displacements between pairs of points.
|
| This class is intended to be used to transform displacements ("position
| deltas") between pairs of points (e.g., as the ``offset_transform``
| of `.Collection`\s): given a transform ``t`` such that ``t =
| AffineDeltaTransform(t) + offset``, ``AffineDeltaTransform``
| satisfies ``AffineDeltaTransform(a - b) == AffineDeltaTransform(a) -
| AffineDeltaTransform(b)``.
|
| This is implemented by forcing the offset components of the transform
| matrix to zero.
|
| This class is experimental as of 3.3, and the API may change.
|
| Method resolution order:
| AffineDeltaTransform
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, transform, **kwargs)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __str__ lambda self from _make_str_method.<locals>
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Affine2DBase:
|
| is_separable
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class Bbox(BboxBase)
| Bbox(points, **kwargs)
|
| A mutable bounding box.
|
| Examples
| --------
| **Create from known bounds**
|
| The default constructor takes the boundary "points" ``[[xmin, ymin],
| [xmax, ymax]]``.
|
| >>> Bbox([[1, 1], [3, 7]])
| Bbox([[1.0, 1.0], [3.0, 7.0]])
|
| Alternatively, a Bbox can be created from the flattened points array, the
| so-called "extents" ``(xmin, ymin, xmax, ymax)``
|
| >>> Bbox.from_extents(1, 1, 3, 7)
| Bbox([[1.0, 1.0], [3.0, 7.0]])
|
| or from the "bounds" ``(xmin, ymin, width, height)``.
|
| >>> Bbox.from_bounds(1, 1, 2, 6)
| Bbox([[1.0, 1.0], [3.0, 7.0]])
|
| **Create from collections of points**
|
| The "empty" object for accumulating Bboxs is the null bbox, which is a
| stand-in for the empty set.
|
| >>> Bbox.null()
| Bbox([[inf, inf], [-inf, -inf]])
|
| Adding points to the null bbox will give you the bbox of those points.
|
| >>> box = Bbox.null()
| >>> box.update_from_data_xy([[1, 1]])
| >>> box
| Bbox([[1.0, 1.0], [1.0, 1.0]])
| >>> box.update_from_data_xy([[2, 3], [3, 2]], ignore=False)
| >>> box
| Bbox([[1.0, 1.0], [3.0, 3.0]])
|
| Setting ``ignore=True`` is equivalent to starting over from a null bbox.
|
| >>> box.update_from_data_xy([[1, 1]], ignore=True)
| >>> box
| Bbox([[1.0, 1.0], [1.0, 1.0]])
|
| .. warning::
|
| It is recommended to always specify ``ignore`` explicitly. If not, the
| default value of ``ignore`` can be changed at any time by code with
| access to your Bbox, for example using the method `~.Bbox.ignore`.
|
| **Properties of the ``null`` bbox**
|
| .. note::
|
| The current behavior of `Bbox.null()` may be surprising as it does
| not have all of the properties of the "empty set", and as such does
| not behave like a "zero" object in the mathematical sense. We may
| change that in the future (with a deprecation period).
|
| The null bbox is the identity for intersections
|
| >>> Bbox.intersection(Bbox([[1, 1], [3, 7]]), Bbox.null())
| Bbox([[1.0, 1.0], [3.0, 7.0]])
|
| except with itself, where it returns the full space.
|
| >>> Bbox.intersection(Bbox.null(), Bbox.null())
| Bbox([[-inf, -inf], [inf, inf]])
|
| A union containing null will always return the full space (not the other
| set!)
|
| >>> Bbox.union([Bbox([[0, 0], [0, 0]]), Bbox.null()])
| Bbox([[-inf, -inf], [inf, inf]])
|
| Method resolution order:
| Bbox
| BboxBase
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __format__(self, fmt)
| Default object formatter.
|
| Return str(self) if format_spec is empty. Raise TypeError otherwise.
|
| __init__(self, points, **kwargs)
| Parameters
| ----------
| points : `~numpy.ndarray`
| A (2, 2) array of the form ``[[x0, y0], [x1, y1]]``.
|
| __repr__(self)
| Return repr(self).
|
| __str__(self)
| Return str(self).
|
| frozen(self)
| The base class for anything that participates in the transform tree
| and needs to invalidate its parents or be invalidated. This includes
| classes that are not really transforms, such as bounding boxes, since some
| transforms depend on bounding boxes to compute their values.
|
| get_points(self)
| Get the points of the bounding box as an array of the form
| ``[[x0, y0], [x1, y1]]``.
|
| ignore(self, value)
| Set whether the existing bounds of the box should be ignored
| by subsequent calls to :meth:`update_from_data_xy`.
|
| value : bool
| - When ``True``, subsequent calls to `update_from_data_xy` will
| ignore the existing bounds of the `Bbox`.
| - When ``False``, subsequent calls to `update_from_data_xy` will
| include the existing bounds of the `Bbox`.
|
| mutated(self)
| Return whether the bbox has changed since init.
|
| mutatedx(self)
| Return whether the x-limits have changed since init.
|
| mutatedy(self)
| Return whether the y-limits have changed since init.
|
| set(self, other)
| Set this bounding box from the "frozen" bounds of another `Bbox`.
|
| set_points(self, points)
| Set the points of the bounding box directly from an array of the form
| ``[[x0, y0], [x1, y1]]``. No error checking is performed, as this
| method is mainly for internal use.
|
| update_from_data_x(self, x, ignore=None)
| Update the x-bounds of the `Bbox` based on the passed in data. After
| updating, the bounds will have positive *width*, and *x0* will be the
| minimal value.
|
| Parameters
| ----------
| x : `~numpy.ndarray`
| Array of x-values.
| ignore : bool, optional
| - When ``True``, ignore the existing bounds of the `Bbox`.
| - When ``False``, include the existing bounds of the `Bbox`.
| - When ``None``, use the last value passed to :meth:`ignore`.
|
| update_from_data_xy(self, xy, ignore=None, updatex=True, updatey=True)
| Update the `Bbox` bounds based on the passed in *xy* coordinates.
|
| After updating, the bounds will have positive *width* and *height*;
| *x0* and *y0* will be the minimal values.
|
| Parameters
| ----------
| xy : (N, 2) array-like
| The (x, y) coordinates.
| ignore : bool, optional
| - When ``True``, ignore the existing bounds of the `Bbox`.
| - When ``False``, include the existing bounds of the `Bbox`.
| - When ``None``, use the last value passed to :meth:`ignore`.
| updatex, updatey : bool, default: True
| When ``True``, update the x/y values.
|
| update_from_data_y(self, y, ignore=None)
| Update the y-bounds of the `Bbox` based on the passed in data. After
| updating, the bounds will have positive *height*, and *y0* will be the
| minimal value.
|
| Parameters
| ----------
| y : `~numpy.ndarray`
| Array of y-values.
| ignore : bool, optional
| - When ``True``, ignore the existing bounds of the `Bbox`.
| - When ``False``, include the existing bounds of the `Bbox`.
| - When ``None``, use the last value passed to :meth:`ignore`.
|
| update_from_path(self, path, ignore=None, updatex=True, updatey=True)
| Update the bounds of the `Bbox` to contain the vertices of the
| provided path. After updating, the bounds will have positive *width*
| and *height*; *x0* and *y0* will be the minimal values.
|
| Parameters
| ----------
| path : `~matplotlib.path.Path`
| ignore : bool, optional
| - When ``True``, ignore the existing bounds of the `Bbox`.
| - When ``False``, include the existing bounds of the `Bbox`.
| - When ``None``, use the last value passed to :meth:`ignore`.
| updatex, updatey : bool, default: True
| When ``True``, update the x/y values.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| from_bounds(x0, y0, width, height)
| Create a new `Bbox` from *x0*, *y0*, *width* and *height*.
|
| *width* and *height* may be negative.
|
| from_extents(*args, minpos=None)
| Create a new Bbox from *left*, *bottom*, *right* and *top*.
|
| The *y*-axis increases upwards.
|
| Parameters
| ----------
| left, bottom, right, top : float
| The four extents of the bounding box.
| minpos : float or None
| If this is supplied, the Bbox will have a minimum positive value
| set. This is useful when dealing with logarithmic scales and other
| scales where negative bounds result in floating point errors.
|
| null()
| Create a new null `Bbox` from (inf, inf) to (-inf, -inf).
|
| unit()
| Create a new unit `Bbox` from (0, 0) to (1, 1).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| bounds
| Return (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).
|
| intervalx
| The pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from left to right.
|
| intervaly
| The pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from bottom to top.
|
| minpos
| The minimum positive value in both directions within the Bbox.
|
| This is useful when dealing with logarithmic scales and other scales
| where negative bounds result in floating point errors, and will be used
| as the minimum extent instead of *p0*.
|
| minposx
| The minimum positive value in the *x*-direction within the Bbox.
|
| This is useful when dealing with logarithmic scales and other scales
| where negative bounds result in floating point errors, and will be used
| as the minimum *x*-extent instead of *x0*.
|
| minposy
| The minimum positive value in the *y*-direction within the Bbox.
|
| This is useful when dealing with logarithmic scales and other scales
| where negative bounds result in floating point errors, and will be used
| as the minimum *y*-extent instead of *y0*.
|
| p0
| The first pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the bottom-left corner (for that, use
| :attr:`min`).
|
| p1
| The second pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the top-right corner (for that, use
| :attr:`max`).
|
| x0
| The first of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`x1` (for that, use
| :attr:`xmin`).
|
| x1
| The second of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`x0` (for that, use
| :attr:`xmax`).
|
| y0
| The first of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`y1` (for that, use
| :attr:`ymin`).
|
| y1
| The second of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`y0` (for that, use
| :attr:`ymax`).
|
| ----------------------------------------------------------------------
| Methods inherited from BboxBase:
|
| __array__(self, *args, **kwargs)
|
| anchored(self, c, container=None)
| Return a copy of the `Bbox` anchored to *c* within *container*.
|
| Parameters
| ----------
| c : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}
| Either an (*x*, *y*) pair of relative coordinates (0 is left or
| bottom, 1 is right or top), 'C' (center), or a cardinal direction
| ('SW', southwest, is bottom left, etc.).
| container : `Bbox`, optional
| The box within which the `Bbox` is positioned.
|
| See Also
| --------
| .Axes.set_anchor
|
| contains(self, x, y)
| Return whether ``(x, y)`` is in the bounding box or on its edge.
|
| containsx(self, x)
| Return whether *x* is in the closed (:attr:`x0`, :attr:`x1`) interval.
|
| containsy(self, y)
| Return whether *y* is in the closed (:attr:`y0`, :attr:`y1`) interval.
|
| corners(self)
| Return the corners of this rectangle as an array of points.
|
| Specifically, this returns the array
| ``[[x0, y0], [x0, y1], [x1, y0], [x1, y1]]``.
|
| count_contains(self, vertices)
| Count the number of vertices contained in the `Bbox`.
| Any vertices with a non-finite x or y value are ignored.
|
| Parameters
| ----------
| vertices : (N, 2) array
|
| count_overlaps(self, bboxes)
| Count the number of bounding boxes that overlap this one.
|
| Parameters
| ----------
| bboxes : sequence of `.BboxBase`
|
| expanded(self, sw, sh)
| Construct a `Bbox` by expanding this one around its center by the
| factors *sw* and *sh*.
|
| fully_contains(self, x, y)
| Return whether ``x, y`` is in the bounding box, but not on its edge.
|
| fully_containsx(self, x)
| Return whether *x* is in the open (:attr:`x0`, :attr:`x1`) interval.
|
| fully_containsy(self, y)
| Return whether *y* is in the open (:attr:`y0`, :attr:`y1`) interval.
|
| fully_overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box,
| not including the edges.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| padded(self, w_pad, h_pad=None)
| Construct a `Bbox` by padding this one on all four sides.
|
| Parameters
| ----------
| w_pad : float
| Width pad
| h_pad : float, optional
| Height pad. Defaults to *w_pad*.
|
| rotated(self, radians)
| Return the axes-aligned bounding box that bounds the result of rotating
| this `Bbox` by an angle of *radians*.
|
| shrunk(self, mx, my)
| Return a copy of the `Bbox`, shrunk by the factor *mx*
| in the *x* direction and the factor *my* in the *y* direction.
| The lower left corner of the box remains unchanged. Normally
| *mx* and *my* will be less than 1, but this is not enforced.
|
| shrunk_to_aspect(self, box_aspect, container=None, fig_aspect=1.0)
| Return a copy of the `Bbox`, shrunk so that it is as
| large as it can be while having the desired aspect ratio,
| *box_aspect*. If the box coordinates are relative (i.e.
| fractions of a larger box such as a figure) then the
| physical aspect ratio of that figure is specified with
| *fig_aspect*, so that *box_aspect* can also be given as a
| ratio of the absolute dimensions, not the relative dimensions.
|
| splitx(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with vertical lines at fractional positions given by *args*.
|
| splity(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with horizontal lines at fractional positions given by *args*.
|
| transformed(self, transform)
| Construct a `Bbox` by statically transforming this one by *transform*.
|
| translated(self, tx, ty)
| Construct a `Bbox` by translating this one by *tx* and *ty*.
|
| ----------------------------------------------------------------------
| Static methods inherited from BboxBase:
|
| intersection(bbox1, bbox2)
| Return the intersection of *bbox1* and *bbox2* if they intersect, or
| None if they don't.
|
| union(bboxes)
| Return a `Bbox` that contains all of the given *bboxes*.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from BboxBase:
|
| extents
| Return (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).
|
| height
| The (signed) height of the bounding box.
|
| max
| The top-right corner of the bounding box.
|
| min
| The bottom-left corner of the bounding box.
|
| size
| The (signed) width and height of the bounding box.
|
| width
| The (signed) width of the bounding box.
|
| xmax
| The right edge of the bounding box.
|
| xmin
| The left edge of the bounding box.
|
| ymax
| The top edge of the bounding box.
|
| ymin
| The bottom edge of the bounding box.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BboxBase:
|
| coefs = {'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0...
|
| is_affine = True
|
| is_bbox = True
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| pass_through = False
class BboxBase(TransformNode)
| BboxBase(shorthand_name=None)
|
| The base class of all bounding boxes.
|
| This class is immutable; `Bbox` is a mutable subclass.
|
| The canonical representation is as two points, with no
| restrictions on their ordering. Convenience properties are
| provided to get the left, bottom, right and top edges and width
| and height, but these are not stored explicitly.
|
| Method resolution order:
| BboxBase
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __array__(self, *args, **kwargs)
|
| anchored(self, c, container=None)
| Return a copy of the `Bbox` anchored to *c* within *container*.
|
| Parameters
| ----------
| c : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}
| Either an (*x*, *y*) pair of relative coordinates (0 is left or
| bottom, 1 is right or top), 'C' (center), or a cardinal direction
| ('SW', southwest, is bottom left, etc.).
| container : `Bbox`, optional
| The box within which the `Bbox` is positioned.
|
| See Also
| --------
| .Axes.set_anchor
|
| contains(self, x, y)
| Return whether ``(x, y)`` is in the bounding box or on its edge.
|
| containsx(self, x)
| Return whether *x* is in the closed (:attr:`x0`, :attr:`x1`) interval.
|
| containsy(self, y)
| Return whether *y* is in the closed (:attr:`y0`, :attr:`y1`) interval.
|
| corners(self)
| Return the corners of this rectangle as an array of points.
|
| Specifically, this returns the array
| ``[[x0, y0], [x0, y1], [x1, y0], [x1, y1]]``.
|
| count_contains(self, vertices)
| Count the number of vertices contained in the `Bbox`.
| Any vertices with a non-finite x or y value are ignored.
|
| Parameters
| ----------
| vertices : (N, 2) array
|
| count_overlaps(self, bboxes)
| Count the number of bounding boxes that overlap this one.
|
| Parameters
| ----------
| bboxes : sequence of `.BboxBase`
|
| expanded(self, sw, sh)
| Construct a `Bbox` by expanding this one around its center by the
| factors *sw* and *sh*.
|
| frozen(self)
| The base class for anything that participates in the transform tree
| and needs to invalidate its parents or be invalidated. This includes
| classes that are not really transforms, such as bounding boxes, since some
| transforms depend on bounding boxes to compute their values.
|
| fully_contains(self, x, y)
| Return whether ``x, y`` is in the bounding box, but not on its edge.
|
| fully_containsx(self, x)
| Return whether *x* is in the open (:attr:`x0`, :attr:`x1`) interval.
|
| fully_containsy(self, y)
| Return whether *y* is in the open (:attr:`y0`, :attr:`y1`) interval.
|
| fully_overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box,
| not including the edges.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| get_points(self)
|
| overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| padded(self, w_pad, h_pad=None)
| Construct a `Bbox` by padding this one on all four sides.
|
| Parameters
| ----------
| w_pad : float
| Width pad
| h_pad : float, optional
| Height pad. Defaults to *w_pad*.
|
| rotated(self, radians)
| Return the axes-aligned bounding box that bounds the result of rotating
| this `Bbox` by an angle of *radians*.
|
| shrunk(self, mx, my)
| Return a copy of the `Bbox`, shrunk by the factor *mx*
| in the *x* direction and the factor *my* in the *y* direction.
| The lower left corner of the box remains unchanged. Normally
| *mx* and *my* will be less than 1, but this is not enforced.
|
| shrunk_to_aspect(self, box_aspect, container=None, fig_aspect=1.0)
| Return a copy of the `Bbox`, shrunk so that it is as
| large as it can be while having the desired aspect ratio,
| *box_aspect*. If the box coordinates are relative (i.e.
| fractions of a larger box such as a figure) then the
| physical aspect ratio of that figure is specified with
| *fig_aspect*, so that *box_aspect* can also be given as a
| ratio of the absolute dimensions, not the relative dimensions.
|
| splitx(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with vertical lines at fractional positions given by *args*.
|
| splity(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with horizontal lines at fractional positions given by *args*.
|
| transformed(self, transform)
| Construct a `Bbox` by statically transforming this one by *transform*.
|
| translated(self, tx, ty)
| Construct a `Bbox` by translating this one by *tx* and *ty*.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| intersection(bbox1, bbox2)
| Return the intersection of *bbox1* and *bbox2* if they intersect, or
| None if they don't.
|
| union(bboxes)
| Return a `Bbox` that contains all of the given *bboxes*.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| bounds
| Return (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).
|
| extents
| Return (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).
|
| height
| The (signed) height of the bounding box.
|
| intervalx
| The pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from left to right.
|
| intervaly
| The pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from bottom to top.
|
| max
| The top-right corner of the bounding box.
|
| min
| The bottom-left corner of the bounding box.
|
| p0
| The first pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the bottom-left corner (for that, use
| :attr:`min`).
|
| p1
| The second pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the top-right corner (for that, use
| :attr:`max`).
|
| size
| The (signed) width and height of the bounding box.
|
| width
| The (signed) width of the bounding box.
|
| x0
| The first of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`x1` (for that, use
| :attr:`xmin`).
|
| x1
| The second of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`x0` (for that, use
| :attr:`xmax`).
|
| xmax
| The right edge of the bounding box.
|
| xmin
| The left edge of the bounding box.
|
| y0
| The first of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`y1` (for that, use
| :attr:`ymin`).
|
| y1
| The second of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`y0` (for that, use
| :attr:`ymax`).
|
| ymax
| The top edge of the bounding box.
|
| ymin
| The bottom edge of the bounding box.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| coefs = {'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0...
|
| is_affine = True
|
| is_bbox = True
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __init__(self, shorthand_name=None)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| pass_through = False
class BboxTransform(Affine2DBase)
| BboxTransform(boxin, boxout, **kwargs)
|
| `BboxTransform` linearly transforms points from one `Bbox` to another.
|
| Method resolution order:
| BboxTransform
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, boxin, boxout, **kwargs)
| Create a new `BboxTransform` that linearly transforms
| points from *boxin* to *boxout*.
|
| __str__ lambda self from _make_str_method.<locals>
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| is_separable = True
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class BboxTransformFrom(Affine2DBase)
| BboxTransformFrom(boxin, **kwargs)
|
| `BboxTransformFrom` linearly transforms points from a given `Bbox` to the
| unit bounding box.
|
| Method resolution order:
| BboxTransformFrom
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, boxin, **kwargs)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __str__ lambda self from _make_str_method.<locals>
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| is_separable = True
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class BboxTransformTo(Affine2DBase)
| BboxTransformTo(boxout, **kwargs)
|
| `BboxTransformTo` is a transformation that linearly transforms points from
| the unit bounding box to a given `Bbox`.
|
| Method resolution order:
| BboxTransformTo
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, boxout, **kwargs)
| Create a new `BboxTransformTo` that linearly transforms
| points from the unit bounding box to *boxout*.
|
| __str__ lambda self from _make_str_method.<locals>
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| is_separable = True
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class BboxTransformToMaxOnly(BboxTransformTo)
| BboxTransformToMaxOnly(boxout, **kwargs)
|
| [*Deprecated*] `BboxTransformToMaxOnly` is a transformation that linearly transforms points from
| the unit bounding box to a given `Bbox` with a fixed upper left of (0, 0).
|
| Notes
| -----
| .. deprecated:: 3.9
|
| Method resolution order:
| BboxTransformToMaxOnly
| BboxTransformTo
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, boxout, **kwargs) from BboxTransformTo
| Create a new `BboxTransformTo` that linearly transforms
| points from the unit bounding box to *boxout*.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Methods inherited from BboxTransformTo:
|
| __str__ lambda self from _make_str_method.<locals>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BboxTransformTo:
|
| is_separable = True
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class BlendedAffine2D(_BlendedMixin, Affine2DBase)
| BlendedAffine2D(x_transform, y_transform, **kwargs)
|
| A "blended" transform uses one transform for the *x*-direction, and
| another transform for the *y*-direction.
|
| This version is an optimization for the case where both child
| transforms are of type `Affine2DBase`.
|
| Method resolution order:
| BlendedAffine2D
| _BlendedMixin
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, x_transform, y_transform, **kwargs)
| Create a new "blended" transform using *x_transform* to transform the
| *x*-axis and *y_transform* to transform the *y*-axis.
|
| Both *x_transform* and *y_transform* must be 2D affine transforms.
|
| You will generally not call this constructor directly but use the
| `blended_transform_factory` function instead, which can determine
| automatically which kind of blended transform to create.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| is_separable = True
|
| ----------------------------------------------------------------------
| Methods inherited from _BlendedMixin:
|
| __eq__(self, other)
| Return self==value.
|
| __str__ lambda self from _make_str_method.<locals>
|
| contains_branch_seperately(self, transform)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _BlendedMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from _BlendedMixin:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class BlendedGenericTransform(_BlendedMixin, Transform)
| BlendedGenericTransform(x_transform, y_transform, **kwargs)
|
| A "blended" transform uses one transform for the *x*-direction, and
| another transform for the *y*-direction.
|
| This "generic" version can handle any given child transform in the
| *x*- and *y*-directions.
|
| Method resolution order:
| BlendedGenericTransform
| _BlendedMixin
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, x_transform, y_transform, **kwargs)
| Create a new "blended" transform using *x_transform* to transform the
| *x*-axis and *y_transform* to transform the *y*-axis.
|
| You will generally not call this constructor directly but use the
| `blended_transform_factory` function instead, which can determine
| automatically which kind of blended transform to create.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| get_affine(self)
| Get the affine part of this transform.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| has_inverse
|
| is_affine
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| input_dims = 2
|
| is_separable = True
|
| output_dims = 2
|
| pass_through = True
|
| ----------------------------------------------------------------------
| Methods inherited from _BlendedMixin:
|
| __eq__(self, other)
| Return self==value.
|
| __str__ lambda self from _make_str_method.<locals>
|
| contains_branch_seperately(self, transform)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _BlendedMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from _BlendedMixin:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
class CompositeAffine2D(Affine2DBase)
| CompositeAffine2D(a, b, **kwargs)
|
| A composite transform formed by applying transform *a* then transform *b*.
|
| This version is an optimization that handles the case where both *a*
| and *b* are 2D affines.
|
| Method resolution order:
| CompositeAffine2D
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, a, b, **kwargs)
| Create a new composite transform that is the result of
| applying `Affine2DBase` *a* then `Affine2DBase` *b*.
|
| You will generally not call this constructor directly but write ``a +
| b`` instead, which will automatically choose the best kind of composite
| transform instance to create.
|
| __str__ lambda self from _make_str_method.<locals>
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Affine2DBase:
|
| is_separable
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class CompositeGenericTransform(Transform)
| CompositeGenericTransform(a, b, **kwargs)
|
| A composite transform formed by applying transform *a* then
| transform *b*.
|
| This "generic" version can handle any two arbitrary
| transformations.
|
| Method resolution order:
| CompositeGenericTransform
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, a, b, **kwargs)
| Create a new composite transform that is the result of
| applying transform *a* then transform *b*.
|
| You will generally not call this constructor directly but write ``a +
| b`` instead, which will automatically choose the best kind of composite
| transform instance to create.
|
| __str__ lambda self from _make_str_method.<locals>
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| get_affine(self)
| Get the affine part of this transform.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| depth
|
| has_inverse
|
| is_affine
|
| is_separable
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| pass_through = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Transform:
|
| input_dims = None
|
| output_dims = None
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
class IdentityTransform(Affine2DBase)
| IdentityTransform(*args, **kwargs)
|
| A special class that does one thing, the identity transform, in a
| fast way.
|
| Method resolution order:
| IdentityTransform
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __str__ lambda self from _make_str_method.<locals>
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Affine2DBase:
|
| is_separable
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, *args, **kwargs)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class LockableBbox(BboxBase)
| LockableBbox(bbox, x0=None, y0=None, x1=None, y1=None, **kwargs)
|
| A `Bbox` where some elements may be locked at certain values.
|
| When the child bounding box changes, the bounds of this bbox will update
| accordingly with the exception of the locked elements.
|
| Method resolution order:
| LockableBbox
| BboxBase
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, bbox, x0=None, y0=None, x1=None, y1=None, **kwargs)
| Parameters
| ----------
| bbox : `Bbox`
| The child bounding box to wrap.
|
| x0 : float or None
| The locked value for x0, or None to leave unlocked.
|
| y0 : float or None
| The locked value for y0, or None to leave unlocked.
|
| x1 : float or None
| The locked value for x1, or None to leave unlocked.
|
| y1 : float or None
| The locked value for y1, or None to leave unlocked.
|
| __str__ lambda self from _make_str_method.<locals>
|
| get_points(self)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| locked_x0
| float or None: The value used for the locked x0.
|
| locked_x1
| float or None: The value used for the locked x1.
|
| locked_y0
| float or None: The value used for the locked y0.
|
| locked_y1
| float or None: The value used for the locked y1.
|
| ----------------------------------------------------------------------
| Methods inherited from BboxBase:
|
| __array__(self, *args, **kwargs)
|
| anchored(self, c, container=None)
| Return a copy of the `Bbox` anchored to *c* within *container*.
|
| Parameters
| ----------
| c : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}
| Either an (*x*, *y*) pair of relative coordinates (0 is left or
| bottom, 1 is right or top), 'C' (center), or a cardinal direction
| ('SW', southwest, is bottom left, etc.).
| container : `Bbox`, optional
| The box within which the `Bbox` is positioned.
|
| See Also
| --------
| .Axes.set_anchor
|
| contains(self, x, y)
| Return whether ``(x, y)`` is in the bounding box or on its edge.
|
| containsx(self, x)
| Return whether *x* is in the closed (:attr:`x0`, :attr:`x1`) interval.
|
| containsy(self, y)
| Return whether *y* is in the closed (:attr:`y0`, :attr:`y1`) interval.
|
| corners(self)
| Return the corners of this rectangle as an array of points.
|
| Specifically, this returns the array
| ``[[x0, y0], [x0, y1], [x1, y0], [x1, y1]]``.
|
| count_contains(self, vertices)
| Count the number of vertices contained in the `Bbox`.
| Any vertices with a non-finite x or y value are ignored.
|
| Parameters
| ----------
| vertices : (N, 2) array
|
| count_overlaps(self, bboxes)
| Count the number of bounding boxes that overlap this one.
|
| Parameters
| ----------
| bboxes : sequence of `.BboxBase`
|
| expanded(self, sw, sh)
| Construct a `Bbox` by expanding this one around its center by the
| factors *sw* and *sh*.
|
| frozen(self)
| The base class for anything that participates in the transform tree
| and needs to invalidate its parents or be invalidated. This includes
| classes that are not really transforms, such as bounding boxes, since some
| transforms depend on bounding boxes to compute their values.
|
| fully_contains(self, x, y)
| Return whether ``x, y`` is in the bounding box, but not on its edge.
|
| fully_containsx(self, x)
| Return whether *x* is in the open (:attr:`x0`, :attr:`x1`) interval.
|
| fully_containsy(self, y)
| Return whether *y* is in the open (:attr:`y0`, :attr:`y1`) interval.
|
| fully_overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box,
| not including the edges.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| padded(self, w_pad, h_pad=None)
| Construct a `Bbox` by padding this one on all four sides.
|
| Parameters
| ----------
| w_pad : float
| Width pad
| h_pad : float, optional
| Height pad. Defaults to *w_pad*.
|
| rotated(self, radians)
| Return the axes-aligned bounding box that bounds the result of rotating
| this `Bbox` by an angle of *radians*.
|
| shrunk(self, mx, my)
| Return a copy of the `Bbox`, shrunk by the factor *mx*
| in the *x* direction and the factor *my* in the *y* direction.
| The lower left corner of the box remains unchanged. Normally
| *mx* and *my* will be less than 1, but this is not enforced.
|
| shrunk_to_aspect(self, box_aspect, container=None, fig_aspect=1.0)
| Return a copy of the `Bbox`, shrunk so that it is as
| large as it can be while having the desired aspect ratio,
| *box_aspect*. If the box coordinates are relative (i.e.
| fractions of a larger box such as a figure) then the
| physical aspect ratio of that figure is specified with
| *fig_aspect*, so that *box_aspect* can also be given as a
| ratio of the absolute dimensions, not the relative dimensions.
|
| splitx(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with vertical lines at fractional positions given by *args*.
|
| splity(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with horizontal lines at fractional positions given by *args*.
|
| transformed(self, transform)
| Construct a `Bbox` by statically transforming this one by *transform*.
|
| translated(self, tx, ty)
| Construct a `Bbox` by translating this one by *tx* and *ty*.
|
| ----------------------------------------------------------------------
| Static methods inherited from BboxBase:
|
| intersection(bbox1, bbox2)
| Return the intersection of *bbox1* and *bbox2* if they intersect, or
| None if they don't.
|
| union(bboxes)
| Return a `Bbox` that contains all of the given *bboxes*.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from BboxBase:
|
| bounds
| Return (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).
|
| extents
| Return (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).
|
| height
| The (signed) height of the bounding box.
|
| intervalx
| The pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from left to right.
|
| intervaly
| The pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from bottom to top.
|
| max
| The top-right corner of the bounding box.
|
| min
| The bottom-left corner of the bounding box.
|
| p0
| The first pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the bottom-left corner (for that, use
| :attr:`min`).
|
| p1
| The second pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the top-right corner (for that, use
| :attr:`max`).
|
| size
| The (signed) width and height of the bounding box.
|
| width
| The (signed) width of the bounding box.
|
| x0
| The first of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`x1` (for that, use
| :attr:`xmin`).
|
| x1
| The second of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`x0` (for that, use
| :attr:`xmax`).
|
| xmax
| The right edge of the bounding box.
|
| xmin
| The left edge of the bounding box.
|
| y0
| The first of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`y1` (for that, use
| :attr:`ymin`).
|
| y1
| The second of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`y0` (for that, use
| :attr:`ymax`).
|
| ymax
| The top edge of the bounding box.
|
| ymin
| The bottom edge of the bounding box.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BboxBase:
|
| coefs = {'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0...
|
| is_affine = True
|
| is_bbox = True
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| pass_through = False
class ScaledTranslation(Affine2DBase)
| ScaledTranslation(xt, yt, scale_trans, **kwargs)
|
| A transformation that translates by *xt* and *yt*, after *xt* and *yt*
| have been transformed by *scale_trans*.
|
| Method resolution order:
| ScaledTranslation
| Affine2DBase
| AffineBase
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, xt, yt, scale_trans, **kwargs)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __str__ lambda self from _make_str_method.<locals>
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| ----------------------------------------------------------------------
| Methods inherited from Affine2DBase:
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| to_values(self)
| Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Affine2DBase:
|
| is_separable
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Affine2DBase:
|
| has_inverse = True
|
| input_dims = 2
|
| output_dims = 2
|
| ----------------------------------------------------------------------
| Methods inherited from AffineBase:
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __eq__(self, other)
| Return self==value.
|
| get_affine(self)
| Get the affine part of this transform.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from AffineBase:
|
| __hash__ = None
|
| is_affine = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
|
| pass_through = False
class Transform(TransformNode)
| Transform(shorthand_name=None)
|
| The base class of all `TransformNode` instances that
| actually perform a transformation.
|
| All non-affine transformations should be subclasses of this class.
| New affine transformations should be subclasses of `Affine2D`.
|
| Subclasses of this class should override the following members (at
| minimum):
|
| - :attr:`input_dims`
| - :attr:`output_dims`
| - :meth:`transform`
| - :meth:`inverted` (if an inverse exists)
|
| The following attributes may be overridden if the default is unsuitable:
|
| - :attr:`is_separable` (defaults to True for 1D -> 1D transforms, False
| otherwise)
| - :attr:`has_inverse` (defaults to True if :meth:`inverted` is overridden,
| False otherwise)
|
| If the transform needs to do something non-standard with
| `matplotlib.path.Path` objects, such as adding curves
| where there were once line segments, it should override:
|
| - :meth:`transform_path`
|
| Method resolution order:
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| has_inverse = False
|
| input_dims = None
|
| is_separable = False
|
| output_dims = None
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __init__(self, shorthand_name=None)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class TransformNode(builtins.object)
| TransformNode(shorthand_name=None)
|
| The base class for anything that participates in the transform tree
| and needs to invalidate its parents or be invalidated. This includes
| classes that are not really transforms, such as bounding boxes, since some
| transforms depend on bounding boxes to compute their values.
|
| Methods defined here:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __init__(self, shorthand_name=None)
| Parameters
| ----------
| shorthand_name : str
| A string representing the "name" of the transform. The name carries
| no significance other than to improve the readability of
| ``str(transform)`` when DEBUG=True.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class TransformWrapper(Transform)
| TransformWrapper(child)
|
| A helper class that holds a single child transform and acts
| equivalently to it.
|
| This is useful if a node of the transform tree must be replaced at
| run time with a transform of a different type. This class allows
| that replacement to correctly trigger invalidation.
|
| `TransformWrapper` instances must have the same input and output dimensions
| during their entire lifetime, so the child transform may only be replaced
| with another child transform of the same dimensions.
|
| Method resolution order:
| TransformWrapper
| Transform
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, child)
| *child*: A `Transform` instance. This child may later
| be replaced with :meth:`set`.
|
| __str__ lambda self from _make_str_method.<locals>
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| set(self, child)
| Replace the current child of this transform with another one.
|
| The new child must have the same number of input and output
| dimensions as the current child.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| has_inverse
|
| input_dims
|
| is_affine
|
| is_separable
|
| output_dims
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| pass_through = True
|
| ----------------------------------------------------------------------
| Methods inherited from Transform:
|
| __add__(self, other)
| Compose two transforms together so that *self* is followed by *other*.
|
| ``A + B`` returns a transform ``C`` so that
| ``C.transform(x) == B.transform(A.transform(x))``.
|
| __array__(self, *args, **kwargs)
| Array interface to get at this Transform's affine matrix.
|
| __sub__(self, other)
| Compose *self* with the inverse of *other*, cancelling identical terms
| if any::
|
| # In general:
| A - B == A + B.inverted()
| # (but see note regarding frozen transforms below).
|
| # If A "ends with" B (i.e. A == A' + B for some A') we can cancel
| # out B:
| (A' + B) - B == A'
|
| # Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
| A - (A + B') == B'.inverted() == B'^-1
|
| Cancellation (rather than naively returning ``A + B.inverted()``) is
| important for multiple reasons:
|
| - It avoids floating-point inaccuracies when computing the inverse of
| B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
| identity transform), whereas ``B + B.inverted()`` may differ by a
| small epsilon.
| - ``B.inverted()`` always returns a frozen transform: if one computes
| ``A + B + B.inverted()`` and later mutates ``B``, then
| ``B.inverted()`` won't be updated and the last two terms won't cancel
| out anymore; on the other hand, ``A + B - B`` will always be equal to
| ``A`` even if ``B`` is mutated.
|
| contains_branch(self, other)
| Return whether the given transform is a sub-tree of this transform.
|
| This routine uses transform equality to identify sub-trees, therefore
| in many situations it is object id which will be used.
|
| For the case where the given transform represents the whole
| of this transform, returns True.
|
| contains_branch_seperately(self, other_transform)
| Return whether the given branch is a sub-tree of this transform on
| each separate dimension.
|
| A common use for this method is to identify if a transform is a blended
| transform containing an Axes' data transform. e.g.::
|
| x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
|
| get_affine(self)
| Get the affine part of this transform.
|
| get_matrix(self)
| Get the matrix for the affine part of this transform.
|
| inverted(self)
| Return the corresponding inverse transformation.
|
| It holds ``x == self.inverted().transform(self.transform(x))``.
|
| The return value of this method should be treated as
| temporary. An update to *self* does not cause a corresponding
| update to its inverted copy.
|
| transform(self, values)
| Apply this transformation on the given array of *values*.
|
| Parameters
| ----------
| values : array-like
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_affine(self, values)
| Apply only the affine part of this transformation on the
| given array of values.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally a no-op. In
| affine transformations, this is equivalent to
| ``transform(values)``.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_angles(self, angles, pts, radians=False, pushoff=1e-05)
| Transform a set of angles anchored at specific locations.
|
| Parameters
| ----------
| angles : (N,) array-like
| The angles to transform.
| pts : (N, 2) array-like
| The points where the angles are anchored.
| radians : bool, default: False
| Whether *angles* are radians or degrees.
| pushoff : float
| For each point in *pts* and angle in *angles*, the transformed
| angle is computed by transforming a segment of length *pushoff*
| starting at that point and making that angle relative to the
| horizontal axis, and measuring the angle between the horizontal
| axis and the transformed segment.
|
| Returns
| -------
| (N,) array
|
| transform_bbox(self, bbox)
| Transform the given bounding box.
|
| For smarter transforms including caching (a common requirement in
| Matplotlib), see `TransformedBbox`.
|
| transform_non_affine(self, values)
| Apply only the non-affine part of this transformation.
|
| ``transform(values)`` is always equivalent to
| ``transform_affine(transform_non_affine(values))``.
|
| In non-affine transformations, this is generally equivalent to
| ``transform(values)``. In affine transformations, this is
| always a no-op.
|
| Parameters
| ----------
| values : array
| The input values as an array of length :attr:`input_dims` or
| shape (N, :attr:`input_dims`).
|
| Returns
| -------
| array
| The output values as an array of length :attr:`output_dims` or
| shape (N, :attr:`output_dims`), depending on the input.
|
| transform_path(self, path)
| Apply the transform to `.Path` *path*, returning a new `.Path`.
|
| In some cases, this transform may insert curves into the path
| that began as line segments.
|
| transform_path_affine(self, path)
| Apply the affine part of this transform to `.Path` *path*, returning a
| new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_path_non_affine(self, path)
| Apply the non-affine part of this transform to `.Path` *path*,
| returning a new `.Path`.
|
| ``transform_path(path)`` is equivalent to
| ``transform_path_affine(transform_path_non_affine(values))``.
|
| transform_point(self, point)
| Return a transformed point.
|
| This function is only kept for backcompatibility; the more general
| `.transform` method is capable of transforming both a list of points
| and a single point.
|
| The point is given as a sequence of length :attr:`input_dims`.
| The transformed point is returned as a sequence of length
| :attr:`output_dims`.
|
| ----------------------------------------------------------------------
| Class methods inherited from Transform:
|
| __init_subclass__()
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Transform:
|
| depth
| Return the number of transforms which have been chained
| together to form this Transform instance.
|
| .. note::
|
| For the special case of a Composite transform, the maximum depth
| of the two is returned.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_bbox = False
class TransformedBbox(BboxBase)
| TransformedBbox(bbox, transform, **kwargs)
|
| A `Bbox` that is automatically transformed by a given
| transform. When either the child bounding box or transform
| changes, the bounds of this bbox will update accordingly.
|
| Method resolution order:
| TransformedBbox
| BboxBase
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, bbox, transform, **kwargs)
| Parameters
| ----------
| bbox : `Bbox`
| transform : `Transform`
|
| __str__ lambda self from _make_str_method.<locals>
|
| contains(self, x, y)
| Return whether ``(x, y)`` is in the bounding box or on its edge.
|
| fully_contains(self, x, y)
| Return whether ``x, y`` is in the bounding box, but not on its edge.
|
| get_points(self)
|
| ----------------------------------------------------------------------
| Methods inherited from BboxBase:
|
| __array__(self, *args, **kwargs)
|
| anchored(self, c, container=None)
| Return a copy of the `Bbox` anchored to *c* within *container*.
|
| Parameters
| ----------
| c : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}
| Either an (*x*, *y*) pair of relative coordinates (0 is left or
| bottom, 1 is right or top), 'C' (center), or a cardinal direction
| ('SW', southwest, is bottom left, etc.).
| container : `Bbox`, optional
| The box within which the `Bbox` is positioned.
|
| See Also
| --------
| .Axes.set_anchor
|
| containsx(self, x)
| Return whether *x* is in the closed (:attr:`x0`, :attr:`x1`) interval.
|
| containsy(self, y)
| Return whether *y* is in the closed (:attr:`y0`, :attr:`y1`) interval.
|
| corners(self)
| Return the corners of this rectangle as an array of points.
|
| Specifically, this returns the array
| ``[[x0, y0], [x0, y1], [x1, y0], [x1, y1]]``.
|
| count_contains(self, vertices)
| Count the number of vertices contained in the `Bbox`.
| Any vertices with a non-finite x or y value are ignored.
|
| Parameters
| ----------
| vertices : (N, 2) array
|
| count_overlaps(self, bboxes)
| Count the number of bounding boxes that overlap this one.
|
| Parameters
| ----------
| bboxes : sequence of `.BboxBase`
|
| expanded(self, sw, sh)
| Construct a `Bbox` by expanding this one around its center by the
| factors *sw* and *sh*.
|
| frozen(self)
| The base class for anything that participates in the transform tree
| and needs to invalidate its parents or be invalidated. This includes
| classes that are not really transforms, such as bounding boxes, since some
| transforms depend on bounding boxes to compute their values.
|
| fully_containsx(self, x)
| Return whether *x* is in the open (:attr:`x0`, :attr:`x1`) interval.
|
| fully_containsy(self, y)
| Return whether *y* is in the open (:attr:`y0`, :attr:`y1`) interval.
|
| fully_overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box,
| not including the edges.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| overlaps(self, other)
| Return whether this bounding box overlaps with the other bounding box.
|
| Parameters
| ----------
| other : `.BboxBase`
|
| padded(self, w_pad, h_pad=None)
| Construct a `Bbox` by padding this one on all four sides.
|
| Parameters
| ----------
| w_pad : float
| Width pad
| h_pad : float, optional
| Height pad. Defaults to *w_pad*.
|
| rotated(self, radians)
| Return the axes-aligned bounding box that bounds the result of rotating
| this `Bbox` by an angle of *radians*.
|
| shrunk(self, mx, my)
| Return a copy of the `Bbox`, shrunk by the factor *mx*
| in the *x* direction and the factor *my* in the *y* direction.
| The lower left corner of the box remains unchanged. Normally
| *mx* and *my* will be less than 1, but this is not enforced.
|
| shrunk_to_aspect(self, box_aspect, container=None, fig_aspect=1.0)
| Return a copy of the `Bbox`, shrunk so that it is as
| large as it can be while having the desired aspect ratio,
| *box_aspect*. If the box coordinates are relative (i.e.
| fractions of a larger box such as a figure) then the
| physical aspect ratio of that figure is specified with
| *fig_aspect*, so that *box_aspect* can also be given as a
| ratio of the absolute dimensions, not the relative dimensions.
|
| splitx(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with vertical lines at fractional positions given by *args*.
|
| splity(self, *args)
| Return a list of new `Bbox` objects formed by splitting the original
| one with horizontal lines at fractional positions given by *args*.
|
| transformed(self, transform)
| Construct a `Bbox` by statically transforming this one by *transform*.
|
| translated(self, tx, ty)
| Construct a `Bbox` by translating this one by *tx* and *ty*.
|
| ----------------------------------------------------------------------
| Static methods inherited from BboxBase:
|
| intersection(bbox1, bbox2)
| Return the intersection of *bbox1* and *bbox2* if they intersect, or
| None if they don't.
|
| union(bboxes)
| Return a `Bbox` that contains all of the given *bboxes*.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from BboxBase:
|
| bounds
| Return (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).
|
| extents
| Return (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).
|
| height
| The (signed) height of the bounding box.
|
| intervalx
| The pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from left to right.
|
| intervaly
| The pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be sorted from bottom to top.
|
| max
| The top-right corner of the bounding box.
|
| min
| The bottom-left corner of the bounding box.
|
| p0
| The first pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the bottom-left corner (for that, use
| :attr:`min`).
|
| p1
| The second pair of (*x*, *y*) coordinates that define the bounding box.
|
| This is not guaranteed to be the top-right corner (for that, use
| :attr:`max`).
|
| size
| The (signed) width and height of the bounding box.
|
| width
| The (signed) width of the bounding box.
|
| x0
| The first of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`x1` (for that, use
| :attr:`xmin`).
|
| x1
| The second of the pair of *x* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`x0` (for that, use
| :attr:`xmax`).
|
| xmax
| The right edge of the bounding box.
|
| xmin
| The left edge of the bounding box.
|
| y0
| The first of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be less than :attr:`y1` (for that, use
| :attr:`ymin`).
|
| y1
| The second of the pair of *y* coordinates that define the bounding box.
|
| This is not guaranteed to be greater than :attr:`y0` (for that, use
| :attr:`ymax`).
|
| ymax
| The top edge of the bounding box.
|
| ymin
| The bottom edge of the bounding box.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from BboxBase:
|
| coefs = {'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0...
|
| is_affine = True
|
| is_bbox = True
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| pass_through = False
class TransformedPatchPath(TransformedPath)
| TransformedPatchPath(patch)
|
| A `TransformedPatchPath` caches a non-affine transformed copy of the
| `~.patches.Patch`. This cached copy is automatically updated when the
| non-affine part of the transform or the patch changes.
|
| Method resolution order:
| TransformedPatchPath
| TransformedPath
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, patch)
| Parameters
| ----------
| patch : `~.patches.Patch`
|
| ----------------------------------------------------------------------
| Methods inherited from TransformedPath:
|
| get_affine(self)
|
| get_fully_transformed_path(self)
| Return a fully-transformed copy of the child path.
|
| get_transformed_path_and_affine(self)
| Return a copy of the child path, with the non-affine part of
| the transform already applied, along with the affine part of
| the path necessary to complete the transformation.
|
| get_transformed_points_and_affine(self)
| Return a copy of the child path, with the non-affine part of
| the transform already applied, along with the affine part of
| the path necessary to complete the transformation. Unlike
| :meth:`get_transformed_path_and_affine`, no interpolation will
| be performed.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
class TransformedPath(TransformNode)
| TransformedPath(path, transform)
|
| A `TransformedPath` caches a non-affine transformed copy of the
| `~.path.Path`. This cached copy is automatically updated when the
| non-affine part of the transform changes.
|
| .. note::
|
| Paths are considered immutable by this class. Any update to the
| path's vertices/codes will not trigger a transform recomputation.
|
| Method resolution order:
| TransformedPath
| TransformNode
| builtins.object
|
| Methods defined here:
|
| __init__(self, path, transform)
| Parameters
| ----------
| path : `~.path.Path`
| transform : `Transform`
|
| get_affine(self)
|
| get_fully_transformed_path(self)
| Return a fully-transformed copy of the child path.
|
| get_transformed_path_and_affine(self)
| Return a copy of the child path, with the non-affine part of
| the transform already applied, along with the affine part of
| the path necessary to complete the transformation.
|
| get_transformed_points_and_affine(self)
| Return a copy of the child path, with the non-affine part of
| the transform already applied, along with the affine part of
| the path necessary to complete the transformation. Unlike
| :meth:`get_transformed_path_and_affine`, no interpolation will
| be performed.
|
| ----------------------------------------------------------------------
| Methods inherited from TransformNode:
|
| __copy__(self)
|
| __getstate__(self)
| Helper for pickle.
|
| __setstate__(self, data_dict)
|
| frozen(self)
| Return a frozen copy of this transform node. The frozen copy will not
| be updated when its children change. Useful for storing a previously
| known state of a transform where ``copy.deepcopy()`` might normally be
| used.
|
| invalidate(self)
| Invalidate this `TransformNode` and triggers an invalidation of its
| ancestors. Should be called any time the transform changes.
|
| set_children(self, *children)
| Set the children of the transform, to let the invalidation
| system know which transforms can invalidate this transform.
| Should be called from the constructor of any transforms that
| depend on other transforms.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransformNode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from TransformNode:
|
| INVALID = 3
|
| INVALID_AFFINE = 2
|
| INVALID_NON_AFFINE = 1
|
| is_affine = False
|
| is_bbox = False
|
| pass_through = False
FUNCTIONS
affine_transform(...) method of builtins.PyCapsule instance
affine_transform(points: numpy.ndarray[numpy.float64], trans: trans_affine) -> object
blended_transform_factory(x_transform, y_transform)
Create a new "blended" transform using *x_transform* to transform
the *x*-axis and *y_transform* to transform the *y*-axis.
A faster version of the blended transform is returned for the case
where both child transforms are affine.
composite_transform_factory(a, b)
Create a new composite transform that is the result of applying
transform a then transform b.
Shortcut versions of the blended transform are provided for the
case where both child transforms are affine, or one or the other
is the identity transform.
Composite transforms may also be created using the '+' operator,
e.g.::
c = a + b
count_bboxes_overlapping_bbox(...) method of builtins.PyCapsule instance
count_bboxes_overlapping_bbox(bbox: rect_d, bboxes: object) -> int
interval_contains(interval, val)
Check, inclusively, whether an interval includes a given value.
Parameters
----------
interval : (float, float)
The endpoints of the interval.
val : float
Value to check is within interval.
Returns
-------
bool
Whether *val* is within the *interval*.
interval_contains_open(interval, val)
Check, excluding endpoints, whether an interval includes a given value.
Parameters
----------
interval : (float, float)
The endpoints of the interval.
val : float
Value to check is within interval.
Returns
-------
bool
Whether *val* is within the *interval*.
nonsingular(vmin, vmax, expander=0.001, tiny=1e-15, increasing=True)
Modify the endpoints of a range as needed to avoid singularities.
Parameters
----------
vmin, vmax : float
The initial endpoints.
expander : float, default: 0.001
Fractional amount by which *vmin* and *vmax* are expanded if
the original interval is too small, based on *tiny*.
tiny : float, default: 1e-15
Threshold for the ratio of the interval to the maximum absolute
value of its endpoints. If the interval is smaller than
this, it will be expanded. This value should be around
1e-15 or larger; otherwise the interval will be approaching
the double precision resolution limit.
increasing : bool, default: True
If True, swap *vmin*, *vmax* if *vmin* > *vmax*.
Returns
-------
vmin, vmax : float
Endpoints, expanded and/or swapped if necessary.
If either input is inf or NaN, or if both inputs are 0 or very
close to zero, it returns -*expander*, *expander*.
offset_copy(trans, fig=None, x=0.0, y=0.0, units='inches')
Return a new transform with an added offset.
Parameters
----------
trans : `Transform` subclass
Any transform, to which offset will be applied.
fig : `~matplotlib.figure.Figure`, default: None
Current figure. It can be None if *units* are 'dots'.
x, y : float, default: 0.0
The offset to apply.
units : {'inches', 'points', 'dots'}, default: 'inches'
Units of the offset.
Returns
-------
`Transform` subclass
Transform with applied offset.
update_path_extents(...) method of builtins.PyCapsule instance
update_path_extents(path: PathIterator, trans: trans_affine, rect: rect_d, minpos: numpy.ndarray[numpy.float64], ignore: bool) -> tuple
DATA
DEBUG = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\matplotlib\transforms.py
matplotlib.use
Python Library Documentation: function use in module matplotlib
use(backend, *, force=True)
Select the backend used for rendering and GUI integration.
If pyplot is already imported, `~matplotlib.pyplot.switch_backend` is used
and if the new backend is different than the current backend, all Figures
will be closed.
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, GTK4Agg, GTK4Cairo, MacOSX, nbAgg, notebook, QtAgg,
QtCairo, TkAgg, TkCairo, WebAgg, WX, WXAgg, WXCairo, Qt5Agg, Qt5Cairo
- non-interactive backends:
agg, cairo, pdf, pgf, ps, svg, template
or a string of the form: ``module://my.module.name``.
notebook is a synonym for nbAgg.
Switching to an interactive backend is not possible if an unrelated
event loop has already been started (e.g., switching to GTK3Agg if a
TkAgg window has already been opened). Switching to a non-interactive
backend is always possible.
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, silently
ignore the failure.
See Also
--------
:ref:`backends`
matplotlib.get_backend
matplotlib.pyplot.switch_backend
matplotlib.validate_backend
Python Library Documentation: function validate_backend in module matplotlib.rcsetup validate_backend(s)