Class numpy.core.ma.MaskedArray

Arrays with possibly masked values.
       Masked values of 1 exclude the corresponding element from 
       any computation.

       Construction:
           x = array(data, dtype=None, copy=True, fortran=False,
                     mask = nomask, fill_value=None)

       If copy=False, every effort is made not to copy the data:
           If data is a MaskedArray, and argument mask=nomask,
           then the candidate data is data.data and the
           mask used is data.mask. If data is a numeric array,
           it is used as the candidate raw data.
           If dtype.char is not None and
           is != data.dtype.char then a data copy is required.
           Otherwise, the candidate is used.

       If a data copy is required, raw data stored is the result of:
       numeric.array(data, dtype=dtype.char, copy=copy)

       If mask is nomask there are no masked values. Otherwise mask must
       be convertible to an array of booleans with the same shape as x.

       fill_value is used to fill in masked values when necessary,
       such as when printing and in method/function filled().
       The fill_value is not used for computation within this module.
    

Contents:
• Base classes
• Attributes
• Methods

Inherits from

• object: __builtin__.object

Attributes

• data

  data = property(fget = raw_data, doc = 'The data, but values at masked locations are meaningless.')
  
  

• dtype

  dtype = property(fget = _get_dtype, doc = 'type of the array elements.')
  
  

• flat

  flat = property(_get_flat, _set_flat, doc = 'Access array in flat form.')
  
  

• imag

  imag = imaginary
  
  

• imaginary

  imaginary = property(_get_imaginary, _set_imaginary, doc = 'Access the imaginary part of the array')
  
  

• mask

  mask = property(fget = raw_mask, doc = 'The mask, may be nomask. Values where mask true are meaningless.')
  
  

• real

  real = property(_get_real, _set_real, doc = 'Access the real part of the array')
  
  

• shape

  shape = property(_get_shape, _set_shape, doc = 'tuple giving the shape of the array')
  
  

• size

  size = property(fget = _get_size, doc = 'Number of elements in the array.')
  
  

Method summary

• __abs__(self)
• __add__(self, other)
• __and__(self, other)
• __array__(self, t = None)
• __array_wrap__(self, array, context)
• __div__(self, other)
• __eq__(self, other)
• __float__(self)
• __floordiv__(self, other)
• __ge__(self, other)
• __getitem__(self, i)
• __getslice__(self, i, j)
• __gt__(self, other)
• __iadd__(self, other)
• __idiv__(self, other)
• __imul__(self, other)
• __init__(self, data, dtype = None, copy = True, fortran = False, mask = nomask, fill_value = None)
• __int__(self)
• __isub__(self, other)
• __le__(self, other)
• __len__(self)
• __lshift__(self, n)
• __lt__(self, other)
• __mod__(self, other)
• __mul__(self, other)
• __ne__(self, other)
• __neg__(self)
• __nonzero__(self)
• __or__(self, other)
• __pos__(self)
• __pow__(self, other, third = None)
• __rdiv__(self, other)
• __repr__(self)
• __rfloordiv__(self, other)
• __rmod__(self, other)
• __rshift__(self, n)
• __rsub__(self, other)
• __rtruediv__(self, other)
• __setitem__(self, index, value)
• __setslice__(self, i, j, value)
• __sqrt__(self)
• __str__(self)
• __sub__(self, other)
• __truediv__(self, other)
• __xor__(self, other)
• astype(self, tc)
• byte_swapped(self)
• compressed(self)
• count(self, axis = None)
• dot(self, other)
• fill_value(self)
• filled(self, fill_value = None)
• ids(self)
• iscontiguous(self)
• item(self)
• itemsize(self)
• outer(self, other)
• put(self, values)
• putmask(self, values)
• ravel(self)
• raw_data(self)
• raw_mask(self)
• reshape(self, s)
• set_fill_value(self, v = None)
• tolist(self, fill_value = None)
• tostring(self, fill_value = None)
• unmask(self)
• unshare_mask(self)

Methods

• __abs__(self)

  Return absolute(self)

• __add__(self, other)

  Return add(self, other)

• __and__(self, other)

  Return bitwise_and

• __array__(self, t = None)

  Special hook for numeric. Converts to numeric if possible.

• __array_wrap__(self, array, context)

  Special hook for ufuncs.
  
          Wraps the numpy array and sets the mask according to
          context.
          

• __div__(self, other)

  Return divide(self, other)

• __eq__(self, other)

• __float__(self)

  Convert self to float.

• __floordiv__(self, other)

  Return divide(self, other)

• __ge__(self, other)

• __getitem__(self, i)

  Get item described by i. Not a copy as in previous versions.

• __getslice__(self, i, j)

  Get slice described by i, j

• __gt__(self, other)

• __iadd__(self, other)

  Add other to self in place.

• __idiv__(self, other)

  Divide self by other in place.

• __imul__(self, other)

  Add other to self in place.

• __init__(self, data, dtype = None, copy = True, fortran = False, mask = nomask, fill_value = None)

  array(data, dtype=None, copy=True, fortran=False, mask=nomask, fill_value=None)
             If data already a numeric array, its dtype becomes the default value of dtype.
          

• __int__(self)

  Convert self to int.

• __isub__(self, other)

  Subtract other from self in place.

• __le__(self, other)

• __len__(self)

  Return length of first dimension. This is weird but Python's
           slicing behavior depends on it.

• __lshift__(self, n)

• __lt__(self, other)

• __mod__(self, other)

  Return remainder(self, other)

• __mul__(self, other)

  Return multiply(self, other)

• __ne__(self, other)

• __neg__(self)

  Return negative(self)

• __nonzero__(self)

  returns true if any element is non-zero or masked
  
          

• __or__(self, other)

  Return bitwise_or

• __pos__(self)

  Return array(self)

• __pow__(self, other, third = None)

  Return power(self, other, third)

• __rdiv__(self, other)

  Return divide(other, self)

• __repr__(self)

  Calculate the repr representation, using masked for fill if
             it is enabled. Otherwise fill with fill value.
          

• __rfloordiv__(self, other)

  Return divide(other, self)

• __rmod__(self, other)

  Return remainder(other, self)

• __rshift__(self, n)

• __rsub__(self, other)

  Return subtract(other, self)

• __rtruediv__(self, other)

  Return divide(other, self)

• __setitem__(self, index, value)

  Set item described by index. If value is masked, mask those locations.

• __setslice__(self, i, j, value)

  Set slice i:j; if value is masked, mask those locations.

• __sqrt__(self)

  Return sqrt(self)

• __str__(self)

  Calculate the str representation, using masked for fill if
             it is enabled. Otherwise fill with fill value.
          

• __sub__(self, other)

  Return subtract(self, other)

• __truediv__(self, other)

  Return divide(self, other)

• __xor__(self, other)

  Return bitwise_xor

• astype(self, tc)

  return self as array of given type.

• byte_swapped(self)

  Returns the raw data field, byte_swapped. Included for consistency
           with numeric but doesn't make sense in this context.
          

• compressed(self)

  A 1-D array of all the non-masked data.

• count(self, axis = None)

  Count of the non-masked elements in a, or along a certain axis.

• dot(self, other)

  s.dot(other) = innerproduct(s, other)

• fill_value(self)

  Get the current fill value.

• filled(self, fill_value = None)

  A numeric array with masked values filled. If fill_value is None,
             use self.fill_value().
  
             If mask is nomask, copy data only if not contiguous.
             Result is always a contiguous, numeric array.
  # Is contiguous really necessary now?
          

• ids(self)

  Return the ids of the data and mask areas

• iscontiguous(self)

  Is the data contiguous?

• item(self)

  Return Python scalar if possible.

• itemsize(self)

  Item size of each data item.

• outer(self, other)

  s.outer(other) = outerproduct(s, other)

• put(self, values)

  Set the non-masked entries of self to filled(values).
             No change to mask
          

• putmask(self, values)

  Set the masked entries of self to filled(values).
             Mask changed to nomask.
          

• ravel(self)

  Return a 1-D view of self.

• raw_data(self)

   Obsolete; use data property instead.
              The raw data; portions may be meaningless.
              May be noncontiguous. Expert use only.

• raw_mask(self)

   Obsolete; use mask property instead.
              May be noncontiguous. Expert use only.
          

• reshape(self, s)

  This array reshaped to shape s

• set_fill_value(self, v = None)

  Set the fill value to v. Omit v to restore default.

• tolist(self, fill_value = None)

  Convert to list

• tostring(self, fill_value = None)

  Convert to string

• unmask(self)

  Replace the mask by nomask if possible.

• unshare_mask(self)

  If currently sharing mask, make a copy.