code: def nanmedian(
      input: ivy.Array,
      /,
      *,
      axis: Optional[Union[Tuple[int], int]] = None,
      keepdims: bool = False,
      overwrite_input: bool = False,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """ivy.Array instance method variant of ivy.nanmedian. This method simply
      wraps the function, and so the docstring for ivy.nanmedian also applies to
      this method with minimal changes.
  
      Parameters
      ----------
      self
          Input array.
      axis
          Axis or axes along which the means are computed.
          The default is to compute the mean of the flattened array.
      keepdims
          If this is set to True, the axes which are reduced are left in the result
          as dimensions with size one. With this option, the result will broadcast
          correctly against the original a. If the value is anything but the default,
          then keepdims will be passed through to the mean or sum methods of
          sub-classes of ndarray. If the sub-classes methods does not implement
          keepdims any exceptions will be raised.
      overwrite_input
          If True, then allow use of memory of input array a for calculations.
          The input array will be modified by the call to median. This will
          save memory when you do not need to preserve the contents of the input array.
          Treat the input as undefined, but it will probably be fully or partially sorted.
          Default is False. If overwrite_input is True and a is not already an ndarray,
          an error will be raised.
      out
          optional output array, for writing the result to.
  
      Returns
      -------
      ret
          A new array holding the result. If the input contains integers
  
      This function is *nestable*, and therefore also accepts :code:'ivy.Container'
      instance in place of the argument.
  
      Examples
      --------
      With :class:`ivy.Array` input:
  
      >>> x = ivy.array([[12.0, 10.0, 34.0], [45.0, 23.0, ivy.nan]])
      >>> ivy.nanmedian(x)
          ivy.array(23.)
      With a mix of :class:`ivy.Container` and :class:`ivy.Array` input:
      >>> x = ivy.Container(a=ivy.array([[10.0, ivy.nan, 4], [3, 2, 1]]),
              b=ivy.array([[12, 10, 34], [45, 23, ivy.nan]]))
      >>> ivy.nanmedian(x)
      {
          a: ivy.array(3.),
          b: ivy.array(23.)
      }
      """
      return ivy.current_backend().nanmedian(
          input,
          axis=axis,
          keepdims=keepdims,
          overwrite_input=overwrite_input,
          out=out,
      )
  
file_path: ivy/ivy/functional/ivy/experimental/statistical.py
imports: from typing import Optional, Union, Tuple, Sequence
  import ivy
  from ivy.func_wrapper import handle_array_function, handle_out_argument, to_native_arrays_and_back, handle_array_like_without_promotion, handle_nestable, infer_dtype, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 8 for calling a global function with example usage: nanmedian() and returns: ivy