Changes

Author: topper-123

doc/source/whatsnew/v0.25.0.rst

@@ -370,6 +370,8 @@ Other Deprecations
 - Deprecated the ``units=M`` (months) and ``units=Y`` (year) parameters for ``units`` of :func:`pandas.to_timedelta`, :func:`pandas.Timedelta` and :func:`pandas.TimedeltaIndex` (:issue:`16344`)
 - The :attr:`SparseArray.values` attribute is deprecated. You can use ``np.asarray(...)`` or
   the :meth:`SparseArray.to_dense` method instead (:issue:`26421`).
+- The internal attributes ``_start``, ``_stop`` and ``_step`` attributes of :class:`RangeIndex` have been deprecated.
+  Use the public attributes :attr:`~RangeIndex.start`, :attr:`~RangeIndex.stop` and :attr:`~RangeIndex.step` instead (:issue:`26581`).
 - The functions :func:`pandas.to_datetime` and :func:`pandas.to_timedelta` have deprecated the ``box`` keyword. Instead, use :meth:`to_numpy` or :meth:`Timestamp.to_datetime64` or :meth:`Timedelta.to_timedelta64`. (:issue:`24416`)
 - The :meth:`DataFrame.compound` and :meth:`Series.compound` methods are deprecated and will be removed in a future version (:issue:`26405`).
 

pandas/core/indexes/range.py

@@ -230,7 +230,7 @@ def _start(self):
         The value of the `start` parameter (or ``0`` if this was not supplied)
 
          .. deprecated:: 0.25.0
-            Use ._range.start or .start instead.
+            Use ``.start`` instead.
         """
         return self._range.start
 
@@ -247,7 +247,7 @@ def _stop(self):
         The value of the `stop` parameter
 
          .. deprecated:: 0.25.0
-            Use ._range.stop or .stop instead.
+            Use ``.stop`` instead.
         """
         # GH 25710
         return self._range.stop
@@ -266,7 +266,7 @@ def _step(self):
         The value of the `step` parameter (or ``1`` if this was not supplied)
 
          .. deprecated:: 0.25.0
-            Use ._range.step or .step instead.
+            Use ``.step`` instead.
         """
         # GH 25710
         return self._range.step
@@ -333,8 +333,8 @@ def tolist(self):
     def _shallow_copy(self, values=None, **kwargs):
         if values is None:
             name = kwargs.get("name", self.name)
-            return RangeIndex._simple_new(
-                name=name, **dict(self._get_data_as_items()))
+            return self._simple_new(name=name,
+                                    **dict(self._get_data_as_items()))
         else:
             kwargs.setdefault('name', self.name)
             return self._int64index._shallow_copy(values, **kwargs)
@@ -344,7 +344,7 @@ def copy(self, name=None, deep=False, dtype=None, **kwargs):
         self._validate_dtype(dtype)
         if name is None:
             name = self.name
-        return RangeIndex.from_range(self._range, name=name)
+        return self.from_range(self._range, name=name)
 
     def _minmax(self, meth):
         no_steps = len(self) - 1
@@ -426,7 +426,7 @@ def intersection(self, other, sort=False):
             return super().intersection(other, sort=sort)
 
         if not len(self) or not len(other):
-            return RangeIndex._simple_new(None)
+            return self._simple_new(None)
 
         first = self._range[::-1] if self.step < 0 else self._range
         second = other._range[::-1] if other.step < 0 else other._range
@@ -436,7 +436,7 @@ def intersection(self, other, sort=False):
         int_low = max(first.start, second.start)
         int_high = min(first.stop, second.stop)
         if int_high <= int_low:
-            return RangeIndex._simple_new(None)
+            return self._simple_new(None)
 
         # Method hint: linear Diophantine equation
         # solve intersection problem
@@ -446,20 +446,18 @@ def intersection(self, other, sort=False):
 
         # check whether element sets intersect
         if (first.start - second.start) % gcd:
-            return RangeIndex._simple_new(None)
+            return self._simple_new(None)
 
         # calculate parameters for the RangeIndex describing the
         # intersection disregarding the lower bounds
         tmp_start = first.start + (second.start - first.start) * \
             first.step // gcd * s
         new_step = first.step * second.step // gcd
-        new_index = RangeIndex._simple_new(tmp_start, int_high, new_step)
+        new_index = self._simple_new(tmp_start, int_high, new_step)
 
         # adjust index to limiting interval
         new_start = new_index._min_fitting_element(int_low)
-        new_index = RangeIndex._simple_new(new_start,
-                                           new_index.stop,
-                                           new_index.step)
+        new_index = self._simple_new(new_start, new_index.stop, new_index.step)
 
         if (self.step < 0 and other.step < 0) is not (new_index.step < 0):
             new_index = new_index[::-1]
@@ -538,21 +536,23 @@ def _union(self, other, sort):
                 if ((start_s - start_o) % step_s == 0 and
                         (start_s - end_o) <= step_s and
                         (start_o - end_s) <= step_s):
-                    return RangeIndex(start_r, end_r + step_s, step_s)
+                    return self.__class__(start_r, end_r + step_s, step_s)
                 if ((step_s % 2 == 0) and
                         (abs(start_s - start_o) <= step_s / 2) and
                         (abs(end_s - end_o) <= step_s / 2)):
-                    return RangeIndex(start_r, end_r + step_s / 2, step_s / 2)
+                    return self.__class__(start_r,
+                                          end_r + step_s / 2,
+                                          step_s / 2)
             elif step_o % step_s == 0:
                 if ((start_o - start_s) % step_s == 0 and
                         (start_o + step_s >= start_s) and
                         (end_o - step_s <= end_s)):
-                    return RangeIndex(start_r, end_r + step_s, step_s)
+                    return self.__class__(start_r, end_r + step_s, step_s)
             elif step_s % step_o == 0:
                 if ((start_s - start_o) % step_o == 0 and
                         (start_s + step_o >= start_o) and
                         (end_s - step_o <= end_o)):
-                    return RangeIndex(start_r, end_r + step_o, step_o)
+                    return self.__class__(start_r, end_r + step_o, step_o)
         return self._int64index._union(other, sort=sort)
 
     @Appender(_index_shared_docs['join'])
@@ -601,7 +601,7 @@ def __getitem__(self, key):
                                                            size=len(self)))
         if isinstance(key, slice):
             new_range = self._range[key]
-            return RangeIndex.from_range(new_range, name=self.name)
+            return self.from_range(new_range, name=self.name)
 
         # fall back to Int64Index
         return super_getitem(key)
@@ -617,12 +617,10 @@ def __floordiv__(self, other):
                 start = self.start // other
                 step = self.step // other
                 stop = start + len(self) * step
-                return RangeIndex._simple_new(
-                    start, stop, step, name=self.name)
+                return self._simple_new( start, stop, step, name=self.name)
             if len(self) == 1:
                 start = self.start // other
-                return RangeIndex._simple_new(
-                    start, start + 1, 1, name=self.name)
+                return self._simple_new(start, start + 1, 1, name=self.name)
         return self._int64index // other
 
     @classmethod
@@ -678,7 +676,7 @@ def _evaluate_numeric_binop(self, other):
                         rstart = op(left.start, right)
                         rstop = op(left.stop, right)
 
-                    result = RangeIndex(rstart, rstop, rstep, **attrs)
+                    result = cls(rstart, rstop, rstep, **attrs)
 
                     # for compat with numpy / Int64Index
                     # even if we can represent as a RangeIndex, return