h ddlmZddlmZddlmZddlZddlmZddl m Z m Z m Z m Z ddlZddlZddlmZddlmZmZmZdd lmZdd lmZdd lmZdd lm Z dd l!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mZ>ddl?m@Z@mAZAddlBmCZCmDZDddlEmFZFmGZGddlHmIZImJZJmKZKddlLmMcmNZOddlPmQZQmRZRddlSmTZTddlUmVZVddlWmXZXddlYmZZZe r.ddl[m\Z\m]Z]m^Z^ddl_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjddlkmlZlmmZmmnZndZod/d ZpGd!d"eFeKeXZqeAeqd#d$gd%&eAeqgd'd(&Gd)d*e@eKeJZr d0d+Zs d1 d2d,Ztd3d-Zud4d.Zvy)5) annotations)QUOTE_NONNUMERIC)partialN)get_terminal_size) TYPE_CHECKINGLiteralcastoverload) get_option)NaTalgoslib) NDArrayBacked)function)find_stack_level)validate_bool_kwarg)coerce_indexer_dtypefind_common_type) ensure_int64ensure_platform_intis_any_real_numeric_dtype is_bool_dtype is_dict_like is_hashableis_integer_dtype is_list_like is_scalarneeds_i8_conversion pandas_dtype) ArrowDtypeCategoricalDtypeCategoricalDtypeTypeExtensionDtype)ABCIndex ABCSeries)is_valid_na_for_dtypeisna) algorithms arraylikeops)PandasDelegatedelegate_names) factorizetake_nd)NDArrayBackedExtensionArray ravel_compat)ExtensionArrayNoNewAttributesMixin PandasObject) extract_arraysanitize_array)unpack_zerodim_and_defer)nargsort)ObjectStringArrayMixin)console)HashableIteratorSequence) ArrayLike AstypeArgAxisIntDtypeDtypeObjNpDtypeOrderedSelfShapeSortKindnpt) DataFrameIndexSeriescdjdtjutfd}|_|S)N__c2t|}t|r$t|t|k7r |s td|js dvr t dt |trd}|j|s t ||jsS|jj|js.t|j|j|jd}n |j} |j|}|jdk(|dk(z}|jr||<|S|rc||jvr>|j|} |j|} dvr|jdk(}||<|St!j"|| S d vrt d d t%|d t |t&rt)|j*r  ||St-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.Fcopy>__eq__rQrO)rU__ne__z$Cannot compare a Categorical for op z with type zB. If you want to compare values, use 'np.asarray(cat) other'.)rrlen ValueErrorordered TypeError isinstance Categorical#_categories_match_up_to_permutation categoriesequalsrecode_for_categoriescodes_codesany _unbox_scalarr*invalid_comparisontyper1rdtypegetattrnparray) selfotherhashablemsg other_codesretmaski fill_valueopopnames CD:\jyotish\venv\Lib\site-packages\pandas/core/arrays/categorical.pyfuncz_cat_compare_op..func~su%  3u:T#:823 3||AAM e[ )TC;;EBn$<<(>(>u?O?O(P3KK!1!14?? $ll T[[+.CKK2%+*;>11:6(C K=)88 %05H5U%&27288D>62288E?C C)__name__operatorner6)rtrwrsrus` @@rv_cat_compare_opr|zsK"++b !Fx{{"Jf%=D&=D~DM Krxct| |jj|}t |r|vSt fd|DS#ttf$rYywxYw)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. Fc3&K|]}|v ywN).0loc_ containers rv zcontains..s549$s)hashr^get_locKeyErrorrZrrc)catkeyrlocs ` rvcontainsrse: I nn$$S)~i5555 i sA AAc0eZdZUdZdZej edgzZdZde d<e defd Z ddde jd f dffd Zedgd Zedhd Ze dd d didZe djdZedkdldZedkdmdZedkdndZdodnfd ZdZe dp dqdZe dr dsdZedtdZedudZedvdZdwdxfd ZdydZdzdZdqdZdqd Z d{d|d!Z!dqd"Z"dpdqd#Z#dqd$Z$dqd%Z%dqd&Z&e jf d}d'Z'e(e)jTZ+e(e)jXZ-e(e)j\Z/e(e)j`Z1e(e)jdZ3e(e)jhZ5d(Z6d)Z7e d~d*Z8e9 d dd+Z:dd,Z;dfd- Zdd0Z?e?Z@dd1ZAeAZBdodd2ZCe dd3ZDdd4ZEdd5ZFd d6d7 dfd8ZGedddd9 dd:ZHeddd; dd<ZHd d d=d9 dd>ZHd?d@dAd d dB ddCZIdvdDZJ ddEZKedvdFZLddGZMdhdHZNddIZOddJZPdwddKZQddLZRddMZSddNZTddOZUdPZVddQZWd d dR dfdSZXd dTddUZYd dTddVZZdoddWZ[dqfdX Z\ddZZ]e ddd[Z^dd\Z_dd]Z`dd^Zadd_Zbd d`ddaZce jedj dYd f ddbZedddcZf dddZgxZhS)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 `__ 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' itolist categoricalr!_dtypect||j}tdj|}t|||S)NFrY)rr^r! update_dtypesuper _simple_new)clsrarg __class__s rvrzCategorical._simple_newgs>%UE,<,<= /< 1 ndim Categorical are not supported at this timeobject) types_mapperTsortzl'values' is not ordered, please explicitly specify the categories order by passing in a categories argument.rR)6r no_defaultwarningswarnDeprecationWarningrr!_from_values_or_dtyperr^rr__init__rrZrirjrhr[rYr$r%r1comconvert_to_list_likelistrWrndarrayndimNotImplementedErrorr5r'rcwherergr issubclassrfr" _pa_arraycombine_chunks dictionary to_pandasindicesto_numpy pyarrow_dtyper-r4rbr`_get_codes_for_valuesonesshape)rkvaluesr^rYrgfastpathrSra null_maskvdtypearridxarr_listsanitize_dtypeerr old_codes full_codesrs rvrzCategorical.__init__ss 3>> ) MMU"+-  H 66 J  (1A1ABE$U3@@GE G UE * F#AB BHHUO $/ f. /'():):EMMJFXy.$IJ--f5F&$'CK1,<"F3FBJJ/;;?-M(5%VT2 I ==?8:xx 7KA7NO7Ns 7NHO 399#8)-),(4~NC    #&,, 3  !!#79&&557 ^^55:5N  ,,.(V\\5O5O5W5WX!&(3+FD9F #(1&t(D%E:)U]]C  &6 7%f-44I)6<<22E4D4D4E *&%2B2BCE ==?'')//EEJ%*J z "E /<>> 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) )rrks rvrgzCategorical.dtypes{{rxcP|jj}|jdSNrT)_ndarrayrgrf)rkrgs rv_internal_fill_valuez Categorical._internal_fill_values! ##zz"~rxFrgrSc||||S)Nrr)rscalarsrgrSs rv_from_sequencezCategorical._from_sequences7%d33rxc|t|j||}t|}||jk(jst|S)Nr)rrr'allrX)rrrgresrqs rv _from_scalarszCategorical._from_scalars sO =% %   6G} "'')  rx.cyrrrkrgrSs rvastypezCategorical.astype rxcyrrrs rvrzCategorical.astyperrxcyrrrs rvrzCategorical.astype#rrxcjt|}|j|ur|r|j}|S|}|St|trB|jj |}|r|jn|}|j |}|St|trt|%||S|jdvr)|jjr tdt|jdk(st|j dk(r4|st#j$||}|St#j&||}|S|j j(} |j||}|j j*}t-||sKt/j0t#j&|j j*j|}t5|t7|j8| }|S#t2tf$r(d|j jd|}t|wxYw) 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. rRiuz#Cannot convert float NaN to integerrrrz Cannot cast z dtype to rs)rrgrSr[r!r _set_dtyper#rrkindr'rcrXrWrar^riasarrayrj_values _na_valuer&ritem_from_zerodimrZr.rrb)rkrgrSresultnew_catsrsrnrs rvrzCategorical.astype'sU# :: $(TYY[FX Y/3FX U/ 0JJ++E2E"&499;DD__U+FL I~ .7>%d>3 3 ZZ4 DIIKOO$5BC C _ !S%9Q%>D64 1$e40 )..H &#??T?B!__66 ,Z?!$!6!6!:!:;BB5I"J-dkk:zF  &%T__%:%:$;:eWM o%  &s BG;;7H2cjtjdtt|j S)z# Alias for tolist. zcCategorical.to_list is deprecated and will be removed in a future version. Use obj.tolist() insteadr)rr FutureWarningrrrs rvto_listzCategorical.to_listcs,   0 ')  {{}rxc ddlm}m}m}m}||} t |t xr|jdu} | rt|jjr ||d} ntj|jjdr ||d} nktj|jjdr ||d} n6t|jjr|gd}| j|} | r|j} t|| | } nV| js;| 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_timedeltaNcoerce)errorsMm)TrueTRUEtrueFrr)pandasrIrrrr[r!r^rrgr is_np_dtyperisinr`is_monotonic_increasingrS sort_valuesr)rinferred_categoriesinferred_codesrg true_valuesrIrrrcatsknown_categoriesr^raunsorteds rv_from_inferred_categoriesz%Categorical._from_inferred_categoriespsX0  () u. / PE4D4DD4P  ()9)9)?)?@!"5hG!1!1!7!7="#6xH!1!1!7!7=#$7Iu//556&":Kyy- ))J).$ KE--yy{H))+J).(JOE$Z?E$T59E"EuE22rxctj|||}|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^rYrgzKThe categories must be provided in 'categories' or 'dtype'. Both were None.r)r!rr^rX_validate_codes_for_dtyper)rrar^rYrgvalidaterns rv from_codeszCategorical.from_codesskj!66!7%     #+ S/ ! 11%u1EEuE22rxc.|jjS)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') )rgr^rs rvr^zCategorical.categoriesspzz$$$rxc.|jjS)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 )rgrYrs rvrYzCategorical.ordered7sLzz!!!rxc\|jj}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)rbviewflags writeable)rkvs rvrazCategorical.codes_s(D KK   !rxc^|r!tj||j}nt||j}|sV|jj@t |jt |jjk7r t dt|!|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'] rNzKnew categories need to have the same number of items as the old categories!) r!_from_fastpathrYrgr^rWrXrrr)rkr^r new_dtypers rv_set_categorieszCategorical._set_categoriess* (77 DLLQI(T\\JI %%1I(()S1F1F-GG/   2rxct|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`rar^rfr)rkrgras rvrzCategorical._set_dtypes:&djj$//5CSCSTDz%%e5%99rxct|j|}|j}tj||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^rSrrr)rkvaluer rs rv set_orderedzCategorical.set_ordereds:%T__eD iiksCLL)< rxc$|jdS)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 Trrs rv as_orderedzCategorical.as_ordereds:%%rxc$|jdS)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 Frrs rv as_unorderedzCategorical.as_unordereds<&&rxc||jj}t||}|j}|r|jjdt |jt |jjkr/d|j |j t |jk\<|j }n+t|j|j|j}tj||||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') rrT) rgrYr!rSr^rWrbr`rarr)rknew_categoriesrYrenamer rras rvset_categorieszCategorical.set_categoriessn ?jj((G$^WE iik yy##/C 8L8L4MPS $$Q5GI 3::Y-A-A)BBCJJE) 3>>9+?+?E sE95 rxct|r*|jDcgc]}|j||}}n*t|r|jDcgc] }|| }}|j }|j ||Scc}wcc}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'] )rr^getcallablerSr )rkritemrs rvrename_categorieszCategorical.rename_categoriesqsz  ';???;J4""4.? n %?COtnT2NOiik N+ Ps BBct|jt|k7s%|jj|js 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)rWr^ differenceemptyrXr)rkrrYs rvreorder_categorieszCategorical.reorder_categoriess[F  C$7 7??--n=CCO "">7"CCrxct|s|g}t|t|jjz}t |dk7rt d|t |droddlm}t|jjj|jg}|t|jjt|z|}n+t|jjt|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'] rz0new categories must not include old categories: rgrJr)rsetrgr^rWrXhasattrrrJrrr!rYrSrrrr)rkralready_includedrJrgr rras rvadd_categorieszCategorical.add_categoriess$VN+,-N~.TZZ5J5J1KK  A %BCSBTU  >7 + %$&&,,n.B.BCE$TZZ**+d>.BB%N"$**"7"784;OON$^T\\B iik$S\\93G3GHsE95 rxcddlm}t|s|g}||jj }|j j dur'|j jj|dn$|j jj|}|j|j j}t|dk7rt|}td||j||j dS)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'] rrITFrz(removals must all be in old categories: )rYr) rrIruniquedropnargrYr^rrWr#rXr)rkremovalsrIr not_includeds rvremove_categorieszCategorical.remove_categoriesIsR !H% zH?))+224zz!!T) JJ ! ! , ,XE , B&&11(;   **4::+@+@A |  !|,LG ~VW W"">4<>> 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_inverserrTrNr)rir)rbsizergr^taker!rrYrrSrr)rkrinvrr  new_codesrs rvremove_unused_categoriesz$Categorical.remove_unused_categoriessD99T[[>S 88q=SVr\12waC..33C8$33 DLL )i.B.BC iiksIy9 rxc6|tjur&tjdtt d}t |s t|sJ|jj|}tj|jdk(}tj}|Q|rOt |r|tjn-|jtjtj}|jra|j sU|tjurCt#||j$}|j'|jj)|dS|r|j+t-||}tj.||jS)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') zThe 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 warningrignorerTrFrgr)rrrrrrrrr^maprircrbnanr is_uniquehasnansr!rYrrSinsertrWr1)rkmapper na_actionrhas_nansna_valr s rvr8zCategorical.maps2b  & MM=+-  !I<#777,,V466$+++,  '/'7VBFF^VZZPRPVPV=WF  # #N,B,BvQSQWQWGW(NI??4;;#3#3#5YQV?W W +223~3FONww~t{{33rxc\t|s|j|S|j|Sr)r_validate_listlike_validate_scalar)rkr s rv_validate_setitem_valuez#Categorical._validate_setitem_value1s,5!**51 1((/ /rxct||jjrd}|S||jvr|j|}|St d|dd)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 rTz5Cannot setitem on a Categorical with a new category (z), set the categories firstN)r&r^rgrdrZ)rkrss rvrCzCategorical._validate_scalar8sr$ !T__-B-B CJ4?? *++J7J  'L(CE rxct|trZt|jrEt |j r t d|jtj}ntj|}t|r#|jjdvr t dt|rD|jt|jk\s|jdkr t d|S)Nzcodes cannot contain NA valuesrrz$codes need to be array-like integersrTz1codes need to be between -1 and len(categories)-1)r[r1rrgr'rcrXrriint64rrWrmaxr^min)rrargs rvrz%Categorical._validate_codes_for_dtypeUs e^ ,1A%++1NE{  !ABBNNN2EJJu%E u:%++**$6CD D u:599;#e.>.>*??599;QSCSPQ Q rxc|dur$tjdttt |j j |j}tj||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) FaSStarting 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.rr) rrrrr.r^rrbrir)rkrgrSrps rv __array__zCategorical.__array__gsWF 5= MM2 +- doo--t{{; zz#U++rxc(tj|||g|i|}|tur|Sd|vrtj|||g|i|S|dk(r%tj|||g|i|}|tur|St d|j d|j)NoutreducezObject with dtype z cannot perform the numpy op )r)!maybe_dispatch_ufunc_to_dunder_opNotImplementeddispatch_ufunc_with_outdispatch_reduction_ufuncrZrgry)rkufuncmethodinputskwargsrs rv__array_ufunc__zCategorical.__array_ufunc__s<< % "( ,2   'M F?44eV&,06  X 77eV&,06F^+   -!NN+ -  rxct|tst| |Sd|vrt |d|d|d<d|vrd|vr|j d|d<t| |y)z*Necessary for making this object picklabler _categories_orderedrbrN)r[dictr __setstate__r!pop)rkstaters rvr\zCategorical.__setstate__sn%&7'. . 5 .u]/CU:EVWE(O u 5!8 % ( 3E*  U#rxc|jj|jjjjzSr)rbnbytesrgr^rrs rvr`zCategorical.nbytess-{{!!DJJ$9$9$@$@$G$GGGrxc||jj|jjj |zS)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)rbr`rgr^ memory_usage)rkrbs rvrczCategorical.memory_usages1.{{!!DJJ$9$9$F$FD$F$QQQrxc |jdk(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)rbrs rvr'zCategorical.isnas"{{b  rxc$|jS)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'rs rvnotnazCategorical.notnas$ |rxcddlm}m}|j|j}}t ||dk\}}t j||j} }|s| r%| r|n||} t j| |xsd} n@t jt j|||} t j|d}t||jj}|j|}|| ||dddS) 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) minlengthrTrGcountF)indexrgnamerS)rrhrJrbr^rWriarangerbincountrappendrrg_from_backing_data) rkr*rhrJcoderncatrqixcleanobsrjs rv value_countszCategorical.value_countss& KKc#h dIIdOTXXZE U$T$ZCKKtyq9EKKtT :;E2r"B !"djj&;&; <  $ $R ( )"-W7QV  rxc|jg|}tj||jj}|j |S)z Analogous to np.empty(shape, dtype=dtype) Parameters ---------- shape : tuple[int] dtype : CategoricalDtype r)rrizerosrrgrp)rrrgrbackings rv_emptyzCategorical._empty>sF  5 1 ((5 (:(:;%%g..rxct|jjr5|jj|jt j St|jjr\d|jvrN|jjdj|jtjj Stj|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. rrTr) rr^rgr1rbr rrrrir9rjrs rv_internal_get_valuesz Categorical._internal_get_valuesSs t44 5??'' 'DLL L doo33 4t{{9J&&x0dkkbff5  xx~rxc:|jstd|dy)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)rYrZ)rkrts rvcheck_for_orderedzCategorical.check_for_orderedjs-||;B4@22 rx quicksort ascendingrc (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]) rr)rargsort)rkrrrVrs rvrzCategorical.argsortssfwHHHHrx)inplacer na_positioncyrrrkrrrs rvrzCategorical.sort_valuess rxrrcyrrrs rvrzCategorical.sort_valuess rxlastct|d}|dvrtdt|t|||}|s |j|}|j |S|j||jddy)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)rfirstzinvalid na_position: rN)rrXreprr7rbrp)rkrrr sorted_idxras rvrzCategorical.sort_valuess|R&gy9 / /4T+5F4GHI Idi[Q KK +E**51 1Z0 ArxraveragekeepaxisrT na_optionrpctcn|dk7rt|j}tj||||||S)z* See Series.rank.__doc__. rr)r_values_for_rankr(rank)rkrrTrrrvffs rv_rankzCategorical._rank sB 19% %##%    rxcddlm}|jrG|j}|dk(}|j r$|j d}t j||<|St|jjrt j|}|St j|j||jdjj}|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 rr"rTfloat64FrR)rrJrYrarcrrir9rr^rgrjrrr)rkrJrrqs rvrzCategorical._values_for_rank%s " <<ZZFREEF  rxcpddlm}tj|jj }||||d}|j }t|r|j|j}n tjt|d}|jrtj||<|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) categorizeuint64r)pandas.core.util.hashingrrirr^rr'rWr1rbrxrcru8max) rkencodinghash_keyrrrhashedrqrs rv_hash_pandas_objectzCategorical._hash_pandas_objectEs& 8DOO334FHh5Iyy{ v;[[-FXXc$ix8F 88:99F4L rxc|jSr)rrs rvrbzCategorical._codesss }}rxcJ|dk(rtjS|j|Sr)rir9r^)rkrrs rv _box_funczCategorical._box_funcws! 766Mq!!rxc|jj|}|jjj |}|Sr)r^rrrgrf)rkrrqs rvrdzCategorical._unbox_scalar|s7&&s+}}""''- rxcjdk(r'tjjSfdt t DS)zJ Returns an Iterator over the values of this Categorical. rc3(K|] }| ywrr)rnrks rvrz'Categorical.__iter__..s6%5DG%5s)riterr|rrangerWrs`rv__iter__zCategorical.__iter__sA 99>113::<= =6U3t9%56 6rxct||jjr't|j j St |||jS)z? Returns True if `key` is in this Categorical. )r)r&r^rgboolr'rcrrb)rkrs rv __contains__zCategorical.__contains__sC !doo&;&; < )* *cT[[99rxcyrr)rkboxeds rv _formatterzCategorical._formattersrxcftddk(rdn td}ddlm}d}|jjdk(r4t t |jjjd}t|j|t }t|j|kDrN|d z}||jd|j}||j| dj}|d gz|z}n||jj}|D cgc]} | j}} |Scc} w) z9 return the base repr for the categories zdisplay.max_categoriesr formatNstrF)r) formatterquotingz...)r pandas.io.formatsrr^rgr r1rrr format_arrayrrWstrip) rkmax_categoriesfmtrrnumheadtail category_strsxs rv_repr_categorieszCategorical._repr_categoriess' 23q8 45  4 ?? E )^T__-D-DEPPQI    ;K  t . 0 A%C 5 = =>D 6 > >?D E7NT1M()@)@AM-::MqM :;sD.cZ|j}t|jj}dt |jd|d}t \}}t dxs|}tjrd}d}d}t |} |jrdnd \} } | jd } |D]]} |dk7r:| | zt | z|kDr&|| d t |d zzzz }t |d z} n|s|| z }| t | z } || z }d }_|d|jdddS)z@ Returns a string representation of the footer. z Categories (, z): z display.widthrT)z < )rr  rF[z < ... < z ... ]) rrr^rgrWrr r9in_ipython_frontendrYrstripreplace)rkrrg levheaderwidth_ max_width levstringstart cur_col_lensep_lenseplinesepvals rv_get_repr_footerzCategorical._get_repr_footersD--/ DOO))*"3t#7"85'E $&q/85  & & (I )n %)\\zy ZZ\N"% CA~+"7#c("BY"NWs9~/A(BCC !)nq0 S s3x'  IE!Ai// WEFaHHrxcddlm}t|dkDsJ|j}|j |dddt }|Dcgc]}|j }}dj|}d|zdz}|Scc}w)NrrNaN) float_formatna_reprrrr)rrrWr|rrrjoin)rkrvals fmt_valuesrrjoinedrs rv_get_values_reprzCategorical._get_values_reprs34y1}}((*%%  $ & *44Aaggi 4:&v# 5sA9cD|j}t|}d}||kDrV|dz}|d|j}|||z dj}|ddd|dd}dt|}|d|d|} | S|d kDr|j}|d|} | Sd }|d |} | S) z( String representation. rrNrTz, ..., rzLength: rrz[]r)rrWr) rkfooterlengthmax_lenrrrbody length_infors rv__repr__zCategorical.__repr__s&&(T G Q,C:..0D'C-(*+<<>D3Bi[QRz2D$SYK0KvR }Bvh7F aZ((*DvRx(F DvRx(F rxct|d}t|trA|j|jk7r t d|j |}|j Sddlm}|j|dj|j}t|r$t|js t d|jj|}|j!|j"jd S) NT) extract_numpyzCCannot set a Categorical with another, without identical categoriesrr(F) tupleize_colszMCannot setitem on a Categorical with a new category, set the categories firstrR)r4r[r\rgrZ_encode_with_my_categoriesrbrrI _with_inferrr^rWr'r get_indexerrr)rkr rIto_addras rvrBzCategorical._validate_listlike se48 e[ )zzU[[(3 33E:E<<  #""5>II OO  v;tF|//15  ++E2||DMM//e|< 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])} c3.K|] \}}||ywrr)rrendrs rvrz/Categorical._reverse_indexer..N sJ2IJE31U3<2IsrN) r^libalgosgroupsort_indexerrrar0rcumsumzipr[)rkr^counts_resultrs @rv_reverse_indexerzCategorical._reverse_indexer/ sr4__ ..  +Z__ 6f%,,.J#ffQRj2IJC G,--rxskipnakeepdimsc xt||f||d|}|dvr|S|rt|||jS|S)Nr)argmaxargminr)r_reducerfrg)rkrlrrrVrrs rvrzCategorical._reduceT sLRfxR6R ' 'M 4:fDJJ7 7Mrx)rc tj|jddtjd||j dt |j s|jjS|j dk7}|js@|r.|jr|j |j}n*tjS|j j}|jd|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 rrrrIrTN)nvvalidate_minmax_axisr validate_minr~rWrbrgna_valuerrcrIrir9_wrap_reduction_resultrkrrVgoodpointers rvrIzCategorical.min`   61 56 F# u%4;;::&& &{{b xxz$((*++d+//1vv kkoo'G**499rxc tj|jddtjd||j dt |j s|jjS|j dk7}|js@|r.|jr|j |j}n*tjS|j j}|jd|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 rrrrHrTN)r r r validate_maxr~rWrbrgr rrcrHrir9rrs rvrHzCategorical.max rrxc|j}d}|r|j}tj||}t t j |}|j|jk(sJ|j|}|S)N)rq) rbr'r(moder rirrgrp)rkr*rarq res_codesrs rv_modezCategorical._mode si  99;DOOE5 Y/ %++---%%i0 rxc 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'] )rr))rkrs rvr)zCategorical.unique s:w~rxrct|tsy|j|r;|j|}t j |j |j Sy)z Returns True if categorical arrays are equal. Parameters ---------- other : `Categorical` Returns ------- bool F)r[r\r]rri array_equalrbrkrls rvr_zCategorical.equals sK%-  5 5e <33E:E>>$++u||< <rxc ddlm}|d}||jk\rtd|d|j|dk(rt d|Dstg}|D]>}|j t |jdDcgc] }|dd|f c}@|j|d}|jt|dd } | S||} | Scc}w) Nr)union_categoricalszaxis z) is out of bounds for array of dimension rc3:K|]}|jdk(yw)rN)r)rrs rvrz0Categorical._concat_same_type.. s6Iqqvv{IsrrTF)order) pandas.core.dtypes.concatrrrXrextendrr_concat_same_typereshaperW) r to_concatrrrtc_flatobjrrres_flatrs rvr%zCategorical._concat_same_type s@!  5:: vFuzzlS  196I66  G 513FG3FaAqD 3FGH!,,W1,=H%%c%j"C%@FM#I.  Hs?C c~t|j|j|jd}|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`rar^rp)rkrlras rvrz&Categorical._encode_with_my_categories s8& KK))4?? &&u--rxcXt|jt|jk(S)z Returns True if categoricals are the same dtype same categories, and same ordered Parameters ---------- other : Categorical Returns ------- bool )rrgrs rvr]z/Categorical._categories_match_up_to_permutation s!DJJ4 #444rxc|jd}||jz }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*rr()concatrr rfreqsr^) rvsumrrIpandas.core.reshape.concatr.columnsrkrl)rkrr/rIr.rs rvdescribezCategorical.describe s_""%"0% 5a0'23(  rxctjt|}|jj |}|||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)rirr'r^get_indexer_forr(rra)rkrr code_valuess rvrzCategorical.isin4 sTRJJtF|, oo55f= !){a/?"@A tzz;77rx)rc>ddlm}|j}t|d}|r|n|j }t t j|}|jr|t j||}|j|jj|}|j|} tj|| j| j|jj} | j!||} || } |jj#| } t j$t'| } t j(| dk(| | } | j+} | j-| }|j/d}||}t1|j2| |d }t5||jj6 }tj|||||k7r$t9j:d t<t? |s|Sy) Nrr(r) to_replacer rTr)rFrRrzThe 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) rrIrgrrSr'rirrcr^rr-rrra to_seriesrr5rmrWrrr1drop_duplicatesr`rbr!rYrrrr)rkr8r rrI orig_dtyperrqr+new_catser all_valuesidxrlocsrr3r s rv_replacezCategorical._replaceb s ZZ %gy9d499;BJJu%& 88:zz*-d3H~~cnn&9&9(&CDH++H5G  " "3 w}} Enn&&(kkZuk=3Z ~~--j9yyS"xx D$/||~$'77W7E~.) JJ N %^TZZ=O=OP sIy9  " MM +- Jrxc|j}|j}|jdk(rn|jj |||}|jj t jurXt|rM|tjus t|r0d}n-ddl m }||jj |||}t|||S)NstringFrNumpyExtensionArrayr)r^rargrj_str_mapr rir9rrrr'pandas.core.arraysrErr.) rkfr rgconvertr^rarrEs rvrFzCategorical._str_map s __     x '%%..q(EBF  ))RVV3!%(/4>! >()<)<)>?HH8UFvu::rxcfddlm}||jtdj |S)NrrDr)r )rGrErr_str_get_dummies)rkrrEs rvrKzCategorical._str_get_dummies s-:"4==u=#EFWW   rxc ddlm}|j|}||||} |j} |dvrt | d|d|dvr| j st d|d |d vr'|d k(rt | d|dt | d |d d} |j } |dk(r|j sJ|j} nA|dvr(|j} tj|t} n|jt} | j| f|||| | d|}|| jvr|S|dvrd|| dk(<|j|S)Nr)WrappedCythonOp)howrhas_dropped_na)r0prodrcumprodskewz type does not support z operations)rIrHridxminidxmaxzCannot perform z with non-ordered Categorical) rrcrrrrIrHrSrT transformz% dtype does not support aggregation ''r)rrrIrHrSrTr) min_countngroupscomp_idsrq result_mask)rrrIrHrTr)pandas.core.groupby.opsrMget_kind_from_howrgrZrYr'rrirxrr_cython_op_ndim_compatcast_blocklistrp)rkrNrOrWrXidsrVrMrrtrgrZrqnpvalues res_valuess rv _groupby_opzCategorical._groupby_op s <005 4 O  > >ug%rSrrdr=Tr)rdrD)NNNT)rgrerrrdrD)rdrI)rdrC)rdrc)F)rrrdrf)rgr!rdrD)r rrdrD)NF)rr)r>z(Literal['ignore'] | None | lib.NoDefault)rgr!rdrc)NN)rgzNpDtype | NonerSz bool | Nonerdrc)rSznp.ufuncrTrrdrf)rbrrdrg)rdnpt.NDArray[np.bool_])r*rrdrJ)rrErgr!rdrD)rdr=)rrrrF)rzLiteral[False]rrrrrdrD)rz Literal[True]rrrrrdrf)rrrrrrrdz Self | None) rr?rTrrrrrrr)rrrrrrrdznpt.NDArray[np.uint64])rrrg)rdr;rdr)rr)rdz list[str])rdr)rdz$dict[Hashable, npt.NDArray[np.intp]])rlrrrrr)rr)r*rrdr\)rlrrdr)r)r'zSequence[Self]rr?rdrD)rlr\rdr\)rlr\rdr)rdrH)rr=rdrj)rr)rIr)|)rr) rNrrOrrWrgrXrgr_znpt.NDArray[np.intp])iry __module__ __qualname____doc____array_priority__r3 _hidden_attrs frozenset_typ__annotations__ classmethodrrrrpropertyrgrrrr rrrrr^rYrar rrrrrrr r&r-r4r8r|rzeqrUr{rVltrNgtrOlerPgerQrDrCrr0rKrWr\r`rcr'isnullrfnotnullrvrzr|r~rrrrrrbrrdrrrrrrrrBrrrIrHrr)r_r%rr]r3rrArirFrKrb __classcell__)rs@rvr\r\s eR ..H:1FFM D 11'71 1 1"),y%  y% ' y%y% y%v   /3%4 ,4;?4 44         :x EIB3 B3B3H" B3  B3  B3 B3B3N7%7%r%"%"N##J#3J: &>'@hTFPIDVCJ:Wx/l?Bnnm4<m4^X[[ )F X[[ )F X[[ )F X[[ )F X[[ )F X[[ )F 0:  "@D4,#4,2=4, 4,4,l : $HHR2!&F(G( Z//"2/ //(.$(+3I 3I/73Ij#&           ;>SV ' 48 MP   ! SS S  S  Sp         0@))*-);?) )\" 7: DI:&:=B .L,0%  $( ;? %):@%):@  >&:." 5*,8\>C/h..0BTX;MQ;2 @3@3 @3  @3  @3"@3rxr\r^rYrv)delegate accessorstyp)rr r&r-r4rrrrTcReZdZdZd dZedZd dZd dZe d dZ 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 |_|jyr) _validater_parentrk_indexrl_name_freeze)rkdatas rvrzCategoricalAccessor.__init__z s8 t{{ jj YY  rxcNt|jts tdy)Nz2Can only use .cat accessor with a 'category' dtype)r[rgr!AttributeError)rs rvrzCategoricalAccessor._validate s"$**&67 !UV V8rxc.t|j|Sr)rhr)rkrls rv_delegate_property_getz*CategoricalAccessor._delegate_property_get st||T**rxc0t|j||Sr)setattrr)rkrl new_valuess rv_delegate_property_setz*CategoricalAccessor._delegate_property_set st||T:66rxc^ddlm}||jj|jS)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 rr")rk)rrJrrar)rkrJs rvrazCategoricalAccessor.codes s" "dll(( <>> 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) rrTr)rWrSr_rr5r.)raold_categoriesrrSindexerr3s rvr`r` sw2 >a ::<    ~ . ::<  "&&~6G26I rxcddlm}t|s tdt |dd}t |t rt|}tjt|j|jj}tj||jd}||}|j}||fSt|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)rhzInput must be list-likergNrFr7r)rrhrrZrhr[r!r4rirmrWr^rargr\r)rrhr cat_codesrr^ras rvfactorize_from_iterabler s (  122VWd +F&*+v&IIc&"3"34FLL.& sNIb5b9Is)rWrr) iterablesrar^s rvfactorize_from_iterablesr sB" 9~2v NINOE: ;Z( ((rxrk)rz,Index | Series | ExtensionArray | np.ndarrayr^rIrdrcrh)rarcrSrrdrc)rdztuple[np.ndarray, Index])rdz$tuple[list[np.ndarray], list[Index]])w __future__rcsvr functoolsrrzshutilrtypingrrr r rnumpyripandas._configr pandas._libsr r rrpandas._libs.arraysrpandas.compat.numpyrr pandas.util._exceptionsrpandas.util._validatorsrpandas.core.dtypes.castrrpandas.core.dtypes.commonrrrrrrrrrrrpandas.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/r0pandas.core.baser1r2r3pandas.core.commoncorecommonrpandas.core.constructionr4r5pandas.core.ops.commonr6pandas.core.sortingr7 pandas.core.strings.object_arrayr8rr9collections.abcr:r;r<pandas._typingr=r>r?r@rArBrCrDrErFrGrrHrIrJr|rr\rrr`rrrrxrvrs" $ % ..47        ! <(C%    FR06fC(3-|=SC(3RP \9$=:    XC.,8LXC "XC| 3 8 3 3 3EI( (=A((V(V)rx