CLN refactor core indexes

pandas/core/indexes/api.py

@@ -282,7 +282,4 @@ def all_indexes_same(indexes):
     """
     itr = iter(indexes)
     first = next(itr)
-    for index in itr:
-        if not first.equals(index):
-            return False
-    return True
+    return all(first.equals(index) for index in itr)

pandas/core/indexes/base.py

@@ -114,7 +114,7 @@
     unique="Index",
     duplicated="np.ndarray",
 )
-_index_shared_docs = dict()
+_index_shared_docs = {}
 str_t = str
 
 
@@ -901,9 +901,7 @@ def __repr__(self) -> str_t:
         if data is None:
             data = ""
 
-        res = f"{klass_name}({data}{prepr})"
-
-        return res
+        return f"{klass_name}({data}{prepr})"
 
     def _format_space(self) -> str_t:
 
@@ -982,7 +980,6 @@ def _format_with_header(
         if is_object_dtype(values.dtype):
             values = lib.maybe_convert_objects(values, safe=1)
 
-        if is_object_dtype(values.dtype):
             result = [pprint_thing(x, escape_chars=("\t", "\r", "\n")) for x in values]
 
             # could have nans
@@ -1583,7 +1580,7 @@ def _drop_level_numbers(self, levnums: List[int]):
         Drop MultiIndex levels by level _number_, not name.
         """
 
