CLN: use self.dtype rather than self.categories/ordered in Categorical (pandas-dev#22513)

Author: topper-123

pandas/core/arrays/categorical.py

@@ -499,10 +499,8 @@ def _from_sequence(cls, scalars, dtype=None, copy=False):
 
     def copy(self):
         """ Copy constructor. """
-        return self._constructor(values=self._codes.copy(),
-                                 categories=self.categories,
-                                 ordered=self.ordered,
-                                 fastpath=True)
+        codes = self._codes.copy()
+        return self._constructor(values=codes, dtype=self.dtype, fastpath=True)
 
     def astype(self, dtype, copy=True):
         """
@@ -635,6 +633,7 @@ def from_codes(cls, codes, categories, ordered=False):
             categorical. If not given, the resulting categorical will be
             unordered.
         """
+        dtype = CategoricalDtype(categories, ordered=ordered)
         codes = np.asarray(codes)  # #21767
         if not is_integer_dtype(codes):
             msg = "codes need to be array-like integers"
@@ -649,19 +648,17 @@ def from_codes(cls, codes, categories, ordered=False):
                 raise ValueError(msg)
 
         try:
-            codes = coerce_indexer_dtype(codes, categories)
+            codes = coerce_indexer_dtype(codes, dtype.categories)
         except (ValueError, TypeError):
             raise ValueError(
                 "codes need to be convertible to an arrays of integers")
 
-        categories = CategoricalDtype.validate_categories(categories)
-
-        if len(codes) and (codes.max() >= len(categories) or codes.min() < -1):
+        if len(codes) and (codes.max() >= len(dtype.categories) or
+                           codes.min() < -1):
             raise ValueError("codes need to be between -1 and "
                              "len(categories)-1")
 
-        return cls(codes, categories=categories, ordered=ordered,
-                   fastpath=True)
+        return cls(codes, dtype=dtype, fastpath=True)
 
     _codes = None
 
@@ -1632,8 +1629,8 @@ def sort_values(self, inplace=False, ascending=True, na_position='last'):
             self._codes = codes
             return
         else:
-            return self._constructor(values=codes, categories=self.categories,
-                                     ordered=self.ordered, fastpath=True)
+            return self._constructor(values=codes, dtype=self.dtype,
+                                     fastpath=True)
 
     def _values_for_rank(self):
         """
@@ -1737,15 +1734,15 @@ def fillna(self, value=None, method=None, limit=None):
             raise NotImplementedError("specifying a limit for fillna has not "
                                       "been implemented yet")
 
-        values = self._codes
+        codes = self._codes
 
         # pad / bfill
         if method is not None:
 
-            values = self.to_dense().reshape(-1, len(self))
-            values = interpolate_2d(values, method, 0, None,
-                                    value).astype(self.categories.dtype)[0]
-            values = _get_codes_for_values(values, self.categories)
+            arr = self.to_dense().reshape(-1, len(self))
+            arr = interpolate_2d(arr, method, 0, None,
+                                 value).astype(self.categories.dtype)[0]
+            codes = _get_codes_for_values(arr, self.categories)
 
         else:
 
@@ -1757,28 +1754,26 @@ def fillna(self, value=None, method=None, limit=None):
 
                 values_codes = _get_codes_for_values(value, self.categories)
                 indexer = np.where(values_codes != -1)
-                values[indexer] = values_codes[values_codes != -1]
+                codes[indexer] = values_codes[values_codes != -1]
 
             # If value is not a dict or Series it should be a scalar
             elif is_hashable(value):
                 if not isna(value) and value not in self.categories:
                     raise ValueError("fill value must be in categories")
 
-                mask = values == -1
+                mask = codes == -1
                 if mask.any():
-                    values = values.copy()
+                    codes = codes.copy()
                     if isna(value):
-                        values[mask] = -1
+                        codes[mask] = -1
                     else:
-                        values[mask] = self.categories.get_loc(value)
+                        codes[mask] = self.categories.get_loc(value)
 
             else:
                 raise TypeError('"value" parameter must be a scalar, dict '
                                 'or Series, but you passed a '
                                 '"{0}"'.format(type(value).__name__))
-
-        return self._constructor(values, categories=self.categories,
-                                 ordered=self.ordered, fastpath=True)
+        return self._constructor(codes, dtype=self.dtype, fastpath=True)
 
     def take_nd(self, indexer, allow_fill=None, fill_value=None):
         """
@@ -1823,8 +1818,7 @@ def take_nd(self, indexer, allow_fill=None, fill_value=None):
 
         codes = take(self._codes, indexer, allow_fill=allow_fill,
                      fill_value=fill_value)
-        result = self._constructor(codes, categories=self.categories,
-                                   ordered=self.ordered, fastpath=True)
+        result = self._constructor(codes, dtype=self.dtype, fastpath=True)
         return result
 
     take = take_nd
@@ -1843,9 +1837,8 @@ def _slice(self, slicer):
                                      "categorical")
             slicer = slicer[1]
 
-        _codes = self._codes[slicer]
-        return self._constructor(values=_codes, categories=self.categories,
-                                 ordered=self.ordered, fastpath=True)
+        codes = self._codes[slicer]
+        return self._constructor(values=codes, dtype=self.dtype, fastpath=True)
 
     def __len__(self):
         """The length of this Categorical."""
@@ -2152,14 +2145,12 @@ def mode(self, dropna=True):
         """
 
         import pandas._libs.hashtable as htable
-        values = self._codes
+        codes = self._codes
         if dropna:
             good = self._codes != -1
-            values = self._codes[good]
-        values = sorted(htable.mode_int64(ensure_int64(values), dropna))
-        result = self._constructor(values=values, categories=self.categories,
-                                   ordered=self.ordered, fastpath=True)
-        return result
+            codes = self._codes[good]
+        codes = sorted(htable.mode_int64(ensure_int64(codes), dropna))
+        return self._constructor(codes, dtype=self.dtype, fastpath=True)
 
     def unique(self):
         """
@@ -2298,8 +2289,7 @@ def repeat(self, repeats, *args, **kwargs):
         """
         nv.validate_repeat(args, kwargs)
         codes = self._codes.repeat(repeats)
-        return self._constructor(values=codes, categories=self.categories,
-                                 ordered=self.ordered, fastpath=True)
+        return self._constructor(values=codes, dtype=self.dtype, fastpath=True)
 
     # Implement the ExtensionArray interface
     @property

pandas/core/indexes/category.py

@@ -460,9 +460,7 @@ def where(self, cond, other=None):
             other = self._na_value
         values = np.where(cond, self.values, other)
 
-        cat = Categorical(values,
-                          categories=self.categories,
-                          ordered=self.ordered)
+        cat = Categorical(values, dtype=self.dtype)
         return self._shallow_copy(cat, **self._get_attributes_dict())
 
     def reindex(self, target, method=None, level=None, limit=None,