various requested fixes

toddrjen · toddrjen · commit 9c5ab5efc48a · 2020-04-10T14:53:31.000-04:00
diff --git a/doc/users/next_whats_new/2020-03-06-auto-tick-formatters.rst b/doc/users/next_whats_new/2020-03-06-auto-tick-formatters.rst
@@ -3,5 +3,5 @@ Allow tick formatters to be set with str or function inputs
 `~.Axis.set_major_formatter` and `~.Axis.set_minor_formatter`
 now accept `str` or function inputs in addition to `~.ticker.Formatter`
 instances. For a `str` a `~.ticker.StrMethodFormatter` is automatically
-created and used. For a function a `~.ticker.FuncFormatter` is automatically
-created and used.
+generated and used. For a function a `~.ticker.FuncFormatter` is automatically
+generated and used.
diff --git a/examples/mplot3d/surface3d.py b/examples/mplot3d/surface3d.py
@@ -54,4 +54,5 @@
 matplotlib.pyplot.subplots
 matplotlib.axis.Axis.set_major_formatter
 matplotlib.axis.Axis.set_major_locator
+matplotlib.ticker.LinearLocator
 matplotlib.ticker.StrMethodFormatter
diff --git a/examples/pyplots/dollar_ticks.py b/examples/pyplots/dollar_ticks.py
@@ -17,10 +17,8 @@
 # Use automatic StrMethodFormatter
 ax.yaxis.set_major_formatter('${x:1.2f}')
 
-for tick in ax.yaxis.get_major_ticks():
-    tick.label1.set_visible(False)
-    tick.label2.set_visible(True)
-    tick.label2.set_color('green')
+ax.yaxis.set_tick_params(which='major', labelcolor='green',
+                         labelleft=False, labelright=True)
 
 plt.show()
 
@@ -38,6 +36,6 @@
 import matplotlib
 matplotlib.pyplot.subplots
 matplotlib.axis.Axis.set_major_formatter
-matplotlib.axis.Axis.get_major_ticks
+matplotlib.axis.Axis.set_tick_params
 matplotlib.axis.Tick
 matplotlib.ticker.StrMethodFormatter
