Add missing spaces after commas.

anntzer · anntzer · commit 8b4ec3beb9d8 · 2020-01-09T09:48:03.000+01:00
Plus minor rewordings.
diff --git a/examples/color/custom_cmap.py b/examples/color/custom_cmap.py
@@ -147,9 +147,9 @@
 # in the middle of the range.
 cdict4 = {**cdict3,
           'alpha': ((0.0, 1.0, 1.0),
-                #   (0.25,1.0, 1.0),
+                #   (0.25, 1.0, 1.0),
                     (0.5, 0.3, 0.3),
-                #   (0.75,1.0, 1.0),
+                #   (0.75, 1.0, 1.0),
                     (1.0, 1.0, 1.0)),
           }
 
diff --git a/examples/images_contours_and_fields/irregulardatagrid.py b/examples/images_contours_and_fields/irregulardatagrid.py
@@ -53,7 +53,7 @@
 # Note that scipy.interpolate provides means to interpolate data on a grid
 # as well. The following would be an alternative to the four lines above:
 #from scipy.interpolate import griddata
-#zi = griddata((x, y), z, (xi[None,:], yi[:,None]), method='linear')
+#zi = griddata((x, y), z, (xi[None, :], yi[:, None]), method='linear')
 
 ax1.contour(xi, yi, zi, levels=14, linewidths=0.5, colors='k')
 cntr1 = ax1.contourf(xi, yi, zi, levels=14, cmap="RdBu_r")
diff --git a/examples/pyplots/whats_new_99_spines.py b/examples/pyplots/whats_new_99_spines.py
@@ -8,7 +8,7 @@
 import numpy as np
 
 
-def adjust_spines(ax,spines):
+def adjust_spines(ax, spines):
     for loc, spine in ax.spines.items():
         if loc in spines:
             spine.set_position(('outward', 10))  # outward by 10 points
@@ -30,24 +30,24 @@ def adjust_spines(ax,spines):
 
 fig = plt.figure()
 
-x = np.linspace(0,2*np.pi,100)
+x = np.linspace(0, 2*np.pi, 100)
 y = 2*np.sin(x)
 
-ax = fig.add_subplot(2,2,1)
-ax.plot(x,y)
-adjust_spines(ax,['left'])
+ax = fig.add_subplot(2, 2, 1)
+ax.plot(x, y)
+adjust_spines(ax, ['left'])
 
-ax = fig.add_subplot(2,2,2)
-ax.plot(x,y)
-adjust_spines(ax,[])
+ax = fig.add_subplot(2, 2, 2)
+ax.plot(x, y)
+adjust_spines(ax, [])
 
-ax = fig.add_subplot(2,2,3)
-ax.plot(x,y)
-adjust_spines(ax,['left','bottom'])
+ax = fig.add_subplot(2, 2, 3)
+ax.plot(x, y)
+adjust_spines(ax, ['left', 'bottom'])
 
-ax = fig.add_subplot(2,2,4)
-ax.plot(x,y)
-adjust_spines(ax,['bottom'])
+ax = fig.add_subplot(2, 2, 4)
+ax.plot(x, y)
+adjust_spines(ax, ['bottom'])
 
 plt.show()
 
diff --git a/examples/text_labels_and_annotations/accented_text.py b/examples/text_labels_and_annotations/accented_text.py
@@ -5,13 +5,12 @@
 
 Matplotlib supports accented characters via TeX mathtext or unicode.
 