-        if len(levnums) == 0:
+        if not levnums:
             return self
         if len(levnums) >= self.nlevels:
             raise ValueError(
@@ -3120,7 +3117,7 @@ def get_indexer(
                 "Reindexing only valid with uniquely valued Index objects"
             )
 
-        if method == "pad" or method == "backfill":
+        if method in ["pad", "backfill"]:
             indexer = self._get_fill_indexer(target, method, limit, tolerance)
         elif method == "nearest":
             indexer = self._get_nearest_indexer(target, limit, tolerance)
@@ -3233,8 +3230,7 @@ def _filter_indexer_tolerance(
         tolerance,
     ) -> np.ndarray:
         distance = abs(self._values[indexer] - target)
-        indexer = np.where(distance <= tolerance, indexer, -1)
-        return indexer
+        return np.where(distance <= tolerance, indexer, -1)
 
     # --------------------------------------------------------------------
     # Indexer Conversion Methods
@@ -3343,9 +3339,7 @@ def _convert_listlike_indexer(self, keyarr):
         keyarr : numpy.ndarray
             Return tuple-safe keys.
         """
-        if isinstance(keyarr, Index):
-            pass
-        else:
+        if not isinstance(keyarr, Index):
             keyarr = self._convert_arr_indexer(keyarr)
 
         indexer = self._convert_list_indexer(keyarr)
@@ -3364,8 +3358,7 @@ def _convert_arr_indexer(self, keyarr):
         -------
         converted_keyarr : array-like
         """
-        keyarr = com.asarray_tuplesafe(keyarr)
-        return keyarr
+        return com.asarray_tuplesafe(keyarr)
 
     def _convert_list_indexer(self, keyarr):
         """
@@ -3737,9 +3730,8 @@ def _join_multi(self, other, how, return_indexers=True):
             other, level, how=how, return_indexers=return_indexers
         )
 
-        if flip_order:
-            if isinstance(result, tuple):
-                return result[0], result[2], result[1]
+        if flip_order and isinstance(result, tuple):
+            return result[0], result[2], result[1]
         return result
 
     @final
@@ -4284,7 +4276,7 @@ def append(self, other):
         to_concat = [self]
 
         if isinstance(other, (list, tuple)):
-            to_concat = to_concat + list(other)
+            to_concat += list(other)
         else:
             to_concat.append(other)
 
@@ -4773,9 +4765,7 @@ def _should_fallback_to_positional(self) -> bool:
         """
         Should an integer key be treated as positional?
         """
-        if self.holds_integer() or self.is_boolean():
-            return False
-        return True
+        return not self.holds_integer() and not self.is_boolean()
 
     def _get_values_for_loc(self, series: "Series", loc, key):
         """
@@ -5168,11 +5158,7 @@ def _validate_indexer(self, form: str_t, key, kind: str_t):
         """
         assert kind in ["getitem", "iloc"]
 
-        if key is None:
-            pass
-        elif is_integer(key):
-            pass
-        else:
+        if key is not None and not is_integer(key):
             self._invalid_indexer(form, key)
 
     def _maybe_cast_slice_bound(self, label, side: str_t, kind):
@@ -5471,9 +5457,10 @@ def _cmp_method(self, other, op):
         """
         Wrapper used to dispatch comparison operations.
         """
-        if isinstance(other, (np.ndarray, Index, ABCSeries, ExtensionArray)):
-            if len(self) != len(other):
-                raise ValueError("Lengths must match to compare")
+        if isinstance(other, (np.ndarray, Index, ABCSeries, ExtensionArray)) and (
+            len(self) != len(other)
+        ):
+            raise ValueError("Lengths must match to compare")
 
         if not isinstance(other, ABCMultiIndex):
             other = extract_array(other, extract_numpy=True)
@@ -5795,7 +5782,7 @@ def trim_front(strings: List[str]) -> List[str]:
     Trims zeros and decimal points.
     """
     trimmed = strings
-    while len(strings) > 0 and all(x[0] == " " for x in trimmed):
+    while trimmed and all(x.startswith(" ") for x in trimmed):
         trimmed = [x[1:] for x in trimmed]
     return trimmed
 
@@ -5865,15 +5852,11 @@ def _maybe_cast_with_dtype(data: np.ndarray, dtype: np.dtype, copy: bool) -> np.
             except ValueError:
                 data = np.array(data, dtype=np.float64, copy=copy)
 
-        elif inferred == "string":
-            pass
-        else:
+        elif inferred != "string":
             data = data.astype(dtype)
     elif is_float_dtype(dtype):
         inferred = lib.infer_dtype(data, skipna=False)
-        if inferred == "string":
-            pass
-        else:
+        if inferred != "string":
             data = data.astype(dtype)
     else:
         data = np.array(data, dtype=dtype, copy=copy)

pandas/core/indexes/category.py

@@ -530,7 +530,7 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
         if self.is_unique and self.equals(target):
             return np.arange(len(self), dtype="intp")
 
-        if method == "pad" or method == "backfill":
+        if method in ["pad", "backfill"]:
             raise NotImplementedError(
                 "method='pad' and method='backfill' not "
                 "implemented yet for CategoricalIndex"

pandas/core/indexes/datetimelike.py

@@ -237,22 +237,17 @@ def min(self, axis=None, skipna=True, *args, **kwargs):
             return self._na_value
 
         i8 = self.asi8
-        try:
-            # quick check
-            if len(i8) and self.is_monotonic:
-                if i8[0] != iNaT:
-                    return self._data._box_func(i8[0])
-
-            if self.hasnans:
-                if skipna:
-                    min_stamp = self[~self._isnan].asi8.min()
-                else:
-                    return self._na_value
-            else:
-                min_stamp = i8.min()
-            return self._data._box_func(min_stamp)
-        except ValueError:
+
+        # quick check
+        if self.is_monotonic and i8[0] != iNaT:
+            return self._data._box_func(i8[0])
+        if self.hasnans and skipna and not self[~self._isnan].empty:
+            min_stamp = self[~self._isnan].asi8.min()
+        elif not self.hasnans:
+            min_stamp = i8.min()
+        else:
             return self._na_value
+        return self._data._box_func(min_stamp)
 
     def argmin(self, axis=None, skipna=True, *args, **kwargs):
         """
@@ -294,22 +289,17 @@ def max(self, axis=None, skipna=True, *args, **kwargs):
             return self._na_value
 
         i8 = self.asi8
-        try:
-            # quick check
-            if len(i8) and self.is_monotonic:
-                if i8[-1] != iNaT:
-                    return self._data._box_func(i8[-1])
-
-            if self.hasnans:
-                if skipna:
-                    max_stamp = self[~self._isnan].asi8.max()
-                else:
-                    return self._na_value
-            else:
-                max_stamp = i8.max()
-            return self._data._box_func(max_stamp)
-        except ValueError:
+
+        # quick check
+        if self.is_monotonic and i8[-1] != iNaT:
+            return self._data._box_func(i8[-1])
+        if self.hasnans and skipna and not self[~self._isnan].empty:
+            max_stamp = self[~self._isnan].asi8.max()
+        elif not self.hasnans:
+            max_stamp = i8.max()
+        else:
             return self._na_value
+        return self._data._box_func(max_stamp)
 
     def argmax(self, axis=None, skipna=True, *args, **kwargs):
         """
@@ -572,9 +562,12 @@ def _get_delete_freq(self, loc: int):
                     loc = lib.maybe_indices_to_slice(
                         np.asarray(loc, dtype=np.intp), len(self)
                     )
-                if isinstance(loc, slice) and loc.step in (1, None):
-                    if loc.start in (0, None) or loc.stop in (len(self), None):
-                        freq = self.freq
+                if (
+                    isinstance(loc, slice)
+                    and loc.step in (1, None)
+                    and (loc.start in (0, None) or loc.stop in (len(self), None))
+                ):
+                    freq = self.freq
         return freq
 
     def _get_insert_freq(self, loc, item):
@@ -592,7 +585,7 @@ def _get_insert_freq(self, loc, item):
             if self.size:
                 if item is NaT:
                     pass
-                elif (loc == 0 or loc == -len(self)) and item + self.freq == self[0]:
+                elif loc in [0, -len(self)] and item + self.freq == self[0]:
                     freq = self.freq
                 elif (loc == len(self)) and item - self.freq == self[-1]:
                     freq = self.freq
@@ -677,8 +670,7 @@ def _shallow_copy(self, values=None, name: Label = lib.no_default):
 
     @Appender(Index.difference.__doc__)
     def difference(self, other, sort=None):
-        new_idx = super().difference(other, sort=sort)._with_freq(None)
-        return new_idx
+        return super().difference(other, sort=sort)._with_freq(None)
 
     def intersection(self, other, sort=False):
         """
@@ -720,10 +712,9 @@ def intersection(self, other, sort=False):
 
         if not isinstance(other, type(self)):
             result = Index.intersection(self, other, sort=sort)
-            if isinstance(result, type(self)):
-                if result.freq is None:
-                    # TODO: no tests rely on this; needed?
-                    result = result._with_freq("infer")
+            if isinstance(result, type(self)) and result.freq is None:
+                # TODO: no tests rely on this; needed?
+                result = result._with_freq("infer")
             return result
 
         elif not self._can_fast_intersect(other):
@@ -869,13 +860,13 @@ def _union(self, other, sort):
             elif result.freq is None:
                 # TODO: no tests rely on this; needed?
                 result = result._with_freq("infer")
-            return result
         else:
             i8self = Int64Index._simple_new(self.asi8)
             i8other = Int64Index._simple_new(other.asi8)
             i8result = i8self._union(i8other, sort=sort)
             result = type(self)(i8result, dtype=self.dtype, freq="infer")
-            return result
+
+        return result
 
     # --------------------------------------------------------------------
     # Join Methods

pandas/core/indexes/datetimes.py

@@ -425,12 +425,13 @@ def _maybe_utc_convert(self, other: Index) -> Tuple["DatetimeIndex", Index]:
         this = self
 
         if isinstance(other, DatetimeIndex):
-            if self.tz is not None:
-                if other.tz is None:
-                    raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
-            elif other.tz is not None:
+            if (
+                (self.tz is not None)
+                and (other.tz is None)
+                or (self.tz is None)
+                and (other.tz is not None)
+            ):
                 raise TypeError("Cannot join tz-naive with tz-aware DatetimeIndex")
-
             if not timezones.tz_compare(self.tz, other.tz):
                 this = self.tz_convert("UTC")
                 other = other.tz_convert("UTC")
@@ -758,8 +759,7 @@ def _get_string_slice(self, key: str):
         freq = getattr(self, "freqstr", getattr(self, "inferred_freq", None))
         parsed, reso = parsing.parse_time_string(key, freq)
         reso = Resolution.from_attrname(reso)
-        loc = self._partial_date_slice(reso, parsed)
-        return loc
+        return self._partial_date_slice(reso, parsed)
 
     def slice_indexer(self, start=None, end=None, step=None, kind=None):
         """
@@ -822,7 +822,7 @@ def slice_indexer(self, start=None, end=None, step=None, kind=None):
     # --------------------------------------------------------------------
 
     def is_type_compatible(self, typ) -> bool:
-        return typ == self.inferred_type or typ == "datetime"
+        return typ in [self.inferred_type, "datetime"]
 
     @property
     def inferred_type(self) -> str: