# numpy.ma.array

ma.array(data, dtype=None, copy=False, order=None, mask=False, fill_value=None, keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=0)

  An array class with possibly masked values.

  Masked values of True exclude the corresponding element from any computation.

  Construction:

      x = MaskedArray(data, mask=nomask, dtype=None, copy=False, subok=True,
                      ndmin=0, fill_value=None, keep_mask=True, hard_mask=None,
                      shrink=True, order=None)

  Parameters:
    data array_like

      Input data.

    mask sequence, optional

      Mask. Must be convertible to an array of booleans with the same shape as data. True indicates a masked (i.e. invalid) data.

    dtype dtype, optional

      Data type of the output. If `dtype` is None, the type of the data argument (`data.dtype`) is used. If `dtype` is not None and different from `data.dtype`, a copy is performed.

    copy bool, optional

      Whether to copy the input data (True), or to use a reference instead. Default is False.

    subok bool, optional

      Whether to return a subclass of `MaskedArray` if possible (True) or a plain `MaskedArray`. Default is True.

    ndmin int, optional

      Minimum number of dimensions. Default is 0.

    fill_value scalar, optional

      Value used to fill in the masked values when necessary. If None, a default based on the data-type is used.

    keep_mask bool, optional

      Whether to combine mask with the mask of the input data, if any (True), or to use only mask for the output (False). Default is True.

    hard_mask bool, optional

      Whether to use a hard mask or not. With a hard mask, masked values cannot be unmasked. Default is False.

    shrink bool, optional

      Whether to force compression of an empty mask. Default is True.

    order{‘C’, ‘F’, ‘A’}, optional

      Specify the order of the array. If order is ‘C’, then the array will be in C-contiguous order (last-index varies the fastest). If order is ‘F’, then the returned array will be in Fortran-contiguous order (first-index varies the fastest). If order is ‘A’ (default), then the returned array may be in any order (either C-, Fortran-contiguous, or even discontiguous), unless a copy is required, in which case it will be C-contiguous.

  Examples

  The `mask` can be initialized with an array of boolean values with the same shape as `data`.

      >>> data = np.arange(6).reshape((2, 3))
      >>> np.ma.MaskedArray(data, mask=[[False, True, False],
      ...                               [False, False, True]])
      masked_array(
        data=[[0, --, 2],
              [3, 4, --]],
        mask=[[False,  True, False],
              [False, False,  True]],
        fill_value=999999)

  Alternatively, the `mask` can be initialized to homogeneous boolean array with the same shape as `data` by passing in a scalar boolean value:

      >>> np.ma.MaskedArray(data, mask=False)
      masked_array(
        data=[[0, 1, 2],
              [3, 4, 5]],
        mask=[[False, False, False],
              [False, False, False]],
        fill_value=999999)

      >>> np.ma.MaskedArray(data, mask=True)
      masked_array(
        data=[[--, --, --],
              [--, --, --]],
        mask=[[ True,  True,  True],
              [ True,  True,  True]],
        fill_value=999999,
        dtype=int64)

  Note

  The recommended practice for initializing `mask` with a scalar boolean value is to use `True`/`False` rather than `np.True_`/`np.False_`. The reason is `nomask` is represented internally as `np.False_`.

      >>> np.False_ is np.ma.nomask
      True