ak.Record
---------

Defined in `awkward.highlevel <https://github.com/scikit-hep/awkward-1.0/blob/80bbef0738a6b7928333d7c705ee1b359991de5b/src/awkward/highlevel.py>`__ on `line 1501 <https://github.com/scikit-hep/awkward-1.0/blob/80bbef0738a6b7928333d7c705ee1b359991de5b/src/awkward/highlevel.py#L1501>`__.

.. py:class:: ak.Record(self, data, behavior=None, with_name=None, check_valid=False, cache=None, kernels=None)


    :param data: Data to wrap or convert into a record.
             If a string, the data are assumed to be JSON.
             If a dict, calls :py:obj:`ak.from_iter`, which assumes all inner
             dimensions have irregular lengths.
    :type data: :py:obj:`ak.layout.Record`, :py:obj:`ak.Record`, str, or dict
    :param behavior: Custom :py:obj:`ak.behavior` for this Record only.
    :type behavior: None or dict
    :param with_name: Gives the record type a name that can be
                  used to override its behavior (see below).
    :type with_name: None or str
    :param check_valid: If True, verify that the :py:meth:`layout <ak.Record.layout>` is valid.
    :type check_valid: bool
    :param kernels: If ``"cpu"``, the Record will be placed in
                main memory for use with other ``"cpu"`` Arrays and Records; if ``"cuda"``,
                the Record will be placed in GPU global memory using CUDA; if None,
                the ``data`` are left untouched. For ``"cuda"``,
                `awkward-cuda-kernels <https://pypi.org/project/awkward-cuda-kernels>`__
                must be installed, which can be invoked with
                ``pip install awkward[cuda] --upgrade``.
    :type kernels: None, ``"cpu"``, or ``"cuda"``

High-level record that can contain fields of any type.

Most users won't be creating Records manually. This class primarily exists
to be overridden in the same way as :py:obj:`ak.Array`.

Records can be used in `Numba <http://numba.pydata.org/>`__: they can be
passed as arguments to a Numba-compiled function or returned as return
values. The only limitation is that they cannot be *created*
inside the Numba-compiled function; to make outputs, consider
:py:obj:`ak.ArrayBuilder`.

See also :py:obj:`ak.Array` and :py:obj:`ak.behavior`.

ak.Record.layout
================

.. py:attribute:: ak.Record.layout

The :py:obj:`ak.layout.Record` that contains composable :py:obj:`ak.layout.Content`
elements to determine how the array is structured.

See :py:obj:`ak.Array.layout` for a more complete description.

The :py:obj:`ak.layout.Record` is not a subclass of :py:obj:`ak.layout.Content` in
Python (note: `Record <../_static/classawkward_1_1Record.html>`__ *is* a
subclass of `Content <../_static/classawkward_1_1Content.html>`__ in
C++!) and it is not composable with them: :py:obj:`ak.layout.Record` contains
one :py:obj:`ak.layout.RecordArray` (which is a :py:obj:`ak.layout.Content`), but
:py:obj:`ak.layout.Content` nodes cannot contain a :py:obj:`ak.layout.Record`.

A :py:obj:`ak.layout.Record` is not an independent entity from its
:py:obj:`ak.layout.RecordArray`; it's really just a marker indicating which
element to select. The XML representation reflects that:

.. code-block:: python


    >>> vectors = ak.Array([{"x": 0.1, "y": 1.0, "z": 30.0},
    ...                     {"x": 0.2, "y": 2.0, "z": 20.0},
    ...                     {"x": 0.3, "y": 3.0, "z": 10.0}])

    >>> vectors[1].layout
    <Record at="1">
        <RecordArray>
            <field index="0" key="x">
                <NumpyArray format="d" shape="3" data="0.1 0.2 0.3" at="0x555660dfe7d0"/>
            </field>
            <field index="1" key="y">
                <NumpyArray format="d" shape="3" data="1 2 3" at="0x555660df4180"/>
            </field>
            <field index="2" key="z">
                <NumpyArray format="d" shape="3" data="30 20 10" at="0x555660df6190"/>
            </field>
        </RecordArray>
    </Record>

ak.Record.behavior
==================

.. py:attribute:: ak.Record.behavior

