U
|
¬ý°d¥P ã @ sæ d dl mZ d dlmZ d dlmZ d dlZd dlmZ d dl m
|
Z
|
m Z m Z m Z mZmZmZmZ d dlZd dlmZ d dlmZmZmZ d d lm Z d d
|
l m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' d d l(m)Z* d d l+m,Z, d d l-m.Z.m/Z/ d dl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@ d dlAmBZBmCZC d dlDmEZEmFZF d dlGmHZHmIZI d dlJmKZKmLZLmMZM d dlNmOZOmPZP d dlQmRZRmSZS d dlTmUZUmVZV d dlWmXZXmYZYmZZZ d dl[m\ m]Z^ d dl_m`Z`maZa d dlbmcZc d dldmeZe d dlfmgZg d dlhmiZi e
|
r(d d ljmkZkmlZlmmZm ed d d Znd d! Zod"d#d$d%ZpG d&d d eUeZegZqePeqd'd(gd)d*ePeqd+d,d-d.d/d0d1d2gd3d*G d4d5 d5eOeZeYZrd6d7d8d9d:ZsdEd7d"d7d<d=d>Ztd?d#d@dAZudBd#dCdDZvdS )Fé )Ú annotations)ÚQUOTE_NONNUMERIC)ÚpartialN)Úget_terminal_size)Ú TYPE_CHECKINGÚHashableÚIteratorÚLiteralÚSequenceÚTypeVarÚcastÚoverload)Ú
|
get_option)ÚNaTÚalgosÚlib)Ú NDArrayBacked)
|
Ú ArrayLikeÚ AstypeArgÚAxisIntÚDtypeÚNpDtypeÚOrderedÚShapeÚSortKindÚnptÚtype_t)Úfunction)Úvalidate_bool_kwarg)Úcoerce_indexer_dtypeÚfind_common_type)Ú ensure_int64Úensure_platform_intÚis_any_real_numeric_dtypeÚ is_bool_dtypeÚis_categorical_dtypeÚis_datetime64_dtypeÚ is_dict_likeÚis_dtype_equalÚis_extension_array_dtypeÚ is_hashableÚis_integer_dtypeÚ is_list_likeÚ is_scalarÚis_timedelta64_dtypeÚneeds_i8_conversionÚ pandas_dtype)ÚCategoricalDtypeÚExtensionDtype)ÚABCIndexÚ ABCSeries)Úis_valid_na_for_dtypeÚisna)Ú
|
algorithmsÚ arraylikeÚops)ÚPandasDelegateÚdelegate_names)Ú factorizeÚtake_nd)ÚNDArrayBackedExtensionArrayÚ ravel_compat)ÚExtensionArrayÚNoNewAttributesMixinÚ PandasObject)Ú extract_arrayÚsanitize_array)Úunpack_zerodim_and_defer)Únargsort)ÚObjectStringArrayMixin)Úconsole)Ú DataFrameÚIndexÚSeriesÚ CategoricalTÚ Categorical)Úboundc s: dj dtjk t fdd}|_ |S )NÚ__c s t |}t|r,t|t| kr,|s,td| jsBdkrBtdt|trÆd}| |¡sbt|| js| j
|
|j ¡st |j |j | j dd}n|j }| j |}| j dk|dkB }| ¡ r ||< |S |r || j kr| |¡}| j |}dkr
|
| j dk} ||< |S t | |¡S n`d krBtd
|
d t| d t|trdt|jrd|| S tt | ¡t |¡S d S ) NzLengths must match.)Ú__lt__Ú__gt__Ú__le__Ú__ge__z7Unordered Categoricals can only compare equality or notz?Categoricals can only be compared if 'categories' are the same.F©Úcopyéÿÿÿÿ> Ú__eq__rQ rS )rW Ú__ne__z$Cannot compare a Categorical for op z with type zB.
|
If you want to compare values, use 'np.asarray(cat) <op> other'.)r* r, ÚlenÚ
|
ValueErrorÚorderedÚ TypeErrorÚ
|
isinstancerM Ú#_categories_match_up_to_permutationÚ
|
categoriesÚequalsÚrecode_for_categoriesÚcodesÚ_codesÚanyÚ _unbox_scalarr9 Zinvalid_comparisonÚtyper@ r/ ÚdtypeÚgetattrÚnpÚarray)ÚselfÚotherZhashableÚmsgZ other_codesÚretÚmaskÚi©Ú
|
fill_valueÚopÚopname© úUd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/arrays/categorical.pyÚfunc~ sR ÿ
|
|
ÿ
|
|
|
|
ÿ
|
z _cat_compare_op.<locals>.func)Ú__name__ÚoperatorÚnerE )rs rw ru rq rv Ú_cat_compare_opz s
|
?r{ Úbool©Úreturnc s^ t | z| j |¡}W n ttfk
|
r2 Y dS X t|rD| kS t fdd|D S dS )aO
|
Helper for membership check for ``key`` in ``cat``.
|
|
This is a helper method for :method:`__contains__`
|
and :class:`CategoricalIndex.__contains__`.
|
|
Returns True if ``key`` is in ``cat.categories`` and the
|
location of ``key`` in ``categories`` is in ``container``.
|
|
Parameters
|
----------
|
cat : :class:`Categorical`or :class:`categoricalIndex`
|
key : a hashable object
|
The key to check membership for.
|
container : Container (e.g. list-like or mapping)
|
The container to check for membership in.
|
|
Returns
|
-------
|
is_in : bool
|
True if ``key`` is in ``self.categories`` and location of
|
``key`` in ``categories`` is in ``container``, else False.
|
|
Notes
|
-----
|
This method does not check for NaN values. Do that separately
|
before calling this method.
|
Fc 3 s | ]}| kV qd S ©Nru )Ú.0Zloc_©Ú containerru rv Ú <genexpr>ó s zcontains.<locals>.<genexpr>N)Úhashr_ Úget_locÚKeyErrorr\ r- rd )ÚcatÚkeyr Úlocru r rv Úcontainsà s r c s~ e Zd ZU dZdZejedgB ZdZde d< dÜd
|
d d d d fdd Z
|
e ddddZ e ddddZ edddd
|
d d dddZedÝdd d dd d ZedÞd d d dd!d Zedßd"d d#dd$d Zdàd"d d#d fd%d Zd&d' Zedád(d)Zedâd
|
d d*d+d,Ze d-dd.d/Ze d0dd1d2Ze d dd3d4Zdãd d d5 fd6d7 Zdd d*d8d9Zd d d:d;d<Zd dd=d>Zd dd?d@Z däd dAdBdCZ d ddDdEZ dådFdGZ d ddHdIZ dJdK Z!d ddLdMZ"dNdO Z#e$e%j&Z'e$e%j(Z)e$e%j*Z+e$e%j,Z-e$e%j.Z/e$e%j0Z1dPdQ Z2dRdS Z3e4dædTd d*dUdVZ5dWdXdYdZd[Z6d d fd\d] Z7e ddd^d_Z8dçd dd`dadbZ9d ddcddZ:e:Z;d ddedfZ<e<Z=dèd dgdhdidjZ>edkdldd dmdndoZ?dpdq Z@d ddrdsZAd dtdud dvdu fdwdxZBeddddydzd dXd d{d|d}ZCeddd~dd dXd d{dd}ZCdd ddyd d dXdd{dd}ZCdd
dd ddddXdXd d dddZDdd ZEe d dddZFddddZGddddZHddddZId dddZJdéd dddZKdêdd dXdddZLd dd¡d¢ZMdXdd£d¤ZNdXdd¥d¦ZOdëd dXd dXd¨d©dªZPdXdd«d¬ZQdd® ZRd¯dd°d±ZSd d²d d²d³d´ZTd d²d d²dµd¶ZUdìd d dhd·d¸ZV fd¹dºZWd d d»d¼d½ZXd¾d d¿dÀdÁZYedídÂdÃddÄdÅdÆdÇZZd d d¿dÈdÉZ[d d d¿dÊdËZ\dÌddÍdÎZ]dÏddÐdÑZ^ddÒd dÒdÓdÔZ_e`jae` d¾¡d fd dÕdÖd×ZbdîdXdÙdÚdÛZc ZdS )ïrM aY
|
Represent a categorical variable in classic R / S-plus fashion.
|
|
`Categoricals` can only take on a limited, and usually fixed, number
|
of possible values (`categories`). In contrast to statistical categorical
|
variables, a `Categorical` might have an order, but numerical operations
|
(additions, divisions, ...) are not possible.
|
|
All values of the `Categorical` are either in `categories` or `np.nan`.
|
Assigning values outside of `categories` will raise a `ValueError`. Order
|
is defined by the order of the `categories`, not lexical order of the
|
values.
|
|
Parameters
|
----------
|
values : list-like
|
The values of the categorical. If categories are given, values not in
|
categories will be replaced with NaN.
|
categories : Index-like (unique), optional
|
The unique categories for this categorical. If not given, the
|
categories are assumed to be the unique values of `values` (sorted, if
|
possible, otherwise in the order in which they appear).
|
ordered : bool, default False
|
Whether or not this categorical is treated as a ordered categorical.
|
If True, the resulting categorical will be ordered.
|
An ordered categorical respects, when sorted, the order of its
|
`categories` attribute (which in turn is the `categories` argument, if
|
provided).
|
dtype : CategoricalDtype
|
An instance of ``CategoricalDtype`` to use for this categorical.
|
|
Attributes
|
----------
|
categories : Index
|
The categories of this categorical
|
codes : ndarray
|
The codes (integer positions, which point to the categories) of this
|
categorical, read only.
|
ordered : bool
|
Whether or not this Categorical is ordered.
|
dtype : CategoricalDtype
|
The instance of ``CategoricalDtype`` storing the ``categories``
|
and ``ordered``.
|
|
Methods
|
-------
|
from_codes
|
__array__
|
|
Raises
|
------
|
ValueError
|
If the categories do not validate.
|
TypeError
|
If an explicit ``ordered=True`` is given but no `categories` and the
|
`values` are not sortable.
|
|
See Also
|
--------
|
CategoricalDtype : Type for categorical data.
|
CategoricalIndex : An Index with an underlying ``Categorical``.
|
|
Notes
|
-----
|
See the `user guide
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html>`__
|
for more.
|
|
Examples
|
--------
|
>>> pd.Categorical([1, 2, 3, 1, 2, 3])
|
[1, 2, 3, 1, 2, 3]
|
Categories (3, int64): [1, 2, 3]
|
|
>>> pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
|
['a', 'b', 'c', 'a', 'b', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
|
Missing values are not included as a category.
|
|
>>> c = pd.Categorical([1, 2, 3, 1, 2, 3, np.nan])
|
>>> c
|
[1, 2, 3, 1, 2, 3, NaN]
|
Categories (3, int64): [1, 2, 3]
|
|
However, their presence is indicated in the `codes` attribute
|
by code `-1`.
|
|
>>> c.codes
|
array([ 0, 1, 2, 0, 1, 2, -1], dtype=int8)
|
|
Ordered `Categoricals` can be sorted according to the custom order
|
of the categories and can have a min and max value.
|
|
>>> c = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'], ordered=True,
|
... categories=['c', 'b', 'a'])
|
>>> c
|
['a', 'b', 'c', 'a', 'b', 'c']
|
Categories (3, object): ['c' < 'b' < 'a']
|
>>> c.min()
|
'c'
|
iè ÚtolistZ categoricalr1 Ú_dtypeNFTz Dtype | Noner| ÚNone)rg ÚfastpathrU r~ c
|
s^ t |||¡}|rBt |j}t dd |¡}t ||¡ d S t sRtdt
|
d¡}t r~|jd kr|t j|j }nÖt tttfsTt ¡ t trÀt dkrÀt j
|
g td nt t jrê jdkrÞtdt d njt d } t| }| ¡ rP fdd t | ¡d D }
|
|
|
s6| j d
|
kr<d } n| j } t|
|
d | d} | |jd krÊzt d d \}}W nF tk
|
rº } z&t dd \}}|j rªtd | W 5 d } ~ X Y nX t ||j }n:t j røt j } t!| j j|j|d}n t" |j}| ¡ r0t j#|j$|j d }||| < |}t dd |¡}t||j} t | |¡ d S )NF©r[ z#Categorical input must be list-liker ©rg é z3> 1 ndim Categorical are not supported at this timec s g | ] } | qS ru ru )r Úidx©Úvaluesru rv Ú
|
<listcomp> s z(Categorical.__init__.<locals>.<listcomp>ÚobjectT)Úsortzl'values' is not ordered, please explicitly specify the categories order by passing in a categories argument.rT )%r1 Ú_from_values_or_dtyper r_ Ú update_dtypeÚsuperÚ__init__r, r\ ri rj r% r[ r] r3 r4 r@ ÚcomZconvert_to_list_likeÚlistrY r ÚndarrayÚndimÚNotImplementedErrorrD r6 rd Úwhererg r< rC rc ra Ú_get_codes_for_valuesZonesÚshape)rk r r_ r[ rg r rU rb Ú null_maskÚarrZarr_listZsanitize_dtypeÚerrZ old_codesZ
|
full_codes©Ú __class__r rv r g s ÿ
|
|
|
|
ÿ
|
|
ÿü
|
ÿ
|
|
zCategorical.__init__r} c C s | j S )zT
|
The :class:`~pandas.api.types.CategoricalDtype` for this instance.
|
)r ©rk ru ru rv rg Ë s zCategorical.dtypeÚintc C s | j j}| d¡S ©NrV )Ú_ndarrayrg rf )rk rg ru ru rv Ú_internal_fill_valueÒ s z Categorical._internal_fill_value©rg rU )rg rU r~ c C s t |||dS )Nr® )rM )ÚclsZscalarsrg rU ru ru rv Ú_from_sequenceÙ s zCategorical._from_sequence.z npt.DTypeLikeú
|
np.ndarrayc C s d S r ru ©rk rg rU ru ru rv Úastypeß s zCategorical.astyper2 r@ c C s d S r ru r² ru ru rv r³ ã s r r c C s d S r ru r² ru ru rv r³ ç s c s^ t |}| j|kr&|r | ¡ n| }n4t|r`tt|}| j |¡}|rP| ¡ n| } | |¡}nút|t rzt
|
j ||dS t |r| ¡ ¡ rtdnÂt| jdks´t| jdkrÆtj| ||d}n| jj}z@|j ||d}| jj}t||s t t | jj¡ |¡¡}W n6 ttfk
|
rD d| jj d| }t|Y nX t|t | j |d}|S )aZ
|
Coerce this type to another dtype
|
|
Parameters
|
----------
|
dtype : numpy dtype or pandas type
|
copy : bool, default True
|
By default, astype always returns a newly allocated object.
|
If copy is set to False and dtype is categorical, the original
|
object is returned.
|
rT z#Cannot convert float NaN to integerr r® z Cannot cast z
|
dtype to ©rr ) r0 rg rU r% r r1 r Ú
|
_set_dtyper] r2 r r³ r+ r6 rd rZ rY rb r_ ri rj Ú_valuesZ _na_valuer5 r Zitem_from_zerodimr\ r= r" rc )rk rg rU ÚresultZnew_catsrr rm r§ ru rv r³ ë sL
|
|
|
|
ý ÿþ ÿc C s | ¡ S )z#
|
Alias for tolist.
|
)r r© ru ru rv Úto_list( s zCategorical.to_listc C s ddl m}m}m}m} ||} t|to2|jdk }
|
|
|
r¦t|jrP||dd} nVt |jrh||dd} n>t
|
|jr||dd} n&t |jr¦|dkrdddg}| |¡} |
|
r¾|j} t || | } n@| jsî| ¡ } | ¡ } t || | } t| d d
|
}nt| d d
|
}|} | | |d d S ) aA
|
Construct a Categorical from inferred values.
|
|
For inferred categories (`dtype` is None) the categories are sorted.
|
For explicit `dtype`, the `inferred_categories` are cast to the
|
appropriate type.
|
|
Parameters
|
----------
|
inferred_categories : Index
|
inferred_codes : Index
|
dtype : CategoricalDtype or 'category'
|
true_values : list, optional
|
If none are provided, the default ones are
|
"True", "TRUE", and "true."
|
|
Returns
|
-------
|
Categorical
|
r )rJ Ú to_datetimeÚ
|
to_numericÚ to_timedeltaNZcoerce)ÚerrorsÚTrueÚTRUEÚtrueFr T©rg r )ÚpandasrJ r¹ rº r» r] r1 r_ r# r& r. r$ Úisinra Zis_monotonic_increasingrU Ú sort_values)r¯ Zinferred_categoriesZinferred_codesrg Z true_valuesrJ r¹ rº r» ZcatsZknown_categoriesr_ rb Zunsortedru ru rv Ú_from_inferred_categories. s4 ÿ
|
|
|
|
|
|
z%Categorical._from_inferred_categories)rg r~ c C s¸ t j|||d}|jdkr&d}t|t|rZt|rZt| ¡ rJtd|jt j
|
d}n
|
t |¡}t |r|t|s|tdt |rª| ¡ t |jks¢| ¡ dk rªtd| ||d d
|
S ) aÖ
|
Make a Categorical type from codes and categories or dtype.
|
|
This constructor is useful if you already have codes and
|
categories/dtype and so do not need the (computation intensive)
|
factorization step, which is usually done on the constructor.
|
|
If your data does not follow this convention, please use the normal
|
constructor.
|
|
Parameters
|
----------
|
codes : array-like of int
|
An integer array, where each integer points to a category in
|
categories or dtype.categories, or else is -1 for NaN.
|
categories : index-like, optional
|
The categories for the categorical. Items need to be unique.
|
If the categories are not given here, then they must be provided
|
in `dtype`.
|
ordered : bool, optional
|
Whether or not this categorical is treated as an ordered
|
categorical. If not given here or in `dtype`, the resulting
|
categorical will be unordered.
|
dtype : CategoricalDtype or "category", optional
|
If :class:`CategoricalDtype`, cannot be used together with
|
`categories` or `ordered`.
|
|
Returns
|
-------
|
Categorical
|
|
Examples
|
--------
|
>>> dtype = pd.CategoricalDtype(['a', 'b'], ordered=True)
|
>>> pd.Categorical.from_codes(codes=[0, 1, 0, 1], dtype=dtype)
|
['a', 'b', 'a', 'b']
|
Categories (2, object): ['a' < 'b']
|
)r_ r[ rg NzKThe categories must be provided in 'categories' or 'dtype'. Both were None.z codes cannot contain NA valuesr z$codes need to be array-like integersrV z1codes need to be between -1 and len(categories)-1TrÀ )r1 r r_ rZ r) r+ r6 rd Úto_numpyri Úint64ÚasarrayrY ÚmaxÚmin)r¯ rb r_ r[ rg rm ru ru rv Ú
|
from_codess s& * ÿ
|
ÿ
|
&zCategorical.from_codesrJ c C s | j jS )a¸
|
The categories of this categorical.
|
|
Setting assigns new values to each category (effectively a rename of
|
each individual category).
|
|
The assigned value has to be a list-like object. All items must be
|
unique and the number of items in the new categories must be the same
|
as the number of items in the old categories.
|
|
Raises
|
------
|
ValueError
|
If the new categories do not validate as categories or if the
|
number of new categories is unequal the number of old categories
|
|
See Also
|
--------
|
rename_categories : Rename categories.
|
reorder_categories : Reorder categories.
|
add_categories : Add new categories.
|
remove_categories : Remove the specified categories.
|
remove_unused_categories : Remove categories which are not used.
|
set_categories : Set the categories to the specified ones.
|
)rg r_ r© ru ru rv r_ ¹ s zCategorical.categoriesr c C s | j jS )zF
|
Whether the categories have an ordered relationship.
|
)rg r[ r© ru ru rv r[ Ö s zCategorical.orderedc C s | j ¡ }d|j_|S )a¢
|
The category codes of this categorical.
|
|
Codes are an array of integers which are the positions of the actual
|
values in the categories array.
|
|
There is no setter, use the other categorical methods and the normal item
|
setter to change values in the categorical.
|
|
Returns
|
-------
|
ndarray[int]
|
A non-writable view of the `codes` array.
|
F)rc ÚviewÚflagsZ writeable)rk Úvru ru rv rb Ý s
|
zCategorical.codes)r r~ c sd |rt || j¡}nt || jd}|sP| jjdk rPt|jt| jjkrPtdt | j |¡ dS )aä
|
Sets new categories inplace
|
|
Parameters
|
----------
|
fastpath : bool, default False
|
Don't perform validation of the categories for uniqueness or nulls
|
|
Examples
|
--------
|
>>> c = pd.Categorical(['a', 'b'])
|
>>> c
|
['a', 'b']
|
Categories (2, object): ['a', 'b']
|
|
>>> c._set_categories(pd.Index(['a', 'c']))
|
>>> c
|
['a', 'c']
|
Categories (2, object): ['a', 'c']
|
r NzKnew categories need to have the same number of items as the old categories!)
|
r1 Ú_from_fastpathr[ rg r_ rY rZ r r r¬ )rk r_ r Ú new_dtyper§ ru rv Ú_set_categoriesñ s ÿ
|
þýÿzCategorical._set_categoriesc C s$ t | j| j|j}t| ||ddS )a+
|
Internal method for directly updating the CategoricalDtype
|
|
Parameters
|
----------
|
dtype : CategoricalDtype
|
|
Notes
|
-----
|
We don't do any validation here. It's assumed that the dtype is
|
a (valid) instance of `CategoricalDtype`.
|
TrÀ )ra rb r_ rf )rk rg rb ru ru rv rµ s zCategorical._set_dtype)Úvaluer~ c C s* t | j|d}| ¡ }t ||j|¡ |S )zÇ
|
Set the ordered attribute to the boolean value.
|
|
Parameters
|
----------
|
value : bool
|
Set whether this categorical is ordered (True) or not (False).
|
r )r1 r_ rU r r r¬ )rk rÑ rÏ r ru ru rv Ú set_ordered& s zCategorical.set_orderedc C s
|
| d¡S )z
|
Set the Categorical to be ordered.
|
|
Returns
|
-------
|
Categorical
|
Ordered Categorical.
|
T©rÒ r© ru ru rv Ú
|
as_ordered4 s zCategorical.as_orderedc C s
|
| d¡S )z
|
Set the Categorical to be unordered.
|
|
Returns
|
-------
|
Categorical
|
Unordered Categorical.
|
FrÓ r© ru ru rv Ú as_unordered? s zCategorical.as_unordered)Úrenamec C s |dkr| j j}t||d}| ¡ }|rh|j jdk r`t|jt|j jk r`d|j|jt|jk< |j}nt|j|j|j}t
|
|||¡ |S )a¯
|
Set the categories to the specified new_categories.
|
|
`new_categories` can include new categories (which will result in
|
unused categories) or remove old categories (which results in values
|
set to NaN). If `rename==True`, the categories will simple be renamed
|
(less or more items than in old categories will result in values set to
|
NaN or in unused categories respectively).
|
|
This method can be used to perform more than one action of adding,
|
removing, and reordering simultaneously and is therefore faster than
|
performing the individual steps via the more specialised methods.
|
|
On the other hand this methods does not do checks (e.g., whether the
|
old categories are included in the new categories on a reorder), which
|
can result in surprising changes, for example when using special string
|
dtypes, which does not considers a S1 string equal to a single char
|
python string.
|
|
Parameters
|
----------
|
new_categories : Index-like
|
The categories in new order.
|
ordered : bool, default False
|
Whether or not the categorical is treated as a ordered categorical.
|
If not given, do not change the ordered information.
|
rename : bool, default False
|
Whether or not the new_categories should be considered as a rename
|
of the old categories or as reordered categories.
|
|
Returns
|
-------
|
Categorical with reordered categories.
|
|
Raises
|
------
|
ValueError
|
If new_categories does not validate as categories
|
|
See Also
|
--------
|
rename_categories : Rename categories.
|
reorder_categories : Reorder categories.
|
add_categories : Add new categories.
|
remove_categories : Remove the specified categories.
|
remove_unused_categories : Remove categories which are not used.
|
Nr rV ) rg r[ r1 rU r_ rY rc ra rb r r )rk Únew_categoriesr[ rÖ rÏ r rb ru ru rv Úset_categoriesJ s" 1 ÿ ÿzCategorical.set_categoriesc sP t r fdd| jD n t r: fdd| jD | ¡ }| ¡ |S )aÉ
|
Rename categories.
|
|
Parameters
|
----------
|
new_categories : list-like, dict-like or callable
|
|
New categories which will replace old categories.
|
|
* list-like: all items must be unique and the number of items in
|
the new categories must match the existing number of categories.
|
|
* dict-like: specifies a mapping from
|
old categories to new. Categories not contained in the mapping
|
are passed through and extra categories in the mapping are
|
ignored.
|
|
* callable : a callable that is called on all items in the old
|
categories and whose return values comprise the new categories.
|
|
Returns
|
-------
|
Categorical
|
Categorical with renamed categories.
|
|
Raises
|
------
|
ValueError
|
If new categories are list-like and do not have the same number of
|
items than the current categories or do not validate as categories
|
|
See Also
|
--------
|
reorder_categories : Reorder categories.
|
add_categories : Add new categories.
|
remove_categories : Remove the specified categories.
|
remove_unused_categories : Remove categories which are not used.
|
set_categories : Set the categories to the specified ones.
|
|
Examples
|
--------
|
>>> c = pd.Categorical(['a', 'a', 'b'])
|
>>> c.rename_categories([0, 1])
|
[0, 0, 1]
|
Categories (2, int64): [0, 1]
|
|
For dict-like ``new_categories``, extra keys are ignored and
|
categories not in the dictionary are passed through
|
|
>>> c.rename_categories({'a': 'A', 'c': 'C'})
|
['A', 'A', 'b']
|
Categories (2, object): ['A', 'b']
|
|
You may also provide a callable to create the new categories
|
|
>>> c.rename_categories(lambda x: x.upper())
|
['A', 'A', 'B']
|
Categories (2, object): ['A', 'B']
|
c s g | ]} ||¡qS ru )Úget©r Úitem©r× ru rv r Ì s z1Categorical.rename_categories.<locals>.<listcomp>c s g | ] } |qS ru ru rÚ rÜ ru rv r Ð s )r' r_ ÚcallablerU rÐ )rk r× r ru rÜ rv Úrename_categories s =
|
ÿ
|
z Categorical.rename_categoriesc C s6 t | jt |ks | j |¡js(td| j||dS )a
|
Reorder categories as specified in new_categories.
|
|
`new_categories` need to include all old categories and no new category
|
items.
|
|
Parameters
|
----------
|
new_categories : Index-like
|
The categories in new order.
|
ordered : bool, optional
|
Whether or not the categorical is treated as a ordered categorical.
|
If not given, do not change the ordered information.
|
|
Returns
|
-------
|
Categorical
|
Categorical with reordered categories.
|
|
Raises
|
------
|
ValueError
|
If the new categories do not contain all old category items or any
|
new ones
|
|
See Also
|
--------
|
rename_categories : Rename categories.
|
add_categories : Add new categories.
|
remove_categories : Remove the specified categories.
|
remove_unused_categories : Remove categories which are not used.
|
set_categories : Set the categories to the specified ones.
|
z=items in new_categories are not the same as in old categoriesr )rY r_ Ú
|
differenceÚemptyrZ rØ )rk r× r[ ru ru rv Úreorder_categoriesÖ s #ÿ þÿz Categorical.reorder_categoriesc C sÌ t |s|g}t|t| jj@ }t|dkr<td| t|drddlm} t | jjj|jg}|t
|
| jjt
|
| |d}nt
|
| jjt
|
| }t || j }| ¡ }t|j|j}t |||¡ |S )a¨
|
Add new categories.
|
|
`new_categories` will be included at the last/highest place in the
|
categories and will be unused directly after this call.
|
|
Parameters
|
----------
|
new_categories : category or list-like of category
|
The new categories to be included.
|
|
Returns
|
-------
|
Categorical
|
Categorical with new categories added.
|
|
Raises
|
------
|
ValueError
|
If the new categories include old categories or do not validate as
|
categories
|
|
See Also
|
--------
|
rename_categories : Rename categories.
|
reorder_categories : Reorder categories.
|
remove_categories : Remove the specified categories.
|
remove_unused_categories : Remove categories which are not used.
|
set_categories : Set the categories to the specified ones.
|
|
Examples
|
--------
|
>>> c = pd.Categorical(['c', 'b', 'c'])
|
>>> c
|
['c', 'b', 'c']
|
Categories (2, object): ['b', 'c']
|
|
>>> c.add_categories(['d', 'a'])
|
['c', 'b', 'c']
|
Categories (4, object): ['b', 'c', 'd', 'a']
|
r z0new categories must not include old categories: rg ©rK r )r, Úsetrg r_ rY rZ ÚhasattrrÁ rK r r r1 r[ rU r r¬ r r )rk r× Zalready_includedrK rg rÏ r rb ru ru rv Úadd_categories s, + ÿ
|
ÿ ÿ zCategorical.add_categoriesc C sz ddl m} t|s|g}|| ¡ ¡ }| jj |¡}| | jj¡}t|dkrht |}t
|
d| | j || j ddS )a
|
Remove the specified categories.
|
|
`removals` must be included in the old categories. Values which were in
|
the removed categories will be set to NaN
|
|
Parameters
|
----------
|
removals : category or list of categories
|
The categories which should be removed.
|
|
Returns
|
-------
|
Categorical
|
Categorical with removed categories.
|
|
Raises
|
------
|
ValueError
|
If the removals are not contained in the categories
|
|
See Also
|
--------
|
rename_categories : Rename categories.
|
reorder_categories : Reorder categories.
|
add_categories : Add new categories.
|
remove_unused_categories : Remove categories which are not used.
|
set_categories : Set the categories to the specified ones.
|
|
Examples
|
--------
|
>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
|
>>> c
|
['a', 'c', 'b', 'c', 'd']
|
Categories (4, object): ['a', 'b', 'c', 'd']
|
|
>>> c.remove_categories(['d', 'a'])
|
[NaN, 'c', 'b', 'c', NaN]
|
Categories (2, object): ['b', 'c']
|
r ©rJ z(removals must all be in old categories: F)r[ rÖ ) rÁ rJ r, ÚuniqueÚdropnarg r_ rß rY rã rZ rØ r[ )rk ÚremovalsrJ r× Z not_includedru ru rv Úremove_categoriesF s ) z Categorical.remove_categoriesc C s t j| jdd\}}|jdkr@|d dkr@|dd
|d }}| jj |¡}tj|| j d}t
|
||j}| ¡ }t |||¡ |S )a¡
|
Remove categories which are not used.
|
|
Returns
|
-------
|
Categorical
|
Categorical with unused categories dropped.
|
|
See Also
|
--------
|
rename_categories : Rename categories.
|
reorder_categories : Reorder categories.
|
add_categories : Add new categories.
|
remove_categories : Remove the specified categories.
|
set_categories : Set the categories to the specified ones.
|
|
Examples
|
--------
|
>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
|
>>> c
|
['a', 'c', 'b', 'c', 'd']
|
Categories (4, object): ['a', 'b', 'c', 'd']
|
|
>>> c[2] = 'a'
|
>>> c[4] = 'c'
|
>>> c
|
['a', 'c', 'a', 'c', 'c']
|
Categories (4, object): ['a', 'b', 'c', 'd']
|
|
>>> c.remove_unused_categories()
|
['a', 'c', 'a', 'c', 'c']
|
Categories (2, object): ['a', 'c']
|
T)Zreturn_inverser rV r Nr )ri rç rc Úsizerg r_ Útaker1 rÎ r[ r rU r r )rk r Úinvr× rÏ Ú new_codesr ru ru rv Úremove_unused_categories~ s " ÿ z$Categorical.remove_unused_categoriesc C sp | j |¡}z| j| j ¡ || jdW S tk
|
rj t | jdk¡rX| t
|
|tj ¡}t || j¡ Y S X dS )a
|
Map categories using an input mapping or function.
|
|
Maps the categories to new categories. If the mapping correspondence is
|
one-to-one the result is a :class:`~pandas.Categorical` which has the
|
same order property as the original, otherwise a :class:`~pandas.Index`
|
is returned. NaN values are unaffected.
|
|
If a `dict` or :class:`~pandas.Series` is used any unmapped category is
|
mapped to `NaN`. Note that if this happens an :class:`~pandas.Index`
|
will be returned.
|
|
Parameters
|
----------
|
mapper : function, dict, or Series
|
Mapping correspondence.
|
|
Returns
|
-------
|
pandas.Categorical or pandas.Index
|
Mapped categorical.
|
|
See Also
|
--------
|
CategoricalIndex.map : Apply a mapping correspondence on a
|
:class:`~pandas.CategoricalIndex`.
|
Index.map : Apply a mapping correspondence on an
|
:class:`~pandas.Index`.
|
Series.map : Apply a mapping correspondence on a
|
:class:`~pandas.Series`.
|
Series.apply : Apply more complex functions on a
|
:class:`~pandas.Series`.
|
|
Examples
|
--------
|
>>> cat = pd.Categorical(['a', 'b', 'c'])
|
>>> cat
|
['a', 'b', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
>>> cat.map(lambda x: x.upper())
|
['A', 'B', 'C']
|
Categories (3, object): ['A', 'B', 'C']
|
>>> cat.map({'a': 'first', 'b': 'second', 'c': 'third'})
|
['first', 'second', 'third']
|
Categories (3, object): ['first', 'second', 'third']
|
|
If the mapping is one-to-one the ordering of the categories is
|
preserved:
|
|
>>> cat = pd.Categorical(['a', 'b', 'c'], ordered=True)
|
>>> cat
|
['a', 'b', 'c']
|
Categories (3, object): ['a' < 'b' < 'c']
|
>>> cat.map({'a': 3, 'b': 2, 'c': 1})
|
[3, 2, 1]
|
Categories (3, int64): [3 < 2 < 1]
|
|
If the mapping is not one-to-one an :class:`~pandas.Index` is returned:
|
|
>>> cat.map({'a': 'first', 'b': 'second', 'c': 'first'})
|
Index(['first', 'second', 'first'], dtype='object')
|
|
If a `dict` is used, all unmapped categories are mapped to `NaN` and
|
the result is an :class:`~pandas.Index`:
|
|
>>> cat.map({'a': 'first', 'b': 'second'})
|
Index(['first', 'second', nan], dtype='object')
|
)r_ r[ rV N) r_ ÚmaprÊ rc rU r[ rZ ri rd ÚinsertrY Únanrì )rk Zmapperr× ru ru rv rð ± s E ÿzCategorical.mapc C s t |s| |¡S | |¡S d S r )r* Ú_validate_listlikeÚ_validate_scalar)rk rÑ ru ru rv Ú_validate_setitem_value s
|
z#Categorical._validate_setitem_valuec C s@ t || jjrd}n(|| jkr*| |¡}ntd| dd|S )aK
|
Convert a user-facing fill_value to a representation to use with our
|
underlying ndarray, raising TypeError if this is not possible.
|
|
Parameters
|
----------
|
fill_value : object
|
|
Returns
|
-------
|
fill_value : int
|
|
Raises
|
------
|
TypeError
|
rV z5Cannot setitem on a Categorical with a new category (z), set the categories firstN)r5 r_ rg re r\ )rk rr ru ru rv rô s
|
|
ÿýz Categorical._validate_scalarzNpDtype | Nonec C s8 t | jj| j}|r.t|| jjs.t ||¡S t |¡S )zÿ
|
The numpy array interface.
|
|
Returns
|
-------
|
numpy.array
|
A numpy array of either the specified dtype or,
|
if dtype==None (default), the same dtype as
|
categorical.categories.dtype.
|
)r= r_ r¶ rc r( rg ri rÇ )rk rg rn ru ru rv Ú __array__2 s zCategorical.__array__znp.ufuncÚstr)ÚufuncÚmethodc O s t j| ||f||}|tk r"|S d|kr@tj| ||f||S |dkrjtj| ||f||}|tk rj|S td| j d|j d S )NÚoutÚreducezObject with dtype z cannot perform the numpy op ) r9 Z!maybe_dispatch_ufunc_to_dunder_opÚNotImplementedr8 Zdispatch_ufunc_with_outZdispatch_reduction_ufuncr\ rg rx )rk rø rù ÚinputsÚkwargsr· ru ru rv Ú__array_ufunc__F sH ÿÿÿ ÿÿÿ ÿÿÿÿzCategorical.__array_ufunc__c sb t |tst |¡S d|kr4t|d |d |d< d|krRd|krR| d¡|d< t |¡ dS )z*Necessary for making this object picklabler Z _categoriesZ_orderedrc r¬ N)r] Údictr Ú __setstate__r1 Úpop)rk Ústater§ ru rv r c s
|
zCategorical.__setstate__c C s | j j| jjjj S r )rc Únbytesrg r_ r r© ru ru rv r q s zCategorical.nbytes)Údeepr~ c C s | j j| jjj|d S )aè
|
Memory usage of my values
|
|
Parameters
|
----------
|
deep : bool
|
Introspect the data deeply, interrogate
|
`object` dtypes for system-level memory consumption
|
|
Returns
|
-------
|
bytes used
|
|
Notes
|
-----
|
Memory usage does not include memory consumed by elements that
|
are not components of the array if deep=False
|
|
See Also
|
--------
|
numpy.ndarray.nbytes
|
)r )rc r rg r_ Ú memory_usage)rk r ru ru rv r u s zCategorical.memory_usagec C s
|
| j dkS )aX
|
Detect missing values
|
|
Missing values (-1 in .codes) are detected.
|
|
Returns
|
-------
|
np.ndarray[bool] of whether my values are null
|
|
See Also
|
--------
|
isna : Top-level isna.
|
isnull : Alias of isna.
|
Categorical.notna : Boolean inverse of Categorical.isna.
|
|
rV )rc r© ru ru rv r6 s zCategorical.isnac C s
|
| ¡ S )a
|
Inverse of isna
|
|
Both missing values (-1 in .codes) and NA as a category are detected as
|
null.
|
|
Returns
|
-------
|
np.ndarray[bool] of whether my values are not null
|
|
See Also
|
--------
|
notna : Top-level notna.
|
notnull : Alias of notna.
|
Categorical.isna : Boolean inverse of Categorical.notna.
|
|
)r6 r© ru ru rv Únotna£ s zCategorical.notnarK )rè r~ c C s¾ ddl m}m} | j| j }}t||dk }}t |¡| ¡ }} |sL| rp| rT|n|| }
|
tj |
|
|phdd} n t t
|
|||¡¡} t |d¡}t || j j}| |¡}|| ||ddddS ) a{
|
Return a Series containing counts of each category.
|
|
Every category will have an entry, even those with a count of 0.
|
|
Parameters
|
----------
|
dropna : bool, default True
|
Don't include counts of NaN.
|
|
Returns
|
-------
|
counts : Series
|
|
See Also
|
--------
|
Series.value_counts
|
r )ÚCategoricalIndexrK )Z minlengthrV rÆ ÚcountF)Úindexrg ÚnamerU )rÁ r rK rc r_ rY ri ÚarangeÚallZbincountr¡ Úappendr rg Ú_from_backing_data) rk rè r rK Úcoder Zncatro ÚixÚcleanZobsr ru ru rv Ú value_counts¹ s$
|
ÿzCategorical.value_countsztype_t[Categorical]r )r¯ r£ rg r~ c C s* | j g |d}tj||jjd}| |¡S )z
|
Analogous to np.empty(shape, dtype=dtype)
|
|
Parameters
|
----------
|
shape : tuple[int]
|
dtype : CategoricalDtype
|
r )r° ri Úzerosr¬ rg r )r¯ r£ rg r¥ Zbackingru ru rv Ú_emptyæ s zCategorical._emptyc C sV t | jjr | jj| jtdS t| jrLd| jkrL| j d¡j| jtj dS t
|
| ¡S )a
|
Return the values.
|
|
For internal compatibility with pandas formatting.
|
|
Returns
|
-------
|
np.ndarray or Index
|
A numpy array of the same dtype as categorical.categories.dtype or
|
Index if datetime / periods.
|
r´ rV r ) r/ r_ rg rì rc r r+ r³ ri rò rj r© ru ru rv Ú_internal_get_valuesû s
|
z Categorical._internal_get_valuesc C s | j std| ddS )zassert that we are orderedz)Categorical is not ordered for operation zG
|
you can use .as_ordered() to change the Categorical to an ordered one
|
N)r[ r\ )rk rs ru ru rv Úcheck_for_ordered s
|
ÿz Categorical.check_for_orderedZ quicksort©Ú ascendingÚkindr c s t jf ||d|S )a¡
|
Return the indices that would sort the Categorical.
|
|
Missing values are sorted at the end.
|
|
Parameters
|
----------
|
ascending : bool, default True
|
Whether the indices should result in an ascending
|
or descending sort.
|
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
|
Sorting algorithm.
|
**kwargs:
|
passed through to :func:`numpy.argsort`.
|
|
Returns
|
-------
|
np.ndarray[np.intp]
|
|
See Also
|
--------
|
numpy.ndarray.argsort
|
|
Notes
|
-----
|
While an ordering is applied to the category values, arg-sorting
|
in this context refers more to organizing and grouping together
|
based on matching category values. Thus, this function can be
|
called on an unordered Categorical instance unlike the functions
|
'Categorical.min' and 'Categorical.max'.
|
|
Examples
|
--------
|
>>> pd.Categorical(['b', 'b', 'a', 'c']).argsort()
|
array([2, 0, 1, 3])
|
|
>>> cat = pd.Categorical(['b', 'b', 'a', 'c'],
|
... categories=['c', 'b', 'a'],
|
... ordered=True)
|
>>> cat.argsort()
|
array([3, 0, 1, 2])
|
|
Missing values are placed at the end
|
|
>>> cat = pd.Categorical([2, None, 1])
|
>>> cat.argsort()
|
array([2, 0, 1])
|
r )r Úargsort)rk r r rþ r§ ru rv r s 3zCategorical.argsort)Úinplacer Ú na_positionzLiteral[False])r r r r~ c C s d S r ru ©rk r r r ru ru rv rà L s zCategorical.sort_values©r r z Literal[True]c C s d S r ru r ru ru rv rà V s ÚlastzCategorical | Nonec C sb t |d}|dkr$tdt| t| ||d}|sJ| j| }| |¡S | j| | jdd
< dS )a
|
Sort the Categorical by category value returning a new
|
Categorical by default.
|
|
While an ordering is applied to the category values, sorting in this
|
context refers more to organizing and grouping together based on
|
matching category values. Thus, this function can be called on an
|
unordered Categorical instance unlike the functions 'Categorical.min'
|
and 'Categorical.max'.
|
|
Parameters
|
----------
|
inplace : bool, default False
|
Do operation in place.
|
ascending : bool, default True
|
Order ascending. Passing False orders descending. The
|
ordering parameter provides the method by which the
|
category values are organized.
|
na_position : {'first', 'last'} (optional, default='last')
|
'first' puts NaNs at the beginning
|
'last' puts NaNs at the end
|
|
Returns
|
-------
|
Categorical or None
|
|
See Also
|
--------
|
Categorical.sort
|
Series.sort_values
|
|
Examples
|
--------
|
>>> c = pd.Categorical([1, 2, 2, 1, 5])
|
>>> c
|
[1, 2, 2, 1, 5]
|
Categories (3, int64): [1, 2, 5]
|
>>> c.sort_values()
|
[1, 1, 2, 2, 5]
|
Categories (3, int64): [1, 2, 5]
|
>>> c.sort_values(ascending=False)
|
[5, 2, 2, 1, 1]
|
Categories (3, int64): [1, 2, 5]
|
|
>>> c = pd.Categorical([1, 2, 2, 1, 5])
|
|
'sort_values' behaviour with NaNs. Note that 'na_position'
|
is independent of the 'ascending' parameter:
|
|
>>> c = pd.Categorical([np.nan, 2, 2, np.nan, 5])
|
>>> c
|
[NaN, 2, 2, NaN, 5]
|
Categories (2, int64): [2, 5]
|
>>> c.sort_values()
|
[2, 2, 5, NaN, NaN]
|
Categories (2, int64): [2, 5]
|
>>> c.sort_values(ascending=False)
|
[5, 2, 2, NaN, NaN]
|
Categories (2, int64): [2, 5]
|
>>> c.sort_values(na_position='first')
|
[NaN, NaN, 2, 2, 5]
|
Categories (2, int64): [2, 5]
|
>>> c.sort_values(ascending=False, na_position='first')
|
[NaN, NaN, 5, 2, 2]
|
Categories (2, int64): [2, 5]
|
r )r Úfirstzinvalid na_position: r N)r rZ ÚreprrF rc r )rk r r r Z
|
sorted_idxrb ru ru rv rà \ s I
|
|
|
r ZaverageÚkeep©Úaxisrù Ú na_optionr Úpctr c C s* |dkr t | ¡ }tj||||||dS )z*
|
See Series.rank.__doc__.
|
r r$ )r Ú_values_for_rankr7 Úrank)rk r% rù r& r r' Zvffru ru rv Ú_rank± s úzCategorical._rankc C sx ddl m} | jr>| j}|dk}| ¡ rt| d¡}tj||< n6t| j rTt
|
| ¡}n t
|
| || j dd ¡ j ¡¡}|S )zð
|
For correctly ranking ordered categorical data. See GH#15420
|
|
Ordered categorical data should be ranked on the basis of
|
codes with -1 translated to NaN.
|
|
Returns
|
-------
|
numpy.array
|
|
r râ rV Úfloat64FrT )rÁ rK r[ rb rd r³ ri rò r# r_ rj rÞ r) r )rk rK r ro ru ru rv r( É s
|
|
ÿÿz Categorical._values_for_rankc C s | j S r )r¬ r© ru ru rv rc ì s zCategorical._codes)rp c C s |dkrt jS | j| S r« )ri ÚNaNr_ )rk rp ru ru rv Ú _box_funcð s zCategorical._box_funcc C s | j |¡}| jj |¡}|S r )r_ r
r¬ rg rf )rk r r ru ru rv re õ s zCategorical._unbox_scalarr c s8 j dkrt ¡ ¡ S fddtt D S dS )zJ
|
Returns an Iterator over the values of this Categorical.
|
r c 3 s | ]} | V qd S r ru )r Únr© ru rv r s z'Categorical.__iter__.<locals>.<genexpr>N)r Úiterr r ÚrangerY r© ru r© rv Ú__iter__þ s
|
zCategorical.__iter__c C s. t || jjr t| ¡ ¡ S t| || jdS )z?
|
Returns True if `key` is in this Categorical.
|
r )r5 r_ rg r| r6 rd r rc )rk r ru ru rv Ú __contains__ s zCategorical.__contains__)Úboxedc C s d S r ru )rk r3 ru ru rv Ú
|
_formatter s zCategorical._formatteré
|
)Úmax_valsÚfooterr~ c C sv |d }| d|
j ddd}| || d
j ddd}|dd
d|dd
}|rn| d| ¡ }t|S ) zd
|
a short repr displaying only max_vals and an optional (but default
|
footer)
|
é NF©Úlengthr7 rV z, ..., r Ú
|
)Ú _get_reprÚ _repr_footerr÷ )rk r6 r7 ÚnumÚheadÚtailr· ru ru rv Ú
|
_tidy_repr s zCategorical._tidy_reprz list[str]c C s t ddkrdnt d}ddlm} t|jdtd}t| j|kr|d }|| jd|
}|| j| d
}|dg | }n
|
|| j}d d
|
|D }|S ) z9
|
return the base repr for the categories
|
zdisplay.max_categoriesr r5 ©ÚformatN)Ú formatterÚquotingr8 z...c S s g | ] }| ¡ qS ru )Ústrip©r Úxru ru rv r > s z0Categorical._repr_categories.<locals>.<listcomp>)r Úpandas.io.formatsrC r Ú format_arrayr rY r_ )rk Zmax_categoriesÚfmtrJ r> r? r@ Ú category_strsru ru rv Ú_repr_categories' s$
|
ÿý ÿ
|
z Categorical._repr_categoriesc C s | ¡ }t| jj}dt| j d| d}t \}}tdp@|}t ¡ rNd}d}d}t|} | j rhdnd \}
|
} |
|
¡ d
|
} |D ]j} |dkrÈ| |
|
t| |krÈ|| d t|d 7 }t|d } n|sà|| 7 }| t| 7 } || 7 }d }q| d| dd¡ dS )z@
|
Returns a string representation of the footer.
|
z Categories (ú, z): z display.widthr Ú T)é z < )r8 rN r; ú r Fú[z < ... < z ... ú]) rM r÷ r_ rg rY r r rH Zin_ipython_frontendr[ ÚrstripÚreplace)rk rL rg Z levheaderÚwidthÚheightÚ max_widthZ levstringÚstartZ cur_col_lenZsep_lenÚsepÚlinesepÚvalru ru rv Ú_repr_categories_infoA s,
|
z!Categorical._repr_categories_infoc C s | ¡ }dt| d| S )NzLength: r; )r] rY )rk Úinforu ru rv r= ^ s zCategorical._repr_footerr, )r: Úna_repr7 r~ c C s. ddl m} |j| |||d}| ¡ }t|S )Nr rB )r: r_ r7 )rI rC ZCategoricalFormatterZ to_stringr÷ )rk r: r_ r7 rK rD r· ru ru rv r< b s ÿzCategorical._get_reprc C sf d}t | j|kr | |¡}nDt | jdkrB| jt | |kd}n | jddd dd¡}d | }|S )
|
z(
|
String representation.
|
r5 r )r: FTr9 r; rN z[], )rY rc rA r< rU )rk Ú_maxlenr· rm ru ru rv Ú__repr__m s
|
zCategorical.__repr__c C s t |dd}t|tr<t| j|js,td| |¡}|jS ddlm } |j
|
|dd | j ¡}t |rzt| ¡ sztd| j |¡}|j| jjdd S )
|
NT)Z extract_numpyzCCannot set a Categorical with another, without identical categoriesr ræ F)Z tupleize_colszMCannot setitem on a Categorical with a new category, set the categories firstrT )rC r] rM r( rg r\ Ú_encode_with_my_categoriesrc rÁ rJ Z _with_inferrß r_ rY r6 r Ú get_indexerr³ r¬ )rk rÑ rJ Zto_addrb ru ru rv ró ~ s$
|
ÿ
|
ÿÿ z Categorical._validate_listlikez$dict[Hashable, npt.NDArray[np.intp]]c sX | j }t t| j|j¡\ }t| ¡ } fddt||dd
D }t t||S )a§
|
Compute the inverse of a categorical, returning
|
a dict of categories -> indexers.
|
|
*This is an internal function*
|
|
Returns
|
-------
|
Dict[Hashable, np.ndarray[np.intp]]
|
dict of categories -> indexers
|
|
Examples
|
--------
|
>>> c = pd.Categorical(list('aabca'))
|
>>> c
|
['a', 'a', 'b', 'c', 'a']
|
Categories (3, object): ['a', 'b', 'c']
|
>>> c.categories
|
Index(['a', 'b', 'c'], dtype='object')
|
>>> c.codes
|
array([0, 0, 1, 2, 0], dtype=int8)
|
>>> c._reverse_indexer()
|
{'a': array([0, 1, 4]), 'b': array([2]), 'c': array([3])}
|
|
c 3 s | ]\}} ||
V qd S r ru )r rY Úend©Úrru rv r ¾ s z/Categorical._reverse_indexer.<locals>.<genexpr>r N)
|
r_ ÚlibalgosZgroupsort_indexerr" rb rë r! ZcumsumÚzipr )rk r_ ÚcountsZ_resultru re rv Ú_reverse_indexer s ÿ z Categorical._reverse_indexer)Úskipnac K s t | dd¡¡ t d|¡ | d¡ t| js:| jjS | jdk}| ¡ sp|rh|
|
¡ rh| j| ¡ }qzt j S n
|
| j ¡ }| d|¡S )a/
|
The minimum value of the object.
|
|
Only ordered `Categoricals` have a minimum!
|
|
Raises
|
------
|
TypeError
|
If the `Categorical` is not `ordered`.
|
|
Returns
|
-------
|
min : the minimum of this `Categorical`, NA value if empty
|
r% r ru rÉ rV N)ÚnvÚvalidate_minmax_axisrÙ Z validate_minr rY rc rg Úna_valuer rd rÉ ri rò Ú_wrap_reduction_result©rk rk rþ ZgoodÚpointerru ru rv rÉ Ä s
|
|
|
|
zCategorical.minc K s t | dd¡¡ t d|¡ | d¡ t| js:| jjS | jdk}| ¡ sp|rh|
|
¡ rh| j| ¡ }qzt j S n
|
| j ¡ }| d|¡S )a2
|
The maximum value of the object.
|
|
Only ordered `Categoricals` have a maximum!
|
|
Raises
|
------
|
TypeError
|
If the `Categorical` is not `ordered`.
|
|
Returns
|
-------
|
max : the maximum of this `Categorical`, NA if array is empty
|
r% r ru rÈ rV N)rl rm rÙ Z validate_maxr rY rc rg rn r rd rÈ ri rò ro rp ru ru rv rÈ ä s
|
|
|
|
zCategorical.maxc C sN | j }d }|r| ¡ }tj||d}ttj|}|j|jks@t| |¡}|S )N)ro )
|
rc r6 r7 Úmoder ri r rg ÚAssertionErrorr )rk rè rb ro Z res_codesÚresru ru rv Ú_mode s
|
zCategorical._modec s
|
t ¡ S )aß
|
Return the ``Categorical`` which ``categories`` and ``codes`` are
|
unique.
|
|
.. versionchanged:: 1.3.0
|
|
Previously, unused categories were dropped from the new categories.
|
|
Returns
|
-------
|
Categorical
|
|
See Also
|
--------
|
pandas.unique
|
CategoricalIndex.unique
|
Series.unique : Return unique values of Series object.
|
|
Examples
|
--------
|
>>> pd.Categorical(list("baabc")).unique()
|
['b', 'a', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
>>> pd.Categorical(list("baab"), categories=list("abc"), ordered=True).unique()
|
['b', 'a']
|
Categories (3, object): ['a' < 'b' < 'c']
|
)r rç r© r§ ru rv rç s zCategorical.unique)Ú
|
res_valuesr~ c C s |j | jj kst|S r )rg r¬ rs )rk rv ru ru rv Ú_cast_quantile_result2 s z!Categorical._cast_quantile_resultr )rl r~ c C s6 t |tsdS | |¡r2| |¡}t | j|j¡S dS )z²
|
Returns True if categorical arrays are equal.
|
|
Parameters
|
----------
|
other : `Categorical`
|
|
Returns
|
-------
|
bool
|
F)r] rM r^ rb ri Z array_equalrc ©rk rl ru ru rv r` 7 s
|
|
|
zCategorical.equalsztype[CategoricalT]zSequence[CategoricalT]rL )r¯ Ú to_concatr% r~ c s´ ddl m} |d }||jkr4td| d|j |dkr¨tdd |D sRtg }|D ]& | fdd t jd D ¡ qZ| j|dd
|
}|j t
|
|d d d }|S ||}|S )Nr )Úunion_categoricalszaxis z) is out of bounds for array of dimension r c s s | ]}|j d kV qdS )r8 N)r rG ru ru rv r X s z0Categorical._concat_same_type.<locals>.<genexpr>c s g | ]} d d
|f qS r ru )r rp ©Úobjru rv r ^ s z1Categorical._concat_same_type.<locals>.<listcomp>©r% rV ÚF)Úorder) Zpandas.core.dtypes.concatrz r rZ r Úextendr0 r£ Ú_concat_same_typeÚreshaperY )r¯ ry r% rz r! Ztc_flatZres_flatr· ru r{ rv r J s"
|
ÿ$z Categorical._concat_same_typec C s t |j|j| jdd}| |¡S )z×
|
Re-encode another categorical using this Categorical's categories.
|
|
Notes
|
-----
|
This assumes we have already checked
|
self._categories_match_up_to_permutation(other).
|
FrT )ra rb r_ r )rk rl rb ru ru rv rb j s ÿz&Categorical._encode_with_my_categoriesc C s t | jt |jkS )zÞ
|
Returns True if categoricals are the same dtype
|
same categories, and same ordered
|
|
Parameters
|
----------
|
other : Categorical
|
|
Returns
|
-------
|
bool
|
)r rg rx ru ru rv r^ { s z/Categorical._categories_match_up_to_permutationrI c C sZ | j dd}|| ¡ }ddlm} ddlm} |||gdd}|dd g|_d
|
|j_|S ) z
|
Describes this Categorical
|
|
Returns
|
-------
|
description: `DataFrame`
|
A dataframe with frequency and counts by category.
|
F)rè r ræ )Úconcatr r} ri Úfreqsr_ ) r ÚsumrÁ rJ Zpandas.core.reshape.concatr Úcolumnsr
|
r )rk ri r rJ r r· ru ru rv Údescribe s zCategorical.describeznpt.NDArray[np.bool_]c C sf t |s"t|j}td| dt|dd}t t|¡}| j |¡}|||dkB }t
|
| j |¡S )a¡
|
Check whether `values` are contained in Categorical.
|
|
Return a boolean NumPy Array showing whether each element in
|
the Categorical matches an element in the passed sequence of
|
`values` exactly.
|
|
Parameters
|
----------
|
values : set or list-like
|
The sequence of values to test. Passing in a single string will
|
raise a ``TypeError``. Instead, turn a single string into a
|
list of one element.
|
|
Returns
|
-------
|
np.ndarray[bool]
|
|
Raises
|
------
|
TypeError
|
* If `values` is not a set or list-like
|
|
See Also
|
--------
|
pandas.Series.isin : Equivalent method on Series.
|
|
Examples
|
--------
|
>>> s = pd.Categorical(['lama', 'cow', 'lama', 'beetle', 'lama',
|
... 'hippo'])
|
>>> s.isin(['cow', 'lama'])
|
array([ True, True, True, False, True, False])
|
|
Passing a single string as ``s.isin('lama')`` will raise an error. Use
|
a list of one element instead:
|
|
>>> s.isin(['lama'])
|
array([ True, False, True, False, True, False])
|
zIonly list-like objects are allowed to be passed to isin(), you passed a [rS Nr ) r, rf rx r\ rD ri rÇ r6 r_ rc r7 r rb )rk r Z values_typer¤ Z code_valuesru ru rv r s )
|
|
ÿ zCategorical.isin)r c C s( ddl m} t|d}|r | n| ¡ }tt |¡}| ¡ rxt |¡| }|j|j |¡ }|
|
|¡}t ||j |j¡ |j ¡ } | j||d} || }
|
|j |
|
¡} t t| ¡} t | dk| | ¡} | ¡ } | | ¡} | jdd} || } t|j|
|
| dd }t| | jjd
|
}t |||¡ |s$|S d S ) Nr ræ r )Ú
|
to_replacerÑ rV r! )r# FrT r ) rÁ rJ r rU r6 ri rÇ rd r_ r rê r r rb rg Z to_seriesrU Úget_indexer_forr rY r¡ r rì Zdrop_duplicatesra rc r1 r[ )rk r rÑ r rJ r ro ré Znew_catZserZ
|
all_valuesZidxrZlocsr× rî rÏ ru ru rv Ú_replaceÔ s:
|
|
|
|
ÿzCategorical._replace)Úconvertc C s< ddl m} | j}| j}|| ¡ |||¡}t|||dS )Nr ©Ú PandasArrayr´ )Úpandas.core.arraysr r_ rb rÅ Ú_str_mapr= ) rk Úfrn rg r r r_ rb r· ru ru rv r ú s
|
zCategorical._str_mapú|)rZ c C s ddl m} || t¡ |¡S )Nr r )r r r³ r÷ Ú_str_get_dummies)rk rZ r ru ru rv r s z Categorical._str_get_dummies)NNNFT).).).)T)N)NNN)F)NF)N)N)F)T)F)r5 T)Tr, T)T)r )r )erx Ú
|
__module__Ú __qualname__Ú__doc__Z__array_priority__rB Z _hidden_attrsÚ frozensetZ_typÚ__annotations__r Úpropertyrg r Ú classmethodr° r r³ r¸ rÄ rÊ r_ r[ rb rÐ rµ rÒ rÔ rÕ rØ rÞ rá rå rê rï rð r{ ry ÚeqrW rz rX ÚltrP ÚgtrQ ÚlerR ÚgerS rõ rô r? rö rÿ r r r r6 Zisnullr Znotnullr r r r r rà r* r( rc r- re r1 r2 r4 rA rM r] r= r< ra ró rj rÉ rÈ ru rç rw r` r rb r^ r r r ri rò r r Ú __classcell__ru ru r§ rv rM ö s
|
i ùd ÿ= ÿ D ÿE % DH
|
+E83Q
|
|
|
|
|
|
-
|
ÿ5û ÿûXù# ÿ !% ÿ 5' ÿ r_ r[ r )ZdelegateZ accessorsÚtyprÞ rá rå rê rï rØ rÔ rÕ rù c @ sT e Zd ZdZddddZedd Zdd Zd
|
d Ze d dd dZ
|
dd Z dS )ÚCategoricalAccessoraP
|
Accessor object for categorical properties of the Series values.
|
|
Parameters
|
----------
|
data : Series or CategoricalIndex
|
|
Examples
|
--------
|
>>> s = pd.Series(list("abbccc")).astype("category")
|
>>> s
|
0 a
|
1 b
|
2 b
|
3 c
|
4 c
|
5 c
|
dtype: category
|
Categories (3, object): ['a', 'b', 'c']
|
|
>>> s.cat.categories
|
Index(['a', 'b', 'c'], dtype='object')
|
|
>>> s.cat.rename_categories(list("cba"))
|
0 c
|
1 b
|
2 b
|
3 a
|
4 a
|
5 a
|
dtype: category
|
Categories (3, object): ['c', 'b', 'a']
|
|
>>> s.cat.reorder_categories(list("cba"))
|
0 a
|
1 b
|
2 b
|
3 c
|
4 c
|
5 c
|
dtype: category
|
Categories (3, object): ['c', 'b', 'a']
|
|
>>> s.cat.add_categories(["d", "e"])
|
0 a
|
1 b
|
2 b
|
3 c
|
4 c
|
5 c
|
dtype: category
|
Categories (5, object): ['a', 'b', 'c', 'd', 'e']
|
|
>>> s.cat.remove_categories(["a", "c"])
|
0 NaN
|
1 b
|
2 b
|
3 NaN
|
4 NaN
|
5 NaN
|
dtype: category
|
Categories (1, object): ['b']
|
|
>>> s1 = s.cat.add_categories(["d", "e"])
|
>>> s1.cat.remove_unused_categories()
|
0 a
|
1 b
|
2 b
|
3 c
|
4 c
|
5 c
|
dtype: category
|
Categories (3, object): ['a', 'b', 'c']
|
|
>>> s.cat.set_categories(list("abcde"))
|
0 a
|
1 b
|
2 b
|
3 c
|
4 c
|
5 c
|
dtype: category
|
Categories (5, object): ['a', 'b', 'c', 'd', 'e']
|
|
>>> s.cat.as_ordered()
|
0 a
|
1 b
|
2 b
|
3 c
|
4 c
|
5 c
|
dtype: category
|
Categories (3, object): ['a' < 'b' < 'c']
|
|
>>> s.cat.as_unordered()
|
0 a
|
1 b
|
2 b
|
3 c
|
4 c
|
5 c
|
dtype: category
|
Categories (3, object): ['a', 'b', 'c']
|
r r} c C s. | |¡ |j| _|j| _|j| _| ¡ d S r )Ú _validater Ú_parentr
|
Ú_indexr Ú_nameZ_freeze)rk Údataru ru rv r s
|
|
z CategoricalAccessor.__init__c C s t | jstdd S )Nz2Can only use .cat accessor with a 'category' dtype)r% rg ÚAttributeError)r¦ ru ru rv r¢ s
|
z CategoricalAccessor._validatec C s t | j|S r )rh r£ )rk r ru ru rv Ú_delegate_property_get s z*CategoricalAccessor._delegate_property_getc C s t | j||S r )Úsetattrr£ )rk r Z
|
new_valuesru ru rv Ú_delegate_property_set s z*CategoricalAccessor._delegate_property_setrK c C s ddl m} || jj| jdS )z>
|
Return Series of codes as well as the index.
|
r râ )r
|
)rÁ rK r£ rb r¤ )rk rK ru ru rv rb s zCategoricalAccessor.codesc O s@ ddl m} t| j|}|||}|d k r<||| j| jdS d S )Nr râ )r
|
r )rÁ rK rh r£ r¤ r¥ )rk r Úargsrþ rK rù rt ru ru rv Ú_delegate_method§ s
|
|
z$CategoricalAccessor._delegate_methodN) rx r r r r Ú staticmethodr¢ r¨ rª r rb r¬ ru ru ru rv r¡ s i
|
r¡ rJ r± )r_ r~ c C s< | j dkr(| ¡ }t||}| | j¡S | | ¡}t||S )z¤
|
utility routine to turn values into codes given the specified categories
|
|
If `values` is known to be a Categorical, use recode_for_categories instead.
|
r )r Zravelr¢ r r£ r r )r r_ Zflatrb ru ru rv r¢ ³ s
|
|
|
r¢ T)rb rU r~ c C sX t |dkr |r| ¡ S | S | |¡r6|r2| ¡ S | S t| |¡|}t|| dd}|S )a#
|
Convert a set of codes for to a new set of categories
|
|
Parameters
|
----------
|
codes : np.ndarray
|
old_categories, new_categories : Index
|
copy: bool, default True
|
Whether to copy if the codes are unchanged.
|
|
Returns
|
-------
|
new_codes : np.ndarray[np.int64]
|
|
Examples
|
--------
|
>>> old_cat = pd.Index(['b', 'a', 'c'])
|
>>> new_cat = pd.Index(['a', 'b'])
|
>>> codes = np.array([0, 1, 1, 2])
|
>>> recode_for_categories(codes, old_cat, new_cat)
|
array([ 1, 0, 0, -1], dtype=int8)
|
r rV r´ )rY rU r` r rc r= )rb Zold_categoriesr× rU Zindexerrî ru ru rv ra  s
|
ÿra ztuple[np.ndarray, Index]c C s ddl m} t| s tdt| rdt| } tjt| j | j
|
j d}t j || j d}||}| j
|
}nt | dd}|j }|j
|
}||fS )az
|
Factorize an input `values` into `categories` and `codes`. Preserves
|
categorical dtype in `categories`.
|
|
Parameters
|
----------
|
values : list-like
|
|
Returns
|
-------
|
codes : ndarray
|
categories : Index
|
If `values` has a categorical dtype, then `categories` is
|
a CategoricalIndex keeping the categories and order of `values`.
|
r )r zInput must be list-liker Fr )rÁ r r, r\ r% rC ri r rY r_ rb rg rM rÊ )r r Z cat_codesr r_ rb ru ru rv Úfactorize_from_iterableí s r® z$tuple[list[np.ndarray], list[Index]]c C s: t | dkrg g fS tdd | D \}}t|t|fS )a$
|
A higher-level wrapper over `factorize_from_iterable`.
|
|
Parameters
|
----------
|
iterables : list-like of list-likes
|
|
Returns
|
-------
|
codes : list of ndarrays
|
categories : list of Indexes
|
|
Notes
|
-----
|
See `factorize_from_iterable` for more info.
|
r c s s | ]}t |V qd S r )r® )r Úitru ru rv r +
|
s z+factorize_from_iterables.<locals>.<genexpr>)rY rh r )Ú iterablesrb r_ ru ru rv Úfactorize_from_iterables
|
s r± )T)wÚ
|
__future__r Úcsvr Ú functoolsr ry Úshutilr Útypingr r r r r
|
r r r Únumpyri Zpandas._configr Z pandas._libsr r rg r Zpandas._libs.arraysr Zpandas._typingr r r r r r r r r r Zpandas.compat.numpyr rl Zpandas.util._validatorsr Zpandas.core.dtypes.castr r Zpandas.core.dtypes.commonr! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 Zpandas.core.dtypes.dtypesr1 r2 Zpandas.core.dtypes.genericr3 r4 Zpandas.core.dtypes.missingr5 r6 Z pandas.corer7 r8 r9 Zpandas.core.accessorr: r; Zpandas.core.algorithmsr< r= Zpandas.core.arrays._mixinsr> r? Zpandas.core.baser@ rA rB Zpandas.core.commonÚcoreÚcommonr Zpandas.core.constructionrC rD Zpandas.core.ops.commonrE Zpandas.core.sortingrF Z pandas.core.strings.object_arrayrG rI rH rÁ rI rJ rK rL r{ r rM r¡ r¢ ra r® r± ru ru ru rv Ú<module> s ( 0 H I3 + ÿø
|
ô ÿ+)
|
