Merge pull request #426 from s-banach/pandas-lints

Pandas lints

Author: PaulWestenthanner

category_encoders/base_contrast_encoder.py

@@ -86,14 +86,14 @@ def _transform(self, X) -> pd.DataFrame:
         return X
 
     @abstractmethod
-    def get_contrast_matrix(self, values_to_encode: np.array) -> ContrastMatrix:
+    def get_contrast_matrix(self, values_to_encode: np.ndarray) -> ContrastMatrix:
         raise NotImplementedError
 
     def fit_contrast_coding(self, col, values, handle_missing, handle_unknown):
         if handle_missing == 'value':
             values = values[values > 0]
 
-        values_to_encode = values.values
+        values_to_encode = values.to_numpy()
 
         if len(values) < 2:
             return pd.DataFrame(index=values_to_encode)
@@ -119,7 +119,7 @@ def fit_contrast_coding(self, col, values, handle_missing, handle_unknown):
 
     @staticmethod
     def transform_contrast_coding(X, mapping):
-        cols = X.columns.values.tolist()
+        cols = X.columns.tolist()
 
         # See issue 370 if it is necessary to add an intercept or not.
         X['intercept'] = pd.Series([1] * X.shape[0], index=X.index)
@@ -132,7 +132,7 @@ def transform_contrast_coding(X, mapping):
 
             # reindex actually applies the mapping
             base_df = mod.reindex(X[col])
-            base_df.set_index(X.index, inplace=True)
+            base_df = base_df.set_index(X.index)
             X = pd.concat([base_df, X], axis=1)
 
             old_column_index = cols.index(col)

category_encoders/basen.py

@@ -188,20 +188,20 @@ def inverse_transform(self, X_in):
                 raise ValueError(f'Unexpected input dimension {X.shape[1]}, expected {self._dim}')
 
         if not list(self.cols):
-            return X if self.return_df else X.values
+            return X if self.return_df else X.to_numpy()
 
         for switch in self.ordinal_encoder.mapping:
             column_mapping = switch.get('mapping')
-            inverse = pd.Series(data=column_mapping.index, index=column_mapping.values)
+            inverse = pd.Series(data=column_mapping.index, index=column_mapping.array)
             X[switch.get('col')] = X[switch.get('col')].map(inverse).astype(switch.get('data_type'))
 
             if self.handle_unknown == 'return_nan' and self.handle_missing == 'return_nan':
                 for col in self.cols:
-                    if X[switch.get('col')].isnull().any():
+                    if X[switch.get('col')].isna().any():
                         warnings.warn("inverse_transform is not supported because transform impute "
                                       f"the unknown category nan when encode {col}")
 
-        return X if self.return_df else X.values
+        return X if self.return_df else X.to_numpy()
 
     def calc_required_digits(self, values):
         # figure out how many digits we need to represent the classes present
@@ -212,7 +212,7 @@ def calc_required_digits(self, values):
 
         return digits
 
-    def basen_encode(self, X_in, cols=None):
+    def basen_encode(self, X_in: pd.DataFrame, cols=None):
         """
         Basen encoding encodes the integers as basen code with one column per digit.
 
@@ -230,22 +230,22 @@ def basen_encode(self, X_in, cols=None):
 
         X = X_in.copy(deep=True)
 
-        cols = X.columns.values.tolist()
+        cols = X.columns.tolist()
 
         for switch in self.mapping:
             col = switch.get('col')
             mod = switch.get('mapping')
 
             base_df = mod.reindex(X[col])
-            base_df.set_index(X.index, inplace=True)
+            base_df = base_df.set_index(X.index)
             X = pd.concat([base_df, X], axis=1)
 
             old_column_index = cols.index(col)
             cols[old_column_index: old_column_index + 1] = mod.columns
 
         return X.reindex(columns=cols)
 
-    def basen_to_integer(self, X, cols, base):
+    def basen_to_integer(self, X: pd.DataFrame, cols, base):
         """
         Convert basen code as integers.
 