-Using mathtext, the following accents are provided: \hat, \breve, \grave, \bar,
-\acute, \tilde, \vec, \dot, \ddot.  All of them have the same syntax,
-e.g., to make an overbar you do \bar{o} or to make an o umlaut you do
-\ddot{o}.  The shortcuts are also provided, e.g.,: \"o \'e \`e \~n \.x
-\^y
-
+Using mathtext, the following accents are provided: \\hat, \\breve, \\grave,
+\\bar, \\acute, \\tilde, \\vec, \\dot, \\ddot.  All of them have the same
+syntax, e.g. \\bar{o} yields "o overbar", \\ddot{o} yields "o umlaut".
+Shortcuts such as \\"o \\'e \\`e \\~n \\.x \\^y are also supported.
 """
+
 import matplotlib.pyplot as plt
 
 # Mathtext demo
diff --git a/examples/text_labels_and_annotations/font_family_rc_sgskip.py b/examples/text_labels_and_annotations/font_family_rc_sgskip.py
@@ -7,8 +7,8 @@
 style (e.g., 'serif', 'sans-serif', or 'monospace').
 
 In the example below, we only allow one font family (Tahoma) for the
-sans-serif font style.  You the default family with the font.family rc
-param, e.g.,::
+sans-serif font style.  The default family is set with the font.family rcparam,
+e.g. ::
 
   rcParams['font.family'] = 'sans-serif'
 
@@ -17,10 +17,8 @@
 
   rcParams['font.sans-serif'] = ['Tahoma', 'DejaVu Sans',
                                  'Lucida Grande', 'Verdana']
-
 """
 
-
 from matplotlib import rcParams
 rcParams['font.family'] = 'sans-serif'
 rcParams['font.sans-serif'] = ['Tahoma']
diff --git a/examples/user_interfaces/svg_tooltip_sgskip.py b/examples/user_interfaces/svg_tooltip_sgskip.py
@@ -90,13 +90,13 @@
     function ShowTooltip(obj) {
         var cur = obj.id.split("_")[1];
         var tip = svgDocument.getElementById('mytooltip_' + cur);
-        tip.setAttribute('visibility',"visible")
+        tip.setAttribute('visibility', "visible")
         }
 
     function HideTooltip(obj) {
         var cur = obj.id.split("_")[1];
         var tip = svgDocument.getElementById('mytooltip_' + cur);
-        tip.setAttribute('visibility',"hidden")
+        tip.setAttribute('visibility', "hidden")
         }
 
     ]]>
diff --git a/lib/matplotlib/_constrained_layout.py b/lib/matplotlib/_constrained_layout.py
@@ -402,8 +402,8 @@ def _align_spines(fig, gs):
             # different sizes if they occupy different amounts
             # of the gridspec:  i.e.
             # gs = gridspec.GridSpec(3, 1)
-            # ax1 = gs[0,:]
-            # ax2 = gs[1:,:]
+            # ax1 = gs[0, :]
+            # ax2 = gs[1:, :]
             # then drows0 = 1, and drowsC = 2, and ax2
             # should be at least twice as large as ax1.
             # But it can be more than twice as large because
diff --git a/lib/matplotlib/axes/_axes.py b/lib/matplotlib/axes/_axes.py
@@ -5970,7 +5970,7 @@ def pcolormesh(self, *args, alpha=None, norm=None, cmap=None, vmin=None,
               quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by
               ``C[i, j]``.
             - 'gouraud': Each quad will be Gouraud shaded: The color of the
-              corners (i', j') are given by ``C[i',j']``. The color values of
+              corners (i', j') are given by ``C[i', j']``. The color values of
               the area in between is interpolated from the corner values.
               When Gouraud shading is used, *edgecolors* is ignored.
 
@@ -6309,7 +6309,7 @@ def hist(self, x, bins=None, range=None, density=False, weights=None,
 
         Compute and draw the histogram of *x*.  The return value is a tuple
         (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*,
-        *patches1*,...]) if the input contains multiple data.  See the
+        *patches1*, ...]) if the input contains multiple data.  See the
         documentation of the *weights* parameter to draw a histogram of
         already-binned data.
 
diff --git a/lib/matplotlib/contour.py b/lib/matplotlib/contour.py
@@ -1661,7 +1661,7 @@ def _initialize_x_y(self, z):
             `.imshow`: it gives the outer pixel boundaries. In this case, the
             position of Z[0, 0] is the center of the pixel, not a corner. If
             *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],
-            and (*x1*, *y1*) is the position of Z[-1,-1].
+            and (*x1*, *y1*) is the position of Z[-1, -1].
 
             This argument is ignored if *X* and *Y* are specified in the call
             to contour.
