Ë
|
nñúh× ã óR d Z ddlmZ ddlZddlZddlmZ ddlmZm Z m
|
Z
|
ddl Z ddl Z ddlmZmZmZmZ ddlmZmZmZmZmZmZ ddlm Z 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/m0Z0m1Z1 dd l2m3Z3 dd l4m5Z5m6Z6m7Z7m8Z8 ddl9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z? ddl@mAZAmBZB ddlCmDZD ddlEmFZGmHZHmIZI ddlJmKZK er ddlmLZLmMZMmNZN ddlOmPZPmQZQmRZR ddlSmTZTmUZU d6dZV d7dZWd8dZXej² ej´ ej¶ ej¸ ejº ej¼ ej¾ ejÀ ej ejÄ ejÆ ejÈ ejÊ ejÌ dZgd9dZhd:dZid Zjd;d Zkd<d=d ZlejZmd Znd>d Zo d? d@d!Zp e ed"« ed#« ed$« ¬%« dA dBd&« Zq dC dDd'Zr dC dDd(Zs d< dEd)Zt dF dGd*Zu dH dId+Zv dJ dKd,Zw dL dMd-Zx dN dOd.Zyh d/£ZzdPdQd0Z{ dR dSd1Z|dTd2Z}dUd3Z~ dVd4Z dW dXd5Zy)Yzl
|
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Únp_find_common_type)Úensure_float64Ú ensure_objectÚensure_platform_intÚ is_array_likeÚ is_bool_dtypeÚis_complex_dtypeÚ is_dict_likeÚis_extension_array_dtypeÚis_float_dtypeÚ
|
is_integerÚis_integer_dtypeÚ is_list_likeÚis_object_dtypeÚis_signed_integer_dtypeÚneeds_i8_conversion)Ú concat_compat)ÚBaseMaskedDtypeÚCategoricalDtypeÚExtensionDtypeÚ NumpyEADtype)ÚABCDatetimeArrayÚABCExtensionArrayÚABCIndexÚ ABCMultiIndexÚ ABCSeriesÚABCTimedeltaArray)ÚisnaÚna_value_for_dtype)Útake_nd)ÚarrayÚ ensure_wrapped_if_datetimelikeÚ extract_array)Úvalidate_indices)ÚListLikeÚ NumpySorterÚNumpyValueArrayLike)Ú CategoricalÚIndexÚSeries)ÚBaseMaskedArrayÚExtensionArrayc óÌ t | t « s t | d¬« } t | j « r t t j | « « S t | j t « rBt d| « } | j st | j « S t j | « S t | j t « rt d| « } | j S t | j « rdt | t j « r$t j | « j# d« S t j | « j% dd¬« S t' | j « rt j | « S t) | j « r8| j j* dv r t- | « S t j | « S t/ | j « rt t j | « S t1 | j « r-| j# d « }t t j |« }|S t j | t2 ¬
|
« } 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= r: Úuint8F©Úcopy)é é é Úi8©Údtype)Ú
|
isinstancer- r5 r" rJ r ÚnpÚasarrayr& r Ú_hasnaÚ _ensure_dataÚ_datar' Úcodesr ÚndarrayÚviewÚastyper r Úitemsizer r r$ Úobject)ÚvaluesÚnpvaluess úIH:\Change_password\venv_build\Lib\site-packages\pandas/core/algorithms.pyrO rO j s¸ ô, fmÔ ,ä v°TÔ:äv||Ô$Ü RZZ¨Ó /Ó0Ð0ä FLL¤/Ô 2äÐ'¨Ó0Ø}}ô § ¡ Ó-Ð -Üzz&Ó!Ð!ä FLLÔ"2Ô 3ô m VÓ,Ø||Ðä v||Ô $Ü fbjjÔ )ä::fÓ%×*Ñ*¨7Ó3Ð 3ô ::fÓ%×,Ñ,¨W¸5Ð,ÓAÐ Aä &,,Ô 'Üzz&Ó!Ð!ä Ô %ð <<× Ñ KÑ /ä! &Ó)Ð )Üzz&Ó!Ð!ä &,,Ô 'ÜBJJ Ó'Ð'ô
|
V\\Ô *Ø;;tÓ$Ü
|
|
HÓ-Øô ZZ¤fÔ -FÜ Ó Ð ó c óì t | t « r| j |k( r| S t |t j « s%|j « }|j | |¬« } | S | j |d¬« } | 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 Úconstruct_array_typeÚ_from_sequencerT )rW rJ ÚoriginalÚclss rY Ú_reconstruct_datar` ¸ sr ô &Ô+Ô,°· ± ÀÒ1Fà ä eRXXÔ &ð ×(Ñ(Ó*à×#Ñ# F°%Ð#Ó8ð
|
Mð u¨5 Ó1à MrZ c ób t | t t t t j
|
f« s|dk7 r't j | dt t « ¬« t j | d¬« }|dv r(t | t « r t | « } t | « } | S t j | « } | S )z5
|
ensure that we are arraylike if not already
|
ú isin-targetsz with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.©Ú
|
stacklevelF©Úskipna)ÚmixedÚstringú mixed-integer)rK r, r. r+ rL rR ÚwarningsÚwarnÚ FutureWarningr r Ú infer_dtypeÚtupleÚlistr rM )rW Ú func_nameÚinferreds rY Ú_ensure_arraylikerr Ù s ô fx¬Ô4EÄrÇzÁzÐ RÔ Sà Ò &ä MMØ +ð "ð "ô Ü+Ó-õ ô ?? 6°%Ô8Ø Ð;Ñ ;ä&¤%Ô(Ü f Ü<¸VÓDFð Mô ZZ Ó'FØ MrZ )Ú
|
complex128Ú complex64Úfloat64Úfloat32Úuint64Úuint32Úuint16rB Úint64Úint32Úint16Úint8rh rV c óH t | « } t | « }t | }|| fS )z
|
Parameters
|
----------
|
values : np.ndarray
|
|
Returns
|
-------
|
htable : HashTable subclass
|
values : ndarray
|
)rO Ú_check_object_for_stringsÚ _hashtables)rW Úndtyper s rY Ú_get_hashtable_algor s- ô &Ó !Fä & vÓ .FÜFÑ#IØ fÐ Ð rZ c ón | j j }|dk( rt j | d¬« rd}|S )z
|
Check if we can use string hashtable instead of object hashtable.
|
|
Parameters
|
----------
|
values : ndarray
|
|
Returns
|
-------
|
str
|
rV Fre rh )rJ Únamer Úis_string_array)rW r s rY r r s7 ð \\× Ñ FØ Òô × Ñ v¨eÕ 4Ø FØ MrZ c ó t | « S )a3
|
|
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(np.array(list("baabc"), dtype="O"))
|
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(pd.Series([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")]).values)
|
array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object)
|
)Úunique_with_mask)rW s rY Úuniquer 3 s ô| FÓ #Ð#rZ c óÀ t | « dk( ryt | « } t j | j « j d« « dk7 j « }|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)ÚlenrO rL ÚbincountÚravelrT Úsum)rW Úresults rY Ú nunique_intsr sO ô 6{aÒØÜ &Ó !Fäkk&,,.×/Ñ/°Ó7Ó8¸AÑ=× BÑ BÓ DFØ MrZ c ó t | d¬« } t | j t « r| j « S | }t | « \ }} |t | « « }|*|j | « }t ||j |« }|S |j | |¬« \ }}t ||j |« }|J ||j d« fS )z?See algorithms.unique for docs. Takes a mask for masked arrays.r ©rp ©ÚmaskÚbool) rr rK rJ r( r r r r` rT )rW r r^ r ÚtableÚuniquess rY r r « s¾ ä v°Ô :Fä&,,¤Ô/à}}Ð àHÜ+¨FÓ3ÑIvá c&kÓ "EØ |Ø,,vÓ&Ü# G¨X¯^©^¸XÓFØð V°$ Ó7 Ü# G¨X¯^©^¸XÓFØÐ Ð Ð Ø FÓ+Ð+Ð+rZ i@B c ó t | « s"t dt | « j d« t |« s"t dt |« j d« t |t
|
t t t j f« sUt |« }t |d¬« }t |« dkD rc|j j dv rKt | « s@t! |« }n4t |t" « rt j$ |« }nt' |dd¬« }t | d ¬« }t' |d¬
|
« }t |t j « s|j) |« S t+ |j « rt- |« j) |« S t+ |j « r:t/ |j « s%t j0 |j2 t4 ¬ « S t+ |j « r t) ||j7 t8 « « S t |j t: « r2t) t j< |« t j< |« « S t |« t> kD rBt |« d k r4|j t8 k7 r!tA |« jC « rd }nZd }nVtE |j |j « }|j7 |d¬« }|j7 |d¬« }tF jH } |||« S )zÀ
|
Compute the isin boolean array.
|
|
Parameters
|
----------
|
comps : list-like
|
values : list-like
|
|
Returns
|
-------
|
ndarray[bool]
|
Same length as `comps`.
|
zIonly list-like objects are allowed to be passed to isin(), you passed a `ú`rb r r ÚiufcbT)rA Ú extract_rangeÚisinr@ rI é c ó t j t j | |« j « t j | « « S ©N)rL Ú
|
logical_orr r Úisnan)ÚcÚvs rY Úfzisin.<locals>.f s. Ü}}¤R§W¡W¨Q°£]×%8Ñ%8Ó%:¼B¿H¹HÀQ»KÓHÐHrZ c óJ t j | |« j « S r )rL r r )ÚaÚbs rY ú<lambda>zisin.<locals>.<lambda> s RWW Q¨]× 0Ñ 0Ó 2 rZ FrC )%r! Ú TypeErrorÚtypeÚ__name__rK r, r. r+ rL rR ro rr r rJ Úkindr# r r- r3 r5 r r$ Úpd_arrayr" ÚzerosÚshaper rT rV r( rM Ú_MINIMUM_COMP_ARR_LENr0 Úanyr ÚhtableÚismember)ÚcompsrW Ú orig_valuesÚ comps_arrayr¤ Úcommons rY r r É sj ô Ô Üð (Ü(,¨U« ×(<Ñ(<Ð'=¸Qð @ó
|
ð
|
ô Ô Üð (Ü(,¨V« ×(=Ñ(=Ð'>¸að Aó
|
ð
|
ô
|
fx¬Ô4EÄrÇzÁzÐ RÔ SÜ6l Ü" ;¸.ÔIô K!OØ ×!Ñ! WÑ,Ü+¨EÔ2ô =¸[ÓIFä FMÔ *ä&Ó!ä v°TÈÔNä# E°VÔ<KÜ ¸4Ô@KÜ k¤2§:¡:Ô .à× Ñ Ó'Ð'ä [× .Ñ .Ô /ä Ó$×)Ñ)¨&Ó1Ð1Ü V\\Ô *´?À;×CTÑCTÔ3Uäxx ×)Ñ)´Ô6Ð6ä V\\Ô *ÜK § ¡ ¬vÓ!6Ó7Ð7ä FLL¤.Ô 1ÜBJJ{Ó+¬R¯Z©Z¸Ó-?Ó@Ð@ô KÓÔ0Ò0Ü K2Ò Ø × Ñ ¤Ò 'ô <× Ñ Ô ó Iñ 3Aô % V§\¡\°;×3DÑ3DÓEØ v¨E Ó2Ø!×(Ñ(¨°eÐ(Ó< Ü OOá [&Ó !Ð!rZ c ó | }| j j dv rt }t | « \ }} ||xs t | « « }|j | 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
|
ÚmMéÿÿÿÿ)Ú na_sentinelÚna_valuer Ú ignore_na)rJ r¬ r
|
r r Ú factorizer` r )
|
rW Úuse_na_sentinelÚ size_hintr¼ r r^ Ú
|
hash_klassr r rQ s
|
rY Úfactorize_arrayr $ s ðH HØ ||×ÑDÑ ô
|
ä,¨VÓ4ÑJá yÒ/¤C¨£KÓ 0EØ__ØØØØ Ø!ð %ó NGUô ¨¯ © ¸ÓBGä Ó &EØ '>ÐrZ 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.
|
)rW ÚsortrÀ c óÌ t | t t f« r| j ||¬« S t | d¬« } | }t | t
|
t f« r%| j | j |¬« \ }}||fS t | t j « s| j |¬« \ }}nt j | « } |s\| j t k( rIt | « }|j « r.t | j d¬« }t j ||| « } t# | ||¬« \ }}|r!t% |« d kD rt' |||d
|
d¬ « \ }}t) ||j |« }||fS ) aN
|
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(np.array(['b', 'b', 'a', 'c', 'b'], dtype="O"))
|
>>> 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(np.array(['b', 'b', 'a', 'c', 'b'], dtype="O"),
|
... 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(np.array(['b', None, 'a', 'c', 'b'], dtype="O"))
|
>>> 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¿ r¾ r )rà )r¿ F)Úcompat)r¿ rÀ r T)r¿ Ú assume_uniqueÚverify)rK r, r. r¾ rr r* r/ ÚfreqrL rR rM rJ rV r0 r± r1 Úwherer r Ú safe_sortr` ) rW rà r¿ rÀ r^ rQ r Ú null_maskr¼ s rY r¾ r¾ b sV ôp &8¤YÐ/Ô0Ø× Ñ T¸?Ð ÓKÐKä v°Ô =FØHô 6Ô ,Ô.?Ð@ÔAØ KKÐ #ð ×)Ñ)¨tÐ)Ó4wØg~Ð ä ¤§
|
¡
|
Ô +à ×)Ñ)¸/Ð)ÓJwô FÓ#á 6§<¡<´6Ò#9ô
|
V IØ}}Ü-¨f¯l©lÀ5ÔIä )¨X°vÓ>ä(Ø Ø +Ø ô
|
wñ G qÒ Ü"Ø Ø Ø +Ø Øô
|
ô ¨¯ © ¸ÓBGà '>ÐrZ c ól t j dt t « ¬« t | |||||¬« 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
|
zupandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.rc )rÃ Ú ascendingÚ normalizeÚbinsÚdropna)rj rk rl r Úvalue_counts_internal)rW rà rÍ rÎ rÏ rÐ s rY Ú value_countsrÒ / s@ ô< MMð EäÜ#Ó%õ ô !ØØ ØØØ Øô ð rZ c ó ddl m}m} t | dd « }|rdnd} |ßddlm}
|
t | |« r | j } |
|
| |d¬« } | j |¬
|
« } | | _
|
| | j j « } | j j d « | _ | j « } |r,| j dk( j « r| j dd } t# j$ t' | « g« }nt) | « rz || d ¬ « j j |¬
|
« } | | _
|
|| j _
|
| j }t |t" j* « st# j, |« }n|t | t. « rot1 t3 | j4 « « } || | ¬« j7 ||¬« j9 « } | j: | j _ | j }nýt= | d¬« } t? | |« \ }}}|j@ t" jB k( r |j t" jD « } ||« }|j@ tF dfv r)|j@ tH k( r|j tH « }nL|j@ |j@ k7 r3|j@ dk7 r$tK jL dtN tQ « ¬« ||_
|
|||| d ¬« } |r| jS |¬« } |r| |jU « z } | S # t $ r} t d « | d } ~ ww xY w)Nr )r; r< r Ú
|
proportionÚcount)ÚcutT)Úinclude_lowestz+bins argument only works with numeric data.©rÐ ÚintervalFrC )Úindexr )ÚlevelrÐ rÒ r rh zàThe behavior of value_counts with object-dtype is deprecated. In a future version, this will *not* perform dtype inference on the resulting index. To retain the old behavior, use `result.index = result.index.infer_objects()`rc )rÚ r rD )rÍ )+Úpandasr; r< ÚgetattrÚpandas.core.reshape.tilerÖ rK Ú_valuesr© rÒ r rÚ ÚnotnarT Ú
|
sort_indexÚallÚilocrL r3 r r rR rM r- ro ÚrangeÚnlevelsÚgroupbyÚsizeÚnamesrr Úvalue_counts_arraylikerJ Úfloat16rv r rV rj rk rl r Ú sort_valuesr )rW rà rÍ rÎ rÏ rÐ r; r< Ú
|
index_namer rÖ ÚiiÚerrr ÚcountsÚlevelsÚkeysÚ_Úidxs rY rÑ rÑ ^ s¼ ÷ô
|
¨Ó.JÙ$<¨'Dà ÐÝ0ä ffÔ %Ø^^Fð TÙVT°$Ô7Bð
|
¨ Ó/Ø Ø ×*Ñ*Ó,Ñ-Ø ||×*Ñ*¨:Ó6 Ø×"Ñ"Ó$ñ v~~¨Ñ*×/Ñ/Ô1Ø[[ 1Ð%Fô 3r7)Ó$ô $ FÔ +áF¨Ô/×7Ñ7×DÑDÈFÐDÓSFØ FKØ *FLLÔ Ø^^FÜ f¤b§j¡jÕ1ä FÓ+ä ¤ Ô .ä% §¡Ó/Ó0FáV¨$Ô/ßv¨fÓ5ßð ð
|
"(§ ¡ FLLÔ Ø^^Fô ' v¸ ÔHFÜ 4°V¸VÓ DOD&!ØzzRZZÒ'Ø{{¤2§:¡:Ó.ñ +CØyyT 8Ð ,Ñ,°·±¼vÒ1EØjj¤Ó(à TZZÒ'ØII Ò)ä ðDô "Ü /Ó 1õð "CHáF¨#°D¸uÔEFá Ø×#Ñ#¨iÐ#Ó8áØ&**,Ñ&à MøôS ò TÜÐ IÓJÐPSÐ Sûð Tús ½ L) Ì) MÌ2 L>Ì>Mc óà | }t | « } t j | ||¬« \ }}}t |j « r|r|t
|
k7 }|| || }}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]
|
r )rO r² Ú value_countr$ rJ r
|
r` )rW rÐ r r^ rñ rï Ú
|
na_counterÚres_keyss rY ré ré à sx ð HÜ &Ó !Fä %× 1Ñ 1°&¸&ÀtÔ LÑ D&*ä8>>Ô*ñ Ø4<DØ : v¨d¡|&Dä x§~¡~°xÓ@HØ VZÐ 'Ð'rZ c óH t | « } t j | ||¬« S )ax
|
Return boolean ndarray denoting duplicate values.
|
|
Parameters
|
----------
|
values : np.ndarray or ExtensionArray
|
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``.
|
mask : ndarray[bool], optional
|
array indicating which elements to exclude from checking
|
|
Returns
|
-------
|
duplicated : ndarray[bool]
|
)Úkeepr )rO r² Ú
|
duplicated)rW rù r s rY rú rú â s# ô2 &Ó !FÜ × Ñ V¨$°TÔ :Ð:rZ c ó® t | d¬« } | }t | j « r)t | « } t d| « } | j |¬« S t | « } t j | ||¬« \ }}|||fS t |« }t ||j |« }|S # t $ r,}t j d| t « ¬« Y d}~Id}~ww xY w) 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
|
Úmoder r> rØ )rÐ r NzUnable to sort modes: rc )rr r$ rJ r4 r Ú_moderO r² rü rÊ r© rj rk r r` )rW rÐ r r^ ÚnpresultÚres_maskrî r s rY rü rü ÿ sÖ ô" v°Ô 8FØHä6<<Ô(ä/°Ó7ÜÐ&¨Ó/Ø|| 6|Ó*Ð*ä &Ó !Fä V°FÀÔFÑHhØÐØÐ!Ð!ð
|
Ü XÓ&ô x¨¯ © ¸Ó BFØ Møô ò
|
Ü Ø$ S EÐ *Ü'Ó)÷
|
ò
|
ûð
|
ús Á; B Â CÂ("CÃCc ó
|
t | j « }t | « } | j dk( r t j
|
| |||||¬« }|S | j dk( r t j | ||||||¬« }|S t d« )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Í Ú na_optionÚpctrE )Úaxisr r rÍ r r z&Array with ndim > 2 are not supported.)r$ rJ rO Úndimr Úrank_1dÚrank_2dr© )rW r Úmethodr rÍ r r Úrankss rY Úrankr + s ô> *¨&¯,©,Ó7OÜ &Ó !Fà {{aÒÜ Ø Ø +Ø Ø Ø Øô
|
ð* Lð
|
Ò Ü Ø ØØ +Ø Ø Ø Øô
|
ð Lô Ð@ÓAÐArZ c óx t | t j t t t
|
f« s$t j dt t « ¬« t | « st j | « } t |« }|r+t || j | « t | ||d|¬« }|S | j! ||¬« }|S )ak
|
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.
|
|
.. deprecated:: 2.1.0
|
Passing an argument other than a numpy.ndarray, ExtensionArray,
|
Index, or Series is deprecated.
|
|
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])
|
zpd.api.extensions.take accepting non-standard inputs is deprecated and will raise in a future version. Pass either a numpy.ndarray, ExtensionArray, Index, or Series instead.rc T)r Ú
|
allow_fillÚ
|
fill_value)r )rK rL rR r+ r, r. rj rk rl r r rM r r6 r¯ r2 Útake)ÚarrÚindicesr r r r s rY r r k s¤ ôj cBJJÔ(9¼8ÄYÐOÔ Pä ð 8ô Ü'Ó)õ
|
ô Ô Üjjoä! 'Ó*Gáä #§)¡)¨D¡/Ô2ÜØ t°Àô
|
ð Mð '¨Ó-Ø MrZ c óà | t |« }t | t j « r(| j j
|
dv rt |« s t |« rùt j | j j « }t |« rt j |g« nt j |« }||j k\ j « r*||j k j « r | j }n |j }t |« r t t |j |« « }n't! t t" |« |¬« }n t% | « } | j' |||¬« S )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.
|
ÚiurI )ÚsideÚsorter)r rK rL rR rJ r¬ r r Úiinforª r3 Úminrâ Úmaxr Úintr r r4 Ú searchsorted)r Úvaluer r r Ú value_arrrJ s rY r r à s ð` ÐÜ$ VÓ,ô 3
|
|
Õ#Ø IINNdÒ "Ü Ô Ô"2°5Ô"9ô Ó(Ü)3°EÔ):BHHeWÔ%ÄÇÁÈÃ Ø Ñ "× 'Ñ 'Ô )¨y¸E¿I¹IÑ/E×.JÑ.JÔ.Lð IIEà OOEä eÔ äejj¨Ó /Ó0Eä T¤)¨UÓ 3¸5ÔAEô -¨SÓ1ð × Ñ E¨°VÐ Ó <Ð<rZ > r} r| r{ rz rv ru c ó\ t |« }t j }| j }t |« }|rt
|
j }nt
|
j }t |t « r | j « } | j }t | t j « s|t | d|j d« rA|dk7 r$t dt | « j d| « || | j! |« « S t# t | « j d« d}| j j$ dv r*t j& }| j) d« } t* }d }nZ|rt j, }nG|j$ d
|
v r9| j j. d v rt j0 }nt j2 }| j4 }|d k( r| j7 d d « } t j |« }t j8 | j: |¬« } t= d« gdz }
|
|dk\ r t= d|« n t= |d« |
|
|< || t? |
|
« < | j j. t@ v rtC jD | | |||¬« nt= d« gdz } |dk\ r t= |d« n t= d|« | |< t? | « } t= d« gdz } |dkD r t= d| « n t= | d« | |< t? | « } || | | | « | | < |r| j) d« } |d k( r | dd
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'.Fr¹ rH Tr )r} r| r rº rI NrE )Ú datetimelikeztimedelta64[ns])#r rL ÚnanrJ r ÚoperatorÚxorÚsubrK r) Úto_numpyrR Úhasattrr« Ú
|
ValueErrorrª Úshiftr© r¬ rz rS r
|
Úobject_r rv ru r ÚreshapeÚemptyr¯ Úslicern Ú _diff_specialr Údiff_2d)r Únr ÚnarJ Úis_boolÚopÚ is_timedeltaÚ orig_ndimÚout_arrÚ
|
na_indexerÚ _res_indexerÚ res_indexerÚ _lag_indexerÚ lag_indexers rY Údiffr; ; s¿ ô( AAÜ BØ IIEäEÓ"GÙÜ \\ä \\ä% Ô&àllnØ ä c2::Ô &ä 3"R[[M¨Ð,Ô -ØqyÜ <´°S³ ×0BÑ0BÐ/CÀ9ÈTÈFÐ!SÓTÐTÙc399 Q<Ó(Ð (äÜ9×%Ñ%Ð&ð 'Gð Góð ð
|
LØ
|
yy~~Ñ ÜØhhtnÜ Ø á ä
|
|
à tÑ ð
|
99>>Ð .Ñ .ÜJJEäJJEàIØA~àkk"aÓ ô HHUOEÜhhsyy¨Ô.Gä+ Ñ"JØ)*¨aªuT 1~´U¸1¸d³^JtÑØ!#GE*Ó Ñ à
|
yy~~ Ñ&ô c7 A t¸,ÖGô d } qÑ( Ø/0°AªvU 1 d^¼5ÀÀq»> TÑÜLÓ) ä d } qÑ( Ø01°A²U 4¨!¨_¼5À!ÀÀT»? TÑÜLÓ) á ! # kÑ"2°C¸ Ñ4DÓ E Ñ áØ,,Ð 0Ó1àA~Ø!Q$-Ø NrZ c ó8 t | t j t t f« s t d« d}t | j t « s&t j | d¬« dk( r t | « }n" | j « }| j |« }||S t% |« s t d« t' t j( |« « }|s+t+ t- | « « t+ | « k( s t/ d« |Jt1 | « \ }} |t+ | « « }|j3 | « t' |j5 |« « }|rG|j « } |r$|t+ | « k |t+ | « k\ z }
|
d||
|
< nd}
|
t7 | |d ¬
|
« } nt j8 t+ |« t: ¬ « } | j= |t j> t+ |« « « | j |d ¬ « } |r(|d k( }
|
|r!|
|
|t+ | « k z |t+ | « k\ z }
|
|r
|
t j@ | |
|
d « |t' | « fS # t
|
t j f$ r: | j r t | d t « r t# | « }n t | « }Y w xY w)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 : np.ndarray[intp] or None, default None
|
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.
|
zbOnly np.ndarray, ExtensionArray, and Index objects are allowed to be passed to safe_sort as valuesNFre ri 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 rI Úwrap)rü )!rK rL rR r+ r, r© rJ r( r rm Ú _sort_mixedÚargsortr ÚdecimalÚInvalidOperationrç rn Ú _sort_tuplesr! r rM r r r' r Ú map_locationsÚlookupr2 r+ r ÚputÚarangeÚputmask) rW rQ r¿ rÆ rÇ r ÚorderedrÁ ÚtÚorder2r Ú new_codesÚreverse_indexers rY rÊ rÊ ¬ sZ ô` frzzÔ+<¼hÐ GÔ HÜð /ó
|
ð
|
ð
|
Fô v||¤^Ô 4Ü OOF¨5Ô 1°_Ò Dä fÓ%ð .Ø^^Ó%FØ kk &Ó)Gð }Øä Ô Üð .ó
|
ð
|
ô ¤§
|
¡
|
¨5Ó 1Ó 2Eá ¤¤V¨F£^Ó!4¼¸F» Ò!CÜÐGÓHÐHà ~ô
|
1°Ó 8Ñ
|
FÙ s6{Ó #Ø Ô Ü$ Q§X¡X¨gÓ%6Ó7áà Ó!Ù ØS [LÑ(¨U´c¸&³kÑ-AÑBDØE$KàDÜF E°bÔ9 ä ((¤3 v£;´cÔ:Ø×ÑF¤B§I¡I¬c°&«kÓ$:Ô;ð $×(Ñ(¨°VÐ(Ó< á ØB;DÙØu¬¨F« |Ñ 3Ñ4¸ÄÀVÃÑ8LÑMá4Ð+Ü
|
|
|
9d BÔ'à Ô'¨ Ó2Ð 2Ð2øô{ 7×3Ñ3Ð4ò
|
.ð {{z¨&°©)´UÔ ;ô ' vÓ.ä% fÓ-úð
|
.ús Á4!I ÉAJÊJc óV t j | D cg c] }t |t « c}t ¬« }t j | D cg c] }t |« c}t ¬« }| | z }t j | | « }t j | | « }|j « d j |« }|j « d j |« }|j « d } t j ||| g« }
|
| j |
|
« S c c}w c c}w )z3order ints before strings before nulls in 1d arraysrI r )
|
rL r3 rK Ústrr r0 r@ Únonzeror Ú concatenate) rW ÚxÚstr_posÚnull_posÚnum_posÚ str_argsortÚ num_argsortÚstr_locsÚnum_locsÚ null_locsÚlocss rY r? r? . sì ähh°FÖ;¨q
|
1¤cÕ*Ò;Ä4ÔHGÜxx¨&Ö1 QaÒ1¼Ô>HØh(Ñ"GÜ**V G_Ó-KÜ**V G_Ó-KàÓ Ñ#×(Ñ(¨Ó5HØÓ Ñ#×(Ñ(¨Ó5HØ× Ñ Ó" 1Ñ%IÜ >>8 X¨yÐ9Ó :DØ ;;tÓ Ð ùò <ùÚ1s D!Á D&c óP ddl m} ddlm} || d« \ }} ||d¬« }| | 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)Úorders)Ú"pandas.core.internals.constructionr] Úpandas.core.sortingr^ )rW r] r^ Úarraysrò Úindexers rY rC rC = s0 õ =Ý3á& $Ó'IFAÙ f¨TÔ2GØ '?ÐrZ c ó ddl m} t j « 5 t j ddt
|
¬« t | d¬« }t |d¬« }ddd« j d¬ « \ }}t j |j |j « } |||j d
|
d¬ « }t | t « r0t |t « r | j |« j « }n[t | t « r | j" } t |t « r |j" }t% | |g« }t |« }t' |« }|j) |« j }t j* ||« S # 1 sw Y ,xY w) 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< Úignorez<The behavior of value_counts with object-dtype is deprecated)ÚcategoryFrØ Nr= r )rÚ rJ rD )rÜ r< rj Úcatch_warningsÚfilterwarningsrl rÑ ÚalignrL ÚmaximumrW rÚ rK r- Úappendr r, rß r% r4 ÚreindexÚrepeat) ÚlvalsÚrvalsr< Úl_countÚr_countÚ final_countÚ unique_valsÚcombinedÚrepeatss rY Úunion_with_duplicatesrw L s; õ. ä × Ñ Ó "ñ =ô × Ñ Ø Ø JÜ"õ
|
ô
|
(¨°eÔ<Ü'¨°eÔ<÷ =ð }} W¸}Ó;ÑGWÜ**W^^¨W¯^©^Ó<KÙ¨G¯M©MÀÈUÔSKÜ% Ô'¬J°u¼mÔ,LØll 5Ó)×0Ñ0Ó2 ä eXÔ &ØMMEÜ eXÔ &ØMMEô ! %¨ Ó0Ü XÓ& Ü4°[ÓA Ø×!Ñ! +Ó.×5Ñ5GÜ 99[ 'Ó *Ð*÷7 =ñ =ús 7E<Å<Fc óÖ |dvrd| d}t |« t |« rYt |t « rt |d« r| fd}n5ddlm} t |« dk( r ||t j ¬« }n ||« }t |t « rU|d k( r ||j j « }|j j | « }t |j |« }|S t | « s| j! « S | j# t$ d
|
¬ « }|t' j( |||¬ « S t' j* ||t- |« j/ t j0 « |¬ « S )a®
|
Map values using an input mapping or function.
|
|
Parameters
|
----------
|
mapper : function, dict, or Series
|
Mapping correspondence.
|
na_action : {None, 'ignore'}, default None
|
If 'ignore', propagate NA values, without passing them to the
|
mapping correspondence.
|
convert : bool, default True
|
Try to find better dtype for elementwise function results. If
|
False, leave as dtype=object.
|
|
Returns
|
-------
|
Union[ndarray, Index, ExtensionArray]
|
The output of the mapping function applied to the array.
|
If the function returns a tuple with more than one element
|
a MultiIndex will be returned.
|
)Nrf z+na_action must either be 'ignore' or None, z was passedÚ __missing__c ó| t | t « r't j | « rt j S | S r )rK ÚfloatrL r¡ r! )rR Údict_with_defaults rY r¨ zmap_array.<locals>.<lambda>ª s1 ø Ð 0Ü$ Q¬Ô.´2·8±8¸A´;ñ ØDEñ rZ r re rI rf FrC )Úconvert)r r} )r' r rK Údictr& rÜ r< r rL ru r. rÚ rà Ú get_indexerr2 rß rD rT rV r Ú map_inferÚmap_infer_maskr0 rS rB )
|
r ÚmapperÚ na_actionr} Úmsgr< rc Ú
|
new_valuesrW r| s
|
@rY Ú map_arrayr s@ ø ð6 Ð(Ñ(Ø;¸I¸;ÀkÐRÜoÐ ô
|
FÔÜ fdÔ #¬°¸ Ô(Fð !'Ð óFõ &ä6{aÒ Ù ¬b¯j©jÔ9á ä&)Ô$Ø Ò ØFLL× .Ñ .Ó 0Ñ1Fð ,,×*Ñ*¨3Ó/Ü V^^¨WÓ5
|
àÐä s8ØxxzÐð ZZ UZÓ +FØÐÜ}}V V°WÔ=Ð=ä×!Ñ!Ø F¤ f£ ×!2Ñ!2´2·8±8Ó!<Àgô
|
ð
|
rZ )rW r Úreturnú
|
np.ndarray)rW r rJ r r^ r r r )rp rO r r )rW r )rW r r rO )rW r r r r )r ú npt.NDArray[np.bool_] | None)r´ r7 rW r7 r únpt.NDArray[np.bool_])TNNN) rW r r¿ r rÀ ú
|
int | Noner¼ rV r r r z'tuple[npt.NDArray[np.intp], np.ndarray])FTN)rà r r¿ r rÀ r r z%tuple[np.ndarray, np.ndarray | Index])TFFNT)
|
rà r rÍ r rÎ r rÐ r r r< )rW r rÐ r r r r z,tuple[ArrayLike, npt.NDArray[np.int64], int])ÚfirstN)rW r rù z Literal['first', 'last', False]r r r r )TN)rW r rÐ r r r r r )r Úaveragerù TF)rW r r r r
|
rO r rO rÍ r r r r znpt.NDArray[np.float64])r FN)r r r r r r )ÚleftN)
|
r r r z$NumpyValueArrayLike | ExtensionArrayr zLiteral['left', 'right']r zNumpySorter | Noner z npt.NDArray[np.intp] | np.intp)r )r/ r r r )NTFT) rW zIndex | ArrayLikerQ znpt.NDArray[np.intp] | Noner¿ r rÆ r rÇ r r z.AnyArrayLike | tuple[AnyArrayLike, np.ndarray])r r )rW r r r )ro úArrayLike | Indexrp r r r )NT)r r r zLiteral['ignore'] | Noner} r r z#np.ndarray | ExtensionArray | Index)Ú__doc__Ú
|
__future__r rA r" Útextwrapr Útypingr r r rj ÚnumpyrL Ú pandas._libsr r r² r
|
r Úpandas._typingr r r r r r Úpandas.util._decoratorsr Úpandas.util._exceptionsr Úpandas.core.dtypes.castr r Úpandas.core.dtypes.commonr r r r r r r r r r r r! r" r# r$ Úpandas.core.dtypes.concatr% Úpandas.core.dtypes.dtypesr& r' r( r) Úpandas.core.dtypes.genericr* r+ r, r- r. r/ Úpandas.core.dtypes.missingr0 r1 Ú pandas.core.array_algos.taker2 Úpandas.core.constructionr3 r r4 r5 Úpandas.core.indexersr6 r7 r8 r9 rÜ r: r; r< Úpandas.core.arraysr= r> rO r` rr ÚComplex128HashTableÚComplex64HashTableÚFloat64HashTableÚFloat32HashTableÚUInt64HashTableÚUInt32HashTableÚUInt16HashTableÚUInt8HashTableÚInt64HashTableÚInt32HashTableÚInt16HashTableÚ Int8HashTableÚStringHashTableÚPyObjectHashTabler r r r r r Úunique1dr° r r r¾ rÒ rÑ ré rú rü r r r r- r; rÊ r? rC rw r © rZ rY ú<module>r³ s ðñõ #ã Û Ý ÷ñ ó
|
ã ÷ó ÷ ÷ õ (Ý 4÷÷÷ ÷ ÷ ñ õ" 4÷ó ÷ ÷ ÷õ
|
1÷ñ õ
|
2á÷ñ ÷ ñ ÷
|
óK!ð\ Ø ð Ø &ð Ø2>ð àó óBð8 ×,Ñ,Ø×*Ñ*Ø×&Ñ&Ø×&Ñ&Ø×$Ñ$Ø×$Ñ$Ø×$Ñ$Ø × "Ñ "Ø × "Ñ "Ø × "Ñ "Ø × "Ñ "Ø × Ñ Ø×$Ñ$Ø×&Ñ&ñ ó$ ó$ò6^$óBô.,ð0 ð "Ð óX"ðz !Ø ØØ)-ð ;Ø ð;àð;ð ð;ð ð ;ð
|
'ð ;ð -ó ;ñ| Ù ð ó ñ
|
ð ó
|
ñ ð óô ð0 Ø Ø ð tà
|
ðtð ðtð ð tð
|
+ò tó-ð,tðr ØØØ Øð ,à
|
ð,ð ð,ð ð ,ð ð ,ð ó,ðb ØØØ Øð aà
|
ðað ðað ð að ð að óaðL LPð (Ø ð (Ø $ð (Ø,Hð (à1ó (ðB -4Ø)-ð;Ø ð;à
|
)ð;ð 'ð;ð ó ;ð< RVð)Ø ð)Ø #ð)Ø2Nð)àó)ð\ ØØØØð 8Ø ð8à
|
ð8ð ð8ð ð 8ð
|
ð 8ð
|
ð 8ð ó8ðF Ø Øð mà ðmð ðmð ó mðp &,Ø!%ð Q=Ø ðQ=à /ðQ=ð #ðQ=ð ð Q=ð
|
$ó Q=òp J ôgðf *.Ø Ø Øð 3Ø ð3à &ð3ð ð3ð ð 3ð
|
ð 3ð 4ó 3óD ó ð 4+Ø ð4+Ø%6ð4+àó4+ðt +/Øð P
|
Ø ðP
|
ð (ðP
|
ð ð P
|
ð
|
)ô P
|
rZ
|
