# dask.dataframe.Series.map

Series.map(arg, na_action=None, meta=<no_default>)

  Map values of Series according to an input mapping or function.

  This docstring was copied from pandas.core.series.Series.map.

  Some inconsistencies with the Dask version may exist.

  Used for substituting each value in a Series with another value, that may be derived from a function, a `dict` or a `Series`.

  Parameters:
    arg function, collections.abc.Mapping subclass or Series

      Mapping correspondence.

    na_action{None, ‘ignore’}, default None

      If ‘ignore’, propagate NaN values, without passing them to the mapping correspondence.

      > metapd.DataFrame, pd.Series, dict, iterable, tuple, optional

      >   An empty `pd.DataFrame` or `pd.Series` that matches the dtypes and column names of the output. This metadata is necessary for many algorithms in dask dataframe to work. For ease of use, some alternative inputs are also available. Instead of a `DataFrame`, a `dict` of `{name: dtype}` or iterable of `(name, dtype)` can be provided (note that the order of the names should match the order of the columns). Instead of a series, a tuple of `(name, dtype)` can be used. If not provided, dask will try to infer the metadata. This may lead to unexpected results, so providing `meta` is recommended. For more information, see `dask.dataframe.utils.make_meta`.

  Returns:
    Series

      Same index as caller.

  See also

  `Series.apply`

    For applying more complex functions on a Series.

  `Series.replace`

    Replace values given in to_replace with value.

  `DataFrame.apply`

    Apply a function row-/column-wise.

  `DataFrame.map`

    Apply a function elementwise on a whole DataFrame.

  Notes

  When `arg` is a dictionary, values in Series that are not in the dictionary (as keys) are converted to `NaN`. However, if the dictionary is a `dict` subclass that defines `__missing__` (i.e. provides a method for default values), then this default is used rather than `NaN`.

  Examples

      >>> s = pd.Series(['cat', 'dog', np.nan, 'rabbit'])
      >>> s
      0      cat
      1      dog
      2      NaN
      3   rabbit
      dtype: object

  `map` accepts a `dict` or a `Series`. Values that are not found in the `dict` are converted to `NaN`, unless the dict has a default value (e.g. `defaultdict`):

      >>> s.map({'cat': 'kitten', 'dog': 'puppy'})
      0   kitten
      1    puppy
      2      NaN
      3      NaN
      dtype: object

  It also accepts a function:

      >>> s.map('I am a {}'.format)
      0       I am a cat
      1       I am a dog
      2       I am a nan
      3    I am a rabbit
      dtype: object

  To avoid applying the function to missing values (and keep them as `NaN`) `na_action='ignore'` can be used:

      >>> s.map('I am a {}'.format, na_action='ignore')
      0     I am a cat
      1     I am a dog
      2            NaN
      3  I am a rabbit
      dtype: object