""" .. redirect-from:: /tutorials/intermediate/artists .. _artists_tutorial: =============== Artist tutorial =============== Using Artist objects to render on the canvas. There are three layers to the Matplotlib API. * the :class:`!matplotlib.backend_bases.FigureCanvas` is the area onto which the figure is drawn * the :class:`!matplotlib.backend_bases.Renderer` is the object which knows how to draw on the :class:`!matplotlib.backend_bases.FigureCanvas` * and the :class:`matplotlib.artist.Artist` is the object that knows how to use a renderer to paint onto the canvas. The :class:`!matplotlib.backend_bases.FigureCanvas` and :class:`!matplotlib.backend_bases.Renderer` handle all the details of talking to user interface toolkits like `wxPython `_ or drawing languages like PostScript®, and the ``Artist`` handles all the high level constructs like representing and laying out the figure, text, and lines. The typical user will spend 95% of their time working with the ``Artists``. There are two types of ``Artists``: primitives and containers. The primitives represent the standard graphical objects we want to paint onto our canvas: :class:`~matplotlib.lines.Line2D`, :class:`~matplotlib.patches.Rectangle`, :class:`~matplotlib.text.Text`, :class:`~matplotlib.image.AxesImage`, etc., and the containers are places to put them (:class:`~matplotlib.axis.Axis`, :class:`~matplotlib.axes.Axes` and :class:`~matplotlib.figure.Figure`). The standard use is to create a :class:`~matplotlib.figure.Figure` instance, use the ``Figure`` to create one or more :class:`~matplotlib.axes.Axes` instances, and use the ``Axes`` instance helper methods to create the primitives. In the example below, we create a ``Figure`` instance using :func:`matplotlib.pyplot.figure`, which is a convenience method for instantiating ``Figure`` instances and connecting them with your user interface or drawing toolkit ``FigureCanvas``. As we will discuss below, this is not necessary -- you can work directly with PostScript, PDF Gtk+, or wxPython ``FigureCanvas`` instances, instantiate your ``Figures`` directly and connect them yourselves -- but since we are focusing here on the ``Artist`` API we'll let :mod:`~matplotlib.pyplot` handle some of those details for us:: import matplotlib.pyplot as plt fig = plt.figure() ax = fig.add_subplot(2, 1, 1) # two rows, one column, first plot The :class:`~matplotlib.axes.Axes` is probably the most important class in the Matplotlib API, and the one you will be working with most of the time. This is because the ``Axes`` is the plotting area into which most of the objects go, and the ``Axes`` has many special helper methods (:meth:`~matplotlib.axes.Axes.plot`, :meth:`~matplotlib.axes.Axes.text`, :meth:`~matplotlib.axes.Axes.hist`, :meth:`~matplotlib.axes.Axes.imshow`) to create the most common graphics primitives (:class:`~matplotlib.lines.Line2D`, :class:`~matplotlib.text.Text`, :class:`~matplotlib.patches.Rectangle`, :class:`~matplotlib.image.AxesImage`, respectively). These helper methods will take your data (e.g., ``numpy`` arrays and strings) and create primitive ``Artist`` instances as needed (e.g., ``Line2D``), add them to the relevant containers, and draw them when requested. If you want to create an ``Axes`` at an arbitrary location, simply use the :meth:`~matplotlib.figure.Figure.add_axes` method which takes a list of ``[left, bottom, width, height]`` values in 0-1 relative figure coordinates:: fig2 = plt.figure() ax2 = fig2.add_axes([0.15, 0.1, 0.7, 0.3]) Continuing with our example:: import numpy as np t = np.arange(0.0, 1.0, 0.01) s = np.sin(2*np.pi*t) line, = ax.plot(t, s, color='blue', lw=2) In this example, ``ax`` is the ``Axes`` instance created by the ``fig.add_subplot`` call above and when you call ``ax.plot``, it creates a ``Line2D`` instance and adds it to the ``Axes``. In the interactive `IPython `_ session below, you can see that the ``Axes.lines`` list is length one and contains the same line that was returned by the ``line, = ax.plot...`` call: .. sourcecode:: ipython In [101]: ax.lines[0] Out[101]: In [102]: line Out[102]: If you make subsequent calls to ``ax.plot`` (and the hold state is "on" which is the default) then additional lines will be added to the list. You can remove a line later by calling its ``remove`` method:: line = ax.lines[0] line.remove() The Axes also has helper methods to configure and decorate the x-axis and y-axis tick, tick labels and axis labels:: xtext = ax.set_xlabel('my xdata') # returns a Text instance ytext = ax.set_ylabel('my ydata') When you call :meth:`ax.set_xlabel `, it passes the information on the :class:`~matplotlib.text.Text` instance of the :class:`~matplotlib.axis.XAxis`. Each ``Axes`` instance contains an :class:`~matplotlib.axis.XAxis` and a :class:`~matplotlib.axis.YAxis` instance, which handle the layout and drawing of the ticks, tick labels and axis labels. Try creating the figure below. """ # sphinx_gallery_capture_repr = ('__repr__',) import matplotlib.pyplot as plt import numpy as np fig = plt.figure() fig.subplots_adjust(top=0.8) ax1 = fig.add_subplot(211) ax1.set_ylabel('Voltage [V]') ax1.set_title('A sine wave') t = np.arange(0.0, 1.0, 0.01) s = np.sin(2*np.pi*t) line, = ax1.plot(t, s, color='blue', lw=2) # Fixing random state for reproducibility np.random.seed(19680801) ax2 = fig.add_axes([0.15, 0.1, 0.7, 0.3]) n, bins, patches = ax2.hist(np.random.randn(1000), 50, facecolor='yellow', edgecolor='yellow') ax2.set_xlabel('Time [s]') plt.show() # %% # .. _customizing-artists: # # Customizing your objects # ======================== # # Every element in the figure is represented by a Matplotlib # :class:`~matplotlib.artist.Artist`, and each has an extensive list of # properties to configure its appearance. The figure itself contains a # :class:`~matplotlib.patches.Rectangle` exactly the size of the figure, # which you can use to set the background color and transparency of the # figures. Likewise, each :class:`~matplotlib.axes.Axes` bounding box # (the standard white box with black edges in the typical Matplotlib # plot, has a ``Rectangle`` instance that determines the color, # transparency, and other properties of the Axes. These instances are # stored as member variables :attr:`!Figure.patch` and :attr:`!Axes.patch` # ("Patch" is a name inherited from MATLAB, and is a 2D "patch" # of color on the figure, e.g., rectangles, circles and polygons). # Every Matplotlib ``Artist`` has the following properties # # ========== ================================================================= # Property Description # ========== ================================================================= # alpha The transparency - a scalar from 0-1 # animated A boolean that is used to facilitate animated drawing # axes The Axes that the Artist lives in, possibly None # clip_box The bounding box that clips the Artist # clip_on Whether clipping is enabled # clip_path The path the artist is clipped to # contains A picking function to test whether the artist contains the pick # point # figure The figure instance the artist lives in, possibly None # label A text label (e.g., for auto-labeling) # picker A python object that controls object picking # transform The transformation # visible A boolean whether the artist should be drawn # zorder A number which determines the drawing order # rasterized Boolean; Turns vectors into raster graphics (for compression & # EPS transparency) # ========== ================================================================= # # Each of the properties is accessed with an old-fashioned setter or # getter (yes we know this irritates Pythonistas and we plan to support # direct access via properties or traits but it hasn't been done yet). # For example, to multiply the current alpha by a half:: # # a = o.get_alpha() # o.set_alpha(0.5*a) # # If you want to set a number of properties at once, you can also use # the ``set`` method with keyword arguments. For example:: # # o.set(alpha=0.5, zorder=2) # # If you are working interactively at the python shell, a handy way to # inspect the ``Artist`` properties is to use the # :func:`matplotlib.artist.getp` function (simply # :func:`~matplotlib.pyplot.getp` in pyplot), which lists the properties # and their values. This works for classes derived from ``Artist`` as # well, e.g., ``Figure`` and ``Rectangle``. Here are the ``Figure`` rectangle # properties mentioned above: # # .. sourcecode:: ipython # # In [149]: matplotlib.artist.getp(fig.patch) # agg_filter = None # alpha = None # animated = False # antialiased or aa = False # bbox = Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0) # capstyle = butt # children = [] # clip_box = None # clip_on = True # clip_path = None # contains = None # data_transform = BboxTransformTo( TransformedBbox( Bbox... # edgecolor or ec = (1.0, 1.0, 1.0, 1.0) # extents = Bbox(x0=0.0, y0=0.0, x1=640.0, y1=480.0) # facecolor or fc = (1.0, 1.0, 1.0, 1.0) # figure = Figure(640x480) # fill = True # gid = None # hatch = None # height = 1 # in_layout = False # joinstyle = miter # label = # linestyle or ls = solid # linewidth or lw = 0.0 # patch_transform = CompositeGenericTransform( BboxTransformTo( ... # path = Path(array([[0., 0.], [1., 0.], [1.,... # path_effects = [] # picker = None # rasterized = None # sketch_params = None # snap = None # transform = CompositeGenericTransform( CompositeGenericTra... # transformed_clip_path_and_affine = (None, None) # url = None # verts = [[ 0. 0.] [640. 0.] [640. 480.] [ 0. 480.... # visible = True # width = 1 # window_extent = Bbox(x0=0.0, y0=0.0, x1=640.0, y1=480.0) # x = 0 # xy = (0, 0) # y = 0 # zorder = 1 # # The docstrings for all of the classes also contain the ``Artist`` # properties, so you can consult the interactive "help" or the # :ref:`artist-api` for a listing of properties for a given object. # # .. _object-containers: # # Object containers # ================= # # # Now that we know how to inspect and set the properties of a given # object we want to configure, we need to know how to get at that object. # As mentioned in the introduction, there are two kinds of objects: # primitives and containers. The primitives are usually the things you # want to configure (the font of a :class:`~matplotlib.text.Text` # instance, the width of a :class:`~matplotlib.lines.Line2D`) although # the containers also have some properties as well -- for example the # :class:`~matplotlib.axes.Axes` :class:`~matplotlib.artist.Artist` is a # container that contains many of the primitives in your plot, but it # also has properties like the ``xscale`` to control whether the xaxis # is 'linear' or 'log'. In this section we'll review where the various # container objects store the ``Artists`` that you want to get at. # # .. _figure-container: # # Figure container # ---------------- # # The top level container ``Artist`` is the # :class:`matplotlib.figure.Figure`, and it contains everything in the # figure. The background of the figure is a # :class:`~matplotlib.patches.Rectangle` which is stored in # :attr:`!Figure.patch`. As # you add subplots (:meth:`~matplotlib.figure.Figure.add_subplot`) and # Axes (:meth:`~matplotlib.figure.Figure.add_axes`) to the figure # these will be appended to the :attr:`Figure.axes # `. These are also returned by the # methods that create them: # # .. sourcecode:: ipython # # In [156]: fig = plt.figure() # # In [157]: ax1 = fig.add_subplot(211) # # In [158]: ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.3]) # # In [159]: ax1 # Out[159]: # # In [160]: print(fig.axes) # [, ] # # Because the figure maintains the concept of the "current Axes" (see # :meth:`Figure.gca ` and # :meth:`Figure.sca `) to support the # pylab/pyplot state machine, you should not insert or remove Axes # directly from the Axes list, but rather use the # :meth:`~matplotlib.figure.Figure.add_subplot` and # :meth:`~matplotlib.figure.Figure.add_axes` methods to insert, and the # `Axes.remove ` method to delete. You are # free however, to iterate over the list of Axes or index into it to get # access to ``Axes`` instances you want to customize. Here is an # example which turns all the Axes grids on:: # # for ax in fig.axes: # ax.grid(True) # # # The figure also has its own ``images``, ``lines``, ``patches`` and ``text`` # attributes, which you can use to add primitives directly. When doing so, the # default coordinate system for the ``Figure`` will simply be in pixels (which # is not usually what you want). If you instead use Figure-level methods to add # Artists (e.g., using `.Figure.text` to add text), then the default coordinate # system will be "figure coordinates" where (0, 0) is the bottom-left of the # figure and (1, 1) is the top-right of the figure. # # As with all ``Artist``\s, you can control this coordinate system by setting # the transform property. You can explicitly use "figure coordinates" by # setting the ``Artist`` transform to :attr:`!fig.transFigure`: import matplotlib.lines as lines fig = plt.figure() l1 = lines.Line2D([0, 1], [0, 1], transform=fig.transFigure, figure=fig) l2 = lines.Line2D([0, 1], [1, 0], transform=fig.transFigure, figure=fig) fig.lines.extend([l1, l2]) plt.show() # %% # Here is a summary of the Artists the Figure contains # # ================ ============================================================ # Figure attribute Description # ================ ============================================================ # axes A list of `~.axes.Axes` instances # patch The `.Rectangle` background # images A list of `.FigureImage` patches - # useful for raw pixel display # legends A list of Figure `.Legend` instances # (different from ``Axes.get_legend()``) # lines A list of Figure `.Line2D` instances # (rarely used, see ``Axes.lines``) # patches A list of Figure `.Patch`\s # (rarely used, see ``Axes.patches``) # texts A list Figure `.Text` instances # ================ ============================================================ # # .. _axes-container: # # Axes container # -------------- # # The :class:`matplotlib.axes.Axes` is the center of the Matplotlib # universe -- it contains the vast majority of all the ``Artists`` used # in a figure with many helper methods to create and add these # ``Artists`` to itself, as well as helper methods to access and # customize the ``Artists`` it contains. Like the # :class:`~matplotlib.figure.Figure`, it contains a # :class:`~matplotlib.patches.Patch` # :attr:`!matplotlib.axes.Axes.patch` which is a # :class:`~matplotlib.patches.Rectangle` for Cartesian coordinates and a # :class:`~matplotlib.patches.Circle` for polar coordinates; this patch # determines the shape, background and border of the plotting region:: # # ax = fig.add_subplot() # rect = ax.patch # a Rectangle instance # rect.set_facecolor('green') # # When you call a plotting method, e.g., the canonical # `~matplotlib.axes.Axes.plot` and pass in arrays or lists of values, the # method will create a `matplotlib.lines.Line2D` instance, update the line with # all the ``Line2D`` properties passed as keyword arguments, add the line to # the ``Axes``, and return it to you: # # .. sourcecode:: ipython # # In [213]: x, y = np.random.rand(2, 100) # # In [214]: line, = ax.plot(x, y, '-', color='blue', linewidth=2) # # ``plot`` returns a list of lines because you can pass in multiple x, y # pairs to plot, and we are unpacking the first element of the length # one list into the line variable. The line has been added to the # ``Axes.lines`` list: # # .. sourcecode:: ipython # # In [229]: print(ax.lines) # [] # # Similarly, methods that create patches, like # :meth:`~matplotlib.axes.Axes.bar` creates a list of rectangles, will # add the patches to the :attr:`!Axes.patches` list: # # .. sourcecode:: ipython # # In [233]: n, bins, rectangles = ax.hist(np.random.randn(1000), 50) # # In [234]: rectangles # Out[234]: # # In [235]: print(len(ax.patches)) # Out[235]: 50 # # You should not add objects directly to the ``Axes.lines`` or ``Axes.patches`` # lists, because the ``Axes`` needs to do a few things when it creates and adds # an object: # # - It sets the ``figure`` and ``axes`` property of the ``Artist``; # - It sets the default ``Axes`` transformation (unless one is already set); # - It inspects the data contained in the ``Artist`` to update the data # structures controlling auto-scaling, so that the view limits can be # adjusted to contain the plotted data. # # You can, nonetheless, create objects yourself and add them directly to the # ``Axes`` using helper methods like `~matplotlib.axes.Axes.add_line` and # `~matplotlib.axes.Axes.add_patch`. Here is an annotated interactive session # illustrating what is going on: # # .. sourcecode:: ipython # # In [262]: fig, ax = plt.subplots() # # # create a rectangle instance # In [263]: rect = matplotlib.patches.Rectangle((1, 1), width=5, height=12) # # # by default the Axes instance is None # In [264]: print(rect.axes) # None # # # and the transformation instance is set to the "identity transform" # In [265]: print(rect.get_data_transform()) # IdentityTransform() # # # now we add the Rectangle to the Axes # In [266]: ax.add_patch(rect) # # # and notice that the ax.add_patch method has set the Axes # # instance # In [267]: print(rect.axes) # Axes(0.125,0.1;0.775x0.8) # # # and the transformation has been set too # In [268]: print(rect.get_data_transform()) # CompositeGenericTransform( # TransformWrapper( # BlendedAffine2D( # IdentityTransform(), # IdentityTransform())), # CompositeGenericTransform( # BboxTransformFrom( # TransformedBbox( # Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0), # TransformWrapper( # BlendedAffine2D( # IdentityTransform(), # IdentityTransform())))), # BboxTransformTo( # TransformedBbox( # Bbox(x0=0.125, y0=0.10999999999999999, x1=0.9, y1=0.88), # BboxTransformTo( # TransformedBbox( # Bbox(x0=0.0, y0=0.0, x1=6.4, y1=4.8), # Affine2D( # [[100. 0. 0.] # [ 0. 100. 0.] # [ 0. 0. 1.]]))))))) # # # the default Axes transformation is ax.transData # In [269]: print(ax.transData) # CompositeGenericTransform( # TransformWrapper( # BlendedAffine2D( # IdentityTransform(), # IdentityTransform())), # CompositeGenericTransform( # BboxTransformFrom( # TransformedBbox( # Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0), # TransformWrapper( # BlendedAffine2D( # IdentityTransform(), # IdentityTransform())))), # BboxTransformTo( # TransformedBbox( # Bbox(x0=0.125, y0=0.10999999999999999, x1=0.9, y1=0.88), # BboxTransformTo( # TransformedBbox( # Bbox(x0=0.0, y0=0.0, x1=6.4, y1=4.8), # Affine2D( # [[100. 0. 0.] # [ 0. 100. 0.] # [ 0. 0. 1.]]))))))) # # # notice that the xlimits of the Axes have not been changed # In [270]: print(ax.get_xlim()) # (0.0, 1.0) # # # but the data limits have been updated to encompass the rectangle # In [271]: print(ax.dataLim.bounds) # (1.0, 1.0, 5.0, 12.0) # # # we can manually invoke the auto-scaling machinery # In [272]: ax.autoscale_view() # # # and now the xlim are updated to encompass the rectangle, plus margins # In [273]: print(ax.get_xlim()) # (0.75, 6.25) # # # we have to manually force a figure draw # In [274]: fig.canvas.draw() # # # There are many, many ``Axes`` helper methods for creating primitive # ``Artists`` and adding them to their respective containers. The table # below summarizes a small sampling of them, the kinds of ``Artist`` they # create, and where they store them # # ========================================= ================= =============== # Axes helper method Artist Container # ========================================= ================= =============== # `~.axes.Axes.annotate` - text annotations `.Annotation` ax.texts # `~.axes.Axes.bar` - bar charts `.Rectangle` ax.patches # `~.axes.Axes.errorbar` - error bar plots `.Line2D` and ax.lines and # `.Rectangle` ax.patches # `~.axes.Axes.fill` - shared area `.Polygon` ax.patches # `~.axes.Axes.hist` - histograms `.Rectangle` ax.patches # `~.axes.Axes.imshow` - image data `.AxesImage` ax.images # `~.axes.Axes.legend` - Axes legend `.Legend` ax.get_legend() # `~.axes.Axes.plot` - xy plots `.Line2D` ax.lines # `~.axes.Axes.scatter` - scatter charts `.PolyCollection` ax.collections # `~.axes.Axes.text` - text `.Text` ax.texts # ========================================= ================= =============== # # # In addition to all of these ``Artists``, the ``Axes`` contains two # important ``Artist`` containers: the :class:`~matplotlib.axis.XAxis` # and :class:`~matplotlib.axis.YAxis`, which handle the drawing of the # ticks and labels. These are stored as instance variables # :attr:`!matplotlib.axes.Axes.xaxis` and # :attr:`!matplotlib.axes.Axes.yaxis`. The ``XAxis`` and ``YAxis`` # containers will be detailed below, but note that the ``Axes`` contains # many helper methods which forward calls on to the # :class:`~matplotlib.axis.Axis` instances, so you often do not need to # work with them directly unless you want to. For example, you can set # the font color of the ``XAxis`` ticklabels using the ``Axes`` helper # method:: # # ax.tick_params(axis='x', labelcolor='orange') # # Below is a summary of the Artists that the `~.axes.Axes` contains # # ============== ========================================= # Axes attribute Description # ============== ========================================= # artists An `.ArtistList` of `.Artist` instances # patch `.Rectangle` instance for Axes background # collections An `.ArtistList` of `.Collection` instances # images An `.ArtistList` of `.AxesImage` # lines An `.ArtistList` of `.Line2D` instances # patches An `.ArtistList` of `.Patch` instances # texts An `.ArtistList` of `.Text` instances # xaxis A `matplotlib.axis.XAxis` instance # yaxis A `matplotlib.axis.YAxis` instance # ============== ========================================= # # The legend can be accessed by `~.axes.Axes.get_legend`, # # .. _axis-container: # # Axis containers # --------------- # # The :class:`matplotlib.axis.Axis` instances handle the drawing of the # tick lines, the grid lines, the tick labels and the axis label. You # can configure the left and right ticks separately for the y-axis, and # the upper and lower ticks separately for the x-axis. The ``Axis`` # also stores the data and view intervals used in auto-scaling, panning # and zooming, as well as the :class:`~matplotlib.ticker.Locator` and # :class:`~matplotlib.ticker.Formatter` instances which control where # the ticks are placed and how they are represented as strings. # # Each ``Axis`` object contains a :attr:`~matplotlib.axis.Axis.label` attribute # (this is what :mod:`.pyplot` modifies in calls to `~.pyplot.xlabel` and # `~.pyplot.ylabel`) as well as a list of major and minor ticks. The ticks are # `.axis.XTick` and `.axis.YTick` instances, which contain the actual line and # text primitives that render the ticks and ticklabels. Because the ticks are # dynamically created as needed (e.g., when panning and zooming), you should # access the lists of major and minor ticks through their accessor methods # `.axis.Axis.get_major_ticks` and `.axis.Axis.get_minor_ticks`. Although # the ticks contain all the primitives and will be covered below, ``Axis`` # instances have accessor methods that return the tick lines, tick labels, tick # locations etc.: fig, ax = plt.subplots() axis = ax.xaxis axis.get_ticklocs() # %% axis.get_ticklabels() # %% # note there are twice as many ticklines as labels because by default there are # tick lines at the top and bottom but only tick labels below the xaxis; # however, this can be customized. axis.get_ticklines() # %% # And with the above methods, you only get lists of major ticks back by # default, but you can also ask for the minor ticks: axis.get_ticklabels(minor=True) axis.get_ticklines(minor=True) # %% # Here is a summary of some of the useful accessor methods of the ``Axis`` # (these have corresponding setters where useful, such as # :meth:`~matplotlib.axis.Axis.set_major_formatter`.) # # ============================= ============================================== # Axis accessor method Description # ============================= ============================================== # `~.Axis.get_scale` The scale of the Axis, e.g., 'log' or 'linear' # `~.Axis.get_view_interval` The interval instance of the Axis view limits # `~.Axis.get_data_interval` The interval instance of the Axis data limits # `~.Axis.get_gridlines` A list of grid lines for the Axis # `~.Axis.get_label` The Axis label - a `.Text` instance # `~.Axis.get_offset_text` The Axis offset text - a `.Text` instance # `~.Axis.get_ticklabels` A list of `.Text` instances - # keyword minor=True|False # `~.Axis.get_ticklines` A list of `.Line2D` instances - # keyword minor=True|False # `~.Axis.get_ticklocs` A list of Tick locations - # keyword minor=True|False # `~.Axis.get_major_locator` The `.ticker.Locator` instance for major ticks # `~.Axis.get_major_formatter` The `.ticker.Formatter` instance for major # ticks # `~.Axis.get_minor_locator` The `.ticker.Locator` instance for minor ticks # `~.Axis.get_minor_formatter` The `.ticker.Formatter` instance for minor # ticks # `~.axis.Axis.get_major_ticks` A list of `.Tick` instances for major ticks # `~.axis.Axis.get_minor_ticks` A list of `.Tick` instances for minor ticks # `~.Axis.grid` Turn the grid on or off for the major or minor # ticks # ============================= ============================================== # # Here is an example, not recommended for its beauty, which customizes # the Axes and Tick properties. # plt.figure creates a matplotlib.figure.Figure instance fig = plt.figure() rect = fig.patch # a rectangle instance rect.set_facecolor('lightgoldenrodyellow') ax1 = fig.add_axes([0.1, 0.3, 0.4, 0.4]) rect = ax1.patch rect.set_facecolor('lightslategray') for label in ax1.xaxis.get_ticklabels(): # label is a Text instance label.set_color('red') label.set_rotation(45) label.set_fontsize(16) for line in ax1.yaxis.get_ticklines(): # line is a Line2D instance line.set_color('green') line.set_markersize(25) line.set_markeredgewidth(3) plt.show() # %% # .. _tick-container: # # Tick containers # --------------- # # The :class:`matplotlib.axis.Tick` is the final container object in our # descent from the :class:`~matplotlib.figure.Figure` to the # :class:`~matplotlib.axes.Axes` to the :class:`~matplotlib.axis.Axis` # to the :class:`~matplotlib.axis.Tick`. The ``Tick`` contains the tick # and grid line instances, as well as the label instances for the upper # and lower ticks. Each of these is accessible directly as an attribute # of the ``Tick``. # # ============== ========================================================== # Tick attribute Description # ============== ========================================================== # tick1line A `.Line2D` instance # tick2line A `.Line2D` instance # gridline A `.Line2D` instance # label1 A `.Text` instance # label2 A `.Text` instance # ============== ========================================================== # # Here is an example which sets the formatter for the right side ticks with # dollar signs and colors them green on the right side of the yaxis. # # # .. include:: ../gallery/ticks/dollar_ticks.rst # :start-after: .. redirect-from:: /gallery/pyplots/dollar_ticks # :end-before: .. admonition:: References