Ë
|
nñúhÝ ã óT d dl mZ d dlmZmZmZmZmZ d dlZd dl Z
|
d dl m Z m Z d dlmZ d dlmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z d dl m!Z!m"Z" d dl#m$Z$ d d l%m&Z& d d
|
l'm(Z( d d l)m*Z* d d l+m,Z, d d l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7m8Z8m9Z9m:Z: d dl;m<Z=m>Z>m Z m?Z?m@Z@ d dlAmBZBmCZCmDZDmEZEmFZF d dlGmHZHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQ d dlRmSZTmUZUmVZV d dlWmXZX d dlYmZZZ d dl[m\Z\ er"d dl]m^Z^m_Z_ d d l`maZa d d lbmcZc d d lmdZdmeZe d d lbmfZf d d lgmhZi G d! d"eMeQ« Zj d$d#Zky)%é )Ú annotations)Ú TYPE_CHECKINGÚAnyÚCallableÚLiteralÚoverloadN)ÚlibÚmissing)Úis_supported_dtype)Ú ArrayLikeÚ AstypeArgÚAxisIntÚDtypeObjÚ FillnaOptionsÚInterpolateOptionsÚNpDtypeÚPositionalIndexerÚScalarÚ ScalarIndexerÚSelfÚSequenceIndexerÚShapeÚnpt)ÚIS64Úis_platform_windows©ÚAbstractMethodError)Údoc)Úfind_stack_level)Úvalidate_fillna_kwargs)ÚExtensionDtype)Úis_boolÚis_integer_dtypeÚ is_list_likeÚ is_scalarÚis_string_dtypeÚ pandas_dtype)ÚBaseMaskedDtype)Úarray_equivalentÚis_valid_na_for_dtypeÚisnaÚnotna)Ú
|
algorithmsÚ arrayliker
|
ÚnanopsÚops)Úfactorize_arrayÚisinÚ map_arrayÚmodeÚtake)Úmasked_accumulationsÚmasked_reductions)Úquantile_with_mask)ÚOpsMixin)Úto_numpy_dtype_inference)ÚExtensionArray)ÚarrayÚ ensure_wrapped_if_datetimelikeÚ extract_array)Úcheck_array_indexer)Úinvalid_comparison)Ú
|
hash_array)ÚIteratorÚSequence)ÚSeries©Ú BooleanArray)Ú NumpySorterÚNumpyValueArrayLike©Ú FloatingArray)Úfunctionc ó e Zd ZU dZded< ded< ded< eZeZedgd« Z dh did
|
Z
|
ed d d djd « Z e e e j « dkd« « ZdhdldZedmd« Zednd« Zedod« ZdpdZd d dd dqdZ e e j* « dr dsd« Zed d dtd« Zd ZdudZdv fd Zdwd Zdxd Zedyd « Z edxd « Z dzd!Z d{d|d#Z dzd$Z dzd%Z!edzd&« Z"d{d}d'Z#dzd(Z$dzd)Z%dzd*Z&dzd+Z'd~d,Z(d d e)jT f dd-Z+ e e jX « d. « Z,eddd/« Z-eddd0« Z-eddd1« Z-ddd2Z-d3Z. d
dd4Z/d5ed6< dd7Z0dd8Z1edvd9« Z2 dd:Z3d; Z4e4Z5dd<Z6 dd=Z7d~d>Z8ed? « Z9edxd@« Z:e d{ ddA« Z; ddBZ<d d d"dC ddDZ=ddEZ>dzdFZ? e e j « d ddG« Z@dzdHZA e e j « d ddI« ZB e e j « d ddJ« ZC e e j « d~dK« ZDdddLZEdddMZF e e j « dvdN« ZG ddOZHdd dP ddQZIddRZJdS ZK ddTZLdd"d"dU ddVZMdd"d"dU ddWZNdd"dXddYZOdd"dZd[ dd\ZPdd"dZd[ dd]ZQdd"dXdd^ZRdd"dXdd_ZSdd`ZTdd"dXddaZUdd"dXddbZV ddcZWddd ddeZX ddfZY xZZS ) ÚBaseMaskedArrayzf
|
Base class for masked arrays (which use _data and _mask to store the data).
|
|
numpy based
|
r Ú_internal_fill_valueú
|
np.ndarrayÚ_dataúnpt.NDArray[np.bool_]Ú_maskc óL t j | « }||_ ||_ |S ©N)rM Ú__new__rP rR )ÚclsÚvaluesÚmaskÚresults úLH:\Change_password\venv_build\Lib\site-packages\pandas/core/arrays/masked.pyÚ _simple_newzBaseMaskedArray._simple_new} s% ä ×(Ñ(¨Ó-Ø Ø Ø ó Fc ó0 t |t j « r |j t j k( s t d« |j |j k7 r t d« |r |j « }|j « }|| _ || _
|
y )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Ú
|
ValueErrorÚcopyrP rR )ÚselfrW rX rf s rZ Ú__init__zBaseMaskedArray.__init__ sx ô 4¤§¡Ô,°·±¼r¿x¹xÒ1GÜð2óð ð <<4::Ò %Ü Ð AÓBÐ Bá Ø[[]FØ99;Dà
|
Ø
|
r\ N©ra rf c óB | j |||¬« \ }} | ||« S )Nri )Ú_coerce_to_array)rV Úscalarsra rf rW rX s rZ Ú_from_sequencez BaseMaskedArray._from_sequence s* à×+Ñ+¨G¸5ÀtÐ+ÓL Ù64Ó Ð r\ c ó t j ||j ¬« }|j | j « t j
|
|t ¬« } | ||« }t || « r||j k7 rt d| d« |S )N©ra z5Default 'empty' implementation is invalid for dtype='ú')
|
r_ ÚemptyÚtypeÚfillrN ÚonesÚboolr^ ra ÚNotImplementedError)rV rd ra rW rX rY s rZ Ú_emptyzBaseMaskedArray._empty s{ ô % u§z¡zÔ2Ø C×,Ñ,Ô-Üwwu¤DÔ)ÙVTÓ"Ü& #Ô&¨%°6·<±<Ò*?Ü%ØGÈÀwÈaÐPóð ð r\ c ó t S rT )Ústr)rg Úboxeds rZ Ú
|
_formatterzBaseMaskedArray._formatter© s ä
|
r\ c ó t | « rT r ©rg s rZ ra zBaseMaskedArray.dtype s ä! $Ó'Ð'r\ c ó y rT © ©rg Úitems rZ Ú __getitem__zBaseMaskedArray.__getitem__± ó à r\ c ó y rT r r s rZ r zBaseMaskedArray.__getitem__µ r r\ c óÚ t | |« }| j | }t |« r'|r| j j S | j
|
| S | j | j
|
| |« S rT )r? rR r" ra Úna_valuerP r[ )rg r Únewmasks rZ r zBaseMaskedArray.__getitem__¹ sb Ü" 4¨Ó.à**TÑ"Ü 7Ô áØzz×*Ñ*Ð*Ø::dÑ#Ð #à× Ñ §
|
¡
|
¨4Ñ 0°'Ó:Ð:r\ T)ÚlimitÚ
|
limit_arearf c ó | j }|j « rMt j || j ¬« }| j
|
j }|j }|r!|j « }|j « }n||j « } ||||¬« ||j « s|j }| } | j « }
|
t | « | d d d
j « z
|
dz
|
} |dk( r)|d |
|
xxx |d |
|
z ccc || dz d xxx || dz d z ccc n |dk( r||
|
dz | xxx ||
|
dz | z ccc |r&| j |j |j « S | S |r| j « } | S | } | S )N©Úndim©r rX éÿÿÿÿé ÚinsideÚoutside) rR Úanyr
|
Ú get_fill_funcr rP ÚTrf ÚallÚargmaxÚlenr[ ) rg Úmethodr r rf rX ÚfuncÚnpvaluesÚnew_maskÚneg_maskÚfirstÚlastÚ
|
new_valuess rZ Ú_pad_or_backfillz BaseMaskedArray._pad_or_backfillÅ sv ð zzà 88:Ü×(Ñ(¨°d·i±iÔ@Dàzz||HØvvHÙØ#==?Ø#==?ØÐ'Øyy{Ù ¨XÕ 6àÐ%¨d¯h©h¬jØvvØ 5Ø Ó)Ü8} x±°"°¡~×'<Ñ'<Ó'>Ñ>ÀÑBØ Ò)Ø VeÓ$¨¨V¨e¨ Ñ4Ó$Ø T AXZÓ(¨D°¸±°Ð,<Ñ<Ô(Ø 9Ò,Ø U QY¨Ó.°$°u¸q±yÀ4Ð2HÑHÓ.áØ×'Ñ'¨¯
|
©
|
°H·J±JÓ?Ð?à áØ !YY[
|
ð Ðð "
|
ØÐr\ c ó< t ||« \ }}| j }t j ||t | « « }|j « r·|t j || j ¬« }| j j }|j }|r |j « }|j « } ||||¬« | j |j |j « S |r| j « } n| d d } || |< | S |r| j « } | S | d d } | S )Nr r ) r rR r
|
Úcheck_value_sizer r r r rP r rf r[ )
|
rg Úvaluer r rf rX r r r r s
|
rZ ÚfillnazBaseMaskedArray.fillnañ s ô /¨u°fÓ= vàzzä×(Ñ(¨°´c¸$³iÓ@à 88:ØÐ!Ü ×,Ñ,¨V¸$¿)¹)ÔDØ ::<<Ø 66ÙØ '}}HØ '}}HÙX U°Õ:Ø×'Ñ'¨¯
|
©
|
°H·J±JÓ?Ð?ñ Ø!%§¡£Jà!%¡a JØ#(
|
4Ñ ð Ðñ Ø !YY[
|
ð Ðð "¡!W
|
ØÐr\ ©rf c ó t | « rT r )rV rW ra rf s rZ rk z BaseMaskedArray._coerce_to_array s ô " #Ó&Ð&r\ c óx | j j }|dk( rt j |« ro|S |dk( r,t j |« st j
|
|« r>|S t j |« s%t j
|
|« r|j « r|S t d|d| j d« )zy
|
Check if we have a scalar that we can cast losslessly.
|
|
Raises
|
------
|
TypeError
|
ÚbÚfzInvalid value 'z ' for dtype 'rp )ra Úkindr r" Ú
|
is_integerÚis_floatrc )rg r£ rª s rZ Ú_validate_setitem_valuez'BaseMaskedArray._validate_setitem_value s ð zzà 3;Ü{{5Ô!Ø à S[Ü~~eÔ$¬¯ © °UÔ(;Ø ô ~~eÔ$¬¯ © °eÔ)<À×AQÑAQÔASØ ô
|
/¨%¨°-ÀÇ
|
Á
|
¸|È1ÐMÓNÐNr\ c óZ t | |« }t |« rVt || j « rd| j |< y | j |« }|| j |< d| j |< y | j || j ¬« \ }}|| j |< || j |< y )NTFro )r? r% r* ra rR r rP rk )rg Úkeyr£ rX s rZ Ú __setitem__zBaseMaskedArray.__setitem__4 s Ü! $¨Ó,ä UÔ Ü$ U¨D¯J©JÔ7Ø"&
|
|
3ð
|
ð ×4Ñ4°UÓ;Ø"'
|
|
3Ø"'
|
|
3Ø à×+Ñ+¨E¸¿¹Ð+ÓD tà
|
|
3Ø
|
|
3r\ c ór t |« r|| j j ur|| j j j dk( rYt j |« rDt t j | j « | j z j « « S t t | 5 |« « S )Nr© )r+ ra r rP rª r r¬ ru r_ ÚisnanrR r ÚsuperÚ __contains__)rg r¯ Ú __class__s rZ r´ z BaseMaskedArray.__contains__E s ø Ü 9 D§J¡J×$7Ñ$7Ñ7àzz× Ñ ×$Ñ$¨Ò+´· ± ¸SÔ0AÜRXX d§j¡jÓ 1°T·Z±Z°KÑ ?× DÑ DÓ FÓGÐGäEGÑ(¨Ó-Ó.Ð.r\ c # óB K | j dk( rl| j s| j D ] }| y | j j }t | j | j « D ] \ }}|r| | y t t | « « D ] }| | y w)Nr ) r Ú_hasnarP ra r ÚziprR Úranger )rg Úvalr Úisna_Úis rZ Ú__iter__zBaseMaskedArray.__iter__M s è ø Ø 99>Ø;;Ø ::ò CØ Iñ ð ::×.Ñ.Ü"% d§j¡j°$·*±*Ó"=ò "JE3Ù Ø &à ! ñ "ô 3t9Ó%ò Ø1g ñ ùs B B c ó, t | j « S rT )r rP r} s rZ Ú__len__zBaseMaskedArray.__len__] s Ü4::Ð r\ c ó. | j j S rT )rP rd r} s rZ rd zBaseMaskedArray.shape` s àzz× Ñ Ð r\ c ó. | j j S rT )rP r r} s rZ r zBaseMaskedArray.ndimd s àzzÐ r\ c ó | j j ||« }| j j ||« }| j ||« S rT )rP ÚswapaxesrR r[ )rg Úaxis1Úaxis2ÚdatarX s rZ rà zBaseMaskedArray.swapaxesh sA Øzz×"Ñ" 5¨%Ó0Øzz×"Ñ" 5¨%Ó0Ø× Ñ dÓ+Ð+r\ r c ó® t j | j ||¬« }t j | j ||¬« }| j ||« S ©N©Úaxis)r_ ÚdeleterP rR r[ )rg ÚlocrÊ rÆ rX s rZ rË zBaseMaskedArray.deletem sA Üyy S¨tÔ4Üyy S¨tÔ4Ø× Ñ dÓ+Ð+r\ c ó | j j |i |¤} | j j |i |¤}| j ||« S rT )rP ÚreshaperR r[ ©rg ÚargsÚkwargsrÆ rX s rZ rÎ zBaseMaskedArray.reshaper sK Ø!tzz×!Ñ! 4Ð2¨6Ñ2Ø!tzz×!Ñ! 4Ð2¨6Ñ2Ø× Ñ dÓ+Ð+r\ c ó | j j |i |¤} | j j |i |¤} t | « ||« S rT )rP ÚravelrR rr rÏ s rZ rÓ zBaseMaskedArray.ravelw sK à tzz× Ñ Ð0¨Ñ0Ø tzz× Ñ Ð0¨Ñ0ØtDz$ Ó%Ð%r\ c óv | j | j j | j j « S rT )r[ rP r rR r} s rZ r zBaseMaskedArray.T} s% à× Ñ §
|
¡
|
§ ¡ ¨d¯j©j¯l©lÓ;Ð;r\ c óü | j j dk( r| S t j ||« t j
|
| j fd|i|¤}| j || j 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¨ Údecimals)
|
ra rª ÚnvÚvalidate_roundr_ ÚroundrP Ú_maybe_mask_resultrR rf )rg rÖ rÐ rÑ rW s rZ rÙ zBaseMaskedArray.round se ð0 ::??cÒ !ØKÜ
|
×Ñ$ Ô'Ü$**ÑB¨xÐB¸6ÑBð ×&Ñ& v¨t¯z©z¯©Ó/@ÓAÐAr\ c ól | j | j | j j « « S rT ©r[ rP rR rf r} s rZ Ú
|
__invert__zBaseMaskedArray.__invert__¤ ó& Ø× Ñ §¡ ¨T¯Z©Z¯_©_Ó->Ó?Ð?r\ c ól | j | j | j j « « S rT rÜ r} s rZ Ú__neg__zBaseMaskedArray.__neg__§ rÞ r\ c ó" | j « S rT r¥ r} s rZ Ú__pos__zBaseMaskedArray.__pos__ª s Øyy{Ðr\ c ó| | j t | j « | j j « « S rT )r[ ÚabsrP rR rf r} s rZ Ú__abs__zBaseMaskedArray.__abs__ s( Ø× Ñ ¤ D§J¡J£°·±· ± Ó1BÓCÐCr\ c ó8 t j | t ¬« S )Nro )r_ ÚasarrayÚobjectr} s rZ Ú_values_for_jsonz BaseMaskedArray._values_for_json² s Üzz$¤fÔ-Ð-r\ c ób | j }t | |||« \ }}|t }|r|t k7 r,t |« s!|t j
|
u rt d| d« t j « 5 t j dt ¬« | j j |« }ddd« || j < |S t j « 5 t j dt ¬« | j j ||¬« }ddd« |S # 1 sw Y qxY w# 1 sw Y S xY w)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©Úcategoryr¥ )r· r: rè r& Ú
|
libmissingÚNAre ÚwarningsÚcatch_warningsÚfilterwarningsÚRuntimeWarningrP ÚastyperR )rg ra rf r ÚhasnarÆ s rZ Úto_numpyzBaseMaskedArray.to_numpyµ s ðD Ü2°4¸ÀÈ%ÓPxØ =ÜEá àÜ'¨Ô.Ø ¤
|
§ ¡ Ñ-ä Ø)¨%¨ð 1&ð &óð ô ×(Ñ(Ó*ñ 0Ü×'Ñ'¨¼>ÕJØzz×(Ñ(¨Ó/÷ 0ð (DÑ ð
|
ô ×(Ñ(Ó*ñ ;Ü×'Ñ'¨¼>ÕJØzz×(Ñ(¨°TÐ(Ó:÷ ;ð ÷ 0ð 0ú÷
|
;ð ús Á17DÃ9D$ÄD!Ä$D.c ó | j dkD r | D cg c] }|j « c}S | j rd n| j j }| j |t j ¬« j « S c c}w )Nr ©ra r )r Útolistr· rP ra rö rî rï )rg Úxra s rZ rù zBaseMaskedArray.tolist s` à 99q=Ø(,Ö- 1AHHJÒ-Ð -Ø ¨¯©×)9Ñ)9Ø}} 5´:·=±=}ÓA×HÑHÓJÐJùò .s Bc ó y rT r ©rg ra rf s rZ rô zBaseMaskedArray.astype r r\ c ó y rT r rü s rZ rô zBaseMaskedArray.astype r r\ c ó y rT r rü s rZ rô zBaseMaskedArray.astype! r r\ c óÈ t |« }|| j k( r|r| j « S | S t |t « r®t j « 5 t j dt ¬« | j j |j |¬« }d d d « | j u r | j n| j j « }|j « } |||d¬« S t |t « r$|j « }|j | ||¬« S |j dk( rt" j$ }n5|j dk( rt# j& d« }nt( j* }|j d v r| j, r t/ d
|
« |j d k( r| j, r t/ d « | j1 |||¬ « }|S # 1 sw Y CxY w)Nrë rì r¥ Fri r© ÚMÚNaTÚiuz cannot convert NA to integerr¨ z cannot convert float NaN to bool)ra r rf )r' ra rf r^ r( rð rñ rò ró rP rô Ú numpy_dtyperR Úconstruct_array_typer! rm rª r_ ÚnanÚ
|
datetime64r Ú
|
no_defaultr· re rö )rg ra rf rÆ rX rV Úeaclsr s rZ rô zBaseMaskedArray.astype% s Ü UÓ#à DJJÒ ÙØyy{Ð"ØKô e_Ô -ä×(Ñ(Ó*ñ GÜ×'Ñ'¨¼>ÕJàzz×(Ñ(¨×):Ñ):ÀÐ(ÓF÷ Gð "&¨¯©Ñ!34::¸¿¹¿ ¹ Ó9JDØ×,Ñ,Ó.CÙtT¨Ô.Ð .ä e^Ô ,Ø×.Ñ.Ó0EØ×'Ñ'¨°EÀÐ'ÓEÐ Eð
|
::Ò ävvHØ ZZ3Ò Ü}} UÓ+Hä~~Hð ::Ñ $§+¢+Ü Ð ;Ó<Ð <Ø ::Ò §¢ä Ð ?Ó@Ð @à}} 5°8À$}ÓGØ ÷C Gñ Gús ÁAGÇG!iè c óÜ |du rR| j s"t j | j ||¬« S t j
|
dt t « ¬« |d}| j ||¬« S )z|
|
the array interface, return my values
|
We return an object array here to preserve our scalar values
|
Fri aS 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.)Ú
|
stacklevel) r· r_ r< rP rð ÚwarnÚ FutureWarningr rö rü s rZ Ú __array__zBaseMaskedArray.__array__U sd ð 5=Ø;;äxx §
|
¡
|
°%¸dÔCÐCä MMð2ô Ü+Ó-õ ð <ØDØ}} 5¨t}Ó4Ð4r\ ztuple[type, ...]Ú_HANDLED_TYPESc ó8
|
|j dd« }||z D ]( }t || j t fz « r"t c S t j | ||g|¢i |¤}|t ur|S d|v rt j | ||g|¢i |¤S |dk( r%t j | ||g|¢i |¤}|t ur|S t j t | « t ¬« g }|D ]N }t |t « r+ |j z |j |j « >|j |« P d fd
|
t! ||« |i |¤}|j" dkD rt%
|
fd|D « « S |dk( r(| j j' « r | j( S |S
|
|« S ) NÚoutr Úreducero c óä ddl m}m}m} | j j
|
dk( rj « } || |« S | j j
|
dv rj « } || |« S | j j
|
dk( rUj « }| j t j k( r | j t j « } || |« S t j | < | S )Nr )rF rJ Ú IntegerArrayr¨ r r© ) Úpandas.core.arraysrF rJ r ra rª rf r_ Úfloat16rô Úfloat32r )rú rF rJ r ÚmrX s rZ Ú reconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct s½ ø ÷ ñ ð ww||sÒ"ØIIKÙ# A qÓ)Ð)Ø Ñ%ØIIKÙ# A qÓ)Ð)Ø Ò$ØIIKØ77bjjÒ(𠤧¡Ó,AÙ$ Q¨Ó*Ð*ä &&$ØHr\ r c 3 ó. K | ] } |« y wrT r )Ú.0rú r s rZ ú <genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>¶ s øè ø Ò8¨A Q Ñ8ùs )rú rO )Úgetr^ r rM ÚNotImplementedr. Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncr_ Úzerosr ru rR ÚappendrP ÚgetattrÚnoutÚtupler Ú _na_value) rg Úufuncr ÚinputsrÑ r rú rY Úinputs2rX r s @@rZ Ú__array_ufunc__z BaseMaskedArray.__array_ufunc__r sµ ù ð jj Ó#à# ò &AÜ a ×!4Ñ!4¼Ð7IÑ!IÕJÜ%Ò%ð &ô
|
×<Ñ<Ø %ð
|
Ø"(ò
|
Ø,2ñ
|
ð Ñ 'ØMà F?ä ×4Ñ4ØeVðØ&,òØ06ñð ð XÒ Ü ×7Ñ7ØeVðØ&,òØ06ñFð ^Ñ+Ø äxxD ¬Ô.ØØò "AÜ!_Ô-ØØqwwÕ'àqÕ!ð "õ ð4 ( Ó'¨Ð;°FÑ;Ø ::>äÓ8°Ô8Ó8Ð 8Ø xÒ àzz~~Ô Ø~~Ð%ØMá vÓ&Ð &r\ c óZ ddl }|j | j | j |¬« S )z6
|
Convert myself into a pyarrow Array.
|
r N)rX rr )Úpyarrowr< rP rR )rg rr Úpas rZ Ú__arrow_array__z BaseMaskedArray.__arrow_array__¿ s$ ó àxx
|
|
¨¯©¸$xÓ?Ð?r\ c ó6 | j j « S rT )rR r r} s rZ r· zBaseMaskedArray._hasnaÇ s ð zz~~Ó Ð r\ c óò |e| j j « }|t j u r|dz }|S t |« r%t |« t |« k( r|t |« z }|S | j |z }|S )NT)rR rf rî rï r$ r r+ )rg rX Úothers rZ Ú_propagate_maskz BaseMaskedArray._propagate_maskÐ sz ð <Ø::??Ó$DØ
|
Ñ%àd{ð ô eÔ$¬¨U«´s¸4³yÒ)@Ød 5kÑ)ð
|
ð :: Ñ$Dð r\ c óà |j }d }t |d« s:t |« r/t |« t | « k( rt |« }t |d¬« }t |t « r|j |j }}nJt |« r?t |t « st j |« }|j dkD r t d« t j |t | « f« }t j" |« }t% |« }|dv r%t |t j& « r t) |« }| j+ ||« }|t, j. u r£t j0 | j « }| j2 j4 dk( r.|dv rt d | d
|
« |d v rd }nd }|j7 |« }nd|v r| j2 j4 dk7 rp|j7 t j8 « }nP| j2 j4 dv r|dv r|}t j: d¬« 5 || j |« }d d d « |dk( rt j< | j dk( | j z d|« }| t j< |dk( | z d|« }n±|t, j. urt j< |dk( d|« }n|dk( r| t j< |dk( | z d|« }n,|t, j. urt j< |dk( d|« }t j< | j dk( | j z d|« }| j? |« S # 1 sw Y %xY w)Nra T)Ú extract_numpyr ú(can only perform ops with 1-d structures> ÚpowÚrpowr¨ > r6 r7 ÚtruedivÚfloordivÚrtruedivÚ rfloordivz
|
operator 'z!' not implemented for bool dtypes> ÚmodÚrmodÚint8ru r8 r© r )r9 r< rë )r r6 Fr r7 ) Ú__name__Úhasattrr$ r Úpd_arrayr> r^ rM rP rR r; r_ rç r rv r0 Úmaybe_prepare_scalar_for_opÚ get_array_opr= rb ru r2 rî rï Ú ones_likera rª rô Úfloat64ÚerrstateÚwhererÚ ) rg r1 ÚopÚop_nameÚomaskÚpd_oprX rY ra s rZ Ú _arith_methodz BaseMaskedArray._arith_methodà sò Ø++Øô wÔ'Ü UÔ#ÜE
|
c $iÒ'ô UOEÜ! %°tÔ<Eä e_Ô -Ø ;;¨¯ © 5Eä %Ô Ü e¤^Ô4Ü
|
|
5Ó)ØzzA~Ü)Ð*TÓUÐUô ×/Ñ/°¼¸D» °|ÓDÜ× Ñ Ó$Ü.¨uÓ5à oÑ %¬*°U¼B¿H¹HÔ*Eô KEà×#Ñ# E¨5Ó1à JMMÑ !Ü\\ $§*¡*Ó-FØzz #Ò%Øð ñ ô .Ø$ W IÐ-NÐOóð ð oÑ-Ø "Eà "EØ uÓ-ØgÑ%¨$¯*©*¯/©/¸SÒ*@ð ¤r§z¡zÓ2ð zz $Ñ&¨7Ð6IÑ+Ið ä Ô*ñ 2Ù tzz¨5Ó1÷ 2ð eÒ ä88TZZ¨1_°·±° Ñ ;¸UÀDÓIDàÐ Üxx ¨!¡°¨vÑ 5°u¸dÓCØjmmÑ+Üxx ¨¡
|
¨E°4Ó8à Ò àÐ Üxx ¨!¡°¨vÑ 5°u¸dÓCØjmmÑ+Üxx ¨¡
|
¨E°4Ó8ä88TZZ¨1_°·±° Ñ ;¸UÀDÓIDà×&Ñ& v¨tÓ4Ð4÷+ 2ñ 2ús È,M#Í#M-c ó| ddl m} d }t |t « r|j |j
|
}}n\t |« rQt j |« }|j dkD r t d« t | « t |« k7 r t d« |t j u rWt j | j j d¬« }t j" | j j d¬« }nt% j& « 5 t% j( dd t* « t% j( dd t, « t/ | j d
|
|j0 d
|
« } ||« }|t2 u rt5 | j ||« }d d d « | j7 ||« } ||d ¬ « S # 1 sw Y &xY w) Nr rE r r5 z Lengths must match to compareru ro rë Ú elementwiseÚ__Fr¥ ) r rF r^ rM rP rR r$ r_ rç r rv r re rî rï r! rd rt rð rñ rò r ÚDeprecationWarningr# r? r r@ r2 )rg r1 rH rF rX rY r s rZ Ú _cmp_methodzBaseMaskedArray._cmp_method? s_ Ý3àä e_Ô -Ø ++ u§{¡{4Eä %Ô ÜJJuÓ%EØzzA~Ü)Ð*TÓUÐUÜ4yC JÒ&Ü Ð!@ÓAÐAà JMMÑ !ô
|
XXdjj× .Ñ .°fÔ=FÜ774::×+Ñ+°6Ô:Dä×(Ñ(Ó*ñ Gô ×'Ñ'¨°-Ä ÔOÜ×'Ñ'¨°-ÔASÔTÜ §¡¨r°"·+±+° ¸bÐ-AÓBÙ à^Ñ+Ü /°·
|
±
|
¸EÀ2Ó FF÷ Gð ×#Ñ# D¨%Ó0ÙF D¨uÔ5Ð5÷ Gð Gús Ä BF2Æ2F;c ó t |t « r)|\ }}| j ||« | j ||« fS |j j dk( rddlm} |||d¬« S |j j dk( rddlm} |||d¬« S t j |j d« rdt |j « rOdd lm } |j j d
|
« ||< t ||« s |j ||j ¬ « S |S |j j d v rdd lm} |||d¬« S t j ||< |S )z
|
Parameters
|
----------
|
result : array-like or tuple[array-like]
|
mask : array-like bool
|
r© r rI Fr¥ r¨ rE r )ÚTimedeltaArrayr ro r ©r )r^ r% rÚ ra rª r rJ rF r Ú is_np_dtyper rS rr r[ r r_ r ) rg rY rX Údivr< rJ rF rS r s rZ rÚ z"BaseMaskedArray._maybe_mask_resultg s% ô feÔ $à HCà×'Ñ'¨¨TÓ2Ø×'Ñ'¨¨TÓ2ðð ð
|
<<× Ñ Ò #Ý 8á ¨°EÔ:Ð :à \\× Ñ #Ò %Ý 7á ¨°5Ô9Ð 9ä __V\\¨3Ô /Ô4FÀvÇ|Á|Ô4Tå 9à!<<×,Ñ,¨UÓ3F4Lä f nÔ5Ø%×1Ñ1°&ÀÇ Á Ð1ÓMÐMàMà \\× Ñ $Ñ &Ý 7á ¨°5Ô9Ð 9ô 66F4LØMr\ c ó6 | j j « S rT )rR rf r} s rZ r+ zBaseMaskedArray.isna s ØzzÓ Ð r\ c ó. | j j S rT rø r} s rZ r& zBaseMaskedArray._na_value s àzz×"Ñ"Ð"r\ c ó\ | j j | j j z S rT )rP ÚnbytesrR r} s rZ rZ zBaseMaskedArray.nbytes s! àzz× Ñ 4§:¡:×#4Ñ#4Ñ4Ð4r\ c óä t j |D cg c] }|j c}|¬« }t j |D cg c] }|j c}|¬« } | ||« S c c}w c c}w rÈ )r_ Ú concatenaterP rR )rV Ú to_concatrÊ rú rÆ rX s rZ Ú_concat_same_typez!BaseMaskedArray._concat_same_type¡ sV ô ~~° Ö :¨1qwwÒ :ÀÔFÜ~~° Ö :¨1qwwÒ :ÀÔFÙ4Ð ùò ;ùÚ :s A(ÁA-c ó t | j |||¬« }t | j j « || j « < |S )N)ÚencodingÚhash_keyÚ
|
categorize)rA rP Úhashra r r+ )rg r` ra rb Ú hashed_arrays rZ Ú_hash_pandas_objectz#BaseMaskedArray._hash_pandas_object« sB ô "Ø JJ °HÈô
|
ô %)¨¯©×)<Ñ)<Ó$= TYY[Ñ!ØÐr\ )Ú
|
allow_fillÚ
|
fill_valuerÊ c ó t |« r | j n|}t | j ||||¬« }t | j |d||¬« }|r-t |« r"t j |« dk( }|||< ||z }| j ||« S )N)rg rf rÊ Tr ) r+ rN r5 rP rR r, r_ rç r[ ) rg Úindexerrf rg rÊ Údata_fill_valuerY rX Ú fill_masks rZ r5 zBaseMaskedArray.take´ s ô 8<¸JÔ7G$×3Ò3ÈZÜØ JJØ Ø&Ø!Øô
|
ô Ø JJ¨D¸ZÈdô
|
ñ %
|
Ô+Ü
|
|
7Ó+¨rÑ1IØ *F9Ñ Ø)Ñ#Dà× Ñ ¨Ó-Ð-r\ c ób ddl m} t j |« }t j
|
|« } j r8|j t k( xr t fd|D « « }|| j < t j j
|
j t ¬« } |||d¬« S )Nr rE c 3 óN K | ] }|j j u y wrT rø )r rº rg s rZ r z'BaseMaskedArray.isin.<locals>.<genexpr>á s' øè ø ò @Ø/2tzz×*Ñ*Ô*ñ@ùs "%ro Fr¥ )r rF r_ rç r2 rP r· ra rè r rR r! rd ru )rg rW rF Ú
|
values_arrrY Úvalues_have_NArX s ` rZ r2 zBaseMaskedArray.isinØ s ø Ý3ô ZZ Ó'
|
Üdjj *Ó-à ;;Ø '× -Ñ -´Ñ 7ò ¼Có @Ø6@ô@ó =Nð "0F4::Ñ äxx
|
|
×(Ñ(´Ô5ÙF D¨uÔ5Ð5r\ c ó | j j « }| j j « }| j ||« S rT )rP rf rR r[ )rg rÆ rX s rZ rf zBaseMaskedArray.copyì s5 ØzzÓ ØzzÓ Ø× Ñ dÓ+Ð+r\ c ób | j }| j }t j |||¬« S )N)ÚkeeprX )rP rR ÚalgosÚ
|
duplicated)rg rr rW rX s rZ rt zBaseMaskedArray.duplicatedñ s+ ð ØzzÜ× Ñ ¨T¸Ô=Ð=r\ c ó t j | j | j « \ }}| j ||« S )z
|
Compute the BaseMaskedArray of unique values.
|
|
Returns
|
-------
|
uniques : BaseMaskedArray
|
)rs Úunique_with_maskrP rR r[ )rg ÚuniquesrX s rZ ÚuniquezBaseMaskedArray.uniqueù s5 ô ×.Ñ.¨t¯z©z¸4¿:¹:ÓF Ø× Ñ ¨Ó.Ð.r\ c ó¶ | j r t d« t |t « r|j t
|
« }| j j |||¬« S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)ÚsideÚsorter)r· re r^ r; rô rè rP Ú searchsorted)rg r£ rz r{ s rZ r| z BaseMaskedArray.searchsorted sS ð ;;Ü ð$óð ô e^Ô ,ØLL¤Ó(Eàzz×&Ñ& u°4ÀÐ&ÓGÐGr\ c ó | j }| j }t |d|¬« \ }}|j | j j k( s J |j | j f« |j « }|s|s t |« }nt |« dz }t j |t ¬« }|sw|ru|j « } | dk( rt j d« }
|
n|d | j « dz }
|
|||
|
k\ xx dz cc< |
|
||dk( < t j ||
|
d« }d||
|
< | j ||« } || fS )NT)Úuse_na_sentinelrX r ro r r )rP rR r1 ra r r r r_ r! ru r ÚintpÚmaxÚinsertr[ ) rg r~ ÚarrrX Úcodesrw Úhas_naÚsizeÚ uniques_maskÚna_indexÚna_codeÚ
|
uniques_eas rZ Ú factorizezBaseMaskedArray.factorize s- ð
|
jjØzzô )¨¸dÈÔNwð }} §
|
¡
|
× 6Ñ 6Ò6ÐS¸¿ ¹ ÈÏ
|
É
|
Ð8SÓSÐ6àÙ ¡&Üw<Dô w< !Ñ#DÜxx ¬DÔ1 Ù ¡6Ø{{}Hà1}Ü '' !*à Ð*×.Ñ.Ó0°1Ñ4Ø %7Ñ"Ó # qÑ (Ó #Ø!(E%2+Ñ äii ¨°!Ó4GØ$(LÑ !Ø×%Ñ% g¨|Ó<
|
àjÐ Ð r\ c ó | j S rT )rP r} s rZ Ú_values_for_argsortz#BaseMaskedArray._values_for_argsort: s àzzÐr\ c ó ddl m}m} ddlm} t j | j || j ¬« \ }}}t j t |« ft j ¬« }|j « } |dkD rd|d< ||| « }
|
| | j j « ||« « } ||
|
| dd ¬
|
« S ) 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 )ÚIndexrD rT ©ÚdropnarX ro Tr ÚcountF)ÚindexÚnamerf )Úpandasr rD Ú pandas.arraysr rs Úvalue_counts_arraylikerP rR r_ r! r rb rf ra r ) rg r r rD r ÚkeysÚ value_countsÚ
|
na_counterÚ
|
mask_indexrX r r s rZ r z BaseMaskedArray.value_counts> s± ÷"
|
õ /ä).×)EÑ)EØ JJv¨D¯J©Jô*
|
Ñ&lJô XXs <Ó 0Ð 2¼"¿(¹(ÔC
|
ØÓ à >Ø !JrNá<¨Ó.ÙØ -DJJ× +Ñ +Ó -Øjó ó
|
ñ
|
c ¨W¸5ÔAÐAr\ c ó> |rRt | j || j ¬« }t j |j
|
t j ¬« }n%t | j || j ¬« \ }} t | « ||« }||j « S )Nr ro ) r4 rP rR r_ r! rd rb rr Úargsort)rg r rY Úres_masks rZ Ú_modezBaseMaskedArray._modef sr Ù Ü$**¨V¸$¿*¹*ÔEFÜxx § ¡ ´B·H±HÔ=Hä # D§J¡J°vÀDÇJÁJÔ OÑ FHØdF HÓ-ØfnnÓ&Ñ'Ð'r\ c óB t | « t |« k7 ry|j | j k7 ryt j | j |j « sy| j
|
| j }|j
|
|j }t ||dd¬« S )NFT)Ú
|
strict_nanÚ dtype_equal)rr ra r_ Ú array_equalrR rP r) )rg r1 ÚleftÚrights rZ ÚequalszBaseMaskedArray.equalso s| ä :eÒ $ØØ ;;$**Ò $Øô ~~djj¨%¯+©+Ô6Øàzz4::+Ñ&Ø U[[LÑ)Ü e¸È$ÔOÐOr\ c ó t | j | j t j ||¬« }| j
|
rÉ| j dk( rt | j « j « rpt j |j t ¬« }t | j « rt j |j | j j ¬« }nKt j |j t ¬« }n%t j |j t ¬« }| j# ||¬« S )z½
|
Dispatch to quantile_with_mask, needed because we do not have
|
_from_factorized.
|
|
Notes
|
-----
|
We assume that all impacted cases are 1D-only.
|
)rX rg ÚqsÚ interpolationé ro ©rX )r8 rP rR r_ r r· r rv r+ r rt rd ru r# ra r! r rÚ )rg r§ r¨ ÚresÚout_masks rZ Ú _quantilezBaseMaskedArray._quantile s× ô !Ø JJØô vvØØ'ô
|
ð ;;ð yyA~ô *Ð)Øyy{Ô Ü 77 3§9¡9´DÔ9ä# D§J¡JÔ/ô (( 3§9¡9°D·J±J×4JÑ4JÔKCä 88 C§I¡I´TÔ:äxx § ¡ ´Ô6HØ×&Ñ& s°Ð&Ó:Ð:r\ )ÚskipnaÚkeepdimsc óÀ |dv r t | |« d d|i|¤}nJ| j }| j }t t d| « }|j dd « } ||f| ||d|¤}|r]t |« r| j |dd¬« S |j d « }t j d t ¬
|
« }| j ||« S t |« rt j S |S ) N> r r r ÚminÚstdÚsumÚvarÚmeanÚprodr® r rÊ )rÊ r® rX r )r )r rÊ Ú mask_sizer ro r )r# rP rR r/ Úpopr+ Ú_wrap_na_resultrÎ r_ r! ru rÚ rî rï )
|
rg r r® r¯ rÑ rY rÆ rX rH rÊ s
|
rZ Ú_reducezBaseMaskedArray._reduce« sß ð ÐTÑ TØ(WT 4Ó(ÑA°ÐA¸&ÑAFð ::DØ::DÜ 3 t f Ó.BØ::f dÓ+DÙÐL 4°¸TÑLÀVÑLFá ÜF|Ø×+Ñ+°¸AÈÐ+ÓNÐNà ¨Ó*Üxx ¬Ô.Ø×.Ñ.¨v°tÓ<Ð<ä <Ü ==Ð àMr\ c óÔ t |t j « rM|r | j j |¬« }n | j j |¬« }| j ||« S |S rÈ )r^ r_ r` rR r r rÚ )rg r rY r® rÊ rX s rZ Ú_wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_resultÅ sS Ü fbjjÔ )Ùàzz~~¨4~Ó0àzz~~¨4~Ó0à×*Ñ*¨6°4Ó8Ð 8Ø r\ c ó¸ t j |t ¬« }| j dk( rdnd}|dv r|}n{|dv s| j j dk( r!| j j
|
j }n=t « xs t }|rdnd }|rd
|
nd } ||| |d | j j }t j d g|¬« }
|
| j |
|
|¬« S )Nro ÚFloat32r rE )rµ Úmedianr´ r² ÚskewÚkurt)r± r é Úint32Úint64Úuint32Úuint64)r¨ r¼ Úur© r rª ) r_ rt ru ra Úitemsizer r r r rª r< rÚ ) rg r rÊ r· rX Ú
|
float_dtypÚnp_dtypeÚis_windows_or_32bitÚint_dtypÚ uint_dtypr£ s rZ r¹ z BaseMaskedArray._wrap_na_resultÐ sÊ Üwwy¬Ô-à"&§*¡*° Ò"9Y¸y
|
Ø ÐCÑ CØ!HØ ^Ñ # t§z¡z×':Ñ':¸aÒ'?Øzz×-Ñ-×2Ñ2Hä"5Ó"7Ò"C¼t¸8Ð Ù"5w¸7HÙ$7¸XIØ %¨H¸9È:ÑVØ
|
|
ñHô ! HÔ-Ø×&Ñ& u°4Ð&Ó8Ð8r\ c óÔ |dk( rOt |t j « r5| j |t j |j
|
t ¬« « S | j ||||¬« S )Nr ro ©r® rÊ )r^ r_ r` rÚ r! rd ru r¼ )rg r rY r® Ú min_countrÊ s rZ Ú _wrap_min_count_reduction_resultz0BaseMaskedArray._wrap_min_count_reduction_resultã sU ð >j¨´·±Ô <Ø×*Ñ*¨6´2·8±8¸F¿L¹LÔPTÔ3UÓVÐ VØ×*Ñ*¨4°ÀÈTÐ*ÓRÐRr\ ©r® rÐ rÊ c ó¶ t j d|« t j | j | j
|
|||¬« }| j d||||¬« S )Nr rÒ r³ )r× Ú validate_sumr7 r³ rP rR rÑ ©rg r® rÐ rÊ rÑ rY s rZ r³ zBaseMaskedArray.sumê s^ ô FÔ#ä"×&Ñ&Ø JJØ JJØØ Øô
|
ð ×4Ñ4Ø 6 &°IÀDð 5ó
|
ð
|
r\ c ó¶ t j d|« t j | j | j
|
|||¬« }| j d||||¬« S )Nr rÒ r¶ )r× Ú validate_prodr7 r¶ rP rR rÑ rÕ s rZ r¶ zBaseMaskedArray.prodÿ s` ô ×ÑVÔ$ä"×'Ñ'Ø JJØ JJØØ Øô
|
ð ×4Ñ4Ø F 6°YÀTð 5ó
|
ð
|
r\ rÏ c ó² t j d|« t j | j | j
|
||¬« }| j d|||¬« S )Nr rÏ rµ )r× Ú validate_meanr7 rµ rP rR r¼ ©rg r® rÊ rÑ rY s rZ rµ zBaseMaskedArray.mean sR Ü
|
×ÑVÔ$Ü"×'Ñ'Ø JJØ JJØØô
|
ð ×*Ñ*¨6°6À&ÈtÐ*ÓTÐTr\ r ©r® rÊ Úddofc ó¸ t j d|d¬« t j | j | j
|
|||¬« }| j d|||¬« S )Nr r´ ©ÚfnamerÛ rÏ )r× Úvalidate_stat_ddof_funcr7 r´ rP rR r¼ ©rg r® rÊ rÜ rÑ rY s rZ r´ zBaseMaskedArray.var óY ô ×"Ñ" 2 v°UÕ;Ü"×&Ñ&Ø JJØ JJØØØô
|
ð ×*Ñ*¨5°&ÀÈdÐ*ÓSÐSr\ c ó¸ t j d|d¬« t j | j | j
|
|||¬« }| j d|||¬« S )Nr r² rÞ rÛ rÏ )r× rà r7 r² rP rR r¼ rá s rZ r² zBaseMaskedArray.std+ râ r\ c ó² t j d|« t j | j | j
|
||¬« }| j d|||¬« S )Nr rÏ r± )r× Ú validate_minr7 r± rP rR r¼ rÚ s rZ r± zBaseMaskedArray.min8 óP Ü
|
FÔ#Ü"×&Ñ&Ø JJØ JJØØô
|
ð ×*Ñ*¨5°&ÀÈdÐ*ÓSÐSr\ c ó² t j d|« t j | j | j
|
||¬« }| j d|||¬« S )Nr rÏ r )r× Ú validate_maxr7 r rP rR r¼ rÚ s rZ r zBaseMaskedArray.maxB ræ r\ c ó: t | j « ||¬« S )N)Ú na_action)r3 rö )rg Úmapperrê s rZ ÚmapzBaseMaskedArray.mapL s Ü ¨&¸IÔFÐFr\ c ód t j d|« | j j « }t j
|
|| j | j « |j « }|r|S |s(t | « dk( s| j j « s|S | j j S )aY
|
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.
|
axis : int, optional, default 0
|
**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 r ) r× Ú validate_anyrP rf r_ ÚputmaskrR Ú _falsey_valuer r ra r ©rg r® rÊ rÑ rW rY s rZ r zBaseMaskedArray.anyO s ô~ FÔ#à Ó"ô
|
|
64:: t×'9Ñ'9Ô:Ø Ù ØMáT a ¨t¯z©z¯~©~Ô/?Ø àzz×*Ñ*Ð*r\ c óh t j d|« | j j « }t j
|
|| j | j « |j |¬« }|r|S |r(t | « dk( s| j j « s|S | j j S )aL
|
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.
|
axis : int, optional, default 0
|
**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 rÉ r ) r× Ú validate_allrP rf r_ rï rR Ú _truthy_valuer r r ra r rñ s rZ r zBaseMaskedArray.all s ô~ FÔ#à Ó"ô
|
|
64:: t×'9Ñ'9Ô:Ø Ó&á ØMáS Y¨!^°4·:±:·>±>Ô3CØ àzz×*Ñ*Ð*r\ c ó | j j dk( rP|r5| j j « } | j j « }
|
n| j } | j }
|
nh| j j dv r8d}| j j d« } | j j « }
|
nt d| j « t j | f|d|||||
|
d|¤ |s| S | j j dk( rt | « j | |
|
« S ddl m } | j | |
|
« S ) z2
|
See NDFrame.interpolate.__doc__.
|
r© r TÚf8z)interpolate is not implemented for dtype=r )r rÊ r r Úlimit_directionr rX rI ) ra rª rP rf rR rô rv r
|
Úinterpolate_2d_inplacerr r[ r rJ ) rg r rÊ r r r÷ r rf rÑ rÆ rX rJ s rZ Ú interpolatezBaseMaskedArray.interpolateò s ð ::??cÒ !ÙØzzÓ(ØzzÓ(àzzØzzØ ZZ__ Ñ $ØDØ::×$Ñ$ TÓ*DØ::??Ó$Dä%Ø;¸D¿J¹J¸<ÐHóð ô ×&Ñ&Ø ð
|
|
àØØØØ +Ø!Øñ
|
|
ð ò
|
|
ñ ØKØ ::??cÒ !Ü:×)Ñ)¨$°Ó5Ð 5å 8à,=×,Ñ,¨T°4Ó8Ð 8r\ )r® c ó | j }| j }t t |« } |||fd|i|¤\ }}| j ||« S )Nr® )rP rR r# r6 r[ )rg r r® rÑ rÆ rX rH s rZ Ú _accumulatezBaseMaskedArray._accumulate& sP ð zzØzzä Ô)¨4Ó 0ÙdÑ<¨6Ð<°VÑ<
|
dà× Ñ dÓ+Ð+r\ c óF ddl m} |j |« } ||||¬« } | j }
|
| j dk7 r|
|
j « } nt j |t ¬« } |dk( r|j d« dv rd | d d | j | j f||||
|
| d
|
|¤} | j d k( rH| j j | j d « } t j | | d f« j } | j d v r| S | j! | | « S )Nr )ÚWrappedCythonOp)Úhowrª Úhas_dropped_naÚ aggregatero ÚrankÚ na_option)ÚtopÚbottomF)rÐ ÚngroupsÚcomp_idsrX Ú result_maskÚohlcr )ÚidxminÚidxmax)Úpandas.core.groupby.opsrý Úget_kind_from_howrR rª rf r_ r! ru r Ú_cython_op_ndim_compatrP rþ Ú _cython_arityÚtiler rÚ )rg rþ rÿ rÐ r ÚidsrÑ rý rª rH rX r Ú
|
res_valuesÚaritys rZ Ú _groupby_opzBaseMaskedArray._groupby_op4 s õ <à ×0Ñ0°Ó5Ù ¨4ÀÔ Oð zzØ 77kÒ !Ø ))+Kä (( 7´$Ô7Kà &=VZZ¨ Ó 4Ð8IÑ IØ "KNà.R×.Ñ.Ø JJð
|
à ØØØØ#ñ
|
ð ñ
|
|
ð 66VÒ Ø×$Ñ$×(Ñ(¨¯©°Ó3EÜ '' +°°q¨zÓ:×<Ñ<Kà 66Ð)Ñ )à Ð ð ×*Ñ*¨:°{ÓCÐ Cr\ )rW rO rX rQ Úreturnr )F)rW rO rX rQ rf ru r ÚNone)rf ru r r )rd r ra r! )rz ru r zCallable[[Any], str | None])r r( )r r r r )r r r r )r r r z
|
Self | Any)
|
r r r ú
|
int | Noner z#Literal['inside', 'outside'] | Nonerf ru r r )NNNT)r r rf ru r r )ra r rf ru r z tuple[np.ndarray, np.ndarray])r r )r ru )r rB )r Úint)r r )r r )r )rÊ r r r )rÖ r )r rO )ra znpt.DTypeLike | Nonerf ru r rè r rO ).)ra z npt.DTypeLikerf ru r rO )ra r! rf ru r r; )ra r rf ru r r )T)NN)ra zNpDtype | Nonerf z bool | Noner rO )r' znp.ufuncr ry rT )rX z npt.NDArray[np.bool_] | Noner rQ )r rF )rY z*np.ndarray | tuple[np.ndarray, np.ndarray]rX rO )r] zSequence[Self]rÊ r r r )r` ry ra ry rb ru r znpt.NDArray[np.uint64])rf ru rg z Scalar | NonerÊ r r r )rW r r rF )r )rr z Literal['first', 'last', False]r rQ )r£ N)r£ z$NumpyValueArrayLike | ExtensionArrayrz zLiteral['left', 'right']r{ zNumpySorter | Noner z npt.NDArray[np.intp] | np.intp)r~ ru r z!tuple[np.ndarray, ExtensionArray])r ru r rD )r ru r r )r§ znpt.NDArray[np.float64]r¨ ry r rM )r ry r® ru r¯ ru )r ry )r® ru rÐ r rÊ úAxisInt | None)r® ru rÊ r )r® ru rÊ r rÜ r )r r rÊ r rf ru r rJ )r ry r® ru r rM )
|
rþ ry rÿ ru rÐ r r r r znpt.NDArray[np.intp])[r? Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__r rô rð Ú classmethodr[ rh rm r r; rw r{ Úpropertyra r r r r¤ rk r r° r´ r½ r¿ rd r rà rË rÎ rÓ r rÙ rÝ rà râ rå ré r r rö rù rô Ú__array_priority__r r* r. r· r2 rL Ú_logical_methodrQ rÚ r+ r& rZ r^ re r5 r2 rf rt rx r| r r r r r¥ r rº r¼ r¹ rÑ r³ r¶ rµ r´ r² r± r rì r r rù rû r Ú __classcell__)rµ s @rZ rM rM l s ø
ñð !Ó à ÓØ Ó ð MØMàòó ðð MRðØ ðØ(=ðØEIðà óð& Ø.2Àô !ó ð!ð Ù × Ñ Ó ò ó ó ð ôð ò(ó ð(ð ò ó ð ð ò ó ð ó
|
;ð !Ø:>Øñ *ð ð*ð ð *ð
|
8ð *ð ð *ð
|
ó*ñX × Ñ Ó àNRð Ø.8ð ØGKð à ò ó ð ðB à6;ñ'Ø 'ð'Ø/3ð'à &ò'ó ð'ò
|
Oó6 õ"/ó ó ð ò ó ð ð ò ó ð ó,ô
|
,ó
|
,ó
|
&ð ò<ó ð<ô BóF@ó@óóDó
|
.ð
|
'+ØØ >>ð [à#ð[ð ð[ð ð [ð
|
|
ó [ñz × Ñ Ó ñKó ðKð ó ó ð ð ó ó ð ð ó ó ð ô,ð\ Ðð AEð5Ø#ð5Ø2=ð5à ó5ð6 %Ó$óK'óZ@ð ò ó ð ðØ0ðà óò [5ðz $Oó&6ðP-Ø@ð-ØHRó-ó^!ð ñ#ó ð#ð ò5ó ð5ð ð ð à!ð ð ð ð
|
ò ó ð ð Ø ð Ø*-ð Ø;?ð à ó ð !Ø$(Øñ .ð ð .ð
|
"ð .ð ð .ð
|
ó .óH6ó(,ñ
|
× "Ñ "Ó#à6=ð>Ø3ð>à ò>ó $ð>ó /ñ × $Ñ $Ó%ð *0Ø%)ð Hà3ðHð 'ðHð #ð Hð
|
|
(ò Hó &ðHñ × !Ñ !Ó"ð !%ð"!à ð"!ð
|
+ò"!ó #ð"!ñH × +Ñ +Ó,òó -ðô&BôP(ñ × Ñ Ó ò Pó ð Pð ';Ø)ð';Ø:=ð';à ó';ðZ ,0À%ñØðØ$(ðØ;?óó4 ò9ð&SØóSð ØØ ñ
|
ð ð
|
ð ð
|
ð
|
ó
|
ð0 ØØ ñ
|
ð ð
|
ð ð
|
ð
|
ó
|
ð* &*À!õ Uð !%¸QÈAñ TØ ð TØ,:ð TØFIó Tð !%¸QÈAñ TØ ð TØ,:ð TØFIó Tð %)Àõ Tð %)Àõ TóGð %)Àõ O+ðb %)Àõ P+ðd29ð #ð29ð ð 29ð ð29ð
|
ó29ðj ,0ñ ,Øð ,Ø$(ð ,à ó ,ð -Dð ð-Dð ð -Dð
|
ð -Dð ð -Dð "÷-Dr\ rM c ó¢ t | « } | d j }| D cg c] }|j j dd« }}t j
|
|dt j t | « t | d « fd|j ¬« ¬« }| D cg c] }|j j dd« }}t j
|
|dt j |t ¬« ¬« }|j « }g }t |j d « D ]+ } ||dd
| f |dd
| f ¬ « }
|
|j |
|
« - |S c c}w c c}w )
|
zÖTranspose masked arrays in a list, but faster.
|
|
Input should be a list of 1-dim masked arrays of equal length and all have the
|
same dtype. The caller is responsible for ensuring validity of input data.
|
r r r ÚF)Úorderra )rÊ r ro Nrª )Úlistra rP rÎ r_ r\ rq r r rR Ú
|
empty_likeru r r¹ rd r" ) Ú masked_arraysra r rW Útransposed_valuesÚmasksÚtransposed_masksÚarr_typeÚtransposed_arraysr¼ Útransposed_arrs rZ Ú#transpose_homogeneous_masked_arraysr. d sI ô Ó'MØ !Ñ × "Ñ "Eà2?Ö @¨3cii× Ñ 2Õ&Ð @FÐ @ÜØØ Ü HHÜ Ó ¤ ]°1Ñ%5Ó!6Ð 7ØØ×#Ñ#ô
|
ôÐð 2?Ö ?¨#SYY× Ñ q "Õ %Ð ?EÐ ?Ü~~Ø A2==Ð):Ä$ÔGôÐð ×)Ñ)Ó+HØ/1ÐÜ Ð$×*Ñ*¨1Ñ-Ó .ò 1Ù!Ð"3²A°q°DÑ"9Ð@PÒQRÐTUÐQUÑ@VÔWØ× Ñ Õ0ð1ð Ð ùò- Aùò @s #EÂ#E )r' zSequence[BaseMaskedArray]r zlist[BaseMaskedArray])lÚ
|
__future__r Útypingr r r r r rð Únumpyr_ Ú pandas._libsr r
|
rî Úpandas._libs.tslibsr Úpandas._typingr r r r r r r r r r r r r r Ú pandas.compatr r Ú pandas.errorsr Úpandas.util._decoratorsr Úpandas.util._exceptionsr Úpandas.util._validatorsr Úpandas.core.dtypes.baser! Úpandas.core.dtypes.commonr" r# r$ r% r& r' Úpandas.core.dtypes.dtypesr( Úpandas.core.dtypes.missingr) r* r+ r, Ú pandas.corer- rs r. r/ r0 Úpandas.core.algorithmsr1 r2 r3 r4 r5 Úpandas.core.array_algosr6 r7 Ú pandas.core.array_algos.quantiler8 Úpandas.core.arrayliker9 Úpandas.core.arrays._utilsr: Úpandas.core.arrays.baser; Úpandas.core.constructionr< rA r= r> Úpandas.core.indexersr? Úpandas.core.opsr@ Úpandas.core.util.hashingrA Úcollections.abcrB rC r rD r rF rG rH rJ Úpandas.compat.numpyrK r× rM r. r r\ rZ ú<module>rK sé ðÝ "÷õ ó ã ÷õ 3÷÷ ÷ ÷ ÷ õ .Ý 'Ý 4Ý :å 2÷÷ õ 6÷ó ÷õ ÷õ ÷õ @Ý *Ý >Ý 2÷ñ õ
|
5Ý .Ý /á÷õ Ý/÷õ 1å .ôuDh ô uDðp/! Ø,ð! àô! r\
|
