class_docstr: Translate and scale each column by its mean and standard deviation, respectively.
  
  The general formula is given by
  
  .. math::
  
      x' = \frac{x - \bar{x}}{s}
  
  where :math:`x` is the column, :math:`x'` is the transformed column,
  :math:`\bar{x}` is the column average, and :math:`s` is the column's sample
  standard deviation. If :math:`s = 0` (i.e., the column is constant-valued),
  then the transformed column will contain zeros.
  
  .. warning::
      :class:`StandardScaler` works best when your data is normal. If your data isn't
      approximately normal, then the transformed features won't be meaningful.
  
  Examples:
      >>> import pandas as pd
      >>> import ray
      >>> from ray.data.preprocessors import StandardScaler
      >>>
      >>> df = pd.DataFrame({"X1": [-2, 0, 2], "X2": [-3, -3, 3], "X3": [1, 1, 1]})
      >>> ds = ray.data.from_pandas(df)  # doctest: +SKIP
      >>> ds.to_pandas()  # doctest: +SKIP
         X1  X2  X3
      0  -2  -3   1
      1   0  -3   1
      2   2   3   1
  
      Columns are scaled separately.
  
      >>> preprocessor = StandardScaler(columns=["X1", "X2"])
      >>> preprocessor.fit_transform(ds).to_pandas()  # doctest: +SKIP
               X1        X2  X3
      0 -1.224745 -0.707107   1
      1  0.000000 -0.707107   1
      2  1.224745  1.414214   1
  
      Constant-valued columns get filled with zeros.
  
      >>> preprocessor = StandardScaler(columns=["X3"])
      >>> preprocessor.fit_transform(ds).to_pandas()  # doctest: +SKIP
         X1  X2   X3
      0  -2  -3  0.0
      1   0  -3  0.0
      2   2   3  0.0
  
  Args:
      columns: The columns to separately scale.
code: def _transform_pandas(self, df: pd.DataFrame):
      def column_standard_scaler(s: pd.Series):
          s_mean = self.stats_[f"mean({s.name})"]
          s_std = self.stats_[f"std({s.name})"]
  
          # Handle division by zero.
          # TODO: extend this to handle near-zero values.
          if s_std == 0:
              s_std = 1
  
          return (s - s_mean) / s_std
  
      df.loc[:, self.columns] = df.loc[:, self.columns].transform(
          column_standard_scaler
      )
      return df
  
imports: from typing import List, Tuple
  import numpy
  import pandas
  from ray.data import Dataset
  from ray.data.aggregate import AbsMax, Max, Mean, Min, Std
  from ray.data.preprocessor import Preprocessor
  from ray.util.annotations import PublicAPI
label_desc: Use image node_id 3 for calling the StandardScaler obj's underlying member method code with example usage: obj._transform_pandas(df) and returns: df, unknown