code: def transform(self, X):
          
          check_is_fitted(self, 'statistics_')
  
          X = self._validate_input(X)
  
          statistics = self.statistics_
  
          if X.shape[1] != statistics.shape[0]:
              raise ValueError("X has %d features per sample, expected %d"
                               % (X.shape[1], self.statistics_.shape[0]))
  
          # Delete the invalid columns if strategy is not constant
          if self.strategy == "constant":
              valid_statistics = statistics
          else:
              # same as np.isnan but also works for object dtypes
              invalid_mask = _get_mask(statistics, np.nan)
              valid_mask = np.logical_not(invalid_mask)
              valid_statistics = statistics[valid_mask]
              valid_statistics_indexes = np.flatnonzero(valid_mask)
  
              if invalid_mask.any():
                  missing = np.arange(X.shape[1])[invalid_mask]
                  if self.verbose:
                      warnings.warn("Deleting features without "
                                    "observed values: %s" % missing)
                  X = X[:, valid_statistics_indexes]
  
          # Do actual imputation
          if sparse.issparse(X):
              if self.missing_values == 0:
                  raise ValueError("Imputation not possible when missing_values "
                                   "== 0 and input is sparse. Provide a dense "
                                   "array instead.")
              else:
                  mask = _get_mask(X.data, self.missing_values)
                  indexes = np.repeat(np.arange(len(X.indptr) - 1, dtype=np.int),
                                      np.diff(X.indptr))[mask]
  
                  X.data[mask] = valid_statistics[indexes].astype(X.dtype,
                                                                  copy=False)
          else:
              mask = _get_mask(X, self.missing_values)
              n_missing = np.sum(mask, axis=0)
              values = np.repeat(valid_statistics, n_missing)
              coordinates = np.where(mask.transpose())[::-1]
  
              X[coordinates] = values
  
          return X
docs: Impute all missing values in X.
  
          Parameters
          ----------
          X : {array-like, sparse matrix}, shape (n_samples, n_features)
              The input data to complete.