@@ -3691,9 +3691,17 @@ def set_xlim(self, left=None, right=None, emit=True, auto=False,
 
         >>> set_xlim(5000, 0)
         """
-        return self.xaxis._set_lim(
-            left, right, xmin, xmax, emit=emit, auto=auto,
-            names=("left", "right"))
+        if right is None and np.iterable(left):
+            left, right = left
+        if xmin is not None:
+            if left is not None:
+                raise TypeError("Cannot pass both 'left' and 'xmin'")
+            left = xmin
+        if xmax is not None:
+            if right is not None:
+                raise TypeError("Cannot pass both 'right' and 'xmax'")
+            right = xmax
+        return self.xaxis._set_lim(left, right, emit=emit, auto=auto)
 
     get_xscale = _axis_method_wrapper("xaxis", "get_scale")
 
@@ -3955,9 +3963,17 @@ def set_ylim(self, bottom=None, top=None, emit=True, auto=False,
 
         >>> set_ylim(5000, 0)
         """
-        return self.yaxis._set_lim(
-            bottom, top, ymin, ymax, emit=emit, auto=auto,
-            names=("bottom", "top"))
+        if top is None and np.iterable(bottom):
+            bottom, top = bottom
+        if ymin is not None:
+            if bottom is not None:
+                raise TypeError("Cannot pass both 'bottom' and 'ymin'")
+            bottom = ymin
+        if ymax is not None:
+            if top is not None:
+                raise TypeError("Cannot pass both 'top' and 'ymax'")
+            top = ymax
+        return self.yaxis._set_lim(bottom, top, emit=emit, auto=auto)
 
     get_yscale = _axis_method_wrapper("yaxis", "get_scale")
 
 
@@ -1023,40 +1023,27 @@ def set_default_intervals(self):
         # attribute, and the derived code below will check for that
         # and use it if it's available (else just use 0..1)
 
-    def _set_lim(self, v0, v1, alt0=None, alt1=None, *,
-                 emit=True, auto, names=("", "")):
+    def _set_lim(self, v0, v1, *, emit=True, auto):
         """
         Set view limits.
 
         This method is a helper for the Axes ``set_xlim``, ``set_ylim``, and
-        ``set_zlim`` methods.  This docstring uses names corresponding to
-        ``set_xlim`` for simplicity.
+        ``set_zlim`` methods.
 
-        *names* is the pair of the names of the first two parameters of the
-        Axes method (e.g., "left" and "right").  They are only used to generate
-        error messages; and can be empty if the limits are known to be valid.
-
-        Other parameters are directly forwarded from the Axes limits setter:
-        *v0*, *v1*, *alt0*, and *alt1* map to *left*, *right*, *xmin*, and
-        *xmax* respectively; *emit* and *auto* are used as is.
+        Parameters
+        ----------
+        v0, v1 : float
+            The view limits.  (Passing *v0* as a (low, high) pair is not
+            supported; normalization must occur in the Axes setters.)
+        emit : bool, default: True
+            Whether to notify observers of limit change.
+        auto : bool or None, default: False
+            Whether to turn on autoscaling of the x-axis. True turns on, False
+            turns off, None leaves unchanged.
         """
-        v0name, v1name = names  # The value names.
         name, = [name for name, axis in self.axes._get_axis_map().items()
                  if axis is self]  # The axis name.
 
-        if v1 is None and np.iterable(v0):
-            v0, v1 = v0
-        if alt0 is not None:
-            if v0 is not None:
-                raise TypeError(
-                    f"Cannot pass both {v0name!r} and '{name}lim'")
-            v0 = alt0
-        if alt1 is not None:
-            if v1 is not None:
-                raise TypeError(
-                    f"Cannot pass both {v1name!r} and '{name}lim'")
-            v1 = alt1
-
         self.axes._process_unit_info([(name, (v0, v1))], convert=False)
         v0 = self.axes._validate_converted_limits(v0, self.convert_units)
         v1 = self.axes._validate_converted_limits(v1, self.convert_units)
@@ -1075,23 +1062,20 @@ def _set_lim(self, v0, v1, alt0=None, alt1=None, *,
             # so only grab the limits if we really need them.
             old0, old1 = self.get_view_interval()
             if v0 <= 0:
-                _api.warn_external(
-                    f"Attempt to set non-positive {v0name} {name}lim on a "
-                    f"log-scaled axis will be ignored.")
+                _api.warn_external(f"Attempt to set non-positive {name}lim on "
+                                   f"a log-scaled axis will be ignored.")
                 v0 = old0
             if v1 <= 0:
-                _api.warn_external(
-                    f"Attempt to set non-positive {v1name} {name}lim on a "
-                    f"log-scaled axis will be ignored.")
+                _api.warn_external(f"Attempt to set non-positive {name}lim on "
+                                   f"a log-scaled axis will be ignored.")
                 v1 = old1
         if v0 == v1:
             _api.warn_external(
-                f"Attempting to set identical {v0name} == {v1name} == {v0} "
+                f"Attempting to set identical low and high {name}lims "
                 f"makes transformation singular; automatically expanding.")
-        reverse = v0 > v1
+        reverse = bool(v0 > v1)  # explicit cast needed for python3.8+np.bool_.
         v0, v1 = self.get_major_locator().nonsingular(v0, v1)
         v0, v1 = self.limit_range_for_scale(v0, v1)
-        # cast to bool to avoid bad interaction between python 3.8 and np.bool_
         v0, v1 = sorted([v0, v1], reverse=bool(reverse))
 
         self.set_view_interval(v0, v1, ignore=True)
@@ -1107,7 +1091,7 @@ def _set_lim(self, v0, v1, alt0=None, alt1=None, *,
             for other in self.axes._shared_axes[name].get_siblings(self.axes):
                 if other is not self.axes:
                     other._get_axis_map()[name]._set_lim(
-                        v0, v1, emit=False, auto=auto, names=names)
+                        v0, v1, emit=False, auto=auto)
                     if other.figure != self.figure:
                         other.figure.canvas.draw_idle()
 
 
@@ -42,7 +42,7 @@
 
 @docstring.interpd
 @cbook._define_aliases({
-    "xlim3d": ["xlim"], "ylim3d": ["ylim"], "zlim3d": ["zlim"]})
+    "xlim": ["xlim3d"], "ylim": ["ylim3d"], "zlim": ["zlim3d"]})
 class Axes3D(Axes):
     """
     3D Axes object.
@@ -659,48 +659,39 @@ def get_w_lims(self):
         minz, maxz = self.get_zlim3d()
         return minx, maxx, miny, maxy, minz, maxz
 
-    def set_xlim3d(self, left=None, right=None, emit=True, auto=False,
-                   *, xmin=None, xmax=None):
-        """
-        Set 3D x limits.
-
-        See `.Axes.set_xlim` for full documentation.
-        """
-        return self.xaxis._set_lim(
-            left, right, xmin, xmax, emit=emit, auto=auto,
-            names=("left", "right"))
-
-    def set_ylim3d(self, bottom=None, top=None, emit=True, auto=False,
-                   *, ymin=None, ymax=None):
-        """
-        Set 3D y limits.
-
-        See `.Axes.set_ylim` for full documentation.
-        """
-        return self.yaxis._set_lim(
-            bottom, top, ymin, ymax, emit=emit, auto=auto,
-            names=("bottom", "top"))
-
-    def set_zlim3d(self, bottom=None, top=None, emit=True, auto=False,
-                   *, zmin=None, zmax=None):
+    # set_xlim, set_ylim are directly inherited from base Axes.
+    def set_zlim(self, bottom=None, top=None, emit=True, auto=False,
+                 *, zmin=None, zmax=None):
         """
         Set 3D z limits.
 
         See `.Axes.set_ylim` for full documentation
         """
-        return self.zaxis._set_lim(
-            bottom, top, zmin, zmax, emit=emit, auto=auto,
-            names=("bottom", "top"))
-
-    def get_xlim3d(self):
+        if top is None and np.iterable(bottom):
+            bottom, top = bottom
+        if zmin is not None:
+            if bottom is not None:
+                raise TypeError("Cannot pass both 'bottom' and 'zmin'")
+            bottom = zmin
+        if zmax is not None:
+            if top is not None:
+                raise TypeError("Cannot pass both 'top' and 'zmax'")
+            top = zmax
+        return self.zaxis._set_lim(bottom, top, emit=emit, auto=auto)
+
+    set_xlim3d = maxes.Axes.set_xlim
+    set_ylim3d = maxes.Axes.set_ylim
+    set_zlim3d = set_zlim
+
+    def get_xlim(self):
+        # docstring inherited
         return tuple(self.xy_viewLim.intervalx)
-    get_xlim3d.__doc__ = maxes.Axes.get_xlim.__doc__
 
-    def get_ylim3d(self):
+    def get_ylim(self):
+        # docstring inherited
         return tuple(self.xy_viewLim.intervaly)
-    get_ylim3d.__doc__ = maxes.Axes.get_ylim.__doc__
 
-    def get_zlim3d(self):
+    def get_zlim(self):
         """Get 3D z limits."""
         return tuple(self.zz_viewLim.intervalx)