The ``behavior`` parameter passed into this Record's constructor.

   * If a dict, this ``behavior`` overrides the global :py:obj:`ak.behavior`.
     Any keys in the global :py:obj:`ak.behavior` but not this ``behavior`` are
     still valid, but any keys in both are overridden by this
     ``behavior``. Keys with a None value are equivalent to missing keys,
     so this ``behavior`` can effectively remove keys from the
     global :py:obj:`ak.behavior`.

   * If None, the Record defaults to the global :py:obj:`ak.behavior`.

See :py:obj:`ak.behavior` for a list of recognized key patterns and their
meanings.

ak.Record.caches
================

.. py:attribute:: ak.Record.caches

ak.Record.tolist
================

.. py:method:: ak.Record.tolist(self)

Converts this Record into Python objects; same as :py:obj:`ak.to_list`
(but without the underscore, like NumPy's
`tolist <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.tolist.html>`__).

ak.Record.to_list
=================

.. py:method:: ak.Record.to_list(self)

Converts this Record into Python objects; same as :py:obj:`ak.to_list`.

ak.Record.nbytes
================

.. py:attribute:: ak.Record.nbytes

The total number of bytes in all the :py:obj:`ak.layout.Index`,
:py:obj:`ak.layout.Identities`, and :py:obj:`ak.layout.NumpyArray` buffers in this
array tree.

Note: this calculation takes overlapping buffers into account, to the
extent that overlaps are not double-counted, but overlaps are currently
assumed to be complete subsets of one another, and so it is
theoretically possible (though unlikely) that this number is an
underestimate of the true usage.

It also does not count buffers that must be kept in memory because
of ownership, but are not directly used in the array. Nor does it count
the (small) C++ nodes or Python objects that reference the (large)
array buffers.

ak.Record.fields
================

.. py:attribute:: ak.Record.fields

List of field names or tuple slot numbers (as strings) of this record.

If this is actually a tuple its fields are string representations of
integers, such as ``"0"``, ``"1"``, ``"2"``, etc.

See also :py:obj:`ak.fields`.

ak.Record._ipython_key_completions_
===================================

.. py:method:: ak.Record._ipython_key_completions_(self)

ak.Record.__iter__
==================

.. py:method:: ak.Record.__iter__(self)

ak.Record.type
==============

.. py:attribute:: ak.Record.type

The high-level type of this Record; same as :py:obj:`ak.type`.

Note that the outermost element of a Record's type is always a
:py:obj:`ak.types.RecordType`.

ak.Record.__getitem__
=====================

.. py:method:: ak.Record.__getitem__(self, where)


    :param where: Index of positions to
              select from this Record.
    :type where: many types supported; see below

Select items from the Record using an extension of NumPy's (already
quite extensive) rules.

See :py:obj:`ak.Array.__getitem__` for a more complete description. Since
this is a record, the first item in the slice tuple must be a
string, selecting a field.

For example, with a ``record`` like

.. code-block:: python


    ak.Record({"x": 3.3, "y": [1, 2, 3]})

we can select

.. code-block:: python


    >>> record["x"]
    3.3
    >>> record["y"]
    <Array [1, 2, 3] type='3 * int64'>
    >>> record["y", 1]
    2

ak.Record.__setitem__
=====================

.. py:method:: ak.Record.__setitem__(self, where, what)


    :param where: Field name to add data to the record.
    :type where: str
    :param what: Data to add as the new field.

For example:

.. code-block:: python


    >>> record = ak.Record({"x": 3.3})
    >>> record["y"] = 4
    >>> record["z"] = {"another": "record"}
    >>> print(record)
    {x: 3.3, y: 4, z: {another: 'record'}}

See :py:obj:`ak.with_field` for a variant that does not change the :py:obj:`ak.Record`
in-place. (Internally, this method uses :py:obj:`ak.with_field`, so performance
is not a factor in choosing one over the other.)

ak.Record.__getattr__
=====================

.. py:method:: ak.Record.__getattr__(self, where)

Whenever possible, fields can be accessed as attributes.

For example, the fields of an ``record`` like

.. code-block:: python


    ak.Record({"x": 1.1, "y": [2, 2], "z": "three"})

can be accessed as

.. code-block:: python


    >>> record.x
    1.1
    >>> record.y
    <Array [2, 2] type='2 * int64'>
    >>> record.z
    'three'

which are equivalent to ``record["x"]``, ``record["y"]``, and
``record["z"]``.

