@@ -4031,9 +4031,8 @@ def do_plot(xs, ys, **kwargs):
             return self.plot(*[xs, ys][maybe_swap], **kwargs)[0]
 
         def do_patch(xs, ys, **kwargs):
-            path = mpath.Path(
-                # Last (0, 0) vertex has a CLOSEPOLY code and is thus ignored.
-                np.column_stack([[*xs, 0], [*ys, 0]][maybe_swap]), closed=True)
+            path = mpath.Path._create_closed(
+                np.column_stack([xs, ys][maybe_swap]))
             patch = mpatches.PathPatch(path, **kwargs)
             self.add_artist(patch)
             return patch
 
@@ -1217,11 +1217,7 @@ def set_verts(self, verts, closed=True):
         self._paths = []
         for xy in verts:
             if len(xy):
-                if isinstance(xy, np.ma.MaskedArray):
-                    xy = np.ma.concatenate([xy, xy[:1]])
-                else:
-                    xy = np.concatenate([xy, xy[:1]])
-                self._paths.append(mpath.Path(xy, closed=True))
+                self._paths.append(mpath.Path._create_closed(xy))
             else:
                 self._paths.append(mpath.Path(xy))
 
 
@@ -195,8 +195,7 @@ def _set_ticks_on_axis_warn(*args, **kwargs):
 class _ColorbarSpine(mspines.Spine):
     def __init__(self, axes):
         self._ax = axes
-        super().__init__(axes, 'colorbar',
-                         mpath.Path(np.empty((0, 2)), closed=True))
+        super().__init__(axes, 'colorbar', mpath.Path(np.empty((0, 2))))
         mpatches.Patch.set_transform(self, axes.transAxes)
 
     def get_window_extent(self, renderer=None):
 
@@ -571,15 +571,13 @@ def _set_pixel(self):
         self._transform = Affine2D().translate(-0.49999, -0.49999)
         self._snap_threshold = None
 
-    _triangle_path = Path([[0, 1], [-1, -1], [1, -1], [0, 1]], closed=True)
+    _triangle_path = Path._create_closed([[0, 1], [-1, -1], [1, -1]])
     # Going down halfway looks to small.  Golden ratio is too far.
-    _triangle_path_u = Path([[0, 1], [-3/5, -1/5], [3/5, -1/5], [0, 1]],
-                            closed=True)
-    _triangle_path_d = Path(
-        [[-3/5, -1/5], [3/5, -1/5], [1, -1], [-1, -1], [-3/5, -1/5]],
-        closed=True)
-    _triangle_path_l = Path([[0, 1], [0, -1], [-1, -1], [0, 1]], closed=True)
-    _triangle_path_r = Path([[0, 1], [0, -1], [1, -1], [0, 1]], closed=True)
+    _triangle_path_u = Path._create_closed([[0, 1], [-3/5, -1/5], [3/5, -1/5]])
+    _triangle_path_d = Path._create_closed(
+        [[-3/5, -1/5], [3/5, -1/5], [1, -1], [-1, -1]])
+    _triangle_path_l = Path._create_closed([[0, 1], [0, -1], [-1, -1]])
+    _triangle_path_r = Path._create_closed([[0, 1], [0, -1], [1, -1]])
 
     def _set_triangle(self, rot, skip):
         self._transform = Affine2D().scale(0.5).rotate_deg(rot)
@@ -901,14 +899,12 @@ def _set_x(self):
         self._filled = False
         self._path = self._x_path
 
-    _plus_filled_path = Path(
-        np.array([(-1, -3), (+1, -3), (+1, -1), (+3, -1), (+3, +1), (+1, +1),
-                  (+1, +3), (-1, +3), (-1, +1), (-3, +1), (-3, -1), (-1, -1),
-                  (-1, -3)]) / 6, closed=True)
-    _plus_filled_path_t = Path(
-        np.array([(+3, 0), (+3, +1), (+1, +1), (+1, +3),
-                  (-1, +3), (-1, +1), (-3, +1), (-3, 0),
-                  (+3, 0)]) / 6, closed=True)
+    _plus_filled_path = Path._create_closed(np.array([
+        (-1, -3), (+1, -3), (+1, -1), (+3, -1), (+3, +1), (+1, +1),
+        (+1, +3), (-1, +3), (-1, +1), (-3, +1), (-3, -1), (-1, -1)]) / 6)
+    _plus_filled_path_t = Path._create_closed(np.array([
+        (+3, 0), (+3, +1), (+1, +1), (+1, +3),
+        (-1, +3), (-1, +1), (-3, +1), (-3, 0)]) / 6)
 
     def _set_plus_filled(self):
         self._transform = Affine2D()
