class_docstr: Imputation transformer for completing missing values.
  
  Read more in the :ref:`User Guide <imputation>`.
  
  Parameters
  ----------
  missing_values : integer or "NaN", optional (default="NaN")
      The placeholder for the missing values. All occurrences of
      `missing_values` will be imputed. For missing values encoded as np.nan,
      use the string value "NaN".
  
  strategy : string, optional (default="mean")
      The imputation strategy.
  
      - If "mean", then replace missing values using the mean along
        the axis.
      - If "median", then replace missing values using the median along
        the axis.
      - If "most_frequent", then replace missing using the most frequent
        value along the axis.
  
  axis : integer, optional (default=0)
      The axis along which to impute.
  
      - If `axis=0`, then impute along columns.
      - If `axis=1`, then impute along rows.
  
  verbose : integer, optional (default=0)
      Controls the verbosity of the imputer.
  
  copy : boolean, optional (default=True)
      If True, a copy of X will be created. If False, imputation will
      be done in-place whenever possible. Note that, in the following cases,
      a new copy will always be made, even if `copy=False`:
  
      - If X is not an array of floating values;
      - If X is sparse and `missing_values=0`;
      - If `axis=0` and X is encoded as a CSR matrix;
      - If `axis=1` and X is encoded as a CSC matrix.
  
  Attributes
  ----------
  statistics_ : array of shape (n_features,)
      The imputation fill value for each feature if axis == 0.
  
  Notes
  -----
  - When ``axis=0``, columns which only contained missing values at `fit`
    are discarded upon `transform`.
  - When ``axis=1``, an exception is raised if there are rows for which it is
    not possible to fill in the missing values (e.g., because they only
    contain missing values).
docstr: Fit the imputer on X.
  
  Parameters
  ----------
  X : {array-like, sparse matrix}, shape (n_samples, n_features)
      Input data, where ``n_samples`` is the number of samples and
      ``n_features`` is the number of features.
  
  Returns
  -------
  self : object
      Returns self.
docstr_tok: ["Fit","the","imputer","on","X.","Parameters","--","--","--","--","--","X",":","{","array-like",",","sparse","matrix","}",",","shape","(","n_samples",",","n_features",")","Input","data",",","where","``","n_samples","``","is","the","number","of","samples","and","``","n_features","``","is","the","number","of","features",".","Returns","--","--","--","-","self",":","object","Returns","self","."]
code: def fit(self, X, y=None):
      """Fit the imputer on X.
  
      Parameters
      ----------
      X : {array-like, sparse matrix}, shape (n_samples, n_features)
          Input data, where ``n_samples`` is the number of samples and
          ``n_features`` is the number of features.
  
      Returns
      -------
      self : object
          Returns self.
      """
      # Check parameters
      allowed_strategies = ["mean", "median", "most_frequent"]
      if self.strategy not in allowed_strategies:
          raise ValueError(
              "Can only use these strategies: {0} "
              " got strategy={1}".format(
                  allowed_strategies, self.strategy
              )
          )
  
      if self.axis not in [0, 1]:
          raise ValueError(
              "Can only impute missing values on axis 0 and 1, "
              " got axis={0}".format(self.axis)
          )
  
      # Since two different arrays can be provided in fit(X) and
      # transform(X), the imputation data will be computed in transform()
      # when the imputation is done per sample (i.e., when axis=1).
      if self.axis == 0:
          X = check_array(
              X,
              accept_sparse="csc",
              dtype=np.float64,
              force_all_finite=False,
          )
  
          if sparse.issparse(X):
              self.statistics_ = self._sparse_fit(
                  X, self.strategy, self.missing_values, self.axis
              )
          else:
              self.statistics_ = self._dense_fit(
                  X, self.strategy, self.missing_values, self.axis
              )
  
      return self
  
imports: import warnings
  import numpy
  import numpy.ma
  from scipy import sparse
  from scipy import stats
  from ..base import BaseEstimator, TransformerMixin
  from ..utils import check_array
  from ..utils.fixes import astype
  from ..utils.sparsefuncs import _get_median
  from ..utils.validation import check_is_fitted
  from ..utils.validation import FLOAT_DTYPES
  from ..externals import six
label_desc: Use image node_id 2 for calling the Imputer obj's underlying member method code with example usage: obj.fit(X, y) and returns: self