Ë
|
nñúhIü ã óN d Z ddlmZ ddlmZ ddlZddlZddlmZm Z m
|
Z
|
m Z m Z m Z ddlZddlZddlmZ ddlmc mZ ddlmZmZmZ ddlmZ dd l m Z dd
|
l m Z dd l!m"Z" dd l#m$Z$ dd l%m&Z&m'Z' ddl(m)Z) ddl*m+Z+m,Z,m-Z- ddl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z:m;Z; ddl<m=Z=m>Z>m?Z? ddl@mAZA ddlBmCc mDZE ddlFmGZG ddlHmIZI ddlJmKZK ddlLmCc mMZN ddlOmPZPmQZQmRZR ddlSmTZTmUZU ddlVmWZW ddlXmYZY erYdd lZm[Z[ dd l\m]Z] G d d e]« Z^e^j¾ Z_dd l`maZa dd!lbmcZcmdZd e d" Zedd#lbmfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZq dd$lrmsZs n ete_« Z^d%d&iZud/d'Zv d0d(Zw d1 d2d)Zx G d* d&eGeKeI« Zy d3 d4d+Zze d5d,« Z{e d6d-« Z{d7d.Z{y)8z
|
SparseArray data structure
|
é )Ú annotations)ÚabcN)Ú TYPE_CHECKINGÚAnyÚCallableÚLiteralÚcastÚoverload)Úlib)Ú
|
BlockIndexÚIntIndexÚ SparseIndex)ÚNaT)Úfunction)ÚPerformanceWarning)Údoc)Úfind_stack_level)Úvalidate_bool_kwargÚvalidate_insert_loc)Ú astype_array)Ú"construct_1d_arraylike_from_scalarÚfind_common_typeÚmaybe_box_datetimelike)Ú is_bool_dtypeÚ
|
is_integerÚ is_list_likeÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚ pandas_dtype)ÚDatetimeTZDtypeÚ SparseDtype)ÚABCIndexÚ ABCSeries)ÚisnaÚna_value_for_dtypeÚnotna)Ú arraylike)ÚOpsMixin)ÚExtensionArray)Ú PandasObject)Ú ensure_wrapped_if_datetimelikeÚ extract_arrayÚsanitize_array)Úcheck_array_indexerÚunpack_tuple_and_ellipses)Úcheck_below_min_count)Úprinting)ÚSequence)ÚEnumc ó e Zd ZdZy)Úellipsisz...N)Ú__name__Ú
|
__module__Ú __qualname__ÚEllipsis© ó úRH:\Change_password\venv_build\Lib\site-packages\pandas/core/arrays/sparse/array.pyr6 r6 [ s Ør< r6 )Úspmatrix)Ú FillnaOptionsÚ NumpySorter)ÚintegerÚblock) Ú ArrayLikeÚ AstypeArgÚAxisÚAxisIntÚDtypeÚNpDtypeÚPositionalIndexerÚScalarÚ ScalarIndexerÚSelfÚSequenceIndexerÚnpt)ÚSeriesÚklassÚ SparseArrayc óÊ t j | j | j j ¬« S # t
|
$ r" t j | j « cY S w xY w)a]
|
Create a 0-dim ndarray containing the fill value
|
|
Parameters
|
----------
|
arr : SparseArray
|
|
Returns
|
-------
|
fill_value : ndarray
|
0-dim ndarray with just the fill value.
|
|
Notes
|
-----
|
coerce fill_value to arr dtype if possible
|
int64 SparseArray can have NaN as fill_value if there is no missing
|
©Údtype)ÚnpÚasarrayÚ
|
fill_valuerT ÚsubtypeÚ
|
ValueError)Úarrs r= Ú _get_fillr[ sH ð$*Üzz#..°· ± ×0AÑ0AÔBÐBøÜ ò *Üzz#..Ó)Ò)ð*ús 47 ·(A"Á!A"c óª |j d« r|dd }| j j }|j j }||k7 rlt ||g« }t || j
|
« }t ||j
|
« }| j |d¬« } |j |d¬« }|j }n|}d}| j j dk( s|j j dk( rt j d¬ « 5 || j « |j « « } |t | « t |« « }
|
ddd« | j j dk( r| j } nð|j } nâ| j j |j « ret j d¬ « 5 || j |j « } |t | « t |« « }
|
ddd« | j } nX|d d
|
k( r || }} |d d }|d v rd|d k( r_d| d} | j j t j « } |j j t j « }t" }n d| d| } | j } |j }|dv rS|dk( j% « r@| j j& dv r(d| d} | j d« } |j d« }t) t* | « }t j d¬ « 5 || | j | j
|
||j |j
|
« \ } } }
|
ddd« |dk( r,t- | d
|
d |¬« t- || d | |
|
d |¬« fS | j }t- |
|
|¬« S # 1 sw Y pxY w# 1 sw Y ÌxY w# 1 sw Y rxY w)a4
|
Perform a binary operation between two arrays.
|
|
Parameters
|
----------
|
left : Union[SparseArray, ndarray]
|
right : Union[SparseArray, ndarray]
|
op : Callable
|
The binary operation to perform
|
name str
|
Name of the callable.
|
|
Returns
|
-------
|
SparseArray
|
Ú__é éþÿÿÿF©ÚcopyNr Úignore©ÚallÚré )ÚandÚorÚxorÚboolÚsparse_Ú_uint8Ú_)ÚfloordivÚmodÚiuÚ_float64Úfloat64ÚdivmodrS )Ú
|
startswithrT rX r r" rW ÚastypeÚsp_indexÚngapsrU ÚerrstateÚto_denser[ ÚequalsÚ sp_valuesÚviewÚuint8rj ÚanyÚkindÚgetattrÚsplibÚ _wrap_result)ÚleftÚrightÚopÚnameÚltypeÚrtyperX rT Ú result_dtypeÚresultÚfillÚindexÚopnameÚleft_sp_valuesÚright_sp_valuesÚ sparse_ops r= Ú_sparse_array_opr sl ð& tÔ àAbzð JJ× Ñ EØ KK× Ñ Eà ~Ü" E¨5 >Ó2ÜG T§_¡_Ó5ÜG U×%5Ñ%5Ó6à{{5 u{Ó-Ø U¨ Ó/Ø àð Là }}×ÑaÒ 5§>¡>×#7Ñ#7¸1Ò#<Ü [[XÔ &ñ 9Ù ¨¯ © Ó)9Ó:FÙi o¤y°Ó'7Ó8D÷ 9ð ==× Ñ !Ò #ØMMEàNNEØ × Ñ ennÔ -Ü [[XÔ &ñ 9Ù¨¯©Ó8FÙi o¤y°Ó'7Ó8D÷ 9ð à 7c>Ø %DØ8Dà Ð'Ñ '¨E°VªOØ tf FÐ+Fà !^^× 0Ñ 0´·±Ó :NØ #oo× 2Ñ 2´2·8±8Ó <OÜ Là tf A e WÐ-FØ !^^NØ #ooOð Ð'Ñ 'Ø!× Ñ Ô"Ø
|
|
4Ñ'ð tf HÐ-FØ +× 2Ñ 2°9Ó =NØ -× 4Ñ 4°YÓ ?OäE 6Ó* ä [[XÔ &ñ Ù"+Ø Ø ØØ ØØ× Ñ ó #Ñ FE4÷ ð xÒô
|
v ay¨%°°a±À Ô MÜ v ay¨%°°a±À Ô Mð
|
ð
|
ð
|
ÐØ || ä f e¨T¸ Ô FÐF÷ 9ñ 9ú÷ 9ñ 9ú÷@ ð ús% Ä AN/Æ99N<Ì :O Î/N9Î<OÏ Oc ó¶ | j d« r| dd } | dv rt }t j |« }t |« r t |« }t ||||¬« S )z.
|
wrap op result to have correct dtype
|
r] r^ r_ )ÚeqÚneÚltÚgtÚleÚge)Ú sparse_indexrW rT )rt rj r Úitem_from_zerodimr rQ )r Údatar rW rT s r= r r sa ð tÔ àAbzà Ð3Ñ3Üä×&Ñ& zÓ2JäUÔä*Ó%
|
Ü Ø <°JÀeô ð r< c ó¨ e Zd ZU dZdZej eg « z Zded< ded< ded< dU dVd Z e
|
dWd « Z e
|
dXd « Z dY dZdZ d[dZe
|
d d
|
dd\d« Ze
|
d « Zed]d« Zed^d« Zed_d« Zed « Zej, d[d« Zed`d« Zed^d« ZdadZedbd« Zdbd Zedad « Z edcd « Z edad « Z ddd Z d d d!d" de fd#Z df dg fd$ Z!dhdid%Z"d& Z# e$e%jL « dj dkd'« Z&ddd(Z'd) Z( dl dmd*Z)dldnd+Z*e+dod,« Z,e+ dpd-« Z, dqd.Z,d/ Z-d
|
d d0drd1Z.dsd^d2Z/ddd3Z0 dt dud4Z1ddd5Z2e
|
dvd6« Z3dwdxd7Z4dsddd8Z5d^d9Z6d: Z7d[d;Z8dyd<Z9d!d
|
d= dzd>Z:dsd?Z;d{d|d@Z< d} d~dAZ=d{ddBZ>d{ddCZ?d d!dDddEZ@d d!dDddFZAddGZBddHZCdlddIZDdlddJZEeFj eHj fZJd
dKZKdL ZLddMZMeMZNddNZOddOZPddPZQddQZRddRZSddSZTdddTZU xZVS )rQ aÞ
|
An ExtensionArray for storing sparse data.
|
|
Parameters
|
----------
|
data : array-like or scalar
|
A dense array of values to store in the SparseArray. This may contain
|
`fill_value`.
|
sparse_index : SparseIndex, optional
|
fill_value : scalar, optional
|
Elements in data that are ``fill_value`` are not stored in the
|
SparseArray. For memory savings, this should be the most common value
|
in `data`. By default, `fill_value` depends on the dtype of `data`:
|
|
=========== ==========
|
data.dtype na_value
|
=========== ==========
|
float ``np.nan``
|
int ``0``
|
bool False
|
datetime64 ``pd.NaT``
|
timedelta64 ``pd.NaT``
|
=========== ==========
|
|
The fill value is potentially specified in three ways. In order of
|
precedence, these are
|
|
1. The `fill_value` argument
|
2. ``dtype.fill_value`` if `fill_value` is None and `dtype` is
|
a ``SparseDtype``
|
3. ``data.dtype.fill_value`` if `fill_value` is None and `dtype`
|
is not a ``SparseDtype`` and `data` is a ``SparseArray``.
|
|
kind : str
|
Can be 'integer' or 'block', default is 'integer'.
|
The type of storage for sparse locations.
|
|
* 'block': Stores a `block` and `block_length` for each
|
contiguous *span* of sparse values. This is best when
|
sparse data tends to be clumped together, with large
|
regions of ``fill-value`` values between sparse values.
|
* 'integer': uses an integer to store the location of
|
each sparse value.
|
|
dtype : np.dtype or SparseDtype, optional
|
The dtype to use for the SparseArray. For numpy dtypes, this
|
determines the dtype of ``self.sp_values``. For SparseDtype,
|
this determines ``self.sp_values`` and ``self.fill_value``.
|
copy : bool, default False
|
Whether to explicitly copy the incoming `data` array.
|
|
Attributes
|
----------
|
None
|
|
Methods
|
-------
|
None
|
|
Examples
|
--------
|
>>> from pandas.arrays import SparseArray
|
>>> arr = SparseArray([0, 0, 1, 2])
|
>>> arr
|
[0, 0, 1, 2]
|
Fill: 0
|
IntIndex
|
Indices: array([2, 3], dtype=int32)
|
Ú sparse_arrayr Ú _sparse_indexú
|
np.ndarrayÚ_sparse_valuesr" Ú_dtypeNFc ó: | t |t « r |j }t |t | « « r6| |j }| |j }| |j
|
}|j }t |t « r t j |« }t |t « r| |j }|j }t |« rft j dt | « j dt t# « ¬« |d}n |j$ }t' ||d ¬« }|j
|
}| t |« }|t) j* g |¬« } t- |d ¬« }|r|j7 « }|.| |j
|
n|}|t( j8 }n t; |« }t |t | « « r1|/|j< }t) j4 |j |¬« } n|Ñt? |d¬« }t |t( j@ « st |j
|
tB « rgt j d |j
|
d
|
tD t# « ¬« t) j4 |d ¬« }|tF u rt) jH d d « }t) j4 |« }tK ||||¬« \ } }}nGt) j4 ||¬« } tM | « |jN k7 rtQ dt | « d« || _ | | _) t | j
|
|« | _* y # t $ r t |« }Y ²w xY w# t. $ rK |Dt) j
|
t0 « }t) j2 t) j4 ||¬« « }n Y :w xY w)Nz Constructing z\ with scalar data is deprecated and will raise in a future version. Pass a sequence instead.©Ú
|
stacklevelrf rS )r T)Ú extract_numpyzCreating SparseArray from z^ data loses timezone information. Cast to object before sparse to retain timezone information.zdatetime64[ns]r Úns)r rW rT zNon array-like type z' must have the same length as the index)+Ú
|
isinstancer" rW Útyperv rT r{ ÚstrÚconstruct_from_stringÚ TypeErrorr rX r ÚwarningsÚwarnr7 Ú FutureWarningr Úlengthr rU Úarrayr. rY ÚobjectÚ
|
atleast_1drV ra Únanr& r r- Úndarrayr! Ú UserWarningr Ú
|
datetime64Ú _make_sparseÚlenÚnpointsÚAssertionErrorr r¡ )
|
Úselfr r rW r rT ra r¹ Úfill_value_dtypeÚ sparse_valuess
|
r= Ú__init__zSparseArray.__init__l sL ð Ð ¤*¨U´KÔ"@Ø ×)Ñ)Jä dD JÔ 'àÐ#Ø #}} ØÐ!Ø !__
|
Ø}Ø
|
|
à>>Dô eSÔ !ð ,Ü#×9Ñ9¸%Ó@ô e[Ô )ØÐ!Ø "× -Ñ -
|
ØMMEä T?Ü MMØ ¤ T£
|
× 3Ñ 3Ð 4ð 5Oð Oä Ü+Ó-õ ð Ð#Øà&×-Ñ-ä5°d¸GÈ4ÔPDØJJEà Ð Ü Ó'Eð <ô 88B eÔ,Dð Ü! $¨dÔ3Dñ à99;Dà Ð Ø-2¨]tzzÀÐ Ø Ð'Ü VV
|
ä /Ð0@Ó A
|
ä dD JÔ '¨LÐ,@Ø ×-Ñ-Lô JJØ eô Mð Ð !Ü °TÔ:DÜ d¤B§J¡JÔ/ä djj¬/Ô:Ü MMØ4°T·Z±Z°Lð AAð Aô $Ü#3Ó#5õ ô :: dÐ2BÔCDØ!¤SÑ(Ü%'§]¡]°5¸$Ó%?
|
Üzz $Ó'Ü6Bð ØØ%Øô7Ñ 3M<©ô JJ t°5Ô 9MÜ=Ó! \×%9Ñ%9Ò9Ü$Ø*¬4° Ó+>Ð*?ð @8ð 8óð ð *ÔØ +ÔÜ! -×"5Ñ"5°zÓB øôM ò ,Ü$ UÓ+ð ,ûôN ò ð }ܤÓ(Ü}}¤R§Z¡Z°¸EÔ%BÓCàò ð ús% Á;L+ Å M Ì+MÍMÍANÎNc óZ t j | « }||_ ||_ ||_ |S ©N)r± Ú__new__r r r¡ )Úclsr r rT Únews r= Ú _simple_newzSparseArray._simple_newñ s. ô nnSÓ!Ø (ÔØ )ÔØ
|
Ø
|
r< c ó |j \ }}|dk7 rt d| d« |j « }|j « |j }|j
|
}t j d|j ¬« j « }t |j |« }t ||« }| j |||« S )a
|
Create a SparseArray from a scipy.sparse matrix.
|
|
Parameters
|
----------
|
data : scipy.sparse.sp_matrix
|
This should be a SciPy sparse matrix where the size
|
of the second dimension is 1. In other words, a
|
sparse matrix with a single column.
|
|
Returns
|
-------
|
SparseArray
|
|
Examples
|
--------
|
>>> import scipy.sparse
|
>>> mat = scipy.sparse.coo_matrix((4, 1))
|
>>> pd.arrays.SparseArray.from_spmatrix(mat)
|
[0.0, 0.0, 0.0, 0.0]
|
Fill: 0.0
|
IntIndex
|
Indices: array([], dtype=int32)
|
rf z''data' must have a single column, not 'ú'r rS ) ÚshaperY ÚtocscÚ sort_indicesr ÚindicesrU r° rT Úitemr" r rÄ ) r r r¯ ÚncolrZ ÚidxÚzerorT r s r= Ú from_spmatrixzSparseArray.from_spmatrixþ s¤ ð4 zz à 19Ü Ð FÀtÀfÈAÐ NÓOÐ Oð zz|Ø ×ÑÔØiiØlläxx §¡Ô+×0Ñ0Ó2ÜCII tÓ,Ü Ó%às E¨5Ó1Ð1r< c ó | j j dk( r/|du r t j | j « S | j S |du r$t j dt t « ¬« | j }|t| j j j dk( r |t u rt j d« } t j | j j t |« « }t j$ | j& ||¬« }| j || j j( < |S # t $ r t" }Y Xw xY w) Nr TFaS Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
|
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.r£ ÚMr rS )rv rw rU r° r{ r¬ r r® r rW rT r r r¶ Ú result_typer¨ r« r± ÚfullrÇ rÊ )r» rT ra rW Úouts r= Ú __array__zSparseArray.__array__* s ð ==× Ñ !Ò #àt|Üxx §¡Ó/Ð/à~~Ð%à 5=Ü MMð2ô Ü+Ó-õ ð __
|
à =ð ~~×#Ñ#×(Ñ(¨CÒ/ð ¤Ñ$ä!#§ ¡ ¨uÓ!5Jð Ü t§~¡~×';Ñ';¼TÀ*Ó=MÓNô ggdjj *°EÔ:Ø%)§^¡^DMM× !Ñ !Ñ"Ø
|
øô ò Ü ð ús à 3D: Ä:E Å E c ó d}t |« )Nz8SparseArray does not support item assignment via setitem)r« )r» ÚkeyÚvalueÚmsgs r= Ú __setitem__zSparseArray.__setitem__U s ð IÜnÐ r< ©rT ra c ó | ||¬« S ©NrS r; )r ÚscalarsrT ra s r= Ú_from_sequencezSparseArray._from_sequence\ s á7 %Ô(Ð(r< c ó* | ||j ¬« S rÝ rS )r ÚvaluesÚoriginals r= Ú_from_factorizedz SparseArray._from_factorized` s á6 § ¡ Ô0Ð0r< c ó | j S )zX
|
The SparseIndex containing the location of non- ``fill_value`` points.
|
)r ©r» s r= rv zSparseArray.sp_indexg s ð
|
×!Ñ!Ð!r< c ó | j S )a
|
An ndarray containing the non- ``fill_value`` values.
|
|
Examples
|
--------
|
>>> from pandas.arrays import SparseArray
|
>>> s = SparseArray([0, 0, 1, 0, 2], fill_value=0)
|
>>> s.sp_values
|
array([1, 2])
|
)r rå s r= r{ zSparseArray.sp_valuesn s ð ×"Ñ"Ð"r< c ó | j S rÀ )r¡ rå s r= rT zSparseArray.dtype| s à{{Ðr< c ó. | j j S )aÚ
|
Elements in `data` that are `fill_value` are not stored.
|
|
For memory savings, this should be the most common value in the array.
|
|
Examples
|
--------
|
>>> ser = pd.Series([0, 0, 2, 2, 2], dtype="Sparse[int]")
|
>>> ser.sparse.fill_value
|
0
|
>>> spa_dtype = pd.SparseDtype(dtype=np.int32, fill_value=2)
|
>>> ser = pd.Series([0, 0, 2, 2, 2], dtype=spa_dtype)
|
>>> ser.sparse.fill_value
|
2
|
)rT rW rå s r= rW zSparseArray.fill_value s ð" zz×$Ñ$Ð$r< c óN t | j j |« | _ y rÀ )r" rT rX r¡ )r» rØ s r= rW zSparseArray.fill_value s ä! $§*¡*×"4Ñ"4°eÓ< r< c ó: t | j t « ryy)zW
|
The kind of sparse index for this array. One of {'integer', 'block'}.
|
rA rB )r§ rv r rå s r= r zSparseArray.kind s ô
|
dmm¤XÔ .Ø àr< c ó: | j }t |« }|| S rÀ )r{ r' )r» Úsp_valsÚmasks r= Ú_valid_sp_valuesz SparseArray._valid_sp_values¡ s à..ÜW~Øt}Ð r< c ó. | j j S rÀ )rv r¯ rå s r= Ú__len__zSparseArray.__len__§ s Ø}}×#Ñ#Ð#r< c ó. | j j S rÀ )r¡ Ú_is_na_fill_valuerå s r= Ú_null_fill_valuez SparseArray._null_fill_valueª s à{{×,Ñ,Ð,r< c óN | j r t |« S | j |k( S rÀ )ró r% rW )r» rW s r= Ú_fill_value_matchesz SparseArray._fill_value_matches® s% Ø × Ò Ü
|
Ó#Ð #à?? jÑ0Ð 0r< c ó\ | j j | j j z S rÀ )r{ Únbytesrv rå s r= r÷ zSparseArray.nbytes´ s! à~~×$Ñ$ t§}¡}×';Ñ';Ñ;Ð;r< c ó\ | j j | j j z S )zú
|
The percent of non- ``fill_value`` points, as decimal.
|
|
Examples
|
--------
|
>>> from pandas.arrays import SparseArray
|
>>> s = SparseArray([0, 0, 1, 1, 1], fill_value=0)
|
>>> s.density
|
0.6
|
)rv r¹ r¯ rå s r= ÚdensityzSparseArray.density¸ s# ð }}×$Ñ$ t§}¡}×';Ñ';Ñ;Ð;r< c ó. | j j S )zë
|
The number of non- ``fill_value`` points.
|
|
Examples
|
--------
|
>>> from pandas.arrays import SparseArray
|
>>> s = SparseArray([0, 0, 1, 1, 1], fill_value=0)
|
>>> s.npoints
|
3
|
)rv r¹ rå s r= r¹ zSparseArray.npointsÆ s ð }}×$Ñ$Ð$r< c ó t t | j « }| j r9t | « j t | j « | j |« S t j t | « dt j ¬« }t | j « || j j < t | « |d|¬« S )NFrS ©rW rT ) r" rj ró r¨ rÄ r% r{ rv rU rÓ r¸ Úbool_rÊ )r» rT rí s r= r% zSparseArray.isnaÖ s ô D $×"7Ñ"7Ó8Ø × Ò Ü:×)Ñ)¬$¨t¯~©~Ó*>ÀÇ Á ÈuÓUÐ UÜwws4y %¬r¯x©xÔ8Ü&*¨4¯>©>Ó&:T]]× "Ñ "Ñ#ØtDz$¨5¸Ô>Ð>r< T)ÚlimitÚ
|
limit_areara c ó* t | ||||¬« S )N)Úmethodrþ rÿ ra )ÚsuperÚ_pad_or_backfill)r» r rþ rÿ ra Ú __class__s r= r z SparseArray._pad_or_backfillà s% ø ô wÑ'Ø °:ÀDð (ó
|
ð
|
r< c óf ||| | t d« |t | ||¬« S t j t | j « || j « }| j r"t | j j |¬« }n | j }| j || j |« S )aï
|
Fill missing values with `value`.
|
|
Parameters
|
----------
|
value : scalar, optional
|
method : str, optional
|
|
.. warning::
|
|
Using 'method' will result in high memory use,
|
as all `fill_value` methods will be converted to
|
an in-memory ndarray
|
|
limit : int, optional
|
|
copy: bool, default True
|
Ignored for SparseArray.
|
|
Returns
|
-------
|
SparseArray
|
|
Notes
|
-----
|
When `value` is specified, the result's ``fill_value`` depends on
|
``self.fill_value``. The goal is to maintain low-memory use.
|
|
If ``self.fill_value`` is NA, the result dtype will be
|
``SparseDtype(self.dtype, fill_value=value)``. This will preserve
|
amount of memory used before and after filling.
|
|
When ``self.fill_value`` is not NA, the result dtype will be
|
``self.dtype``. Again, this preserves the amount of memory used.
|
z(Must specify one of 'method' or 'value'.)r rþ ©rW ) rY r ÚfillnarU Úwherer% r{ ró r" rT rX rÄ r )r» rØ r rþ ra Ú
|
new_valuesÚ new_dtyper s r= r zSparseArray.fillnaî s£ ø ðT Nu}Ø Ð 5Ð#4ä Ð GÓHÐ Hà Ð Ü7>¨°u>Ó=Ð =ô ¤$ t§~¡~Ó"6¸¸t¿~¹~ÓNJà×$Ò$ä '¨¯
|
©
|
×(:Ñ(:ÀuÔ M à JJ à× Ñ
|
¨D×,>Ñ,>À ÓJÐJr< c ó6 t | « r|dk( r| j « S t |« r| j j }t j || j j « }|| j j k7 r&| j t || j « « }n| }| j |gt t |« t | « « z |j ¬« }|dkD r |}|d | }n|t |« d }|}|j ||g« S )Nr rS )r¸ ra r% rT Úna_valuerU rÒ rX ru r" rW rß ÚminÚabsÚ_concat_same_type)r» ÚperiodsrW rX rZ ÚemptyÚaÚbs r= ÚshiftzSparseArray.shift+ sõ Ü4yG qLØ99;Ð ä
|
Ô Ø ×,Ñ,Jä.. ¨T¯Z©Z×-?Ñ-?Ó@à djj×(Ñ(Ò (à++k¨'°4·?±?Ó CÓDCàCà×#Ñ#Ø L3s 7|¬S°«YÓ7Ñ 7¸s¿y¹yð $ó
|
ð Q;ØAØIgXAàCLNÐ#AØAØ×$Ñ$ a¨ VÓ,Ð,r< c ó: t | « dk( s"| j j t | « k( ry| j j }t |« r|d dkD ryt j
|
t j |« df }||dkD j « dz S )zh
|
Get the location of the first fill value.
|
|
Returns
|
-------
|
int
|
r éÿÿÿÿr^ rf )r¸ rv r¹ rÊ rU Úr_ÚdiffÚargmax)r» rÊ r s r= Ú_first_fill_value_locz!SparseArray._first_fill_value_locF s
ô t9>T]]× 2Ñ 2´c¸$³iÒ ?Øà--×'Ñ'Ü7|w qz¨A~Øô
|
uuRWWWÓ% qÐ(Ñ)Øq×(Ñ(Ó*Ñ+¨aÑ/Ð/r< c ó¢ t j | « }t j | j « « }t j |||¬« S )N)Úkeeprí )rU rV r% ÚalgosÚ
|
duplicated)r» r rá rí s r= r zSparseArray.duplicated[ s; ô DÓ!Üzz$))+Ó&Ü× Ñ ¨T¸Ô=Ð=r< c ó t j | j « }t | j « t | « k7 r\| j « }t t j | j d | « « }t j ||| j « }t | « j || j ¬« S rÝ ) r Úuniquer{ r¸ r rU ÚinsertrW r¨ rß rT )r» ÚuniquesÚfill_locÚ
|
insert_locs r= r zSparseArray.uniquec s Ü,,t~~Ó.Ü t~~Ó ¤# d£)Ò +Ø×1Ñ1Ó3Hô U\\¨$¯.©.¸¸(Ð*CÓ DÓEJÜii ¨°T·_±_ÓEGÜDz×(Ñ(¨¸¿
|
¹
|
Ð(ÓCÐCr< c óD t j | « | j fS rÀ )rU rV rW rå s r= Ú_values_for_factorizez!SparseArray._values_for_factorizeq s äzz$Ó § ¡ Ð0Ð0r< c ó t j t j | « |¬« \ }}t || j
|
¬« }||fS )N)Úuse_na_sentinelrS )r Ú factorizerU rV rQ rT )r» r( Úcodesr" Ú
|
uniques_sps r= r) zSparseArray.factorizeu sA ô Ü JJtÓ ¨oô
|
wô ! °·
|
±
|
Ô;
|
ØjÐ Ð r< c óò ddl m}m} t j | j
|
|¬« \ }}}| j j }|dkD r| j r|s|| j r t |« n|| j k( }|j « r||xx |z cc< n8t j |d| j « }t j |d|« }t |t « s ||« } n|} ||| d¬« S )a
|
Returns a Series containing counts of unique values.
|
|
Parameters
|
----------
|
dropna : bool, default True
|
Don't include counts of NaN, even if NaN is in sp_values.
|
|
Returns
|
-------
|
counts : Series
|
r )ÚIndexrO )ÚdropnaF)r ra )Úpandasr- rO r Úvalue_counts_arrayliker{ rv rw ró r% rW r~ rU r! r§ r# )
|
r» r. r- rO ÚkeysÚcountsrm Úfcountsrí r s
|
r= Ú value_countszSparseArray.value_counts sÉ ÷
|
ô
|
×6Ñ6°t·~±~ÈfÔUfaØ--×%Ñ%Ø Q; × 5Ò 5¹VØ!%×!6Ò!64:¸DÀDÇOÁOÑ<SDØxxzØt Ñ' ô yy q¨$¯/©/Ó:Ü 6¨1¨gÓ6ä$¤Ô)Ù$KEàEÙf E°Ô6Ð6r< c ó y rÀ r; ©r» r× s r= Ú __getitem__zSparseArray.__getitem__¯ s à r< c ó y rÀ r; r6 s r= r7 zSparseArray.__getitem__³ s ð
|
r< c óæ t |t « r t |« }|t u r t d« t |« r| j |« S t |t « r| j « | }nft |t « r~|j |j dk( r |j dn |j }|dk r|t | « z }|j t | « n |j }|dk r|t | « z }| j j }t j ||k\ ||k z « }| j" | }|| j% « }|dkD r||z }t t' t | « « | « } t) | || j* « }
|
t- | « j/ ||
|
| j0 « S t j2 t | « t j4 ¬« | }| j7 |« S t9 |« s t; d« t |t< « r t? |« rétA |jB « r2| j7 |j j |j" « S |jB s%| j7 |j j « S t | « } t jD | dt jF ¬« } d| |j j < | j7 t j2 | « | « S t jH |« }tK | |« }tM jN |« rZtQ t jR |« }| j7 t j2 t |« t j4 ¬« | « S tU |d« r| j7 |« S t d | d
|
« t- | « || j* ¬ « S ) NzCannot slice with Ellipsisrf r rS zuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indicesTFrð zCannot slice with 'rÆ ©r )+r§ Útupler0 r: rY r Ú _get_val_atry ÚsliceÚstepÚstartr¸ Ústoprv rÊ rU Ú flatnonzeror{ ra ÚrangeÚmake_sparse_indexr r¨ rÄ rT ÚarangeÚint32Útaker Ú
|
IndexErrorrQ r r% rW rÓ rý rV r/ ÚcomÚis_bool_indexerr r´ Úhasattr) r» r× Ú
|
data_slicer? ÚendrÊ Ú keep_indsrì rv Únew_lenÚ new_sp_indexÚnrí s r= r7 zSparseArray.__getitem__º s ô c5Ô !Ü+¨CÓ0CØhÜ Ð!=Ó>Ð>ä c?Ø×#Ñ# CÓ(Ð (Ü UÔ #ð ¨Ñ-JÜ UÕ #àxxÐ 3§8¡8¨q£=Ø YYÐ .°C·I±IØ19ØS YÑ&Eà#&§8¡8Ð#3c$i¸¿¹Ø7Ø3t9Ñ$Cà --×/Ñ/Ü NN¨G°uÑ,<ÀÈ3Á Ñ+OÓ P Ø ..¨Ñ3à" 9Ñ-×2Ñ2Ó4ð 19Ø Ñ%Hô e¤C¨£IÓ .¨sÑ 3Ó4Ü 0°¸(ÀDÇIÁIÓ N ÜDz×-Ñ-¨g°|ÀTÇZÁZÓPÐPä ))¤C¨£I´R·X±XÔ>¸sÑCØyy Ó)Ð)ä cÔ"ô ðLóð ô #{Õ+ô
|
! Ô%ÜCNNÔ+Ø #yy¨¯ © ×)=Ñ)=¸c¿m¹mÑ)LÓ MÐMØ >>Ø #yy¨¯ © ×)=Ñ)=Ó >Ð>ÜD AÜ 77 1 d´"·(±(Ô;DØ16D ×-Ñ-Ñ.Ø 99¤R§Y¡Y¨q£\°$Ñ%7Ó8Ð8ä ** S/Cä% d¨CÓ0Cä×"Ñ" 3Ô'ä2:: sÓ+Øyy¤§¡¬3¨s«8¼2¿8¹8Ô!DÀSÑ!IÓJÐJÜiÔ(Øyy ~Ð%ä Ð#6°s°e¸1Ð!=Ó>Ð>àtDz*¨4¯9©9Ô5Ð5r< c óæ t |t | « « }| j j |« }|dk( r | j S | j
|
| }t || j
|
j « }|S )Nr )r r¸ rv ÚlookuprW r{ r rT )r» ÚlocÚsp_locÚvals r= r< zSparseArray._get_val_at s` Ü! #¤s¨4£yÓ1à ×%Ñ% cÓ*Ø R<Ø??Ð "à.. Ñ(CÜ(¨¨d¯n©n×.BÑ.BÓCCØJr< )Ú
|
allow_fillrW c ó t |« rt d| d« t j |t j ¬« }d }|j
|
dk( r$t j g d¬« }| j }n'|r| j ||¬« }n| j |« S t | « || j | j |¬« S )Nz*'indices' must be an array, not a scalar 'z'.rS r r± r )rW r rT ) r rY rU rV rE Úsizer° rT Ú_take_with_fillÚ_take_without_fillr¨ rW r )r» rÊ rV rW rT r s r= rF zSparseArray.take# s« Ü WÔ Ü Ð IÈ'ÈÐRTÐ UÓVÐ VÜ**W¬B¯H©HÔ5àØ <<1Ò ÜXXb¨Ô1FØJJEÙ Ø×)Ñ)¨'¸jÐ)ÓIFà×*Ñ*¨7Ó3Ð 3àtDzØ t°T·Y±YÀeô
|
ð
|
r< c ó || j j }|j « dk r t d« |j « t | « k\ r t d« t | « dk( rq|dk( j « rSt j | j t |« « }t j ||¬« }|j |« |S t d« | j j |« }|dk( }|dk( | z }| j j dk( rR|j « rBt j" |j$ | j& | j j( ¬« }|S | j j dk( rft j | j j( t |« « }t j" |j$ ||¬« }| j& ||< |S | j j+ |« }|| dk } || dk }
|
|j } | j- « rIt j | t | j& « « } |j/ | « }| j& ||< |
|
j- « r5t j | t |« « } |j/ | « }|||< |S )Nr zKInvalid value in 'indices'. Must be between -1 and the length of the array.ú!out of bounds value in 'indices'.r rS ú.cannot do a non-empty take from an empty axes.rü )rT r r rY Úmaxr¸ rG rd rU rÒ r{ r¨ Ú
|
empty_liker rv Ú lookup_arrayr¹ rÓ rÇ rW rX rF r~ ru ) r» rÊ rW rT ÚtakenÚ
|
sp_indexerÚnew_fill_indicesÚold_fill_indicesr¡ Úm0Úm1rÒ s r= rY zSparseArray._take_with_fill5 sX Ø Ð Ø ×,Ñ,Jà ;;=2Ò Ü ð/óð ð
|
;;=C IÒ %Ü Ð @ÓAÐ Aä t9>à2 ×"Ñ"Ô$Ü t§~¡~´t¸JÓ7GÓHÜ g°UÔ;Ø
|
|
:Ô&Ø ä Ð!QÓRÐRð
|
]]×/Ñ/°Ó8
|
Ø" b=ÐØ &¨"Ñ ,Ð1AÐ0AÑAÐà ==× Ñ AÒ %Ð*:×*>Ñ*>Ô*@äGGØ× Ñ ¨T¯_©_ÀDÇJÁJ×DVÑDVôEð@ ð9 ]]× "Ñ " aÒ 'ä^^ D§J¡J×$6Ñ$6¼¸ZÓ8HÓIFÜGGJ× ,Ñ ,¸È6ÔREØ&*§o¡oEÐ"Ñ #ð0 ð- NN×'Ñ'¨
|
Ó3Eð Ð ,Ñ-°Ñ1BØÐ ,Ñ-°Ñ1Bà ++KàvvxÜ nn¨[¼$¸t¿¹Ó:OÓ P Ø [Ó1Ø*.¯/©/Ð&Ñ'àvvxÜ nn¨[¼$¸zÓ:JÓ K Ø [Ó1Ø*4Ð&Ñ'à r< c ó\ |dk }t | « }|j « |k\ s|j « | k r|dk( r t d« t d« |j « r |j « }||xx |z cc< | j j |« }|dk7 }| j || }t j |« j t j d¬« }t t |« || j ¬« }t | « j! ||| j" ¬« S ) Nr r] r\ r Fr` r: rS )r¸ r^ r rG r~ ra rv r` r{ rU rA ru rE rC r r¨ rÄ rT ) r» rÊ Úto_shiftrP rb Ú
|
value_maskÚ new_sp_valuesÚ value_indicesrO s r= rZ z SparseArray._take_without_fillw sý ØQ;ä Ià KKMQÒ G§K¡K£M°Q°BÒ$6ØAvÜ Ð!QÓRÐRÜ Ð @ÓAÐ Aà <<>Ø llnGØ HÓ Ñ "Ó à]]×/Ñ/°Ó8
|
Ø 2Ñ%
|
Ø z°*Ñ'=Ñ> ä zÓ2×9Ñ9¼"¿(¹(ÈÐ9ÓO ä(¬¨W« °}È4Ï9É9ÔU ÜDz×%Ñ% m°\ÈÏÉÐ%ÓTÐTr< c óð d}t j |t t « ¬« t j
|
|« }t j
|
| | j j ¬« j |||« S )Nz(searchsorted requires high memory usage.r£ rS ) r¬ r r r rU rV rT rX Ú searchsorted)r» ÚvÚsideÚsorterrÙ s r= rm zSparseArray.searchsorted sV ð 9Ü cÔ-Ô:JÓ:LÕMÜ JJqMÜzz$ d§j¡j×&8Ñ&8Ô9×FÑFÀqÈ$ÐPVÓWÐWr< c ó | j j « }| j || j | j « S rÀ )r{ ra rÄ rv rT )r» rá s r= ra zSparseArray.copy s1 Ø ×$Ñ$Ó&Ø× Ñ ¨¯ © °t·z±zÓBÐBr< c ó¤ |d j }g }d}|r|d j }nd}|dk( r®g }|D ]p }|j j j « }||z }||j j
|
z }|j |j « |j |« r t j |« } t j |« }
|
t ||
|
« } nìg } g } |D ] }|j j « }|j |j « | j |j j « |z « | j |j « ||j j
|
z } t j |« } t j | « }t j | « }t |||« } | | | |¬« S )Nr rA ©r rW )rW r rv rÊ ra r¯ Úappendr{ rU Ú concatenater Úto_block_indexÚblocsÚblengthsr )rÂ Ú to_concatrW rá r¯ Úsp_kindrÊ rZ Úint_idxr Ú indices_arrrv rx rw Ú block_idxÚ blocs_arrÚ blengths_arrs r= r z SparseArray._concat_same_type s à q\×,Ñ,
|
àØá Ø l×'Ñ'Gà Gð iÒ ØGà ò (Ø ,,×.Ñ.×3Ñ3Ó5Ø6Ñ!Ø#,,×-Ñ-Ñ-à cmmÔ,ØwÕ'ð (ô >> &Ó)DÜ ..¨Ó1Kô ¨ Ó4Hð HØEà ò .Ø LL× 7Ñ 7Ó 9 à cmmÔ,Ø Y__× 1Ñ 1Ó 3°fÑ <Ô=Ø × 2Ñ 2Ô3Ø#,,×-Ñ-Ñ-ð .ô >> &Ó)DÜ uÓ-IÜ >>¨(Ó3Lä! &¨)°\ÓBHá4 h¸:ÔFÐFr< c ó || j k( r|s| S | j « S t |« }t |t « s.t j | « }t |« }t ||d¬« S | j j |« }t |j « }t t
|
j |« }t | j « }t |||¬« }t j |« }| j || j |« S )aE
|
Change the dtype of a SparseArray.
|
|
The output will always be a SparseArray. To convert to a dense
|
ndarray with a certain dtype, use :meth:`numpy.asarray`.
|
|
Parameters
|
----------
|
dtype : np.dtype or ExtensionDtype
|
For SparseDtype, this changes the dtype of
|
``self.sp_values`` and the ``self.fill_value``.
|
|
For other dtypes, this only changes the dtype of
|
``self.sp_values``.
|
|
copy : bool, default True
|
Whether to ensure a copy is made, even if not necessary.
|
|
Returns
|
-------
|
SparseArray
|
|
Examples
|
--------
|
>>> arr = pd.arrays.SparseArray([0, 0, 1, 2])
|
>>> arr
|
[0, 0, 1, 2]
|
Fill: 0
|
IntIndex
|
Indices: array([2, 3], dtype=int32)
|
|
>>> arr.astype(SparseDtype(np.dtype('int32')))
|
[0, 0, 1, 2]
|
Fill: 0
|
IntIndex
|
Indices: array([2, 3], dtype=int32)
|
|
Using a NumPy dtype with a different kind (e.g. float) will coerce
|
just ``self.sp_values``.
|
|
>>> arr.astype(SparseDtype(np.dtype('float64')))
|
... # doctest: +NORMALIZE_WHITESPACE
|
[nan, nan, 1.0, 2.0]
|
Fill: nan
|
IntIndex
|
Indices: array([2, 3], dtype=int32)
|
|
Using a SparseDtype, you can also change the fill value as well.
|
|
>>> arr.astype(SparseDtype("float64", fill_value=0.0))
|
... # doctest: +NORMALIZE_WHITESPACE
|
[0.0, 0.0, 1.0, 2.0]
|
Fill: 0.0
|
IntIndex
|
Indices: array([2, 3], dtype=int32)
|
FrÛ r` )r¡ ra r r§ r" rU rV r, r rT Ú update_dtypeÚ_subtype_with_strr r{ rÄ rv )r» rT ra Ú future_dtyperá rX r{ s r= ru zSparseArray.astypeÕ s× ðr DKKÒ ÙØ àyy{Ð"ä# EÓ* Ü,¬ Ô4äZZ Ó%FÜ3°FÓ;FÜ ¨lÀÔGÐ Gà
|
|
×'Ñ'¨Ó.Ü u× 6Ñ 6Ó7Ürxx Ó)Ü/°·±Ó?Ü ¨°tÔ< ÜJJyÓ) à× Ñ ¨4¯=©=¸%Ó@Ð@r< c óD t t j t f« | j | t « r rj « n « fd}| j D cg c]
|
} ||« }} t | « || j ¬« S c c}w )af
|
Map categories using an input mapping or function.
|
|
Parameters
|
----------
|
mapper : dict, Series, callable
|
The correspondence from old values to new.
|
na_action : {None, 'ignore'}, default None
|
If 'ignore', propagate NA values, without passing them to the
|
mapping correspondence.
|
|
Returns
|
-------
|
SparseArray
|
The output array will have the same density as the input.
|
The output fill value will be the result of applying the
|
mapping to ``self.fill_value``
|
|
Examples
|
--------
|
>>> arr = pd.arrays.SparseArray([0, 1, 2])
|
>>> arr.map(lambda x: x + 10)
|
[10, 11, 12]
|
Fill: 10
|
IntIndex
|
Indices: array([1, 2], dtype=int32)
|
|
>>> arr.map({0: 10, 1: 11, 2: 12})
|
[10, 11, 12]
|
Fill: 10
|
IntIndex
|
Indices: array([1, 2], dtype=int32)
|
|
>>> arr.map(pd.Series([10, 11, 12], index=[0, 1, 2]))
|
[10, 11, 12]
|
Fill: 10
|
IntIndex
|
Indices: array([1, 2], dtype=int32)
|
c ól rj | d « n | « }|u s|k( r d}t |« |S )Nz-fill value in the sparse values not supported)ÚgetrY )Úsp_valÚ
|
new_sp_valrÙ Úfill_valÚis_mapÚmappers r= Úfuncz SparseArray.map.<locals>.funcS s? ø Ù5; F¨DÔ1ÁÈÃ JàXÑ%¨°xÒ)?ØEÜ oÐ%Ø Ð r< rs )
|
r§ r ÚMappingr$ rW r' r r{ r¨ rv )r» r Ú na_actionr Úxr{ r r s ` @@r= ÚmapzSparseArray.map$ s ú ôP F¤S§[¡[´)Ð$<Ó=à??à Ð ¤ h¤Ù9?vzz (¨HÔ5ÁVÈHÓEUHö ð '+§n¡nÖ5 T!WÐ5 Ð5àtDz)°$·-±-ÈHÔUÐUùò 6s Á.B c óX t j | | j j ¬« S )zr
|
Convert SparseArray to a NumPy array.
|
|
Returns
|
-------
|
arr : NumPy array
|
rS )rU rV r{ rT rå s r= ry zSparseArray.to_dense_ s ô zz$ d§n¡n×&:Ñ&:Ô;Ð;r< c ó® t j || |« }t |j | j ¬« }t | « j ||¬« }|S )Nr rS )rU r r" rT rW r¨ rß )r» rí rØ Únaive_implementationrT r s r= Ú_wherezSparseArray._wherei sM ô "xx¨¨d°EÓ :Ð ÜÐ 0× 6Ñ 6À4Ç?Á?ÔSÜd×*Ñ*Ð+?ÀuÐ*ÓMØ r< c ó
|
t |t « rX|\ }\ }}t j g « }|j |« || _ || _ t |j |« | _ y| j j |« y)z*Necessary for making this object picklableN) r§ r; rU r° Ú __setstate__r r r" rT r¡ Ú__dict__Úupdate)r» ÚstateÚnd_staterW rv r½ s r= r zSparseArray.__setstate__t sl ä eUÔ #à/4Ñ ,HÑ,z 8Ü HH RLMØ × &Ñ & xÔ 0à"/DÔ Ø!)DÔ Ü% m×&9Ñ&9¸:ÓFDKà MM× Ñ Õ 'r< c ó | j dk( r| j j fS | j j | j dk7 fS )Nr )rW rv rÊ r{ rå s r= ÚnonzerozSparseArray.nonzero sB Ø ??aÒ ØMM×)Ñ)Ð+Ð +àMM×)Ñ)¨$¯.©.¸AÑ*=Ñ>Ð@Ð @r< )ÚskipnaÚkeepdimsc óè t | |d « }|t d| d| j « |r| }n| j « } t ||« di |¤}|r t | « |g| j ¬« S |S )Nzcannot perform z with type rS r; )r r« rT r. r¨ )r» r r r Úkwargsr rZ r s r= Ú_reducezSparseArray._reduce s} ô t TÓ*à >Üo¨d¨V°;¸t¿z¹z¸lÐ KÓLÐ Lá ØCà++-Cà#dÓ#Ñ- fÑ-á Ø 4:vh¨d¯j©jÔ9Ð 9àMr< c óÔ t j ||« | j }t |« t | « k7 r t j
|
| j « sy|j « S )z£
|
Tests whether all elements evaluate True
|
|
Returns
|
-------
|
all : bool
|
|
See Also
|
--------
|
numpy.all
|
F)ÚnvÚ validate_allr{ r¸ rU rd rW ©r» ÚaxisÚargsr rá s r= rd zSparseArray.all sI ô fÔ%à ä v;#d)Ò #¬B¯F©F°4·?±?Ô,CØàzz|Ðr< c óð t j ||« | j }t |« t | « k7 r t j
|
| j « ry|j « j « S )z¯
|
Tests whether at least one of elements evaluate True
|
|
Returns
|
-------
|
any : bool
|
|
See Also
|
--------
|
numpy.any
|
T)r£ Ú validate_anyr{ r¸ rU r~ rW rË r¥ s r= r~ zSparseArray.anyµ sR ô fÔ%à ä v;#d)Ò #¬¯©¨t¯©Ô(?Øàzz|× Ñ Ó"Ð"r< c óR t j ||« | j }|j « }| j j
|
dkD xr | j }|r#|s!t | j j d¬« S | j r:t |j d|« r!t | j j d¬« S |S | j j
|
} t |j d|| z
|
« r!t | j j d¬« S || j | z z S )a
|
Sum of non-NA/null values
|
|
Parameters
|
----------
|
axis : int, default 0
|
Not Used. NumPy compatibility.
|
min_count : int, default 0
|
The required number of valid values to perform the summation. If fewer
|
than ``min_count`` valid values are present, the result will be the missing
|
value indicator for subarray type.
|
*args, **kwargs
|
Not Used. NumPy compatibility.
|
|
Returns
|
-------
|
scalar
|
r F©ÚcompatN) r£ Ú validate_sumrî Úsumrv rw ró r& rT rX r1 rÇ rW )
|
r» r¦ Ú min_countr r§ r Ú
|
valid_valsÚsp_sumÚhas_naÚnsparses
|
r= r® zSparseArray.sumÊ sï ô4 fÔ%Ø×*Ñ*
|
Ø Ó!Ø ×$Ñ$ qÑ(ÒF°×1FÑ1FÐ-Fá &Ü% d§j¡j×&8Ñ&8ÀÔGÐ Gà × Ò Ü$ Z×%5Ñ%5°t¸YÔGÜ)¨$¯*©*×*<Ñ*<ÀUÔKÐKØMàmm×)Ñ)GÜ$ Z×%5Ñ%5°t¸YÈÑ=PÔQÜ)¨$¯*©*×*<Ñ*<ÀUÔKÐKØDOO¨gÑ 5Ñ5Ð 5r< c óH t j ||« | || j k\ rt d| d« | j s't | j « « j « S t | j j « | j | j ¬« S )a
|
Cumulative sum of non-NA/null values.
|
|
When performing the cumulative summation, any non-NA/null values will
|
be skipped. The resulting SparseArray will preserve the locations of
|
NaN values, but the fill value will be `np.nan` regardless.
|
|
Parameters
|
----------
|
axis : int or None
|
Axis over which to perform the cumulative summation. If None,
|
perform cumulative summation over flattened array.
|
|
Returns
|
-------
|
cumsum : SparseArray
|
zaxis(=z) out of boundsrs ) r£ Úvalidate_cumsumÚndimrY ró rQ ry Úcumsumr{ rv rW )r» r¦ r§ r s r= r· zSparseArray.cumsumö s ô$ ×Ñ4 Ô(à Ð ¨¯ © Ò 1Ü v d V¨?Ð ;Ó<Ð <à×$Ò$Ü t}}Ó/×6Ñ6Ó8Ð 8äØ NN× !Ñ !Ó #Ø Øô
|
ð
|
r< c óú t j ||« | j }|j « }t |« }| j
|
r||z S | j j }|| j |z z ||z z S )zb
|
Mean of non-NA/null values
|
|
Returns
|
-------
|
mean : float
|
) r£ Ú validate_meanrî r® r¸ ró rv rw rW )r» r¦ r§ r r° r± Úctr³ s r= ÚmeanzSparseArray.mean ss ô ×ÑvÔ&Ø×*Ñ*
|
Ø Ó!Ü _à × Ò ØB;Ð àmm×)Ñ)GØT__¨wÑ 6Ñ6¸2À¹<ÑHÐ Hr< )r¦ r c óh t j || j « | j d|¬« S )a4
|
Max of array values, ignoring NA values if specified.
|
|
Parameters
|
----------
|
axis : int, default 0
|
Not Used. NumPy compatibility.
|
skipna : bool, default True
|
Whether to ignore NA values.
|
|
Returns
|
-------
|
scalar
|
r^ ©r ©r£ Úvalidate_minmax_axisr¶ Ú_min_max©r» r¦ r s r= r^ zSparseArray.max) ó+ ô × Ñ d§i¡iÔ0Ø}}U¨6}Ó2Ð2r< c óh t j || j « | j d|¬« S )a4
|
Min of array values, ignoring NA values if specified.
|
|
Parameters
|
----------
|
axis : int, default 0
|
Not Used. NumPy compatibility.
|
skipna : bool, default True
|
Whether to ignore NA values.
|
|
Returns
|
-------
|
scalar
|
r r½ r¾ rÁ s r= r zSparseArray.min; r r< c óÒ | j }| j xr | j j dkD }t |« dkD rw t ||« « }|r$|dk( rt nt } ||| j « S |r|S | j j dk( r|S t | j j d¬« S |r | j S t | j j d¬« S )zº
|
Min/max of non-NA/null values
|
|
Parameters
|
----------
|
kind : {"min", "max"}
|
skipna : bool
|
|
Returns
|
-------
|
scalar
|
r r^ Fr« ) rî ró rv rw r¸ r r^ r rW r& rT rX )r» r r r° Úhas_nonnull_fill_valsÚ
|
sp_min_maxr s r= rÀ zSparseArray._min_maxM sÏ ð ×*Ñ*
|
Ø$(×$9Ñ$9Ð 9Ò U¸d¿m¹m×>QÑ>QÐTUÑ>UÐ ä z?QÒ Ø2 ¨TÓ2Ó4Jñ %Ø " ems´ÙJ¨¯©Ó8Ð8ÙØ!Ð!Ø ×$Ñ$¨Ò)à!Ð!ä)¨$¯*©*×*<Ñ*<ÀUÔKÐKÙ "Ø??Ð "ä% d§j¡j×&8Ñ&8ÀÔGÐ Gr< c ó | j }| j j }t j t |« « }|dk( rt j nt j }t j |j d « }|| }|| }| ||« } || }
|
t | j « r|
|
S |dk( r| |
|
| j k r|
|
S |dk( r| |
|
| j kD r|
|
S | j « } | dk( r|
|
S | S )Nr r Úargminr ) r r rÊ rU rV r% r rÈ rD rÇ rW r ) r» r rá r rí r rÍ Únon_nansÚ non_nan_idxÚ
|
_candidateÚ candidateÚ_locs r= Ú_argmin_argmaxzSparseArray._argmin_argmaxp sö Ø×$Ñ$Ø×"Ñ"×*Ñ*Üzz$v,Ó'Ø HÒ ,ryy´"·)±)äii QÓ(Ø4%=Ø4%j à ¡ h£ Ñ0
|
Ø*Ñ% ä Ô Ø Ð Ø 8Ò Y¡°$·/±/Ò AØ Ð Ø 8Ò Y¡°$·/±/Ò AØ Ð Ø×)Ñ)Ó+Ø 2:à Ð àKr< c ód t |d« |s| j rt | j d« S )Nr r ©r Ú_hasnaÚNotImplementedErrorrÎ ©r» r s r= r zSparseArray.argmax ó, ÜF HÔ-Ù$++Ü%Ð %Ø×"Ñ" 8Ó,Ð,r< c ód t |d« |s| j rt | j d« S )Nr rÈ rÐ rÓ s r= rÈ zSparseArray.argmin rÔ r< c ó° |j dd« }||z D ]( }t | j t fz « r"t c S t j ||g|¢i |¤}|t ur|S d|v r t j ||g|¢i |¤}|S |dk( r%t j ||g|¢i |¤}|t ur|S t |« dk( r¡ t ||« j fi |¤} t ||« j fi |¤}
|
|j dkD r t fdt | |
|
« D « « } | S |dk( r| S j! | j" t% | j& |
|
« « S t d |D « « } t ||« | i |¤}|rt |« dk( r|d }|S |j dkD rt fd|D « « S |d k( ry t) « |« S )
|
NrÔ r; Úreducerf c 3 ó K | ]8 \ }}j |j t |j |« « : y wrÀ )rÄ rv r" rT )Ú.0Úsp_valueÚfvr» s r= ú <genexpr>z.SparseArray.__array_ufunc__.<locals>.<genexpr>À s@ øè ø ò ñ % "ð ×$Ñ$Ø $§-¡-´¸X¿^¹^ÈRÓ1P÷ñ ùs >Ac 3 óF K | ] }t j |« y wrÀ )rU rV )rÙ r s r= rÜ z.SparseArray.__array_ufunc__.<locals>.<genexpr>Ï s è ø Ò9¨Q2:: a=Ñ9ùs !r c 3 ó@ K | ] } t « |« y wrÀ )r¨ )rÙ r r» s r= rÜ z.SparseArray.__array_ufunc__.<locals>.<genexpr>× s øè ø Ò7¨1d A Ñ7ùs Úat)r r§ Ú_HANDLED_TYPESrQ ÚNotImplementedr( Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncr¸ r r{ rW Únoutr; ÚziprÄ rv r" rT r¨ ) r» Úufuncr Úinputsr rÔ r r Úresr{ rW ÚarraysÚ
|
new_inputss ` r= Ú__array_ufunc__zSparseArray.__array_ufunc__ s ø Øjj Ó#à# ò &AÜ a ×!4Ñ!4¼ °~Ñ!EÕFÜ%Ò%ð &ô
|
×<Ñ<Ø %ð
|
Ø"(ò
|
Ø,2ñ
|
ð Ñ 'ØMà F?ä×3Ñ3ØeVðØ&,òØ06ñCð Jà XÒ Ü ×7Ñ7ØeVðØ&,òØ06ñFð ^Ñ+à ä v;!Ò à. vÓ.¨t¯~©~ÑHÀÑHIØ/ ¨Ó/°·±ÑJÀ6ÑJJàzzA~ä ó ô ),¨I°zÓ(Bô ó ð Ø8Ò#à Ð à×#Ñ#Ø4==¬+°i·o±oÀzÓ*Róð ô Ñ9°&Ô9Ó9
|
Ø' Ó'¨Ð>°vÑ>Ù Ü3x1}Ø!fØJà ::>ÜÓ7°Ô7Ó7Ð 7Ø t^àà 4:fÓ%Ð %r< c ó^ |j }t |t « rt | |||« S t |« r®t j d¬« 5 |t | « t j |« « } || j |« }d d d « |dk( r:\ }}\ }} t ||| j |« t ||| j | « fS t || j « S t j |« }t j d¬« 5 t | « t |« k7 r#t dt | « dt |« « t |t « s%t |dd « }
|
t || j |
|
¬« }t | |||« cd d d « S # 1 sw Y xY w# 1 sw Y y xY w)Nrb rc rs zlength mismatch: z vs. rT rü )r7 r§ rQ r r rU rx r[ rV r{ r rv r¸ rº r rW ) r» Úotherr
Úop_namer r r r ÚlfillÚrfillrT s r= Ú _arith_methodzSparseArray._arith_methodâ s Ø++ä e[Ô )Ü# D¨%°°WÓ=Ð =ä uÔ Ü Ô*ñ 3Ù) D/¬2¯:©:°eÓ+<Ó=ÙDNN¨EÓ2÷ 3ð (Ò"Ø $ eØ # uä ¨$°· ± ¸uÓEÜ ¨%°· ± ÀÓFðð ô
|
¨°· ± ÀÓEÐ Eô JJuÓ%EÜ Ô*ñ BÜt9¤ E£
|
Ò*Ü(Ø+¬C°«I¨;°e¼CÀ»J¸<ÐHóð ô " %¬Ô5Ü # E¨7°DÓ 9EÜ '¨¸$¿/¹/ÐQVÔ WEÜ'¨¨e°R¸ÓA÷ Bñ B÷! 3ñ 3ú÷ Bð Bús Á 9FÄA=F#ÆF Æ#F,c óÐ t |« s*t |t | « « st j |« }t |t j
|
« rt || j ¬« }t |t « rct | « t |« k7 r#t dt | « dt |« « |j j d« }t | |||« S || j |« }t j t | « |t j ¬« } || j |« || j j" < t | « ||t j ¬« S )Nr z operands have mismatched length z and rm rS rü )r r§ r¨ rU rV r´ rQ rW r¸ rY r7 Ústripr rÓ rý r{ rv rÊ )r» rî r
rï rW r s r= Ú _cmp_methodzSparseArray._cmp_method s ÜÔ ¬
|
°5¼$¸t»*Ô(EäJJuÓ%Eä eRZZÔ (ä °$·/±/ÔBEä e[Ô )Ü4yC JÒ&Ü Ø6´s¸4³y°kÀÄsÈ5ÃzÀlÐSóð ð kk×'Ñ'¨Ó,GÜ# D¨%°°WÓ=Ð =ñ DOO¨UÓ3JÜWWS Y¨
|
¼"¿(¹(ÔCFÙ,.¨t¯~©~¸uÓ,EF4==×(Ñ(Ñ )à 4:ØØ%Ühhôð r< c óÂ |t j | j « « j « }t | j
|
j |« }t | j « s|| j k( rB || j « }t | « j || j | j
|
« S t | « || j « « |¬« S rÝ ) rU r° rW rË r" rT rX r% r{ r¨ rÄ rv ry )r» r
rW rT rá s r= Ú _unary_methodzSparseArray._unary_method" s Ù § ¡ Ó1Ó2×7Ñ7Ó9
|
ÜDJJ× .Ñ .°
|
Ó;ô Ô J°$·/±/Ò$AÙÓ'FÜ:×)Ñ)¨&°$·-±-ÀÇÁÓLÐ LàtDz"T]]_Ó-°UÔ;Ð;r< c ó@ | j t j « S rÀ )r÷ ÚoperatorÚposrå s r= Ú__pos__zSparseArray.__pos__- ó Ø×!Ñ!¤(§,¡,Ó/Ð/r< c ó@ | j t j « S rÀ )r÷ rù Únegrå s r= Ú__neg__zSparseArray.__neg__0 rü r< c ó@ | j t j « S rÀ )r÷ rù Úinvertrå s r= Ú
|
__invert__zSparseArray.__invert__3 s Ø×!Ñ!¤(§/¡/Ó2Ð2r< c ó@ | j t j « S rÀ )r÷ rù r rå s r= Ú__abs__zSparseArray.__abs__6 rü r< c ó¼ t j | « }t j | j « }t j | j « }| d| d| S )Nz
|
Fill: ú
|
)r2 Ú pprint_thingrW rv )r» Úpp_strÚpp_fillÚpp_indexs r= Ú__repr__zSparseArray.__repr__< sQ Ü×&Ñ& tÓ,Ü×'Ñ'¨¯©Ó8Ü×(Ñ(¨¯ © Ó7Ø ' ¨"¨X¨JÐ7Ð7r< c ó y rÀ r; )r» Úboxeds r= Ú
|
_formatterzSparseArray._formatterB s ð r< )NNrA NF)r ÚSparseIndexKindrT ú Dtype | Nonera rj ÚreturnÚNone)r r r r rT r" r rL )r r> r rL )NN)rT zNpDtype | Nonera z bool | Noner r )r r )rT r ra rj )r r )r r )r r" )r r )r Úint)r rj )r Úfloat)r rL )
|
r r? rþ ú
|
int | Nonerÿ z#Literal['inside', 'outside'] | Nonera rj r rL )NNNT)r zFillnaOptions | Nonerþ r ra rj r rL )rf N)r r r rL )Úfirst)r z Literal['first', 'last', False]r znpt.NDArray[np.bool_])T)r( rj r z tuple[np.ndarray, SparseArray])r. rj r rO )r× rK r r )r× z,SequenceIndexer | tuple[int | ellipsis, ...]r rL )r× z.PositionalIndexer | tuple[int | ellipsis, ...]r z
|
Self | Any)rV rj r rL rÀ )r N)rn zArrayLike | objectro zLiteral['left', 'right']rp zNumpySorter | Noner z npt.NDArray[np.intp] | np.intp)ry zSequence[Self]r rL )NT)rT zAstypeArg | Nonera rj )r z tuple[npt.NDArray[np.int32]])r r© r rj r rj )r )r¦ rF r rj )r r T)r¦ rF r¯ r r rj r rJ )r¦ rF r rQ )r¦ rE )r¦ zAxisInt | Noner rj )r zLiteral['min', 'max']r rj r rJ )r zLiteral['argmin', 'argmax']r r )r rj r r )rç znp.ufuncr r© )r rQ )r r© )F)r rj )Wr7 r8 r9 Ú__doc__Ú_subtypr+ Ú _hidden_attrsÚ frozensetÚ__annotations__r¾ Ú classmethodrÄ rÏ rÕ rÚ rß rã Úpropertyrv r{ rT rW Úsetterr rî rð ró rõ r÷ rù r¹ r% r r r r r r* r r r& r) r4 r
|
r7 r< rF rY rZ rm ra r ru r ry r r r r¡ rd r~ r® r· r» r^ r rÀ rÎ r rÈ rU r´ ÚnumbersÚNumberrà rì rò rõ Ú_logical_methodr÷ rû rÿ r r r r Ú __classcell__)r s @r= rQ rQ så ø
ñDðL GØ ×.Ñ.±¸2³ Ñ>MØ Ó Ø Ó Ø Óð
|
ØØ )Ø "ØðCCð
|
ð CCð ð CCð ðCCð
|
óCCðJ ð
|
à ð
|
ð "ð
|
ð ð
|
ð
|
|
ò
|
ó ð
|
ð ò)2ó ð)2ðX AEð)Ø#ð)Ø2=ð)à ó)óV ð Ø>BÐQVô )ó ð)ð ñ1ó ð1ð ò"ó ð"ð ò #ó ð #ð òó ðð ñ%ó ð%ð$ ×Ñò=ó ð=ð òó ðð ò ó ð ó
|
$ð ò-ó ð-ó1ð ò<ó ð<ð ò <ó ð <ð ò %ó ð %ó ?ð !Ø:>Øñ
|
ð ð
|
ð ð
|
ð
|
8ð
|
ð ð
|
ð
|
õ
|
ð Ø'+Ø Øð ;Kð %ð;Kð ð ;Kð
|
ð ;Kð
|
õ ;Kôz-ò60ñ* × "Ñ "Ó#à6=ð>Ø3ð>à ò>ó $ð>ó Dò 1ð !%ð !à ð !ð
|
(ó !ô &7ðV ò ó ð ð ð à 9ð ð
|
ò ó ð ð \6à ;ð\6ð
|
ó\6ò| ð 38ÀDõ
|
ô$@óDUð4 *0Ø%)ð Xà ð Xð 'ð Xð #ð Xð
|
|
(ó XóCð ò5Gó ð5GônMAô^9Vóv<òó (ó Að ,0À%ñØðØ$(ðØ;?óó( ô*#ð. ØØð *6àð*6ð ð*6ð ð *6ð
|
ó*6ôX
|
ô@Ið& -1Àõ 3ð$ -1Àõ 3ó$!HóFô4-ô -ð jj '§.¡.Ð1Nó@&òL BóBð: "Oó <ó0ó0ó3ó0ó 8÷ ð r< c óÌ t | t j « sJ | j dkD r t d« |t | j « }t |« r t | « }n[t | j « r| j t « } t | j « rt j | |« }n| |k7 }t | « }|t |« k7 r|j j" }n0|j% « d j t j& « }t) |||« }| | }|-t+ |« }t- ||¬« }t j. |« }|||fS )a@
|
Convert ndarray to sparse format
|
|
Parameters
|
----------
|
arr : ndarray
|
kind : {'block', 'integer'}
|
fill_value : NaN or another value
|
dtype : np.dtype, optional
|
copy : bool, default False
|
|
Returns
|
-------
|
(sparse_values, index, fill_value) : (ndarray, SparseIndex, Scalar)
|
rf z expected dimension <= 1 datar rS )r§ rU r´ r¶ r« r& rT r% r' r ru r± r r Úmake_mask_object_ndarrayr¸ rv rÊ r rE rC r, r rV ) rZ r rW rT rí r¯ rÊ r Úsparsified_valuess r= r· r· H s4 ô* c2::Ô &Ð&Ð &à
|
xx!|ÜÐ6Ó7Ð7àÐÜ'¨¯ © Ó2
|
ä JÔÜSzô 399Ô %Ø**VÓ$Cä 399Ô %ô ×1Ñ1°#°zÓBDà*Ñ$Dä XFØ TÒà--×'Ñ'à,,. Ñ#×*Ñ*¬2¯8©8Ó4ä f g¨tÓ 4EØD ÐØ ÐÜ :Ð;LÓ MÐÜ (Ð):À%Ô HÐÜ JJÐ'8Ó 9Ðð e ZÐ /Ð/r< c ó y rÀ r; ©r¯ rÊ r s r= rC rC ó àr< c ó y rÀ r; r' s r= rC rC r( r< c ó |dk( r't j |« \ }}t | ||« }|S |dk( rt | |« }|S t d« )NrB rA z must be block or integer type)r Ú
|
get_blocksr r rY )r¯ rÊ r ÚlocsÚlensr s r= rC rC s] à wÜ×%Ñ% gÓ.
|
dÜ6 4¨Ó.ð
|
Lð
|
Ò Ü Ó)ð Lô Ð8Ó9Ð9r< )rZ rQ r r )
|
r rQ r rQ r
r r r© r rQ rÀ )r r© rT r r rQ )rB NN)rZ r r r rT znp.dtype | None)r¯ r r zLiteral['block']r r )r¯ r r zLiteral['integer']r r )r¯ r r r r r )|r Ú
|
__future__r Ú collectionsr r rù Útypingr r r r r r
|
r¬ ÚnumpyrU Ú pandas._libsr Úpandas._libs.sparseÚ_libsÚsparser r r r Úpandas._libs.tslibsr Úpandas.compat.numpyr r£ Ú pandas.errorsr Úpandas.util._decoratorsr Úpandas.util._exceptionsr Úpandas.util._validatorsr r Úpandas.core.dtypes.astyper Úpandas.core.dtypes.castr r r Úpandas.core.dtypes.commonr r r r r r r Úpandas.core.dtypes.dtypesr! r" Úpandas.core.dtypes.genericr# r$ Úpandas.core.dtypes.missingr% r& r' Ú pandas.corer( Úpandas.core.algorithmsÚcoreÚ
|
algorithmsr Úpandas.core.arrayliker) Úpandas.core.arraysr* Úpandas.core.baser+ Úpandas.core.commonÚcommonrH Úpandas.core.constructionr, r- r. Úpandas.core.indexersr/ r0 Úpandas.core.nanopsr1 Úpandas.io.formatsr2 Úcollections.abcr3 Úenumr4 r6 r: Ú scipy.sparser> Úpandas._typingr? r@ r rC rD rE rF rG rH rI rJ rK rL rM rN r/ rO r¨ Ú_sparray_doc_kwargsr[ r r rQ r· rC r; r< r= ú<module>rT sî ðñõ #å Û Û ÷÷ ó ã å ß #Ð #÷ñ õ
|
$Ý .Ý ,Ý 'Ý 4÷õ
|
3÷ñ ÷
|
÷ ñ ÷÷÷ñ õ "ß &Ð &Ý *Ý -Ý )ß Ð ÷ñ ÷
|
õ 5å &ñ Ý(Ýô4ô ð × Ñ Hå%÷ð
|
Ð 0Ñ1O÷ ÷ ÷ ó ö ñ H~Hð Ð.Ð ó*ð0iGØ
|
ðiGØ )ðiGØ/7ðiGØ?BðiGàóiGðZ FJðØ
|
ðØ6Bðàóô.f(L¨.ô fðV1 $ØØ !ð ;0Ø ð;0à
|
ð;0ð ó ;0ð|
|
òó
|
ðð
|
òó
|
ðô r<
|
