Ë
|
nñúh ã óö d dl mZ d dlmZ d dlmZ d dlZd dlmZ d dl m
|
Z
|
m Z m Z m Z d dlZd dlZd dlmZ d dlmZmZmZ d d lmZ d d
|
lmZ d d l m Z d d l m Z d d l!m"Z"m#Z# d dl$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ d dl0m1Z1m2Z2m3Z3m4Z4 d dl5m6Z6m7Z7 d dl8m9Z9m:Z: d dl;m<Z<m=Z=m>Z> d dl?m@Z@mAZA d dlBmCZCmDZD d dlEmFZFmGZG d dlHmIZImJZJmKZK d dlLmMc mNZO d dlPmQZQmRZR d dlSmTZT d dlUmVZV d dlWmXZX d dlYmZZZ e
|
r.d d l[m\Z\m]Z]m^Z^ d d l_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZj d d lkmlZlmmZmmnZn d Zod/d Zp G d! d"eFeKeX« Zq eAeqd#d$gd%¬&« eAeqg d'¢d(¬&« G d) d*e@eKeJ« « « Zr d0d+Zs d1 d2d,Ztd3d-Zud4d.Zvy)5é )Ú annotations)ÚQUOTE_NONNUMERIC)ÚpartialN)Úget_terminal_size)Ú TYPE_CHECKINGÚLiteralÚcastÚoverload)Ú
|
get_option)ÚNaTÚalgosÚlib)Ú NDArrayBacked)Úfunction)Úfind_stack_level)Úvalidate_bool_kwarg)Úcoerce_indexer_dtypeÚfind_common_type) Ú ensure_int64Úensure_platform_intÚis_any_real_numeric_dtypeÚ is_bool_dtypeÚ is_dict_likeÚ is_hashableÚis_integer_dtypeÚ is_list_likeÚ is_scalarÚneeds_i8_conversionÚ pandas_dtype)Ú
|
ArrowDtypeÚCategoricalDtypeÚCategoricalDtypeTypeÚ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)ÚHashableÚIteratorÚSequence) Ú ArrayLikeÚ AstypeArgÚAxisIntÚDtypeÚDtypeObjÚNpDtypeÚOrderedÚSelfÚShapeÚSortKindÚnpt)Ú DataFrameÚIndexÚSeriesc ó d j d t j u t « fd« }|_ |S )NÚ__c ó2 t |« }t |« r$t |« t | « k7 r |s t d« | j s
|
dv r t d« t |t « rÈd}| j |« s t |« | j sS| j j |j « s.t |j |j | j d¬« }n |j } | j |« }| j dk( |dk( z }|j « r||< |S |rc|| j v r>| j |« } | j |« }
|
dvr| j dk( }||< |S t! j" | | « S
|
d vrt d
|
|
d t% |« d « t |t& « r t) |j* « r || « S t- t/ j0 | «
|
« t/ j0 |« « 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 rO )rU Ú__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Ú
|
isinstanceÚ CategoricalÚ#_categories_match_up_to_permutationÚ
|
categoriesÚequalsÚrecode_for_categoriesÚcodesÚ_codesÚanyÚ _unbox_scalarr* Úinvalid_comparisonÚtyper1 r ÚdtypeÚgetattrÚnpÚarray) ÚselfÚotherÚhashableÚmsgÚ other_codesÚretÚmaskÚiÚ
|
fill_valueÚopÚopnames úQH:\Change_password\venv_build\Lib\site-packages\pandas/core/arrays/categorical.pyÚfuncz _cat_compare_op.<locals>.func~ sô ø ä uÓ%Ü Ô ¤3 u£:´°T³Ò#:Á8ä Ð 2Ó3Ð 3à||ØÐAÑAÜ ØMóð ô e[Ô )ð TCØ×;Ñ;¸EÔBÜ nÐ$à<<¨¯©×(>Ñ(>¸u×?OÑ?OÔ(Pä 3ØKK ×!1Ñ!1°4·?±?Èô ð $ll áT[[ +Ó.CØKK 2Ñ%¨+¸Ñ*;Ñ<DØxxzØ &D ØJá ØÑ'Ø×&Ñ& uÓ-Ù aÓ(àÐ!?Ñ?ð ;;¨"Ñ,DØ *CIØ
|
ä×-Ñ-¨d°E¸2Ó>Ð>ð Ð 1Ñ1Ü Ø:¸6¸(ð C Ü K=ð )8ð8óð ô %¤ Ô0Ô5HÈÏÉÔ5Uñ % Ð&Ø27288 D>¨6Ó2´2·8±8¸E³?ÓCÐ Có )Ú__name__ÚoperatorÚner6 )rt rw rs ru s ` @@rv Ú_cat_compare_opr| z sK ú Ø"++ bÐ !FØx{{Ð"Jä fÓ%õ=Dó &ð=Dð~ DMà Krx c óÂ t |« | j j |« }t |« r|v S t fd|D « « S # t t f$ r Y yw xY w)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 ó& K | ] }|v
|
y w©N© )Ú.0Úloc_Ú containers rv ú <genexpr>zcontains.<locals>.<genexpr>ó s øè ø Ò5¨49Ô$Ñ5ùs )Úhashr^ Úget_locÚKeyErrorrZ r rc )ÚcatÚkeyr Úlocs ` rv Úcontainsr à se ø ô: Ið
|
Ønn×$Ñ$ SÓ)ô ~ØiÐ Ð ô Ó5°Ô5Ó5Ð5øô iÐ ò Ùðús A Á A Á A c ó0 e Zd ZU dZdZej edg« z ZdZde d< e
|
de fd « Z ddde j d f df fd
|
Zedgd « Zedhd « Ze
|
dd d did« Ze
|
djd« Zedkdld« Zedkdmd« Zedkdnd« Zdodn fd Zd Ze
|
dp dqd« Ze
|
dr dsd« Zedtd« Zedud« Zedvd« Zdwdx fd Z dyd Z dzd Z dqd Z dqd Z d{d|d!Z!dqd"Z"dpdqd#Z#dqd$Z$dqd%Z%dqd&Z&e j f d}d'Z' e(e)jT « Z+ e(e)jX « Z- e(e)j\ « Z/ e(e)j` « Z1 e(e)jd « Z3 e(e)jh « Z5d( Z6d) Z7e
|
d~d*« Z8e9 d dd+« Z:dd,Z;d fd- Z<edhd.« Z=dwdd/Z>dd0Z?e?Z@dd1ZAeAZBdod
d2ZCe
|
dd3« ZDdd4ZEdd5ZFd d6d7 d fd8ZGedddd9 dd:« ZHeddd; dd<« ZHd d d=d9 dd>ZHd?d@dAd d dB ddCZIdvdDZJ ddEZKedvdF« ZLddGZMdhdHZNddIZOddJZPdwddKZQddLZRddMZSddNZTddOZUdP ZVddQZWd d dR d fdSZXd dTddUZYd dTddVZZdoddWZ[dq fdX Z\ddZZ]e
|
ddd[« Z^dd\Z_dd]Z`dd^Zadd_Zbd d`ddaZce j edj dY« d f d dbZed¡d¢dcZf d£ddZg xZhS )¤r\ aZ
|
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è ÚtolistÚ categoricalr! Ú_dtypec ó t ||j « }t d¬« j |« }t | ||« S )NF©rY )r r^ r! Ú update_dtypeÚsuperÚ _simple_new)Úclsra rg Ú __class__s rv r zCategorical._simple_newg s> ø ô % U¨E×,<Ñ,<Ó=Ü ¨Ô/×<Ñ<¸UÓCÜwÑ" 5¨%Ó0Ð0rx NTc ó
|
|t j ur%t j dt t « ¬« nd}t j ||||« }|rBt ||j « }t d¬« j |« }t | 1 ||« y t |« s t d« t j d« }t# |dd « } t% | t « r/|j Nt |j |j& « }n,t% |t( t* t, f« st/ j0 |« }t% |t2 « r*t5 |« dk( r t j g t6 ¬« }nÁt% |t j8 « r'|j: d kD r t= d
|
« t? |d « }nt? |d « }
|
tA |
|
« }|jC « rWt jD | « d D cg c] } || } } | s|
|
jF d k( rd } n |
|
jF } t? | d | ¬« }
|
|
|
}|j t% |jF tH « r£tK |jF jL tN « r|jP jS « }
|
|
|
jT jW tH ¬ « }|
|
jX j[ « }t ||jF j\ j& « }n·t% |t( « s t? |d « } t_ |d ¬« \ }}t ||j& « }nst% |jF t « rCta |« jb }te ||jF j |j |¬« }ntg ||j « }|jC « r4t jh |jj |jF ¬« }||| < |}t d¬« j |« }t ||j « }
|
t | 1 |
|
|« y c c} w # t $ r3}t_ |d¬« \ }}|j& r t d« |Y d }~Ld }~ww xY w)NzThe 'fastpath' keyword in Categorical is deprecated and will be removed in a future version. Use Categorical.from_codes instead©Ú
|
stacklevelFr z#Categorical input must be list-likerg r ©rg é z3> 1 ndim Categorical are not supported at this timeÚobject)Ú types_mapperT©Úsortzl'values' is not ordered, please explicitly specify the categories order by passing in a categories argument.rR )6r Ú
|
no_defaultÚwarningsÚwarnÚDeprecationWarningr r! Ú_from_values_or_dtyper r^ r r Ú__init__r rZ ri rj rh r[ rY r$ r% r1 ÚcomÚconvert_to_list_likeÚlistrW r ÚndarrayÚndimÚNotImplementedErrorr5 r' rc Úwhererg r Ú
|
issubclassrf r" Ú _pa_arrayÚcombine_chunksÚ
|
dictionaryÚ to_pandasÚindicesÚto_numpyÚ pyarrow_dtyper- r4 rb r` Ú_get_codes_for_valuesÚonesÚshape)rk Úvaluesr^ rY rg ÚfastpathrS ra Ú null_maskÚvdtypeÚarrÚidxÚarr_listÚsanitize_dtypeÚerrÚ old_codesÚ
|
full_codesr s rv r¥ zCategorical.__init__s s¼ ø ð 3>>Ñ )ä MMðUä"Ü+Ó-ö ð Hä ×6Ñ6Ø J ¨ó
|
ñ Ü(¨°×1AÑ1AÓBEÜ$¨UÔ3×@Ñ@ÀÓGEÜ GÑ U EÔ *Ø äFÔ#äÐ AÓBÐ Bô HHUO ô ¨$Ó/Ü fÔ .Ô /Ø× Ñ Ñ'Ü(¨×):Ñ):¸E¿M¹MÓJÜF¤X¬y¼.Ð$IÕJÜ×-Ñ-¨fÓ5FÜ&¤$Ô'¬C°«K¸1Ò,<ä "¬FÔ3ÜF¤B§J¡JÔ/Ø;; ?ä-ØMóð ô (¨°Ó5ô % V¨TÓ2Ü I Ø ==?ô 8:·x±xÀÀ
|
Ó7KÈAÑ7NÖ O° s£ Ð OHÐ Oñ 3§9¡9°Ò#8Ø)-à),¯©ä(¨°4¸~ÔNCØ à × Ñ Ñ #Ü&,,¬
|
Ô3¼
|
Ø ×!Ñ!Ô#7ô9ð ×&Ñ&×5Ñ5Ó7Ø ^^× 5Ñ 5Ä:Ð 5Ó N
|
Ø ×,Ñ,Ó.Ü(¨°V·\±\×5OÑ5O×5WÑ5WÓXä! &¬(Ô3ä +¨F°DÓ 9Fð #Ü(1°&¸tÔ(DÑ%E:ô )¨°U·]±]ÓCä Ô&6Ô 7Ü% fÓ-×4Ñ4IÜ)Ø6<<×2Ñ2°E×4DÑ4DÈ4ôEô
|
*¨&°%×2BÑ2BÓCEà ==?ä '' )§/¡/¸¿¹ÔEÐEJØ%*J zÑ "Ø Eä ¨Ô/×<Ñ<¸UÓCÜ" 5¨%×*:Ñ*:Ó;Ü ÑeÕ$ùòq Pøô2 !ò #Ü(1°&¸uÔ(EÑ%E:Ø }}ô (ð Có ð #ð #õ %ûð #ús Ç< QÌ!Q Ñ RÑ(Q=Ñ=Rc ó | j S )an
|
The :class:`~pandas.api.types.CategoricalDtype` for this instance.
|
|
Examples
|
--------
|
>>> cat = pd.Categorical(['a', 'b'], ordered=True)
|
>>> cat
|
['a', 'b']
|
Categories (2, object): ['a' < 'b']
|
>>> cat.dtype
|
CategoricalDtype(categories=['a', 'b'], ordered=True, categories_dtype=object)
|
)r ©rk s rv rg zCategorical.dtypeî s ð {{Ðrx c óP | j j }|j d« S ©NrT )Ú_ndarrayrg rf )rk rg s rv Ú_internal_fill_valuez Categorical._internal_fill_valueþ s! ð ×#Ñ#Øzz"~Ð rx F©rg rS c ó | |||¬« S )NrÉ r )r Úscalarsrg rS s rv Ú_from_sequencezCategorical._from_sequence s ñ 7 %¨dÔ3Ð3rx c ó |t | j ||¬« }t |« }||j « k( j « st |S )Nr )r« rÌ r' ÚallrX )r rË rg Úresrq s rv Ú _from_scalarszCategorical._from_scalars sO à =ä%Ð %à× Ñ °Ð Ó6ô G}Ø
|
Ñ"×'Ñ'Ô)ä Ð Ø
|
rx .c ó y r r ©rk rg rS s rv ÚastypezCategorical.astype ó à rx c ó y r r rÒ s rv rÓ zCategorical.astype rÔ rx c ó y r r rÒ s rv rÓ zCategorical.astype# rÔ rx c ój t |« }| j |u r|r| j « }|S | }|S t |t « rB| j j |« }|r| j « n| } | j |« }|S t |t « rt | % ||¬« S |j dv r)| j « j « r t d« t | j « dk( st | j « dk( r4|st# j$ | |¬« }|S t# j& | |¬« }|S | j j( } |j ||¬« }| j j* }t- ||« sKt/ j0 t# j& | j j* « j |« « }t5 |t7 | j8 « |¬ « }|S # t2 t f$ r( d| j j d| }t |« w xY w)
|
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.
|
rR Úiuz#Cannot convert float NaN to integerr r rÉ z Cannot cast z
|
dtype to ©rs ) r rg rS r[ r! r Ú
|
_set_dtyper# r rÓ Úkindr' rc rX rW ra r^ ri Úasarrayrj Ú_valuesÚ _na_valuer& r Úitem_from_zerodimrZ r. r rb )rk rg rS ÚresultÚnew_catsrs rn r s rv rÓ zCategorical.astype' sû ø ô UÓ#Ø ::Ñ Ù$(TYY[FðX ðY /3FðX ôU Ô /Ô 0àJJ×+Ñ+¨EÓ2EÙ"&499;¨DDØ__ UÓ+FðL ôI ~Ô .Ü7> %¨d>Ó3Ð 3à ZZ4Ñ D§I¡I£K§O¡OÔ$5Ü Ð BÓCÐ Cä _ Ò !¤S¨¯ © Ó%9¸QÒ%>ñ Ü D°Ô6ð4 ô1 $¨eÔ4ð0 ð) ×.Ñ.Hð &Ø#??°¸T?ÓBØ !__× 6Ñ 6
|
Ü,¨Z¸Ô?Ü!$×!6Ñ!6Ü § ¡ ×!:Ñ!:Ó;×BÑBÀ5ÓIó"Jô ØÔ-¨d¯k©kÓ:ÀzôFð øô Üðò &ð % T§_¡_×%:Ñ%:Ð$;¸:ÀeÀWÐMÜ oÐ%ð &ús ÅB G; Ç;7H2c ój t j dt t « ¬« | j « S )z#
|
Alias for tolist.
|
zcCategorical.to_list is deprecated and will be removed in a future version. Use obj.tolist() insteadr )r¡ r¢ Ú FutureWarningr r rÄ s rv Úto_listzCategorical.to_listc s, ô
|
ð 0ä Ü'Ó)õ
|
ð {{}Ð rx c ó ddl m}m}m}m} ||« } t |t « xr |j du}
|
|
|
rÊt |j j « r ||d¬« } n t j |j j d« r ||d¬« } nkt j |j j d« r ||d¬« } n6t |j j « r|g d¢}| j |« } |
|
r|j } t || | « } nV| j s;| j! « } | j# « } t || | « } t | d ¬
|
« }nt | d ¬
|
« }|} | j% | |¬ « 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 )rI Ú to_datetimeÚ
|
to_numericÚ to_timedeltaNÚcoerce)ÚerrorsÚMÚm)ÚTrueÚTRUEÚtrueFr r )ÚpandasrI ræ rç rè r[ r! r^ r rg r Ú is_np_dtyper Úisinr` Úis_monotonic_increasingrS Ú sort_valuesr )r Úinferred_categoriesÚinferred_codesrg Ú true_valuesrI ræ rç rè ÚcatsÚknown_categoriesr^ ra Úunsorteds rv Ú_from_inferred_categoriesz%Categorical._from_inferred_categoriesp sX ÷0
|
ó
|
ñ Ð(Ó)ä uÔ .Ó /Ò P°E×4DÑ4DÈDÐ4Pð ñ ä(¨×)9Ñ)9×)?Ñ)?Ô@Ù!Ð"5¸hÔGÜ ×!1Ñ!1×!7Ñ!7¸Ô=Ù"Ð#6¸xÔHÜ ×!1Ñ!1×!7Ñ!7¸Ô=Ù#Ð$7ÀÔIÜ u× /Ñ /× 5Ñ 5Ô6Ø Ð&Ú":Kð yy Ó-á à ×)Ñ)JÜ)¨.¸$À
|
ÓKEØ×-Ò-àyy{HØ ×)Ñ)Ó+Jä)¨.¸(ÀJÓOEÜ$ Z¸Ô?Eä$ T°5Ô9EØ"Eàu¨EÓ2Ð2rx c ó´ t j |||¬« }|j d}t |« |r| j ||¬« }| j ||¬« 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`.
|
validate : bool, default True
|
If True, validate that the codes are valid for the dtype.
|
If False, don't validate that the codes are valid. Be careful about skipping
|
validation, as invalid codes can lead to severe problems, such as segfaults.
|
|
.. versionadded:: 2.1.0
|
|
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^ rY rg zKThe categories must be provided in 'categories' or 'dtype'. Both were None.r )r! r¤ r^ rX Ú_validate_codes_for_dtyper )r ra r^ rY rg Úvalidatern s rv Ú
|
from_codeszCategorical.from_codesµ sk ôj !×6Ñ6Ø!¨7¸%ô
|
ð × Ñ Ð #ð+ð ô S/Ð !á à×1Ñ1°%¸uÐ1ÓEEàu¨EÓ2Ð2rx c ó. | j j S )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.
|
|
Examples
|
--------
|
For :class:`pandas.Series`:
|
|
>>> ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
|
>>> ser.cat.categories
|
Index(['a', 'b', 'c'], dtype='object')
|
|
>>> raw_cat = pd.Categorical(['a', 'b', 'c', 'a'], categories=['b', 'c', 'd'])
|
>>> ser = pd.Series(raw_cat)
|
>>> ser.cat.categories
|
Index(['b', 'c', 'd'], dtype='object')
|
|
For :class:`pandas.Categorical`:
|
|
>>> cat = pd.Categorical(['a', 'b'], ordered=True)
|
>>> cat.categories
|
Index(['a', 'b'], dtype='object')
|
|
For :class:`pandas.CategoricalIndex`:
|
|
>>> ci = pd.CategoricalIndex(['a', 'c', 'b', 'a', 'c', 'b'])
|
>>> ci.categories
|
Index(['a', 'b', 'c'], dtype='object')
|
|
>>> ci = pd.CategoricalIndex(['a', 'c'], categories=['c', 'b', 'a'])
|
>>> ci.categories
|
Index(['c', 'b', 'a'], dtype='object')
|
)rg r^ rÄ s rv r^ zCategorical.categoriesý s ðp zz×$Ñ$Ð$rx c ó. | j j S )a{
|
Whether the categories have an ordered relationship.
|
|
Examples
|
--------
|
For :class:`pandas.Series`:
|
|
>>> ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
|
>>> ser.cat.ordered
|
False
|
|
>>> raw_cat = pd.Categorical(['a', 'b', 'c', 'a'], ordered=True)
|
>>> ser = pd.Series(raw_cat)
|
>>> ser.cat.ordered
|
True
|
|
For :class:`pandas.Categorical`:
|
|
>>> cat = pd.Categorical(['a', 'b'], ordered=True)
|
>>> cat.ordered
|
True
|
|
>>> cat = pd.Categorical(['a', 'b'], ordered=False)
|
>>> cat.ordered
|
False
|
|
For :class:`pandas.CategoricalIndex`:
|
|
>>> ci = pd.CategoricalIndex(['a', 'b'], ordered=True)
|
>>> ci.ordered
|
True
|
|
>>> ci = pd.CategoricalIndex(['a', 'b'], ordered=False)
|
>>> ci.ordered
|
False
|
)rg rY rÄ s rv rY zCategorical.ordered7 s ðL zz×!Ñ!Ð!rx c ó\ | j j « }d|j _ |S )a§
|
The category codes of this categorical index.
|
|
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.
|
|
Examples
|
--------
|
For :class:`pandas.Categorical`:
|
|
>>> cat = pd.Categorical(['a', 'b'], ordered=True)
|
>>> cat.codes
|
array([0, 1], dtype=int8)
|
|
For :class:`pandas.CategoricalIndex`:
|
|
>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'])
|
>>> ci.codes
|
array([0, 1, 2, 0, 1, 2], dtype=int8)
|
|
>>> ci = pd.CategoricalIndex(['a', 'c'], categories=['c', 'b', 'a'])
|
>>> ci.codes
|
array([2, 0], dtype=int8)
|
F)rb ÚviewÚflagsÚ writeable)rk Úvs rv ra zCategorical.codes_ s( ðD KK× Ñ Ó Ø !ÔØrx c ó^ |r!t j || j « }nt || j ¬« }|sV| j j @t |j « t | j j « k7 r t d« t | ! | j |« y)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!)
|
r! Ú_from_fastpathrY rg r^ rW rX r r¥ rÇ )rk r^ r¹ Ú new_dtyper s rv Ú_set_categorieszCategorical._set_categories
s ø ñ* Ü(×7Ñ7¸
|
ÀDÇLÁLÓQIä(¨¸T¿\¹\ÔJIáØ
|
|
×%Ñ%Ð1ÜI×(Ñ(Ó)¬S°·±×1FÑ1FÓ-GÒGä ð/óð ô
|
Ñ ¨ Õ2rx c ó t | j | j |j « }t | « j ||¬« S )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`.
|
r )r` ra r^ rf r )rk rg ra s rv rÚ zCategorical._set_dtypeª s: ô & d§j¡j°$·/±/À5×CSÑCSÓTÜDz×%Ñ% e°5Ð%Ó9Ð9rx c ó t | j |¬« }| j « }t j ||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 )r! r^ rS r r¥ rÇ )rk Úvaluer r s rv Ú set_orderedzCategorical.set_orderedº s: ô % T§_¡_¸eÔD ØiikÜ× Ñ s C§L¡L°)Ô<Ø
|
rx c ó$ | j d« S )ae
|
Set the Categorical to be ordered.
|
|
Returns
|
-------
|
Categorical
|
Ordered Categorical.
|
|
Examples
|
--------
|
For :class:`pandas.Series`:
|
|
>>> ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
|
>>> ser.cat.ordered
|
False
|
>>> ser = ser.cat.as_ordered()
|
>>> ser.cat.ordered
|
True
|
|
For :class:`pandas.CategoricalIndex`:
|
|
>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a'])
|
>>> ci.ordered
|
False
|
>>> ci = ci.as_ordered()
|
>>> ci.ordered
|
True
|
T©r rÄ s rv Ú
|
as_orderedzCategorical.as_orderedÈ s ð: × Ñ Ó%Ð%rx c ó$ | j d« S )a¥
|
Set the Categorical to be unordered.
|
|
Returns
|
-------
|
Categorical
|
Unordered Categorical.
|
|
Examples
|
--------
|
For :class:`pandas.Series`:
|
|
>>> raw_cat = pd.Categorical(['a', 'b', 'c', 'a'], ordered=True)
|
>>> ser = pd.Series(raw_cat)
|
>>> ser.cat.ordered
|
True
|
>>> ser = ser.cat.as_unordered()
|
>>> ser.cat.ordered
|
False
|
|
For :class:`pandas.CategoricalIndex`:
|
|
>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a'], ordered=True)
|
>>> ci.ordered
|
True
|
>>> ci = ci.as_unordered()
|
>>> ci.ordered
|
False
|
Fr rÄ s rv Ú as_unorderedzCategorical.as_unorderedç s ð< × Ñ Ó&Ð&rx c ó || j j }t ||¬« }| j « }|r|j j dt |j « t |j j « k r/d|j |j t |j « k\ < |j }n+t |j |j |j « }t j |||« |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 simply 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.
|
|
Examples
|
--------
|
For :class:`pandas.Series`:
|
|
>>> raw_cat = pd.Categorical(['a', 'b', 'c', 'A'],
|
... categories=['a', 'b', 'c'], ordered=True)
|
>>> ser = pd.Series(raw_cat)
|
>>> ser
|
0 a
|
1 b
|
2 c
|
3 NaN
|
dtype: category
|
Categories (3, object): ['a' < 'b' < 'c']
|
|
>>> ser.cat.set_categories(['A', 'B', 'C'], rename=True)
|
0 A
|
1 B
|
2 C
|
3 NaN
|
dtype: category
|
Categories (3, object): ['A' < 'B' < 'C']
|
|
For :class:`pandas.CategoricalIndex`:
|
|
>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'A'],
|
... categories=['a', 'b', 'c'], ordered=True)
|
>>> ci
|
CategoricalIndex(['a', 'b', 'c', nan], categories=['a', 'b', 'c'],
|
ordered=True, dtype='category')
|
|
>>> ci.set_categories(['A', 'b', 'c'])
|
CategoricalIndex([nan, 'b', 'c', nan], categories=['A', 'b', 'c'],
|
ordered=True, dtype='category')
|
>>> ci.set_categories(['A', 'b', 'c'], rename=True)
|
CategoricalIndex(['A', 'b', 'c', nan], categories=['A', 'b', 'c'],
|
ordered=True, dtype='category')
|
r rT ) rg rY r! rS r^ rW rb r` ra r r¥ )rk Únew_categoriesrY Úrenamer r ra s rv Úset_categorieszCategorical.set_categories sÒ ðn ?Øjj×(Ñ(GÜ$ ^¸WÔE àiikÙ Øyy×#Ñ#Ð/´C¸ ×8LÑ8LÓ4MÔPSØ ×$Ñ$óQò 5ð GI
|
|
3::¬¨Y×-AÑ-AÓ)BÑBÑCØJJEä)Ø 3>>¨9×+?Ñ+?óEô × Ñ s E¨9Ô5Ø
|
rx c ó t |« r*| j D cg c] }|j ||« }}n*t |« r | j D cg c]
|
} ||« }}| j « }|j |« |S c c}w c c}w )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']
|
)r r^ ÚgetÚcallablerS r
|
)rk r Úitemr s rv Úrename_categoriesz Categorical.rename_categoriesq s ôz Ô 'à;?¿?¹?ö Ø37×"Ñ" 4¨Õ.ð Nñ ô nÔ %Ø?C¿¹Ö O°tn¨TÕ 2Ð ONÐ OàiikØ ×ÑNÔ+Ø
|
ùò ùò Ps BÁBc óÊ t | j « t |« k7 s%| j j |« j s t d« | j ||¬« S )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.
|
|
Examples
|
--------
|
For :class:`pandas.Series`:
|
|
>>> ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
|
>>> ser = ser.cat.reorder_categories(['c', 'b', 'a'], ordered=True)
|
>>> ser
|
0 a
|
1 b
|
2 c
|
3 a
|
dtype: category
|
Categories (3, object): ['c' < 'b' < 'a']
|
|
>>> ser.sort_values()
|
2 c
|
1 b
|
0 a
|
3 a
|
dtype: category
|
Categories (3, object): ['c' < 'b' < 'a']
|
|
For :class:`pandas.CategoricalIndex`:
|
|
>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a'])
|
>>> ci
|
CategoricalIndex(['a', 'b', 'c', 'a'], categories=['a', 'b', 'c'],
|
ordered=False, dtype='category')
|
>>> ci.reorder_categories(['c', 'b', 'a'], ordered=True)
|
CategoricalIndex(['a', 'b', 'c', 'a'], categories=['c', 'b', 'a'],
|
ordered=True, dtype='category')
|
z=items in new_categories are not the same as in old categoriesr )rW r^ Ú
|
differenceÚemptyrX r )rk r rY s rv Úreorder_categoriesz Categorical.reorder_categories¹ s[ ôF Ó ¤C¨Ó$7Ò 7Ø??×-Ñ-¨nÓ=×CÒCä ØOóð ð ×"Ñ" >¸7Ð"ÓCÐCrx c ó¶ t |« s|g}t |« t | j j « z }t |« dk7 rt d| « t |d« roddlm} t | j j j |j g« } |t | j j « t |« z |¬« }n+t | j j « t |« z }t || j « }| j « }t |j |j « }t! j" |||« |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 ©rJ r )r Úsetrg r^ rW rX Úhasattrrð rJ r r¨ r! rY rS r rÇ r r¥ )rk r Úalready_includedrJ rg r r ra s rv Úadd_categorieszCategorical.add_categories s$ ôV NÔ+Ø ,Ð -NÜ ~Ó.´°T·Z±Z×5JÑ5JÓ1KÑKÐÜ Ð Ó AÒ %Ü ØBÐCSÐBTÐUóð ô > 7Ô +Ý %ä$Ø×&Ñ&×,Ñ,¨n×.BÑ.BÐCóEñ $ÜTZZ×*Ñ*Ó+¬d°>Ó.BÑBÈ%ô Nô " $§*¡*×"7Ñ"7Ó 8¼4ÀÓ;OÑ ONä$ ^°T·\±\ÓB ØiikÜ$ S§\¡\°9×3GÑ3GÓHÜ× Ñ s E¨9Ô5Ø
|
rx c ó ddl m} t |« s|g} ||« j « j « }| j
|
j du r'| j
|
j j |d¬« n$| j
|
j j |« }|j | j
|
j « }t |« dk7 rt |« }t d| « | j || j d¬« S )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 ©rI TFr z(removals must all be in old categories: )rY r ) rð rI r ÚuniqueÚdropnarg rY r^ r rW r# rX r )rk ÚremovalsrI r Ú not_includeds rv Úremove_categoriesz Categorical.remove_categoriesI så õR !äHÔ%Ø zHá?×)Ñ)Ó+×2Ñ2Ó4ð zz×!Ñ! TÑ)ð JJ× !Ñ !× ,Ñ ,¨X¸EÐ ,Ô Bà×&Ñ&×1Ñ1°(Ó;ð ð
|
×*Ñ*¨4¯:©:×+@Ñ+@ÓA ä |Ó Ò !Ü |Ó,LÜ Ð GÈ À~Ð VÓWÐ Wà×"Ñ" >¸4¿<¹<ÐPUÐ"ÓVÐVrx c ó t j | j d¬« \ }}|j dk7 r|d dk( r
|
|dd |dz
|
}}| j j
|
j |« }t j || j ¬« }t ||j
|
« }| j « }t j |||« |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)Úreturn_inverser rT r Nr )ri r) rb Úsizerg r^ Útaker! r rY r rS r r¥ )rk r½ Úinvr r Ú new_codesr s rv Úremove_unused_categoriesz$Categorical.remove_unused_categories
s® ôD 99T[[¸Ô>Sà 88q=S V r\Ø12w a¡Cà ×.Ñ.×3Ñ3°CÓ8Ü$×3Ñ3Ø D§L¡Lô
|
ô )¨¨i×.BÑ.BÓC àiikÜ× Ñ s I¨yÔ9Ø
|
rx c ó6 |t j u r&t j dt t « ¬« d}t |« s t |« sJ | j j |« }t j | j dk( « }t j }|Q|rOt |« r |t j « n-|j t j t j « }|j ra|j sU|t j u rCt# || j$ ¬« }| j' | j j) « |d¬« S |r|j+ t- |« |« }t j. || j « S )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.
|
na_action : {None, 'ignore'}, default 'ignore'
|
If 'ignore', propagate NaN values, without passing them to the
|
mapping correspondence.
|
|
.. deprecated:: 2.1.0
|
|
The default value of 'ignore' has been deprecated and will be changed to
|
None in the future.
|
|
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(), na_action=None)
|
['A', 'B', 'C']
|
Categories (3, object): ['A', 'B', 'C']
|
>>> cat.map({'a': 'first', 'b': 'second', 'c': 'third'}, na_action=None)
|
['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}, na_action=None)
|
[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'}, na_action=None)
|
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'}, na_action=None)
|
Index(['first', 'second', nan], dtype='object')
|
zÝThe default value of 'ignore' for the `na_action` parameter in pandas.Categorical.map is deprecated and will be changed to 'None' in a future version. Please set na_action to the desired value to avoid seeing this warningr ÚignorerT r F©rg rþ )r r r¡ r¢ rã r r r r^ Úmapri rc rb Únanr Ú is_uniqueÚhasnansr! rY rÿ rS ÚinsertrW r1 )rk ÚmapperÚ na_actionr Úhas_nansÚna_valr s rv r8 zCategorical.map¸ s2 ðb Ñ &Ü MMð=ô Ü+Ó-õ ð !IäÔ ¤<°Ô#7Ð7Ð7à ×,Ñ,¨VÓ4ä66$++¨Ñ+Ó,äØ Ð ¡Ü'/°Ô'7VBFF^¸V¿Z¹ZÌÏÉÔPR×PVÑPVÓ=WFà × #Ò #¨N×,BÒ,BÀvÔQS×QWÑQWÑGWÜ(¨ ÀÇ Á ÔNIØ?? 4§;¡;×#3Ñ#3Ó#5¸YÐQV?ÓWÐ Wá Ø +× 2Ñ 2´3°~Ó3FÈÓ ONäww~ t§{¡{Ó3Ð3rx c ó\ t |« s| j |« S | j |« S r )r Ú_validate_listlikeÚ_validate_scalar)rk r s rv Ú_validate_setitem_valuez#Categorical._validate_setitem_value1 s, Ü5Ô!à×*Ñ*¨5Ó1Ð 1à×(Ñ(¨Ó/Ð /rx c ó¬ t || j j « rd}|S || j v r| j |« }|S t d| d« d)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
|
rT z5Cannot setitem on a Categorical with a new category (z), set the categories firstN)r& r^ rg rd rZ )rk rs s rv rC z Categorical._validate_scalar8 sr ô$ ! ¨T¯_©_×-BÑ-BÔ CØJð Ðð 4??Ñ *Ø ×+Ñ+¨JÓ7Jð Ðô ð Ø 'LÐ(CðEóð ð rx c óþ t |t « rZt |j « rEt |« j « r t d« |j t j ¬« }nt j |« }t |« r#|j j dvr t d« t |« rD|j « t |j « k\ s|j « dk r t d« |S )Nz codes cannot contain NA valuesr rØ z$codes need to be array-like integersrT z1codes need to be between -1 and len(categories)-1)r[ r1 r rg r' rc rX r³ ri Úint64rÜ rW rÛ Úmaxr^ Úmin)r ra rg s rv rý z%Categorical._validate_codes_for_dtypeU s¶ ä e^Ô ,Ô1AÀ%Ç+Á+Ô1NäE{Ô Ü Ð!AÓBÐBØNN¬¯©NÓ2EäJJuÓ%EÜ u:%++×*Ñ*°$Ñ6Ü Ð CÓDÐ Dä u:599;¬#¨e×.>Ñ.>Ó*?Ò?À5Ç9Á9Ã;ÐQSÒCSÜ Ð PÓQÐ QØ rx c óÔ |du r$t j dt t « ¬« t | j
|
j | j « }t j ||¬« S )a
|
The numpy array interface.
|
|
Users should not call this directly. Rather, it is invoked by
|
:func:`numpy.array` and :func:`numpy.asarray`.
|
|
Parameters
|
----------
|
dtype : np.dtype or None
|
Specifies the the dtype for the array.
|
|
copy : bool or None, optional
|
See :func:`numpy.asarray`.
|
|
Returns
|
-------
|
numpy.array
|
A numpy array of either the specified dtype or,
|
if dtype==None (default), the same dtype as
|
categorical.categories.dtype.
|
|
Examples
|
--------
|
|
>>> cat = pd.Categorical(['a', 'b'], ordered=True)
|
|
The following calls ``cat.__array__``
|
|
>>> np.asarray(cat)
|
array(['a', 'b'], dtype=object)
|
FaS Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
|
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.r r )
|
r¡ r¢ rã r r. r^ rÝ rb ri rÜ )rk rg rS rp s rv Ú __array__zCategorical.__array__g sW ðF 5=Ü MMð2ô Ü+Ó-õ ô doo×-Ñ-¨t¯{©{Ó;ô zz# UÔ+Ð+rx c ó( t j | ||g|¢i |¤}|t ur|S d|v rt j | ||g|¢i |¤S |dk( r%t j | ||g|¢i |¤}|t ur|S t d| j d|j « )NÚoutÚreducezObject with dtype z cannot perform the numpy op )r) Ú!maybe_dispatch_ufunc_to_dunder_opÚNotImplementedÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncrZ rg ry )rk ÚufuncÚmethodÚinputsÚkwargsrà s rv Ú__array_ufunc__zCategorical.__array_ufunc__ s× ä×<Ñ<Ø %ð
|
Ø"(ò
|
Ø,2ñ
|
ð Ñ 'ØMà F?ä ×4Ñ4ØeVðØ&,òØ06ñð ð XÒ ä ×7Ñ7ØeVðØ&,òØ06ñFð ^Ñ+Ø ô Ø §¡ ð - Ø !NNÐ+ð -ó
|
ð
|
rx c óÌ t |t « st | |« S d|vrt |d |d « |d< d|v rd|vr|j d« |d< t | |« y)z*Necessary for making this object picklabler Ú _categoriesÚ_orderedrb rÇ N)r[ Údictr Ú __setstate__r! Úpop)rk Ústater s rv r\ zCategorical.__setstate__» sn ø ä%¤Ô&Ü7Ñ'¨Ó.Ð .à 5Ñ Ü .¨u°]Ñ/CÀUÈ:ÑEVÓ WE(Oà uÑ °5Ñ!8à %§ ¡ ¨(Ó 3E*Ñ ä Ñ UÕ#rx c ó | j j | j j j j z S r )rb Únbytesrg r^ r¸ rÄ s rv r` zCategorical.nbytesÉ s- à{{×!Ñ! D§J¡J×$9Ñ$9×$@Ñ$@×$GÑ$GÑGÐGrx c ó| | j j | j j j |¬« z 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
|
)Údeep)rb r` rg r^ Ú memory_usage)rk rb s rv rc zCategorical.memory_usageÍ s1 ð. {{×!Ñ! D§J¡J×$9Ñ$9×$FÑ$FÈDÐ$FÓ$QÑQÐQrx c ó | j dk( S )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.
|
|
rT )rb rÄ s rv r' zCategorical.isnaæ s ð" {{bÑ Ð rx c ó$ | j « 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.
|
|
)r' rÄ s rv ÚnotnazCategorical.notnaû s ð$ |Ðrx c ó ddl m}m} | j | j }}t |« |dk\ }}t j |« |j « } }|s| r%| r|n|| }
|
t j |
|
|xs d¬« } n@t j t j |||« « } t j |d« }t || j j « }| j |« } || ||« ddd¬« S ) 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 )ÚCategoricalIndexrJ )Ú minlengthrT rG ÚcountF)Úindexrg ÚnamerS )rð rh rJ rb r^ rW ri ÚarangerÎ Úbincountr¬ Úappendr rg Ú_from_backing_data) rk r* rh rJ Úcoder Úncatrq ÚixÚcleanÚobsrj s rv Ú value_countszCategorical.value_counts sØ ÷&
|
ð
|
KK § ¡ cÜ#h ¨¡ dÜIIdO T§X¡X£ZEá UÙ $ T¨$¡ZCÜKK ¨tªy°qÔ9EäKK¤§¡¨¨t°TÓ :Ó;EÜ2rÓ"Bä ! " d§j¡j×&;Ñ&;Ó <Ø × $Ñ $ RÓ (áØ Ñ)¨"Ó-°WÀ7ÐQVô
|
ð
|
rx c ó | j g |¬« }t j ||j j ¬« }|j |« S )z
|
Analogous to np.empty(shape, dtype=dtype)
|
|
Parameters
|
----------
|
shape : tuple[int]
|
dtype : CategoricalDtype
|
r )rÌ ri ÚzerosrÇ rg rp )r r· rg r¼ Úbackings rv Ú_emptyzCategorical._empty> sF ð × Ñ ¨5Ð Ó1ô
|
((5¨¯ © ×(:Ñ(:Ô;à×%Ñ% gÓ.Ð.rx c óÊ t | j j « r5| j j | j t
|
¬« j S t | j j « r\d| j v rN| j j d« j | j t j ¬« j S t j | « S )a
|
Return the values.
|
|
For internal compatibility with pandas formatting.
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
A numpy array or ExtensionArray of the same dtype as
|
categorical.categories.dtype.
|
rÙ rT r ) r r^ rg r1 rb r rÝ r rÓ ri r9 rj rÄ s rv Ú_internal_get_valuesz Categorical._internal_get_valuesS s ô t× 4Ñ 4Ô 5Ø??×'Ñ'¨¯ © ÄÐ'ÓD×LÑLÐ LÜ doo× 3Ñ 3Ô 4¸¸t¿{¹{Ñ9Jà×&Ñ& xÓ0ßdkk¬b¯f©fÓ5ßð ô
|
xx~Ð rx c ó: | j st d| d« y)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)rY rZ )rk rt s rv Úcheck_for_orderedz Categorical.check_for_orderedj s- à||ÜØ;¸B¸4ð @2ð 2óð ð rx Ú quicksort©Ú ascendingrÛ c ó( t | d||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 )r Úargsort)rk r rÛ rV r s rv r zCategorical.argsorts s ø ôf wÐH¨¸ÑHÀÑHÐHrx )Úinplacer Ú na_positionc ó y r r ©rk r r r
s rv rô zCategorical.sort_values¨ s ð rx ©r r
c ó y r r r s rv rô zCategorical.sort_values² s ð rx Úlastc óê t |d« }|dvrt dt |« « t | ||¬« }|s | j | }| j |« S | j | | j dd y)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 rX Úreprr7 rb rp )rk r r r
Ú
|
sorted_idxra s rv rô zCategorical.sort_values¸ s| ôR & g¨yÓ9Ø Ð /Ñ /Ü Ð 4´T¸+Ó5FÐ4GÐ HÓIÐ Iä d¨iÀ[ÔQ
|
áØKK
|
Ñ+EØ×*Ñ*¨5Ó1Ð 1Ø ZÑ0 AØrx r ÚaverageÚkeep©ÚaxisrT Ú na_optionr Úpctc ón |dk7 rt | j « }t j ||||||¬« S )z*
|
See Series.rank.__doc__.
|
r r )r« Ú_values_for_rankr( Úrank)rk r rT r r r Úvffs rv Ú_rankzCategorical._rank sB ð 19Ü%Ð %Ø×#Ñ#Ó%ÜØ ØØØ Ø Øô
|
ð
|
rx c óÀ ddl m} | j rG| j }|dk( }|j « r$|j d« }t j ||< |S t | j j « rt j | « }|S t j | j || j d¬« j « 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" rT Úfloat64FrR )rð rJ rY ra rc rÓ ri r9 r r^ rg rj r r r¸ )rk rJ r¸ rq s rv r z Categorical._values_for_rank% sµ õ "à <<ØZZFØR<DØxxzØ yÓ1Ü !vvt ð ô ' t§¡×'<Ñ'<Ô =ÜXXd^Fð ô XXØ×&Ñ&Ù4??°Ô7×<Ñ<Ó>×EÑEóóFð
|
rx c óp ddl m} t j | j j
|
« } ||||d¬« }| j « }t |« r |j | j « }n t j t |« d¬« }|j « rt j ||< |S )aA
|
Hash a Categorical by hashing its categories, and then mapping the codes
|
to the hashes.
|
|
Parameters
|
----------
|
encoding : str
|
hash_key : str
|
categorize : bool
|
Ignored for Categorical.
|
|
Returns
|
-------
|
np.ndarray[uint64]
|
r )Ú
|
hash_arrayF)Ú
|
categorizeÚuint64r )Úpandas.core.util.hashingr ri rÜ r^ rÝ r' rW r1 rb rx rc r Úu8max) rk ÚencodingÚhash_keyr r r¸ Úhashedrq rà s rv Ú_hash_pandas_objectz Categorical._hash_pandas_objectE s õ& 8ô DOO× 3Ñ 3Ó4ÙF H¨hÀ5ÔIð yy{Ü v;Ø[[ §¡Ó-FäXXc $i¨xÔ8Fà 88:Ü 99F4Là rx c ó | j S r )rÇ rÄ s rv rb zCategorical._codess s à}}Ð rx c óJ |dk( rt j S | j | S rÆ )ri r9 r^ )rk rr s rv Ú _box_funczCategorical._box_funcw s! Ø 7Ü66MØqÑ!Ð!rx c ó | j j |« }| j j j |« }|S r )r^ r rÇ rg rf )rk r rq s rv rd zCategorical._unbox_scalar| s7 ð ×&Ñ& sÓ+Ø}}×"Ñ"×'Ñ'¨Ó-Ø rx c óª j dk( r't j « j « « S fdt t « « D « S )zJ
|
Returns an Iterator over the values of this Categorical.
|
r c 3 ó( K | ] }| y wr r )r Únrk s rv r z'Categorical.__iter__.<locals>.<genexpr> s øè ø Ò6 DGÑ6ùs )rª Úiterr| r ÚrangerW rÄ s `rv Ú__iter__zCategorical.__iter__
sA ø ð 99>Ü×1Ñ1Ó3×:Ñ:Ó<Ó=Ð =ã6¤U¬3¨t«9Ó%5Ô6Ð 6rx c óÀ t || j j « r't | j « j « « S t | || j ¬« S )z?
|
Returns True if `key` is in this Categorical.
|
)r )r& r^ rg Úboolr' rc r rb )rk r s rv Ú __contains__zCategorical.__contains__ sC ô
|
! d§o¡o×&;Ñ&;Ô <Ü Ó)Ó*Ð *äc¨T¯[©[Ô9Ð9rx c ó y r r )rk Úboxeds rv Ú
|
_formatterzCategorical._formatter s àrx c óf t d« dk( rdn
|
t d« }ddlm} d}| j j dk( r4t t | j j « j d¬« }t |j |t ¬ « }t | j « |kD rN|d
|
z } || j d| j « } || j | d j « }|d gz |z }n || j j « }|D cg c] } | j « }} |S c c} w ) z9
|
return the base repr for the categories
|
zdisplay.max_categoriesr é
|
©ÚformatNÚstrF)r´ )Ú formatterÚquotingé z...)r Úpandas.io.formatsr¹ r^ rg r r1 rÝ rµ r Ú format_arrayr rW Ústrip)
|
rk Úmax_categoriesÚfmtr» r¿ ÚnumÚheadÚtailÚ category_strsÚxs
|
rv Ú_repr_categoriesz Categorical._repr_categories s& ô Ð2Ó3°qÒ8ñ äÐ 4Ó5ð õ
|
4à Ø ??× Ñ EÒ )ô ^¨T¯_©_×-DÑ-DÓE×PÑPØð Qó Iô Ø × Ñ ¨ Ô;Kô
|
ô tÓ .Ò 0Ø AÑ%CÙ §¡°°Ð 5× =Ñ =Ó>DÙ §¡°°°Ð 6× >Ñ >Ó?DØ E 7N¨TÑ 1Má (¨¯ © ×)@Ñ)@Ó AMð -:Ö: qÐ: Ð:Ø Ð ùò ;s ÄD.c óZ | j « }t | j j « }dt | j « d| d}t « \ }}t d« xs |}t j « rd}d}d}t |« } | j rdnd \ }
|
} | j « d
|
} |D ]] } |dk7 r:| |
|
z t | « z |kD r&|| d t |« d z z z z }t |« d z } n|s|| z }| t | « z } || z }d }_ | d|j dd« dS )z@
|
Returns a string representation of the footer.
|
z Categories (ú, z): z display.widthr Ú T)é z < )r½ rÊ ú
|
ú r Fú[z < ... < z ... ú]) rÈ rº r^ rg rW r r r9 Úin_ipython_frontendrY ÚrstripÚreplace)rk rÆ rg Ú levheaderÚwidthÚ_Ú max_widthÚ levstringÚstartÚ cur_col_lenÚsep_lenÚsepÚlinesepÚvals rv Ú_get_repr_footerz Categorical._get_repr_footerÁ sI ð ×-Ñ-Ó/ ÜDOO×)Ñ)Ó*Ø"¤3 t§¡Ó#7Ð"8¸¸5¸'ÀÐE Ü$Ó&qÜ Ó/Ò8°5 Ü × &Ñ &Ô (àIØ ØÜ)n Ø%)§\¢\z°y ØZZ\N "Ð%Ø ò CØA~ +°Ñ"7¼#¸c»(Ñ"BÀYÒ"NØW¨¬s°9«~ÀÑ/AÑ(BÑ CÑC Ü ! )n¨qÑ 0 ÙØSÑ Øs 3xÑ' Ø Ñ IØEð ð Ai× /Ñ /° ¸WÓ EÐ FÀaÐHÐHrx c óü ddl m} t | « dkD sJ | j « }|j |d d dt
|
¬« }|D cg c] }|j « }}dj |« }d|z dz }|S c c}w )Nr r¸ ÚNaN)Ú float_formatÚna_repr¼ rÊ rÏ rÐ )r¾ r¹ rW r| r¿ r rÀ Újoin)rk r ÚvalsÚ
|
fmt_valuesrr Újoinedrà s rv Ú_get_values_reprz Categorical._get_values_reprÞ s Ý3ä4y1}Ð }à×(Ñ(Ó*Ø×%Ñ%Ø Ø Ø ØÜ$ð &ó
|
|
ð *4Ö4 AaggiÐ4
|
Ð4Ø:Ó&Øv Ñ#Ø ùò 5s ÁA9c óD | j « }t | « }d}||kD rV|dz }| d| j « }| ||z
|
d j « }|dd d|dd }dt | « }| d| d| } | S |d kD r| j « }| d| } | S d
|
}| d | } | S ) z(
|
String representation.
|
r· r½ NrT z, ..., r zLength: rÍ r z[]rÊ )rß rW rè )
|
rk ÚfooterÚlengthÚmax_lenrà rÄ rÅ ÚbodyÚ length_inforà s
|
rv Ú__repr__zCategorical.__repr__ñ s÷ ð ×&Ñ&Ó(ÜTØØ GÒ ð Q,CØ:×.Ñ.Ó0DØ' C-Ð(Ð*Ð+×<Ñ<Ó>DØ3Bi[ ¨¨Q¨R¨ zÐ2DØ $¤S¨£Y KÐ0KØ vR }¨B¨v¨hÐ7Fð ð aZØ×(Ñ(Ó*DØ vR xÐ(Fð ð DØ vR xÐ(Fà rx c ó t |d¬« }t |t « rA| j |j k7 r t d« | j |« }|j S ddlm} |j |d¬« j | j « }t |« r$t |« j « s t d« | j j |« }|j! | j" j d¬ « S )
|
NT)Ú extract_numpyzCCannot set a Categorical with another, without identical categoriesr r( F)Ú tupleize_colszMCannot setitem on a Categorical with a new category, set the categories firstrR )r4 r[ r\ rg rZ Ú_encode_with_my_categoriesrb rð rI Ú _with_inferr r^ rW r' rÎ Ú get_indexerrÓ rÇ )rk r rI Úto_addra s rv rB z Categorical._validate_listlike sà ä e°4Ô8ô e[Ô )ØzzU[[Ò(Ü ð3óð ð
|
×3Ñ3°EÓ:EØ<<Ð å ð #×"Ñ" 5¸Ô>×IÑIØ OOó
|
ô v;t F|× /Ñ /Ô 1Üð5óð ð
|
×+Ñ+¨EÓ2Ø||DMM× /Ñ /°e|Ó<Ð<rx c ó | j }t j t | j « |j
|
« \ }t |« j « }fdt ||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 ó. K | ] \ }}|| y wr r )r rÙ ÚendÚrs rv r z/Categorical._reverse_indexer.<locals>.<genexpr>N s øè ø ÒJ¡J E¨31U3<ÑJùs r N)
|
r^ ÚlibalgosÚgroupsort_indexerr ra r0 r ÚcumsumÚzipr[ )rk r^ ÚcountsÚ_resultrú s @rv Ú_reverse_indexerz Categorical._reverse_indexer/ sr ø ð4 __
|
Ü ×.Ñ.Ü §
|
¡
|
Ó +¨Z¯_©_ó
|
6ô fÓ%×,Ñ,Ó.ÛJ´#°f¸fÀQÀR¸jÓ2IÔJÜC
|
GÓ,Ó-Ð-rx ©ÚskipnaÚkeepdimsc óx t | |f||d|¤}|dv r|S |r t | « || j ¬« S |S )Nr )ÚargmaxÚargminr )r Ú_reducerf rg )rk rl r r rV rà r s rv r zCategorical._reduceT sL ø ô ÐR¨f¸xÑRÈ6ÑRØ Ð'Ñ 'àMÙ Ø 4:f¨D¯J©JÔ7Ð 7àMrx )r c ó t j |j dd« « t j d|« | j d« t | j « s| j j S | j dk7 }|j « s@|r.|j « r | j | j « }n*t j S | j j « }| 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 r rI rT N)ÚnvÚvalidate_minmax_axisr Ú validate_minr~ rW rb rg Úna_valuerÎ rc rI ri r9 Ú_wrap_reduction_result©rk r rV ÚgoodÚpointers rv rI zCategorical.min` óº ô × Ñ §
|
¡
|
¨6°1Ó 5Ô6Ü
|
FÔ#Ø × Ñ uÔ%ä4;;Ô Ø::×&Ñ&Ð &à{{bÑ ØxxzÙ$((*Ø ++ dÑ+×/Ñ/Ó1ävv àkkooÓ'GØ×*Ñ*¨4°Ó9Ð9rx c ó t j |j dd« « t j d|« | j d« t | j « s| j j S | j dk7 }|j « s@|r.|j « r | j | j « }n*t j S | j j « }| 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 r rH rT N)r
|
r r Ú validate_maxr~ rW rb rg r rÎ rc rH ri r9 r r s rv rH zCategorical.max r rx c ó | j }d }|r| j « }t j ||¬« }t t
|
j |« }|j |j k( sJ | j |« }|S )N)rq ) rb r' r( Úmoder ri r© rg rp )rk r* ra rq Ú res_codesrÏ s rv Ú_modezCategorical._mode si Ø ØÙ Ø99;Dä OO E°Ô5 Ü YÓ/ Ø %§+¡+Ò-Ð-Ð-Ø×%Ñ% iÓ0Ø
|
rx c ó 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) )rk r s rv r) zCategorical.unique¯ s ø ô: w~Ó Ð rx r c ó¾ t |t « sy| j |« r;| j |« }t j
|
| j |j « S y)z²
|
Returns True if categorical arrays are equal.
|
|
Parameters
|
----------
|
other : `Categorical`
|
|
Returns
|
-------
|
bool
|
F)r[ r\ r] ró ri Ú array_equalrb ©rk rl s rv r_ zCategorical.equalsÎ sK ô %¤Ô-ØØ × 5Ñ 5°eÔ <Ø×3Ñ3°EÓ:EÜ>> $§+¡+¨u¯|©|Ó<Ð <Ørx c ó² ddl m} |d }||j k\ rt d| d|j « |dk( rt d |D « « st g }|D ]> }|j t |j d « D cg c] }|d d
|f c}« @ | j |d¬« }|j t |« dd ¬
|
« } | S ||« } | S c c}w ) Nr )Úunion_categoricalszaxis z) is out of bounds for array of dimension r c 3 ó: K | ] }|j d k( yw)r½ N)rª )r rÇ s rv r z0Categorical._concat_same_type.<locals>.<genexpr>í s è ø Ò6 qqvv {Ñ6ùs ©r rT ÚF)Úorder) Úpandas.core.dtypes.concatr rª rX rÎ Úextendr® r· Ú_concat_same_typeÚreshaperW )
|
r Ú to_concatr r r Útc_flatÚobjrr Úres_flatrà s
|
rv r% z Categorical._concat_same_typeá sé å@à! Ø 5::Ò Ü ØvÐ FÀuÇzÁzÀlÐSóð ð 19äÑ6¨IÔ6Ô6Ü Ð ð GØ ò IØ´5¸¿¹À1¹ Ó3FÖ G¨a ¢A q D£ Ò GÕHð Ið ×,Ñ,¨W¸1Ð,Ó=Hà ×%Ñ%¤c¨%£j°"¸CÐ%Ó@FØMá# IÓ.Ø ùò Hs Á?C
|
c ó~ t |j |j | j d¬« }| j |« 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).
|
FrR )r` ra r^ rp )rk rl ra s rv ró z&Categorical._encode_with_my_categoriesÿ s8 ô &Ø KK×)Ñ)¨4¯?©?Àô
|
ð ×&Ñ& uÓ-Ð-rx c óX t | j « t |j « k( S )zÞ
|
Returns True if categoricals are the same dtype
|
same categories, and same ordered
|
|
Parameters
|
----------
|
other : Categorical
|
|
Returns
|
-------
|
bool
|
)r
rg r s rv r] z/Categorical._categories_match_up_to_permutation
|
s! ô DJJÓ ¤4¨¯ © Ó#4Ñ4Ð4rx c óÀ | j d¬« }||j « z }ddlm} ddlm} |||gd¬« } |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 rÿ Úfreqsr^ ) rv Úsumrð rI Úpandas.core.reshape.concatr. Úcolumnsrk rl )rk rÿ r/ rI r. rà s rv ÚdescribezCategorical.describe
|
s_ ð ×"Ñ"¨%Ð"Ó0Ø Ñ%å Ý5á ¨aÔ0Ù ¨'Ð 2Ó3Ø ( Ôà rx c óÊ t j t |« « }| j j |« }|||dk\ z }t j | 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 : np.ndarray or ExtensionArray
|
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])
|
r )ri rÜ r' r^ Úget_indexer_forr( rò ra )rk r¸ rº Ú code_valuess rv rò zCategorical.isin4
|
sT ôR JJt F|Ó, Øoo×5Ñ5°fÓ= Ø! )¨{¸aÑ/?Ñ"@ÑA Ützz¨;Ó7Ð7rx )r c ó> ddl m} | j }t |d« }|r| n| j « }t t j |« « }|j « r|t j |« | }|j |j j |« }|j |« } t j || j | j « |j j « }
|
|
|
j! ||¬« }
|
||
|
« } |j j# | « } t j$ t' |
|
« « } t j( | dk( | | « } | j+ « } |
|
j- | « }|j/ d¬« } ||« }t1 |j2 | |d¬ « }t5 || j j6 ¬
|
« }t j |||« ||k7 r$t9 j: d t< t? « ¬ « |s|S y ) Nr r( r )Ú
|
to_replacer rT r )r FrR r zóThe behavior of Series.replace (and DataFrame.replace) with CategoricalDtype is deprecated. In a future version, replace will only be used for cases that preserve the categories. To change the categories, use ser.cat.rename_categories instead.r ) rð rI rg r rS r' ri rÜ rc r^ rò r- r r¥ ra Ú to_seriesrÓ r5 rm rW r¬ r r1 Údrop_duplicatesr` rb r! rY r¡ r¢ rã r )rk r8 r r rI Ú
|
orig_dtyper rq r+ Únew_catÚserÚ
|
all_valuesÚidxrÚlocsr r3 r s rv Ú_replacezCategorical._replaceb
|
s³ Ý àZZ
|
ä% g¨yÓ9Ù d 4§9¡9£;äBJJuÓ%Ó&Ø 88:Üzz *Ó-¨dÑ3HØ~~ c§n¡n×&9Ñ&9¸(Ó&CÑDHØ×+Ñ+¨HÓ5GÜ × "Ñ " 3¨¯ © °w·}±}Ô Eànn×&Ñ&Ó(Økk Z°ukÓ=á3Z
|
ð ~~×-Ñ-¨jÓ9ÜyySÓ"Üxx
|
D¨$Ó/Ø||~à $ Ø'×7Ñ7¸WÐ7ÓEÙ ~Ó.Ü)Ø JJ
|
N¸ô
|
ô % ^¸T¿Z¹Z×=OÑ=OÔP Ü× Ñ s I¨yÔ9à
|
Ò "Ü MMðô
|
Ü+Ó-õ ñ ØJð rx c ó¢ | j }| j }|j dk( rn|j j |||« }|j j
|
t j u rXt |« rM|t j u s t |« r0d}n-ddl m } ||j « « j |||« }t |||¬« S )NÚstringFr ©ÚNumpyExtensionArrayrÙ )r^ ra rg rj Ú_str_mapr ri r9 r r r r' Úpandas.core.arraysrE r³ r. ) rk Úfr rg Úconvertr^ ra rà rE s rv rF zCategorical._str_map
|
s° ð __
|
Ø
|
|
Ø × Ñ xÒ 'Ø ×%Ñ%×.Ñ.¨q°(¸EÓBFà× Ñ ×)Ñ)¬R¯V©VÑ3Ü! %Ô(Ø ¤§ ¡ Ñ/´4¸´>ð !å >á(¨×)<Ñ)<Ó)>Ó?×HÑHØ8UóFô vu°Ô:Ð:rx c óf ddl m} || j t d¬« « j |« S )Nr rD rá )r )rG rE r³ rº Ú_str_get_dummies)rk rÜ rE s rv rK z Categorical._str_get_dummies®
|
s- å:á" 4§=¡=´¸u =Ó#EÓF×WÑWØ ó
|
ð
|
rx c ó ddl m} |j |« } ||||¬« } | j }
|
|dv rt |
|
d| d« |dv r|
|
j
|
st d| d « |d
|
vr'|d k( rt |
|
d| d« t |
|
d | d « d } | j « } |dk( r| j
|
sJ | j } nA|dv r(| j } t j |t ¬« } n| j t « } | j | f|||| | d|¤}|| j v r|S |dv rd|| dk( < | j |« S )Nr )ÚWrappedCythonOp)ÚhowrÛ Úhas_dropped_na)r0 Úprodrý ÚcumprodÚskewz type does not support z operations)rI rH r ÚidxminÚidxmaxzCannot perform z with non-ordered Categorical) r rc rÎ r r rI rH rS rT Ú transformz% dtype does not support aggregation 'ú'r )r r rI rH rS rT r )Ú min_countÚngroupsÚcomp_idsrq Ú result_mask)r r rI rH rT r )Úpandas.core.groupby.opsrM Úget_kind_from_howrg rZ rY r' rÇ ri rx r± rÓ Ú_cython_op_ndim_compatÚcast_blocklistrp )rk rN rO rW rX ÚidsrV rM rÛ rt rg rZ rq ÚnpvaluesÚ
|
res_valuess rv Ú _groupby_opzCategorical._groupby_op¹
|
s õ <à ×0Ñ0°Ó5Ù ¨4ÀÔ Oà
|
|
Ø Ð>Ñ >ÜugÐ%<¸S¸EÀÐ MÓNÐ NØ Ð<Ñ <ÀUÇ]Â]ô o¨c¨UÐ2OÐ PÓQÐ QØ ð
|
|
ñ
|
|
ð {Ò"Ü 5 'Ð)@ÀÀÀ[Ð QÓRÐRÜugÐ%JÈ3È%ÈqÐ QÓRÐ Rà Øyy{Ø &=Ø<<Ð <Ø}}HØ ÐGÑ GØ}}HÜ (( 7´$Ô7Kð {{¤4Ó(Hà.R×.Ñ.Ø ð
|
à ØØØØ#ñ
|
ð ñ
|
|
ð "×#Ñ#Ñ #Ø Ð Ø Ð3Ñ 3Ø+-J{ aÑ'Ñ (Ø×&Ñ& zÓ2Ð2rx )ra ú
|
np.ndarrayrg r! ÚreturnrD )rg ú Dtype | Noner¹ zbool | lib.NoDefaultrS r± rd ÚNone)rd r! )rd Úint)rg re rS r± rd rD )rg rA rd rD ).)rg z npt.DTypeLikerS r± rd rc )rg r# rS r± rd r1 )rg r> rS r± rd r= ©Tr )rd rD )NNNT)rg re rþ r± rd rD )rd rI )rd rC )rd rc )F)r¹ r± rd rf )rg r! rd rD )r r± rd rD )NF)r r± )r> z(Literal['ignore'] | None | lib.NoDefault)rg r! rd rc )NN)rg zNpDtype | NonerS z bool | Nonerd rc )rS znp.ufuncrT rº ©rd rf )rb r± rd rg )rd únpt.NDArray[np.bool_])r* r± rd rJ )r· rE rg r! rd rD )rd r= )r r± rÛ rF )r zLiteral[False]r r± r
rº rd rD )r z Literal[True]r r± r
rº rd rf )r r± r r± r
rº rd z Self | None)
|
r r? rT rº r rº r r± r r± )r¢ rº r£ rº r r± rd znpt.NDArray[np.uint64])rr rg )rd r; ©rd r± )r´ r± )rd z list[str])rd rº )rd z$dict[Hashable, npt.NDArray[np.intp]])rl rº r r± r r± )r r± )r* r± rd r\ )rl r rd r± )r )r' zSequence[Self]r r? rd rD )rl r\ rd r\ )rl r\ rd r± )rd rH )r¸ r= rd rj )r r± )rI r± )ú|)rÜ rº )
|
rN rº rO r± rW rg rX rg r_ znpt.NDArray[np.intp])iry Ú
|
__module__Ú __qualname__Ú__doc__Ú__array_priority__r3 Ú _hidden_attrsÚ frozensetÚ_typÚ__annotations__Ú classmethodr r r r¥ Úpropertyrg rÈ rÌ rÐ r
|
rÓ rä rû rÿ r^ rY ra r
|
rÚ r r r r r r r& r- r4 r8 r| rz ÚeqrU r{ rV ÚltrN ÚgtrO ÚlerP ÚgerQ rD rC rý r0 rK rW r\ r` rc r' Úisnullrf Únotnullrv rz r| r~ r rô r r r¥ rb r¨ rd r¯ r² rµ rÈ rß rè rï rB r r rI rH r r) r_ r% ró r] r3 rò rA ri rF rK rb Ú __classcell__)r s @rv r\ r\ ö s ø
ñeðR Ðà ×.Ñ.±¸H¸:Ó1FÑFMØ Dà Ó àð1Ø ð1Ø'7ð1à ô1ó ð1ð ØØ "Ø),¯ © Øðy%ð
|
ð y%ð 'ð y%ð ðy%ð
|
õy%ðv ò ó ð ð ò ó ð ð à/3À%ñ4Ø ,ð4Ø;?ð4à ò4ó ð4ð
|
ò ó ð ð ó ó ð ð ó ó ð ð ó ó ð ö:òx ð àEIðB3à òB3ó ðB3ðH ð ØØ "Ø ð B3ð
|
ð B3ð ð B3ð
|
òB3ó ðB3ðN ò7%ó ð7%ðr ò%"ó ð%"ðN ò#ó ð#öJ#3óJ:ó ó &ó> 'ô@hóTFôPIDóVCóJ:Wóx/ðl ?B¿n¹nðm4ð <óm4ñ^ X[[Ó )FÙ X[[Ó )FÙ X[[Ó )FÙ X[[Ó )FÙ X[[Ó )FÙ X[[Ó )Fò
|
0òð: ò ó ð ð" à@Dð4,Ø#ð4,Ø2=ð4,à ò4,ó ð4,ól
|
õ: $ð òHó ðHôRó2!ð& Fó ð( Gô(
|
ðZ ð/Øð/Ø"2ð/à ò/ó ð/ó( ó.ð $(¸+ñ3IØ ð3IØ/7õ3Iðj ð #&Ø Ø ñ ð ð ð ð ð
|
ð ð
|
ò ó ð ð à;>ÐSVñ Ø'ð Ø48ð ØMPð à ò ó ð ð Ø Ø!ñ Sð ðSð ð Sð
|
ð Sð
|
ó Sðp Ø Ø Ø Øñ
|
ð ð
|
ð ð
|
ð
|
ð
|
ð ð
|
ð ó
|
ó0 ð@)Ø ð)Ø*-ð)Ø;?ð)à ó)ð\ ò ó ð ó"ó
|
ó7ó:ôó óDIó:ó&ò: =óB .ðL ,0À%ñ
|
Øð
|
Ø$(ð
|
Ø;?õ
|
ð %)õ :ð@ %)õ :ô@
|
õ ó>ð& óó ðó:.ó" 5ó ó*,8ð\ >Cõ /ðh ..°°·±¸Ó0BÐTXð;ØMQó;ô2
|
ð@3ð ð@3ð ð @3ð
|
ð @3ð ð @3ð "÷@3rx r\ r^ rY rv )ÚdelegateÚ accessorsÚtyp)r r r& r- r4 r r r rT c óR e Zd ZdZd dZed « Zd
|
dZd
|
dZe d d« Z
|
d
|
dZ y) Ú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']
|
c ó¬ | j |« |j | _ |j | _ |j
|
| _ | j « y r )Ú _validater¸ Ú_parentrk Ú_indexrl Ú_nameÚ_freeze)rk Údatas rv r¥ z CategoricalAccessor.__init__z s8 Ø tÔ Ø{{ Øjj ØYY
|
Ø rx c óN t | j t « s t d« y )Nz2Can only use .cat accessor with a 'category' dtype)r[ rg r! ÚAttributeError)r s rv r
z CategoricalAccessor._validate s" ä$**Ô&6Ô7Ü Ð!UÓVÐ Vð 8rx c ó. t | j |« S r )rh r )rk rl s rv Ú_delegate_property_getz*CategoricalAccessor._delegate_property_get s Üt|| TÓ*Ð*rx c ó0 t | j ||« S r )Úsetattrr )rk rl Ú
|
new_valuess rv Ú_delegate_property_setz*CategoricalAccessor._delegate_property_set s Üt|| T¨:Ó6Ð6rx c ó^ ddl m} || j j | j ¬« S )a@
|
Return Series of codes as well as the index.
|
|
Examples
|
--------
|
>>> raw_cate = pd.Categorical(["a", "b", "c", "a"], categories=["a", "b"])
|
>>> ser = pd.Series(raw_cate)
|
>>> ser.cat.codes
|
0 0
|
1 1
|
2 -1
|
3 0
|
dtype: int8
|
r r" )rk )rð rJ r ra r )rk rJ s rv ra zCategoricalAccessor.codes s" õ "ádll×(Ñ(°· ± Ô<Ð<rx c ó ddl m} t | j |« } ||i |¤}| ||| j | j
|
¬« S y )Nr r" )rk rl )rð rJ rh r r r )rk rl ÚargsrV rJ rT rÏ s rv Ú_delegate_methodz$CategoricalAccessor._delegate_method¢ sE Ý!ä tÓ,ÙdÐ%fÑ%Ø ?Ù# T§[¡[°t·z±zÔBÐ Bð rx Nri )rl rº )rd rJ ) ry rm rn ro r¥ Ú staticmethodr
r r rv ra r r rx rv r r ÿ
|
sH ñ$góRð ñWó ðWó+ó
|
7ð ò=ó ð=ô&Crx r c ó< |j | « }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.
|
)r5 r )r¸ r^ ra s rv rµ rµ ® s! ð × &Ñ & vÓ .EÜ zÓ 2Ð2rx c óæ t |« dk( r|r| j « S | S |j |« r|r| j « S | S t |j |« |« }t || d¬« }|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 rT rÙ )rW rS r_ r r5 r. )ra Úold_categoriesr rS Úindexerr3 s rv r` r` » sw ô2 >ÓaÒ á Ø::<Ð Ø Ø × Ñ ~Ô .á Ø::<Ð Ø ä"Ø×&Ñ& ~Ó6¸óGô °2Ô6IØ Ðrx c óÌ ddl m} t | « s t d« t | dd« }t |t « rt | « } t j t | j « | j j ¬« }t j || j d¬« } ||« }| j }||fS t | d¬ « }|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 )rh zInput must be list-likerg Nr Fr7 r )rð rh r rZ rh r[ r! r4 ri rm rW r^ ra rg r\ rÿ )r¸ rh r» Ú cat_codesr r^ ra s rv Úfactorize_from_iterabler æ sÍ õ (ä Ô ÜÐ1Ó2Ð2ô VW dÓ +FÜ&Ô*Ô+Ü vÓ&ô IIc &×"3Ñ"3Ó 4¸F¿L¹L×<NÑ<NÔO Ü×$Ñ$ Y°f·l±lÈUÐ$ÓSá% cÓ*
|
Ø ð *Ð Ð ô &¨%Ô0Ø^^
|
Ø Ø *Ð Ð rx c óv t | « dk( rg g fS t d | 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 3 ó2 K | ] }t |« y wr )r )r Úits rv r z+factorize_from_iterables.<locals>.<genexpr>& s è ø Ò N¸bÔ 5°b× 9Ñ Nùs )rW rþ r¨ )Ú iterablesra r^ s rv Úfactorize_from_iterablesr£ sB ô" 9~Òà2v äÑ NÀIÔ NÐOÑE:Ü ;ZÓ(Ð (Ð(rx rk )r¸ z,Index | Series | ExtensionArray | np.ndarrayr^ rI rd rc rh )ra rc rS r± rd rc )rd ztuple[np.ndarray, Index])rd z$tuple[list[np.ndarray], list[Index]])wÚ
|
__future__r Úcsvr Ú functoolsr rz Úshutilr Útypingr r r r
|
r¡ Únumpyri Úpandas._configr Ú pandas._libsr r rû r Úpandas._libs.arraysr Úpandas.compat.numpyr r
|
Úpandas.util._exceptionsr Úpandas.util._validatorsr Úpandas.core.dtypes.castr r Úpandas.core.dtypes.commonr r r r r r r r r r r Úpandas.core.dtypes.dtypesr r! r" r# Úpandas.core.dtypes.genericr$ r% Úpandas.core.dtypes.missingr& r' Ú pandas.corer( r) r* Úpandas.core.accessorr+ r, Úpandas.core.algorithmsr- r. Úpandas.core.arrays._mixinsr/ r0 Úpandas.core.baser1 r2 r3 Úpandas.core.commonÚcoreÚcommonr¦ Úpandas.core.constructionr4 r5 Úpandas.core.ops.commonr6 Úpandas.core.sortingr7 Ú pandas.core.strings.object_arrayr8 r¾ r9 Úcollections.abcr: r; r< Úpandas._typingr= r> r? r@ rA rB rC rD rE rF rG rð rH rI rJ r| r r\ r rµ r` r r£ r rx rv ú<module>rà s ðÝ "å Ý Û Ý $÷ó ó ã å %÷ñ õ
|
.Ý .Ý 4Ý 7÷÷ ÷ ÷ ñ ÷ó ÷ ÷÷
|
ñ ÷
|
÷÷÷ñ ÷
|
!Ð ÷õ <Ý (Ý Cå %á÷ñ ÷ ÷ ÷ ñ ÷ ñ òFóR06ôfC(3Ð-¨|Ð=Sô C(3ñRP Ø \°9Ð$=À:ôñ Ø ò ð ô ô XC.¨,Ð8Ló XCó óð"XCð|
|
3Ø 8ð
|
3àð
|
3ð ó
|
3ð EIð(Ø ð(Ø=Að(àó(óV( ôV)rx
|