diff --git a/lib/matplotlib/spines.py b/lib/matplotlib/spines.py
@@ -18,7 +18,7 @@ class Spine(mpatches.Patch):
     positions. See function:`~matplotlib.spines.Spine.set_position`
     for more information.
 
-    The default position is ``('outward',0)``.
+    The default position is ``('outward', 0)``.
 
     Spines are subclasses of class:`~matplotlib.patches.Patch`, and
     inherit much of their behavior.
@@ -379,28 +379,23 @@ def draw(self, renderer):
         return ret
 
     def set_position(self, position):
-        """Set the position of the spine.
+        """
+        Set the position of the spine.
 
         Spine position is specified by a 2 tuple of (position type,
         amount). The position types are:
 
-        * 'outward' : place the spine out from the data area by the
-          specified number of points. (Negative values specify placing the
-          spine inward.)
-
-        * 'axes' : place the spine at the specified Axes coordinate (from
-          0.0-1.0).
-
-        * 'data' : place the spine at the specified data coordinate.
+        * 'outward': place the spine out from the data area by the specified
+          number of points. (Negative values place the spine inwards.)
+        * 'axes': place the spine at the specified Axes coordinate (0 to 1).
+        * 'data': place the spine at the specified data coordinate.
 
         Additionally, shorthand notations define a special positions:
 
-        * 'center' -> ('axes',0.5)
+        * 'center' -> ('axes', 0.5)
         * 'zero' -> ('data', 0.0)
-
         """
-        if position in ('center', 'zero'):
-            # special positions
+        if position in ('center', 'zero'):  # special positions
             pass
         else:
             if len(position) != 2:
@@ -409,9 +404,7 @@ def set_position(self, position):
                 raise ValueError("position[0] should be one of 'outward', "
                                  "'axes', or 'data' ")
         self._position = position
-
         self.set_transform(self.get_spine_transform())
-
         if self.axis is not None:
             self.axis.reset_ticks()
         self.stale = True
diff --git a/lib/matplotlib/textpath.py b/lib/matplotlib/textpath.py
@@ -385,8 +385,8 @@ def __init__(self, xy, s, size=None, prop=None,
             from matplotlib.font_manager import FontProperties
 
             fp = FontProperties(family="Helvetica", style="italic")
-            path1 = TextPath((12,12), "ABC", size=12, prop=fp)
-            path2 = TextPath((0,0), r"$\frac{1}{2}$", size=12, usetex=True)
+            path1 = TextPath((12, 12), "ABC", size=12, prop=fp)
+            path2 = TextPath((0, 0), r"$\frac{1}{2}$", size=12, usetex=True)
 
         Also see :doc:`/gallery/text_labels_and_annotations/demo_text_path`.
         """
diff --git a/lib/matplotlib/tri/triangulation.py b/lib/matplotlib/tri/triangulation.py
@@ -58,7 +58,7 @@ def __init__(self, x, y, triangles=None, mask=None):
             # orientation.
             self.triangles = np.array(triangles, dtype=np.int32, order='C')
             if self.triangles.ndim != 2 or self.triangles.shape[1] != 3:
-                raise ValueError('triangles must be a (?,3) array')
+                raise ValueError('triangles must be a (?, 3) array')
             if self.triangles.max() >= len(self.x):
                 raise ValueError('triangles max element is out of bounds')
             if self.triangles.min() < 0:
@@ -184,8 +184,8 @@ def neighbors(self):
         For each triangle, the indices of the three triangles that
         share the same edges, or -1 if there is no such neighboring
         triangle.  ``neighbors[i, j]`` is the triangle that is the neighbor