diff --git a/examples/ticks_and_spines/custom_ticker1.py b/examples/ticks_and_spines/custom_ticker1.py
@@ -12,9 +12,7 @@
 millions of dollars on the y axis.
 """
 import matplotlib.pyplot as plt
-import numpy as np
 
-x = np.arange(4)
 money = [1.5e5, 2.5e6, 5.5e6, 2.0e7]
 
 
@@ -25,8 +23,7 @@ def millions(x, pos):
 fig, ax = plt.subplots()
 # Use automatic FuncFormatter creation
 ax.yaxis.set_major_formatter(millions)
-ax.bar(x, money)
-ax.set_xticks(x, ('Bill', 'Fred', 'Mary', 'Sue'))
+ax.bar(['Bill', 'Fred', 'Mary', 'Sue'], money)
 plt.show()
 
 #############################################################################
diff --git a/examples/ticks_and_spines/tick-formatters.py b/examples/ticks_and_spines/tick-formatters.py
@@ -34,59 +34,76 @@ def setup(ax, title):
             fontsize=14, fontname='Monospace', color='tab:blue')
 
 
-fig, axs = plt.subplots(9, 1, figsize=(8, 8))
+# Tick formatters can be set in one of two ways, either by passing a ``str``
+# or function to `~.Axis.set_major_formatter` or `~.Axis.set_minor_formatter`,
+# or by creating an instance of one of the various `~.ticker.Formatter` classes
+# and providing that to `~.Axis.set_major_formatter` or
+# `~.Axis.set_minor_formatter`.
 
-# A string, using format string function syntax, can be used directly as a
+# The first two examples directly pass a ``str`` or function.
+
+fig0, axs0 = plt.subplots(2, 1, figsize=(8, 2))
+fig0.suptitle('Simple Formatting')
+
+# A ``str``, using format string function syntax, can be used directly as a
 # formatter.  The variable ``x`` is the tick value and the variable ``pos`` is
 # tick position.  This creates a StrMethodFormatter automatically.
-setup(axs[0], title="'{x} km'")
-axs[0].xaxis.set_major_formatter('{x} km')
+setup(axs0[0], title="'{x} km'")
+axs0[0].xaxis.set_major_formatter('{x} km')
 
 # A function can also be used directly as a formatter. The function must take
 # two arguments: ``x`` for the tick value and ``pos`` for the tick position,
 # and must return a ``str``  This creates a FuncFormatter automatically.
-setup(axs[1], title="lambda x, pos: str(x-5)")
-axs[1].xaxis.set_major_formatter(lambda x, pos: str(x-5))
+setup(axs0[1], title="lambda x, pos: str(x-5)")
+axs0[1].xaxis.set_major_formatter(lambda x, pos: str(x-5))
+
+fig0.tight_layout()
+
+
+# The remaining examples use Formatter objects.
+
+fig1, axs1 = plt.subplots(7, 1, figsize=(8, 6))
+fig1.suptitle('Formatter Object Formatting')
 
 # Null formatter
-setup(axs[2], title="NullFormatter()")
-axs[2].xaxis.set_major_formatter(ticker.NullFormatter())
+setup(axs1[0], title="NullFormatter()")
+axs1[0].xaxis.set_major_formatter(ticker.NullFormatter())
 
 # StrMethod formatter
-setup(axs[3], title="StrMethodFormatter('{x:.3f}')")
-axs[3].xaxis.set_major_formatter(ticker.StrMethodFormatter("{x:.3f}"))
+setup(axs1[1], title="StrMethodFormatter('{x:.3f}')")
+axs1[1].xaxis.set_major_formatter(ticker.StrMethodFormatter("{x:.3f}"))
 
 # FuncFormatter can be used as a decorator
 @ticker.FuncFormatter
 def major_formatter(x, pos):
     return f'[{x:.2f}]'
 
 
-setup(axs[4], title='FuncFormatter("[{:.2f}]".format')
-axs[4].xaxis.set_major_formatter(major_formatter)
+setup(axs1[2], title='FuncFormatter("[{:.2f}]".format')
+axs1[2].xaxis.set_major_formatter(major_formatter)
 
 # Fixed formatter
-setup(axs[5], title="FixedFormatter(['A', 'B', 'C', ...])")
+setup(axs1[3], title="FixedFormatter(['A', 'B', 'C', ...])")
 # FixedFormatter should only be used together with FixedLocator.
 # Otherwise, one cannot be sure where the labels will end up.
 positions = [0, 1, 2, 3, 4, 5]
 labels = ['A', 'B', 'C', 'D', 'E', 'F']
-axs[5].xaxis.set_major_locator(ticker.FixedLocator(positions))
-axs[5].xaxis.set_major_formatter(ticker.FixedFormatter(labels))
+axs1[3].xaxis.set_major_locator(ticker.FixedLocator(positions))
+axs1[3].xaxis.set_major_formatter(ticker.FixedFormatter(labels))
 
 # Scalar formatter
-setup(axs[6], title="ScalarFormatter()")
-axs[6].xaxis.set_major_formatter(ticker.ScalarFormatter(useMathText=True))
+setup(axs1[4], title="ScalarFormatter()")
+axs1[4].xaxis.set_major_formatter(ticker.ScalarFormatter(useMathText=True))
 
 # FormatStr formatter
-setup(axs[7], title="FormatStrFormatter('#%d')")
-axs[7].xaxis.set_major_formatter(ticker.FormatStrFormatter("#%d"))
+setup(axs1[5], title="FormatStrFormatter('#%d')")
+axs1[5].xaxis.set_major_formatter(ticker.FormatStrFormatter("#%d"))
 
 # Percent formatter
-setup(axs[8], title="PercentFormatter(xmax=5)")
-axs[8].xaxis.set_major_formatter(ticker.PercentFormatter(xmax=5))
+setup(axs1[6], title="PercentFormatter(xmax=5)")
+axs1[6].xaxis.set_major_formatter(ticker.PercentFormatter(xmax=5))
 
-fig.tight_layout()
+fig1.tight_layout()
 plt.show()
 
 
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -1530,8 +1530,8 @@ def set_major_formatter(self, formatter):
         See the  `~matplotlib.ticker.StrMethodFormatter` documentation for
         more information.
 
-        For a function a `~matplotlib.ticker.FuncFormatter` is used.
-        The function should take in two inputs (a tick value ``x`` and a
+        For a function, a `~matplotlib.ticker.FuncFormatter` is used.
+        The function must take two inputs (a tick value ``x`` and a
         position ``pos``), and return a string containing the corresponding
         tick label.
         See the  `~matplotlib.ticker.FuncFormatter` documentation for
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -204,25 +204,46 @@ def test_formatter_ticker():
     ax.autoscale_view()
 
 
-def test_auto_formatter():
+def test_funcformatter_auto_formatter():
     def _formfunc(x, pos):
         return ''
 
-    formstr = '{x}_{pos}'
-
     ax = plt.figure().subplots()
+
+    assert ax.xaxis.isDefault_majfmt == True
+    assert ax.xaxis.isDefault_minfmt == True
+
     ax.xaxis.set_major_formatter(_formfunc)
-    ax.yaxis.set_minor_formatter(formstr)
+
+    assert ax.xaxis.isDefault_majfmt == False
+    assert ax.xaxis.isDefault_minfmt == True
 
     targ_funcformatter = mticker.FuncFormatter(_formfunc)
-    targ_strformatter = mticker.StrMethodFormatter(formstr)
 
     assert isinstance(ax.xaxis.get_major_formatter(),
                       mticker.FuncFormatter)
+
+    assert ax.xaxis.get_major_formatter().func == targ_funcformatter.func
+
+
+def test_strmethodformatter_auto_formatter():
+    formstr = '{x}_{pos}'
+
+    ax = plt.figure().subplots()
+
+    assert ax.yaxis.isDefault_majfmt == True
+    assert ax.yaxis.isDefault_minfmt == True
+
+    ax.yaxis.set_minor_formatter(formstr)
+
+    assert ax.yaxis.isDefault_majfmt == True
+    assert ax.yaxis.isDefault_minfmt == False
+
+    targ_strformatter = mticker.StrMethodFormatter(formstr)
+
     assert isinstance(ax.yaxis.get_minor_formatter(),
                       mticker.StrMethodFormatter)
 
-    assert ax.xaxis.get_major_formatter().func == targ_funcformatter.func
     assert ax.yaxis.get_minor_formatter().fmt == targ_strformatter.fmt
 
 
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -159,11 +159,11 @@
   ax.yaxis.set_major_formatter(ymajor_formatter)
   ax.yaxis.set_minor_formatter(yminor_formatter)
 
-In addition to `.Formatter`, `~.Axis.set_major_formatter` and
-`~.Axis.set_minor_formatter` also accept a ``str`` or function.  In the case of
-a ``str``, a `.StrMethodFormatter` will be automatically created and applied
-based on the given ``str``.  Similarly, for a function a `.FuncFormatter` will
-be automatically created and applied using the given function.
+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_and_spines/major_minor_demo` for an
 example of setting major and minor ticks. See the :mod:`matplotlib.dates`
diff --git a/tutorials/intermediate/artists.py b/tutorials/intermediate/artists.py
@@ -650,19 +650,9 @@ class in the matplotlib API, and the one you will be working with most
 # ==============   ==========================================================
 #
 # 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
-
-# Fixing random state for reproducibility
-np.random.seed(19680801)
-
-fig, ax = plt.subplots()
-ax.plot(100*np.random.rand(20))
-
-ax.yaxis.set_major_formatter('${x:1.2f}')
-
-for tick in ax.yaxis.get_major_ticks():
-    tick.label1.set_visible(False)
-    tick.label2.set_visible(True)
-    tick.label2.set_color('green')
-
-plt.show()
+# dollar signs and colors them green on the right side of the yaxis.
+#
+#
+# .. include:: ../../gallery/pyplots/dollar_ticks.rst
+#    :start-after: y axis labels.
+#    :end-before: -------
diff --git a/tutorials/introductory/lifecycle.py b/tutorials/introductory/lifecycle.py
@@ -5,7 +5,7 @@
 
 This tutorial aims to show the beginning, middle, and end of a single
 visualization using Matplotlib. We'll begin with some raw data and
-end by saving a figure of a customized visualization. Along the way we'll try
+end by saving a figure of a customized visualization. Along the way we try
 to highlight some neat features and best-practices using Matplotlib.
 
 .. currentmodule:: matplotlib
@@ -74,7 +74,7 @@
 # ===============
 #
 # This data is naturally visualized as a barplot, with one bar per
-# group. To do this with the object-oriented approach, we'll first generate
+# group. To do this with the object-oriented approach, we first generate
 # an instance of :class:`figure.Figure` and
 # :class:`axes.Axes`. The Figure is like a canvas, and the Axes
 # is a part of that canvas on which we will make a particular visualization.
@@ -143,7 +143,7 @@
 ###############################################################################
 # It looks like this cut off some of the labels on the bottom. We can
 # tell Matplotlib to automatically make room for elements in the figures
-# that we create. To do this we'll set the ``autolayout`` value of our
+# that we create. To do this we set the ``autolayout`` value of our
 # rcParams. For more information on controlling the style, layout, and
 # other features of plots with rcParams, see
 # :doc:`/tutorials/introductory/customizing`.
@@ -156,7 +156,7 @@
 plt.setp(labels, rotation=45, horizontalalignment='right')
 
 ###############################################################################
-# Next, we'll add labels to the plot. To do this with the OO interface,
+# Next, we add labels to the plot. To do this with the OO interface,
 # we can use the :meth:`axes.Axes.set` method to set properties of this
 # Axes object.
 
@@ -187,7 +187,7 @@
 
 ###############################################################################
 # For labels, we can specify custom formatting guidelines in the form of
-# functions. Below we'll define a function that takes an integer as input, and
+# functions. Below we define a function that takes an integer as input, and
 # returns a string as an output. When used with `.Axis.set_major_formatter` or
 # `.Axis.set_minor_formatter`, they will automatically create and use a
 # :class:`ticker.FuncFormatter` class.
@@ -207,7 +207,7 @@ def currency(x, pos):
 
 ###############################################################################
 # We can then apply this function to the labels on our plot. To do this,
-# we'll use the ``xaxis`` attribute of our axis. This lets you perform
+# we use the ``xaxis`` attribute of our axis. This lets you perform
 # actions on a specific axis on our plot.
 
 fig, ax = plt.subplots(figsize=(6, 8))
@@ -240,7 +240,7 @@ def currency(x, pos):
     ax.text(145000, group, "New Company", fontsize=10,
             verticalalignment="center")
 
-# Now we'll move our title up since it's getting a little cramped
+# Now we move our title up since it's getting a little cramped
 ax.title.set(y=1.05)
 
 ax.set(xlim=[-10000, 140000], xlabel='Total Revenue', ylabel='Company',
@@ -263,7 +263,7 @@ def currency(x, pos):
 
 ###############################################################################
 # We can then use the :meth:`figure.Figure.savefig` in order to save the figure
-# to disk. Note that there are several useful flags we'll show below:
+# to disk. Note that there are several useful flags we show below:
 #
 # * ``transparent=True`` makes the background of the saved figure transparent
 #   if the format supports it.
diff --git a/tutorials/text/text_intro.py b/tutorials/text/text_intro.py
@@ -286,8 +286,8 @@
 # used `matplotlib.ticker.StrMethodFormatter` (new-style ``str.format()``
 # format string) or `matplotlib.ticker.FormatStrFormatter` (old-style '%'
 # format string) and passed it to the ``ax.xaxis``.  A
-# `matplotlib.ticker.StrMethodFormatter` can also be created by simply
-# passing a ``str`` without having to explicitly create the formatter.
+# `matplotlib.ticker.StrMethodFormatter` can also be created by passing a
+# ``str`` without having to explicitly create the formatter.
 
 fig, axs = plt.subplots(2, 1, figsize=(5, 3), tight_layout=True)
 axs[0].plot(x1, y1)
@@ -350,7 +350,7 @@
 ##############################################################################
 #  Finally, we can specify functions for the formatter using
 # `matplotlib.ticker.FuncFormatter`.  Further, like
-# `matplotlib.ticker.StrMethodFormatter`, simply passing a function will
+# `matplotlib.ticker.StrMethodFormatter`, passing a function will
 # automatically create a `matplotlib.ticker.FuncFormatter`.
 
 