@@ -263,7 +263,7 @@ def basen_to_integer(self, X, cols, base):
         numerical: DataFrame
 
         """
-        out_cols = X.columns.values.tolist()
+        out_cols = X.columns.tolist()
 
         for col in cols:
             col_list = [col0 for col0 in out_cols if re.match(re.escape(str(col))+'_\\d+', str(col0))]
@@ -275,8 +275,8 @@ def basen_to_integer(self, X, cols, base):
                 len0 = len(col_list)
                 value_array = np.array([base ** (len0 - 1 - i) for i in range(len0)])
             X.insert(insert_at, col, np.dot(X[col_list].values, value_array.T))
-            X.drop(col_list, axis=1, inplace=True)
-            out_cols = X.columns.values.tolist()
+            X = X.drop(col_list, axis=1)
+            out_cols = X.columns.tolist()
 
         return X
 

category_encoders/cat_boost.py

@@ -121,7 +121,7 @@ def _transform(self, X, y=None):
             unique_train = colmap.index
             unseen_values = pd.Series([x for x in X[col].unique() if x not in unique_train], dtype=unique_train.dtype)
 
-            is_nan = X[col].isnull()
+            is_nan = X[col].isna()
             is_unknown_value = X[col].isin(unseen_values.dropna().astype(object))
 
             if self.handle_unknown == 'error' and is_unknown_value.any():
@@ -153,7 +153,7 @@ def _transform(self, X, y=None):
             if self.handle_missing == 'value':
                 # only set value if there are actually missing values.
                 # In case of pd.Categorical columns setting values that are not seen in pd.Categorical gives an error.
-                nan_cond = is_nan & unseen_values.isnull().any()
+                nan_cond = is_nan & unseen_values.isna().any()
                 if nan_cond.any():
                     X.loc[nan_cond, col] = self._mean
             elif self.handle_missing == 'return_nan':

category_encoders/count.py

@@ -154,11 +154,11 @@ def _transform(self, X):
                   and X[col].isna().any()
                   and self._handle_missing[col] != 'return_nan'
             ):
-                X[col].replace(np.nan, 0, inplace=True)
+                X[col] = X[col].replace(np.nan, 0)
 
             elif (
                     self._handle_unknown[col] == 'error'
-                    and X[col].isnull().any()
+                    and X[col].isna().any()
             ):
                 raise ValueError(f'Missing data found in column {col} at transform time.')
         return X
@@ -168,7 +168,7 @@ def _fit_count_encode(self, X_in, y):
         X = X_in.copy(deep=True)
 
         if self.cols is None:
-            self.cols = X.columns.values
+            self.cols = X.columns
 
         self.mapping = {}
 
@@ -202,20 +202,20 @@ def combine_min_categories(self, X):
             elif self._combine_min_nan_groups[col] == 'force':
                 min_groups_idx = (
                     (mapper < self._min_group_size[col])
-                    | (mapper.index.isnull())
+                    | (mapper.index.isna())
                 )
             else:
                 min_groups_idx = (
                     (mapper < self._min_group_size[col])
-                    & (~mapper.index.isnull())
+                    & (~mapper.index.isna())
                 )
 
             min_groups_sum = mapper.loc[min_groups_idx].sum()
 
             if (
                 min_groups_sum > 0
                 and min_groups_idx.sum() > 1
-                and not min_groups_idx.loc[~min_groups_idx.index.isnull()].all()
+                and not min_groups_idx.loc[~min_groups_idx.index.isna()].all()
             ):
                 if isinstance(self._min_group_name[col], str):
                     min_group_mapper_name = self._min_group_name[col]

category_encoders/gray.py

@@ -91,7 +91,7 @@ def _fit(self, X, y=None, **kwargs):
             col = col_to_encode["col"]
             bin_mapping = col_to_encode["mapping"]
             n_cols_out = bin_mapping.shape[1]
-            null_cond = (bin_mapping.index < 0) | (bin_mapping.isnull().all(1))
+            null_cond = (bin_mapping.index < 0) | (bin_mapping.isna().all(1))
             map_null = bin_mapping[null_cond]
             map_non_null = bin_mapping[~null_cond].copy()
             ordinal_mapping = [m for m in self.ordinal_encoder.mapping if m.get("col") == col]

category_encoders/hashing.py

@@ -246,7 +246,7 @@ def _transform_single_cpu(self, X, override_return_df=False):
         if self.return_df or override_return_df:
             return X
         else:
-            return X.values
+            return X.to_numpy()
 
     @staticmethod
     def hashing_trick(X_in, hashing_method='md5', N=2, cols=None, make_copy=False):
@@ -294,11 +294,11 @@ def hashing_trick(X_in, hashing_method='md5', N=2, cols=None, make_copy=False):
             X = X_in
 
         if cols is None:
-            cols = X.columns.values
+            cols = X.columns
 
         def hash_fn(x):
             tmp = [0 for _ in range(N)]
-            for val in x.values:
+            for val in x.array:
                 if val is not None:
                     hasher = hashlib.new(hashing_method)
                     if sys.version_info[0] == 2:
@@ -311,7 +311,7 @@ def hash_fn(x):
         new_cols = [f'col_{d}' for d in range(N)]
 
         X_cat = X.loc[:, cols]
-        X_num = X.loc[:, [x for x in X.columns.values if x not in cols]]
+        X_num = X.loc[:, [x for x in X.columns if x not in cols]]
 
         X_cat = X_cat.apply(hash_fn, axis=1, result_type='expand')
         X_cat.columns = new_cols

category_encoders/james_stein.py

@@ -169,7 +169,7 @@ def _fit(self, X, y, **kwargs):
             unique = y.unique()
             if len(unique) != 2:
                 raise ValueError("The target column y must be binary. But the target contains " + str(len(unique)) + " unique value(s).")
-            if y.isnull().any():
+            if y.isna().any():
                 raise ValueError("The target column y must not contain missing values.")
             if np.max(unique) < 1:
                 raise ValueError("The target column y must be binary with values {0, 1}. Value 1 was not found in the target.")
@@ -357,7 +357,7 @@ def get_best_sigma(sigma, mu_k, sigma_k, K):
             crosstable['E-A+'] = stats['count'] - stats['sum']
             crosstable['E+A-'] = global_sum - stats['sum']
             crosstable['E+A+'] = stats['sum']
-            index = crosstable.index.values
+            index = crosstable.index
             crosstable = np.array(crosstable, dtype=np.float32)  # The argument unites the types into float
 
             # Count of contingency tables.

category_encoders/leave_one_out.py

@@ -110,7 +110,7 @@ def fit_leave_one_out(self, X_in, y, cols=None):
         X = X_in.copy(deep=True)
 
         if cols is None:
-            cols = X.columns.values
+            cols = X.columns
 
         self._mean = y.mean()
 
@@ -143,7 +143,7 @@ def transform_leave_one_out(self, X, y, mapping=None):
             unique_train = colmap.index
             unseen_values = pd.Series([x for x in X[col].unique() if x not in unique_train], dtype=unique_train.dtype)
 
-            is_nan = X[col].isnull()
+            is_nan = X[col].isna()
             is_unknown_value = X[col].isin(unseen_values.dropna().astype(object))
 
             if X[col].dtype.name == 'category': # Pandas 0.24 tries hard to preserve categorical data type
@@ -161,15 +161,15 @@ def transform_leave_one_out(self, X, y, mapping=None):
                 # excluding this row's y, it's (sum - y) / (count - 1)
                 level_means = (X[col].map(colmap['sum']) - y) / (X[col].map(colmap['count']) - 1)
                 # The 'where' fills in singleton levels (count = 1 -> div by 0) with the global mean
-                X[col] = level_means.where(X[col].map(colmap['count'][level_notunique]).notnull(), self._mean)
+                X[col] = level_means.where(X[col].map(colmap['count'][level_notunique]).notna(), self._mean)
 
             if self.handle_unknown == 'value':
                 X.loc[is_unknown_value, col] = self._mean
             elif self.handle_unknown == 'return_nan':
                 X.loc[is_unknown_value, col] = np.nan
 
             if self.handle_missing == 'value':
-                X.loc[is_nan & unseen_values.isnull().any(), col] = self._mean
+                X.loc[is_nan & unseen_values.isna().any(), col] = self._mean
             elif self.handle_missing == 'return_nan':
                 X.loc[is_nan, col] = np.nan
 

category_encoders/one_hot.py

@@ -227,7 +227,7 @@ def inverse_transform(self, X_in):
                 raise ValueError(f'Unexpected input dimension {X.shape[1]}, expected {self._dim}')
 
         if not list(self.cols):
-            return X if self.return_df else X.values
+            return X if self.return_df else X.to_numpy()
 
         for switch in self.ordinal_encoder.mapping:
             column_mapping = switch.get('mapping')
@@ -236,11 +236,11 @@ def inverse_transform(self, X_in):
 
             if self.handle_unknown == 'return_nan' and self.handle_missing == 'return_nan':
                 for col in self.cols:
-                    if X[switch.get('col')].isnull().any():
+                    if X[switch.get('col')].isna().any():
                         warnings.warn("inverse_transform is not supported because transform impute "
                                       f"the unknown category nan when encode {col}")
 
-        return X if self.return_df else X.values
+        return X if self.return_df else X.to_numpy()
 
     def get_dummies(self, X_in):
         """