-        to the edge from point index ``triangles[i,j]`` to point index
-        ``triangles[i,(j+1)%3]``.
+        to the edge from point index ``triangles[i, j]`` to point index
+        ``triangles[i, (j+1)%3]``.
         """
         if self._neighbors is None:
             self._neighbors = self.get_cpp_triangulation().get_neighbors()
diff --git a/lib/matplotlib/tri/tricontour.py b/lib/matplotlib/tri/tricontour.py
@@ -206,7 +206,7 @@ def tricontour(ax, *args, **kwargs):
         pixel boundaries. In this case, the position of Z[0, 0]
         is the center of the pixel, not a corner. If *origin* is
         *None*, then (*x0*, *y0*) is the position of Z[0, 0], and
-        (*x1*, *y1*) is the position of Z[-1,-1].
+        (*x1*, *y1*) is the position of Z[-1, -1].
 
         This keyword is not active if *X* and *Y* are specified in
         the call to contour.
diff --git a/lib/matplotlib/tri/triinterpolate.py b/lib/matplotlib/tri/triinterpolate.py
@@ -492,16 +492,16 @@ def _get_alpha_vec(x, y, tris_pts):
         Parameters
         ----------
         x, y : array-like of dim 1 (shape (nx,))
-                  Coordinates of the points whose points barycentric
-                  coordinates are requested
+            Coordinates of the points whose points barycentric coordinates are
+            requested.
         tris_pts : array like of dim 3 (shape: (nx, 3, 2))
-                    Coordinates of the containing triangles apexes.
+            Coordinates of the containing triangles apexes.
 
         Returns
         -------
         alpha : array of dim 2 (shape (nx, 3))
-                 Barycentric coordinates of the points inside the containing
-                 triangles.
+            Barycentric coordinates of the points inside the containing
+            triangles.
         """
         ndim = tris_pts.ndim-2
 
@@ -532,19 +532,19 @@ def _get_jacobian(tris_pts):
         Parameters
         ----------
         tris_pts : array like of dim 3 (shape: (nx, 3, 2))
-                    Coordinates of the containing triangles apexes.
+            Coordinates of the containing triangles apexes.
 
         Returns
         -------
         J : array of dim 3 (shape (nx, 2, 2))
-                 Barycentric coordinates of the points inside the containing
-                 triangles.
-                 J[itri,:,:] is the jacobian matrix at apex 0 of the triangle
-                 itri, so that the following (matrix) relationship holds:
-                    [dz/dksi] = [J] x [dz/dx]
-                    with x: global coordinates
-                    ksi: element parametric coordinates in triangle first apex
-                    local basis.
+            Barycentric coordinates of the points inside the containing
+            triangles.
+            J[itri, :, :] is the jacobian matrix at apex 0 of the triangle
+            itri, so that the following (matrix) relationship holds:
+               [dz/dksi] = [J] x [dz/dx]
+            with x: global coordinates
+                 ksi: element parametric coordinates in triangle first apex
+                 local basis.
         """
         a = np.array(tris_pts[:, 1, :] - tris_pts[:, 0, :])
         b = np.array(tris_pts[:, 2, :] - tris_pts[:, 0, :])
@@ -560,13 +560,13 @@ def _compute_tri_eccentricities(tris_pts):
         Parameters
         ----------
         tris_pts : array like of dim 3 (shape: (nx, 3, 2))
-                   Coordinates of the triangles apexes.
+            Coordinates of the triangles apexes.
 
         Returns
         -------
         ecc : array like of dim 2 (shape: (nx, 3))
-              The so-called eccentricity parameters [1] needed for
-              HCT triangular element.
+            The so-called eccentricity parameters [1] needed for HCT triangular
+            element.
         """
         a = np.expand_dims(tris_pts[:, 2, :] - tris_pts[:, 1, :], axis=2)
         b = np.expand_dims(tris_pts[:, 0, :] - tris_pts[:, 2, :], axis=2)
@@ -1008,8 +1008,8 @@ class _DOF_estimator:
     Abstract base class for classes used to perform estimation of a function
     first derivatives, and deduce the dofs for a CubicTriInterpolator using a
     reduced HCT element formulation.
