U
|
O ±dô ã @ sP d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z
|
ddl m Z dd l mZ dd
|
lmZ d d d dddddgZejZdddddddddddddddZe
|
jZdd ZedG d d d ZG d d d e
|
jZG d d d eZd d Zed!d+d#dZ ed!d,d$dZ ed!d-d%dZ d&d' Z ed!d.d(dZ ed!d/d*dZ!dS )0a
|
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ÚitemÚcountsr! r! úId:\z\workplace\vscode\pyvenv\venv\Lib\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 ddZd ddZdd 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¤ |dkrt dt|tr6t dd t|D |¡}n t ||¡}|j dkrht d|fg|¡}|j |j} fdd|D | _ fdd|D | _ t
|
|| _ dS )z Parse the field formats NzNeed formats argumentc S s g | ]\}}d |¡|fqS )zf{})Úformat)r" r Zformat_r! r! r% r& s z/format_parser._parseFormats.<locals>.<listcomp>Úf1c s g | ]} | d qS ©r r! ©r" Úkey©Úfieldsr! r% r& © s c s g | ]} | d qS r r! r9 r; r! r% r& ª s ) Ú
|
ValueErrorÚ
|
isinstancer( ÚsbÚdtypeÚ enumerater< r1 Ú
|
_f_formatsÚ_offsetsÚlenÚ_nfields)r/ r0 r3 r@ Úkeysr! r; r% r, s
|
þ zformat_parser._parseFormatsc C sø |rXt |ttfkrn&t|tr,| d¡}ntdt| dd |d| j
D | _ ng | _ | j dd t
|
t | j | jD 7 _ t | j }|rt 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& ¹ s z0format_parser._setfieldnames.<locals>.<listcomp>Nc S s g | ] }d | qS )zf%dr! ©r" r r! r! r% r& Á s zDuplicate field names: %sc S s g | ] }| ¡ qS r! rH rJ r! r! r% r& É s )Útyper( Útupler> ÚstrÚsplitÚ NameErrorÚreprrE Ú_namesÚrangerD r) r= Ú_titles)r/ r1 r2 Z_dupr! r! r% r- s(
|
ÿ
|
z format_parser._setfieldnamesc C sD t | j| j| j| jd¡}|d k r:t|d }| |¡}|| _d S )N)r1 r0 Úoffsetsr2 r )r? r@ rR rB rC rT Ú_byteorderconvZ newbyteorder)r/ r4 r@ r! r! r% r. Ñ s ü
|
zformat_parser._createdtype)FN)F)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r5 r, r- r. r! r! r! r% r W s
|
:
|
|
$c sT e Zd ZdZd Z dZ fddZ fddZdd 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 r[ )r rN r# r^ r] r` ra r! r% r] í s
|
zrecord.__str__c C s |dkrt j | |¡S zt j | |¡W S tk
|
r: Y nX t j | d¡j}| |d ¡}|r²| j|d d
}z
|
|j}W n tk
|
r | Y S X |jd k r®| | j
|
|jf¡S |S td| d S )N©ÚsetfieldÚgetfieldr@ r@ é ú%'record' object has no attribute '%s') ÚntÚvoidÚ__getattribute__ÚAttributeErrorr< Úgetre r@ r1 Úviewrb )r/ ÚattrÚ fielddictÚresÚobjÚdtr! r! r% rj ò s(
|
|
|
ÿzrecord.__getattribute__c C sx |dkrt d| tj | d¡j}| |d ¡}|rL| j|f|d d
S t| |d rhtj | ||¡S t d| d S )Nrc zCannot set '%s' attributer@ rf rg ) rk rh ri rj r< rl rd ÚgetattrÚ __setattr__)r/ rn Úvalro rp r! r! r% rt s ÿzrecord.__setattr__c C s@ t j | |¡}t|t jr8|jjd k r8| | j|jf¡S |S d S r+ )rh ri Ú __getitem__r> r@ r1 rm rb ©r/ Zindxrq r! r! r% rv 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>' s z record.pprint.<locals>.<genexpr>z %% %ds: %%sc s g | ]} |t |f qS r! )rs rx ©Úfmtr/ r! r% r& ) s z!record.pprint.<locals>.<listcomp>Ú
|
)r@ r1 ÚmaxÚjoin)r/ r1 ÚmaxlenÚrowsr! r{ r% Úpprint# s
|
z record.pprint) rW rX rY rZ r_ r] rj rt rv r Ú __classcell__r! r! ra r% r
|
ß s
|
c
|
s\ e Zd ZdZd Z dZdddZd d
|
Zd d Zd d Z fddZdd Z dddZ
|
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 k rt |¡} nt||||
|
| j} |d krFtj| |t| f| d} n tj| |t| f|||| d} | S )N)Úorder)ÚbufferÚoffsetÚstridesr
)r? r@ r ÚndarrayÚ__new__r
|
)ÚsubtypeÚshaper@ Úbufr r r0 r1 r2 r4 r3 r
Údescrr/ r! r! r% r ¢ s þzrecarray.__new__c C s$ | j jtk r | j jd k r | j | _ d S r+ )r@ rL r
|
r1 )r/ rq r! r! r% Ú__array_finalize__³ s zrecarray.__array_finalize__c
|
C sÊ zt | |¡W S tk
|
r" Y nX t | d¡j}z|| d d
}W n4 ttfk
|
rz } ztd| |W 5 d }~X Y nX | j| }|jj d k r¼t
|
|jj t j r¸|j| jj |jfdS |S | t¡S d S )Nr@ rf z recarray has no attribute %s©r@ )Úobjectrj rk r r< Ú TypeErrorÚKeyErrorre r@ r1 Ú
|
issubclassrL rh ri rm )r/ rn ro rp Úerq r! r! r% rj ¹ s
|
zrecarray.__getattribute__c
|
C s$ |dkr.t |jtjr.|jd k r.t t|f¡}|| jk}zt
|
| ||¡}W n0 t k
|
rz t | d¡jpji }||krv Y nNX t | d¡jpi }||kr|S |rÈzt | |¡ W n t k
|
rÆ | Y S X z|| d d
}W n6 ttfk
|
r } ztd| |W 5 d }~X Y nX | j|f| S )Nr@ rf z record array has no attribute %s)r rL rh ri r1 r? r@ r
|
Ú__dict__r rt Ú Exceptionr rj r< Ú __delattr__r r rk rd )r/ rn ru ZnewattrÚretro rp r r! r! r% rt Û s4
|
|
ÿþzrecarray.__setattr__c sp t |¡}t|trh|jjd k rZ| t| ¡}t|jjt j
|
rV|j| jj|jfdS |S |jtdS n|S d S )Nr )rL ) r^ rv r> r r@ r1 rm rL r rh ri rw ra r! r% rv ü s
|
zrecarray.__getitem__c C s¶ | j }| j jtks"t| j jtjsF|jtkr<t tj|f¡}d}d}nd}d}| jdksb| jdkrvtj | d|dd }nd
|
t
|
| jf }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 rh ri r? Úsizer Z array2stringrQ rD r )r/ Z
|
repr_dtyper r| ÚlstÚlfr! r! r% r_ s(
|
ÿ
|
zrecarray.__repr__c C s~ t |tr t | d¡j}|| }t | d¡j}|| d d
}|d krj| j| }|jjd k r`|S | t¡S | j |f| S d S )Nr@ rf )
|
r> Úintr rj r1 r< re r@ rm rd )r/ rn ru r1 ro rp rq r! r! r% Úfield. s
|
|
|
zrecarray.field)
|
NNr NNNNNFr )N) rW rX rY rZ r r rj rt rv r_ r¢ r r! r! ra r% r 4 s" j þ
|
"! !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 |}|dkr*| d j}nt|tr:|f}|dkrX|dkrXdd | D }|dk rlt |¡}nt|||||j}|j} t|t| krt d|d j}
|
t|
|
} | dkrÄ|d|
}t
|
||} t | D ]V\} }|| j } |jd|j |
}| | }||kr$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& } s z fromarrays.<locals>.<listcomp>Nr c S s g | ]
|
}|j qS r! r )r" rq r! r! r% r& s 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 r1 rD r= r rA Úndim)Z arrayListr@ r r0 r1 r2 r3 r4 r rR Zd0ÚnnÚ_arrayÚkrq Z testshapery r! r! r% r L s6 1
|
|
|
|
|
|
c sL |dkrP|dkrPt j| td fddt jd D }t|||||||dS |dk rht t|f¡} nt|||||j} zt j| | d}
|
W n t t
|
fk
|
r t |}|dkrºt | }t |trÊ|f}t |dkrÞt
|
dt|| } t| jD ]} t| | | | < qòtjd td
|
d | Y S X |dk r>|
|
j|kr>||
|
_|
|
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 ©rq r! r% r& Ù s z fromrecords.<locals>.<listcomp>éÿÿÿÿ)r0 r r1 r2 r3 r4 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 errorrf r¤ )r? r r rS r r r@ r
|
r r r= r© rD r> r¡ r r rM r¦ r§ r¨ rm )ZrecListr@ r r0 r1 r2 r3 r4 Zarrlistr Úretvalr r® rp r! r° r% r « sD ,
|
ÿ
|
|
ý
|
|
c C sx |dkr|dkrt d|dk r,t |¡} nt|||||j} | j}
|
t|}|dkrdt| | |
|
}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 r0 r1 r2 r3 r4 r r³ r r! r! r% r s 8 c
|
C s8 | ¡ }z | dd¡ | ¡ | W ¢S | |d¡ X d S )Nr rf )ÚtellÚseek)ÚfdÚposr! r! r% Úget_remaining_sizeK s
|
r¸ c C s\ |dkr|dkrt dt|}|dkr.d}nt|tr>|f}t| drRt| } ntt| d} | î} |dkrz| |d¡ t | }
|
|dk rt
|
|¡} nt |||||j } | j } t
|
|¡jtjd} | | }|dk r t|}|
|
| || d ¡< t|}t
|
|¡jtjd} | | }||
|
kr&td
|
t|| }| |j¡}||krNtd W 5 Q R X |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 Úprodrh Zintpr( ÚindexrM r= r r¹ ÚdataÚOSError)r¶ r@ r r r0 r1 r2 r3 r4 Úctxr r r³ Z shapeprodZ shapesizeÚnbytesr Z
|
nbytesreadr! r! r% r T sF .
|
|
|
|
|
ÿ
|
|
Tc C s$ t | tdtfs t| dr4|dkr4|dkr4tdi } |dk rLt |¡}n,|dk rht||||| j}n||||| d} | dkr¢|dkrtdt||| ||dS t | t rÄt
|
| |f||d| S t | t t frt | d t t f rþt | f||d | S t| f||d | S nt | tr\|dk rF| j|krF| |¡} n| } |
|
rX| ¡ } | S t| drxt| |||d
|
S t | trÂ|dk r¦| j|kr¦| |¡} n| } |
|
r¸| ¡ } | t¡S t| d d} | dksät | tsìtd t | ¡} |dk r| j|kr| |¡} | 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)r0 r1 r2 r3 r4 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 rm Úcopyr r rs Údictr )rq r@ r r r r0 r1 r2 r3 r4 rÄ ÚkwdsÚnewZ interfacer! r! r% r ¹ sj U ÿÿ ÿü
|
|
|
|
)NNNNNFN)NNNNNFN)NNr NNNFN)NNr NNNFN)
|
NNr NNNNFNT)"rZ r¦ Ú collectionsr Ú
|
contextlibr Ú r r? r rh Z numpy.compatr Znumpy.core.overridesr Z
|
arrayprintr Ú__all__r rV Z
|
sctypeDictZnumfmtr) r ri r
|
r r© r r r r¸ r r r! r! r! r% Ú<module> s # þó U ÿ ^ ÿ T ÿ J ÿ d ÿ
|
