U
|
¬ý°dCü ã @ sH d Z ddlmZ ddlmZ ddlZddlZddlmZm Z m
|
Z
|
m Z m Z m Z mZmZ ddlZddlZddlmZ ddlm mZ ddlmZmZmZ ddl m Z dd l m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) dd
|
l*m+Z, dd l-m.Z. dd l/m0Z0 dd l1m2Z2m3Z3 ddl4m5Z5 ddl6m7Z7m8Z8m9Z9 ddl:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZE ddlFmGZGmHZH ddlImJZJmKZKmLZL ddlMmNZNmOZO ddlPmQ mRZS ddlTmUZU ddlVmWZW ddlXmYZY ddlZm[Z[ ddl\mQ m]Z^ ddl_m`Z`maZambZb ddlcmdZdmeZe ddlfmgZg ddlhmiZi dd ljmkZk erdd llmmZm G d d d emZnenjoZodd lpmqZq dd!l mrZrmsZs e d" Ztdd#lumvZv neweoZne d$d%d&Zxd'd%iZyd%d(d)d*d+Zzd%d%d,d-d%d.d/d0Z{dGd-d1d%d2d3d4Z|G d5d% d%eUe[eWZ}dHd(d7d8d9d:d;Z~ed<d=d>d?d@dAZed<dBdCd?dDdAZd<d7dEd?dFdAZdS )Iz
|
SparseArray data structure
|
é )Ú annotations)ÚabcN)Ú TYPE_CHECKINGÚAnyÚCallableÚLiteralÚSequenceÚTypeVarÚcastÚoverload)Úlib)Ú
|
BlockIndexÚIntIndexÚ SparseIndex)ÚNaT) Ú ArrayLikeÚ AstypeArgÚAxisÚAxisIntÚDtypeÚNpDtypeÚPositionalIndexerÚScalarÚ ScalarIndexerÚSequenceIndexerÚnpt)Úfunction)ÚPerformanceWarning)Úfind_stack_level)Úvalidate_bool_kwargÚvalidate_insert_loc)Ú astype_array)Ú"construct_1d_arraylike_from_scalarÚfind_common_typeÚmaybe_box_datetimelike) Ú is_array_likeÚ is_bool_dtypeÚis_datetime64_any_dtypeÚis_datetime64tz_dtypeÚis_dtype_equalÚ
|
is_integerÚ is_list_likeÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚ pandas_dtype)ÚABCIndexÚ ABCSeries)ÚisnaÚna_value_for_dtypeÚnotna)Ú arraylikeÚops)ÚOpsMixin)ÚExtensionArray)Ú SparseDtype)Ú PandasObject)Ú ensure_wrapped_if_datetimelikeÚ extract_arrayÚsanitize_array)Úcheck_array_indexerÚunpack_tuple_and_ellipses)Úinterpolate_2d)Úcheck_below_min_count)Úprinting)ÚEnumc @ s e Zd ZdZdS )Úellipsisz...N)Ú__name__Ú
|
__module__Ú __qualname__ÚEllipsis© rI rI úVd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/arrays/sparse/array.pyrD m s rD )Úspmatrix)Ú FillnaOptionsÚ NumpySorter)ÚintegerÚblock)ÚSeriesÚ SparseArrayTÚ SparseArray)ÚboundÚklassú
|
np.ndarray)ÚarrÚreturnc C s< zt j| j| jjdW S tk
|
r6 t | j¡ Y S X dS )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
|
©ÚdtypeN)ÚnpÚasarrayÚ
|
fill_valuerY ÚsubtypeÚ
|
ValueError)rV rI rI rJ Ú _get_fill s r_ r Ústr)ÚleftÚrightÚopÚnamerW c C s® | d¡r|dd
}| jj}|jj}t||sxt||g}t|| j}t||j}| j|dd} |j|dd}|j}n|}d}| jj dks|jj dkròt
|
j dd * || ¡ | ¡ } |t | t |}
|
W 5 Q R X | jj dkrè| j} n|j} n\| j |j¡rDt
|
j dd & || j|j} |t | t |}
|
W 5 Q R X | j} n
|
|d d
|
krh|| } }|d d
}|d krª|d krªd| d} | j t
|
j¡} |j t
|
j¡}t}n d| d| } | j} |j}|dkr |dk ¡ r | jjdkr d| d} | d¡} | d¡}tt| }t
|
j dd & || | j| j||j|j\} } }
|
W 5 Q R X |dkrt|| d | |
|
d |dt|| d | |
|
d |dfS |dkr| j}t|| | |
|
|dS )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ÚboolZsparse_Z_uint8Ú_)ÚfloordivÚmod)ÚiÚuZ_float64Úfloat64ÚdivmodrX )Ú
|
startswithrY r] r) r# r9 r\ ÚastypeÚsp_indexÚngapsrZ ÚerrstateÚto_denser_ ÚequalsÚ sp_valuesÚviewZuint8rr ÚanyÚkindÚgetattrÚsplibÚ _wrap_result)ra rb rc rd ZltypeZrtyper] rY Z result_dtypeÚresultÚfillÚindexÚopnameZleft_sp_valuesZright_sp_valuesZ sparse_oprI rI rJ Ú_sparse_array_op¡ s|
|
|
|
|
|
ÿ
|
þ
|
ý
|
|
|
ú
|
þ
|
r ú Dtype | None)rd rY rW c C sL | d¡r| dd
} | dkr"t}t |¡}t|r<t|}t||||dS )z.
|
wrap op result to have correct dtype
|
re rf rg )ÚeqÚneÚltÚgtÚleÚge)Ú sparse_indexr\ rY )rz rr r Zitem_from_zerodimr& rR )rd Údatar r\ rY rI rI rJ r s
|
|
ÿr c @ s e Zd ZU dZdZejeg B Zded< ded< ded< dÏd d dddddZ e
|
ddddddddZ e
|
ddddddZ dÐd dd d d Z d d! Ze
|
d d d"d dd"d#d$Ze
|
d%d& Zedd'd(d)Zedd'd*d+Zedd'd,d-Zed.d/ Zejdd'd0d/Zed d'd1d2Zedd'd3d4Zd5d'd6d7Zedd'd8d9Zdd'd:d;Zed5d'd<d=Z ed>d'd?d@Z ed5d'dAdBZ dCdD Z dÑddEdFddGdHdIZ dÒdd5ddKdLdMZ!dNdO Z"dddPdQdRZ#dSdT Z$dÓddVdWdXdYZ%dÔddZd[d\d]Z&e'd^d_d`dadbZ(e'ddcddddedbZ(ddfdgdddhdbZ(didj Z)d d dkddddldmdnZ*dÕdd'dodpZ+dddPdqdrZ,dÖdtdudvdwdxdydzZ-dddPd{d|Z.e
|
dd}dd~ddZ/d×ddd"ddZ0dddPdd
Z1dd'ddZ2dd Z3dd'ddZ4dd'ddZ5dUddddddZ6dØddZ7dÙddddZ8dÚdd5dddddZ9dÛdd dd d¡Z:dÜd¢dd£d¤Z;d dUd¥d¦dd¥d§d¨Z<d dUd¥d¦dd¥d©dªZ=d«ddd¬dd®Z>d¯d5d°d±d²Z?dÝdd5d³d´dµZ@dÞdd5d³d¶d·ZAeBjCeDjEfZFd¸dd¹dºd»ZGd¼d½ ZHd d'd¾d¿ZIeIZJd d'dÀdÁZKd d'dÂdÃZLd d'dÄdÅZMd d'dÆdÇZNd d'dÈdÉZOdd'dÊdËZPdßddÌdÍdÎZQd S )àrR 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_indexrU Ú_sparse_valuesr9 Ú_dtypeNrN FÚSparseIndexKindr rr ÚNone)r rY ri rW c
|
C sº |d krt |tr|j}t |t| rV|d kr4|j}|d krB|j}|d krP|j}|j}t |trzt |¡}W n t k
|
r t
|
|}Y nX t |trª|d kr¤|j}|j }t |rÚ|d krÀd}n|j }t||d d}|j}|d k rêt
|
|}|d krtjg |d}t|s`zt|d d}W nB tk
|
r^ |d krXt t¡}t tj||d¡}n Y nX |rn| ¡ }|d kr¦|d kr|jn|}|d krtj}nt|}t |t| rØ|d krØ|j}tj|j|d} nÄ|d krjt|dd}t |tj sRt |jrHt j d|j dt t! d tj|d d}|t"krHt #d
|
d ¡}t |¡}t$||||d \} }}n2tj||d} t%| |j&krt'd t| d|| _| | _(t| j|| _)d S )Nrn rX )r T)Z extract_numpyzCreating SparseArray from z^ data loses timezone information. Cast to object before sparse to retain timezone information.©Ú
|
stacklevelzdatetime64[ns]r Úns)r r\ rY zNon array-like type z' must have the same length as the index)*Ú
|
isinstancer9 r\ Útyper| rY r r` Zconstruct_from_stringÚ TypeErrorr/ r] r- Úlengthr" rZ Úarrayr% r= r^ ÚobjectZ
|
atleast_1dr[ ri Únanr3 r r< Úndarrayr( ÚwarningsÚwarnÚ UserWarningr r Ú
|
datetime64Ú _make_sparseÚlenÚnpointsÚAssertionErrorr r )
|
Úselfr r r\ r rY ri r Zfill_value_dtypeÚ sparse_valuesrI rI rJ Ú__init__q s
|
|
|
|
|
|
|
|
ÿ
|
û
|
|
ù ÿzSparseArray.__init__ztype[SparseArrayT]rQ )Úclsr r rY rW c C s t | ¡}||_||_||_|S ©N)r¤ Ú__new__r r r )r² r r rY ÚnewrI rI rJ Ú _simple_newó s
|
|
zSparseArray._simple_newrK )r² r rW c C sv |j \}}|dkr"td| d| ¡ }| ¡ |j}|j}tjd|jd ¡ }t
|
|j|}t ||}| |||¡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)
|
rn z''data' must have a single column, not 'ú'r rX ) Úshaper^ ZtocscZ sort_indicesr ÚindicesrZ r£ rY Úitemr9 r r¶ ) r² r r¢ ZncolrV ÚidxZzerorY r rI rI rJ Ú from_spmatrix s
|
|
zSparseArray.from_spmatrixzNpDtype | None)rY rW c C s | j }| jjdkr| jS |d krpt| jjr>|tkr>t d¡}zt | jjt
|
|¡}W n t k
|
rn t }Y nX tj | j||d}| j|| jj< |S )Nr r rX )r\ r| r} r r' rY r rZ rª Ú result_typer r¡ r¤ Úfullr¸ r¹ )r¯ rY r\ ÚoutrI rI rJ Ú __array__, s
|
|
zSparseArray.__array__c C s d}t |d S )Nz8SparseArray does not support item assignment via setitem)r¡ )r¯ ÚkeyÚvalueÚmsgrI rI rJ Ú __setitem__E s zSparseArray.__setitem__©rY ri c C s | ||dS ©NrX rI )r² ZscalarsrY ri rI rI rJ Ú_from_sequenceL s zSparseArray._from_sequencec C s | ||j dS rÆ rX )r² ÚvaluesÚoriginalrI rI rJ Ú_from_factorizedP s z SparseArray._from_factorized)rW c C s | j S )zX
|
The SparseIndex containing the location of non- ``fill_value`` points.
|
)r ©r¯ rI rI rJ r| W s zSparseArray.sp_indexc C s | 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Ë rI rI rJ r ^ s zSparseArray.sp_valuesc C s | j S r³ )r rË rI rI rJ rY l s zSparseArray.dtypec C s | j jS )z
|
Elements in `data` that are `fill_value` are not stored.
|
|
For memory savings, this should be the most common value in the array.
|
)rY r\ rË rI rI rJ r\ p s zSparseArray.fill_valuec C s t | jj|| _d S r³ )r9 rY r] r )r¯ r rI rI rJ r\ y s c C s t | jtrdS dS dS )zW
|
The kind of sparse index for this array. One of {'integer', 'block'}.
|
rN rO N)r r| r rË rI rI rJ r } s zSparseArray.kindc C s | j }t|}|| S r³ )r r4 )r¯ Úsp_valsÚmaskrI rI rJ Ú_valid_sp_values s z SparseArray._valid_sp_valuesÚintc C s | j jS r³ )r| r¢ rË rI rI rJ Ú__len__ s zSparseArray.__len__c C s | j jS r³ )r Z_is_na_fill_valuerË rI rI rJ Ú_null_fill_value s z SparseArray._null_fill_valuec C s | j rt|S | j|kS d S r³ )rÑ r2 r\ )r¯ r\ rI rI rJ Ú_fill_value_matches s z SparseArray._fill_value_matchesc C s | j j| jj S r³ )r Únbytesr| rË rI rI rJ rÓ s zSparseArray.nbytesÚfloatc C s | j j| j j 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
|
)r| r r¢ rË rI rI rJ Údensity s zSparseArray.densityc C s | j jS )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
|
)r| r rË rI rI rJ r ¬ s zSparseArray.npointsc C sf t t| j}| jr,t| t| j| j|¡S tj t
|
| dtj d}t| j|| jj < t| |d|dS )NFrX ©r\ rY ) r9 rr rÑ r r¶ r2 r r| rZ r¾ r¬ Úbool_r¹ )r¯ rY rÍ rI rI rJ r2 º s zSparseArray.isnazFillnaOptions | Nonez
|
int | None)r¯ ÚmethodÚlimitrW c C s´ |dkr|dks |dk r(|dk r(t d|dk rpd}tj|tt d t | ¡}t|||d t| || j dS t
|
t | j || j ¡}| j rt| jj|d}n| 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
|
|
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.
|
Nz(Must specify one of 'method' or 'value'.z0fillna with 'method' requires high memory usage.r )rØ rÙ ©r\ )r^ r§ r¨ r r rZ r[ r@ r r\ Úwherer2 r rÑ r9 rY r] r¶ r )r¯ r rØ rÙ rà Z
|
new_valuesZ new_dtyperI rI rJ ÚfillnaÄ s* &ÿÿý
|
zSparseArray.fillnarn )r¯ ÚperiodsrW c C s¾ t | r|dkr| ¡ S t|r(| jj}t || jj¡}|| jjkrX| t || j
|
¡}n| }| j |gt t |t | |jd}|dkr|}|d |
}n|t |d
}|}| ||g¡S )Nr rX )r¬ ri r2 rY Úna_valuerZ r½ r] r{ r9 r\ rÇ ÚminÚabsÚ_concat_same_type)r¯ rÝ r\ r] rV ÚemptyÚaÚbrI rI rJ Úshift s$ ÿzSparseArray.shiftc C sh t | dks | jjt | kr dS | jj}t |r<|d dkr@dS tjt |¡df }||dk ¡ d S )zh
|
Get the location of the first fill value.
|
|
Returns
|
-------
|
int
|
r éÿÿÿÿrf rn )r¬ r| r r¹ rZ Zr_ÚdiffÚargmax)r¯ r¹ rç rI rI rJ Ú_first_fill_value_loc! s z!SparseArray._first_fill_value_loc)r¯ rW c C sb t | j¡}t| jt| krN| ¡ }tt | jd |
¡}t ||| j¡}t| j || j
|
dS rÆ ) ÚalgosÚuniquer r¬ ré rZ Úinsertr\ r rÇ rY )r¯ ÚuniquesZfill_locZ
|
insert_locrI rI rJ rë 6 s zSparseArray.uniquec C s t | ¡| jfS r³ )rZ r[ r\ rË rI rI rJ Ú_values_for_factorizeD s z!SparseArray._values_for_factorizeTz tuple[np.ndarray, SparseArray])Úuse_na_sentinelrW c C s. t jt | ¡|d\}}t|| jd}||fS )N)rï rX )rê Ú factorizerZ r[ rR rY )r¯ rï Úcodesrí Z
|
uniques_sprI rI rJ rð H s ÿ
|
zSparseArray.factorizerP )ÚdropnarW c C s´ ddl m}m} tj| j|d\}}| jj}|dkr| jr>|s| jrLt |n|| j
|
k}| ¡ rp|| |7 < n t |d| j
|
¡}t |d|¡}t|ts¢||}n|}|||ddS )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 )ÚIndexrP )rò F)r ri )Úpandasró rP rê Zvalue_counts_arrayliker r| r} rÑ r2 r\ r rZ rì r r0 ) r¯ rò ró rP ÚkeysÚcountsZfcountsrÍ r rI rI rJ Ú value_countsW s
|
|
zSparseArray.value_countsr r )rÁ rW c C s d S r³ rI ©r¯ rÁ rI rI rJ Ú __getitem__ s zSparseArray.__getitem__z,SequenceIndexer | tuple[int | ellipsis, ...])r¯ rÁ rW c C s d S r³ rI rø rI rI rJ rù s z.PositionalIndexer | tuple[int | ellipsis, ...]zSparseArrayT | Anyc C s t |tr"t|}|tkr"tdt|r4| |¡S t |trN| ¡ | }n"t |trf|j d ksp|j dkr@|j
|
d kr~dn|j
|
}|dk r|t | 7 }|j d krªt | n|j }|dk rÄ|t | 7 }| j j}t ||k||k @ ¡}| j| }|| ¡ }|dkr
|
||8 }t tt | | } t| || j}
|
t| ||
|
| j¡S tjt | tjd| }| |¡S n
|
t |szt dnöt |t r
|
t |r t |j!r°| |j j|j ¡S |j!sÆ| |j j¡S t | } tj"| dtj#d} d| |j j< | t | ¡| ¡S t $|¡}t%| |}t& '|¡rJt(tj)|}| tjt |tjd| ¡S t*|dr`| |¡S td | d
|
t| || jd S ) NzCannot slice with Ellipsisrn r rX zuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indicesTFrÐ zCannot slice with 'r· ©r )+r Útupler? rH r^ r* Ú _get_val_atr ÚsliceÚstepÚstartr¬ Ústopr| r¹ rZ Ú flatnonzeror ri ÚrangeÚmake_sparse_indexr r r¶ rY ÚarangeÚint32Útaker+ Ú
|
IndexErrorrR r& r2 r\ r¾ r× r[ r> ÚcomZis_bool_indexerr
|
r¦ Úhasattr) r¯ rÁ Z
|
data_slicerÿ Úendr¹ Z keep_indsrÌ r| Znew_lenÚ new_sp_indexÚnrÍ rI rI rJ rù sd
|
|
|
|
|
|
|
ÿ
|
|
|
|
c C sH t |t| }| j |¡}|dkr(| jS | j| }t|| jj}|S d S )Nræ )r r¬ r| Úlookupr\ r r$ rY )r¯ ÚlocZsp_locÚvalrI rI rJ rü ë s
|
zSparseArray._get_val_at)Ú
|
allow_fillr\ )r¯ r rW c C s t |rtd| dtj|tjd}d }|jdkrLtjg dd}| j}n |r`| j||d}n
|
| |¡S t
|
| || j | j |dS )Nz*'indices' must be an array, not a scalar 'z'.rX r r¤ rÚ )r\ r rY ) r- r^ rZ r[ r Úsizer£ rY Ú_take_with_fillÚ_take_without_fillr r\ r )r¯ r¹ r r\ rY r rI rI rJ r ö s
|
|
ÿzSparseArray.takec C s |d kr| j j}| ¡ dk r$td| ¡ t| kr<tdt| dkr|dk ¡ rt | j
|
t |¡}tj ||d}| |¡ |S td| j |¡}|dk}|dk| @ }| jjdkrÚ| ¡ rÚtj|j| j| j jd}n¼| jjdkrt | j jt |¡}tj|j||d}n| j
|
|¡}|| dk } || dk }
|
|j } | ¡ rjt | t | j¡} | | ¡}| j||< |
|
¡ rt | t |¡} | | ¡}|||< |S )Nræ zKInvalid value in 'indices'. Must be between -1 and the length of the array.ú!out of bounds value in 'indices'.r rX ú.cannot do a non-empty take from an empty axes.rÖ )rY rÞ rß r^ Úmaxr¬ r rl rZ r½ r r Z
|
empty_liker r| Ú lookup_arrayr r¾ r¸ r\ r] r r r{ ) r¯ r¹ r\ rY ZtakenÚ
|
sp_indexerZnew_fill_indicesZold_fill_indicesr Zm0Úm1r½ rI rI rJ r
|
sP ÿ
|
ÿ
|
|
|
|
|
zSparseArray._take_with_fillc C sÄ |dk }t | }| ¡ |ks*| ¡ | k rB|dkr:tdtd| ¡ rb| ¡ }|| |7 < | j |¡}|dk}| j|| }t
|
|¡j t j dd}t t ||| jd}t| j||| jdS ) Nr r r ræ Frh rú rX )r¬ r rß r r ri r| r r rZ r r{ r r r r r¶ rY ) r¯ r¹ Zto_shiftr r Z
|
value_maskZ new_sp_valuesZ value_indicesr rI rI rJ r K s z SparseArray._take_without_fillra zArrayLike | objectzLiteral[('left', 'right')]rM z npt.NDArray[np.intp] | np.intp)ÚvÚsideÚsorterrW c C sN d}t j|tt d t|s(t |¡}t |¡}tj| | jjd |||¡S )Nz(searchsorted requires high memory usage.r rX )
|
r§ r¨ r r r- rZ r[ rY r] Ú searchsorted)r¯ r r r rà rI rI rJ r b s
|
|
zSparseArray.searchsortedc C s | j ¡ }| || j| j¡S r³ )r ri r¶ r| rY )r¯ rÈ rI rI rJ ri o s
|
zSparseArray.copyzSequence[SparseArrayT])r² Ú to_concatrW c C s |d j }g }d}|r"|d j}nd}|dkrg }|D ]:}|jj ¡ }||7 }||jj7 }| |j¡ | |¡ q6t |¡} t |¡}
|
t
|
||
|
} n~g } g } |D ]F}|j ¡ }| |j¡ | |j ¡ | ¡ | |j ¡ ||jj7 }qt |¡} t | ¡}t | ¡}t|||} | | | |dS )Nr rN ©r r\ )r\ r r| r¹ ri r¢ Úappendr rZ Z concatenater Zto_block_indexÚblocsÚblengthsr )r² r r\ rÈ r¢ Zsp_kindr¹ rV Zint_idxr Z indices_arrr| r" r! Z block_idxZ blocs_arrZ blengths_arrrI rI rJ rá s s<
|
|
|
|
|
|
|
z SparseArray._concat_same_typezAstypeArg | Nonec C s¢ t || jr |s| S | ¡ S t|}t|tsNt | ¡}t|}t ||ddS | j
|
|¡}t|j }t tj
|
|}t| j}t |||d}t |¡}| || 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Å rh )r) r ri r/ r r9 rZ r[ r; r! rY Z update_dtypeZ_subtype_with_strr
|
r r¶ r| )r¯ rY ri Z future_dtyperÈ r] r rI rI rJ r{ s 9
|
|
|
|
|
zSparseArray.astypec sv t tr ¡ t tjrD | j| j¡} fdd| jD }n | j} fdd| jD }t| || j |dS )aÅ
|
Map categories using an input mapping or function.
|
|
Parameters
|
----------
|
mapper : dict, Series, callable
|
The correspondence from old values to new.
|
|
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 s g | ]} |d ¡qS r³ )Úget©Ú.0Úx©ÚmapperrI rJ Ú
|
<listcomp>) s z#SparseArray.map.<locals>.<listcomp>c s g | ] } |qS rI rI r$ r' rI rJ r) , s r )
|
r r1 Úto_dictr ÚMappingr# r\ r r r| )r¯ r( r\ r rI r' rJ Úmapü s (
|
|
zSparseArray.mapc C s t j| | jjdS )zr
|
Convert SparseArray to a NumPy array.
|
|
Returns
|
-------
|
arr : NumPy array
|
rX )rZ r[ r rY rË rI rI rJ r 0 s zSparseArray.to_densec C s4 t || |¡}t|j| jd}t| j||d}|S )NrÚ rX )rZ rÛ r9 rY r\ r rÇ )r¯ rÍ r Znaive_implementationrY r rI rI rJ Ú_where: s zSparseArray._wherec C sV t |trF|\}\}}t g ¡}| |¡ || _|| _t|j|| _ n | j
|
|¡ dS )z*Necessary for making this object picklableN) r rû rZ r£ Ú __setstate__r r r9 rY r Ú__dict__Úupdate)r¯ ÚstateZnd_stater\ r| r° rI rI rJ r. E s
|
|
|
zSparseArray.__setstate__z tuple[npt.NDArray[np.int32]]c C s, | j dkr| jjfS | jj| jdk fS d S )Nr )r\ r| r¹ r rË rI rI rJ ÚnonzeroS s
|
|
zSparseArray.nonzero©Úskipnar` )rd r4 c K sL t | |d }|d kr*td| d| j |r4| }n| ¡ }t ||f |S )Nzcannot perform z with type )r
r¡ rY rò )r¯ rd r4 ÚkwargsrØ rV rI rI rJ Ú_reduce] s zSparseArray._reducec O s: t ||¡ | j}t|t| kr2t | j¡s2dS | ¡ S )z£
|
Tests whether all elements evaluate True
|
|
Returns
|
-------
|
all : bool
|
|
See Also
|
--------
|
numpy.all
|
F)ÚnvZ validate_allr r¬ rZ rl r\ ©r¯ ÚaxisÚargsr5 rÈ rI rI rJ rl j s
|
zSparseArray.allr r )r9 c O s> t ||¡ | j}t|t| kr2t | j¡r2dS | ¡ ¡ S )z¯
|
Tests whether at least one of elements evaluate True
|
|
Returns
|
-------
|
any : bool
|
|
See Also
|
--------
|
numpy.any
|
T)r7 Z validate_anyr r¬ rZ r r\ rº r8 rI rI rJ r s
|
zSparseArray.anyr )r9 Ú min_countr4 rW c
|
O sª t ||¡ | j}| ¡ }| jjdko,| j }|rF|sFt| jj ddS | jrnt
|
|j d|rjt| jj ddS |S | jj} t
|
|j d|| rt| jj ddS || j | S dS )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) r7 Z validate_sumrÎ Úsumr| r} rÑ r3 rY r] rA r¸ r\ )
|
r¯ r9 r; r4 r: r5 Ú
|
valid_valsÚsp_sumZhas_naÚnsparserI rI rJ r> s zSparseArray.sum)r9 rW c O s\ t ||¡ |dk r.|| jkr.td| d| jsDt| ¡ ¡ S t| j ¡ | j | j
|
dS )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
|
Nzaxis(=z) out of boundsr ) r7 Zvalidate_cumsumÚndimr^ rÑ rR r Úcumsumr r| r\ )r¯ r9 r: r5 rI rI rJ rC À s ýzSparseArray.cumsumr c O sR t ||¡ | j}| ¡ }t|}| jr0|| S | jj}|| j| || S dS )zb
|
Mean of non-NA/null values
|
|
Returns
|
-------
|
mean : float
|
N) r7 Z validate_meanrÎ r> r¬ rÑ r| r} r\ )r¯ r9 r: r5 r? r@ ÚctrA rI rI rJ Úmeanà s zSparseArray.mean)r9 r4 zAxisInt | Nonec C s t || j¡ | jd|dS )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 r3 ©r7 Zvalidate_minmax_axisrB Ú_min_max©r¯ r9 r4 rI rI rJ r ó s zSparseArray.maxc C s t || j¡ | jd|dS )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ß r3 rF rH rI rI rJ rß s zSparseArray.minzLiteral[('min', 'max')])r r4 rW c C s | j }| j o| jjdk}t|dkr|t|| }|rR|dkrBtnt}||| jS |rZ|S | jjdkrj|S t | j
|
j ddS n|r| jS t | j
|
j ddS dS )zº
|
Min/max of non-NA/null values
|
|
Parameters
|
----------
|
kind : {"min", "max"}
|
skipna : bool
|
|
Returns
|
-------
|
scalar
|
r r Fr< N) rÎ rÑ r| r} r¬ r
r rß r\ r3 rY r] )r¯ r r4 r? Zhas_nonnull_fill_valsZ
|
sp_min_maxÚfuncrI rI rJ rG s zSparseArray._min_maxz Literal[('argmin', 'argmax')])r rW c C sÆ | j }| jj}t t|¡}|dkr*tjntj}t |j d ¡}|| }|| }||| } || }
|
t| j
|
rv|
|
S |dkr| |
|
| j
|
k r|
|
S |dkrª| |
|
| j
|
krª|
|
S | ¡ } | dkr¾|
|
S | S d S )Nrè r Úargminræ ) r r r¹ rZ r[ r2 rè rJ r r¸ r\ ré ) r¯ r rÈ r rÍ rI r» Znon_nansZ non_nan_idxZ
|
_candidateÚ candidateZ_locrI rI rJ Ú_argmin_argmax: s&
|
|
|
zSparseArray._argmin_argmax)r4 rW c C s" t |d |s| jrt| d¡S )Nr4 rè ©r Z_hasnaÚNotImplementedErrorrL ©r¯ r4 rI rI rJ rè T s
|
|
zSparseArray.argmaxc C s" t |d |s| jrt| d¡S )Nr4 rJ rM rO rI rI rJ rJ Z s
|
|
zSparseArray.argminznp.ufunc)ÚufuncrØ c s¬ | dd¡}|| D ] }t| jtf st S qtj ||f||}|tk rV|S d|krxtj ||f||}|S |dkr¢tj ||f||}|tk r¢|S t
|
|dkr*t || j f|} t || j f|}
|
|jdkrt fddt| |
|
D } | S |dkr| S | jt| j|
|
¡S tdd |D } t ||| |}|rlt
|
|dkrh|d }|S |jdkrt fd d|D S |d
|
krd S t |S d S ) Nr¿ rI Úreducern c 3 s* | ]"\}} | jt|j|¡V qd S r³ )r¶ r| r9 rY )r% Zsp_valueZfvrË rI rJ Ú <genexpr> s ý
|
ÿz.SparseArray.__array_ufunc__.<locals>.<genexpr>c s s | ]}t |¡V qd S r³ )rZ r[ r$ rI rI rJ rR s r c 3 s | ]}t |V qd S r³ )r r$ rË rI rJ rR ¡ s Úat)r# r Ú_HANDLED_TYPESrR ÚNotImplementedr6 Z!maybe_dispatch_ufunc_to_dunder_opr5 Zdispatch_ufunc_with_outZdispatch_reduction_ufuncr¬ r
r r\ Znoutrû Úzipr¶ r| r9 rY r ) r¯ rP rØ Úinputsr5 r¿ r& r Úresr r\ ZarraysZ
|
new_inputsrI rË rJ Ú__array_ufunc__f s
|
ÿÿÿ ÿÿÿ ÿÿÿ ü
|
|
ÿ
|
zSparseArray.__array_ufunc__c
|
C s6 |j }t|tr t| |||S t|r¦tjdd& |t| t |¡}|| j |}W 5 Q R X |dkr|\}}|\}} t
|
||| j |t
|
||| j | fS t
|
||| j |S t |¡}tjddp t | t |krêt dt | dt | t|tst|dd }
|
t|| j|
|
d}t| |||W 5 Q R £ S Q R X d S )Nrj rk ry zlength mismatch: z vs. rY rÖ )rE r rR r r- rZ r~ r_ r[ r r r| r¬ r® r
r\ ) r¯ Úotherrc Úop_namer r ra rb ZlfillZrfillrY rI rI rJ Ú _arith_method¬ s0
|
þ
|
ÿ zSparseArray._arith_methodc C sð t |s t|t| s t |¡}t|tjr:t|| jd}t|trt| t|krpt dt| dt| |j
|
d¡}t | |||S tj dd< || j|}tjt| |tjd}|| j||| jj< W 5 Q R X t| ||tjdS d S ) NrÚ z operands have mismatched length z and rs rj rk rX rÖ )r- r r rZ r[ r¦ rR r\ r¬ r^ rE Ústripr r~ r¾ r× r r| r¹ )r¯ rZ rc r[ r\ r rI rI rJ Ú _cmp_methodÍ s(
|
|
ÿ ýzSparseArray._cmp_methodc C sn |t | j¡ ¡ }t| jj|}t| js6|| jkrV|| j}t |
|
|| j | j¡S t | || ¡ |dS rÆ ) rZ r£ r\ rº r9 rY r] r2 r r r¶ r| r )r¯ rc r\ rY rÈ rI rI rJ Ú _unary_methodí s
|
zSparseArray._unary_methodc C s | tj¡S r³ )r_ ÚoperatorÚposrË rI rI rJ Ú__pos__ø s zSparseArray.__pos__c C s | tj¡S r³ )r_ r` ÚnegrË rI rI rJ Ú__neg__û s zSparseArray.__neg__c C s | tj¡S r³ )r_ r` ÚinvertrË rI rI rJ Ú
|
__invert__þ s zSparseArray.__invert__c C s | tj¡S r³ )r_ r` rà rË rI rI rJ Ú__abs__ s zSparseArray.__abs__c C s6 t | ¡}t | j¡}t | j¡}| d| d| S )Nz
|
Fill: Ú
|
)rB Z pprint_thingr\ r| )r¯ Zpp_strZpp_fillZpp_indexrI rI rJ Ú__repr__ s
|
zSparseArray.__repr__)Úboxedc C s d S r³ rI )r¯ rj rI rI rJ Ú
|
_formatter s zSparseArray._formatter)NNrN NF)N)NNN)rn N)T)T)N)ra N)NT)N)r )r r T)r )r )T)T)F)RrE rF rG Ú__doc__Z_subtypr: Z _hidden_attrsÚ frozensetÚ__annotations__r± Ú classmethodr¶ r¼ rÀ rÄ rÇ rÊ Úpropertyr| r rY r\ Úsetterr rÎ rÐ rÑ rÒ rÓ rÕ r r2 rÜ rå ré rë rî rð r÷ r rù rü r r r r ri rá r{ r, r r- r. r2 r6 rl r r> rC rE r rß rG rL rè rJ rZ r¦ ÚnumbersÚNumberrT rY r\ r^ Z_logical_methodr_ rb rd rf rg ri rk rI rI rI rJ rR $ sÚ
|
F ù +
|
|
üB þ+^ ÿA ü 9O4
|
|
|
ü, #
|
F! rO r znp.dtype | None)rV r rY c C sð t | tjst| jdkr"td|dkr4t| j}t|rFt | }n4t
|
| jrZ| t ¡} t | jrrt | |¡}n| |k}t| }|t|kr|jj}n| ¡ d tj¡}t|||}| | }|dk ræt|}t||d}t |¡}|||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)
|
rn z expected dimension <= 1 dataNr rX )r rZ r¦ r® rB r¡ r3 rY r2 r4 r. r{ r¤ r, r Zmake_mask_object_ndarrayr¬ r| r¹ r2 r r r; r! r[ ) rV r r\ rY rÍ r¢ r¹ r Zsparsified_valuesrI rI rJ r« s.
|
|
|
|
|
|
|
|
r« rÏ zLiteral['block']r )r¢ r rW c C s d S r³ rI ©r¢ r¹ r rI rI rJ r Q s r zLiteral['integer']r c C s d S r³ rI rt rI rI rJ r V s r c C sD |dkr$t |¡\}}t| ||}n |dkr8t| |}ntd|S )NrO rN z must be block or integer type)r Z
|
get_blocksr r r^ )r¢ r¹ r ZlocsZlensr rI rI rJ r [ s )N)rO NN)rl Ú
|
__future__r Ú collectionsr rr r` Útypingr r r r r r r
|
r r§ ÚnumpyrZ Z pandas._libsr Zpandas._libs.sparseZ_libsÚsparser r r r Zpandas._libs.tslibsr Zpandas._typingr r r r r r r r r r r Zpandas.compat.numpyr r7 Z pandas.errorsr Zpandas.util._exceptionsr Zpandas.util._validatorsr r Zpandas.core.dtypes.astyper! Zpandas.core.dtypes.castr" r# r$ Zpandas.core.dtypes.commonr% r& r' r( r) r* r+ r, r- r. r/ Zpandas.core.dtypes.genericr0 r1 Zpandas.core.dtypes.missingr2 r3 r4 Z pandas.corer5 r6 Zpandas.core.algorithmsÚcoreZ
|
algorithmsrê Zpandas.core.arrayliker7 Zpandas.core.arraysr8 Z pandas.core.arrays.sparse.dtyper9 Zpandas.core.baser: Zpandas.core.commonÚcommonr Zpandas.core.constructionr; r< r= Zpandas.core.indexersr> r? Zpandas.core.missingr@ Zpandas.core.nanopsrA Zpandas.io.formatsrB ÚenumrC rD rH Z scipy.sparserK rL rM r rô rP r rQ Z_sparray_doc_kwargsr_ r r rR r« r rI rI rI rJ Ú<module> s (
|
4 4 m ÿ | ü>
|
