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 .

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 :None:None:`buf` keyword.

3. Use :None:None:`np.rec.fromrecords`.

Other Parameters

titles : tuple of str, optional

Aliases for column names. For example, if :None:None:`names` were ('x', 'y', 'z') and :None:None:`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 (:None:None:`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 (:None:None:`buf`) from this offset onwards.

order : {'C', 'F'}, optional

Row-major (C-style) or column-major (Fortran-style) order.

Parameters

shape : tuple

Shape of output array.

dtype : data-type, optional

The desired data-type. By default, the data-type is determined from :None:None:`formats`, :None:None:`names`, :None:None:`titles`, :None:None:`aligned` and byteorder .

formats : list of data-types, optional

A list containing the data-types for the different columns, e.g. ['i4', 'f8', 'i4'] . :None:None:`formats` does not support the new convention of using types directly, i.e. (int, float, int) . Note that :None:None:`formats` must be a list, not a tuple. Given that :None:None:`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 :None:None:`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 :None:None:`offset` and :None:None:`strides` keywords are available.

Returns

rec : recarray

Empty array of the given shape and type.

Construct an ndarray that allows field access using attributes.

See Also

core.records.fromrecords

Construct a record array from data.

format_parser

determine a data-type from formats, names, titles.

record

fundamental data-type for :None:None:`recarray`.

Examples

Create an array with two fields, x and y :

>>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '<f8'), ('y', '<i8')])
... x
array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')])

>>> 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)]) #doctest: +SKIP
rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
       (3471280, 1.2134086255804012e-316, 0)],
      dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])

See :

Back References

The following pages refer to to this document either explicitly or contain code examples using this.

pandas.core.frame.DataFrame.to_records numpy.typing astropy.io.fits.column.ColDefs.__init__ networkx.convert_matrix.to_numpy_recarray numpy.rec.array numpy.lib.npyio.recfromtxt astropy.io.fits.fitsrec.FITS_rec numpy.lib.npyio.recfromcsv

Local connectivity graph

Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.

Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)

SVG is more flexible but power hungry; and does not scale well to 50 + nodes.

All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them

---

GitHub : /numpy/__init__.py#None
type: <class 'type'>
Commit: