Remove unnecessary :func:, :meth: from examples markup.

anntzer · anntzer · commit b02ffa638b1b · 2019-12-20T09:10:59.000+01:00
diff --git a/examples/color/custom_cmap.py b/examples/color/custom_cmap.py
@@ -6,11 +6,9 @@
 For more detail on creating and manipulating colormaps see
 :doc:`/tutorials/colors/colormap-manipulation`.
 
-Creating a :doc:`colormap </tutorials/colors/colormaps>`
-from a list of colors can be done with the
-:meth:`~.colors.LinearSegmentedColormap.from_list` method of
-`.LinearSegmentedColormap`. You must pass a list of RGB tuples that define the
-mixture of colors from 0 to 1.
+Creating a :doc:`colormap </tutorials/colors/colormaps>` from a list of colors
+can be done with the `.LinearSegmentedColormap.from_list` method.  You must
+pass a list of RGB tuples that define the mixture of colors from 0 to 1.
 
 
 Creating custom colormaps
diff --git a/examples/images_contours_and_fields/contourf_demo.py b/examples/images_contours_and_fields/contourf_demo.py
@@ -3,8 +3,9 @@
 Contourf Demo
 =============
 
-How to use the :meth:`.axes.Axes.contourf` method to create filled contour plots.
+How to use the `.axes.Axes.contourf` method to create filled contour plots.
 """
+
 import numpy as np
 import matplotlib.pyplot as plt
 
diff --git a/examples/images_contours_and_fields/image_annotated_heatmap.py b/examples/images_contours_and_fields/image_annotated_heatmap.py
@@ -7,7 +7,8 @@
 variables as a color coded image plot. This is often referred to as a
 heatmap. If the data is categorical, this would be called a categorical
 heatmap.
-Matplotlib's :meth:`imshow <matplotlib.axes.Axes.imshow>` function makes
+
+Matplotlib's `~matplotlib.axes.Axes.imshow` function makes
 production of such plots particularly easy.
 
 The following examples show how to create a heatmap with annotations.
@@ -25,11 +26,11 @@
 # which defines the data to color code. We then also need two lists or arrays
 # of categories; of course the number of elements in those lists
 # need to match the data along the respective axes.
-# The heatmap itself is an :meth:`imshow <matplotlib.axes.Axes.imshow>` plot
+# The heatmap itself is an `~matplotlib.axes.Axes.imshow` plot
 # with the labels set to the categories we have.
 # Note that it is important to set both, the tick locations
-# (:meth:`set_xticks<matplotlib.axes.Axes.set_xticks>`) as well as the
-# tick labels (:meth:`set_xticklabels<matplotlib.axes.Axes.set_xticklabels>`),
+# (`~matplotlib.axes.Axes.set_xticks`) as well as the
+# tick labels (`~matplotlib.axes.Axes.set_xticklabels`),
 # otherwise they would become out of sync. The locations are just
 # the ascending integer numbers, while the ticklabels are the labels to show.
 # Finally we can label the data itself by creating a `~matplotlib.text.Text`
diff --git a/examples/images_contours_and_fields/image_demo.py b/examples/images_contours_and_fields/image_demo.py
@@ -6,7 +6,7 @@
 Many ways to plot images in Matplotlib.
 
 The most common way to plot images in Matplotlib is with
-:meth:`~.axes.Axes.imshow`. The following examples demonstrate much of the
+`~.axes.Axes.imshow`. The following examples demonstrate much of the
 functionality of imshow and the many images you can create.
 """
 
diff --git a/examples/images_contours_and_fields/image_transparency_blend.py b/examples/images_contours_and_fields/image_transparency_blend.py
@@ -5,7 +5,7 @@
 
 Blend transparency with color to highlight parts of data with imshow.
 
-A common use for :func:`matplotlib.pyplot.imshow` is to plot a 2-D statistical
+A common use for `matplotlib.pyplot.imshow` is to plot a 2-D statistical
 map. The function makes it easy to visualize a 2-D matrix as an image and add
 transparency to the output. For example, one can plot a statistic (such as a
 t-statistic) and color the transparency of each pixel according to its p-value.
