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.

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')])

Methods

all(a[, axis, out])	Test whether all array elements along a given axis evaluate to True.
any(a[, axis, out])	Test whether any array element along a given axis evaluates to True.
argmax(a[, axis])	Indices of the maximum values along an axis.
argmin(a[, axis])	Return the indices of the minimum values along an axis.
argsort(a[, axis, kind, order])	Returns the indices that would sort an array.
astype
byteswap
choose(a, choices[, out, mode])	Construct an array from an index array and a set of arrays to choose from.
clip(a, a_min, a_max[, out])	Clip (limit) the values in an array.
compress(condition, a[, axis, out])	Return selected slices of an array along given axis.
conj()	Return the complex conjugate, element-wise.
conjugate()	Return the complex conjugate, element-wise.
copy(a)	Return an array copy of the given object.
cumprod(a[, axis, dtype, out])	Return the cumulative product of elements along a given axis.
cumsum(a[, axis, dtype, out])	Return the cumulative sum of the elements along a given axis.
diagonal(a[, offset, axis1, axis2])	Return specified diagonals.
dot(a, b)	Dot product of two arrays.
dump
dumps
field
fill
flatten
getfield
item
itemset
max(a[, axis, out])	Return the maximum of an array or maximum along an axis.
mean(a[, axis, dtype, out])	Compute the arithmetic mean along the specified axis.
min(a[, axis, out])	Return the minimum of an array or minimum along an axis.
newbyteorder
nonzero(a)	Return the indices of the elements that are non-zero.
prod(a[, axis, dtype, out])	Return the product of array elements over a given axis.
ptp(a[, axis, out])	Range of values (maximum - minimum) along an axis.
put(a, ind, v[, mode])	Replaces specified elements of an array with given values.
ravel(a[, order])	Return a flattened array.
repeat(a, repeats[, axis])	Repeat elements of an array.
reshape(a, newshape[, order])	Gives a new shape to an array without changing its data.
resize(a, new_shape)	Return a new array with the specified shape.
round(a[, decimals, out])	Round an array to the given number of decimals.
searchsorted(a, v[, side])	Find indices where elements should be inserted to maintain order.
setfield
setflags
sort(a[, axis, kind, order])	Return a sorted copy of an array.
squeeze(a)	Remove single-dimensional entries from the shape of an array.
std(a[, axis, dtype, out, ddof])	Compute the standard deviation along the specified axis.
sum(a[, axis, dtype, out])	Sum of array elements over a given axis.
swapaxes(a, axis1, axis2)	Interchange two axes of an array.
take(a, indices[, axis, out, mode])	Take elements from an array along an axis.
tofile
tolist
tostring
trace(a[, offset, axis1, axis2, dtype, out])	Return the sum along diagonals of the array.
transpose(a[, axes])	Permute the dimensions of an array.
var(a[, axis, dtype, out, ddof])	Compute the variance along the specified axis.
view