*jd 4ddlmZddlmZddlmZddlZddlZddlm Z ddl m Z m Z m Z mZmZddlZddlZddlmZddlmZmZmZdd lmZdd lmZdd lm Z dd l!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;mm?Z?m@Z@ddlAmBZBmCZCmDZDddlEmFZFmGZGddlHmIZImJZJddlKmLZLmMZMddlNmOZOmPZPmQZQddlRmScmTZUddlVmWZWmXZXddlYmZZZddl[m\Z\ddl]m^Z^ddl_m`Z`e r,ddlambZbmcZcmdZdmeZeddlfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZodd lpmqZqmrZrmsZsd!Ztd5d"Zue"d#Gd$d%eLeQe^ZveGevd&d'gd()eGevgd*d+)Gd,d-eFeQePZw d6d.Zxd/d0d1 d7d2Zyd8d3Zzd9d4Z{y):) annotations)QUOTE_NONNUMERIC)partialN)get_terminal_size) TYPE_CHECKINGLiteralSelfcastoverload) get_option)NaTalgoslib) NDArrayBacked)function)Pandas4Warning) set_module)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)CallableHashableIteratorSequence) ArrayLike AstypeArgAxisIntDtypeNpDtypeOrderedShapeSortKindnpt) 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__rSrQ)rW__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_comparisontyper4r!dtypegetattrnparray) selfotherhashablemsg other_codesretmaski fill_valueopopnames @C:\FundamentalWorkbench\vendor\pandas\core\arrays\categorical.pyfuncz_cat_compare_op..funcsu%  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__operatorner9)rvryrurws` @@rx_cat_compare_opr~}sK"++b !Fx{{"Jf%=D&=D~DM Krzct| |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 rx zcontains..s549$s)hashr`get_locKeyErrorr\r re)catkeyrlocs ` rxcontainsrse: I nn$$S)~i5555 i sA AApandasceZdZUdZdZej edgzZdZde d<e dcfd Z dd defd Z e dfd Ze dgd Ze dd d dhdZdifd ZedjdkdZedjdldZedjdmdZdndmfd Ze do dpdZe dd dqdZe drdZe dsdZe dtdZdudvfd ZdwdZdxdZdpdZdpdZ dy dzd Zdpd!Zdodpd"Z dpd#Z!dpd$Z"dpd%Z# do d{d&Z$e%e&jNZ(e%e&jRZ*e%e&jVZ,e%e&jZZ.e%e&j^Z0e%e&jbZ2d'Z3d(Z4e d|d)Z5e6 d} d~d*Z7dd+Z8dfd, Z9e dgd-Z:dudd.Z;dd/Ze>Z?dndd1Z@e dd2ZAdid3ZBdd4ZCd d5d6 dfd7ZDedddd8 dd9ZEeddd: dd;ZEd d dd?d@d d dA ddBZFdtdCZG ddDZHe dtdEZIddFZJdgdGZKddHZLddIZMduddJZNddKZOddLZPddMZQddNZRdOZSddPZTd d dQ dfdRZUd dSddTZVd dSddUZWdnddVZXdpfdW ZYddYZZdnddZZ[e ddd[Z\dd\Z]dd]Z^dd^Z_dd_Z`eajecjdXd f dd`ZddddaZe ddbZfxZgS)r^aP 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 an 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. copy : bool, default True Whether to copy if the codes are unchanged. 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 as_ordered as_unordered set_categories rename_categories reorder_categories add_categories remove_categories remove_unused_categories map __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, str): ['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, str): ['c' < 'b' < 'a'] >>> c.min() 'c' itolist categoricalr$_dtypect||j}tdj|}t|||S)NFr[)rr`r$ update_dtypesuper _simple_new)clsrcri __class__s rxrzCategorical._simple_newws>%UE,<,<= /<t@rdd l!m"} t|| r%|jFjHjK} n#tM|jHjK} | jNjQt: }| jRjU}t||j8jVj}nd}t|ttfr|j8t(k(rd }t|ts t1|d} tY|d \}}|rdd l!m"} | |t(d}t||j}ntt|j8trDtM|jZ}t]||j8j|j|d }nt_||j}|j5r4t j`|jb|j8 }|||<|}tdje|}tg||j} th|| |ycc} w#t$r3}tY|d \}}|jr td|Yd}~dd}~wwxYw)Nz#Categorical input must be list-likeFrir) RangeIndexriz3> 1 ndim Categorical are not supported at this timeobjectrK) types_mapperTsortzl'values' is not ordered, please explicitly specify the categories order by passing in a categories argument.rirUrUwarnr)6r$_from_values_or_dtyperr\rkrlrjr]r`r[rangepandas.core.indexes.rangerr'r(r4comconvert_to_list_likelistrYrndarrayndimNotImplementedErrorr8r*rewhererir# issubclassrhr%rrK_data _pa_arraycombine_chunksr7 dictionary to_pandasindicesto_numpy pyarrow_dtyper0rdrb_get_codes_for_valuesonesshaperrr__init__)rmvaluesr`r[rirU null_maskvdtyperarridxarr_listsanitize_dtyperKrcpreserve_objecterr old_codes full_codesrs rxrzCategorical.__init__s!66 J F#AB BHHUO $/ f. /'():):EMMJ  & <'FFXy.$IJ--f5F&$'CK1,<"F3FBJJ/;;?-M(5%VT2 I ==?8:xx 7KA7NO7Ns 7NHO 399#8)-),(4~NC    #&,, 3  !!#79)fe, ,,00??AC'/99HHJC ^^55:5N  ,,.(V\\5O5O5W5WX"'fx&;<QWAW&*O!&(3+FD9F #(1&t(D%E:#-!&ze!LJ)U]]C  &6 7%f-44I) ''   E*&%2B2BCE ==?'')//EEJ%*J z "E /<>> cat = pd.Categorical(["a", "b"], ordered=True) >>> cat ['a', 'b'] Categories (2, str): ['a' < 'b'] >>> cat.dtype CategoricalDtype(categories=['a', 'b'], ordered=True, categories_dtype=str) )rrms rxrizCategorical.dtypes&{{rzcP|jj}|jdSNrV)_ndarrayrirh)rmris rx_internal_fill_valuez Categorical._internal_fill_values! ##zz"~rzFrc||||S)Nrr)rscalarsrirUs rx_from_sequencezCategorical._from_sequence s7%d33rzcHt||}tj5tjddt |j ||j}dddjt|k(jr|S|S#1swY7xYw)Nignorez=Constructing a Categorical with a dtype and values containingr) r_cast_pointwise_resultwarningscatch_warningsfilterwarningsrhrrir*all)rmrresrrs rxrz"Categorical._cast_pointwise_result&sg,V4  $ $ &  # #O t*++Ctzz+BC ' HHJ$s) # ( ( *J ' &s =BB!.cyrrrmrirUs rxastypezCategorical.astype3sLOrzcyrrrs rxrzCategorical.astype6sQTrzcyrrrs rxrzCategorical.astype9sGJrzc$t|}|j|ur|r|j}|S|}|St|tr|jj |}|r|jn|}|j |d}|j|jz}|jr$tjdtt|St|trt |=||S|j dvr)|jjr t#dt%|j&dk(st%|j(dk(r4|st+j,||}|St+j.||}|S|j(j0} |j|| }|j(j2}t5||sKt7j8t+j.|j(j2j|}t=|t?|j@| }|S#t:t"f$r-}d |j(jd |}t#||d }~wwxYw)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. FrTConstructing a Categorical with a dtype and values containing non-null entries not in that dtype's categories is deprecated and will raise in a future version. stackleveliuz#Cannot convert float NaN to integerrrrz Cannot cast z dtype to Nru)!r"rirUr]r$r _set_dtyper*rerrrrr&rrkindrZrYrcr`rkasarrayrl_values _na_valuer)ritem_from_zerodimr\r1rrd) rmrirUresultwrongnew_catsrurrprs rxrzCategorical.astype<s?U# :: $(TYY[Fj k/3Fj g/ 0JJ++E2E"&499;DD__U_7FKKMTYY[L0Eyy{ :#/1 X 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 o3.  /s0BIJ"(J  Jcddlm}m}m}m}||d} t |t xr|jdu} | rt|jjr ||d} ntj|jjdr ||d} nktj|jjd r ||d} n6t|jjr|gd }| j|} | r|j} t|| | dd } nY| js>| j!} | j#} t|| | dd } 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)rK to_datetime to_numeric to_timedeltaFrTNcoerce)errorsMm)TrueTRUEtrueTrrr)rrKrrrr]r$r`rrir is_np_dtyperisinrbis_monotonic_increasingrU sort_valuesr)rinferred_categoriesinferred_codesri true_valuesrKrrrcatsknown_categoriesr`rcunsorteds rx_from_inferred_categoriesz%Categorical._from_inferred_categoriessl0  (u5 u. / PE4D4DD4P  ()9)9)?)?@!"5hG!1!1!7!7="#6xH!1!1!7!7=#$7Iu//556&":Kyy- ))J)ju4E--yy{H))+J)*5tE%Z?E$T59E"EuE22rzctj|||}|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 See Also -------- codes : The category codes of the categorical. CategoricalIndex : An Index with an underlying ``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, str): ['a' < 'b'] )r`r[rizKThe categories must be provided in 'categories' or 'dtype'. Both were None.r)r$rr`rZ_validate_codes_for_dtyper)rrcr`r[rivalidaterps rx from_codeszCategorical.from_codesskt!66!7%     #+ S/ ! 11%u1EEuE22rzc.|jjS)aP 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='str') >>> raw_cat = pd.Categorical([None, "b", "c", None], categories=["b", "c", "d"]) >>> ser = pd.Series(raw_cat) >>> ser.cat.categories Index(['b', 'c', 'd'], dtype='str') For :class:`pandas.Categorical`: >>> cat = pd.Categorical(["a", "b"], ordered=True) >>> cat.categories Index(['a', 'b'], dtype='str') For :class:`pandas.CategoricalIndex`: >>> ci = pd.CategoricalIndex(["a", "c", "b", "a", "c", "b"]) >>> ci.categories Index(['a', 'b', 'c'], dtype='str') >>> ci = pd.CategoricalIndex(["a", "c"], categories=["c", "b", "a"]) >>> ci.categories Index(['c', 'b', 'a'], dtype='str') )rir`rs rxr`zCategorical.categoriesspzz$$$rzc.|jjS)aC Whether the categories have an ordered relationship. See Also -------- set_ordered : Set the ordered attribute. as_ordered : Set the Categorical to be ordered. as_unordered : Set the Categorical to be unordered. 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 )rir[rs rxr[zCategorical.orderedRsXzz!!!rzc\|jj}d|j_|S)aR 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. See Also -------- Categorical.from_codes : Make a Categorical from codes. CategoricalIndex : An Index with an underlying ``Categorical``. 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)rdviewflags writeable)rmvs rxrczCategorical.codess(N KK   !rzc^|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, str): ['a', 'b'] >>> c._set_categories(pd.Index(["a", "c"])) >>> c ['a', 'c'] Categories (2, str): ['a', 'c'] rNzKnew categories need to have the same number of items as the old categories!) r$_from_fastpathr[rir`rYrZrrr)rmr`fastpath new_dtypers rx_set_categorieszCategorical._set_categoriess* (77 DLLQI(T\\JI %%1I(()S1F1F-GG/   2rzct|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`. rTr)rbrcr`rhr)rmrirUrcs rxrzCategorical._set_dtypesA& JJ)9)9 Dz%%e5%99rzct|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`rUrrr)rmvaluerrs rx set_orderedzCategorical.set_ordereds:%T__eD iiksCLL)< rzc$|jdS)a Set the Categorical to be ordered. Returns ------- Categorical Ordered Categorical. See Also -------- as_unordered : Set the Categorical to be unordered. 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 rx as_orderedzCategorical.as_orderedsB%%rzc$|jdS)a Set the Categorical to be unordered. Returns ------- Categorical Unordered Categorical. See Also -------- as_ordered : Set the Categorical to be ordered. 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 rx as_unorderedzCategorical.as_unorderedsD&&rzc ||jj}t||}|j}|r|jjdt |jt |jjkr/d|j |j t |jk\<|j }n.t|j|j|jdd}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 do not consider a S1 string equal to a single char python string. Parameters ---------- new_categories : Index-like The categories in new order. ordered : bool, default None Whether or not the categorical is treated as an 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 New categories to be used, with optional ordering changes. 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", None], categories=["a", "b", "c"], ordered=True ... ) >>> ser = pd.Series(raw_cat) >>> ser 0 a 1 b 2 c 3 NaN dtype: category Categories (3, str): ['a' < 'b' < 'c'] >>> ser.cat.set_categories(["A", "B", "C"], rename=True) 0 A 1 B 2 C 3 NaN dtype: category Categories (3, str): ['A' < 'B' < 'C'] For :class:`pandas.CategoricalIndex`: >>> ci = pd.CategoricalIndex( ... ["a", "b", "c", None], 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') rrVFr) rir[r$rUr`rYrdrbrcrr)rmnew_categoriesr[renamerrrcs rxset_categorieszCategorical.set_categories7sx ?jj((G$^WE iik yy##/C 8L8L4MPS $$Q5GI 3::Y-A-A)BBCJJE) 3>>9+?+?eRWE sE95 rzct|r*|jDcgc]}|j||}}n*t|r|jDcgc] }|| }}|j }|j ||Scc}wcc}w)a Rename categories. This method is commonly used to re-label or adjust the category names in categorical data without changing the underlying data. It is useful in situations where you want to modify the labels used for clarity, consistency, or readability. 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, str): ['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, str): ['A', 'B'] )rr`getcallablerUr)rmritemrs rxrename_categorieszCategorical.rename_categoriessF  ';???;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 an 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, str): ['c' < 'b' < 'a'] >>> ser.sort_values() 2 c 1 b 0 a 3 a dtype: category Categories (3, str): ['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)rYr` differenceemptyrZr)rmrr[s rxreorder_categorieszCategorical.reorder_categoriess[F  C$7 7??--n=CCO "">7"CCrzct|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, str): ['b', 'c'] >>> c.add_categories(["d", "a"]) ['c', 'b', 'c'] Categories (4, str): ['b', 'c', 'd', 'a'] rz0new categories must not include old categories: rirLr)rsetrir`rYrZhasattrrrLrrr$r[rUrrrr)rmralready_includedrLrirrrcs rxadd_categorieszCategorical.add_categories?s$VN+,-N~.TZZ5J5J1KK  A %BCSBTU  >7 + %$&&,,n.B.BCE$TZZ**+d>.BB%N"$**"7"784;OON$^T\\B iik$S\\93G3GHsE95 rzcddlm}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. The ``removals`` argument must be a subset of the current categories. Any values that were part of 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, str): ['a', 'b', 'c', 'd'] >>> c.remove_categories(["d", "a"]) [NaN, 'c', 'b', 'c', NaN] Categories (2, str): ['b', 'c'] rrTFrz(removals must all be in old categories: )r[r) rrKruniquedropnarir[r`r&rYr+rZr)rmremovalsrKr not_includeds rxremove_categorieszCategorical.remove_categoriessR !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, str): ['a', 'b', 'c', 'd'] >>> c[2] = "a" >>> c[4] = "c" >>> c ['a', 'c', 'a', 'c', 'c'] Categories (4, str): ['a', 'b', 'c', 'd'] >>> c.remove_unused_categories() ['a', 'c', 'a', 'c', 'c'] Categories (2, str): ['a', 'c'] T)return_inverserrVrNr)rkr0rdsizerir`taker$rr[rrUrr)rmrinvrr new_codesrs rxremove_unused_categoriesz$Categorical.remove_unused_categoriessL99T[[>S 88q=SVr\12waC..33C8$33 DLL )i.B.BC iiksIy9 rzct|s t|sJ|jj|}t j |j dk(}tj}|Q|rOt|r|tjn-|jtjtj}|jra|jsU|tjurCt||j}|j|j j|dS|r|jt!||}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 None If 'ignore', propagate NaN values, without passing them to the mapping correspondence. Returns ------- pandas.Categorical or pandas.Index Mapped categorical. See Also -------- CategoricalIndex.map : Apply a mapping correspondence on a :class:`~pandas.CategoricalIndex`. Index.map : Apply a mapping correspondence on an :class:`~pandas.Index`. Series.map : Apply a mapping correspondence on a :class:`~pandas.Series`. Series.apply : Apply more complex functions on a :class:`~pandas.Series`. Examples -------- >>> cat = pd.Categorical(["a", "b", "c"]) >>> cat ['a', 'b', 'c'] Categories (3, str): ['a', 'b', 'c'] >>> cat.map(lambda x: x.upper(), na_action=None) ['A', 'B', 'C'] Categories (3, str): ['A', 'B', 'C'] >>> cat.map({"a": "first", "b": "second", "c": "third"}, na_action=None) ['first', 'second', 'third'] Categories (3, str): ['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, str): ['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='str') 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='str') The mapping function is applied to categories, not to each value. It is therefore only called once per unique category, and the result reused for all occurrences: >>> cat = pd.Categorical(["a", "a", "b"]) >>> calls = [] >>> def f(x): ... calls.append(x) ... return x.upper() >>> result = cat.map(f) >>> result ['A', 'A', 'B'] Categories (2, str): ['A', 'B'] >>> calls ['a', 'b'] rVrFrir)r"rr`maprkrerdnanr! is_uniquehasnansr$r[rrUinsertrYr8)rmmapper na_actionrhas_nansna_valrs rxr>zCategorical.mapsx<#777,,V466$+++,  '/'7VBFF^VZZPRPVPV=WF  # #N,B,BvQSQWQWGW(NI??4;;#3#3#5YQV?W W +223~3FONww~t{{33rzc\t|s|j|S|j|Sr)r_validate_listlike_validate_scalar)rmrs rx_validate_setitem_valuez#Categorical._validate_setitem_valueps,5!**51 1((/ /rzct||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 rVz5Cannot setitem on a Categorical with a new category (z), set the categories firstN)r)r`rirfr\)rmrus rxrIzCategorical._validate_scalarwsr$ !T__-B-B CJ4?? *++J7J  'L(CE rzct|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 integersrVz1codes need to be between -1 and len(categories)-1)r]r4rrir*rerZrrkint64rrYrmaxr`min)rrcris rxrz%Categorical._validate_codes_for_dtypes e^ ,1A%++1NE{  !ABBNNN2EJJu%E u:%++**$6CD D u:599;#e.>.>*??599;QSCSPQ Q rzc|dur tdt|jj|j}t j ||S)ap 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 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. See Also -------- numpy.asarray : Convert input to numpy.ndarray. Examples -------- >>> cat = pd.Categorical(["a", "b"], ordered=True) The following calls ``cat.__array__`` >>> np.asarray(cat) array(['a', 'b'], dtype=object) Fz:Unable to avoid copy while creating an array as requested.r)rZr1r`rrdrkr)rmrirUrrs rx __array__zCategorical.__array__sKN 5=L doo--t{{; zz#U++rzc(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_ufuncr\rir{)rmufuncmethodinputskwargsrs rx__array_ufunc__zCategorical.__array_ufunc__s<< % "( ,2   'M F?44eV&,06  X 77eV&,06F^+   -!NN+ -  rzct|tst| |Sd|vrt |d|d|d<d|vrd|vr|j d|d<t| |y)z*Necessary for making this object picklabler _categories_orderedrdrN)r]dictr __setstate__r$pop)rmstaters rxrbzCategorical.__setstate__sn%&7'. . 5 .u]/CU:EVWE(O u 5!8 % ( 3E*  U#rzc|jj|jjjjzSr)rdnbytesrir`rrs rxrfzCategorical.nbytess-{{!!DJJ$9$9$@$@$G$GGGrzc||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)rdrfrir` memory_usage)rmrhs rxrizCategorical.memory_usage s1.{{!!DJJ$9$9$F$FD$F$QQQrzc |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. rV)rdrs rxr*zCategorical.isna"s"{{b  rzc$|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 rxnotnazCategorical.notna7s$ |rzcddlm}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)CategoricalIndexrL) minlengthrVrMcountF)indexrinamerU)rrnrLrdr`rYrkarangerbincountrappendrri_from_backing_data) rmr1rnrLcoderncatrsixcleanobsrpix_categoricals rx value_countszCategorical.value_countsMs& KKc#h dIIdOTXXZE U$T$ZCKKtyq9EKKtT :;E2r"B !"djj&;&; <004 ">2   rzc|jg|}tj||jj}|j |S)z Analogous to np.empty(shape, dtype=dtype) Parameters ---------- shape : tuple[int] dtype : CategoricalDtype r)rrkzerosrrirv)rrrirbackings rx_emptyzCategorical._empty~sF  5 1 ((5 (:(:;%%g..rzct|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. rrVr) r!r`rir8rdr rrrrkr?rlrs rx_internal_get_valuesz Categorical._internal_get_valuess t44 5??'' 'DLL L doo33 4t{{9J&&x0dkkbff5  xx~rzc:|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)r[r\)rmrvs rxcheck_for_orderedzCategorical.check_for_ordereds-||;B4@22 rz 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)rmrrr\rs rxrzCategorical.argsortsfwHHHHrz)inplacer na_positioncyrrrmrrrs rxrzCategorical.sort_valuessrzrrcyrrrs rxrzCategorical.sort_valuessrzlastct|d}|dvrtd|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)rrZr:rdrv)rmrrr sorted_idxrcs rxrzCategorical.sort_valuessvR&gy9 / /4[ODE Edi[Q KK +E**51 1Z0 ArzraveragekeepaxisrZ na_optionrpctcn|dk7rt|j}tj||||||S)z* See Series.rank.__doc__. rr)r_values_for_rankr+rank)rmrrZrrrvffs rx_rankzCategorical._rankKsB 19% %##%    rzcddlm}|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*rVfloat64FrT)rrLr[rcrerrkr?rr`rirlr$rr)rmrLrrss rxrzCategorical._values_for_rankcs " <<ZZFREEF  rzcpddlm}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.hashingrrkrr`rr*rYr8rdrreru8max) rmencodinghash_keyrrrhashedrsrs rx_hash_pandas_objectzCategorical._hash_pandas_objects& 8DOO334FHh5Iyy{ v;[[-FXXc$ix8F 88:99F4L rzc|jSr)rrs rxrdzCategorical._codess }}rzcJ|dk(rtjS|j|Sr)rkr?r`)rmrts rx _box_funczCategorical._box_funcs! 766Mq!!rzc|jj|}|jjj |}|Sr)r`rrrirh)rmrrws rxrfzCategorical._unbox_scalars7&&s+}}""''- rzcjdk(r'tjjSfdt t DS)zJ Returns an Iterator over the values of this Categorical. rc3(K|] }| ywrr)rnrms rxrz'Categorical.__iter__..s6%5DG%5s)riterrrrrYrs`rx__iter__zCategorical.__iter__sA 99>113::<= =6U3t9%56 6rzct||jjr't|j j St |||jS)z? Returns True if `key` is in this Categorical. )r)r)r`riboolr*rerrd)rmrs rx __contains__zCategorical.__contains__sC !doo&;&; < )* *cT[[99rzcyrr)rmboxeds rx _formatterzCategorical._formattersrzctddk(rdn td}ddlm}d}|jjdk(s|jjdk(r4t t |jjjd }t|j|t }t|j|kDrM|d z}||jd|j}||j| dj}g|d |}n||jj}|D cgc]} | j}} |Scc} w) z9 return the base repr for the categories zdisplay.max_categoriesr formatNstrstringF)r) formatterquotingz...)r pandas.io.formatsrr`rir r4rrr format_arrayrrYstrip) rmmax_categoriesfmtrrnumheadtail category_strsxs rx_repr_categorieszCategorical._repr_categoriess< 23q8 45  4 ?? E )T__-B-Bh-N^T__-D-DEPPQI    ;K  t . 0 A%C 5 = =>D 6 > >?D1d1E1D1M()@)@AM-::MqM :;s+EcZ|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`rirYrr r<in_ipython_frontendr[rstripreplace)rmrri levheaderwidth_ max_width levstringstart cur_col_lensep_lenseplinesepvals rx_get_repr_footerzCategorical._get_repr_footer sD--/ DOO))*"3t#7"85'E $&q/85  & & (I )n %)\\zy ZZ\N"% CA~+"7#c("BY"NWs9~/A(BCC !)nq0 S s3x'  IE!Ai// WEFaHHrzcddlm}t|dkDsJ|j}|j |dddt }|Dcgc]}|j }}dj|}d|zdz}|Scc}w)NrrNaN) float_formatna_reprrrr)rrrYrrrrjoin)rmrvals fmt_valuesrtjoinedrs rx_get_values_reprzCategorical._get_values_repr s34y1}}((*%%  $ & *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. rrNrVz, ..., rzLength: rrz[]r)rrYr) rmfooterlengthmax_lenrrrbody length_infors rx__repr__zCategorical.__repr__1 s&&(T G Q,C:..0D'C-(*+<<>D3Bi[QRz2D$SYK0KvR }Bvh7F aZ((*DvRx(F DvRx(F rzct|d}t|trA|j|jk7r t d|j |}|j Sddlm}|j|ddj|j}t|r$t|js t d|jj|}|j!|j"jd S) NT) extract_numpyzCCannot set a Categorical with another, without identical categoriesrrF) tupleize_colsrUzMCannot setitem on a Categorical with a new category, set the categories firstrT)r7r]r^rir\_encode_with_my_categoriesrdrrK _with_inferr&r`rYr*r get_indexerrr)rmrrKto_addrcs rxrHzCategorical._validate_listlikeN se48 e[ )zzU[[(3 33E:E<<  #""5EJUU 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, str): ['a', 'b', 'c'] >>> c.categories Index(['a', 'b', 'c'], dtype='str') >>> 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 rxrz/Categorical._reverse_indexer.. sM2LJE31U3<2LsT)strict) r`libalgosgroupsort_indexerrrcr7rcumsum itertoolspairwiserazip)rmr`counts_resultrs @rx_reverse_indexerzCategorical._reverse_indexero sr4__ ..  +Z__ 6f%,,.M)2D2DV2LMC GD9::rzskipnakeepdimsc xt||f||d|}|dvr|S|rt|||jS|S)Nr )argmaxargminr)r_reducerhri)rmrrr r r\rrs rxrzCategorical._reduce sLRfxR6R ' 'M 4:fDJJ7 7Mrz)r c 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 rrrrOrVN)nvvalidate_minmax_axisr! validate_minrrYrdrina_valuerrerOrkr?_wrap_reduction_resultrmr r\goodpointers rxrOzCategorical.min   61 56 F# u%4;;::&& &{{b xxz$((*++d+//1vv kkoo'G**499rzc 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 rrrrNrVN)rrr! validate_maxrrYrdrirrrerNrkr?rrs rxrNzCategorical.max rrzc|j}d}|r|j}tj||\}}t t j |}|j|jk(sJ|j|}|S)N)rs) rdr*r+moder rkrrirv)rmr1rcrs res_codesrrs rx_modezCategorical._mode sm  99;D!u48 1Y/ %++---%%i0 rzc t|S)ae Return the ``Categorical`` which ``categories`` and ``codes`` are unique. 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, str): ['a', 'b', 'c'] >>> pd.Categorical(list("baab"), categories=list("abc"), ordered=True).unique() ['b', 'a'] Categories (3, str): ['a' < 'b' < 'c'] )rr0)rmrs rxr0zCategorical.unique s0w~rzrct|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_rrk array_equalrdrmrns rxrazCategorical.equals sK%-  5 5e <33E:E>>$++u||< <rzc h|dk(rtjj}n:|dk(rtjj}nt d|dt ||j ||jj}|j}|tjjk(r6tj|jj j||<|stjj|}||}d||<|j||jS)Ncummincummaxz Accumulation z not supported for rVr)rkminimum accumulatemaximumr\rhrrcrUr*iinforirNrr)rmrrr r\ryrcrss rx _accumulatezCategorical._accumulate s 8 ::((D X ::((DmD61DT$ZLQR R t$ !yy{ 2::(( (((5;;#3#3488E$K::((.DU d T[[99rzc 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 rxrz0Categorical._concat_same_type..> s6Iqqvv{Is)rrVF)order) pandas.core.dtypes.concatr/rrZrextendrr_concat_same_typereshaperY) r to_concatrr/rtc_flatobjrtres_flatrs rxr5zCategorical._concat_same_type2 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). FrT)rbrcr`rv)rmrnrcs rxrz&Categorical._encode_with_my_categoriesR s8& KK))4?? &&u--rzcXt|jt|jk(S)z Returns True if categoricals are the same dtype same categories, and same ordered Parameters ---------- other : Categorical Returns ------- bool )rrir%s rxr_z/Categorical._categories_match_up_to_permutationc s!DJJ4 #444rzc|jd}||jz }ddlm}ddlm}|||gdd}|d d g|_d |j_|S) z Describes this Categorical Returns ------- description: `DataFrame` A dataframe with frequency and counts by category. F)r1rr)concatTr) ignore_indexrrfreqsr`) r}sumrrKpandas.core.reshape.concatr>columnsrqrr)rmrr@rKr>rs rxdescribezCategorical.describer sa""%"0% 5dC'23(  rzctjt|}|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(["llama", "cow", "llama", "beetle", "llama", "hippo"]) >>> s.isin(["cow", "llama"]) array([ True, True, True, False, True, False]) Passing a single string as ``s.isin('llama')`` will raise an error. Use a list of one element instead: >>> s.isin(["llama"]) array([ True, False, True, False, True, False]) r)rkrr*r`get_indexer_forr+rrc)rmrr code_valuess rxrzCategorical.isin sTPJJtF|, oo55f= !){a/?"@A tzz;77rzc|j}|j}|jdk(rn|jj |||}|jj t jurXt|rM|tjus t|r0d}n-ddl m }||jj |||}t|||S)NrFrNumpyExtensionArrayr)r`rcrirl_str_maprrkr?rr no_defaultr*pandas.core.arraysrJrr1) rmfrriconvertr`rcrrJs rxrKzCategorical._str_map s __     x '%%..q(EBF  ))RVV3!%(/4>! >()<)<)>?HH8UFvu::rzchddlm}||jtdj ||S)NrrIr)r)rMrJrr_str_get_dummies)rmrrirJs rxrQzCategorical._str_get_dummies s/:"4==u=#EFWW   rzc 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)rAprodrcumprodskewkurtz type does not support z operations)rOrNridxminidxmaxzCannot perform z with non-ordered Categorical) rrerrrrOrNrZr[ transformz% dtype does not support aggregation ''r)rrrOrNrZr[r) min_countngroupscomp_idsrs result_mask)rrrOrNrVr)pandas.core.groupby.opsrSget_kind_from_howrir\r[r*rrkrrr_cython_op_ndim_compatcast_blocklistrv)rmrTrUr^r_idsr\rSrrvrirarsnpvalues res_valuess rx _groupby_opzCategorical._groupby_op s <005 4 O  F Fug%r~r|eqrWr}rXltrPgtrQlerRgerSrJrIrr3rQr]rbrfrir*isnullrlnotnullr}rrrrrrrrrdrrfrrrrrrrrHr rrOrNr!r0rar-r5rr_rDrrrLrkrKrQri __classcell__)rs@rxr^r^sqj ..H:1FFM D 11'71 1 1" %  %  % %B( /3%4 ,4;?4 44 OO TT JJDLEIF3 F3F3P" G3  G3  G3 G3G3X7%7%r+"+"Z((T#3J:$ !&F"'JSV'48MP ! SS S  S  Sp         0@))*-);?) )\" 7: DI:&:=B ;L,0%  $( ;? %):@%):@  4&:,>." 5*+8`..0BTX;MQ;2 @3@3 @3  @3  @3"@3rzr^r`r[r~)delegate accessorstyp)r$r(r.r4r;rrrrZcTeZdZdZd dZed dZd dZd dZe d dZ d dZ y) CategoricalAccessora Accessor object for categorical properties of the Series values. Parameters ---------- data : Series or CategoricalIndex The object to which the categorical accessor is attached. See Also -------- Series.dt : Accessor object for datetimelike properties of the Series values. Series.sparse : Accessor for sparse matrix data types. 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, str): ['a', 'b', 'c'] >>> s.cat.categories Index(['a', 'b', 'c'], dtype='str') >>> s.cat.rename_categories(list("cba")) 0 c 1 b 2 b 3 a 4 a 5 a dtype: category Categories (3, str): ['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, str): ['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, str): ['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, str): ['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, str): ['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, str): ['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, str): ['a' < 'b' < 'c'] >>> s.cat.as_unordered() 0 a 1 b 2 b 3 c 4 c 5 c dtype: category Categories (3, str): ['a', 'b', 'c'] c|j||j|_|j|_|j |_|jyr) _validater_parentrq_indexrr_name_freeze)rmdatas rxrzCategoricalAccessor.__init__ s8 t{{ jj YY  rzcNt|jts tdy)Nz2Can only use .cat accessor with a 'category' dtype)r]rir$AttributeError)rs rxrzCategoricalAccessor._validate s"$**&67 !UV V8rzc.t|j|Sr)rjr)rmrrs rx_delegate_property_getz*CategoricalAccessor._delegate_property_get st||T**rzc2t|j||yr)setattrr)rmrr new_valuess rx_delegate_property_setz*CategoricalAccessor._delegate_property_set s dJ/rzc^ddlm}||jj|jS)a9 Return Series of codes as well as the index. See Also -------- Series.cat.categories : Return the categories of this categorical. Series.cat.as_ordered : Set the Categorical to be ordered. Series.cat.as_unordered : Set the Categorical to be unordered. Examples -------- >>> raw_cate = pd.Categorical(["a", "b", None, "a"], categories=["a", "b"]) >>> ser = pd.Series(raw_cate) >>> ser.cat.codes 0 0 1 1 2 -1 3 0 dtype: int8 rr*)rq)rrLrrcr)rmrLs rxrczCategoricalAccessor.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, copy=True) array([ 1, 0, 0, -1], dtype=int8) rrVrrr) rYrUrarFrerrrrrr1) rcold_categoriesrrUrcodes_in_old_catsrindexerr:s rxrbrb s@ >a ::<    ~ . ::<  &66~F !R' 99; MM6+-  ##4nEG26I rzcddlm}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)rnzInput must be list-likeriNrFr=r)rrnrr\rjr]r$r7rkrsrYr`rcrir^r)rrnr cat_codesrr`rcs rxfactorize_from_iterabler* s (  122VWd +F&*+v&IIc&"3"34FLL.k s : " !" % srT)rYrr) iterablesrcr`s rxfactorize_from_iterablesrU sN" 9~2v  : :E: ;Z( ((rzrs)rz,Index | Series | ExtensionArray | np.ndarrayr`rKrkrj)rcrjrUrrrrkrj)rkztuple[np.ndarray, Index])rkz$tuple[list[np.ndarray], list[Index]])| __future__rcsvr functoolsrrr|shutilrtypingrrr r r rnumpyrkpandas._configr pandas._libsr rrrpandas._libs.arraysrpandas.compat.numpyrr pandas.errorsrpandas.util._decoratorsrpandas.util._exceptionsrpandas.util._validatorsrpandas.core.dtypes.castrrpandas.core.dtypes.commonrrrrrrrrr 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.algorithmsr0r1pandas.core.arrays._mixinsr2r3pandas.core.baser4r5r6pandas.core.commoncorecommonrpandas.core.constructionr7r8pandas.core.ops.commonr9pandas.core.sortingr: pandas.core.strings.object_arrayr;rr<collections.abcr=r>r?r@pandas._typingrArBrCrDrErFrGrHrIrrJrKrLr~rr^rrrbrrrrzrxrs" $% ..(.47        ! <(C%   FR06f H`(3-|=S`(3`(3LQ \9$=:    bC.,8LbC "bCP3 83336 8 8  8  88v(V)rz