class_docstr: 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.
  
  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.
  
  Returns
  -------
  rec : recarray
      Empty array of the given shape and type.
  
  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)]) #doctest: +SKIP
  rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
         (3471280, 1.2134086255804012e-316, 0)],
        dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])
code: def __new__(
      subtype,
      shape,
      dtype=None,
      buf=None,
      offset=0,
      strides=None,
      formats=None,
      names=None,
      titles=None,
      byteorder=None,
      aligned=False,
      order="C",
  ):
      if dtype is not None:
          descr = sb.dtype(dtype)
      else:
          descr = format_parser(
              formats, names, titles, aligned, byteorder
          )._descr
  
      if buf is None:
          self = ndarray.__new__(
              subtype, shape, (record, descr), order=order
          )
      else:
          self = ndarray.__new__(
              subtype,
              shape,
              (record, descr),
              buffer=buf,
              offset=offset,
              strides=strides,
              order=order,
          )
      return self
  
imports: from __future__ import division, absolute_import, print_function
  import sys
  import os
  import warnings
  from .None import numeric
  from .None import numerictypes
  from numpy.compat import isfileobj, bytes, long, unicode, os_fspath
  from numpy.core.overrides import set_module
  from .arrayprint import get_printoptions
label_desc: Use image node_id 1 for calling the recarray obj's underlying member method code with example usage: obj.__new__(subtype, shape, dtype, buf, offset, strides, formats, names, titles, byteorder, aligned, order) and returns: self