#### Previous topic

numpy.core.defchararray.array

#### Next topic

numpy.recarray.T

# numpy.recarray

class `numpy.``recarray`

  Construct an ndarray that allows field access using attributes.

  Arrays may have a data-types containing fields, analogous to columns in a spread sheet. An example is `[(x, int), (y, float)]`, where each entry in the array is a pair of `(int, float)`. Normally, these attributes are accessed using dictionary lookups such as `arr['x']` and `arr['y']`. Record arrays allow the fields to be accessed as members of the array, using `arr.x` and `arr.y`.

  Parameters: | shape : tuple Shape of output array. dtype : data-type, optional The desired data-type. By default, the data-type is determined from formats, names, titles, aligned and byteorder. formats : list of data-types, optional A list containing the data-types for the different columns, e.g. `['i4', 'f8', 'i4']`. formats does not support the new convention of using types directly, i.e. `(int, float, int)`. Note that formats must be a list, not a tuple. Given that formats is somewhat limited, we recommend specifying `dtype` instead. names : tuple of str, optional The name of each column, e.g. `('x', 'y', 'z')`. buf : buffer, optional By default, a new array is created of the given shape and data-type. If buf is specified and is an object exposing the buffer interface, the array will use the memory from the existing buffer. In this case, the offset and `strides` keywords are available.
  Returns: | rec : recarray Empty array of the given shape and type.
  Other Parameters:
  | titles : tuple of str, optional Aliases for column names. For example, if names were `('x', 'y', 'z')` and titles is `('x_coordinate', 'y_coordinate', 'z_coordinate')`, then `arr['x']` is equivalent to both `arr.x` and `arr.x_coordinate`. byteorder : {‘<’, ‘>’, ‘=’}, optional Byte-order for all fields. aligned : bool, optional Align the fields in memory as the C-compiler would. strides : tuple of ints, optional Buffer (buf) is interpreted according to these strides (strides define how many bytes each array element, row, column, etc. occupy in memory). offset : int, optional Start reading buffer (buf) from this offset onwards. order : {‘C’, ‘F’}, optional Row-major (C-style) or column-major (Fortran-style) order.

  See also

  `rec.fromrecords`
    Construct a record array from data.
  `record`
    fundamental data-type for `recarray`.
  `format_parser`
    determine a data-type from formats, names, titles.

  Notes

  This constructor can be compared to `empty`: it creates a new record array but does not fill it with data. To create a record array from data, use one of the following methods:

  1. Create a standard ndarray and convert it to a record array, using `arr.view(np.recarray)`
  2. Use the buf keyword.
  3. Use np.rec.fromrecords.

  Examples

  Create an array with two fields, `x` and `y`:

      >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', float), ('y', int)])
      >>> x
      array([(1.0, 2), (3.0, 4)],
            dtype=[('x', '<f8'), ('y', '<i4')])

      >>> x['x']
      array([ 1.,  3.])

  View the array as a record array:

      >>> x = x.view(np.recarray)

      >>> x.x
      array([ 1.,  3.])

      >>> x.y
      array([2, 4])

  Create a new, empty record array:

      >>> np.recarray((2,),
      ... dtype=[('x', int), ('y', float), ('z', int)])
      rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
             (3471280, 1.2134086255804012e-316, 0)],
            dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])

  Attributes

  `T` | Same as self.transpose(), except that self is returned if self.ndim < 2.
  `base` | Base object if memory is from some other object.
  `ctypes` | An object to simplify the interaction of the array with the ctypes module.
  `data` | Python buffer object pointing to the start of the array’s data.
  `dtype` | Data-type of the array’s elements.
  `flags` | Information about the memory layout of the array.
  `flat` | A 1-D iterator over the array.
  `imag` | The imaginary part of the array.
  `itemsize` | Length of one array element in bytes.
  `nbytes` | Total bytes consumed by the elements of the array.
  `ndim` | Number of array dimensions.
  `real` | The real part of the array.
  `shape` | Tuple of array dimensions.
  `size` | Number of elements in the array.
  `strides` | Tuple of bytes to step in each dimension when traversing an array.

  Methods

  `all`([axis, out, keepdims]) | Returns True if all elements evaluate to True.
  `any`([axis, out, keepdims]) | Returns True if any of the elements of a evaluate to True.
  `argmax`([axis, out]) | Return indices of the maximum values along the given axis.
  `argmin`([axis, out]) | Return indices of the minimum values along the given axis of a.
  `argpartition`(kth[, axis, kind, order]) | Returns the indices that would partition this array.
  `argsort`([axis, kind, order]) | Returns the indices that would sort this array.
  `astype`(dtype[, order, casting, subok, copy]) | Copy of the array, cast to a specified type.
  `byteswap`(inplace) | Swap the bytes of the array elements
  `choose`(choices[, out, mode]) | Use an index array to construct a new array from a set of choices.
  `clip`([min, max, out]) | Return an array whose values are limited to `[min, max]`.
  `compress`(condition[, axis, out]) | Return selected slices of this array along given axis.
  `conj`() | Complex-conjugate all elements.
  `conjugate`() | Return the complex conjugate, element-wise.
  `copy`([order]) | Return a copy of the array.
  `cumprod`([axis, dtype, out]) | Return the cumulative product of the elements along the given axis.
  `cumsum`([axis, dtype, out]) | Return the cumulative sum of the elements along the given axis.
  `diagonal`([offset, axis1, axis2]) | Return specified diagonals.
  `dot`(b[, out]) | Dot product of two arrays.
  `dump`(file) | Dump a pickle of the array to the specified file.
  `dumps`() | Returns the pickle of the array as a string.
  `field`(attr[, val]) |
  `fill`(value) | Fill the array with a scalar value.
  `flatten`([order]) | Return a copy of the array collapsed into one dimension.
  `getfield`(dtype[, offset]) | Returns a field of the given array as a certain type.
  `item`(*args) | Copy an element of an array to a standard Python scalar and return it.
  `itemset`(*args) | Insert scalar into an array (scalar is cast to array’s dtype, if possible)
  `max`([axis, out]) | Return the maximum along a given axis.
  `mean`([axis, dtype, out, keepdims]) | Returns the average of the array elements along given axis.
  `min`([axis, out, keepdims]) | Return the minimum along a given axis.
  `newbyteorder`([new_order]) | Return the array with the same data viewed with a different byte order.
  `nonzero`() | Return the indices of the elements that are non-zero.
  `partition`(kth[, axis, kind, order]) | Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array.
  `prod`([axis, dtype, out, keepdims]) | Return the product of the array elements over the given axis
  `ptp`([axis, out]) | Peak to peak (maximum - minimum) value along a given axis.
  `put`(indices, values[, mode]) | Set `a.flat[n] = values[n]` for all n in indices.
  `ravel`([order]) | Return a flattened array.
  `repeat`(repeats[, axis]) | Repeat elements of an array.
  `reshape`(shape[, order]) | Returns an array containing the same data with a new shape.
  `resize`(new_shape[, refcheck]) | Change shape and size of array in-place.
  `round`([decimals, out]) | Return a with each element rounded to the given number of decimals.
  `searchsorted`(v[, side, sorter]) | Find indices where elements of v should be inserted in a to maintain order.
  `setfield`(val, dtype[, offset]) | Put a value into a specified place in a field defined by a data-type.
  `setflags`([write, align, uic]) | Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.
  `sort`([axis, kind, order]) | Sort an array, in-place.
  `squeeze`([axis]) | Remove single-dimensional entries from the shape of a.
  `std`([axis, dtype, out, ddof, keepdims]) | Returns the standard deviation of the array elements along given axis.
  `sum`([axis, dtype, out, keepdims]) | Return the sum of the array elements over the given axis.
  `swapaxes`(axis1, axis2) | Return a view of the array with axis1 and axis2 interchanged.
  `take`(indices[, axis, out, mode]) | Return an array formed from the elements of a at the given indices.
  `tobytes`([order]) | Construct Python bytes containing the raw data bytes in the array.
  `tofile`(fid[, sep, format]) | Write array to a file as text or binary (default).
  `tolist`() | Return the array as a (possibly nested) list.
  `tostring`([order]) | Construct Python bytes containing the raw data bytes in the array.
  `trace`([offset, axis1, axis2, dtype, out]) | Return the sum along diagonals of the array.
  `transpose`(*axes) | Returns a view of the array with axes transposed.
  `var`([axis, dtype, out, ddof, keepdims]) | Returns the variance of the array elements, along given axis.
  `view`([dtype, type]) | New view of array with the same data.