@@ -67,7 +67,7 @@ def normal_pdf(x, mean, var):
 # ========================
 #
 # The simplest way to include transparency when plotting data with
-# :func:`matplotlib.pyplot.imshow` is to pass an array matching the shape of
+# `matplotlib.pyplot.imshow` is to pass an array matching the shape of
 # the data to the ``alpha`` argument. For example, we'll create a gradient
 # moving from left to right below.
 
diff --git a/examples/images_contours_and_fields/interpolation_methods.py b/examples/images_contours_and_fields/interpolation_methods.py
@@ -4,7 +4,7 @@
 =========================
 
 This example displays the difference between interpolation methods for
-:meth:`~.axes.Axes.imshow`.
+`~.axes.Axes.imshow`.
 
 If *interpolation* is None, it defaults to the :rc:`image.interpolation`.
 If the interpolation is ``'none'``, then no interpolation is performed for the
diff --git a/examples/images_contours_and_fields/pcolor_demo.py b/examples/images_contours_and_fields/pcolor_demo.py
@@ -3,7 +3,7 @@
 Pcolor Demo
 ===========
 
-Generating images with :meth:`~.axes.Axes.pcolor`.
+Generating images with `~.axes.Axes.pcolor`.
 
 Pcolor allows you to generate 2-D image-style plots. Below we will show how
 to do so in Matplotlib.
@@ -33,9 +33,9 @@
 # Comparing pcolor with similar functions
 # ---------------------------------------
 #
-# Demonstrates similarities between :meth:`~.axes.Axes.pcolor`,
-# :meth:`~.axes.Axes.pcolormesh`, :meth:`~.axes.Axes.imshow` and
-# :meth:`~.axes.Axes.pcolorfast` for drawing quadrilateral grids.
+# Demonstrates similarities between `~.axes.Axes.pcolor`,
+# `~.axes.Axes.pcolormesh`, `~.axes.Axes.imshow` and
+# `~.axes.Axes.pcolorfast` for drawing quadrilateral grids.
 
 # make these smaller to increase the resolution
 dx, dy = 0.15, 0.05
diff --git a/examples/images_contours_and_fields/pcolormesh_levels.py b/examples/images_contours_and_fields/pcolormesh_levels.py
@@ -3,11 +3,9 @@
 pcolormesh
 ==========
 
-Shows how to combine Normalization and Colormap instances to draw
-"levels" in :meth:`~.axes.Axes.pcolor`, :meth:`~.axes.Axes.pcolormesh`
-and :meth:`~.axes.Axes.imshow` type plots in a similar
-way to the levels keyword argument to contour/contourf.
-
+Shows how to combine Normalization and Colormap instances to draw "levels" in
+`~.axes.Axes.pcolor`, `~.axes.Axes.pcolormesh` and `~.axes.Axes.imshow` type
+plots in a similar way to the levels keyword argument to contour/contourf.
 """
 
 import matplotlib
diff --git a/examples/images_contours_and_fields/plot_streamplot.py b/examples/images_contours_and_fields/plot_streamplot.py
@@ -4,7 +4,7 @@
 ==========
 
 A stream plot, or streamline plot, is used to display 2D vector fields. This
-example shows a few features of the :meth:`~.axes.Axes.streamplot` function:
+example shows a few features of the `~.axes.Axes.streamplot` function:
 
 * Varying the color along a streamline.
 * Varying the density of streamlines.
diff --git a/examples/lines_bars_and_markers/scatter_with_legend.py b/examples/lines_bars_and_markers/scatter_with_legend.py
@@ -37,11 +37,9 @@
 # -------------------------
 #
 # Another option for creating a legend for a scatter is to use the
-# `~matplotlib.collections.PathCollection`'s
-# :meth:`~.PathCollection.legend_elements` method.
-# It will automatically try to determine a useful number of legend entries
-# to be shown and return a tuple of handles and labels. Those can be passed
-# to the call to :meth:`~.axes.Axes.legend`.
+# `.PathCollection.legend_elements` method.  It will automatically try to
+# determine a useful number of legend entries to be shown and return a tuple of
+# handles and labels. Those can be passed to the call to `~.axes.Axes.legend`.
 
 
 N = 45
@@ -66,10 +64,9 @@
 
 
 ##############################################################################
-# Further arguments to the :meth:`~.PathCollection.legend_elements` method
+# Further arguments to the `.PathCollection.legend_elements` method
 # can be used to steer how many legend entries are to be created and how they
 # should be labeled. The following shows how to use some of them.
-#
 
 volume = np.random.rayleigh(27, size=40)
 amount = np.random.poisson(10, size=40)
diff --git a/examples/lines_bars_and_markers/span_regions.py b/examples/lines_bars_and_markers/span_regions.py
@@ -6,8 +6,9 @@
 Illustrate some helper functions for shading regions where a logical
 mask is True.
 
-See :meth:`matplotlib.collections.BrokenBarHCollection.span_where`
+See `matplotlib.collections.BrokenBarHCollection.span_where`.
 """
