U
|
¬ý°d½ ã @ s d dl mZ d dlmZmZmZmZmZmZm Z d dl
|
Z
|
d dl Z d dl mZmZ d dlmZmZ d dlmZmZmZmZmZmZmZm Z m Z m Z m Z d dl m!Z! d dl"m#Z# d d l$m%Z% d d
|
l&m'Z' d d l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 d d l4m5Z5 d d l6m7Z7 d dl8m9Z9m:Z:m;Z;m<Z< d dl=m>Z?m@Z@mZmAZAmBZB d dlCmDZDmEZEmFZF d dlGmHZHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQ d dlRmSZS d dlTmUZU erÞd dlVmWZW d dlNmXZX d dlmYZYmZZZ d dl[m\Z] ed d d Z^G d d d eMeOZ_dS ) é )Ú annotations)Ú TYPE_CHECKINGÚAnyÚIteratorÚLiteralÚSequenceÚTypeVarÚoverloadN)ÚlibÚmissing)Úget_unit_from_dtypeÚis_supported_unit) Ú ArrayLikeÚ AstypeArgÚAxisIntÚDtypeObjÚNpDtypeÚPositionalIndexerÚScalarÚ ScalarIndexerÚSequenceIndexerÚShapeÚnpt©ÚAbstractMethodError)Údoc)Úvalidate_fillna_kwargs)ÚExtensionDtype) Úis_boolÚ is_bool_dtypeÚis_datetime64_dtypeÚis_dtype_equalÚis_float_dtypeÚis_integer_dtypeÚ is_list_likeÚis_object_dtypeÚ is_scalarÚis_string_dtypeÚ pandas_dtype)ÚBaseMaskedDtype)Ú is_array_like)Úarray_equivalentÚis_valid_na_for_dtypeÚisnaÚnotna)Ú
|
algorithmsÚ arrayliker ÚnanopsÚops)Úfactorize_arrayÚisinÚtake)Úmasked_accumulationsÚmasked_reductions)Úquantile_with_mask)ÚOpsMixin)ÚExtensionArray)Ú ensure_wrapped_if_datetimelike)Úcheck_array_indexer)Úinvalid_comparison)ÚSeries©Ú BooleanArray)Ú NumpySorterÚNumpyValueArrayLike)ÚfunctionÚBaseMaskedArrayTÚBaseMaskedArray)Úboundc @ s2 e Zd ZU dZded< ded< ded< eZeZdÐddd d
|
d d d Ze ddddd ddddZ
|
e ddddZ e dddd d Ze dd dd d d Zdd!d"d d#d ZeejdÑddd$d%d&Ze dd'd(d d)d*d+d,Zd-d. Zd
|
dd/d0Zd1dd2d3Zd4dd5d6Ze d7dd8d9Ze d4dd:d;Zddd$d<d=ZdÒdd?dd@dAdBZddd$dCdDZddd$dEdFZ e ddd$dGdHZ dÓd4dIdJdKZ ddd$dLdMZ ddd$dNdOZ ddd$dPdQZ!ddd$dRdSZ"dde#j$fdTd dUddVdWdXZ%eej&dYdZ Z&e dÔd\d dd*d]d^Z'e dÕd_d d`d*dad^Z'e dÖdbd dcd*ddd^Z'd×dbd dcd*dfd^Z'dgZ(dØdhddidjdkZ)dledm< dndodpdqdrZ*dÙdsdtZ+e d ddudvZ,dwddxdydzZ-d{d| Z.e.Z/d}dd~dZ0dd Z1ddddZ2e dd
Z3e d4dddZ4e dÚddd?ddddZ5ddd>ddd dd?ddddZ6d}dddZ7ddd$ddZ8ddd$ddZ9eej:dÛdddddddZ:eej;dÜd dd d¡d¢Z;eej<ddd£d¤Z<dÝd d¥d¦d§d¨Z=eej>d dd©dªZ>d«dod d¬dd®Z?ded¯dod d°d±d²Z@dod³d´dµZAded>d>d¶d d4d·d¶d¸d¹ZBded>d>d¶d d4d·d¶dºd»ZCded>d¼d d·d¼d½d¾ZDded>d¿dÀd d·d4dÀdÁdÂZEded>d¿dÀd d·d4dÀdÃdÄZFded>d¼d d·d¼dÅdÆZGded>d¼d d·d¼dÇdÈZHded¯d d¯dÉdÊZIded¯d d¯dËdÌZJded¯dod d dÍdÎdÏZKdS )ÞrE zf
|
Base class for masked arrays (which use _data and _mask to store the data).
|
|
numpy based
|
r Ú_internal_fill_valuez
|
np.ndarrayÚ_dataznpt.NDArray[np.bool_]Ú_maskFÚboolÚNone)ÚvaluesÚmaskÚcopyÚreturnc C sX t |tjr|jtjks td|j|jkr4td|rH| ¡ }| ¡ }|| _ || _
|
d S )NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape) Ú
|
isinstanceÚnpÚndarrayÚdtypeÚbool_Ú TypeErrorÚshapeÚ
|
ValueErrorrN rH rI )ÚselfrL rM rN © rY úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/arrays/masked.pyÚ__init__u s ÿ zBaseMaskedArray.__init__N©rS rN ztype[BaseMaskedArrayT]rD )ÚclsrN rO c C s | j |||d\}}| ||S )Nr\ )Ú_coerce_to_array)r] ZscalarsrS rN rL rM rY rY rZ Ú_from_sequence s z BaseMaskedArray._from_sequencer) )rO c C s t | d S ©Nr ©rX rY rY rZ rS s zBaseMaskedArray.dtyper r )ÚitemrO c C s d S r` rY ©rX rb rY rY rZ Ú __getitem__ s zBaseMaskedArray.__getitem__r )rX rb rO c C s d S r` rY rc rY rY rZ rd s r zBaseMaskedArrayT | Anyc C sF t | |}| j| }t|r2|r(| jjS | j| S t| | j| |S r` )r< rI r rS Úna_valuerH Útype)rX rb ZnewmaskrY rY rZ rd s
|
|
|
)rX rO c C sÄ t ||\}}| j}t|rPt|t| krHtdt| dt| || }| ¡ r¸|d k r¦tj|| jd}| j
|
¡ j }|
|
¡ j }||||d t | |j |j S |
|
¡ }|||< n|
|
¡ }|S )Nz'Length of 'value' does not match. Got (z ) expected )Úndim)ÚlimitrM ) r rI r* ÚlenrW Úanyr Z get_fill_funcrg rH rN ÚTrf ) rX ÚvalueÚmethodrh rM ÚfuncZnpvaluesZnew_maskZ
|
new_valuesrY rY rZ Úfillna© s& ÿ
|
|
zBaseMaskedArray.fillna©rN r z tuple[np.ndarray, np.ndarray])rS rN rO c C s t | d S r` r )r] rL rS rN rY rY rZ r^ È s z BaseMaskedArray._coerce_to_arrayc C s | j j}|dkr t |¡rb|S nB|dkrBt |¡s<t |¡rb|S n t |¡s^t |¡rb| ¡ rb|S tdt| d| j dS )zy
|
Check if we have a scalar that we can cast losslessly.
|
|
Raises
|
------
|
TypeError
|
ÚbÚfzInvalid value 'z ' for dtype N)rS Úkindr
|
r Ú
|
is_integerZis_floatrU Ústr)rX rl rs rY rY rZ Ú_validate_setitem_valueÎ s
|
z'BaseMaskedArray._validate_setitem_valuec C sx t | |}t|rLt|| jr*d| j|< n | |¡}|| j|< d| j|< d S | j|| jd\}}|| j|< || j|< d S )NTF©rS )r< r& r, rS rI rv rH r^ )rX Úkeyrl rM rY rY rZ Ú __setitem__é s
|
|
|
|
|
zBaseMaskedArray.__setitem__r c c sx | j dkrX| js$| jD ]
|
}|V qqt| jj}t| j| jD ]\}}|rN|V q:|V q:n tt| D ]}| | V qdd S )Né ) rg Ú_hasnarH rS re ÚziprI Úrangeri )rX Úvalre Zisna_ÚirY rY rZ Ú__iter__ú s
|
|
|
|
zBaseMaskedArray.__iter__Úintc C s
|
t | jS r` )ri rH ra rY rY rZ Ú__len__
|
s zBaseMaskedArray.__len__r c C s | j jS r` )rH rV ra rY rY rZ rV s zBaseMaskedArray.shapec C s | j jS r` )rH rg ra rY rY rZ rg s zBaseMaskedArray.ndimc C s* | j ||¡}| j ||¡}t| ||S r` )rH ÚswapaxesrI rf )rX Zaxis1Zaxis2ÚdatarM rY rY rZ r s zBaseMaskedArray.swapaxesr r )rX ÚaxisrO c C s2 t j| j||d}t j| j||d}t| ||S )N©r
)rQ ÚdeleterH rI rf )rX Úlocr
r rM rY rY rZ r s zBaseMaskedArray.deletec O s* | j j||}| jj||}t| ||S r` )rH ÚreshaperI rf ©rX ÚargsÚkwargsr rM rY rY rZ r s zBaseMaskedArray.reshapec O s* | j j||}| jj||}t| ||S r` )rH ÚravelrI rf r rY rY rZ r $ s zBaseMaskedArray.ravelc C s t | | jj| jjS r` )rf rH rk rI ra rY rY rZ rk * s zBaseMaskedArray.T)Údecimalsc O s6 t ||¡ tj| jfd|i|}| || j ¡ ¡S )aó
|
Round each value in the array a to the given number of decimals.
|
|
Parameters
|
----------
|
decimals : int, default 0
|
Number of decimal places to round to. If decimals is negative,
|
it specifies the number of positions to the left of the decimal point.
|
*args, **kwargs
|
Additional arguments and keywords have no effect but might be
|
accepted for compatibility with NumPy.
|
|
Returns
|
-------
|
NumericArray
|
Rounded values of the NumericArray.
|
|
See Also
|
--------
|
numpy.around : Round values of an np.array.
|
DataFrame.round : Round values of a DataFrame.
|
Series.round : Round values of a Series.
|
r )ÚnvZvalidate_roundrQ ÚroundrH Ú_maybe_mask_resultrI rN )rX r r r rL rY rY rZ r . s zBaseMaskedArray.roundc C s t | | j | j ¡ S r` ©rf rH rI rN ra rY rY rZ Ú
|
__invert__O s zBaseMaskedArray.__invert__c C s t | | j | j ¡ S r` r ra rY rY rZ Ú__neg__R s zBaseMaskedArray.__neg__c C s | ¡ S r` rp ra rY rY rZ Ú__pos__U s zBaseMaskedArray.__pos__c C s t | t| j| j ¡ S r` )rf ÚabsrH rI rN ra rY rY rZ Ú__abs__X s zBaseMaskedArray.__abs__znpt.DTypeLike | NoneÚobject)rS rN re rO c C s¼ |t jkrtj}|dkr t}| jrt|sLt|sL|tjkrLtd| dt
|
¡ t j dt d | j |¡}W 5 Q R X ||| j< n2t
|
¡ $ t j dt d | j j||d}W 5 Q R X |S )aF
|
Convert to a NumPy Array.
|
|
By default converts to an object-dtype NumPy array. Specify the `dtype` and
|
`na_value` keywords to customize the conversion.
|
|
Parameters
|
----------
|
dtype : dtype, default object
|
The numpy dtype to convert to.
|
copy : bool, default False
|
Whether to ensure that the returned value is a not a view on
|
the array. Note that ``copy=False`` does not *ensure* that
|
``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
|
a copy is made, even if not strictly necessary. This is typically
|
only possible when no missing values are present and `dtype`
|
is the equivalent numpy dtype.
|
na_value : scalar, optional
|
Scalar missing value indicator to use in numpy array. Defaults
|
to the native missing value indicator of this array (pd.NA).
|
|
Returns
|
-------
|
numpy.ndarray
|
|
Examples
|
--------
|
An object-dtype is the default result
|
|
>>> a = pd.array([True, False, pd.NA], dtype="boolean")
|
>>> a.to_numpy()
|
array([True, False, <NA>], dtype=object)
|
|
When no missing values are present, an equivalent dtype can be used.
|
|
>>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
|
array([ True, False])
|
>>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
|
array([1, 2])
|
|
However, requesting such dtype will raise a ValueError if
|
missing values are present and the default missing value :attr:`NA`
|
is used.
|
|
>>> a = pd.array([True, False, pd.NA], dtype="boolean")
|
>>> a
|
<BooleanArray>
|
[True, False, <NA>]
|
Length: 3, dtype: boolean
|
|
>>> a.to_numpy(dtype="bool")
|
Traceback (most recent call last):
|
...
|
ValueError: cannot convert to bool numpy array in presence of missing values
|
|
Specify a valid `na_value` instead
|
|
>>> a.to_numpy(dtype="bool", na_value=False)
|
array([ True, False, False])
|
Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.Úignore©Úcategoryrp )r
|
Ú
|
no_defaultÚ
|
libmissingÚNAr r{ r% r' rW ÚwarningsÚcatch_warningsÚfilterwarningsÚRuntimeWarningrH ÚastyperI )rX rS rN re r rY rY rZ Úto_numpy] s, B
|
ÿþý
|
ÿ
|
|
zBaseMaskedArray.to_numpyc C s: | j dkrdd | D S | jr"d n| jj}| j|d ¡ S )Nrz c S s g | ] }| ¡ qS rY )Útolist©Ú.0ÚxrY rY rZ Ú
|
<listcomp>¼ s z*BaseMaskedArray.tolist.<locals>.<listcomp>rw )rg r{ rH rS r¤ r¥ ©rX rS rY rY rZ r¥ ¹ s
|
zBaseMaskedArray.tolist.z npt.DTypeLikec C s d S r` rY ©rX rS rN rY rY rZ r£ À s zBaseMaskedArray.astyper r: c C s d S r` rY r« rY rY rZ r£ Ä s r r c C s d S r` rY r« rY rY rZ r£ È s Tc C s" t |}t|| jr$|r | ¡ S | S t|trt ¡ & tjdt d | j
|
j |j |d}W 5 Q R X || j
|
krr| j n| j ¡ }| ¡ }|||ddS t|tr´| ¡ }|j| ||dS t|rÄtj}nt|rØt d¡}ntj}t|rô| jrôtdt|r| jrtd| j |||d }|S )
|
Nr r rp Fr\ ÚNaTz cannot convert NA to integerz cannot convert float NaN to bool)rS re rN ) r( r! rS rN rP r) r r r¡ r¢ rH r£ Ú numpy_dtyperI Zconstruct_array_typer r_ r" rQ Únanr Z
|
datetime64r
|
r r# r{ rW r r¤ )rX rS rN r rM r] Zeaclsre rY rY rZ r£ Ì s4
|
|
|
iè zNpDtype | None)rS rO c C s | j |dS )z|
|
the array interface, return my values
|
We return an object array here to preserve our scalar values
|
rw )r¤ rª rY rY rZ Ú __array__ü s zBaseMaskedArray.__array__ztuple[type, ...]Ú_HANDLED_TYPESznp.ufuncru )Úufuncrm c sT | dd¡}|| D ] }t|| jtf st S qtj| ||f||}|tk rV|S d|krttj| ||f||S |dkrtj | ||f||}|tk r|S t
|
j t | t d g }|D ]0}t|trÞ |jO | |j¡ q¸| |¡ q¸ fddt||||}|jdkr(tfdd |D S |dkrH| j ¡ rD| jS |S |S d S )
|
NÚoutrY Úreducerw c s ddl m}m}m} t| jr0 ¡ }|| |S t| jrL ¡ }|| |S t| jr ¡ }| jt j
|
krv| t j ¡} || |S t j | < | S )Nr )r@ Ú FloatingArrayÚ IntegerArray)Úpandas.core.arraysr@ r´ rµ r rS rN r# r" rQ Úfloat16r£ Úfloat32r® )r¨ r@ r´ rµ Úm©rM rY rZ Ú reconstruct, s
|
|
|
|
|
|
|
z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructrz c 3 s | ]} |V qd S r` rY r¦ )r» rY rZ Ú <genexpr>I s z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)ÚgetrP r° rE ÚNotImplementedr2 Z!maybe_dispatch_ufunc_to_dunder_opr0 Zdispatch_ufunc_with_outZdispatch_reduction_ufuncrQ Úzerosri rJ rI ÚappendrH ÚgetattrZnoutÚtuplerj Ú _na_value) rX r± rm Úinputsr r² r¨ ÚresultZinputs2rY )rM r» rZ Ú__array_ufunc__ sj
|
ÿÿÿ ÿÿÿ ÿÿÿ
|
|
|
z BaseMaskedArray.__array_ufunc__c C s ddl }|j| j| j|dS )z6
|
Convert myself into a pyarrow Array.
|
r N)rM rf )ZpyarrowÚarrayrH rI )rX rf ÚparY rY rZ Ú__arrow_array__R s z BaseMaskedArray.__arrow_array__c C s
|
| j ¡ S r` )rI rj ra rY rY rZ r{ Z s zBaseMaskedArray._hasnaz npt.NDArray[np.bool_] | None)rM rO c C sZ |d krL| j ¡ }|tjkr&|dB }qVt|rVt|t|krV|t|B }n
|
| j |B }|S )NT)rI rN r r r$ ri r- )rX rM ÚotherrY rY rZ Ú_propagate_maskc s
|
|
|
|
z BaseMaskedArray._propagate_maskc C sÔ |j }d }t|dst|rt|t| krtj|dd}|dkrZddlm} | |¡}n>|dkrzddlm } | |¡}n |d krdd
|
lm
|
} | |¡}t |t r²|j |j }}n.t|ràt |tsÎt |¡}|jd kràtd t |t| f¡}t |¡} t|}|d kr$t |tjr$t|}| ||¡}
|
|tj kr¶t | j ¡} | j j dkr|dkrptd| d|dkrd} nd} | | ¡} n$d|krö| j j dkrö| tj!¡} n@| j j dkrÒ|dkrÒ|} tj"dd | | j |} W 5 Q R X |dkr`t #| j d k| j @ d |
|
¡}
|
|d k r@t #|dk| @ d |
|
¡}
|
n |tj k rÈt #|dkd |
|
¡}
|
nh|d krÈ|d k rt #|d k| @ d |
|
¡}
|
n |tj k r¬t #|d kd |
|
¡}
|
t #| j dk| j @ d |
|
¡}
|
| $| |
|
¡S ) NrS T©ÚskipnaÚintegerr ©rµ )Zfloatingzmixed-integer-float©r´ )Úbooleanr? rz ú(can only perform ops with 1-d structures> ÚpowÚrpowrq > rÔ ÚtruedivÚfloordivÚ rfloordivrÓ Úrtruedivz
|
operator 'z!' not implemented for bool dtypes> ÚrmodÚmodZint8rJ rÕ rr )r Úu)rÖ rÚ r ©ÚallrÓ FrÔ )%Ú__name__Úhasattrr$ ri r
|
Z infer_dtyper¶ rµ r_ r´ r@ rP rE rH rI r: rQ Úasarrayrg ÚNotImplementedErrorr2 Zmaybe_prepare_scalar_for_opZ get_array_opr; rT rJ rË r r Z ones_likerS rs r£ Úfloat64ÚerrstateÚwherer ) rX rÊ ÚopZop_nameZomaskZinferred_dtyperµ r´ r@ Zpd_oprM rÅ rS rY rY rZ Ú _arith_methods sz ÿþý
|
|
|
|
|
|
|
|
|
ÿ
|
|
|
|
|
z BaseMaskedArray._arith_methodr@ c
|
C s. ddl m} d }t|tr*|j|j }}n<t|rft |¡}|j dkrNt
|
dt | t |krft d|t jkrtj| jjdd}tj| jjdd}n~t ¡ p t dd t¡ t dd t¡ tjdd
|
$ t| jd |j d }||}W 5 Q R X |tkr
|
t| j||}W 5 Q R X | ||¡}|||d d S )Nr r? rz rÒ z Lengths must match to comparerJ rw r Z elementwiserÜ Ú__Frp ) r¶ r@ rP rE rH rI r$ rQ rà rg rá ri rW r r r¿ rV Úonesr r r¡ Ú FutureWarningÚDeprecationWarningrã rÁ rÞ r¾ r= rË )rX rÊ rå r@ rM rÅ rm rY rY rZ Ú _cmp_methodÞ s.
|
|
|
|
|
|
zBaseMaskedArray._cmp_methodc C s t |tr*|\}}| ||¡| ||¡fS t|jrNddlm} |||ddS t|jrrddlm} |||ddS t |jt jrÔ|jj
|
dkrÔt t |jrÔddlm } t ||sÀ|j||jd}|j d ¡||< |S t|j rúdd
|
lm} |||ddS t j||< |S d S ) z
|
Parameters
|
----------
|
result : array-like or tuple[array-like]
|
mask : array-like bool
|
r rÐ Frp r? r¹ )ÚTimedeltaArrayrw r¬ rÏ N)rP r r r" rS r¶ r´ r r@ rQ rs r r rì Z _simple_newrf r# rµ r® ) rX rÅ rM ÚdivrÚ r´ r@ rì rµ rY rY rZ r s6
|
|
|
þ
|
|
ÿ
|
þ ý
|
|
z"BaseMaskedArray._maybe_mask_resultc C s
|
| j ¡ S r` )rI rN ra rY rY rZ r- 7 s zBaseMaskedArray.isnac C s | j jS r` ©rS re ra rY rY rZ rà : s zBaseMaskedArray._na_valuec C s | j j| jj S r` )rH ÚnbytesrI ra rY rY rZ rï > s zBaseMaskedArray.nbyteszSequence[BaseMaskedArrayT])r] Ú to_concatr
rO c C s: t jdd |D |d}t jdd |D |d}| ||S )Nc S s g | ]
|
}|j qS rY ©rH r¦ rY rY rZ r© H s z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r c S s g | ]
|
}|j qS rY )rI r¦ rY rY rZ r© I s )rQ Z concatenate)r] rð r
r rM rY rY rZ Ú_concat_same_typeB s z!BaseMaskedArray._concat_same_type)Ú
|
allow_fillÚ
|
fill_valuer
z Scalar | None)rX ró rô r
rO c C sv t |r| jn|}t| j||||d}t| j|d||d}|rdt|rdt |¡dk}|||< ||A }t| ||ddS )N)rô ró r
TéÿÿÿÿFrp ) r- rG r5 rH rI r. rQ rà rf ) rX Zindexerró rô r
Zdata_fill_valuerÅ rM Z fill_maskrY rY rZ r5 L s(
|
û ÿ zBaseMaskedArray.takec sr ddl m} t |¡}t j|} jrRt|joFt fdd|D }|| j
|
< tj jj t d}|||ddS )Nr r? c 3 s | ]}| j jkV qd S r` rî )r§ r~ ra rY rZ r¼ y s z'BaseMaskedArray.isin.<locals>.<genexpr>rw Frp )r¶ r@ rQ rà r4 rH r{ r% rS rj rI r¿ rV rJ )rX rL r@ Z
|
values_arrrÅ Zvalues_have_NArM rY ra rZ r4 p s
|
ÿ
|
zBaseMaskedArray.isinc C s0 | j | j }}| ¡ }| ¡ }t| ||ddS )NFrp )rH rI rN rf )rX r rM rY rY rZ rN s zBaseMaskedArray.copyc C s& t | j| j¡\}}t| ||ddS )z
|
Compute the BaseMaskedArray of unique values.
|
|
Returns
|
-------
|
uniques : BaseMaskedArray
|
Frp )ÚalgosZunique_with_maskrH rI rf )rX ÚuniquesrM rY rY rZ Úunique s zBaseMaskedArray.uniqueÚleftz$NumpyValueArrayLike | ExtensionArrayzLiteral[('left', 'right')]rA z npt.NDArray[np.intp] | np.intp)rl ÚsideÚsorterrO c C s4 | j rtdt|tr"| t¡}| jj|||dS )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)rú rû )r{ rW rP r: r£ r rH Ú searchsorted)rX rl rú rû rY rY rZ rü s ÿ
|
|
z BaseMaskedArray.searchsortedz!tuple[np.ndarray, ExtensionArray])Úuse_na_sentinelrO c C sô | j }| j}t|d|d\}}|j| jjks<t|j| jf| ¡ }|sL|sVt|}n t|d }tj |t
|
d}|sÞ|rÞ| ¡ } | dkrt d¡}
|
n|d |
¡ d }
|
|||
|
k d7 < |
|
||dk< t ||
|
d¡}d||
|
< t| ||} || fS )NT)rý rM rz rw r rõ )rH rI r3 rS r ÚAssertionErrorrj ri rQ r¿ rJ ZargmaxZintpÚmaxÚinsertrf ) rX rý ZarrrM Úcodesr÷ Zhas_naÚsizeZ uniques_maskZna_indexZna_codeZ
|
uniques_earY rY rZ Ú factorize¦ s(
|
zBaseMaskedArray.factorizec C s | j S r` rñ ra rY rY rZ Ú_values_for_argsortÍ s z#BaseMaskedArray._values_for_argsortr> )ÚdropnarO c C sì ddl m}m} ddlm} tj| jd| jd\}}|rf|||ddd}|j
|
| j ¡|_ |
|
d ¡}|S t j t|d
|
d d }||d d
< | j ¡ |d< ||| j d t|| j j¡} |
|
| j ¡} t jt|dd }
|
|||
|
} || | dddS )aA
|
Returns a Series containing counts of each unique value.
|
|
Parameters
|
----------
|
dropna : bool, default True
|
Don't include counts of missing values.
|
|
Returns
|
-------
|
counts : Series
|
|
See Also
|
--------
|
Series.value_counts
|
r )ÚIndexr> rÏ T)r rM ÚcountF)ÚindexÚnamerN ZInt64rz Úint64rw Nrõ rJ )Úpandasr r> Z pandas.arraysrµ rö Zvalue_counts_arraylikerH rI r r£ rS rQ Úemptyri Úsumr re r¿ ) rX r r r> rµ ÚkeysÚ value_countsÚresÚcountsr rM Z counts_arrayrY rY rZ r Ñ s( ÿ
|
|
|
z BaseMaskedArray.value_countsc C sb t | t |krdS |j| jkr$dS t | j|j¡s8dS | j| j }|j|j }t||ddS )NFT)Z dtype_equal)rf rS rQ Z array_equalrI rH r+ )rX rÊ rù ÚrightrY rY rZ Úequalsÿ s zBaseMaskedArray.equalsznpt.NDArray[np.float64])ÚqsÚ interpolationrO c C s t | j| jtj||d}| jrz| jdkr,t| ¡ ¡ rhtj
|
|j t d}t | jrxtj|j | jjd}qtj|j t d}ntj|j t d}| j||dS )z½
|
Dispatch to quantile_with_mask, needed because we do not have
|
_from_factorized.
|
|
Notes
|
-----
|
We assume that all impacted cases are 1D-only.
|
)rM rô r r é rw rº )r8 rH rI rQ r® r{ rg rá r- rÝ rè rV rJ r# rS r¿ r r )rX r r r Zout_maskrY rY rZ Ú _quantile s" ù
|
|
|
zBaseMaskedArray._quantilerÌ )r rÍ c K sh |dkr t | |f d|i|S | j}| j}t td| }||fd||d|}t |¡rdtjS |S )N> rj rÝ rÿ ÚvarÚminÚstdr ÚprodÚmeanrÍ r® r )r
rÍ rM )rÁ rH rI r1 rQ Úisnanr r )rX r rÍ r r rM rå rÅ rY rY rZ Ú_reduce; s
|
zBaseMaskedArray._reduce)r c K sF t |tjrB|d }|r(| jj|d}n| jj|d}| ||¡S |S )Nr
r )rP rQ rR rI rÝ rj r )rX r rÅ rÍ r r
rM rY rY rZ Ú_wrap_reduction_resultK s z&BaseMaskedArray._wrap_reduction_result©rÍ Ú min_countr
zAxisInt | Nonec K s` t d|¡ d|kr.|d d k r$t| d¡ tj| j| j|||d}| jd|f||d|S )NrY r² r r ©rÍ r
) r Z validate_sumrá Úpopr7 r rH rI r ©rX rÍ r! r
r rÅ rY rY rZ r W s*
|
û ÿ ÿÿzBaseMaskedArray.sumc K s> t d|¡ tj| j| j|||d}| jd|f||d|S )NrY r r r" )r Z validate_prodr7 r rH rI r r$ rY rY rZ r s s" û ÿ ÿÿzBaseMaskedArray.prodr" c K s< t d|¡ tj| j| j||d}| jd|f||d|S )NrY r" r )r Z validate_meanr7 r rH rI r )rX rÍ r
r rÅ rY rY rZ r s ü ÿ ÿÿzBaseMaskedArray.meanrz ©rÍ r
Úddofc K sB t jd|dd tj| j| j|||d}| jd|f||d|S )NrY r ©Úfnamer% r" )r Úvalidate_stat_ddof_funcr7 r rH rI r ©rX rÍ r
r& r rÅ rY rY rZ r s" û ÿ ÿÿzBaseMaskedArray.varc K sB t jd|dd tj| j| j|||d}| jd|f||d|S )NrY r r' r% r" )r r) r7 r rH rI r r* rY rY rZ r ¢ s" û ÿ ÿÿzBaseMaskedArray.stdc K s" t d|¡ tj| j| j||dS ©NrY r" )r Z validate_minr7 r rH rI ©rX rÍ r
r rY rY rZ r ± s üzBaseMaskedArray.minc K s" t d|¡ tj| j| j||dS r+ )r Z validate_maxr7 rÿ rH rI r, rY rY rZ rÿ º s üzBaseMaskedArray.maxc K sn | dd¡ t d|¡ | j ¡ }t || j| j¡ | ¡ }|rD|S |s^t
|
| dks^| j ¡ sb|S | j j S dS )a1
|
Return whether any element is truthy.
|
|
Returns False unless there is at least one element that is truthy.
|
By default, NAs are skipped. If ``skipna=False`` is specified and
|
missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
|
is used as for logical operations.
|
|
.. versionchanged:: 1.4.0
|
|
Parameters
|
----------
|
skipna : bool, default True
|
Exclude NA values. If the entire array is NA and `skipna` is
|
True, then the result will be False, as for an empty array.
|
If `skipna` is False, the result will still be True if there is
|
at least one element that is truthy, otherwise NA will be returned
|
if there are NA's present.
|
**kwargs : any, default None
|
Additional keywords have no effect but might be accepted for
|
compatibility with NumPy.
|
|
Returns
|
-------
|
bool or :attr:`pandas.NA`
|
|
See Also
|
--------
|
numpy.any : Numpy version of this method.
|
BaseMaskedArray.all : Return whether all elements are truthy.
|
|
Examples
|
--------
|
The result indicates whether any element is truthy (and by default
|
skips NAs):
|
|
>>> pd.array([True, False, True]).any()
|
True
|
>>> pd.array([True, False, pd.NA]).any()
|
True
|
>>> pd.array([False, False, pd.NA]).any()
|
False
|
>>> pd.array([], dtype="boolean").any()
|
False
|
>>> pd.array([pd.NA], dtype="boolean").any()
|
False
|
>>> pd.array([pd.NA], dtype="Float64").any()
|
False
|
|
With ``skipna=False``, the result can be NA if this is logically
|
required (whether ``pd.NA`` is True or False influences the result):
|
|
>>> pd.array([True, False, pd.NA]).any(skipna=False)
|
True
|
>>> pd.array([1, 0, pd.NA]).any(skipna=False)
|
True
|
>>> pd.array([False, False, pd.NA]).any(skipna=False)
|
<NA>
|
>>> pd.array([0, 0, pd.NA]).any(skipna=False)
|
<NA>
|
r
NrY r ) r# r Z validate_anyrH rN rQ ÚputmaskrI Ú _falsey_valuerj ri rS re ©rX rÍ r rL rÅ rY rY rZ rj à s >
|
zBaseMaskedArray.anyc K sn | dd¡ t d|¡ | j ¡ }t || j| j¡ | ¡ }|rD|S |r^t
|
| dks^| j ¡ sb|S | j j S dS )a$
|
Return whether all elements are truthy.
|
|
Returns True unless there is at least one element that is falsey.
|
By default, NAs are skipped. If ``skipna=False`` is specified and
|
missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
|
is used as for logical operations.
|
|
.. versionchanged:: 1.4.0
|
|
Parameters
|
----------
|
skipna : bool, default True
|
Exclude NA values. If the entire array is NA and `skipna` is
|
True, then the result will be True, as for an empty array.
|
If `skipna` is False, the result will still be False if there is
|
at least one element that is falsey, otherwise NA will be returned
|
if there are NA's present.
|
**kwargs : any, default None
|
Additional keywords have no effect but might be accepted for
|
compatibility with NumPy.
|
|
Returns
|
-------
|
bool or :attr:`pandas.NA`
|
|
See Also
|
--------
|
numpy.all : Numpy version of this method.
|
BooleanArray.any : Return whether any element is truthy.
|
|
Examples
|
--------
|
The result indicates whether all elements are truthy (and by default
|
skips NAs):
|
|
>>> pd.array([True, True, pd.NA]).all()
|
True
|
>>> pd.array([1, 1, pd.NA]).all()
|
True
|
>>> pd.array([True, False, pd.NA]).all()
|
False
|
>>> pd.array([], dtype="boolean").all()
|
True
|
>>> pd.array([pd.NA], dtype="boolean").all()
|
True
|
>>> pd.array([pd.NA], dtype="Float64").all()
|
True
|
|
With ``skipna=False``, the result can be NA if this is logically
|
required (whether ``pd.NA`` is True or False influences the result):
|
|
>>> pd.array([True, True, pd.NA]).all(skipna=False)
|
<NA>
|
>>> pd.array([1, 1, pd.NA]).all(skipna=False)
|
<NA>
|
>>> pd.array([True, False, pd.NA]).all(skipna=False)
|
False
|
>>> pd.array([1, 0, pd.NA]).all(skipna=False)
|
False
|
r
NrY r )r# r Z validate_allrH rN rQ r- rI Ú _truthy_valuerÝ ri rj rS re r/ rY rY rZ rÝ s >
|
zBaseMaskedArray.all)r rÍ rO c K sB | j }| j}tt|}|||fd|i|\}}t| ||ddS )NrÍ Frp )rH rI rÁ r6 rf )rX r rÍ r r rM rå rY rY rZ Ú _accumulatef s
|
|
zBaseMaskedArray._accumulate)F)NNN)r )r ).).).)T)N)N)r )rù N)T)T)LrÞ Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__r r0 r. r[ Ú classmethodr_ ÚpropertyrS r rd r r: ro r^ rv ry r r rV rg r r r r rk r r r r r r
|
r r¤ r¥ r£ Z__array_priority__r¯ rÆ rÉ r{ rË ræ Z_logical_methodrë r r- rà rï rò r5 r4 rN rø rü r r r r r r r r r r r r r rÿ rj rÝ r1 rY rY rY rZ rE d sø
|
ÿ ÿ ÿ ÿ!ü\
|
.M
|
i)0
|
ý ú$ ü þ&.,û û ÿ ÿ QSÿ)`Ú
|
__future__r Útypingr r r r r r r r ÚnumpyrQ Z pandas._libsr
|
r r Zpandas._libs.tslibsr r Zpandas._typingr r r r r r r r r r r Z pandas.errorsr Zpandas.util._decoratorsr Zpandas.util._validatorsr Zpandas.core.dtypes.baser Zpandas.core.dtypes.commonr r r r! r" r# r$ r% r& r' r( Zpandas.core.dtypes.dtypesr) Z pandas.core.dtypes.inferencer* Zpandas.core.dtypes.missingr+ r, r- r. Z pandas.corer/ rö r0 r1 r2 Zpandas.core.algorithmsr3 r4 r5 Zpandas.core.array_algosr6 r7 Z pandas.core.array_algos.quantiler8 Zpandas.core.arrayliker9 r¶ r: Zpandas.core.constructionr; Zpandas.core.indexersr< Zpandas.core.opsr= r r> r@ rA rB Zpandas.compat.numpyrC r rD rE rY rY rY rZ Ú<module> s< $ 4 4
|
