code: def rename_axis(
      df_or_series,
      mapper=None,
      index=None,
      columns=None,
      axis=0,
      copy=True,
      inplace=False,
  ):
      """
      Set the name of the axis for the index or columns.
  
      Parameters
      ----------
      mapper : scalar, list-like, optional
          Value to set the axis name attribute.
      index, columns : scalar, list-like, dict-like or function, optional
          A scalar, list-like, dict-like or functions transformations to
          apply to that axis' values.
          Note that the ``columns`` parameter is not allowed if the
          object is a Series. This parameter only apply for DataFrame
          type objects.
  
          Use either ``mapper`` and ``axis`` to
          specify the axis to target with ``mapper``, or ``index``
          and/or ``columns``.
  
      axis : {0 or 'index', 1 or 'columns'}, default 0
          The axis to rename.
      copy : bool, default True
          Also copy underlying data.
      inplace : bool, default False
          Modifies the object directly, instead of creating a new Series
          or DataFrame.
  
      Returns
      -------
      Series, DataFrame, or None
          The same type as the caller or None if `inplace` is True.
  
      See Also
      --------
      Series.rename : Alter Series index labels or name.
      DataFrame.rename : Alter DataFrame index labels or name.
      Index.rename : Set new names on index.
  
      Notes
      -----
      ``DataFrame.rename_axis`` supports two calling conventions
  
      * ``(index=index_mapper, columns=columns_mapper, ...)``
      * ``(mapper, axis={'index', 'columns'}, ...)``
  
      The first calling convention will only modify the names of
      the index and/or the names of the Index object that is the columns.
      In this case, the parameter ``copy`` is ignored.
  
      The second calling convention will modify the names of the
      the corresponding index if mapper is a list or a scalar.
      However, if mapper is dict-like or a function, it will use the
      deprecated behavior of modifying the axis *labels*.
  
      We *highly* recommend using keyword arguments to clarify your
      intent.
  
      Examples
      --------
      **Series**
  
      >>> import mars.dataframe as md
      >>> s = md.Series(["dog", "cat", "monkey"])
      >>> s.execute()
      0       dog
      1       cat
      2    monkey
      dtype: object
      >>> s.rename_axis("animal").execute()
      animal
      0    dog
      1    cat
      2    monkey
      dtype: object
  
      **DataFrame**
  
      >>> df = md.DataFrame({"num_legs": [4, 4, 2],
      ...                    "num_arms": [0, 0, 2]},
      ...                   ["dog", "cat", "monkey"])
      >>> df.execute()
              num_legs  num_arms
      dog            4         0
      cat            4         0
      monkey         2         2
      >>> df = df.rename_axis("animal")
      >>> df.execute()
              num_legs  num_arms
      animal
      dog            4         0
      cat            4         0
      monkey         2         2
      >>> df = df.rename_axis("limbs", axis="columns")
      >>> df.execute()
      limbs   num_legs  num_arms
      animal
      dog            4         0
      cat            4         0
      monkey         2         2
      """
      return rename_axis_with_level(
          df_or_series,
          mapper=mapper,
          index=index,
          columns=columns,
          axis=axis,
          copy=copy,
          inplace=inplace,
      )
  
imports: from ...None import opcodes
  from ...core import OutputType
  from ...serialization.serializables import AnyField, BoolField
  from ..core import DATAFRAME_TYPE
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from ..utils import validate_axis, parse_index, build_df, build_series
label_desc: Use image node_id 2 for calling a global function with example usage: rename_axis(df_or_series, mapper, index, columns, axis, copy, inplace) and returns: rename_axis_with_level