@@ -258,7 +258,7 @@ def get_dummies(self, X_in):
 
         X = X_in.copy(deep=True)
 
-        cols = X.columns.values.tolist()
+        cols = X.columns.tolist()
 
         for switch in self.mapping:
             col = switch.get('col')
@@ -290,7 +290,7 @@ def reverse_dummies(self, X, mapping):
         numerical: DataFrame
 
         """
-        out_cols = X.columns.values.tolist()
+        out_cols = X.columns.tolist()
         mapped_columns = []
         for switch in mapping:
             col = switch.get('col')
@@ -304,7 +304,7 @@ def reverse_dummies(self, X, mapping):
                 val = positive_indexes[i]
                 X.loc[X[existing_col] == 1, col] = val
                 mapped_columns.append(existing_col)
-            X.drop(mod.columns, axis=1, inplace=True)
-            out_cols = X.columns.values.tolist()
+            X = X.drop(mod.columns, axis=1)
+            out_cols = X.columns.tolist()
 
         return X

category_encoders/ordinal.py

@@ -151,7 +151,7 @@ def inverse_transform(self, X_in):
                 raise ValueError(f'Unexpected input dimension {X.shape[1]}, expected {self._dim}')
 
         if not list(self.cols):
-            return X if self.return_df else X.values
+            return X if self.return_df else X.to_numpy()
 
         if self.handle_unknown == 'value':
             for col in self.cols:
@@ -161,7 +161,7 @@ def inverse_transform(self, X_in):
 
         if self.handle_unknown == 'return_nan' and self.handle_missing == 'return_nan':
             for col in self.cols:
-                if X[col].isnull().any():
+                if X[col].isna().any():
                     warnings.warn("inverse_transform is not supported because transform impute "
                                   f"the unknown category nan when encode {col}")
 
@@ -170,7 +170,7 @@ def inverse_transform(self, X_in):
             inverse = pd.Series(data=column_mapping.index, index=column_mapping.values)
             X[switch.get('col')] = X[switch.get('col')].map(inverse).astype(switch.get('data_type'))
 
-        return X if self.return_df else X.values
+        return X if self.return_df else X.to_numpy()
 
     @staticmethod
     def ordinal_encoding(X_in, mapping=None, cols=None, handle_unknown='value', handle_missing='value'):
@@ -185,7 +185,7 @@ def ordinal_encoding(X_in, mapping=None, cols=None, handle_unknown='value', hand
         X = X_in.copy(deep=True)
 
         if cols is None:
-            cols = X.columns.values
+            cols = X.columns
 
         if mapping is not None:
             mapping_out = mapping
@@ -197,7 +197,7 @@ def ordinal_encoding(X_in, mapping=None, cols=None, handle_unknown='value', hand
                 X[column] = pd.Series([el if el is not None else np.NaN for el in X[column]], index=X[column].index)
                 X[column] = X[column].map(col_mapping)
                 if util.is_category(X[column].dtype):
-                    nan_identity = col_mapping.loc[col_mapping.index.isna()].values[0]
+                    nan_identity = col_mapping.loc[col_mapping.index.isna()].array[0]
                     X[column] = X[column].cat.add_categories(nan_identity)
                     X[column] = X[column].fillna(nan_identity)
                 try:
@@ -206,9 +206,9 @@ def ordinal_encoding(X_in, mapping=None, cols=None, handle_unknown='value', hand
                     X[column] = X[column].astype(float)
 
                 if handle_unknown == 'value':
-                    X[column].fillna(-1, inplace=True)
+                    X[column] = X[column].fillna(-1)
                 elif handle_unknown == 'error':
-                    missing = X[column].isnull()
+                    missing = X[column].isna()
                     if any(missing):
                         raise ValueError(f'Unexpected categories found in column {column}')
 
@@ -237,7 +237,7 @@ def ordinal_encoding(X_in, mapping=None, cols=None, handle_unknown='value', hand
 
                 data = pd.Series(index=index, data=range(1, len(index) + 1))
 
-                if handle_missing == 'value' and ~data.index.isnull().any():
+                if handle_missing == 'value' and ~data.index.isna().any():
                     data.loc[nan_identity] = -2
                 elif handle_missing == 'return_nan':
                     data.loc[nan_identity] = -2