+
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.collections as collections
diff --git a/examples/pie_and_polar_charts/nested_pie.py b/examples/pie_and_polar_charts/nested_pie.py
@@ -13,7 +13,7 @@
 
 ###############################################################################
 # The most straightforward way to build a pie chart is to use the
-# :meth:`pie method <matplotlib.axes.Axes.pie>`
+# `~matplotlib.axes.Axes.pie` method.
 #
 # In this case, pie takes values corresponding to counts in a group.
 # We'll first generate some fake data, corresponding to three groups.
diff --git a/examples/pie_and_polar_charts/pie_and_donut_labels.py b/examples/pie_and_polar_charts/pie_and_donut_labels.py
@@ -3,10 +3,10 @@
 Labeling a pie and a donut
 ==========================
 
-Welcome to the matplotlib bakery. We will create a pie and a donut
-chart through the :meth:`pie method <matplotlib.axes.Axes.pie>` and
-show how to label them with a :meth:`legend <matplotlib.axes.Axes.legend>`
-as well as with :meth:`annotations <matplotlib.axes.Axes.annotate>`.
+Welcome to the Matplotlib bakery. We will create a pie and a donut
+chart through the `pie method <matplotlib.axes.Axes.pie>` and
+show how to label them with a `legend <matplotlib.axes.Axes.legend>`
+as well as with `annotations <matplotlib.axes.Axes.annotate>`.
 """
 
 ###############################################################################
@@ -71,7 +71,7 @@ def func(pct, allvals):
 # This is done via the ``wedgeprops`` argument.
 #
 # We then want to label the wedges via
-# :meth:`annotations <matplotlib.axes.Axes.annotate>`. We first create some
+# `annotations <matplotlib.axes.Axes.annotate>`. We first create some
 # dictionaries of common properties, which we can later pass as keyword
 # argument. We then iterate over all wedges and for each
 #
diff --git a/examples/pie_and_polar_charts/pie_demo2.py b/examples/pie_and_polar_charts/pie_demo2.py
@@ -3,7 +3,7 @@
 Pie Demo2
 =========
 
-Make a pie charts using :meth:`~.axes.Axes.pie`.
+Make a pie charts using `~.axes.Axes.pie`.
 
 This example demonstrates some pie chart features like labels, varying size,
 autolabeling the percentage, offsetting a slice and adding a shadow.
diff --git a/examples/recipes/create_subplots.py b/examples/recipes/create_subplots.py
@@ -21,8 +21,8 @@
 ax3 = fig.add_subplot(224, sharex=ax1, sharey=ax1)
 
 ###############################################################################
-# Fernando Perez has provided a nice top level method in
-# :func:`~matplotlib.pyplot.subplots` (note the "s" at the end) to create
+# Fernando Perez has provided the nice top-level function
+# `~matplotlib.pyplot.subplots` (note the "s" at the end) to create
 # everything at once, and turn on x and y sharing for the whole bunch.
 # You can either unpack the axes individually...
 
diff --git a/examples/recipes/fill_between_alpha.py b/examples/recipes/fill_between_alpha.py
@@ -2,7 +2,7 @@
 Fill Between and Alpha
 ======================
 
-The :meth:`~matplotlib.axes.Axes.fill_between` function generates a shaded
+The `~matplotlib.axes.Axes.fill_between` function generates a shaded
 region between a min and max boundary that is useful for illustrating ranges.
 It has a very handy ``where`` argument to combine filling with logical ranges,
 e.g., to just fill in a curve over some threshold value.
@@ -125,10 +125,9 @@
 ax.grid()
 
 ###############################################################################
-# Another handy use of filled regions is to highlight horizontal or
-# vertical spans of an axes -- for that matplotlib has some helper
-# functions :meth:`~matplotlib.axes.Axes.axhspan` and
-# :meth:`~matplotlib.axes.Axes.axvspan` and example
+# Another handy use of filled regions is to highlight horizontal or vertical
+# spans of an axes -- for that Matplotlib has the helper functions
+# `~matplotlib.axes.Axes.axhspan` and `~matplotlib.axes.Axes.axvspan`.  See
 # :doc:`/gallery/subplots_axes_and_figures/axhspan_demo`.
 
 plt.show()
diff --git a/examples/recipes/share_axis_lims_views.py b/examples/recipes/share_axis_lims_views.py
@@ -2,13 +2,12 @@
 Sharing axis limits and views
 =============================
 
-It's common to make two or more plots which share an axis, e.g., two
-subplots with time as a common axis.  When you pan and zoom around on
-one, you want the other to move around with you.  To facilitate this,
-matplotlib Axes support a ``sharex`` and ``sharey`` attribute.  When
-you create a :func:`~matplotlib.pyplot.subplot` or
-:func:`~matplotlib.pyplot.axes` instance, you can pass in a keyword
-indicating what axes you want to share with
+It's common to make two or more plots which share an axis, e.g., two subplots
+with time as a common axis.  When you pan and zoom around on one, you want the
+other to move around with you.  To facilitate this, matplotlib Axes support a
+``sharex`` and ``sharey`` attribute.  When you create a `~.pyplot.subplot` or
+`~.pyplot.axes`, you can pass in a keyword indicating what axes you want to
+share with.
 """
 
 import numpy as np
