Current File : //lib64/python3.9/site-packages/numpy/core/__pycache__/records.cpython-39.pyc
a
z[yc�� � @ sD d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z
ddl m Z dd l
mZ dd
lmZ g d �ZejZd d
dd d
dddd d
ddddd�Ze
jZdd� Zed�G dd� d��ZG dd� de
j�ZG dd� de�Zdd � Zed �d,d d ��Z ed �d-d!d"��Z ed �d.d#d$��Z d%d&� Z ed �d/d'd(��Z ed �d0d*d+��Z!dS )1a�
Record Arrays
=============
Record arrays expose the fields of structured arrays as properties.
Most commonly, ndarrays contain elements of a single type, e.g. floats,
integers, bools etc. However, it is possible for elements to be combinations
of these using structured types, such as::
>>> a = np.array([(1, 2.0), (1, 2.0)], dtype=[('x', np.int64), ('y', np.float64)])
>>> a
array([(1, 2.), (1, 2.)], dtype=[('x', '<i8'), ('y', '<f8')])
Here, each element consists of two fields: x (and int), and y (a float).
This is known as a structured array. The different fields are analogous
to columns in a spread-sheet. The different fields can be accessed as
one would a dictionary::
>>> a['x']
array([1, 1])
>>> a['y']
array([2., 2.])
Record arrays allow us to access fields as properties::
>>> ar = np.rec.array(a)
>>> ar.x
array([1, 1])
>>> ar.y
array([2., 2.])
� N)�Counter)� nullcontext� )�numeric)� numerictypes)� os_fspath)�
set_module)�_get_legacy_print_mode)�record�recarray�
format_parser�
fromarrays� fromrecords�
fromstring�fromfile�array�>�<�=�s�|)�b�l�n�B�L�N�Sr r r r r �I�ic C s dd� t | ��� D �S )z@Find duplication in a list, return a list of duplicated elementsc S s g | ]\}}|d kr|�qS �r � )�.0�itemZcountsr! r! �8/usr/lib64/python3.9/site-packages/numpy/core/records.py�
<listcomp>P s �z"find_duplicate.<locals>.<listcomp>)r �items)�listr! r! r$ �find_duplicateN s
�r( �numpyc @ s4 e Zd ZdZd dd�Zd
dd�Zdd � Zd
d � ZdS )r a�
Class to convert formats, names, titles description to a dtype.
After constructing the format_parser object, the dtype attribute is
the converted data-type:
``dtype = format_parser(formats, names, titles).dtype``
Attributes
----------
dtype : dtype
The converted data-type.
Parameters
----------
formats : str or list of str
The format description, either specified as a string with
comma-separated format descriptions in the form ``'f8, i4, a5'``, or
a list of format description strings in the form
``['f8', 'i4', 'a5']``.
names : str or list/tuple of str
The field names, either specified as a comma-separated string in the
form ``'col1, col2, col3'``, or as a list or tuple of strings in the
form ``['col1', 'col2', 'col3']``.
An empty list can be used, in that case default field names
('f0', 'f1', ...) are used.
titles : sequence
Sequence of title strings. An empty list can be used to leave titles
out.
aligned : bool, optional
If True, align the fields by padding as the C-compiler would.
Default is False.
byteorder : str, optional
If specified, all the fields will be changed to the
provided byte-order. Otherwise, the default byte-order is
used. For all available string specifiers, see `dtype.newbyteorder`.
See Also
--------
dtype, typename, sctype2char
Examples
--------
>>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'],
... ['T1', 'T2', 'T3']).dtype
dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')])
`names` and/or `titles` can be empty lists. If `titles` is an empty list,
titles will simply not appear. If `names` is empty, default field names
will be used.
>>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
... []).dtype
dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
>>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])
FNc C s& | � ||� | �||� | �|� d S �N)�
_parseFormats�_setfieldnames� _createdtype)�self�formats�names�titles�aligned� byteorderr! r! r$ �__init__� s zformat_parser.__init__c s� |du rt d��t|t�r6t�dd� t|�D �|�}n t�||�}|j� � du rht�d|fg|�}|j� |j}� fdd�|D �| _� fdd�|D �| _ t
|�| _ dS )z Parse the field formats NzNeed formats argumentc S s g | ]\}}d � |�|f�qS )zf{})�format)r" r Zformat_r! r! r$ r% � � z/format_parser._parseFormats.<locals>.<listcomp>�f1c s g | ]}� | d �qS �r r! �r" �key��fieldsr! r$ r% � r6 c s g | ]}� | d �qS r r! r9 r; r! r$ r% � r6 ) �
ValueError�
isinstancer' �sb�dtype� enumerater< r0 �
_f_formats�_offsets�len�_nfields)r. r/ r2 r@ �keysr! r; r$ r+ � s
� zformat_parser._parseFormatsc C s� |rXt |�ttfv rn&t|t�r,|�d�}ntdt|� ��dd� |d| j� D �| _ ng | _ | j dd� t
t | j �| j�D �7 _ t | j �}|r�t
d| ��|r�dd� |d| j� D �| _n
g | _g }| jt |�kr�| jdg| jt |� 7 _dS ) zQconvert input field names into a list and assign to the _names
attribute �,zillegal input names %sc S s g | ] }|� � �qS r! ��strip�r" r r! r! r$ r% � r6 z0format_parser._setfieldnames.<locals>.<listcomp>Nc S s g | ] }d | �qS )zf%dr! �r" r r! r! r$ r% � r6 zDuplicate field names: %sc S s g | ] }|� � �qS r! rH rJ r! r! r$ r% � r6 )�typer' �tupler> �str�split� NameError�reprrE �_names�rangerD r( r= �_titles)r. r0 r1 Z_dupr! r! r$ r, � s(
�
z format_parser._setfieldnamesc C sD t �| j| j| j| jd��}|d ur:t|d }|�|�}|| _d S )N)r0 r/ Zoffsetsr1 r )r? r@ rR rB rC rT �_byteorderconvZ newbyteorder)r. r3 r@ r! r! r$ r- � s �
zformat_parser._createdtype)FN)F)�__name__�
__module__� __qualname__�__doc__r4 r+ r, r- r! r! r! r$ r W s
:
$r c sT e Zd ZdZd Z dZ� fdd�Z� fdd�Zdd� Zd d
� Zd d � Zd
d� Z � Z
S )r
zEA data-type scalar that allows field access as attribute lookup.
r) c s t � dkr| �� S t� �� S �N�q )r �__str__�super�__repr__�r. �� __class__r! r$ r^ � s
zrecord.__repr__c s t � dkrt| �� �S t� �� S rZ )r rN r# r] r\ r_ r` r! r$ r\ � s
zrecord.__str__c C s� |dv rt j�| |�S zt j�| |�W S ty8 Y n0 t j�| d�j}|�|d �}|r�| j|d d� � }z
|j}W n ty� | Y S 0 |jd ur�|� | j
|jf�S |S td| ��d S )N��setfield�getfieldr@ r@ � �%'record' object has no attribute '%s') �nt�void�__getattribute__�AttributeErrorr< �getrd r@ r0 �viewra )r. �attr� fielddict�res�objZdtr! r! r$ ri � s(
�zrecord.__getattribute__c C sz |dv rt d| ��tj�| d�j}|�|d �}|rN| j|g|d d� �R � S t| |d �rjtj�| ||�S t d| ��d S )Nrb zCannot set '%s' attributer@ re rf ) rj rg rh ri r< rk rc �getattr� __setattr__)r. rm �valrn ro r! r! r$ rr s �zrecord.__setattr__c C s@ t j�| |�}t|t j�r8|jjd ur8|�| j|jf�S |S d S r* )rg rh � __getitem__r> r@ r0 rl ra �r. Zindxrp r! r! r$ rt s zrecord.__getitem__c s@ �j j}tdd� |D ��}d| � � �fdd�|D �}d�|�S )zPretty-print all fields.c s s | ]}t |�V qd S r* )rD �r" �namer! r! r$ � <genexpr>' r6 z record.pprint.<locals>.<genexpr>z %% %ds: %%sc s g | ]}� |t �|�f �qS r! )rq rv ��fmtr. r! r$ r% ) r6 z!record.pprint.<locals>.<listcomp>�
)r@ r0 �max�join)r. r0 �maxlenZrowsr! ry r$ �pprint# s
z
record.pprint) rV rW rX rY r^ r\ ri rr rt r �
__classcell__r! r! r` r$ r
� s
r
c
s\ e Zd ZdZd Z dZddd�Zd d
� Zd d � Zd
d� Z� fdd�Zdd� Z ddd�Z
� Z S )r a- 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
--------
core.records.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', '<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')])
r) Nr F�Cc C sf |d urt �|�} nt||||
| �j} |d u rFtj| |t| f| d�}
n tj| |t| f|||| d�}
|
S )N)�order)�buffer�offset�stridesr� )r? r@ r �ndarray�__new__r
)Zsubtype�shaper@ �bufr� r� r/ r0 r1 r3 r2 r� �descrr. r! r! r$ r� � s �zrecarray.__new__c C s$ | j jtur | j jd ur | j | _ d S r* )r@ rL r
r0 )r. rp r! r! r$ �__array_finalize__� s zrecarray.__array_finalize__c
C s� zt �| |�W S ty Y n0 t�| d�j}z|| d d� }W n6 ttfyz } ztd| �|�W Y d }~n
d }~0 0 | j|� }|jj d ur�t
|jj t j
�r�|j| jj |jfd�S |S |�t�S d S )Nr@ re z recarray has no attribute %s�r@ )�objectri rj r� r< � TypeError�KeyErrorrd r@ r0 �
issubclassrL rg rh rl )r. rm rn ro �erp r! r! r$ ri � s $
zrecarray.__getattribute__c
C s$ |dkr.t |jtj�r.|jd ur.t�t|f�}|| jv}zt �
| ||�}W n. t yx t �
| d�jphi }||vrt� Y nL0 t �
| d�jp�i }||vr�|S |r�zt �| |� W n t y� | Y S 0 z|| d d� }W n8 ttf�y } ztd| �|�W Y d }~n
d }~0 0 | j|g|�R � S )Nr@ re z record array has no attribute %s)r� rL rg rh r0 r? r@ r
�__dict__r� rr � Exceptionr� ri r< � __delattr__r� r� rj rc )r. rm rs Znewattr�retrn ro r� r! r! r$ rr � s4
��zrecarray.__setattr__c sp t � �|�}t|t�rh|jjd urZ|�t| ��}t|jjt j
�rV|j| jj|jfd�S |S |jtd�S n|S d S )Nr� )rL ) r] rt r> r� r@ r0 rl rL r� rg rh ru r` r! r$ rt � s
zrecarray.__getitem__c C s� | j }| j jtu s"t| j jtj�sF|jtu r<t� tj|f�}d}d}nd}d}| jdksb| jdkrvtj | d|dd �}nd
t
| j�f }d d t |� }t � d
kr�d | }||||f S )Nz
rec.array(zrec.array(%s,%sdtype=%s)zarray(z)array(%s,%sdtype=%s).view(numpy.recarray)r r8 z, rG )� separator�prefix�suffixz [], shape=%sr{ � r[ )
r@ rL r
r� rg rh r? �sizer� Z array2stringrQ rD r )r. Z
repr_dtyper� rz ZlstZlfr! r! r$ r^
s"
�
zrecarray.__repr__c C s� t |t�r t�| d�j}|| }t�| d�j}|| d d� }|d u rj| j|� }|jjd ur`|S |�t�S | j |g|�R � S d S )Nr@ re )
r> �intr� ri r0 r< rd r@ rl rc )r. rm rs r0 rn ro rp r! r! r$ �field. s
zrecarray.field)
NNr NNNNNFr� )N) rV rW rX rY r� r� ri rr rt r^ r� r� r! r! r` r$ r 4 s j �
"! !r c C s$ | dkr t jdtdd� d S | S d S )Nr z�Passing `shape=0` to have the shape be inferred is deprecated, and in future will be equivalent to `shape=(0,)`. To infer the shape and suppress this warning, pass `shape=None` instead.� ��
stacklevel)�warnings�warn�
FutureWarning)r� r! r! r$ �_deprecate_shape_0_as_None@ s �r� z numpy.recFc C s2 dd� | D �} t |�}|du r*| d j}nt|t�r:|f}|du rX|du rXdd� | D �}|durlt�|�}nt|||||�j}|j} t|�t| �kr�t d��|d j}
t|
�} | dkr�|d| � }t
||�} t | �D ]V\}
}||
j } |jd|j | � }| |
}||k�r$t d|
� d|� d ���|| |< q�| S )
a� Create a record array from a (flat) list of arrays
Parameters
----------
arrayList : list or tuple
List of array-like objects (such as lists, tuples,
and ndarrays).
dtype : data-type, optional
valid dtype for all arrays
shape : int or tuple of ints, optional
Shape of the resulting array. If not provided, inferred from
``arrayList[0]``.
formats, names, titles, aligned, byteorder :
If `dtype` is ``None``, these arguments are passed to
`numpy.format_parser` to construct a dtype. See that function for
detailed documentation.
Returns
-------
np.recarray
Record array consisting of given arrayList columns.
Examples
--------
>>> x1=np.array([1,2,3,4])
>>> x2=np.array(['a','dd','xyz','12'])
>>> x3=np.array([1.1,2,3,4])
>>> r = np.core.records.fromarrays([x1,x2,x3],names='a,b,c')
>>> print(r[1])
(2, 'dd', 2.0) # may vary
>>> x1[1]=34
>>> r.a
array([1, 2, 3, 4])
>>> x1 = np.array([1, 2, 3, 4])
>>> x2 = np.array(['a', 'dd', 'xyz', '12'])
>>> x3 = np.array([1.1, 2, 3,4])
>>> r = np.core.records.fromarrays(
... [x1, x2, x3],
... dtype=np.dtype([('a', np.int32), ('b', 'S3'), ('c', np.float32)]))
>>> r
rec.array([(1, b'a', 1.1), (2, b'dd', 2. ), (3, b'xyz', 3. ),
(4, b'12', 4. )],
dtype=[('a', '<i4'), ('b', 'S3'), ('c', '<f4')])
c S s g | ]}t �|��qS r! )r? Zasarray)r" �xr! r! r$ r% } r6 z fromarrays.<locals>.<listcomp>Nr c S s g | ]
}|j �qS r! r� )r" rp r! r! r$ r% � r6 z>mismatch between the number of fields and the number of arraysz array-shape mismatch in array z ("z"))
r� r� r> r� r? r@ r r0 rD r= r rA �ndim)Z arrayListr@ r� r/ r0 r1 r2 r3 r� rR Zd0�nn�_array�krp Z testshaperw r! r! r$ r
L s6 1
r
c sJ |du rP|du rPt j| td�� � fdd�t� jd �D �}t|||||||d�S |durht �t|f�} nt|||||�j} zt j| | d�}
W n� t t
f�y t |�}|du r�t | �}t
|t�r�|f}t |�dkr�t
d��t|| �} t| j�D ]} t| | �| | < q�tjd td
d � | Y S 0 |du�r<|
j|k�r<||
_|
�t�}
|
S ) a Create a recarray from a list of records in text form.
Parameters
----------
recList : sequence
data in the same field may be heterogeneous - they will be promoted
to the highest data type.
dtype : data-type, optional
valid dtype for all arrays
shape : int or tuple of ints, optional
shape of each array.
formats, names, titles, aligned, byteorder :
If `dtype` is ``None``, these arguments are passed to
`numpy.format_parser` to construct a dtype. See that function for
detailed documentation.
If both `formats` and `dtype` are None, then this will auto-detect
formats. Use list of tuples rather than list of lists for faster
processing.
Returns
-------
np.recarray
record array consisting of given recList rows.
Examples
--------
>>> r=np.core.records.fromrecords([(456,'dbe',1.2),(2,'de',1.3)],
... names='col1,col2,col3')
>>> print(r[0])
(456, 'dbe', 1.2)
>>> r.col1
array([456, 2])
>>> r.col2
array(['dbe', 'de'], dtype='<U3')
>>> import pickle
>>> pickle.loads(pickle.dumps(r))
rec.array([(456, 'dbe', 1.2), ( 2, 'de', 1.3)],
dtype=[('col1', '<i8'), ('col2', '<U3'), ('col3', '<f8')])
Nr� c s" g | ]}t �� d |f �� ��qS ).)r? r �tolistrK �rp r! r$ r% � r6 z fromrecords.<locals>.<listcomp>���)r/ r� r0 r1 r2 r3 r z Can only deal with 1-d array.zxfromrecords expected a list of tuples, may have received a list of lists instead. In the future that will raise an errorre r� )r? r r� rS r� r
r@ r
r r� r= r� rD r> r� r r� rM r� r� r� rl )ZrecListr@ r� r/ r0 r1 r2 r3 Zarrlistr� Zretvalr� r� ro r! r� r$ r � s> ,
�
�
r c C sx |du r|du rt d��|dur,t�|�} nt|||||�j} | j}
t|�}|dv rdt| �| |
}t|| | |d�} | S )a� Create a record array from binary data
Note that despite the name of this function it does not accept `str`
instances.
Parameters
----------
datastring : bytes-like
Buffer of binary data
dtype : data-type, optional
Valid dtype for all arrays
shape : int or tuple of ints, optional
Shape of each array.
offset : int, optional
Position in the buffer to start reading from.
formats, names, titles, aligned, byteorder :
If `dtype` is ``None``, these arguments are passed to
`numpy.format_parser` to construct a dtype. See that function for
detailed documentation.
Returns
-------
np.recarray
Record array view into the data in datastring. This will be readonly
if `datastring` is readonly.
See Also
--------
numpy.frombuffer
Examples
--------
>>> a = b'\x01\x02\x03abc'
>>> np.core.records.fromstring(a, dtype='u1,u1,u1,S3')
rec.array([(1, 2, 3, b'abc')],
dtype=[('f0', 'u1'), ('f1', 'u1'), ('f2', 'u1'), ('f3', 'S3')])
>>> grades_dtype = [('Name', (np.str_, 10)), ('Marks', np.float64),
... ('GradeLevel', np.int32)]
>>> grades_array = np.array([('Sam', 33.3, 3), ('Mike', 44.4, 5),
... ('Aadi', 66.6, 6)], dtype=grades_dtype)
>>> np.core.records.fromstring(grades_array.tobytes(), dtype=grades_dtype)
rec.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), ('Aadi', 66.6, 6)],
dtype=[('Name', '<U10'), ('Marks', '<f8'), ('GradeLevel', '<i4')])
>>> s = '\x01\x02\x03abc'
>>> np.core.records.fromstring(s, dtype='u1,u1,u1,S3')
Traceback (most recent call last)
...
TypeError: a bytes-like object is required, not 'str'
Nz2fromstring() needs a 'dtype' or 'formats' argument)Nr� )r� r� )r� r? r@ r �itemsizer� rD r ) Z
datastringr@ r� r� r/ r0 r1 r2 r3 r� r� r� r! r! r$ r s 8 r c
C sB | � � }z&| �dd� | � � | W | �|d� S | �|d� 0 d S )Nr re )�tell�seek)�fd�posr! r! r$ �get_remaining_sizeK s �r� c C sr |du r|du rt d��t|�}|du r.d}nt|t�r>|f}t| d�rRt| �} ntt| �d�} | ��} |dkrz| �|d� t | �}
|dur�t
� |�} nt |||||�j } | j
} t
�|�jtjd�}
|
| }|dk �r t|�}|
| ||�d �< t|�}t
�|�jtjd�}
|
| }||
k�r&td
��t|| �}| �|j�}||k�rNtd ��W d � n1 �sd0 Y |S ) a� Create an array from binary file data
Parameters
----------
fd : str or file type
If file is a string or a path-like object then that file is opened,
else it is assumed to be a file object. The file object must
support random access (i.e. it must have tell and seek methods).
dtype : data-type, optional
valid dtype for all arrays
shape : int or tuple of ints, optional
shape of each array.
offset : int, optional
Position in the file to start reading from.
formats, names, titles, aligned, byteorder :
If `dtype` is ``None``, these arguments are passed to
`numpy.format_parser` to construct a dtype. See that function for
detailed documentation
Returns
-------
np.recarray
record array consisting of data enclosed in file.
Examples
--------
>>> from tempfile import TemporaryFile
>>> a = np.empty(10,dtype='f8,i4,a5')
>>> a[5] = (0.5,10,'abcde')
>>>
>>> fd=TemporaryFile()
>>> a = a.newbyteorder('<')
>>> a.tofile(fd)
>>>
>>> _ = fd.seek(0)
>>> r=np.core.records.fromfile(fd, formats='f8,i4,a5', shape=10,
... byteorder='<')
>>> print(r[5])
(0.5, 10, 'abcde')
>>> r.shape
(10,)
Nz0fromfile() needs a 'dtype' or 'formats' argument)r� �readinto�rbr r r� r� z:Not enough bytes left in file for specified shape and typez%Didn't read as many bytes as expected)r� r� r> r� �hasattrr �openr r� r� r? r@ r r� r Zprodrg Zintpr' �indexrM r= r r� �data�OSError)r� r@ r� r� r/ r0 r1 r2 r3 �ctxr� r� r� Z shapeprodZ shapesize�nbytesr� Z
nbytesreadr! r! r$ r T sF .
�
(r Tc C s$ t | td�tf�s t| d�r4|du r4|du r4td��i } |durLt�|�}n,|durht||||| �j}n||||| d�} | du r�|du r�td��t||| ||d�S t | t �r�t
| |f||d�| ��S t | t t f��rt | d t t f�� r�t
| f||d �| ��S t| f||d �| ��S �nt | t��r\|du�rF| j|k�rF| �|�} n| } |
�rX| �� } | S t| d��rxt| |||d
�S t | t��r�|du�r�| j|k�r�| �|�} n| } |
�r�| �� } | �t�S t| d d�}
|
du �s�t |
t��s�td ��t�| �} |du�r| j|k�r| �|�} | �t�S dS )
a�
Construct a record array from a wide-variety of objects.
A general-purpose record array constructor that dispatches to the
appropriate `recarray` creation function based on the inputs (see Notes).
Parameters
----------
obj : any
Input object. See Notes for details on how various input types are
treated.
dtype : data-type, optional
Valid dtype for array.
shape : int or tuple of ints, optional
Shape of each array.
offset : int, optional
Position in the file or buffer to start reading from.
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).
formats, names, titles, aligned, byteorder :
If `dtype` is ``None``, these arguments are passed to
`numpy.format_parser` to construct a dtype. See that function for
detailed documentation.
copy : bool, optional
Whether to copy the input object (True), or to use a reference instead.
This option only applies when the input is an ndarray or recarray.
Defaults to True.
Returns
-------
np.recarray
Record array created from the specified object.
Notes
-----
If `obj` is ``None``, then call the `~numpy.recarray` constructor. If
`obj` is a string, then call the `fromstring` constructor. If `obj` is a
list or a tuple, then if the first object is an `~numpy.ndarray`, call
`fromarrays`, otherwise call `fromrecords`. If `obj` is a
`~numpy.recarray`, then make a copy of the data in the recarray
(if ``copy=True``) and use the new formats, names, and titles. If `obj`
is a file, then call `fromfile`. Finally, if obj is an `ndarray`, then
return ``obj.view(recarray)``, making a copy of the data if ``copy=True``.
Examples
--------
>>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> np.core.records.array(a)
rec.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]],
dtype=int32)
>>> b = [(1, 1), (2, 4), (3, 9)]
>>> c = np.core.records.array(b, formats = ['i2', 'f2'], names = ('x', 'y'))
>>> c
rec.array([(1, 1.0), (2, 4.0), (3, 9.0)],
dtype=[('x', '<i2'), ('y', '<f2')])
>>> c.x
rec.array([1, 2, 3], dtype=int16)
>>> c.y
rec.array([ 1.0, 4.0, 9.0], dtype=float16)
>>> r = np.rec.array(['abc','def'], names=['col1','col2'])
>>> print(r.col1)
abc
>>> r.col1
array('abc', dtype='<U3')
>>> r.col2
array('def', dtype='<U3')
Nr� zIMust define formats (or dtype) if object is None, string, or an open file)r/ r0 r1 r2 r3 z"Must define a shape if obj is None)r� r� r� )r� r� r )r@ r� )r@ r� r� Z__array_interface__zUnknown input type)r> rL rN r� r= r? r@ r r �bytesr r' rM r r
rl �copyr r� rq �dictr )rp r@ r� r� r� r/ r0 r1 r2 r3 r� �kwds�newZ interfacer! r! r$ r � sh U �� ��
r )NNNNNFN)NNNNNFN)NNr NNNFN)NNr NNNFN)
NNr NNNNFNT)"rY r� � collectionsr �
contextlibr � r r? r rg Z numpy.compatr Znumpy.core.overridesr Z
arrayprintr �__all__r� rU Z
sctypeDictZnumfmtr( r rh r
r r� r
r r r� r r r! r! r! r$ �<module> sp # � U � ^ � T � J � d �
Mini Shell