Fields can't be accessed as attributes when

   * :py:obj:`ak.Record` methods or properties take precedence,
   * a domain-specific behavior has methods or properties that take
     precedence, or
   * the field name is not a valid Python identifier or is a Python
     keyword.

ak.Record.__dir__
=================

.. py:method:: ak.Record.__dir__(self)

Lists all methods, properties, and field names (see :py:meth:`__getattr__ <ak.Record.__getattr__>`)
that can be accessed as attributes.

ak.Record.slot0
===============

.. py:attribute:: ak.Record.slot0

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"0"``, which selects slot ``0`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot1
===============

.. py:attribute:: ak.Record.slot1

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"1"``, which selects slot ``1`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot2
===============

.. py:attribute:: ak.Record.slot2

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"2"``, which selects slot ``2`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot3
===============

.. py:attribute:: ak.Record.slot3

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"3"``, which selects slot ``3`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot4
===============

.. py:attribute:: ak.Record.slot4

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"4"``, which selects slot ``4`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot5
===============

.. py:attribute:: ak.Record.slot5

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"5"``, which selects slot ``5`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot6
===============

.. py:attribute:: ak.Record.slot6

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"6"``, which selects slot ``6`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot7
===============

.. py:attribute:: ak.Record.slot7

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"7"``, which selects slot ``7`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot8
===============

.. py:attribute:: ak.Record.slot8

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"8"``, which selects slot ``8`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.slot9
===============

.. py:attribute:: ak.Record.slot9

Equivalent to :py:meth:`__getitem__ <ak.Record.__getitem__>` with ``"9"``, which selects slot ``9`` from
the Record as a tuple.

See :py:obj:`ak.Array.slot0` for a more complete description.

ak.Record.__str__
=================

.. py:method:: ak.Record.__str__(self)


    :param limit_value: Maximum number of characters to use when
                    presenting the Record as a string.
    :type limit_value: int

Presents this Record as a string without type or ``"<Record ...>"``.

See :py:obj:`ak.Array.__str__` for a more complete description.

ak.Record.__repr__
==================

.. py:method:: ak.Record.__repr__(self)


    :param limit_value: Maximum number of characters to use when
                    presenting the data of the Record.
    :type limit_value: int
    :param limit_total: Maximum number of characters to use for
                    the whole string (should be larger than ``limit_value``).
    :type limit_total: int

Presents this Record as a string with its type and ``"<Record ...>"``.

See :py:obj:`ak.Array.__repr__` for a more complete description.

ak.Record._str
==============

.. py:method:: ak.Record._str(self, limit_value=85)

ak.Record._repr
===============

.. py:method:: ak.Record._repr(self, limit_value=40, limit_total=85)

ak.Record.__array_ufunc__
=========================

.. py:method:: ak.Record.__array_ufunc__(self, ufunc, method)

Intercepts attempts to pass this Record to a NumPy
`universal functions <https://docs.scipy.org/doc/numpy/reference/ufuncs.html>`__
(ufuncs) and passes it through the Record's structure.

This method conforms to NumPy's
`NEP 13 <https://numpy.org/neps/nep-0013-ufunc-overrides.html>`__
for overriding ufuncs, which has been
`available since NumPy 1.13 <https://numpy.org/devdocs/release/1.13.0-notes.html#array-ufunc-added>`__
(and thus NumPy 1.13 is the minimum allowed version).

See :py:obj:`ak.Array.__array_ufunc__` for a more complete description.

ak.Record.numba_type
====================

.. py:attribute:: ak.Record.numba_type

The type of this Record when it is used in Numba. It contains enough
information to generate low-level code for accessing any element,
down to the leaves.

See `Numba documentation <https://numba.pydata.org/numba-doc/dev/reference/types.html>`__
on types and signatures.

ak.Record.__getstate__
======================

.. py:method:: ak.Record.__getstate__(self)

ak.Record.__setstate__
======================

.. py:method:: ak.Record.__setstate__(self, state)

ak.Record.__copy__
==================

.. py:method:: ak.Record.__copy__(self)

ak.Record.__deepcopy__
======================

.. py:method:: ak.Record.__deepcopy__(self, memo)

ak.Record.__bool__
==================

.. py:method:: ak.Record.__bool__(self)

ak.Record.__contains__
======================

.. py:method:: ak.Record.__contains__(self, element)