diff --git a/examples/subplots_axes_and_figures/subplots_adjust.py b/examples/subplots_axes_and_figures/subplots_adjust.py
@@ -4,15 +4,15 @@
 ===============
 
 Adjusting the spacing of margins and subplots using
-:func:`~matplotlib.pyplot.subplots_adjust`.
+`~matplotlib.pyplot.subplots_adjust`.
 """
+
 import matplotlib.pyplot as plt
 import numpy as np
 
 # Fixing random state for reproducibility
 np.random.seed(19680801)
 
-
 plt.subplot(211)
 plt.imshow(np.random.random((100, 100)), cmap=plt.cm.BuPu_r)
 plt.subplot(212)
diff --git a/examples/subplots_axes_and_figures/two_scales.py b/examples/subplots_axes_and_figures/two_scales.py
@@ -9,8 +9,8 @@
 You can use separate `matplotlib.ticker` formatters and locators as
 desired since the two axes are independent.
 
-Such axes are generated by calling the :meth:`.Axes.twinx` method. Likewise,
-:meth:`.Axes.twiny` is available to generate axes that share a *y* axis but
+Such axes are generated by calling the `.Axes.twinx` method. Likewise,
+`.Axes.twiny` is available to generate axes that share a *y* axis but
 have different top and bottom scales.
 """
 import numpy as np
