U
|
¬ý°d]Ò ã @ sä d Z ddlmZ ddlZddlmZ ddlmZmZm Z ddl
|
Z
|
ddl Z ddl mZmZmZmZ ddlmZmZmZmZmZmZ ddlmZ dd l m Z dd
|
l m Z 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,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 dd l3m4Z4 dd l5m6Z6m7Z7m8Z8 ddl9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z? ddl@mAZAmBZB ddlCmDZD ddlEmFZGmHZHmIZI ddlJmKZK erªddlmLZLmMZM ddlNmOZOmPZPmQZQ ddlRmSZSmTZT dddddZUddd dd d d ZVdd d!d"ZWejXejYejZej[ej\ej]ej^ej_ej`ejaejbejcejdejed#Zfdd$d%d&Zgdd'dd(d)Zhd*d+ Zidd,dd-d.Zjdd/d0d1d2ZkeiZld d d3d4d5d6Zmd
dd8d9d:d/d;d<d=d>Zneed?ed@edAdBdd8d8d9dDdEdFdGZodd8d8d8d8dHdIdJdKZpddd8d/dLdMdNdOZqdddQd3dRdSdTZrddd8d/ddMdUdVZsdddYd'd'd8d8dZd[d\d]Ztdd^d_d/d/d^d`dadbZuddcdYd8dddedfZvdddhdidjdkdldmdnZwdodpdqdrdsdthZxdd,dYdudvdwZydd8d8d8dxdydzd{Zzd d d|d}Z{dddd~dZ|ddddddZ}dS )zl
|
Generic data algorithms. This module is experimental at the moment and not
|
intended for public consumption
|
é )Ú annotationsN)Údedent)Ú TYPE_CHECKINGÚLiteralÚcast)ÚalgosÚ hashtableÚiNaTÚlib)Ú AnyArrayLikeÚ ArrayLikeÚAxisIntÚDtypeObjÚ TakeIndexerÚnpt)Údoc)Úfind_stack_level)Ú'construct_1d_object_array_from_listlikeÚinfer_dtype_from_array)Úensure_float64Ú ensure_objectÚensure_platform_intÚ is_array_likeÚ is_bool_dtypeÚis_categorical_dtypeÚis_complex_dtypeÚis_extension_array_dtypeÚis_float_dtypeÚ
|
is_integerÚis_integer_dtypeÚ is_list_likeÚis_numeric_dtypeÚis_object_dtypeÚ is_scalarÚis_signed_integer_dtypeÚneeds_i8_conversion)Ú concat_compat)ÚBaseMaskedDtypeÚExtensionDtypeÚ PandasDtype)ÚABCDatetimeArrayÚABCExtensionArrayÚABCIndexÚ ABCMultiIndexÚ ABCSeriesÚABCTimedeltaArray)ÚisnaÚna_value_for_dtype)Útake_nd)ÚarrayÚ ensure_wrapped_if_datetimelikeÚ extract_array)Úvalidate_indices)Ú NumpySorterÚNumpyValueArrayLike)Ú CategoricalÚIndexÚSeries)ÚBaseMaskedArrayÚExtensionArrayr z
|
np.ndarray)ÚvaluesÚreturnc C sD t | tst| dd} t| jr.tt | ¡S t | jtr^t d| } | j
|
sTt | j S t | ¡S t | jrxt d| } | jS t| jr´t | tjrt | ¡ d¡S t | ¡jdddS nzt| jrÈt | ¡S t| jrð| jjdkræt| S t | ¡S t| jrt tj| S t| jr.| d ¡}t tj|}|S tj| td
|
} t| S ) a
|
routine to ensure that our data is of the correct
|
input dtype for lower-level routines
|
|
This will coerce:
|
- ints -> int64
|
- uint -> uint64
|
- bool -> uint8
|
- datetimelike -> i8
|
- datetime64tz -> i8 (in local tz)
|
- categorical -> codes
|
|
Parameters
|
----------
|
values : np.ndarray or ExtensionArray
|
|
Returns
|
-------
|
np.ndarray
|
T©Ú extract_numpyr< r9 Úuint8F©Úcopy)é é é Úi8©Údtype)Ú
|
isinstancer- r5 r" rJ r ÚnpÚasarrayr' r Z_hasnaÚ _ensure_dataÚ_datar Úcodesr ÚndarrayÚviewÚastyper r Úitemsizer r r% Úobject)r> Znpvalues© rV úMd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/algorithms.pyrN i s<
|
|
|
|
|
|
|
|
|
|
|
|
|
rN r r )r> rJ Úoriginalr? c C sN t | tr| j|kr| S t |tjs<| ¡ }|j| |d} n| j|dd} | S )zç
|
reverse of _ensure_data
|
|
Parameters
|
----------
|
values : np.ndarray or ExtensionArray
|
dtype : np.dtype or ExtensionDtype
|
original : AnyArrayLike
|
|
Returns
|
-------
|
ExtensionArray or np.ndarray
|
rI FrC )rK r+ rJ rL Zconstruct_array_typeZ_from_sequencerS )r> rJ rX ÚclsrV rV rW Ú_reconstruct_data· s rZ )r? c C sH t | sDtj| dd}|dkr:t| tr0t| } t| } n
|
t | ¡} | S )z5
|
ensure that we are arraylike if not already
|
F©Zskipna)ÚmixedÚstringú mixed-integer) r r
|
Ú infer_dtyperK ÚtupleÚlistr rL rM )r> ÚinferredrV rV rW Ú_ensure_arraylikeØ s
|
|
|
rc )Z
|
complex128Z complex64Úfloat64Úfloat32Zuint64Zuint32Zuint16rB Úint64Úint32Úint16Úint8r] rU ©r> c C s t | } t| }t| }|| fS )z
|
Parameters
|
----------
|
values : np.ndarray
|
|
Returns
|
-------
|
htable : HashTable subclass
|
values : ndarray
|
)rN Ú_check_object_for_stringsÚ _hashtables)r> Úndtyper rV rV rW Ú_get_hashtable_algoú s rn Ústrc C s* | j j}|dkr&tj| dddkr&d}|S )z
|
Check if we can use string hashtable instead of object hashtable.
|
|
Parameters
|
----------
|
values : ndarray
|
|
Returns
|
-------
|
str
|
rU Fr[ )r] r] )rJ Únamer
|
r_ )r> rm rV rV rW rk s
|
rk c C s t | S )a
|
|
Return unique values based on a hash table.
|
|
Uniques are returned in order of appearance. This does NOT sort.
|
|
Significantly faster than numpy.unique for long enough sequences.
|
Includes NA values.
|
|
Parameters
|
----------
|
values : 1d array-like
|
|
Returns
|
-------
|
numpy.ndarray or ExtensionArray
|
|
The return can be:
|
|
* Index : when the input is an Index
|
* Categorical : when the input is a Categorical dtype
|
* ndarray : when the input is a Series/ndarray
|
|
Return numpy.ndarray or ExtensionArray.
|
|
See Also
|
--------
|
Index.unique : Return unique values from an Index.
|
Series.unique : Return unique values of Series object.
|
|
Examples
|
--------
|
>>> pd.unique(pd.Series([2, 1, 3, 3]))
|
array([2, 1, 3])
|
|
>>> pd.unique(pd.Series([2] + [1] * 5))
|
array([2, 1])
|
|
>>> pd.unique(pd.Series([pd.Timestamp("20160101"), pd.Timestamp("20160101")]))
|
array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]')
|
|
>>> pd.unique(
|
... pd.Series(
|
... [
|
... pd.Timestamp("20160101", tz="US/Eastern"),
|
... pd.Timestamp("20160101", tz="US/Eastern"),
|
... ]
|
... )
|
... )
|
<DatetimeArray>
|
['2016-01-01 00:00:00-05:00']
|
Length: 1, dtype: datetime64[ns, US/Eastern]
|
|
>>> pd.unique(
|
... pd.Index(
|
... [
|
... pd.Timestamp("20160101", tz="US/Eastern"),
|
... pd.Timestamp("20160101", tz="US/Eastern"),
|
... ]
|
... )
|
... )
|
DatetimeIndex(['2016-01-01 00:00:00-05:00'],
|
dtype='datetime64[ns, US/Eastern]',
|
freq=None)
|
|
>>> pd.unique(list("baabc"))
|
array(['b', 'a', 'c'], dtype=object)
|
|
An unordered Categorical will return categories in the
|
order of appearance.
|
|
>>> pd.unique(pd.Series(pd.Categorical(list("baabc"))))
|
['b', 'a', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
|
>>> pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc"))))
|
['b', 'a', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
|
An ordered Categorical preserves the category ordering.
|
|
>>> pd.unique(
|
... pd.Series(
|
... pd.Categorical(list("baabc"), categories=list("abc"), ordered=True)
|
... )
|
... )
|
['b', 'a', 'c']
|
Categories (3, object): ['a' < 'b' < 'c']
|
|
An array of tuples
|
|
>>> pd.unique([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")])
|
array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object)
|
)Úunique_with_maskrj rV rV rW Úunique' s ^rr Úintc C s8 t | dkrdS t| } t | ¡ d¡¡dk ¡ }|S )aH
|
Return the number of unique values for integer array-likes.
|
|
Significantly faster than pandas.unique for long enough sequences.
|
No checks are done to ensure input is integral.
|
|
Parameters
|
----------
|
values : 1d array-like
|
|
Returns
|
-------
|
int : The number of unique values in ``values``
|
r Úintp)ÚlenrN rL ZbincountZravelrS Úsum)r> ÚresultrV rV rW Ú nunique_ints s
|
rx z npt.NDArray[np.bool_] | None©Úmaskc C s t | } t| jr| ¡ S | }t| \}} |t| }|dkrZ| | ¡}t||j|}|S |j| |d\}}t||j|}|dk st|| d¡fS dS )z?See algorithms.unique for docs. Takes a mask for masked arrays.Nry Úbool) rc r rJ rr rn ru rZ ÚAssertionErrorrS )r> rz rX r ÚtableÚuniquesrV rV rW rq s
|
|
rq znpt.NDArray[np.bool_])Úcompsr> r? c C sÚ t | s tdt| j dt |s<tdt|j dt|ttttj fst
|
|}t |}t |dkrªt |rªt| sªt|}n$t|trt |¡}nt|ddd}t | }t|dd}t|tj sÔ| |¡S t|jrìt| |¡S t|jrt|jstj|jtdS t|jr0t|| t ¡S t|jt rTtt |¡t |¡S t |dkrt |d krt|st | ¡ rd
|
d }ntj!}n6t "|j|jgg ¡}|j|d d }|j|d d }t#j$}|||S )zÂ
|
Compute the isin boolean array.
|
|
Parameters
|
----------
|
comps : array-like
|
values : array-like
|
|
Returns
|
-------
|
ndarray[bool]
|
Same length as `comps`.
|
zIonly list-like objects are allowed to be passed to isin(), you passed a [ú]r T)rA Z extract_ranger@ rI i@B é c S s t t | |¡t | ¡¡S )N)rL Ú
|
logical_orÚin1dÚisnan)ÚcÚvrV rV rW Úf s zisin.<locals>.fFrC )%r Ú TypeErrorÚtypeÚ__name__rK r, r. r+ rL rQ ra rc ru r! r$ r r- r3 r5 Úisinr% rJ Úpd_arrayr" ÚzerosÚshaper{ rS rU r( rM r0 Úanyr Zfind_common_typeÚhtableZismember)r r> Z orig_valuesZ comps_arrayr ÚcommonrV rV rW r º s^ ÿÿ
|
ÿþý
|
|
|
|
|
ÿ
|
þý
|
r Tr{ z
|
int | NonerU z'tuple[npt.NDArray[np.intp], np.ndarray])r> Úuse_na_sentinelÚ size_hintÚna_valuerz r? c
|
C sf | }| j jdkrt}t| \}} ||p,t| }|j| d|||d\}} t||j |}t| } | |fS )a(
|
Factorize a numpy array to codes and uniques.
|
|
This doesn't do any coercion of types or unboxing before factorization.
|
|
Parameters
|
----------
|
values : ndarray
|
use_na_sentinel : bool, default True
|
If True, the sentinel -1 will be used for NaN values. If False,
|
NaN values will be encoded as non-negative integers and will not drop the
|
NaN from the uniques of the values.
|
size_hint : int, optional
|
Passed through to the hashtable's 'get_labels' method
|
na_value : object, optional
|
A value in `values` to consider missing. Note: only use this
|
parameter when you know that you don't have any values pandas would
|
consider missing in the array (NaN for float data, iNaT for
|
datetimes, etc.).
|
mask : ndarray[bool], optional
|
If not None, the mask is used as indicator for missing values
|
(True = missing, False = valid) instead of `na_value` or
|
condition "val != val".
|
|
Returns
|
-------
|
codes : ndarray[np.intp]
|
uniques : ndarray
|
)ÚmÚMéÿÿÿÿ)Z na_sentinelr rz Z ignore_na)rJ Úkindr rn ru Ú factorizerZ r )
|
r> r r r rz rX Ú
|
hash_klassr} r~ rP rV rV rW Úfactorize_array s $ û
|
r z values : sequence
|
A 1-D sequence. Sequences that aren't pandas objects are
|
coerced to ndarrays before factorization.
|
zt sort : bool, default False
|
Sort `uniques` and shuffle `codes` to maintain the
|
relationship.
|
zG size_hint : int, optional
|
Hint to the hashtable sizer.
|
)r> Úsortr Fz%tuple[np.ndarray, np.ndarray | Index])r r r r? c C s t | ttfr | j||dS t| } | }t | ttfrX| jdk rX| j|d\}}||fS t | tj sv| j|d\}}nTt
|
| ¡} |s¸t | r¸t | }| ¡ r¸t| jdd}t ||| ¡} t| ||d\}}|rðt|dkrðt|||d dd
|
\}}t||j|}||fS ) aé
|
Encode the object as an enumerated type or categorical variable.
|
|
This method is useful for obtaining a numeric representation of an
|
array when all that matters is identifying distinct values. `factorize`
|
is available as both a top-level function :func:`pandas.factorize`,
|
and as a method :meth:`Series.factorize` and :meth:`Index.factorize`.
|
|
Parameters
|
----------
|
{values}{sort}
|
use_na_sentinel : bool, default True
|
If True, the sentinel -1 will be used for NaN values. If False,
|
NaN values will be encoded as non-negative integers and will not drop the
|
NaN from the uniques of the values.
|
|
.. versionadded:: 1.5.0
|
{size_hint}
|
Returns
|
-------
|
codes : ndarray
|
An integer ndarray that's an indexer into `uniques`.
|
``uniques.take(codes)`` will have the same values as `values`.
|
uniques : ndarray, Index, or Categorical
|
The unique valid values. When `values` is Categorical, `uniques`
|
is a Categorical. When `values` is some other pandas object, an
|
`Index` is returned. Otherwise, a 1-D ndarray is returned.
|
|
.. note::
|
|
Even if there's a missing value in `values`, `uniques` will
|
*not* contain an entry for it.
|
|
See Also
|
--------
|
cut : Discretize continuous-valued array.
|
unique : Find the unique value in an array.
|
|
Notes
|
-----
|
Reference :ref:`the user guide <reshaping.factorize>` for more examples.
|
|
Examples
|
--------
|
These examples all show factorize as a top-level method like
|
``pd.factorize(values)``. The results are identical for methods like
|
:meth:`Series.factorize`.
|
|
>>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'])
|
>>> codes
|
array([0, 0, 1, 2, 0])
|
>>> uniques
|
array(['b', 'a', 'c'], dtype=object)
|
|
With ``sort=True``, the `uniques` will be sorted, and `codes` will be
|
shuffled so that the relationship is the maintained.
|
|
>>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=True)
|
>>> codes
|
array([1, 1, 0, 2, 1])
|
>>> uniques
|
array(['a', 'b', 'c'], dtype=object)
|
|
When ``use_na_sentinel=True`` (the default), missing values are indicated in
|
the `codes` with the sentinel value ``-1`` and missing values are not
|
included in `uniques`.
|
|
>>> codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b'])
|
>>> codes
|
array([ 0, -1, 1, 2, 0])
|
>>> uniques
|
array(['b', 'a', 'c'], dtype=object)
|
|
Thus far, we've only factorized lists (which are internally coerced to
|
NumPy arrays). When factorizing pandas objects, the type of `uniques`
|
will differ. For Categoricals, a `Categorical` is returned.
|
|
>>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c'])
|
>>> codes, uniques = pd.factorize(cat)
|
>>> codes
|
array([0, 0, 1])
|
>>> uniques
|
['a', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
|
Notice that ``'b'`` is in ``uniques.categories``, despite not being
|
present in ``cat.values``.
|
|
For all other pandas objects, an Index of the appropriate type is
|
returned.
|
|
>>> cat = pd.Series(['a', 'a', 'c'])
|
>>> codes, uniques = pd.factorize(cat)
|
>>> codes
|
array([0, 0, 1])
|
>>> uniques
|
Index(['a', 'c'], dtype='object')
|
|
If NaN is in the values, and we want to include NaN in the uniques of the
|
values, it can be achieved by setting ``use_na_sentinel=False``.
|
|
>>> values = np.array([1, 2, 1, np.nan])
|
>>> codes, uniques = pd.factorize(values) # default: use_na_sentinel=True
|
>>> codes
|
array([ 0, 1, 0, -1])
|
>>> uniques
|
array([1., 2.])
|
|
>>> codes, uniques = pd.factorize(values, use_na_sentinel=False)
|
>>> codes
|
array([0, 1, 0, 2])
|
>>> uniques
|
array([ 1., 2., nan])
|
)r r N)r )r F)Úcompat)r r r T)r Ú assume_uniqueÚverify)rK r, r. r rc r* r/ ÚfreqrL rQ rM r" r0 r r1 rJ Úwherer ru Ú safe_sortrZ ) r> r r r rX rP r~ Z null_maskr rV rV rW r S sD ÿþ
|
ý
|
û
|
r r; )r Ú ascendingÚ normalizeÚdropnar? c
|
C s ddl m}m} t| dd}|r$dnd} |dk ròddlm}
|
|| dd } z|
|
| |d
|
d } W n, tk
|
r } ztd | W 5 d} ~ X Y nX | j|d } | | _| | j
|
¡ } | j d¡| _ | ¡ } |rÞ| j dk ¡ rÞ| jdd
} t t| g¡}nt| r@|| dd j j|d } | | _|| j _| j }t|tjsöt |¡}n¶t| trtt| j}|| | dj||d ¡ } | j | j _ | j }npt | } t | |\}}|j tj!kr¶| tj"¡}||}|j t#krà|j t$krà| t$¡}||_|||| dd} |r| j%|d} |r| | &¡ } | S )aK
|
Compute a histogram of the counts of non-null values.
|
|
Parameters
|
----------
|
values : ndarray (1-d)
|
sort : bool, default True
|
Sort by values
|
ascending : bool, default False
|
Sort in ascending order
|
normalize: bool, default False
|
If True then compute a relative histogram
|
bins : integer, optional
|
Rather than count values, group them into half-open bins,
|
convenience for pd.cut, only works with numeric data
|
dropna : bool, default True
|
Don't include counts of NaN
|
|
Returns
|
-------
|
Series
|
r )r: r; rp NZ
|
proportionÚcount)ÚcutFrC T)Zinclude_lowestz+bins argument only works with numeric data.©r¥ Úinterval)Úindexrp )Úlevelr¥ )rª rp rD )r£ )'Úpandasr: r; ÚgetattrZpandas.core.reshape.tiler§ r Ú value_countsrp rª ZnotnarS Z
|
sort_indexÚ_valuesÚallZilocrL r3 ru r rK rQ rM r- ra ÚrangeZnlevelsÚgroupbyÚsizeÚnamesrc Úvalue_counts_arraylikerJ Úfloat16re r{ rU Z sort_valuesrv )r> r r£ r¤ Zbinsr¥ r: r; Z
|
index_namerp r§ ÚiiÚerrrw ÚcountsÚlevelsÚkeysÚidxrV rV rW r® s`
|
ÿÿ
|
|
r® z'tuple[ArrayLike, npt.NDArray[np.int64]])r> r¥ rz r? c C s^ | }t | } tj| ||d\}}t|jrH|rH|tk}|| || }}t||j|}||fS )zÓ
|
Parameters
|
----------
|
values : np.ndarray
|
dropna : bool
|
mask : np.ndarray[bool] or None, default None
|
|
Returns
|
-------
|
uniques : np.ndarray
|
counts : np.ndarray[np.int64]
|
ry )rN r Z value_countr% rJ r rZ )r> r¥ rz rX r» r¹ Zres_keysrV rV rW rµ s
|
rµ Úfirstz!Literal[('first', 'last', False)])r> Úkeepr? c C sJ t | dr4t| jtr4td| } tj| j|| jdS t | } tj| |dS )a
|
Return boolean ndarray denoting duplicate values.
|
|
Parameters
|
----------
|
values : nd.array, ExtensionArray or Series
|
Array over which to check for duplicate values.
|
keep : {'first', 'last', False}, default 'first'
|
- ``first`` : Mark duplicates as ``True`` except for the first
|
occurrence.
|
- ``last`` : Mark duplicates as ``True`` except for the last
|
occurrence.
|
- False : Mark all duplicates as ``True``.
|
|
Returns
|
-------
|
duplicated : ndarray[bool]
|
rJ r< )r¾ rz )r¾ )
|
ÚhasattrrK rJ r' r r Ú
|
duplicatedrO Z_maskrN )r> r¾ rV rV rW rÀ ª s
|
|
rÀ c
|
C s¦ t | } | }t| jr4t| } td| } | j|dS t| } tj| ||d}zt
|
|¡}W n8 t k
|
r } zt j d| t d W 5 d}~X Y nX t||j|}|S )a
|
Returns the mode(s) of an array.
|
|
Parameters
|
----------
|
values : array-like
|
Array over which to check for duplicate values.
|
dropna : bool, default True
|
Don't consider counts of NaN/NaT.
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
r= r¨ )r¥ rz zUnable to sort modes: )Ú
|
stacklevelN)rc r% rJ r4 r Ú_moderN r ÚmoderL r r ÚwarningsÚwarnr rZ )r> r¥ rz rX Znpresultr¸ rw rV rV rW rÃ Ç s"
|
|
þrà Úaverager¾ r znpt.NDArray[np.float64])r> ÚaxisÚmethodÚ na_optionr£ Úpctr? c C sd t | j}t| } | jdkr4tj| |||||d}n,| jdkrXtj| ||||||d}ntd|S )a÷
|
Rank the values along a given axis.
|
|
Parameters
|
----------
|
values : np.ndarray or ExtensionArray
|
Array whose values will be ranked. The number of dimensions in this
|
array must not exceed 2.
|
axis : int, default 0
|
Axis over which to perform rankings.
|
method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
|
The method by which tiebreaks are broken during the ranking.
|
na_option : {'keep', 'top'}, default 'keep'
|
The method by which NaNs are placed in the ranking.
|
- ``keep``: rank each NaN value with a NaN ranking
|
- ``top``: replace each NaN with either +/- inf so that they
|
there are ranked at the top
|
ascending : bool, default True
|
Whether or not the elements should be ranked in ascending order.
|
pct : bool, default False
|
Whether or not to the display the returned rankings in integer form
|
(e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1).
|
é )Úis_datetimelikeÚ ties_methodr£ rÉ rÊ rE )rÇ rÌ rÍ r£ rÉ rÊ z&Array with ndim > 2 are not supported.)r% rJ rN Úndimr Zrank_1dZrank_2dr )r> rÇ rÈ rÉ r£ rÊ rÌ ZranksrV rV rW Úrankð s.
|
|
ú
|
ù
|
rÏ znpt.NDArray[np.int64]zint | npt.NDArray[np.int64])ÚarrÚbÚarr_maskÚb_maskr? c C sb t || j¡}|dk r&t || j¡}nd}|dk rJ|dk rJt ||B ¡}nB|dk r^t |¡}n.|dk rrt |¡}nt j| jtd}| d¡ tj}t }|dk} |dk }
|
|
|
¡ sÄ|| | k|@
|
¡ } n`|
|
|
¡ sâ|| | k |@
|
¡ } nB||| | | k || @
|
¡ p"|||
|
| |
|
k||
|
@
|
¡ } | r2t d| | } |dk sN|dk r^t | | t ¡ | S )aÒ
|
Perform array addition that checks for underflow and overflow.
|
|
Performs the addition of an int64 array and an int64 integer (or array)
|
but checks that they do not result in overflow first. For elements that
|
are indicated to be NaN, whether or not there is overflow for that element
|
is automatically ignored.
|
|
Parameters
|
----------
|
arr : np.ndarray[int64] addend.
|
b : array or scalar addend.
|
arr_mask : np.ndarray[bool] or None, default None
|
array indicating which elements to exclude from checking
|
b_mask : np.ndarray[bool] or None, default None
|
array or scalar indicating which element(s) to exclude from checking
|
|
Returns
|
-------
|
sum : An array for elements x + b for each element x in arr if b is
|
a scalar or an array for elements x + y for each element pair
|
(x, y) in (arr, b).
|
|
Raises
|
------
|
OverflowError if any x + y exceeds the maximum or minimum int64 value.
|
NrI Tr zOverflow in int64 addition) rL Z broadcast_tor Z logical_notÚemptyr{ Úfillr
|
Úi8maxr r Ú OverflowErrorÚputmask) rÐ rÑ rÒ rÓ Zb2Zb2_maskZnot_nanrÖ Zi8minZmask1Zmask2Zto_raiserw rV rV rW Úchecked_add_with_arr+ s: #
|
"ÿrÙ r )ÚindicesrÇ Ú
|
allow_fillc C s\ t | st | ¡} tj|tjd}|rJt|| j| t| ||d|d}n| j||d}|S )aÓ
|
Take elements from an array.
|
|
Parameters
|
----------
|
arr : array-like or scalar value
|
Non array-likes (sequences/scalars without a dtype) are coerced
|
to an ndarray.
|
indices : sequence of int or one-dimensional np.ndarray of int
|
Indices to be taken.
|
axis : int, default 0
|
The axis over which to select values.
|
allow_fill : bool, default False
|
How to handle negative values in `indices`.
|
|
* False: negative values in `indices` indicate positional indices
|
from the right (the default). This is similar to :func:`numpy.take`.
|
|
* True: negative values in `indices` indicate
|
missing values. These values are set to `fill_value`. Any other
|
negative values raise a ``ValueError``.
|
|
fill_value : any, optional
|
Fill value to use for NA-indices when `allow_fill` is True.
|
This may be ``None``, in which case the default NA value for
|
the type (``self.dtype.na_value``) is used.
|
|
For multi-dimensional `arr`, each *element* is filled with
|
`fill_value`.
|
|
Returns
|
-------
|
ndarray or ExtensionArray
|
Same type as the input.
|
|
Raises
|
------
|
IndexError
|
When `indices` is out of bounds for the array.
|
ValueError
|
When the indexer contains negative values other than ``-1``
|
and `allow_fill` is True.
|
|
Notes
|
-----
|
When `allow_fill` is False, `indices` may be whatever dimensionality
|
is accepted by NumPy for `arr`.
|
|
When `allow_fill` is True, `indices` should be 1-D.
|
|
See Also
|
--------
|
numpy.take : Take elements from an array along an axis.
|
|
Examples
|
--------
|
>>> import pandas as pd
|
|
With the default ``allow_fill=False``, negative numbers indicate
|
positional indices from the right.
|
|
>>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1])
|
array([10, 10, 30])
|
|
Setting ``allow_fill=True`` will place `fill_value` in those positions.
|
|
>>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True)
|
array([10., 10., nan])
|
|
>>> pd.api.extensions.take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True,
|
... fill_value=-10)
|
array([ 10, 10, -10])
|
rI T)rÇ rÛ Ú
|
fill_value)rÇ )r rL rM rt r6 r r2 Útake)rÐ rÚ rÇ rÛ rÜ rw rV rV rW rÝ s P
|
ÿrÝ Úleftz$NumpyValueArrayLike | ExtensionArrayzLiteral[('left', 'right')]r7 z npt.NDArray[np.intp] | np.intp)rÐ ÚvalueÚsideÚsorterr? c C sÒ |dk rt |}t| tjrºt| jrºt|s6t|rºt | jj¡}t |rXt
|
|g¡nt
|
|¡}||j k ¡ r||j k ¡ r| j}n|j}t |r¦tt| |¡}qÂttt||d}nt| } | j|||dS )aû
|
Find indices where elements should be inserted to maintain order.
|
|
Find the indices into a sorted array `arr` (a) such that, if the
|
corresponding elements in `value` were inserted before the indices,
|
the order of `arr` would be preserved.
|
|
Assuming that `arr` is sorted:
|
|
====== ================================
|
`side` returned index `i` satisfies
|
====== ================================
|
left ``arr[i-1] < value <= self[i]``
|
right ``arr[i-1] <= value < self[i]``
|
====== ================================
|
|
Parameters
|
----------
|
arr: np.ndarray, ExtensionArray, Series
|
Input array. If `sorter` is None, then it must be sorted in
|
ascending order, otherwise `sorter` must be an array of indices
|
that sort it.
|
value : array-like or scalar
|
Values to insert into `arr`.
|
side : {'left', 'right'}, optional
|
If 'left', the index of the first suitable location found is given.
|
If 'right', return the last such index. If there is no suitable
|
index, return either 0 or N (where N is the length of `self`).
|
sorter : 1-D array-like, optional
|
Optional array of integer indices that sort array a into ascending
|
order. They are typically the result of argsort.
|
|
Returns
|
-------
|
array of ints or int
|
If value is array-like, array of insertion points.
|
If value is scalar, a single integer.
|
|
See Also
|
--------
|
numpy.searchsorted : Similar method from NumPy.
|
NrI )rà rá )r rK rL rQ r rJ r Úiinfor r# r3 Úminr° Úmaxr rs r r r4 Ú searchsorted)rÐ rß rà rá râ Z value_arrrJ rV rV rW rå ò s( 0
|
ÿþýý rå rd re rf rg rh ri )ÚnrÇ c C sT t |}tj}| j}t|}|r(tj}ntj}t|t rF|
|
¡ } | j}t|tjs¬t | d|j dr|dkrt dt| j d| || | |¡S tt| j dd}t| jrÔtj}| d¡} t}d}n2|ràtj}n&t|r| jjd kr tj}ntj}| j}|d
|
kr"| d d
|
¡} t |¡}tj | j |d } t d gd }
|
|dkr^t d |nt |d |
|
|< || t |
|
< | jjt krt!j"| | |||d nt d gd } |dkr¾t |d nt d || |< t | } t d gd } |dkrøt d | n
|
t | d | |< t | }|| | | | | | < |r6| d¡} |d
|
krP| d d
df } | S )aQ
|
difference of n between self,
|
analogous to s-s.shift(n)
|
|
Parameters
|
----------
|
arr : ndarray or ExtensionArray
|
n : int
|
number of periods
|
axis : {0, 1}
|
axis to shift on
|
stacklevel : int, default 3
|
The stacklevel for the lost dtype warning.
|
|
Returns
|
-------
|
shifted
|
Ú__r z cannot diff z on axis=zK has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.FrH T)ri rh rË r rI NrE )Z datetimelikeztimedelta64[ns])#rs rL ÚnanrJ r ÚoperatorÚxorÚsubrK r) Zto_numpyr¿ r Ú
|
ValueErrorr Úshiftr r% rf rR r Zobject_r rp re rd rÎ ZreshaperÔ r Úslicer` Ú _diff_specialr Zdiff_2d)rÐ ræ rÇ ÚnarJ Zis_boolÚopZ is_timedeltaZ orig_ndimZout_arrZ
|
na_indexerZ _res_indexerZ res_indexerZ _lag_indexerZ lag_indexerrV rV rW ÚdiffM sh
|
ÿ
|
|
|
|
|
" "&
|
|
rò z.AnyArrayLike | tuple[AnyArrayLike, np.ndarray])r r r r? c C s t | stdt| s2t| \}}tj| |d} d}t| sZtj| dddkrZt | }nRz|
|
¡ }| |¡}W n: tk
|
rª | j rt | d trt| }nt | }Y nX |dkr¸|S t |sÈtdtt |¡}|sött| t| ksötd |dkr0t| \} } | t| }
|
|
|
| ¡ t|
|
|¡}|rt|
|
¡ } t| |d
|
d } |rn|t| k |t| kB } nd} njtjt|tjd}| |t t|¡¡ |j |d d } |rÞ|d
|
k} |rÞ| |t| k B |t| kB } |rü| dk rüt | | d
|
¡ |t| fS )a
|
Sort ``values`` and reorder corresponding ``codes``.
|
|
``values`` should be unique if ``codes`` is not None.
|
Safe for use with mixed types (int, str), orders ints before strs.
|
|
Parameters
|
----------
|
values : list-like
|
Sequence; must be unique if ``codes`` is not None.
|
codes : list_like, optional
|
Indices to ``values``. All out of bound indices are treated as
|
"not found" and will be masked with ``-1``.
|
use_na_sentinel : bool, default True
|
If True, the sentinel -1 will be used for NaN values. If False,
|
NaN values will be encoded as non-negative integers and will not drop the
|
NaN from the uniques of the values.
|
assume_unique : bool, default False
|
When True, ``values`` are assumed to be unique, which can speed up
|
the calculation. Ignored when ``codes`` is None.
|
verify : bool, default True
|
Check if codes are out of bound for the values and put out of bound
|
codes equal to ``-1``. If ``verify=False``, it is assumed there
|
are no out of bound codes. Ignored when ``codes`` is None.
|
|
Returns
|
-------
|
ordered : AnyArrayLike
|
Sorted ``values``
|
new_codes : ndarray
|
Reordered ``codes``; returned when ``codes`` is not None.
|
|
Raises
|
------
|
TypeError
|
* If ``values`` is not list-like or if ``codes`` is neither None
|
nor list-like
|
* If ``values`` cannot be sorted
|
ValueError
|
* If ``codes`` is not None and ``values`` contain duplicates.
|
zFOnly list-like objects are allowed to be passed to safe_sort as valuesrI NFr[ r^ r zMOnly list-like objects or None are allowed to be passed to safe_sort as codesz,values should be unique if codes is not Noner ©rÜ Úwrap)rà ) r r r r rL rM r r
|
r_ Ú _sort_mixedÚargsortrÝ r³ rK r` Ú _sort_tuplesr ru rr rì rn Z map_locationsÚlookupr2 rÔ Úint_ÚputZarangerØ )r> rP r r r rJ Ú_rá Zorderedr ÚtZorder2Z new_codesrz Zreverse_indexerrV rV rW r¢ ¾ sd 0ÿ ÿþ
|
|
ÿ
|
|
r¢ c
|
C s¢ t jdd | D td}t jdd | D td}| | @ }t | | ¡}t | | ¡}| ¡ d |¡}| ¡ d |¡}| ¡ d }t |||g¡} | | ¡S )z3order ints before strings before nulls in 1d arraysc S s g | ]}t |tqS rV )rK ro ©Ú.0ÚxrV rV rW Ú
|
<listcomp>C s z _sort_mixed.<locals>.<listcomp>rI c S s g | ] }t |qS rV )r0 rý rV rV rW r D s r )rL r3 r{ rö ZnonzerorÝ Z concatenate)
|
r> Zstr_posZnull_posÚnum_posZ str_argsortZ num_argsortZstr_locsZnum_locsZ null_locsZlocsrV rV rW rõ A s rõ c C s: ddl m} ddlm} || d\}}||dd}| | S )a
|
Convert array of tuples (1d) to array of arrays (2d).
|
We need to keep the columns separately as they contain different types and
|
nans (can't use `np.sort` as it may fail when str and nan are mixed in a
|
column as types cannot be compared).
|
r )Ú to_arrays)Úlexsort_indexerNT)Zorders)Z"pandas.core.internals.constructionr Zpandas.core.sortingr )r> r r Zarraysrû ZindexerrV rV rW r÷ P s
|
r÷ zArrayLike | Index)ÚlvalsÚrvalsr? c C sÌ ddl m} t| dd}t|dd}|j|dd\}}t |j|j¡}|||jddd}t| t r|t|t r||
|
|¡ ¡ }n8t| t r| j } t|t r|j }t t| |g}t|}| |¡j}t ||¡S )aù
|
Extracts the union from lvals and rvals with respect to duplicates and nans in
|
both arrays.
|
|
Parameters
|
----------
|
lvals: np.ndarray or ExtensionArray
|
left values which is ordered in front.
|
rvals: np.ndarray or ExtensionArray
|
right values ordered after lvals.
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
Containing the unsorted union of both arrays.
|
|
Notes
|
-----
|
Caller is responsible for ensuring lvals.dtype == rvals.dtype.
|
r )r; Fr¨ ró rs )rª rJ rD )r¬ r; r® ZalignrL Úmaximumr> rª rK r- Úappendrr r, r¯ r& r4 ZreindexÚrepeat)r r r; Zl_countZr_countZ final_countZ unique_valsZrepeatsrV rV rW Úunion_with_duplicates_ s
|
|
r )N)TNNN)FTN)TFFNT)N)r½ )TN)r rÆ r¾ TF)NN)r FN)rÞ N)r )NTFT)~Ú__doc__Ú
|
__future__r ré Útextwrapr Útypingr r r rÄ ÚnumpyrL Z pandas._libsr r r r r
|
Zpandas._typingr r r r r r Zpandas.util._decoratorsr Zpandas.util._exceptionsr Zpandas.core.dtypes.castr r Zpandas.core.dtypes.commonr r r r r r r r r r r r r! r" r# r$ r% Zpandas.core.dtypes.concatr& Zpandas.core.dtypes.dtypesr' r( r) Zpandas.core.dtypes.genericr* r+ r, r- r. r/ Zpandas.core.dtypes.missingr0 r1 Z pandas.core.array_algos.taker2 Zpandas.core.constructionr3 r r4 r5 Zpandas.core.indexersr6 r7 r8 r¬ r9 r: r; Zpandas.core.arraysr< r= rN rZ rc ZComplex128HashTableZComplex64HashTableZFloat64HashTableZFloat32HashTableZUInt64HashTableZUInt32HashTableZUInt16HashTableZUInt8HashTableZInt64HashTableZInt32HashTableZInt16HashTableZ Int8HashTableZStringHashTableZPyObjectHashTablerl rn rk rr rx rq Zunique1dr r r r® rµ rÀ rà rÏ rÙ rÝ rå rï rò r¢ rõ r÷ r rV rV rV rW Ú<module> sÚ L N!òa] û>ÿÿÿñ ü 9 úm ÿ ÿ ÿ+ ú > üd ûi üXs û
|
