Ë
|
Kñúh$ï ã ój d Z ddlZddlZddlmZ ddlmc mZ ddl m
|
Z
|
ddl m Z g d¢Z d Z e
|
e« d « Zd Zd Zd
|
Zd Zd7d Zd7d Zd8dZd Zd Zd9dZd:dZd;dZ d<dZ e
|
e « d=d« Z d8dZ e
|
e « d:d« Z d:dZ d Z! e
|
e!« d « Z"d Z# e
|
e#« d « Z$ d<d Z% e
|
e%« d>d « Z&d;d Z' e
|
e'« d;d « Z(d8d!Z) e
|
e)« d?d"« Z*d@d#Z+d$ Z, dAd%Z- e
|
e-« dBd&« Z. dCd'Z/ e
|
e/« dDd(« Z0d) Z1 e
|
e1« d* « Z2d;d+Z3 e
|
e3« dEd,« Z4d- Z5 e
|
e5« d. « Z6 d<d/Z7 e
|
e7« dFd0« Z8 dAd1Z9 e
|
e9« dGd2« Z: dHd3Z; e
|
e;« dId4« Z< d<d5Z= e
|
e=« dJd6« Z>[
|
y)KzÆ
|
Collection of utilities to manipulate structured arrays.
|
|
Most of these functions were initially implemented by John Hunter for
|
matplotlib. They have been rewritten and extended for convenience.
|
|
é N)Úarray_function_dispatch)Ú_is_string_like)Ú append_fieldsÚapply_along_fieldsÚassign_fields_by_nameÚ drop_fieldsÚfind_duplicatesÚ flatten_descrÚget_fieldstructureÚ get_namesÚget_names_flatÚjoin_byÚ merge_arraysÚrec_append_fieldsÚrec_drop_fieldsÚrec_joinÚrecursive_fill_fieldsÚ rename_fieldsÚ repack_fieldsÚrequire_fieldsÚ stack_arraysÚstructured_to_unstructuredÚunstructured_to_structuredc ó
|
| |fS ©N© )ÚinputÚoutputs úIH:\Change_password\venv_build\Lib\site-packages\numpy/lib/recfunctions.pyÚ!_recursive_fill_fields_dispatcherr s Ø 6?Ðó c óØ |j }|j D ]? } | | }|j j t ||| « /||| dt |« A |S # t $ r Y Ow xY w)a
|
Fills fields from output with fields from input,
|
with support for nested structures.
|
|
Parameters
|
----------
|
input : ndarray
|
Input array.
|
output : ndarray
|
Output array.
|
|
Notes
|
-----
|
* `output` should be at least the same size as `input`
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> a = np.array([(1, 10.), (2, 20.)], dtype=[('A', np.int64), ('B', np.float64)])
|
>>> b = np.zeros((3,), dtype=a.dtype)
|
>>> rfn.recursive_fill_fields(a, b)
|
array([(1, 10.), (2, 20.), (0, 0.)], dtype=[('A', '<i8'), ('B', '<f8')])
|
|
N)ÚdtypeÚnamesÚ
|
ValueErrorr Úlen)r r ÚnewdtypeÚfieldÚcurrents r r r s} ð6 ||HØ ò 3ð ØElGð ==× Ñ Ð *Ü ! '¨6°%©=Õ 9à+2F5M-3w<Ñ (ð3ð Møô ò Ù ð ús A Á A)Á(A)c óº j d fgS fd j D « }|D cg c]! \ }}t |« dk( r|n|d |f|d f# c}}S c c}}w )am
|
Produce a list of name/dtype pairs corresponding to the dtype fields
|
|
Similar to dtype.descr, but the second item of each tuple is a dtype, not a
|
string. As a result, this handles subarray dtypes
|
|
Can be passed to the dtype constructor to reconstruct the dtype, noting that
|
this (deliberately) discards field offsets.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> dt = np.dtype([(('a', 'A'), np.int64), ('b', np.double, 3)])
|
>>> dt.descr
|
[(('a', 'A'), '<i8'), ('b', '<f8', (3,))]
|
>>> _get_fieldspec(dt)
|
[(('a', 'A'), dtype('int64')), ('b', dtype(('<f8', (3,))))]
|
|
Ú c 3 ó@ K | ] }|j | f y wr )Úfields)Ú.0Únamer# s r ú <genexpr>z!_get_fieldspec.<locals>.<genexpr>_ s øè ø ÒE°4 dÑ+Ô,ÑEùs é r )r$ r& )r# r- r/ Úfs ` r Ú_get_fieldspecr3 G sl ø ð( {{ÐàU }Ð ãE¸¿¹ÔEð "÷
|
áaô Vq[T q¨¡t¨T l°A°a±DÒ 9ó
|
ð
|
ùó
|
s &Ac óÒ g }| j }|D ]J }| | }|j &|j |t t |« « f« :|j |« L t |« S )ab
|
Returns the field names of the input datatype as a tuple. Input datatype
|
must have fields otherwise error is raised.
|
|
Parameters
|
----------
|
adtype : dtype
|
Input datatype
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> rfn.get_names(np.empty((1,), dtype=[('A', int)]).dtype)
|
('A',)
|
>>> rfn.get_names(np.empty((1,), dtype=[('A',int), ('B', float)]).dtype)
|
('A', 'B')
|
>>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
|
>>> rfn.get_names(adtype)
|
('a', ('b', ('ba', 'bb')))
|
)r$ ÚappendÚtupler ©ÚadtypeÚ listnamesr$ r/ r) s r r r g sl ð, IØ LLEØò #Ø,Ø ==Ð $Ø × Ñ d¤E¬)°GÓ*<Ó$=Ð >Õ ?à × Ñ TÕ "ð #ô Ó Ðr! c ó¼ g }| j }|D ]? }|j |« | | }|j &|j t |« « A t |« S )a¡
|
Returns the field names of the input datatype as a tuple. Input datatype
|
must have fields otherwise error is raised.
|
Nested structure are flattened beforehand.
|
|
Parameters
|
----------
|
adtype : dtype
|
Input datatype
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> rfn.get_names_flat(np.empty((1,), dtype=[('A', int)]).dtype) is None
|
False
|
>>> rfn.get_names_flat(np.empty((1,), dtype=[('A',int), ('B', str)]).dtype)
|
('A', 'B')
|
>>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
|
>>> rfn.get_names_flat(adtype)
|
('a', 'b', 'ba', 'bb')
|
)r$ r5 Úextendr r6 r7 s r r r sb ð. IØ LLEØò 6Ø×ÑÔ Ø,Ø ==Ñ $Ø × Ñ ^¨GÓ 4Õ 5ð 6ô
|
Ó Ðr! c óè | j }|d| ffS g }|D ]N }| j | \ }}|j |j t |« « <|j ||f« P t |« S )a_
|
Flatten a structured data-type description.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> ndtype = np.dtype([('a', '<i4'), ('b', [('ba', '<f8'), ('bb', '<i4')])])
|
>>> rfn.flatten_descr(ndtype)
|
(('a', dtype('int32')), ('ba', dtype('float64')), ('bb', dtype('int32')))
|
|
r+ )r$ r- r; r
|
r5 r6 )Úndtyper$ Údescrr( ÚtypÚ_s r r
|
r
|
© s{ ð LLEØ }ØV Ð àØò +EØ }} UÑ+HS!ØyyÐ$Ø ]¨3Ó /Õ0à e S\Õ*ð +ô U|Ðr! c óV g }|r,| D ]& }|j t |j « « ( ne| D ]` }|j }|j 3t |j « dk( r|j t |« « N|j d|f« b t j |« S )Né r+ )r; r
|
r# r$ r& r3 r5 Únp)Ú seqarraysÚflattenr' Úar) s r Ú
|
_zip_dtyperG Ä s ØHÙØò 4AØ OOM¨!¯'©'Ó 2Õ 3ñ 4ð ò /AØggGØ}}Ð(¬S°· ± Ó-?À1Ò-DनwÓ 7Õ8à W Õ.ð /ô 88HÓ Ð r! c ó0 t | |¬« j S )zî
|
Combine the dtype description of a series of arrays.
|
|
Parameters
|
----------
|
seqarrays : sequence of arrays
|
Sequence of arrays
|
flatten : {boolean}, optional
|
Whether to collapse nested descriptions.
|
©rE )rG r> )rD rE s r Ú
|
_zip_descrrJ Ô s ô i¨Ô 1× 7Ñ 7Ð7r! c ó. |i }| j }|D ] }| | }|j +|r|g||< ng ||< |j t |||« « ?t |j |g « xs g « }|r|j |« n|r|g}|xs g ||< |S )a}
|
Returns a dictionary with fields indexing lists of their parent fields.
|
|
This function is used to simplify access to fields nested in other fields.
|
|
Parameters
|
----------
|
adtype : np.dtype
|
Input datatype
|
lastname : optional
|
Last processed field name (used internally during recursion).
|
parents : dictionary
|
Dictionary of parent fields (used internally during recursion).
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> ndtype = np.dtype([('A', int),
|
... ('B', [('BA', int),
|
... ('BB', [('BBA', int), ('BBB', int)])])])
|
>>> rfn.get_fieldstructure(ndtype)
|
... # XXX: possible regression, order of BBA and BBB is swapped
|
{'A': [], 'B': [], 'BA': ['B'], 'BB': ['B'], 'BBA': ['B', 'BB'], 'BBB': ['B', 'BB']}
|
|
)r$ Úupdater ÚlistÚgetr5 )r8 ÚlastnameÚparentsr$ r/ r) Ú
|
lastparents r r r â s° ð6 ØØ LLEØò -Ø,Ø ==Ð $ÙØ!) à " Ø NNÔ-¨g°t¸WÓEÕ Fä gkk¨(°BÓ 7Ò =¸2Ó>JÙØ×!Ñ! (Õ+ÙØ &\
|
Ø &Ò ,¨"GDMð -ð Nr! c # ó K | D ]= }t |t j « r t t |« « E d{ :| ? y7 w)zu
|
Returns an iterator of concatenated fields from a sequence of arrays,
|
collapsing any nested structure.
|
|
N)Ú
|
isinstancerC ÚvoidÚ_izip_fields_flatr6 ©ÚiterableÚelements r rU rU s? è ø ð ò Ü grwwÔ 'Ü(¬¨w« Ó8× 8Ñ 8àMñ à 8ús 7A¹Aº Ac # ó K | D ]{ }t |d« r$t |t « st |« E d{ 3t |t j
|
« r+t t |« « dk( rt |« E d{ x| } y7 Q7 w)zP
|
Returns an iterator of concatenated fields from a sequence of arrays.
|
|
Ú__iter__NrB )ÚhasattrrS ÚstrÚ _izip_fieldsrC rT r& r6 rV s r r] r] su è ø ð
|
ò Ü GZÔ (Ü w¬Ô,Ü# GÓ,× ,Ñ ,Ü ¤§¡Ô )¬c´%¸³.Ó.AÀQÒ.Fä# GÓ,× ,Ñ ,àMñð -øð -ús" 0B²B³ABÁ7BÁ8 BÂBc # ó K |rt }nt }t j | d|iD ] }t ||« « yw)a*
|
Returns an iterator of concatenated items from a sequence of arrays.
|
|
Parameters
|
----------
|
seqarrays : sequence of arrays
|
Sequence of arrays.
|
fill_value : {None, integer}
|
Value used to pad shorter iterables.
|
flatten : {True, False},
|
Whether to
|
Ú fillvalueN)rU r] Ú itertoolsÚ zip_longestr6 )rD Ú
|
fill_valuerE ÚzipfuncÚtups r Ú _izip_recordsre / sC è ø ñ Ü#ä ä×$Ñ$ iÐF¸:ÑFò "ÜGCLÓ!Ó!ñ"ùs >A c óô t | t j « sd}|r#|r | j t j
|
« } | S t j | « } |r | j t j « } | S )z
|
Private function: return a recarray, a ndarray, a MaskedArray
|
or a MaskedRecords depending on the input parameters
|
F) rS ÚmaÚ MaskedArrayÚviewÚmrecÚ MaskedRecordsÚfilledrC Úrecarray)r ÚusemaskÚ
|
asrecarrays r Ú _fix_outputrp G sb ô
|
fbnnÔ -ØÙÙ Ø[[¤×!3Ñ!3Ó4Fð
|
Mô 6Ó"Ù Ø[[¤§¡Ó-FØ Mr! c óÜ | j j }| j | j | j }}}|xs i j « D ] \ }}||v s |||< ||| || < | S )zp
|
Update the fill_value and masked data of `output`
|
from the default given in a dictionary defaults.
|
)r# r$ ÚdataÚmaskrb Úitems)r Údefaultsr$ rr rs rb ÚkÚvs r Ú _fix_defaultsrx X sw ð
|
LL× Ñ EØ &§ ¡ ¨V¯[©[¸&×:KÑ:K4TØ>r×(Ñ(Ó*ò !AØ :Ø JqMØ DGDGÒ ð!ð Mr! c ó | S r r )rD rb rE rn ro s r Ú_merge_arrays_dispatcherrz f s à Ðr! c ó$ t | « dk( rt j | d « } t | t j t j
|
f« r³| j }|j t j d|fg« }|rt | fd¬« |k( rl| j « } |r$|rt j }n4t j }n#|rt j }nt j }| j ||¬« S | f} n"| D cg c] }t j |« } }t! d | D « « }t# |« } t | |¬« }
|
g } g } |rêt% | |« D ]` \ } }| |z
|
}| j « j' « }t j( | « j « }|r¼t j* || j « }t |t j t j
|
f« rvt |j « dk( r|j- « d }d}nHt j. || j d¬ « }t j0 d
|
|j ¬ « }nd}d}| j3 t5 j6 ||g|z « « | j3 t5 j6 |g|z « « c t! t9 | |¬« « }t j. t j: ||
|
| ¬ « t= t9 | |¬« « ¬ « }|r |j t j « }|S t% | |« D ]î \ } }| |z
|
}| j « j' « }|rt j* || j « }t |t j t j
|
f« rQt |j « dk( r|j- « d }n%t j. || j d¬ « }nd}| j3 t5 j6 ||g|z « « ð t j: t! t9 | |¬« « |
|
| ¬ « }|r |j t j « }|S c c}w )am
|
Merge arrays field by field.
|
|
Parameters
|
----------
|
seqarrays : sequence of ndarrays
|
Sequence of arrays
|
fill_value : {float}, optional
|
Filling value used to pad missing data on the shorter arrays.
|
flatten : {False, True}, optional
|
Whether to collapse nested fields.
|
usemask : {False, True}, optional
|
Whether to return a masked array or not.
|
asrecarray : {False, True}, optional
|
Whether to return a recarray (MaskedRecords) or not.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> rfn.merge_arrays((np.array([1, 2]), np.array([10., 20., 30.])))
|
array([( 1, 10.), ( 2, 20.), (-1, 30.)],
|
dtype=[('f0', '<i8'), ('f1', '<f8')])
|
|
>>> rfn.merge_arrays((np.array([1, 2], dtype=np.int64),
|
... np.array([10., 20., 30.])), usemask=False)
|
array([(1, 10.0), (2, 20.0), (-1, 30.0)],
|
dtype=[('f0', '<i8'), ('f1', '<f8')])
|
>>> rfn.merge_arrays((np.array([1, 2]).view([('a', np.int64)]),
|
... np.array([10., 20., 30.])),
|
... usemask=False, asrecarray=True)
|
rec.array([( 1, 10.), ( 2, 20.), (-1, 30.)],
|
dtype=[('a', '<i8'), ('f1', '<f8')])
|
|
Notes
|
-----
|
* Without a mask, the missing value will be filled with something,
|
depending on what its corresponding type:
|
|
* ``-1`` for integers
|
* ``-1.0`` for floating point numbers
|
* ``'-'`` for characters
|
* ``'-1'`` for strings
|
* ``True`` for boolean values
|
* XXX: I just obtained these values empirically
|
rB r Nr+ TrI )r# Útypec 3 ó4 K | ] }|j y wr )Úsize)r. rF s r r0 z merge_arrays.<locals>.<genexpr>¹ s è ø Ò,Q!&&Ñ,ùs )r# Úndmin)rB ©r# )r# Úcount)rs ) r& rC Ú
|
asanyarrayrS ÚndarrayrT r# r$ rG Úravelrj rk rg rh rm ri r6 ÚmaxÚzipÚ __array__Ú getmaskarrayÚ_check_fill_valueÚitemÚarrayÚonesr5 r` Úchainre ÚfromiterrM )rD rb rE rn ro ÚseqdtypeÚseqtypeÚ_mÚsizesÚ maxlengthr' ÚseqdataÚseqmaskrF ÚnÚ nbmissingrr rs ÚfvalÚfmskr s r r r k s ôd I!ÒÜMM )¨A¡,Ó/ ä)bjj¬"¯'©'Ð 2Ô3Ø ??à >>Ð !Üxx " h Ð 0Ó1HÙ* i \¸4Ô@ÀHÒLà!Ó)IáÙ Ü "× 0Ñ 0Gä nnGÙÜ ++ä **Ø >>¨°w>Ó?Ð ?à" Ið 2;Ö;¨2R]] 2Õ&Ð; Ð;ä Ñ, )Ô,Ó ,EÜE
|
Iä)¨WÔ5HàGØGâÜ) UÓ+ó FFQØ" Q Ià779×&Ñ&Ó(DÜ?? 1Ó%×+Ñ+Ó-DáÜ×-Ñ-¨j¸!¿'¹'ÓBÜ d¤R§Z¡Z´·±Ð$9Ô:Ü4::¨!Ò+Ø #yy{¨1~Ø #ä !xx¨°A·G±GÀ1Ô EÜ !ww t°4·:±:Ô >àØà NN9??¨4°$°¸)Ñ1CÓDÔ EØ NN9??¨4°$°¸)Ñ1CÓDÖ Eð) Fô, ] 7°GÔ<Ó=Ü"++ d°(À)ÔLÜ #¤M°'À7Ô$KÓ LôNá Ø[[¤×!3Ñ!3Ó4Fð* Mô% ) UÓ+ò FFQØ" Q IØ779×&Ñ&Ó(DÙÜ×-Ñ-¨j¸!¿'¹'ÓBÜ d¤R§Z¡Z´·±Ð$9Ô:Ü4::¨!Ò+Ø #yy{¨1~ä !xx¨°A·G±GÀ1Ô EàØ NN9??¨4°$°¸)Ñ1CÓDÕ Eð Fô U¤=°À'Ô#JÓ KØ#+°9ô>á Ø[[¤§¡Ó-Fà Mùòu <s Ä R c ó | fS r r )ÚbaseÚ
|
drop_namesrn ro s r Ú_drop_fields_dispatcherr ô ó Ø 7Nr! c óÞ t |« r|g}n t |« }fd | j |« }t j | j
|
|¬« }t | |« }t |||¬« S )a
|
Return a new array with fields in `drop_names` dropped.
|
|
Nested fields are supported.
|
|
Parameters
|
----------
|
base : array
|
Input array
|
drop_names : string or sequence
|
String or sequence of strings corresponding to the names of the
|
fields to drop.
|
usemask : {False, True}, optional
|
Whether to return a masked array or not.
|
asrecarray : string or sequence, optional
|
Whether to return a recarray or a mrecarray (`asrecarray=True`) or
|
a plain ndarray or masked array with flexible dtype. The default
|
is False.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> a = np.array([(1, (2, 3.0)), (4, (5, 6.0))],
|
... dtype=[('a', np.int64), ('b', [('ba', np.double), ('bb', np.int64)])])
|
>>> rfn.drop_fields(a, 'a')
|
array([((2., 3),), ((5., 6),)],
|
dtype=[('b', [('ba', '<f8'), ('bb', '<i8')])])
|
>>> rfn.drop_fields(a, 'ba')
|
array([(1, (3,)), (4, (6,))], dtype=[('a', '<i8'), ('b', [('bb', '<i8')])])
|
>>> rfn.drop_fields(a, ['ba', 'bb'])
|
array([(1,), (4,)], dtype=[('a', '<i8')])
|
c óÄ | j }g }|D ]K }| | }||v r |j ||« }|s%|j ||f« 9|j ||f« M |S r )r$ r5 )r= r r$ r' r/ r) r> Ú _drop_descrs r r¡ z drop_fields.<locals>._drop_descr st ø Ø ØØò 1DØ TlGØzÑ!ØØ}}Ð(Ù# G¨ZÓ8ÚØ OO T¨5 MÕ2à w Õ0ð 1ð r! r ©rn ro )r Úsetr# rC ÚemptyÚshaper rp )r r rn ro r' r r¡ s @r r r ø sd ø ôF zÔ"Ø \
|
ä_
|
ô ñ 4:: zÓ2Hä XXdjj¨Ô 1FÜ " 4¨Ó 0FÜ v w¸:Ô FÐFr! c ó¾ |D cg c] }|| j | f }}t j | j |¬« }t | |« }t |||¬« S c c}w )a
|
Return a new array keeping only the fields in `keep_names`,
|
and preserving the order of those fields.
|
|
Parameters
|
----------
|
base : array
|
Input array
|
keep_names : string or sequence
|
String or sequence of strings corresponding to the names of the
|
fields to keep. Order of the names will be preserved.
|
usemask : {False, True}, optional
|
Whether to return a masked array or not.
|
asrecarray : string or sequence, optional
|
Whether to return a recarray or a mrecarray (`asrecarray=True`) or
|
a plain ndarray or masked array with flexible dtype. The default
|
is False.
|
r r¢ )r# rC r¤ r¥ r rp )r Ú
|
keep_namesrn ro r r' r s r Ú _keep_fieldsr¨ 6 sX ð& -7Ö7 qDJJqMÒ"Ð7HÐ7Ü XXdjj¨Ô 1FÜ " 4¨Ó 0FÜ v w¸:Ô FÐFùò 8s
Ac ó | fS r r ©r r s r Ú_rec_drop_fields_dispatcherr« O r r! c ó t | |dd¬« S )zK
|
Returns a new numpy.recarray with fields in `drop_names` dropped.
|
FTr¢ )r rª s r r r S s ô
|
tZ°À4Ô HÐHr! c ó | fS r r )r Ú
|
namemappers r Ú_rename_fields_dispatcherr¯ [ r r! c óV fd | j |« }| j |« S )aÜ
|
Rename the fields from a flexible-datatype ndarray or recarray.
|
|
Nested fields are supported.
|
|
Parameters
|
----------
|
base : ndarray
|
Input array whose fields must be modified.
|
namemapper : dictionary
|
Dictionary mapping old field names to their new version.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> a = np.array([(1, (2, [3.0, 30.])), (4, (5, [6.0, 60.]))],
|
... dtype=[('a', int),('b', [('ba', float), ('bb', (float, 2))])])
|
>>> rfn.rename_fields(a, {'a':'A', 'bb':'BB'})
|
array([(1, (2., [ 3., 30.])), (4, (5., [ 6., 60.]))],
|
dtype=[('A', '<i8'), ('b', [('ba', '<f8'), ('BB', '<f8', (2,))])])
|
|
c óÐ g }| j D ]S }|j ||« }| | }|j |j | ||« f« A|j ||f« U |S r )r$ rN r5 )r= r® r' r/ Únewnamer) Ú_recursive_rename_fieldss r r³ z/rename_fields.<locals>._recursive_rename_fieldsx st ø ØØLLò 4DØ nn T¨4Ó0GØ TlGØ}}Ð(ØØ Ñ 6°wÀ
|
Ó KÐLõð ¨'Ð 2Õ3ð 4ð r! )r# ri )r r® r' r³ s @r r r _ s) ø ô2 ñ (¨¯
|
©
|
°JÓ?HØ 99XÓ Ð r! c # ó, K | |E d { y 7 wr r )r r$ rr Údtypesrb rn ro s r Ú_append_fields_dispatcherr¶ s è ø à
|
JØOOúó
|
c óP t |t t f« r$t |« t |« k7 r#d}t |« t |t
|
« r|g}|g}|`|D cg c] }t j |dd¬« }}t ||« D cg c]# \ } }|j | |j fg« % }} }n¥t |t t f« s|g}t |« t |« k7 r*t |« dk( r|t |« z }n d}t |« t |||« D
|
cg c]1 \ }}
|
} t j |dd| ¬« j |
|
| fg« 3 }}
|
}} t | ||¬« } t |« dkD rt |d||¬ « }n|j « }t j t t | « t |« « t! | j « t! |j « z ¬
|
« } t# | | « } t# || « } t% | ||¬ « S c c}w c c}} w c c} }
|
}w ) a
|
Add new fields to an existing array.
|
|
The names of the fields are given with the `names` arguments,
|
the corresponding values with the `data` arguments.
|
If a single field is appended, `names`, `data` and `dtypes` do not have
|
to be lists but just values.
|
|
Parameters
|
----------
|
base : array
|
Input array to extend.
|
names : string, sequence
|
String or sequence of strings corresponding to the names
|
of the new fields.
|
data : array or sequence of arrays
|
Array or sequence of arrays storing the fields to add to the base.
|
dtypes : sequence of datatypes, optional
|
Datatype or sequence of datatypes.
|
If None, the datatypes are estimated from the `data`.
|
fill_value : {float}, optional
|
Filling value used to pad missing data on the shorter arrays.
|
usemask : {False, True}, optional
|
Whether to return a masked array or not.
|
asrecarray : {False, True}, optional
|
Whether to return a recarray (MaskedRecords) or not.
|
|
z7The number of arrays does not match the number of namesNT)ÚcopyÚsubokrB z5The dtypes argument must be None, a dtype, or a list.)r¹ rº r# )rn rb )rE rn rb r r¢ )rS r6 rM r& r% r\ rC r r ri r# r Úpoprg Ú
|
masked_allr
r3 r rp ) r r$ rr rµ rb rn ro ÚmsgrF r/ r Údr s r r r sí ô@ %%¤ Ô'Ü u:TÒ "ØKCÜ S/Ð !Ü E3Ô Ø Øxà ~Ø<@ÖA°q ¨TÖ2ÐAÐAÜ;>¸uÀdÓ;K×L©i¨t°QqwwÐ(Õ)ÐLÒLä&¤5¬$ -Ô0Ø ZFÜ t9F Ò #Ü6{aÒ Ø ¤# d£)Ñ+àMÜ oÐ%ä!$ T¨5°&Ó!9÷;ð ;Ù Q1ô ¨T¸Ô;×@Ñ@À1ÀaÀ&ÀÕJð ;ò ;ô g¸*Ô EDÜ
|
4y1}ÜD¨$¸Ø'1ô3ð xxzä ]]Ü CIs4yÓ!Ü TZZÓ(¬>¸$¿*¹*Ó+EÑEôGFô # 4¨Ó 0FÜ " 4¨Ó 0Fä v w¸:Ô FÐFùò7 BùÛLùô;s Á HÂ(HÄ 6H!c # ó, K | |E d { y 7 wr r ©r r$ rr rµ s r Ú _rec_append_fields_dispatcherrÁ Õ s è ø Ø
|
JØOOúr· c ó$ t | |||dd¬« S )aM
|
Add new fields to an existing array.
|
|
The names of the fields are given with the `names` arguments,
|
the corresponding values with the `data` arguments.
|
If a single field is appended, `names`, `data` and `dtypes` do not have
|
to be lists but just values.
|
|
Parameters
|
----------
|
base : array
|
Input array to extend.
|
names : string, sequence
|
String or sequence of strings corresponding to the names
|
of the new fields.
|
data : array or sequence of arrays
|
Array or sequence of arrays storing the fields to add to the base.
|
dtypes : sequence of datatypes, optional
|
Datatype or sequence of datatypes.
|
If None, the datatypes are estimated from the `data`.
|
|
See Also
|
--------
|
append_fields
|
|
Returns
|
-------
|
appended_array : np.recarray
|
TF)rr rµ ro rn )r rÀ s r r r Ú s ô> u¨4¸Ø$(°%ô 9ð 9r! c ó | fS r r )rF ÚalignÚrecurses r Ú_repack_fields_dispatcherrÆ ý s Ø 4Kr! c óÞ t | t j « s+t | j ||¬« }| j |d¬« S | j
|
| S g }| j
|
D ]R }| j | }|rt |d |d¬« }n|d }t |« dk( r|d |f}|j ||f« T t j ||¬« }t j | j |f« S ) a#
|
Re-pack the fields of a structured array or dtype in memory.
|
|
The memory layout of structured datatypes allows fields at arbitrary
|
byte offsets. This means the fields can be separated by padding bytes,
|
their offsets can be non-monotonically increasing, and they can overlap.
|
|
This method removes any overlaps and reorders the fields in memory so they
|
have increasing byte offsets, and adds or removes padding bytes depending
|
on the `align` option, which behaves like the `align` option to
|
`numpy.dtype`.
|
|
If `align=False`, this method produces a "packed" memory layout in which
|
each field starts at the byte the previous field ended, and any padding
|
bytes are removed.
|
|
If `align=True`, this methods produces an "aligned" memory layout in which
|
each field's offset is a multiple of its alignment, and the total itemsize
|
is a multiple of the largest alignment, by adding padding bytes as needed.
|
|
Parameters
|
----------
|
a : ndarray or dtype
|
array or dtype for which to repack the fields.
|
align : boolean
|
If true, use an "aligned" memory layout, otherwise use a "packed" layout.
|
recurse : boolean
|
If True, also repack nested structures.
|
|
Returns
|
-------
|
repacked : ndarray or dtype
|
Copy of `a` with fields repacked, or `a` itself if no repacking was
|
needed.
|
|
Examples
|
--------
|
>>> import numpy as np
|
|
>>> from numpy.lib import recfunctions as rfn
|
>>> def print_offsets(d):
|
... print("offsets:", [d.fields[name][1] for name in d.names])
|
... print("itemsize:", d.itemsize)
|
...
|
>>> dt = np.dtype('u1, <i8, <f8', align=True)
|
>>> dt
|
dtype({'names': ['f0', 'f1', 'f2'], 'formats': ['u1', '<i8', '<f8'], 'offsets': [0, 8, 16], 'itemsize': 24}, align=True)
|
>>> print_offsets(dt)
|
offsets: [0, 8, 16]
|
itemsize: 24
|
>>> packed_dt = rfn.repack_fields(dt)
|
>>> packed_dt
|
dtype([('f0', 'u1'), ('f1', '<i8'), ('f2', '<f8')])
|
>>> print_offsets(packed_dt)
|
offsets: [0, 1, 9]
|
itemsize: 17
|
|
)rÄ rÅ F)r¹ r Té r1 ©rÄ )
|
rS rC r# r Úastyper$ r- r& r5 r| )rF rÄ rÅ ÚdtÚ fieldinfor/ rd Úfmts r r r sÜ ôz aÔ "Ü 177¨%¸Ô AØxx xÓ'Ð'àwwØàIØò
|
&ØhhtnÙ Ü A¡¨e¸TÔBCàa&Cä s8q=ØFD>Dà×Ñ$ Õ%ð
|
&ô
|
) 5Ô )BÜ 88QVVRLÓ !Ð!r! c óà d }g }| j D ]Ò }| j | }|d |d }} ||« \ }}|j .|j t j ||ff« |||z f« at |||z « } |j }
|
t |« D ]I } | dk( r|j | « |j | D cg c] \ } } }| | || |
|
z z f c}} } « K Ô |S c c}} } w )z£
|
Returns a flat list of (dtype, count, offset) tuples of all the
|
scalar fields in the dtype "dt", including nested fields, in left
|
to right order.
|
c ó d}| j dk7 r2| j D ] }||z } | j } | j dk7 r2| |fS )NrB r )r¥ r )rË r r~ s r Ú
|
count_elemz+_get_fields_and_offsets.<locals>.count_elem^ sP ØØhh"nØò Ø ð àBð hh"nð 5yÐr! r rB ) r$ r- r5 rC r# Ú_get_fields_and_offsetsÚitemsizeÚranger; )rË ÚoffsetrÐ r- r/ r( Úf_dtÚf_offsetr Ú subfieldsr~ Úir¾ ÚcÚos r rÑ rÑ U sþ òð FØò SØ $Ø q 5¨¡8hÙ TÓ"aà ::Ð Ø MM288 T¨A¨4 LÓ1°1°hÀÑ6GÐHÕ Iä/°°hÀÑ6GÓHIØ==Dä1Xò SØ6àMM )Õ,àMMÀy×"QÐ"Q¹G¸A¸qÀ! A q¨!¨a°$©h©,Ò#7Ô"QÕRñ SðSð" Mùô #Rs ÃC)c ó( t | « dk r|S | d | d k }|r t t | « t |« « }n t | |« }d}d}|D ]; \ }}|dk7 r|r y||}||k7 r y||dz
|
|z z } n|} |||z
|
}
|
||
|
}||
|
k7 r y| }= |r| S |S )zì
|
Returns the stride between the fields, or None if the stride is not
|
constant. The values in "counts" designate the lengths of
|
subarrays. Subarrays are treated as many contiguous fields, with
|
always positive stride.
|
rB r N)r& r Úreversed) ÚoffsetsÚcountsrÒ ÚnegativeÚitÚ prev_offsetÚstriderÔ r Ú
|
end_offsetÚ
|
new_strides r Ú_common_striderå z sÞ ô 7|qÒØàqzG AJÑ&HÙä 'Ó"¤H¨VÓ$4Ó 5ä &Ó !àKØ FØò ! Ø A:ÙÙØ~Ø!ØÒ!ÙØ 5¨1¡9°Ñ"8Ñ8Jà Jà Ð "Ø +Ñ-JØ~Ø#ØÒ#Ùà ð'!ñ* ØwØ Mr! c ó | fS r r )Úarrr# r¹ Úcastings r Ú&_structured_to_unstructured_dispatcherré § ó à 6Mr! c óì | j j t d« t | j « }t |« }|dk( r | t d« |dk( r t d« t | \ }}}t |« D cg c] } d| }
|
} |+t j |D cg c] } | j c} nt j |« t j |
|
||| j j d« } | j | « } t | « t j t j t j fv } |s:| r7t# fd|D « « r"t% ||j « }|| j& }| j( t+ |« j fz }| j, t/ |« d fz }| d
|
t j0 f j t j2 « } | d
|
t5 |« d
f } t j6 j8 j; | ||d ¬ « } | j « d } |dk r
|
| d
|
ddd
f } t | « t |j< « ur || « } | S t j |
|
|D cg c] } | j( f c} d« }| j? |||¬« } | j t+ |« ff« S c c} w c c} w c c} w )a{
|
Converts an n-D structured array into an (n+1)-D unstructured array.
|
|
The new array will have a new last dimension equal in size to the
|
number of field-elements of the input array. If not supplied, the output
|
datatype is determined from the numpy type promotion rules applied to all
|
the field datatypes.
|
|
Nested fields, as well as each element of any subarray fields, all count
|
as a single field-elements.
|
|
Parameters
|
----------
|
arr : ndarray
|
Structured array or dtype to convert. Cannot contain object datatype.
|
dtype : dtype, optional
|
The dtype of the output unstructured array.
|
copy : bool, optional
|
If true, always return a copy. If false, a view is returned if
|
possible, such as when the `dtype` and strides of the fields are
|
suitable and the array subtype is one of `numpy.ndarray`,
|
`numpy.recarray` or `numpy.memmap`.
|
|
.. versionchanged:: 1.25.0
|
A view can now be returned if the fields are separated by a
|
uniform stride.
|
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
See casting argument of `numpy.ndarray.astype`. Controls what kind of
|
data casting may occur.
|
|
Returns
|
-------
|
unstructured : ndarray
|
Unstructured array with one more dimension.
|
|
Examples
|
--------
|
>>> import numpy as np
|
|
>>> from numpy.lib import recfunctions as rfn
|
>>> a = np.zeros(4, dtype=[('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)])
|
>>> a
|
array([(0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.]),
|
(0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.])],
|
dtype=[('a', '<i4'), ('b', [('f0', '<f4'), ('f1', '<u2')]), ('c', '<f4', (2,))])
|
>>> rfn.structured_to_unstructured(a)
|
array([[0., 0., 0., 0., 0.],
|
[0., 0., 0., 0., 0.],
|
[0., 0., 0., 0., 0.],
|
[0., 0., 0., 0., 0.]])
|
|
>>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
|
... dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
|
>>> np.mean(rfn.structured_to_unstructured(b[['x', 'z']]), axis=-1)
|
array([ 3. , 5.5, 9. , 11. ])
|
|
Nú arr must be a structured arrayr z(arr has no fields. Unable to guess dtypez#arr with no fields is not supportedr2 ©r$ ÚformatsrÝ rÒ c 3 ó< K | ] }|j k( y wr )r )r. rË Ú out_dtypes r r0 z-structured_to_unstructured.<locals>.<genexpr> s øè ø Ò&JÀ r§w¡w°)Õ';Ñ&Jùs rB .T)rº ©.r éÿÿÿÿ©r$ rî ©r¹ rè ) r# r$ r% rÑ r& ÚNotImplementedErrorr rÓ rC Ú result_typer rÒ ri r| r rm ÚmemmapÚallrå Ú__array_wrap__r¥ ÚsumÚstridesÚabsÚnewaxisÚuint8ÚminÚlibÚ stride_tricksÚ
|
as_stridedÚ__self__rÊ )rç r# r¹ rè r- Ún_fieldsÚdtsrÞ rÝ r r$ rË Úflattened_fieldsÚcan_viewÚ common_strideÚwrapÚ new_shapeÚ new_stridesÚ packed_fieldsrð s @r r r « s± ø ðx yyÐ ÜÐ9Ó:Ð:ä $ S§Y¡YÓ /FÜ6{HØ1} ÜÐCÓDÐDØ Q ä!Ð"GÓHÐHä <ÑCÜ # HoÖ .qWÐ .EÐ .à }ÜNN°sÖ$;° R§W£WÒ$;Ð< äHHUO ô xx¨%Ø,/Ø,3Ø-0¯Y©Y×-?Ñ-?ñ!Aó BÐð ((Ð#Ó
|
$Cô
|
CyRZZ¬¯©´b·i±iÐ @Ð@HÚ h¤3Ó&JÀcÔ&JÕ#Jô ' w°¸ ×8JÑ8JÓK Ø Ñ $Ø×%Ñ%Dà ¤S¨£[°)×2DÑ2DÐ$EÑEIØ ++¬¨]Ó);¸QÐ(?Ñ?Kàc2::oÑ&×+Ñ+¬B¯H©HÓ5CØc3w<=Ð(Ñ)CÜ&&×&Ñ&×1Ñ1°#Ø2;Ø2=Ø8<ð 2ó >Cð ((9Ó% fÑ-Cà qÒ Ø#t t)nÜCy¤ T§]¡]Ó 3Ñ3ñ 3iØJô HH uØJMÖ)NÀB¨9°b·h±hÒ*?Ò)Nñ Pó QMà
|
**]¨°w*Ó
|
?Cð 88Y¤ V£ Ð/Ó 0Ð0ùòq /ùò %<ùòb *Os Á> K'Â!K,ÊK1
|
c ó | fS r r )rç r# r$ rÄ r¹ rè s r Ú&_unstructured_to_structured_dispatcherr . rê r! c ó | j dk( r t d« | j d }|dk( r t d« |f|t |« D cg c] }d| }}t j
|
|D cg c] }|| j
|
f c}|¬« }t |« } t | \ }
|
} } n| t d« t j
|
|« }t |« } t | « dk( rg g g } } }
|
n t | \ }
|
} } |t | « k7 r t d « |}|r|j s t d
|
« t t | « « D cg c] }d| }}t j
|
||
|
D cg c] } | j
|
| j f c} d « }t j | « j |« } t j
|
||
|
| |j d « }| j |||¬ « } | j |« d S c c}w c c}w c c}w c c} w )a*
|
Converts an n-D unstructured array into an (n-1)-D structured array.
|
|
The last dimension of the input array is converted into a structure, with
|
number of field-elements equal to the size of the last dimension of the
|
input array. By default all output fields have the input array's dtype, but
|
an output structured dtype with an equal number of fields-elements can be
|
supplied instead.
|
|
Nested fields, as well as each element of any subarray fields, all count
|
towards the number of field-elements.
|
|
Parameters
|
----------
|
arr : ndarray
|
Unstructured array or dtype to convert.
|
dtype : dtype, optional
|
The structured dtype of the output array
|
names : list of strings, optional
|
If dtype is not supplied, this specifies the field names for the output
|
dtype, in order. The field dtypes will be the same as the input array.
|
align : boolean, optional
|
Whether to create an aligned memory layout.
|
copy : bool, optional
|
See copy argument to `numpy.ndarray.astype`. If true, always return a
|
copy. If false, and `dtype` requirements are satisfied, a view is
|
returned.
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
See casting argument of `numpy.ndarray.astype`. Controls what kind of
|
data casting may occur.
|
|
Returns
|
-------
|
structured : ndarray
|
Structured array with fewer dimensions.
|
|
Examples
|
--------
|
>>> import numpy as np
|
|
>>> from numpy.lib import recfunctions as rfn
|
>>> dt = np.dtype([('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)])
|
>>> a = np.arange(20).reshape((4,5))
|
>>> a
|
array([[ 0, 1, 2, 3, 4],
|
[ 5, 6, 7, 8, 9],
|
[10, 11, 12, 13, 14],
|
[15, 16, 17, 18, 19]])
|
>>> rfn.unstructured_to_structured(a, dt)
|
array([( 0, ( 1., 2), [ 3., 4.]), ( 5, ( 6., 7), [ 8., 9.]),
|
(10, (11., 12), [13., 14.]), (15, (16., 17), [18., 19.])],
|
dtype=[('a', '<i4'), ('b', [('f0', '<f4'), ('f1', '<u2')]), ('c', '<f4', (2,))])
|
|
r z$arr must have at least one dimensionrò r z&last axis with size 0 is not supportedr2 rÉ z!don't supply both dtype and nameszVThe length of the last dimension of arr must be equal to the number of fields in dtypez'align was True but dtype is not alignedró rí rô rñ )r¥ r% rõ rÓ rC r# rÑ r r& rú ÚisalignedstructÚascontiguousarrayri rÒ rÊ )rç r# r$ rÄ r¹ rè Ún_elemr rð r- r rÞ rÝ rË r r s r r r 2 s
|
ðr yyBÜÐ?Ó@Ð@Ø YYr]FØ {ä!Ð"JÓKÐKà }Ø =Ü&+¨F£mÖ4 qWÐ4EÐ4ÜHH°eÖ <°q #§)¡)nÒ <ÀEÔJ Ü(¨Ó3Ü " F|Ñ VWà Ð Ü Ð @ÓAÐ Aää(¨Ó/Ü v;!Ò Ø#% r¨2Cä#&¨ <Ñ Cà S[Ò Ü ð Ió Jð Jà Ù ×2Ò2Ü Ð FÓGÐ Gä #¤C¨£KÓ 0Ö 1qWÐ 1EÐ 1ô
|
HH uØJMÖ)NÀB¨3¯9©9°b·h±hÒ*?Ò)Nñ Pó QMä
|
×
|
Ñ
|
sÓ
|
#×
|
(Ñ
|
(¨ Ó
|
7Cô xx¨%Ø,/Ø,3Ø-6×-?Ñ-?ñ!Aó BÐð **Ð%¨D¸'*Ó
|
BCð 88IÓ vÑ &Ð&ùòQ 5ùÚ <ùò, 2ùò *Os Á G4Á,G9Ä: G>Å H
|
c ó |fS r r )Úfuncrç s r Ú _apply_along_fields_dispatcherr s Ø 6Mr! c ón |j j t d« t |« } | |d¬« S )al
|
Apply function 'func' as a reduction across fields of a structured array.
|
|
This is similar to `numpy.apply_along_axis`, but treats the fields of a
|
structured array as an extra axis. The fields are all first cast to a
|
common type following the type-promotion rules from `numpy.result_type`
|
applied to the field's dtypes.
|
|
Parameters
|
----------
|
func : function
|
Function to apply on the "field" dimension. This function must
|
support an `axis` argument, like `numpy.mean`, `numpy.sum`, etc.
|
arr : ndarray
|
Structured array for which to apply func.
|
|
Returns
|
-------
|
out : ndarray
|
Result of the reduction operation
|
|
Examples
|
--------
|
>>> import numpy as np
|
|
>>> from numpy.lib import recfunctions as rfn
|
>>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
|
... dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
|
>>> rfn.apply_along_fields(np.mean, b)
|
array([ 2.66666667, 5.33333333, 8.66666667, 11. ])
|
>>> rfn.apply_along_fields(np.mean, b[['x', 'z']])
|
array([ 3. , 5.5, 9. , 11. ])
|
|
rì rò )Úaxis)r# r$ r% r )r rç Úuarrs r r r ¡ s6 ðH yyÐ ÜÐ9Ó:Ð:ä % cÓ *DÙ 2Ô Ð r! c ó
|
| |fS r r )ÚdstÚsrcÚzero_unassigneds r Ú!_assign_fields_by_name_dispatcherr Í s Ø 8Or! c óÚ | j j || d< y| j j D ]6 }||j j vr |s d| |< $t | | || |« 8 y)aÆ
|
Assigns values from one structured array to another by field name.
|
|
Normally in numpy >= 1.14, assignment of one structured array to another
|
copies fields "by position", meaning that the first field from the src is
|
copied to the first field of the dst, and so on, regardless of field name.
|
|
This function instead copies "by field name", such that fields in the dst
|
are assigned from the identically named field in the src. This applies
|
recursively for nested structures. This is how structure assignment worked
|
in numpy >= 1.6 to <= 1.13.
|
|
Parameters
|
----------
|
dst : ndarray
|
src : ndarray
|
The source and destination arrays during assignment.
|
zero_unassigned : bool, optional
|
If True, fields in the dst for which there was no matching
|
field in the src are filled with the value 0 (zero). This
|
was the behavior of numpy <= 1.13. If False, those fields
|
are not modified.
|
N.r )r# r$ r )r r r r/ s r r r Ð sh ð4 yyÐ ØCØà ò 3Ø syyÑ &Ú Ø D ä ! # d¡)¨S°©YØ"1õ 3ñ 3r! c ó | fS r r )r Úrequired_dtypes r Ú_require_fields_dispatcherr! ö s Ø 8Or! c ó` t j | j |¬« }t || « |S )a
|
Casts a structured array to a new dtype using assignment by field-name.
|
|
This function assigns from the old to the new array by name, so the
|
value of a field in the output array is the value of the field with the
|
same name in the source array. This has the effect of creating a new
|
ndarray containing only the fields "required" by the required_dtype.
|
|
If a field name in the required_dtype does not exist in the
|
input array, that field is created and set to 0 in the output array.
|
|
Parameters
|
----------
|
a : ndarray
|
array to cast
|
required_dtype : dtype
|
datatype for output array
|
|
Returns
|
-------
|
out : ndarray
|
array with the new dtype, with field values copied from the fields in
|
the input array with the same name
|
|
Examples
|
--------
|
>>> import numpy as np
|
|
>>> from numpy.lib import recfunctions as rfn
|
>>> a = np.ones(4, dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'u1')])
|
>>> rfn.require_fields(a, [('b', 'f4'), ('c', 'u1')])
|
array([(1., 1), (1., 1), (1., 1), (1., 1)],
|
dtype=[('b', '<f4'), ('c', 'u1')])
|
>>> rfn.require_fields(a, [('b', 'f4'), ('newf', 'u1')])
|
array([(1., 0), (1., 0), (1., 0), (1., 0)],
|
dtype=[('b', '<f4'), ('newf', 'u1')])
|
|
r )rC r¤ r¥ r )r r Úouts r r r ù s( ôP ((5;; nÔ
|
5CÜ#uÔ%Ø Jr! c ó | S r r )Úarraysru rn ro Ú autoconverts r Ú_stack_arrays_dispatcherr' & s à Mr! c óê t | t j « r| S t | « dk( r| d S | D cg c]% }t j |« j « ' }}|D cg c] }t |« }}|D cg c] }|j }}|D cg c] } | j }
|
} |d } t | « } | D cg c] \ } } | }} } |dd D ] }t |« D ]r \ }}||vr%| j ||f« |j |« /|j |« }| | \ }}|r|t ||« f| |< \||k7 sbt d| d| d« t | « dk( rt j |« }nÇt j t j |« f| « }t j" t j$ d|f « }g }t' ||
|
|dd |dd « D ]\ \ }} }}|j j }|||dt |« || 5| D ]# }|| || || ||vs|j |« % ^ t) t+ ||« ||¬ « S c c}w c c}w c c}w c c} w c c} } w )
|
a
|
Superposes arrays fields by fields
|
|
Parameters
|
----------
|
arrays : array or sequence
|
Sequence of input arrays.
|
defaults : dictionary, optional
|
Dictionary mapping field names to the corresponding default values.
|
usemask : {True, False}, optional
|
Whether to return a MaskedArray (or MaskedRecords is
|
`asrecarray==True`) or a ndarray.
|
asrecarray : {False, True}, optional
|
Whether to return a recarray (or MaskedRecords if `usemask==True`)
|
or just a flexible-type ndarray.
|
autoconvert : {False, True}, optional
|
Whether automatically cast the type of the field to the maximum.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> x = np.array([1, 2,])
|
>>> rfn.stack_arrays(x) is x
|
True
|
>>> z = np.array([('A', 1), ('B', 2)], dtype=[('A', '|S3'), ('B', float)])
|
>>> zz = np.array([('a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)],
|
... dtype=[('A', '|S3'), ('B', np.double), ('C', np.double)])
|
>>> test = rfn.stack_arrays((z,zz))
|
>>> test
|
masked_array(data=[(b'A', 1.0, --), (b'B', 2.0, --), (b'a', 10.0, 100.0),
|
(b'b', 20.0, 200.0), (b'c', 30.0, 300.0)],
|
mask=[(False, False, True), (False, False, True),
|
(False, False, False), (False, False, False),
|
(False, False, False)],
|
fill_value=(b'N/A', 1e+20, 1e+20),
|
dtype=[('A', 'S3'), ('B', '<f8'), ('C', '<f8')])
|
|
rB r NzIncompatible type 'z' <> 'ú'rò r2 r¢ )rS rC r r& r r r# r$ r3 r5 Úindexr
Ú TypeErrorrg Ú concatenater¼ rú ÚcumsumÚr_r rp rx )r% ru rn ro r& rF rD Únrecordsr= r¾ ÚfldnamesÚdtype_lÚnewdescrr r$ Údtype_nÚfnameÚfdtypeÚnameidxr@ Úcdtyper rÔ ÚseenrØ Újr/ s r r r + s ôT &"**Ô%Ø Ü VÒ ØayÐØ39Ö:¨a qÓ!×'Ñ'Õ)Ð:IÐ:Ø )Ö*1AÐ*HÐ*Ø (Ö )!aggÐ )FÐ )Ø!'Ö(AÐ(HÐ(àQiGÜ gÓ&HØ#× $41aQÐ $EÑ $Ø!":ò SÜ +¨GÓ 4ò
|
SME6ØEÑ!Ø ¨ Ô0Ø UÕ#à ++ eÓ,Ø $ WÑ - 6Ù Ø).´°F¸FÓ0CÐ(DHWÒ%ØvÓ%Ü#Ð&9¸&¸ÀÈÀxÈqÐ$QÓRÐRñ
|
Sð Sô 8}ÒÜ Ó*ô ¤§¡ xÓ 0Ð 2°HÓ=Ü255 H Ñ-Ó.ØÜ ¨8°V¸C¸R°[À&ÈÈÀ*Ó Mò *LQ1aØGGMMEØ}Ø/03t9+Ñ'¨¨!Ñ,à ò *DØ()¨$©F4L 1Ð%Ø 4Ò'Ø DÕ)ñ*ð *ô } V¨XÓ6Ø &°:ô ?ð ?ùòM ;ùÚ*ùÚ )ùÚ(ùó %s ´*IÁ$I Á<I%ÂI*Â? I/c ó | fS r r )rF ÚkeyÚ
|
ignoremaskÚ return_indexs r Ú_find_duplicates_dispatcherr> s à 4Kr! c ó t j | « j « } t | j « }| }|r|| D ] }|| } || }|j « }|| }|j « } | dd | dd k( }
|
|r|j } d|
|
| dd < t j dg|
|
f« }
|
|
|
dd |
|
dd z |
|
dd | | |
|
} |r| ||
|
fS | S )a
|
Find the duplicates in a structured array along a given key
|
|
Parameters
|
----------
|
a : array-like
|
Input array
|
key : {string, None}, optional
|
Name of the fields along which to check the duplicates.
|
If None, the search is performed by records
|
ignoremask : {True, False}, optional
|
Whether masked data should be discarded or considered as duplicates.
|
return_index : {False, True}, optional
|
Whether to return the indices of the duplicated values.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.lib import recfunctions as rfn
|
>>> ndtype = [('a', int)]
|
>>> a = np.ma.array([1, 1, 1, 2, 2, 3, 3],
|
... mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype)
|
>>> rfn.find_duplicates(a, ignoremask=True, return_index=True)
|
(masked_array(data=[(1,), (1,), (2,), (2,)],
|
mask=[(False,), (False,), (False,), (False,)],
|
fill_value=(999999,),
|
dtype=[('a', '<i8')]), array([0, 1, 3, 4]))
|
Nrò rB F) rC r r r r# Úargsortrl Ú
|
recordmaskr, ) rF r; r< r= r- r r2 ÚsortidxÚ
|
sortedbaseÚ
|
sorteddataÚflagÚ
|
sortedmaskÚ
|
duplicatess r r r s ô< aÓ× Ñ Ó Aä §¡Ó (Fà DÙ
|
Øò AØ7Dð àCyàllnGØg JØ×"Ñ"Ó$Jà sOz¨!¨"~Ñ -DáØ ×*Ñ*
|
Ø $Z^Ñ Ü >>E7 D/Ó *DàSb D HÑ$D"IØ7DÑ!JÙØG DMÐ*Ð*àÐr! c ó
|
||fS r r ) r; Úr1Úr2ÚjointypeÚ r1postfixÚ r2postfixru rn ro s r Ú_join_by_dispatcherrN Ã ó ð 8Or! c óh |dvrt d|z « t t « r f t t « « t « k7 r+t fdt « D « « } t d| « D ]N }
|
|
|
|j j vrt d|
|
« |
|
|j j vsBt d|
|
« |j « }|j « }t |« t |« } } |j j |j j }} t | « t |« z t « z
|
}|r|s|sd}|dz }t |« | D cg c] }| v s| }}t ||« }t ||« }t j ||f« }|j ¬ « }|| }t j d
|
g|d d |d d k( f« }|d d |d d z |d d || }||| k }||| k\ | z
|
}t |« t |« } }|dk( rd\ } } n|dk( r`|| } t j || | | k f« }t j || | | k\ | z
|
f« }t |« |z
|
t |« | z
|
} } n8|dk( r3|| } t j || | | k f« }t |« |z
|
d} } || || }!} t |j « }"t |j « D ] \ }#}$|# vs |"j! |#|$f« t |j « D ]] \ }#}$|"D
|
%cg c] \ }
|
}%|
|
}&}
|
}% |&j# |#« }'|"|' \ }(})|# v r|#t% |$|)« f|"|'< J|#|z |)f|#|z |$fg|"|'|'d z _ t j |"« }"t% || « }*t j& |* z z f|"¬« }+|+j j }&| D ]7 },| |, }-|,|&vs
|
|,|v r |s |, vr|,|z },|+|, }.|-d | |.d | |dv s-|-|d |.|*|*| z 9 |D ]9 },|!|, }-|,|&vs
|
|,| v r |s |, vr|,|z },|+|, }.|-d | |.d | |dk( s.| s1|-| d |.| d ; |+j) ¬ « ||d}/t+ t- |+|« fi |/¤S c c}w c c}%}
|
w # t $ r |"j! |#|$f« Y w xY w)a<
|
Join arrays `r1` and `r2` on key `key`.
|
|
The key should be either a string or a sequence of string corresponding
|
to the fields used to join the array. An exception is raised if the
|
`key` field cannot be found in the two input arrays. Neither `r1` nor
|
`r2` should have any duplicates along `key`: the presence of duplicates
|
will make the output quite unreliable. Note that duplicates are not
|
looked for by the algorithm.
|
|
Parameters
|
----------
|
key : {string, sequence}
|
A string or a sequence of strings corresponding to the fields used
|
for comparison.
|
r1, r2 : arrays
|
Structured arrays.
|
jointype : {'inner', 'outer', 'leftouter'}, optional
|
If 'inner', returns the elements common to both r1 and r2.
|
If 'outer', returns the common elements as well as the elements of
|
r1 not in r2 and the elements of not in r2.
|
If 'leftouter', returns the common elements and the elements of r1
|
not in r2.
|
r1postfix : string, optional
|
String appended to the names of the fields of r1 that are present
|
in r2 but absent of the key.
|
r2postfix : string, optional
|
String appended to the names of the fields of r2 that are present
|
in r1 but absent of the key.
|
defaults : {dictionary}, optional
|
Dictionary mapping field names to the corresponding default values.
|
usemask : {True, False}, optional
|
Whether to return a MaskedArray (or MaskedRecords is
|
`asrecarray==True`) or a ndarray.
|
asrecarray : {False, True}, optional
|
Whether to return a recarray (or MaskedRecords if `usemask==True`)
|
or just a flexible-type ndarray.
|
|
Notes
|
-----
|
* The output is sorted along the key.
|
* A temporary array is formed by dropping the fields not in the key for
|
the two arrays and concatenating the result. This array is then
|
sorted, and the common entries selected. The output is constructed by
|
filling the fields with the selected entries. Matching is not
|
preserved if there are some duplicates...
|
|
)ÚinnerÚouterÚ leftouterzWThe 'jointype' argument should be in 'inner', 'outer' or 'leftouter' (got '%s' instead)c 3 ó> K | ] \ }}||d z d v s| yw)rB Nr )r. r Úxr; s r r0 zjoin_by.<locals>.<genexpr> s& øè ø ÒDA°1¸¸AÀ¹E¸F¸ Ò3C1ÑDùs zduplicate join key zr1 does not have key field zr2 does not have key field z8r1 and r2 contain common names, r1postfix and r2postfix zcan't both be empty)ÚorderFrB Nrò rQ )r r rR rS r r )rR rS r¢ )r% rS r\ r& r£ ÚnextÚ enumerater# r$ r r¨ rg r, r@ rC r3 r5 r* r
r¼ Úsortrp rx )0r; rI rJ rK rL rM ru rn ro Údupr/ Únb1Únb2Úr1namesÚr2namesÚ
|
collisionsr½ r Úkey1Úr1kÚr2kÚauxÚidx_sortÚflag_inÚidx_inÚidx_1Úidx_2Úr1cmnÚr2cmnÚr1spcÚr2spcÚidx_outÚs1Ús2r= r4 r5 r# r$ r6 r@ r7 Úcmnr r2 Úselectedr) Úkwargss0 ` r r r É st ø ðh Ð6Ñ6Üð<Ø>FñGóð ô
|
#sÔØfô 3s8}CÒ ÜÓD¤¨3£ ÔDÓDÜÐ.¨s¨gÐ6Ó7Ð7Øò EØ rxx~~Ñ %Ü Ð :¸4¸(Ð CÓDÐ DØ rxx~~Ò %Ü Ð :¸4¸(Ð CÓDÐ Dð Eð
|
BØ BÜb'3r7#SØ ((..¨"¯(©(¯.©.gWô g,¤ W£ Ñ-´°S³Ñ9JÙ9© ØHØ Ð$Ñ$ÜoÐ ð Ö +! ! s¢(AÐ +DÐ +Ü
|
r4Ó
|
CÜ
|
r4Ó
|
Cô ..#sÓ
|
$CØ{{ {Ó%HØ
|
h-Cô nnug s¨1¨2 w°#°c°r°(Ñ':Ð ;Ó<GØ12; ¨¨" Ñ-GCRLØ gÑ FØ FSLÑ "EØ FcMÑ # cÑ )EÜ%j¤# e£*EUØ7ÒØ Ø WÒ ØG8Ñ$Ü w°¸#± Ñ'?Ð @ÓAÜ w°¸3±Ñ'@À3Ñ'FÐ GÓHÜ e* uÑ,¬c°%«j¸5Ñ.@Ø [Ò ØG8Ñ$Ü w°¸#± Ñ'?Ð @ÓAÜ e* uÑ,¨aà5 2e9Rô CIIÓ &Fô (¨¯©Ó1ò + vØ Ò Ø MM5 &/Õ *ð+ô
|
(¨¯©Ó1ò vð *0×0+$ Ð0Ñ0ð Økk %Ó(Gð wIAvØ|à#(¬#¨f°fÓ*=Ð">wð
|
YÑ&¨Ð/ØYÑ&¨Ð/ð/ww¨{Ñ+ð%ô. XXfÓ Fô eUÓ
|
Cä ]]C %K¨%Ñ /Ð1¸Ô @FØ LL× Ñ EØ ò 8Øa5Ø E>a 7l±9ÀÈ#Á Ø NAØ)Ø" 6 EÐ*Ø Ð-Ò -Ø'/°°Ð'7GCe Ñ $ð8ð ò 0Øa5Ø E>a 7l±9ÀÈ#Á Ø NAØ)Ø" 6 EÐ*Ø Ó ¢UØ '¨¨Ð /GUFGÑ ð0ð KKcKÔØ °
|
Ñ ;FÜ } V¨XÓ6Ñ A¸&Ñ AÐAùòs ,ùóV 1øô ò +à MM5 &/× *ð +ús$ Å& RÅ0RÌ5 R ÍRÒ R1Ò0R1c ó
|
||fS r r )r; rI rJ rK rL rM ru s r Ú_rec_join_dispatcherrt { rO r! c ó0 ||||ddd}t | ||fi |¤S )z¨
|
Join arrays `r1` and `r2` on keys.
|
Alternative to join_by, that always returns a np.recarray.
|
|
See Also
|
--------
|
join_by : equivalent function
|
FT)rK rL rM ru rn ro )r )r; rI rJ rK rL rM ru rr s r r r s. ð #°ÈØ &°5ÈñNFä 3BÑ ) &Ñ )Ð)r! )F)NN)NT)TFr )NNNN)rò FFF)Nrò TF)FF)r )NNN)NFÚunsafe)NNNNN)NNFFrv )T)NTFF)NTF)NNNNNN)rQ Ú1Ú2NTF)rQ rw rx N)?Ú__doc__r` ÚnumpyrC Únumpy.marg Únumpy.ma.mrecordsÚmrecordsrj Únumpy._core.overridesr Únumpy.lib._iotoolsr Ú__all__r r r3 r r r
|
rG rJ r rU r] re rp rx rz r r r r¨ r« r r¯ r r¶ r rÁ r rÆ r rÑ rå ré r r r r r r r r! r r' r r> r rN r rt r r r! r ú<module>r s ðñó ã Ý ß Ð Ý 9Ý .ò òñ Ð:Ó;ñ$ó <ð$òN
|
ò@ òB òB ó6 ó 8ó -ò`
|
ò ó "ó0ó" ð BFØ6:óñ
|
Ð1Ó2Ø38Ø+0òEó 3ðEóPñ Ð0Ó1ò:Gó 2ð:GózGò2ñ Ð4Ó5ñIó 6ðIòñ Ð2Ó3ñ% ó 4ð% ðP 9=ØHLóñ Ð2Ó3Ø,0Ø:?òCGó 4ðCGóLñ
|
Ð6Ó7ò 9ó 8ð 9óDñ Ð2Ó3òQ"ó 4ðQ"óf#òJ*ðZ BFØ37óñ Ð?Ó@ò1ó Að1ðD CGØJNóñ Ð?Ó@ØBGØ3;òi'ó Aði'òVñ Ð7Ó8ñ' ó 9ð' óVñ Ð:Ó;ò#3ó <ð#3òJñ Ð3Ó4ñ)ó 5ð)ðX =AØ:>óñ
|
Ð1Ó2ØAFØ "òT?ó 3ðT?ðp 48óñ
|
Ð4Ó5ò7ó 6ð7ðv ?CØ04óñ Ð,Ó-ØDGØ49ònBó .ðnBðd ?CØóñ Ð-Ó.ØEHØò *ó /ð *ñ r!
|