@@ -924,15 +920,12 @@ def _set_plus_filled(self):
                 {'top': 0, 'left': 90, 'bottom': 180, 'right': 270}[fs])
             self._alt_transform = self._transform.frozen().rotate_deg(180)
 
-    _x_filled_path = Path(
-        np.array([(-1, -2), (0, -1), (+1, -2), (+2, -1), (+1, 0), (+2, +1),
-                  (+1, +2), (0, +1), (-1, +2), (-2, +1), (-1, 0), (-2, -1),
-                  (-1, -2)]) / 4,
-        closed=True)
-    _x_filled_path_t = Path(
-        np.array([(+1, 0), (+2, +1), (+1, +2), (0, +1),
-                  (-1, +2), (-2, +1), (-1, 0), (+1, 0)]) / 4,
-        closed=True)
+    _x_filled_path = Path._create_closed(np.array([
+        (-1, -2), (0, -1), (+1, -2), (+2, -1), (+1, 0), (+2, +1),
+        (+1, +2), (0, +1), (-1, +2), (-2, +1), (-1, 0), (-2, -1)]) / 4)
+    _x_filled_path_t = Path._create_closed(np.array([
+        (+1, 0), (+2, +1), (+1, +2), (0, +1),
+        (-1, +2), (-2, +1), (-1, 0)]) / 4)
 
     def _set_x_filled(self):
         self._transform = Affine2D()
 
@@ -1269,11 +1269,9 @@ class Arrow(Patch):
     def __str__(self):
         return "Arrow()"
 
-    _path = Path([[0.0, 0.1], [0.0, -0.1],
-                  [0.8, -0.1], [0.8, -0.3],
-                  [1.0, 0.0], [0.8, 0.3],
-                  [0.8, 0.1], [0.0, 0.1]],
-                 closed=True)
+    _path = Path._create_closed([
+        [0.0, 0.1], [0.0, -0.1], [0.8, -0.1], [0.8, -0.3], [1.0, 0.0],
+        [0.8, 0.3], [0.8, 0.1]])
 
     @_docstring.dedent_interpd
     @_api.make_keyword_only("3.6", name="width")
@@ -2303,8 +2301,8 @@ def __call__(self, x0, y0, width, height, mutation_size):
             # boundary of the padded box
             x0, y0 = x0 - pad, y0 - pad
             x1, y1 = x0 + width, y0 + height
-            return Path([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)],
-                        closed=True)
+            return Path._create_closed(
+                [(x0, y0), (x1, y0), (x1, y1), (x0, y1)])
 
     @_register_style(_style_list)
     class Circle:
@@ -2353,11 +2351,11 @@ def __call__(self, x0, y0, width, height, mutation_size):
             dxx = dx / 2
             x0 = x0 + pad / 1.4  # adjust by ~sqrt(2)
 
-            return Path([(x0 + dxx, y0), (x1, y0), (x1, y1), (x0 + dxx, y1),
-                         (x0 + dxx, y1 + dxx), (x0 - dx, y0 + dx),
-                         (x0 + dxx, y0 - dxx),  # arrow
-                         (x0 + dxx, y0), (x0 + dxx, y0)],
-                        closed=True)
+            return Path._create_closed(
+                [(x0 + dxx, y0), (x1, y0), (x1, y1), (x0 + dxx, y1),
+                 (x0 + dxx, y1 + dxx), (x0 - dx, y0 + dx),
+                 (x0 + dxx, y0 - dxx),  # arrow
+                 (x0 + dxx, y0)])
 
     @_register_style(_style_list)
     class RArrow(LArrow):