-    Derived classes implement compute_df(self,**kwargs), returning
-    np.vstack([dfx,dfy]).T where : dfx, dfy are the estimation of the 2
+    Derived classes implement ``compute_df(self, **kwargs)``, returning
+    ``np.vstack([dfx, dfy]).T`` where ``dfx, dfy`` are the estimation of the 2
     gradient coordinates.
     """
     def __init__(self, interpolator, **kwargs):
@@ -1160,7 +1160,7 @@ def compute_geom_grads(self):
         dZ = np.vstack([dZ1, dZ2]).T
         df = np.empty_like(dZ)
 
-        # With np.einsum :  could be ej,eji -> ej
+        # With np.einsum: could be ej,eji -> ej
         df[:, 0] = dZ[:, 0]*dM_inv[:, 0, 0] + dZ[:, 1]*dM_inv[:, 1, 0]
         df[:, 1] = dZ[:, 0]*dM_inv[:, 0, 1] + dZ[:, 1]*dM_inv[:, 1, 1]
         return df
@@ -1585,8 +1585,9 @@ def _extract_submatrices(M, block_indices, block_size, axis):
     Extracts selected blocks of a matrices *M* depending on parameters
     *block_indices* and *block_size*.
 
-    Returns the array of extracted matrices *Mres* so that:
-        M_res[...,ir,:] = M[(block_indices*block_size+ir), :]
+    Returns the array of extracted matrices *Mres* so that ::
+
+        M_res[..., ir, :] = M[(block_indices*block_size+ir), :]
     """
     assert block_indices.ndim == 1
     assert axis in [0, 1]
diff --git a/lib/mpl_toolkits/axisartist/axis_artist.py b/lib/mpl_toolkits/axisartist/axis_artist.py
@@ -42,7 +42,7 @@
 --------------
 
 `AxisArtist`, `AxisLabel`, `TickLabels` have an *axis_direction* attribute,
-which adjusts the location, angle, etc.,. The *axis_direction* must be one of
+which adjusts the location, angle, etc. The *axis_direction* must be one of
 "left", "right", "bottom", "top", and follows the Matplotlib convention for
 rectangular axis.
 
diff --git a/lib/mpl_toolkits/mplot3d/axes3d.py b/lib/mpl_toolkits/mplot3d/axes3d.py
@@ -2490,7 +2490,7 @@ def quiver(self, *args,
             :class:`~matplotlib.collections.LineCollection`
         """
         def calc_arrows(UVW, angle=15):
-            # get unit direction vector perpendicular to (u,v,w)
+            # get unit direction vector perpendicular to (u, v, w)
             x = UVW[:, 0]
             y = UVW[:, 1]
             norm = np.linalg.norm(UVW[:, :2], axis=1)
diff --git a/tutorials/colors/colormap-manipulation.py b/tutorials/colors/colormap-manipulation.py
@@ -155,8 +155,8 @@ def plot_examples(colormaps):
 
 ##############################################################################
 # Of course we need not start from a named colormap, we just need to create
-# the Nx4 array to pass to `.ListedColormap`. Here we  create a
-# colormap that goes from brown (RGB: 90,40,40) to white (RGB: 255,255,255).
+# the Nx4 array to pass to `.ListedColormap`. Here we create a colormap that
+# goes from brown (RGB: 90, 40, 40) to white (RGB: 255, 255, 255).
 
 N = 256
 vals = np.ones((N, 4))
diff --git a/tutorials/colors/colormapnorms.py b/tutorials/colors/colormapnorms.py
diff --git a/tutorials/introductory/usage.py b/tutorials/introductory/usage.py
diff --git a/tutorials/text/pgf.py b/tutorials/text/pgf.py
diff --git a/tutorials/text/usetex.py b/tutorials/text/usetex.py
diff --git a/tutorials/toolkits/axes_grid.py b/tutorials/toolkits/axes_grid.py

Original file line number	Diff line number	Diff line change
`@@ -90,13 +90,13 @@`
`90`	`90`	`function ShowTooltip(obj) {`
`91`	`91`	`var cur = obj.id.split("_")[1];`
`92`	`92`	`var tip = svgDocument.getElementById('mytooltip_' + cur);`
`93`		`- tip.setAttribute('visibility',"visible")`
	`93`	`+ tip.setAttribute('visibility', "visible")`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`function HideTooltip(obj) {`
`97`	`97`	`var cur = obj.id.split("_")[1];`
`98`	`98`	`var tip = svgDocument.getElementById('mytooltip_' + cur);`
`99`		`- tip.setAttribute('visibility',"hidden")`
	`99`	`+ tip.setAttribute('visibility', "hidden")`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`]]>`