@@ -2397,14 +2395,14 @@ def __call__(self, x0, y0, width, height, mutation_size):
             dxx = dx / 2
             x0 = x0 + pad / 1.4  # adjust by ~sqrt(2)
 
-            return Path([(x0 + dxx, y0), (x1, y0),  # bot-segment
-                         (x1, y0 - dxx), (x1 + dx + dxx, y0 + dx),
-                         (x1, y1 + dxx),  # right-arrow
-                         (x1, y1), (x0 + dxx, y1),  # top-segment
-                         (x0 + dxx, y1 + dxx), (x0 - dx, y0 + dx),
-                         (x0 + dxx, y0 - dxx),  # left-arrow
-                         (x0 + dxx, y0), (x0 + dxx, y0)],  # close-poly
-                        closed=True)
+            return Path._create_closed([
+                (x0 + dxx, y0), (x1, y0),  # bot-segment
+                (x1, y0 - dxx), (x1 + dx + dxx, y0 + dx),
+                (x1, y1 + dxx),  # right-arrow
+                (x1, y1), (x0 + dxx, y1),  # top-segment
+                (x0 + dxx, y1 + dxx), (x0 - dx, y0 + dx),
+                (x0 + dxx, y0 - dxx),  # left-arrow
+                (x0 + dxx, y0)])
 
     @_register_style(_style_list)
     class Round:
 
@@ -188,6 +188,17 @@ def _fast_from_codes_and_verts(cls, verts, codes, internals_from=None):
             pth._interpolation_steps = 1
         return pth
 
+    @classmethod
+    def _create_closed(cls, vertices):
+        """
+        Create a closed polygonal path going through *vertices*.
+
+        Unlike ``Path(..., closed=True)``, *vertices* should **not** end with
+        an entry for the CLOSEPATH; this entry is added by `._create_closed`.
+        """
+        v = _to_unmasked_float_array(vertices)
+        return cls(np.concatenate([v, v[:1]]), closed=True)
+
     def _update_values(self):
         self._simplify_threshold = mpl.rcParams['path.simplify_threshold']
         self._should_simplify = (
 
@@ -296,7 +296,7 @@ def test_marker_as_markerstyle():
     line.set_marker(MarkerStyle("o"))
     fig.canvas.draw()
     # test Path roundtrip
-    triangle1 = Path([[-1., -1.], [1., -1.], [0., 2.], [0., 0.]], closed=True)
+    triangle1 = Path._create_closed([[-1, -1], [1, -1], [0, 2]])
     line2, = ax.plot([1, 3, 2], marker=MarkerStyle(triangle1), ms=22)
     line3, = ax.plot([0, 2, 1], marker=triangle1, ms=22)
 
 
@@ -53,9 +53,7 @@ def test_path_exceptions():
 
 def test_point_in_path():
     # Test #1787
-    verts2 = [(0, 0), (0, 1), (1, 1), (1, 0), (0, 0)]
-
-    path = Path(verts2, closed=True)
+    path = Path._create_closed([(0, 0), (0, 1), (1, 1), (1, 0)])
     points = [(0.5, 0.5), (1.5, 0.5)]
     ret = path.contains_points(points)
     assert ret.dtype == 'bool'
 
@@ -191,8 +191,7 @@ def test_affine_inverted_invalidated():
 
 def test_clipping_of_log():
     # issue 804
-    path = Path([(0.2, -99), (0.4, -99), (0.4, 20), (0.2, 20), (0.2, -99)],
-                closed=True)
+    path = Path._create_closed([(0.2, -99), (0.4, -99), (0.4, 20), (0.2, 20)])
     # something like this happens in plotting logarithmic histograms
     trans = mtransforms.BlendedGenericTransform(
         mtransforms.Affine2D(), scale.LogTransform(10, 'clip'))
 
@@ -160,8 +160,7 @@ def __init__(self, bbox, **kwargs):
     def get_path(self):
         # docstring inherited
         x0, y0, x1, y1 = self.bbox.extents
-        return Path([(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)],
-                    closed=True)
+        return Path._create_closed([(x0, y0), (x1, y0), (x1, y1), (x0, y1)])
 
 
 class BboxConnector(Patch):