Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/arrays/__pycache__/categorical.cpython-37.pyc
Назад
B �5�gLh � @ s& d dl mZ d dlmZ d dlmZ d dlZd dlmZ d dl m Z m Z m Z m Z mZmZ d dlmZmZmZ d dlZd dlmZ d d lmZmZm Z m Z d d l m Z d d l!m"Z" d d l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* d d l+m,Z- d dl.m/Z/m0Z0 d dl1m2Z2 d dl3m4Z4 d dl5m6Z6m7Z7 d dl8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZH d dlImJZJmKZK d dlLmMZMmNZN d dlOmPZPmQZQmRZR d dlSmTZT d dlUmVZVmWZW d dlXmY mZZZ d dlXm[Z[m\Z\m]Z]m^Z^ d dl_m`Z` d dlambZbmcZcmdZd d dlemY mfZg d dlhmiZjmkZkmlZl d d lmmnZn d d lompZp d d lqmrZr d d lsmtZt d d lumvZv e �rnd d!lwmxZx e d"d#d$�Zyd%d&� Zzd'd(� Z{G d)d#� d#e`edet�Z|eWe|d*d+gd,d-�eWe|d.d/d0d1d2d3d4d5gd6d-�G d7d8� d8eVedec���Z}d9d:d;�d<d=�Z~dJd:d?d:d@�dAdB�ZdCdD�dEdF�Z�dGdD�dHdI�Z�dS )K� )� annotations)�QUOTE_NONNUMERIC)�partialN)�get_terminal_size)� TYPE_CHECKING�Hashable�Sequence�TypeVar�Union�cast)�catch_warnings� simplefilter�warn)� get_option)�NaT�algos� hashtable�lib)� NDArrayBacked)� no_default)� ArrayLike�Dtype�NpDtype�Ordered�Scalar�Shape�type_t)�function)�cache_readonly�deprecate_kwarg)�find_stack_level)�validate_bool_kwarg)�coerce_indexer_dtype� maybe_cast_to_extension_array)� ensure_int64� ensure_object�ensure_platform_int�is_categorical_dtype�is_datetime64_dtype� is_dict_like�is_dtype_equal�is_extension_array_dtype� is_hashable�is_integer_dtype� is_list_like�is_object_dtype� is_scalar�is_timedelta64_dtype�needs_i8_conversion� pandas_dtype)�CategoricalDtype�ExtensionDtype)�ABCIndex� ABCSeries)�is_valid_na_for_dtype�isna�notna)�ops)�PandasDelegate�delegate_names)� factorize� get_data_algo�take_nd�unique1d)�NDArrayBackedExtensionArray)�ExtensionArray�NoNewAttributesMixin� PandasObject)�array� extract_array�sanitize_array)�deprecate_ndim_indexing)�unpack_zerodim_and_defer)�nargsort)�ObjectStringArrayMixin)�console)�Index� CategoricalT� Categorical)�boundc sB d�j � d���tjkr dnd� t��� ��fdd��}�|_ |S )N�__TFc s� t |�}t|�r,t|�t| �kr,|s,td��| jsB�dkrBtd��t|t�r�d}| �|�sbt|��| js�| j � |j �s�t |j |j | j dd�}n|j }�| j |�}| j dk|dkB }|�� r ||< |S |�r || j k�r| �|�}�| j |�}�dk�r | j dk}� ||< |S t�| |��S n`�d k�rBtd �� d t|�� d ���t|t��rdt|j��rd�|| �S tt�| ���t�|��S d S ) NzLengths must match.)�__lt__�__gt__�__le__�__ge__z7Unordered Categoricals can only compare equality or notz?Categoricals can only be compared if 'categories' are the same.F)�copy���> �__eq__rT rV )rY �__ne__z$Cannot compare a Categorical for op z with type zB. If you want to compare values, use 'np.asarray(cat) <op> other'.)r, r. �len� ValueError�ordered� TypeError� isinstancerP �#_categories_match_up_to_permutation� categories�equals�recode_for_categories�codes�_codes�any� _unbox_scalarr; Zinvalid_comparison�typerC r2 �dtype�getattr�nprF )�self�otherZhashable�msgZ other_codes�ret�mask�i)� fill_value�op�opname� �T/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/arrays/categorical.py�func� sF z _cat_compare_op.<locals>.func)�__name__�operator�nerJ )rs rw ru )rr rs rt rv �_cat_compare_op| s @r{ c s\ t |� y| j�|�}W n ttfk r0 dS X t|�rB|� kS t� fdd�|D ��S dS )aO Helper for membership check for ``key`` in ``cat``. This is a helper method for :method:`__contains__` and :class:`CategoricalIndex.__contains__`. Returns True if ``key`` is in ``cat.categories`` and the location of ``key`` in ``categories`` is in ``container``. Parameters ---------- cat : :class:`Categorical`or :class:`categoricalIndex` key : a hashable object The key to check membership for. container : Container (e.g. list-like or mapping) The container to check for membership in. Returns ------- is_in : bool True if ``key`` is in ``self.categories`` and location of ``key`` in ``categories`` is in ``container``, else False. Notes ----- This method does not check for NaN values. Do that separately before calling this method. Fc 3 s | ]}|� kV qd S )Nru )�.0�loc_)� containerru rv � <genexpr>� s zcontains.<locals>.<genexpr>N)�hashra �get_loc�KeyErrorr^ r0 rf )�cat�keyr~ �locru )r~ rv �contains� s r� c s� e Zd ZU dZdZejedg�B ZdZde d< d�d d d �� fd d� Z e dd�dd��Z e dd�dd��Z eddd �d d�dd��Zd�dd dd�dd �Zed d�d d ��Zd d�d!d"�ZeZed�d#d$��Zed�d d�d%d&��Ze d'd(� �Zej� fd)d(��Ze d*d�d+d,��Ze d-d�d.d/��Zdԇ fd0d1� Zdd d2�d3d4�Z d�d5d6�Z d�d7d8�Z d�d9d:�Z dde fd;d<�Z!e fd=d>�Z"de fd?d@�Z#e fdAdB�Z$e fdCdD�Z%e fdEdF�Z&dGdH� Z'e(e)j*�Z+e(e)j,�Z-e(e)j.�Z/e(e)j0�Z1e(e)j2�Z3e(e)j4�Z5dIdJ� Z6dKdL� Z7d�dMd-d2�dNdO�Z8dPdQdR�dSdT�Z9� fdUdV�Z:e d d�dWdX��Z;d�d d dY�dZd[�Z<d-d�d\d]�Z=e=Z>d-d�d^d_�Z?e?Z@d�d d`�dadb�ZAedcdddd de�dfdg��ZBdhdi� ZCdjdk� ZDdۇ fdmdn� ZEd�d d dQdp�dqdr�ZFdsdt� ZGd�dudv�ZHd-d�dwdx�ZIe d-d�dydz��ZJeJjd-d{�d|dz��ZJd d}�d~d�ZKd d�d�d��ZLd�d d��d�d��ZMd�d�� ZNd d�d�d��ZOd�d d��d�d��ZPd�dQd�d�d��ZQd�d�� ZRdQd�d�d��ZSdQd�d�d��ZTd�d d dQd��d�d��ZUdQd�d�d��ZV� fd�d��ZWd�d�� ZXd�d�d�d��ZYeZd�d�d��d d��d�d���Z[eZd�d�d��d d��d�d���Z\d�d�d��Z]d�d�� Z^d�d�� Z_ed�d�� �Z`d�d d��d�d��Zaed�d�d�d d�d��d�d���Zbd d d��d�d��Zcd d d��d�d��Zdd d�d�dZed�dĄ Zfd-d�d�dƄZgd�d dǜd�dɄZheijjei� d��d fd dʜd�d̄Zkd�d�dτZl� ZmS )�rP a^ Represent a categorical variable in classic R / S-plus fashion. `Categoricals` can only take on only a limited, and usually fixed, number of possible values (`categories`). In contrast to statistical categorical variables, a `Categorical` might have an order, but numerical operations (additions, divisions, ...) are not possible. All values of the `Categorical` are either in `categories` or `np.nan`. Assigning values outside of `categories` will raise a `ValueError`. Order is defined by the order of the `categories`, not lexical order of the values. Parameters ---------- values : list-like The values of the categorical. If categories are given, values not in categories will be replaced with NaN. categories : Index-like (unique), optional The unique categories for this categorical. If not given, the categories are assumed to be the unique values of `values` (sorted, if possible, otherwise in the order in which they appear). ordered : bool, default False Whether or not this categorical is treated as a ordered categorical. If True, the resulting categorical will be ordered. An ordered categorical respects, when sorted, the order of its `categories` attribute (which in turn is the `categories` argument, if provided). dtype : CategoricalDtype An instance of ``CategoricalDtype`` to use for this categorical. Attributes ---------- categories : Index The categories of this categorical codes : ndarray The codes (integer positions, which point to the categories) of this categorical, read only. ordered : bool Whether or not this Categorical is ordered. dtype : CategoricalDtype The instance of ``CategoricalDtype`` storing the ``categories`` and ``ordered``. Methods ------- from_codes __array__ Raises ------ ValueError If the categories do not validate. TypeError If an explicit ``ordered=True`` is given but no `categories` and the `values` are not sortable. See Also -------- CategoricalDtype : Type for categorical data. CategoricalIndex : An Index with an underlying ``Categorical``. Notes ----- See the `user guide <https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html>`__ for more. Examples -------- >>> pd.Categorical([1, 2, 3, 1, 2, 3]) [1, 2, 3, 1, 2, 3] Categories (3, int64): [1, 2, 3] >>> pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c']) ['a', 'b', 'c', 'a', 'b', 'c'] Categories (3, object): ['a', 'b', 'c'] Missing values are not included as a category. >>> c = pd.Categorical([1, 2, 3, 1, 2, 3, np.nan]) >>> c [1, 2, 3, 1, 2, 3, NaN] Categories (3, int64): [1, 2, 3] However, their presence is indicated in the `codes` attribute by code `-1`. >>> c.codes array([ 0, 1, 2, 0, 1, 2, -1], dtype=int8) Ordered `Categoricals` can be sorted according to the custom order of the categories and can have a min and max value. >>> c = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'], ordered=True, ... categories=['c', 'b', 'a']) >>> c ['a', 'b', 'c', 'a', 'b', 'c'] Categories (3, object): ['c' < 'b' < 'a'] >>> c.min() 'c' i� �tolistZ categoricalr4 �_dtypeNFTz Dtype | None�bool)ri rW c sH t �� |||�}|rBt� |j�}t dd��|�}t� �||� d S t� �s^tdt dd� � g� t � d�}t � �r�|jd kr�t � j|j �}n�t� tttf��s>t�� �� t� t�r�t� �dkr�t j g td�� nrt� t j�r�� jdkr�td ��t� d �� nHt� d �} t| �}|� � �r:� fd d �t � | �d D �} t| d �} | � |jd k�r�yt � d d �\}}W nF t k �r� } z&t � dd �\}}|j �r�t d�| �W d d } ~ X Y nX t ||j �}n:t � j ��r�t!� �j"} t#| � j j|j|d�}n t$� |j�}|� � �rt j%|j&|j d� } || | < | }t dd��|�}t||j�} t� �| |� d S )NF)r] zxAllowing scalars in the Categorical constructor is deprecated and will raise in a future version. Use `[value]` instead� )� stacklevelr )ri � z3> 1 ndim Categorical are not supported at this timec s g | ] }� | �qS ru ru )r| �idx)�valuesru rv � <listcomp>� s z(Categorical.__init__.<locals>.<listcomp>T)�sortzl'values' is not ordered, please explicitly specify the categories order by passing in a categories argument.)rW )'r4 �_from_values_or_dtyper" ra � update_dtype�super�__init__r. r � FutureWarningrk rF r' r] r_ r6 r7 rC �comZconvert_to_list_like�listr[ �objectZndarray�ndim�NotImplementedErrorrH r9 rf �wherer> r^ ri rG re rc �_get_codes_for_valuesZones�shape) rl r� ra r] ri �fastpathrW rd � null_mask�arr�errZ old_codesZ full_codes)� __class__)r� rv r� i sl zCategorical.__init__)�returnc C s | j S )zT The :class:`~pandas.api.types.CategoricalDtype` for this instance. )r� )rl ru ru rv ri � s zCategorical.dtypeztype[Categorical]c C s t S )N)rP )rl ru ru rv � _constructor� s zCategorical._constructor)ri c C s t |||d�S )N)ri rW )rP )�clsZscalarsri rW ru ru rv �_from_sequence� s zCategorical._from_sequencer r )ri rW r� c C sT t |�}| j|kr&|r | �� n| }�n*t|�rhttttf |�}| j�|�}|rX| �� n| } | � |�}n�t |t �r�t | ||d�}n�t |�r�| �� �� r�td��n�t| j�dks�t| j�dkr�tj| ||d�}n�y6t�| j�}|j||d�}t�t�tj��|��}W n6 ttfk �r: d| jj� d|� �}t|��Y nX t |t | j �|d�}|S )aZ Coerce this type to another dtype Parameters ---------- dtype : numpy dtype or pandas type copy : bool, default True By default, astype always returns a newly allocated object. If copy is set to False and dtype is categorical, the original object is returned. )ri rW z#Cannot convert float NaN to integerr z Cannot cast z dtype to )rr ) r3 ri rW r' r r �strr4 r� � _set_dtyper_ r5 �pd_arrayr- r9 rf r\ r[ rd ra rk rF �asarray�astyper Zitem_from_zerodim�nanr^ r@ r& re )rl ri rW �resultZnew_catsrr rn ru ru rv r� � s: zCategorical.astype�intc C s | j jS )z6 return the size of a single category )ra �itemsize)rl ru ru rv r� s zCategorical.itemsizez list[Scalar]c C s t | �S )z� Return a list of the values. These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period) )r� )rl ru ru rv r� % s zCategorical.tolistc C s ddl m}m}m}m} ||�} t|t�o2|jdk } | r�|j�� rP||dd�} nVt |j�rh||dd�} n>t |j�r�||dd�} n&|j� � r�|dkr�dddg}| � |�} | r�|j} t || | �} n@| js�| �� } | �� } t || | �} t| d d �}nt| d d �}|} | | |d d �S ) aA Construct a Categorical from inferred values. For inferred categories (`dtype` is None) the categories are sorted. For explicit `dtype`, the `inferred_categories` are cast to the appropriate type. Parameters ---------- inferred_categories : Index inferred_codes : Index dtype : CategoricalDtype or 'category' true_values : list, optional If none are provided, the default ones are "True", "TRUE", and "true." Returns ------- Categorical r )rN � to_datetime� to_numeric� to_timedeltaNZcoerce)�errors�True�TRUE�trueF)r] T)ri r� )�pandasrN r� r� r� r_ r4 ra � is_numericr( r1 Z is_boolean�isinrc Zis_monotonic_increasingrW � sort_values)r� Zinferred_categoriesZinferred_codesri Z true_valuesrN r� r� r� �catsZknown_categoriesra rd Zunsortedru ru rv �_from_inferred_categories1 s2 z%Categorical._from_inferred_categoriesc C s� t j|||d�}|jdkr&d}t|��t|�rZt|�rZt|��� rJtd��|jt j d�}n t � |�}t |�r|t|�s|td��t |�r�|� � t |j�ks�|�� dk r�td��| ||d d �S ) a� Make a Categorical type from codes and categories or dtype. This constructor is useful if you already have codes and categories/dtype and so do not need the (computation intensive) factorization step, which is usually done on the constructor. If your data does not follow this convention, please use the normal constructor. Parameters ---------- codes : array-like of int An integer array, where each integer points to a category in categories or dtype.categories, or else is -1 for NaN. categories : index-like, optional The categories for the categorical. Items need to be unique. If the categories are not given here, then they must be provided in `dtype`. ordered : bool, optional Whether or not this categorical is treated as an ordered categorical. If not given here or in `dtype`, the resulting categorical will be unordered. dtype : CategoricalDtype or "category", optional If :class:`CategoricalDtype`, cannot be used together with `categories` or `ordered`. Returns ------- Categorical Examples -------- >>> dtype = pd.CategoricalDtype(['a', 'b'], ordered=True) >>> pd.Categorical.from_codes(codes=[0, 1, 0, 1], dtype=dtype) ['a', 'b', 'a', 'b'] Categories (2, object): ['a' < 'b'] )ra r] ri NzKThe categories must be provided in 'categories' or 'dtype'. Both were None.z codes cannot contain NA values)ri z$codes need to be array-like integersrX z1codes need to be between -1 and len(categories)-1T)ri r� )r4 r� ra r\ r+ r- r9 rf �to_numpyrk �int64r� r[ �max�min)r� rd ra r] ri rn ru ru rv � from_codesv s * &zCategorical.from_codesc C s | j jS )a� The categories of this categorical. Setting assigns new values to each category (effectively a rename of each individual category). The assigned value has to be a list-like object. All items must be unique and the number of items in the new categories must be the same as the number of items in the old categories. Assigning to `categories` is a inplace operation! 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. )ri ra )rl ru ru rv ra � s zCategorical.categoriesc sL t || jd�}| jjd k r8t| jj�t|j�kr8td��t� �| j|� d S )N)r] zKnew categories need to have the same number of items as the old categories!) r4 r] ri ra r[ r\ r� r� �_ndarray)rl ra � new_dtype)r� ru rv ra � s r c C s | j jS )zF Whether the categories have an ordered relationship. )ri r] )rl ru ru rv r] � s zCategorical.orderedz np.ndarrayc C s | j �� }d|j_|S )a� The category codes of this categorical. Codes are an array of integers which are the positions of the actual values in the categories array. There is no setter, use the other categorical methods and the normal item setter to change values in the categorical. Returns ------- ndarray[int] A non-writable view of the `codes` array. F)re �view�flagsZ writeable)rl �vru ru rv rd � s zCategorical.codesc sd |rt �|| j�}nt || jd�}|sP| jjdk rPt|j�t| jj�krPtd��t� �| j |� dS )a� Sets new categories inplace Parameters ---------- fastpath : bool, default False Don't perform validation of the categories for uniqueness or nulls Examples -------- >>> c = pd.Categorical(['a', 'b']) >>> c ['a', 'b'] Categories (2, object): ['a', 'b'] >>> c._set_categories(pd.Index(['a', 'c'])) >>> c ['a', 'c'] Categories (2, object): ['a', 'c'] )r] NzMnew categories need to have the same number of items than the old categories!) r4 �_from_fastpathr] ri ra r[ r\ r� r� r� )rl ra r� r� )r� ru rv �_set_categories s zCategorical._set_categories)ri r� c C s$ t | j| j|j�}t| �||dd�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`. T)ri r� )rc rd ra rh )rl ri rd ru ru rv r� ' s zCategorical._set_dtypec C sD t |d�}t| j|d�}|r | n| �� }t�||j|� |s@|S dS )a| Set the ordered attribute to the boolean value. Parameters ---------- value : bool Set whether this categorical is ordered (True) or not (False). inplace : bool, default False Whether or not to set the ordered attribute in-place or return a copy of this categorical with ordered set to the value. �inplace)r] N)r! r4 ra rW r r� r� )rl �valuer� r� r� ru ru rv � set_ordered7 s zCategorical.set_orderedc C s t |d�}| jd|d�S )a� Set the Categorical to be ordered. Parameters ---------- inplace : bool, default False Whether or not to set the ordered attribute in-place or return a copy of this categorical with ordered set to True. Returns ------- Categorical or None Ordered Categorical or None if ``inplace=True``. r� T)r� )r! r� )rl r� ru ru rv � as_orderedJ s zCategorical.as_orderedc C s t |d�}| jd|d�S )a� Set the Categorical to be unordered. Parameters ---------- inplace : bool, default False Whether or not to set the ordered attribute in-place or return a copy of this categorical with ordered set to False. Returns ------- Categorical or None Unordered Categorical or None if ``inplace=True``. r� F)r� )r! r� )rl r� ru ru rv � as_unordered\ s zCategorical.as_unorderedc C s� |t k rtdtdd� nd}t|d�}|dkr6| jj}t||d�}|rJ| n| �� }|r�|jjdk r�t |j�t |jj�k r�d|j |j t |j�k< |j }nt |j |j|j�}t �|||� |s�|S dS ) a� Set the categories to the specified new_categories. `new_categories` can include new categories (which will result in unused categories) or remove old categories (which results in values set to NaN). If `rename==True`, the categories will simple be renamed (less or more items than in old categories will result in values set to NaN or in unused categories respectively). This method can be used to perform more than one action of adding, removing, and reordering simultaneously and is therefore faster than performing the individual steps via the more specialised methods. On the other hand this methods does not do checks (e.g., whether the old categories are included in the new categories on a reorder), which can result in surprising changes, for example when using special string dtypes, which does not considers a S1 string equal to a single char python string. Parameters ---------- new_categories : Index-like The categories in new order. ordered : bool, default False Whether or not the categorical is treated as a ordered categorical. If not given, do not change the ordered information. rename : bool, default False Whether or not the new_categories should be considered as a rename of the old categories or as reordered categories. inplace : bool, default False Whether or not to reorder the categories in-place or return a copy of this categorical with reordered categories. .. deprecated:: 1.3.0 Returns ------- Categorical with reordered categories or None if inplace. 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. z�The `inplace` parameter in pandas.Categorical.set_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.r� )r� Fr� N)r] rX )r r r� r! ri r] r4 rW ra r[ re rc rd r r� )rl �new_categoriesr] �renamer� r� r� rd ru ru rv �set_categoriesn s* 7 zCategorical.set_categoriesc s� |t k rtdtdd� nd}t|d�}|r.| n| �� }t� �rV� fdd�|jD �|_n&t� �rv� fdd�|jD �|_n� |_|s�|S d S ) a� Rename categories. Parameters ---------- new_categories : list-like, dict-like or callable New categories which will replace old categories. * list-like: all items must be unique and the number of items in the new categories must match the existing number of categories. * dict-like: specifies a mapping from old categories to new. Categories not contained in the mapping are passed through and extra categories in the mapping are ignored. * callable : a callable that is called on all items in the old categories and whose return values comprise the new categories. inplace : bool, default False Whether or not to rename the categories inplace or return a copy of this categorical with renamed categories. .. deprecated:: 1.3.0 Returns ------- cat : Categorical or None Categorical with removed categories or None if ``inplace=True``. 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'] z�The `inplace` parameter in pandas.Categorical.rename_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.r� )r� Fr� c s g | ]}� � ||��qS ru )�get)r| �item)r� ru rv r� s z1Categorical.rename_categories.<locals>.<listcomp>c s g | ] }� |��qS ru ru )r| r� )r� ru rv r� s N)r r r� r! rW r) ra �callable)rl r� r� r� ru )r� rv �rename_categories� s B z Categorical.rename_categoriesc C sn |t k rtdtt� d� nd}t|d�}t| jj�t|�krDtd��t � � t d� | j |||d�S Q R X dS ) a Reorder categories as specified in new_categories. `new_categories` need to include all old categories and no new category items. Parameters ---------- new_categories : Index-like The categories in new order. ordered : bool, optional Whether or not the categorical is treated as a ordered categorical. If not given, do not change the ordered information. inplace : bool, default False Whether or not to reorder the categories inplace or return a copy of this categorical with reordered categories. .. deprecated:: 1.3.0 Returns ------- cat : Categorical or None Categorical with removed categories or None if ``inplace=True``. Raises ------ ValueError If the new categories do not contain all old category items or any new ones See Also -------- rename_categories : Rename categories. add_categories : Add new categories. remove_categories : Remove the specified categories. remove_unused_categories : Remove categories which are not used. set_categories : Set the categories to the specified ones. z�The `inplace` parameter in pandas.Categorical.reorder_categories is deprecated and will be removed in a future version. Reordering categories will always return a new Categorical object.)r� Fr� z=items in new_categories are not the same as in old categories�ignore)r] r� N) r r r� r r! �setri ra r\ r r r� )rl r� r] r� ru ru rv �reorder_categories! s ' z Categorical.reorder_categoriesc C s� |t k rtdtdd� nd}t|d�}t|�s4|g}t|�t| jj�@ }t|�dkrbt d|� ���t | jj�t |� }t || j �}|r�| n| � � }t|j|j�}t�|||� |s�|S dS ) 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. inplace : bool, default False Whether or not to add the categories inplace or return a copy of this categorical with added categories. .. deprecated:: 1.3.0 Returns ------- cat : Categorical or None Categorical with new categories added or None if ``inplace=True``. 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. z�The `inplace` parameter in pandas.Categorical.add_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.r� )r� Fr� r z0new categories must not include old categories: N)r r r� r! r. r� ri ra r[ r\ r� r4 r] rW r" r� r r� )rl r� r� Zalready_includedr� r� rd ru ru rv �add_categories^ s( $ zCategorical.add_categoriesc s� |t k rtdtdd� nd}t|d�}t|�s4|g}t|�� � t| jj� }� fdd�| jjD �}tt |��r�dd � |D �}d d� |D �}t |�d kr�t d |� ���t � � t d � | j|| jd|d�S Q R X dS )aK 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. inplace : bool, default False Whether or not to remove the categories inplace or return a copy of this categorical with removed categories. .. deprecated:: 1.3.0 Returns ------- cat : Categorical or None Categorical with removed categories or None if ``inplace=True``. 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. z�The `inplace` parameter in pandas.Categorical.remove_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.r� )r� Fr� c s g | ]}|� kr|�qS ru ru )r| �c)� removal_setru rv r� � s z1Categorical.remove_categories.<locals>.<listcomp>c S s h | ]}t |�r|�qS ru )r: )r| �xru ru rv � <setcomp>� s z0Categorical.remove_categories.<locals>.<setcomp>c S s g | ]}t |�r|�qS ru )r: )r| r� ru ru rv r� � s r z(removals must all be in old categories: r� )r] r� r� N)r r r� r! r. r� ri ra rf r9 r[ r\ r r r� r] )rl Zremovalsr� Z not_includedr� ru )r� rv �remove_categories� s* # z Categorical.remove_categoriesc C s� |t k rtdtdd� nd}t|d�}|r.| n| �� }tj|jdd�\}}|jdkrv|d d krv|d d � |d }}|j j � |�}t j || jd �}t||j �}t�|||� |s�|S d S ) a� Remove categories which are not used. Parameters ---------- inplace : bool, default False Whether or not to drop unused categories inplace or return a copy of this categorical with unused categories dropped. .. deprecated:: 1.2.0 Returns ------- cat : Categorical or None Categorical with unused categories dropped or None if ``inplace=True``. See Also -------- rename_categories : Rename categories. reorder_categories : Reorder categories. add_categories : Add new categories. remove_categories : Remove the specified categories. set_categories : Set the categories to the specified ones. z}The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.r� )r� Fr� T)Zreturn_inverser rX r� N)r] )r r r� r! rW rk �uniquere �sizeri ra �taker4 r� r] r" r r� )rl r� r� r� �invr� r� � new_codesru ru rv �remove_unused_categories� s$ z$Categorical.remove_unused_categoriesc C sj | j �|�}y| j| j�� || jd�S tk rd t�| jdk�rV|� t |�tj �}t� || j�S X dS )a� Map categories using input correspondence (dict, Series, or function). Maps the categories to new categories. If the mapping correspondence is one-to-one the result is a :class:`~pandas.Categorical` which has the same order property as the original, otherwise a :class:`~pandas.Index` is returned. NaN values are unaffected. If a `dict` or :class:`~pandas.Series` is used any unmapped category is mapped to `NaN`. Note that if this happens an :class:`~pandas.Index` will be returned. Parameters ---------- mapper : function, dict, or Series Mapping correspondence. Returns ------- pandas.Categorical or pandas.Index Mapped categorical. See Also -------- CategoricalIndex.map : Apply a mapping correspondence on a :class:`~pandas.CategoricalIndex`. Index.map : Apply a mapping correspondence on an :class:`~pandas.Index`. Series.map : Apply a mapping correspondence on a :class:`~pandas.Series`. Series.apply : Apply more complex functions on a :class:`~pandas.Series`. Examples -------- >>> cat = pd.Categorical(['a', 'b', 'c']) >>> cat ['a', 'b', 'c'] Categories (3, object): ['a', 'b', 'c'] >>> cat.map(lambda x: x.upper()) ['A', 'B', 'C'] Categories (3, object): ['A', 'B', 'C'] >>> cat.map({'a': 'first', 'b': 'second', 'c': 'third'}) ['first', 'second', 'third'] Categories (3, object): ['first', 'second', 'third'] If the mapping is one-to-one the ordering of the categories is preserved: >>> cat = pd.Categorical(['a', 'b', 'c'], ordered=True) >>> cat ['a', 'b', 'c'] Categories (3, object): ['a' < 'b' < 'c'] >>> cat.map({'a': 3, 'b': 2, 'c': 1}) [3, 2, 1] Categories (3, int64): [3 < 2 < 1] If the mapping is not one-to-one an :class:`~pandas.Index` is returned: >>> cat.map({'a': 'first', 'b': 'second', 'c': 'first'}) Index(['first', 'second', 'first'], dtype='object') If a `dict` is used, all unmapped categories are mapped to `NaN` and the result is an :class:`~pandas.Index`: >>> cat.map({'a': 'first', 'b': 'second'}) Index(['first', 'second', nan], dtype='object') )ra r] rX N) ra �mapr� re rW r] r\ rk rf �insertr[ r� r� )rl Zmapperr� ru ru rv r� s E zCategorical.mapc s< t |�r� �|�}n$� fdd�|D �}tj|� jjd�}|S )Nc s g | ]}� j �|��qS ru )ra r� )r| r� )rl ru rv r� { s z<Categorical._validate_searchsorted_value.<locals>.<listcomp>)ri )r0 rg rk rF rd ri )rl r� rd Zlocsru )rl rv � _validate_searchsorted_valueu s z(Categorical._validate_searchsorted_valuec C s> t || jj�rd}n&|| jkr*| �|�}ntd|� d���|S )aK Convert a user-facing fill_value to a representation to use with our underlying ndarray, raising TypeError if this is not possible. Parameters ---------- fill_value : object Returns ------- fill_value : int Raises ------ TypeError rX z 'fill_value=z1' is not present in this Categorical's categories)r8 ra ri rg r^ )rl rr ru ru rv �_validate_scalar� s z Categorical._validate_scalarzNpDtype | Nonec C s8 t | jj| j�}|r.t|| jj�s.t�||�S t�|�S )z� The numpy array interface. Returns ------- numpy.array A numpy array of either the specified dtype or, if dtype==None (default), the same dtype as categorical.categories.dtype. )r@ ra Z_valuesre r* ri rk r� )rl ri ro ru ru rv � __array__� s zCategorical.__array__znp.ufuncr� )�ufunc�methodc O s> t j| ||f|�|�}|tk r"|S td| j� d|j� ���d S )NzObject with dtype z cannot perform the numpy op )r; Z!maybe_dispatch_ufunc_to_dunder_op�NotImplementedr^ ri rx )rl r� r� �inputs�kwargsr� ru ru rv �__array_ufunc__� s zCategorical.__array_ufunc__c sb t |t�st� �|�S d|kr4t|d |d �|d< d|krRd|krR|�d�|d< t� �|� dS )z*Necessary for making this object picklabler� Z _categoriesZ_orderedre r� N)r_ �dictr� � __setstate__r4 �pop)rl �state)r� ru rv r� � s zCategorical.__setstate__c C s | j j| jjjj S )N)re �nbytesri ra r� )rl ru ru rv r� � s zCategorical.nbytes)�deepr� c C s | j j| jjj|d� S )a� Memory usage of my values Parameters ---------- deep : bool Introspect the data deeply, interrogate `object` dtypes for system-level memory consumption Returns ------- bytes used Notes ----- Memory usage does not include memory consumed by elements that are not components of the array if deep=False See Also -------- numpy.ndarray.nbytes )r� )re r� ri ra � memory_usage)rl r� ru ru rv r� � s zCategorical.memory_usagec C s | j dkS )aX Detect missing values Missing values (-1 in .codes) are detected. Returns ------- np.ndarray[bool] of whether my values are null See Also -------- isna : Top-level isna. isnull : Alias of isna. Categorical.notna : Boolean inverse of Categorical.isna. rX )re )rl ru ru rv r9 � s zCategorical.isnac C s | � � S )a� Inverse of isna Both missing values (-1 in .codes) and NA as a category are detected as null. Returns ------- np.ndarray[bool] of whether my values are not null See Also -------- notna : Top-level notna. notnull : Alias of notna. Categorical.isna : Boolean inverse of Categorical.notna. )r9 )rl ru ru rv r: s zCategorical.notna)�dropnac C s� ddl m}m} | j| j }}t|�|dk }}t�|�|�� }} |sL| rp| rT|n|| } tj | |phdd�} n t� t� |||��} t� |d�}t || j j�}| �|�}|| ||�dd�S )a{ Return a Series containing counts of each category. Every category will have an entry, even those with a count of 0. Parameters ---------- dropna : bool, default True Don't include counts of NaN. Returns ------- counts : Series See Also -------- Series.value_counts r )�CategoricalIndex�Series)Z minlengthrX r� )�indexri )r� r� r� re ra r[ rk �arange�allZbincountr� �appendr" ri �_from_backing_data) rl r� r� r� �coder� Zncatrp Zix�cleanZobs�countru ru rv � value_counts s zCategorical.value_countsztype_t[Categorical]r )r� r� ri r� c C s* | j g |d�}tj||jjd�}|�|�S )z� Analogous to np.empty(shape, dtype=dtype) Parameters ---------- shape : tuple[int] dtype : CategoricalDtype )ri )r� rk Zzerosr� ri r� )r� r� ri r� Zbackingru ru rv �_emptyC s zCategorical._emptyc C sV t | jj�r | jj| jtd�S t| j�rLd| jkrL| j�d�j| jtj d�S t� | �S )a Return the values. For internal compatibility with pandas formatting. Returns ------- np.ndarray or Index A numpy array of the same dtype as categorical.categories.dtype or Index if datetime / periods. )rr rX r� ) r2 ra ri r� re r r- r� rk r� rF )rl ru ru rv �_internal_get_valuesX s z Categorical._internal_get_valuesc C s | j std|� d���dS )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^ )rl rs ru ru rv �check_for_orderedk s z Categorical.check_for_ordered� quicksortc s t � jf ||d�|��S )a� Return the indices that would sort the Categorical. .. versionchanged:: 0.25.0 Changed to sort missing values 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]) )� ascending�kind)r� �argsort)rl r r r� )r� ru rv r t s 3zCategorical.argsort�last)r� r � na_positionc C sd t |d�}|dkr$tdt|�� ���t| ||d�}|rL| j| | jdd�< n| j| }| �|�S dS )a7 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] Inplace sorting can be done as well: >>> c.sort_values(inplace=True) >>> c [1, 1, 2, 2, 5] Categories (3, int64): [1, 2, 5] >>> >>> c = pd.Categorical([1, 2, 2, 1, 5]) 'sort_values' behaviour with NaNs. Note that 'na_position' is independent of the 'ascending' parameter: >>> c = pd.Categorical([np.nan, 2, 2, np.nan, 5]) >>> c [NaN, 2, 2, NaN, 5] Categories (2, int64): [2, 5] >>> c.sort_values() [2, 2, 5, NaN, NaN] Categories (2, int64): [2, 5] >>> c.sort_values(ascending=False) [5, 2, 2, NaN, NaN] Categories (2, int64): [2, 5] >>> c.sort_values(na_position='first') [NaN, NaN, 2, 2, 5] Categories (2, int64): [2, 5] >>> c.sort_values(ascending=False, na_position='first') [NaN, NaN, 5, 2, 2] Categories (2, int64): [2, 5] r� )r �firstzinvalid na_position: )r r N)r! r\ �reprrK re r� )rl r� r r Z sorted_idxrd ru ru rv r� � s L zCategorical.sort_valuesc C st ddl m} | jr>| j}|dk}|�� rp|�d�}tj||< n2| j� � rTt� | �}n t� | � || j�� � j ��}|S )z� For correctly ranking ordered categorical data. See GH#15420 Ordered categorical data should be ranked on the basis of codes with -1 translated to NaN. Returns ------- numpy.array r )r� rX Zfloat64)r� r� r] rd rf r� rk r� ra r� rF r� Zrankr� )rl r� r� rp ru ru rv �_values_for_rank s z Categorical._values_for_rankc C s |d k rt |��| �| j�S )N)r� r� r� )rl ri ru ru rv r� s zCategorical.viewc C s t dtdd� t�| �S )z� Return my 'dense' representation For internal compatibility with numpy arrays. Returns ------- dense : array ziCategorical.to_dense is deprecated and will be removed in a future version. Use np.asarray(cat) instead.r� )r� )r r� rk r� )rl ru ru rv �to_dense$ s zCategorical.to_densec C s | j S )N)r� )rl ru ru rv re 9 s zCategorical._codes)r� c C s" t dtdd� t�| || j� d S )Nz|Setting the codes on a Categorical is deprecated and will raise in a future version. Create a new Categorical object insteadr� )r� )r r� r r� ri )rl r� ru ru rv re = s )rq c C s |dkrt jS | j| S )NrX )rk �NaNra )rl rq ru ru rv � _box_funcG s zCategorical._box_funcc C s | j �|�}| jj�|�}|S )N)ra r� r� ri rh )rl r� r� ru ru rv rg L s zCategorical._unbox_scalar)� allow_fillc C s t dtdd� | j|||d�S )Nz?Categorical.take_nd is deprecated, use Categorical.take insteadr� )r� )r rr )r r� r� )rl �indexerr rr ru ru rv r@ U s zCategorical.take_ndc C s t | �� �� �S )zJ Returns an Iterator over the values of this Categorical. )�iterr r� )rl ru ru rv �__iter__^ s zCategorical.__iter__c C s. t || jj�r t| �� �� �S t| || jd�S )z? Returns True if `key` is in this Categorical. )r~ )r8 ra ri r� r9 rf r� re )rl r� ru ru rv � __contains__d s zCategorical.__contains__)�boxedc C s d S )Nru )rl r ru ru rv � _formatterq s zCategorical._formatter� c C sv |d }| d|� j ddd�}| || d� j ddd�}|dd� � d|dd� � �}|rn|� d| �� � �}t|�S ) zd a short repr displaying only max_vals and an optional (but default footer) r� NF)�length�footerrX z, ..., r� � )� _get_repr� _repr_footerr� )rl Zmax_valsr �num�head�tailr� ru ru rv � _tidy_repru s zCategorical._tidy_reprc C s� t d�dkrdnt d�}ddlm} t|jdtd�}t| j�|kr�|d }|| jd|� �}|| j| d� �}|dg | }n || j�}d d � |D �}|S ) z9 return the base repr for the categories zdisplay.max_categoriesr r )�formatN)� formatter�quotingr� z...c S s g | ] }|� � �qS ru )�strip)r| r� ru ru rv r� � s z0Categorical._repr_categories.<locals>.<listcomp>)r �pandas.io.formatsr" r � format_arrayr r[ ra )rl Zmax_categories�fmtr' r r r � category_strsru ru rv �_repr_categories� s z Categorical._repr_categoriesc C s | � � }t| jj�}dt| j�� d|� d�}t� \}}td�p@|}t�� rNd}d}d}t|�} | j rhdnd \} } | � � d } xr|D ]j} |dkr�| | t| � |kr�|| d t|�d 7 }t|�d } n|s�|| 7 }| t| �7 } || 7 }d }q�W |d |� dd� d S )z@ Returns a string representation of the footer. z Categories (z, z): z display.widthr � T)� z < )r� z, r � r� F�[z < ... < z ... �]) r* r� ra ri r[ r r rM Zin_ipython_frontendr] �rstrip�replace)rl r) ri Z levheader�width�height� max_widthZ levstring�startZ cur_col_lenZsep_len�sep�linesep�valru ru rv �_repr_categories_info� s, z!Categorical._repr_categories_infoc C s | � � }dt| �� d|� �S )NzLength: r )r9 r[ )rl �inforu ru rv r � s zCategorical._repr_footerr )r r r� c C s. ddl m} |j| |||d�}|�� }t|�S )Nr )r" )r �na_repr )r& r" ZCategoricalFormatterZ to_stringr� )rl r r; r r( r# r� ru ru rv r � s zCategorical._get_reprc C sf d}t | j�|kr | �|�}nDt | j�dkrB| jt | �|kd�}n | jddd��dd�}d |� �}|S ) z( String representation. r r )r FT)r r r z, z[], )r[ re r! r r1 )rl �_maxlenr� rn ru ru rv �__repr__� s zCategorical.__repr__c s. t � �|�}t|dd�dkr*|j}t|� |S )z! Return an item. r� r r� )r� � __getitem__rj r� rI )rl r� r� )r� ru rv r> � s zCategorical.__getitem__c C s� t |dd�}t|t�r<t| j|j�s,td��| �|�}|jS t|�sH|n|g}ddl m } ||dd�� | j �}t |�r�t|��� s�td��| j �|�}|j| jjdd �S ) NT)Z extract_numpyzCCannot set a Categorical with another, without identical categoriesr )rN F)Z tupleize_colszMCannot setitem on a Categorical with a new category, set the categories first)rW )rG r_ rP r* ri r\ �_encode_with_my_categoriesre r, r� rN � differencera r[ r9 r� � get_indexerr� r� )rl r� ZrvaluerN Zto_addrd ru ru rv �_validate_setitem_value� s z#Categorical._validate_setitem_valuezdict[Hashable, np.ndarray]c sX | j }t�t| j�|j�\� }t|��� }� fdd�t||dd� �D �}t t||��S )a� Compute the inverse of a categorical, returning a dict of categories -> indexers. *This is an internal function* Returns ------- Dict[Hashable, np.ndarray[np.intp]] dict of categories -> indexers Examples -------- >>> c = pd.Categorical(list('aabca')) >>> c ['a', 'a', 'b', 'c', 'a'] Categories (3, object): ['a', 'b', 'c'] >>> c.categories Index(['a', 'b', 'c'], dtype='object') >>> c.codes array([0, 0, 1, 2, 0], dtype=int8) >>> c._reverse_indexer() {'a': array([0, 1, 4]), 'b': array([2]), 'c': array([3])} c 3 s | ]\}}� ||� V qd S )Nru )r| r5 �end)�rru rv r # s z/Categorical._reverse_indexer.<locals>.<genexpr>r� N) ra �libalgosZgroupsort_indexerr& rd r� r$ Zcumsum�zipr� )rl ra �counts�_resultru )rD rv �_reverse_indexer s z Categorical._reverse_indexerZ numeric_only�skipna)Z old_arg_nameZ new_arg_name)rJ c K s� t �|�dd�� t �d|� | �d� t| j�s:| jjS | jdk}|� � sp|rh|� � rh| j| � � }qzt j S n | j� � }| �d|�S )ao The minimum value of the object. Only ordered `Categoricals` have a minimum! .. versionchanged:: 1.0.0 Returns an NA value on empty arrays Raises ------ TypeError If the `Categorical` is not `ordered`. Returns ------- min : the minimum of this `Categorical` �axisr ru r� rX N)�nv�validate_minmax_axisr� Z validate_minr r[ re ri �na_valuer� rf r� rk r� �_wrap_reduction_result)rl rJ r� �good�pointerru ru rv r� ) s zCategorical.minc K s� t �|�dd�� t �d|� | �d� t| j�s:| jjS | jdk}|� � sp|rh|� � rh| j| � � }qzt j S n | j� � }| �d|�S )ao The maximum value of the object. Only ordered `Categoricals` have a maximum! .. versionchanged:: 1.0.0 Returns an NA value on empty arrays Raises ------ TypeError If the `Categorical` is not `ordered`. Returns ------- max : the maximum of this `Categorical` rK r ru r� rX N)rL rM r� Z validate_maxr r[ re ri rN r� rf r� rk r� rO )rl rJ r� rP rQ ru ru rv r� N s zCategorical.maxc C sJ | j }|r | j dk}| j | }t�||�}|�� t|| jj�}| �|�S )a8 Returns the mode(s) of the Categorical. Always returns `Categorical` even if only one value. Parameters ---------- dropna : bool, default True Don't consider counts of NaN/NaT. Returns ------- modes : `Categorical` (sorted) rX )re �htable�moder� r" ri ra r� )rl r� rd rP ru ru rv rS s s zCategorical.modec C s t | j�}| �|�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'] )rA rd r� )rl Z unique_codesru ru rv r� � s zCategorical.uniquec C s | j dfS )NrX )r� )rl ru ru rv �_values_for_factorize� s z!Categorical._values_for_factorizec C s |j |j�|�|jd�S )N)ri )r� ra r� ri )r� Zuniques�originalru ru rv �_from_factorized� s z Categorical._from_factorizedr� )rm r� c C s6 t |t�sdS | �|�r2| �|�}t�| j|j�S dS )z� Returns True if categorical arrays are equal. Parameters ---------- other : `Categorical` Returns ------- bool F)r_ rP r` r? rk Z array_equalre )rl rm ru ru rv rb � s zCategorical.equalsr ztype[CategoricalT]zSequence[CategoricalT]rO )r� � to_concatrK r� c C s ddl m} ||�S )Nr )�union_categoricals)Zpandas.core.dtypes.concatrX )r� rW rK rX ru ru rv �_concat_same_type� s z Categorical._concat_same_typec C s t |j|j| jdd�}| �|�S )z� Re-encode another categorical using this Categorical's categories. Notes ----- This assumes we have already checked self._categories_match_up_to_permutation(other). F)rW )rc rd ra r� )rl rm rd ru ru rv r? � s z&Categorical._encode_with_my_categoriesc C s t | j�t |j�kS )z� Returns True if categoricals are the same dtype same categories, and same ordered Parameters ---------- other : Categorical Returns ------- bool )r� ri )rl rm ru ru rv r` � s z/Categorical._categories_match_up_to_permutationc C s6 t dtdd� y | �|�S ttfk r0 dS X d S )NzPCategorical.is_dtype_equal is deprecated and will be removed in a future versionr� )r� F)r r� r` �AttributeErrorr^ )rl rm ru ru rv r* � s zCategorical.is_dtype_equalc C sJ | j dd�}||�� }ddlm} |||gdd�}ddg|_d |j_|S ) z� Describes this Categorical Returns ------- description: `DataFrame` A dataframe with frequency and counts by category. F)r� r )�concatr� )rK rG �freqsra )r �sumZpandas.core.reshape.concatr[ �columnsr� �name)rl rG r\ r[ r� ru ru rv �describe s zCategorical.describec C sf t |�s"t|�j}td|� d���t|dd�}t�t|��}| j� |�}|||dkB }t � | j |�S )a� Check whether `values` are contained in Categorical. Return a boolean NumPy Array showing whether each element in the Categorical matches an element in the passed sequence of `values` exactly. Parameters ---------- values : set or list-like The sequence of values to test. Passing in a single string will raise a ``TypeError``. Instead, turn a single string into a list of one element. Returns ------- isin : numpy.ndarray (bool dtype) Raises ------ TypeError * If `values` is not a set or list-like See Also -------- pandas.Series.isin : Equivalent method on Series. Examples -------- >>> s = pd.Categorical(['lama', 'cow', 'lama', 'beetle', 'lama', ... 'hippo']) >>> s.isin(['cow', 'lama']) array([ True, True, True, False, True, False]) Passing a single string as ``s.isin('lama')`` will raise an error. Use a list of one element instead: >>> s.isin(['lama']) array([ True, False, True, False, True, False]) zIonly list-like objects are allowed to be passed to isin(), you passed a [r/ Nr ) r. rh rx r^ rH rk r� r9 ra rA � algorithmsr� rd )rl r� Z values_typer� Z code_valuesru ru rv r� s ) zCategorical.isin)r� c s: t |d�}|r| n| �� }t|�r6� fdd�|D �}n|� i}x�|�� D ]�\}}||krZqH||jkrHt|�r�t� � td� |j|dd� W dQ R X qH|j� � }|� |�} ||jkr�|� |�} | |j |j | k< t� � td� |j|dd� W dQ R X qH||| < t� � td� |j |dd� W dQ R X qHW |�s6|S dS )aM Replaces all instances of one value with another Parameters ---------- to_replace: object The value to be replaced value: object The value to replace it with inplace: bool Whether the operation is done in-place Returns ------- None if inplace is True, otherwise the new Categorical after replacement Examples -------- >>> s = pd.Categorical([1, 2, 1, 3]) >>> s.replace(1, 3) [3, 2, 3, 3] Categories (2, int64): [2, 3] r� c s i | ] }� |�qS ru ru )r| � replace_value)r� ru rv � <dictcomp>j s z'Categorical.replace.<locals>.<dictcomp>r� T)r� N) r! rW r. �itemsra r9 r r r� r� r� re r� ) rl Z to_replacer� r� r� Z replace_dictrb � new_valuera r� Z value_indexru )r� rv r1 I s8 zCategorical.replace)�convertc C s< ddl m} | j}| j}||�� ��|||�}t|||d�S )Nr )� PandasArray)rr )�pandas.core.arraysrg ra rd r� �_str_mapr@ ) rl �frN ri rf rg ra rd r� ru ru rv ri � s zCategorical._str_map�|c C s ddl m} || �t���|�S )Nr )rg )rh rg r� r� �_str_get_dummies)rl r6 rg ru ru rv rl � s z Categorical._str_get_dummies)NNNFT)T)N)NNN)F)F)F)F)N)F)T)Tr )FTr )N)FN)F)r T)Tr T)T)r )F)rk )nrx � __module__� __qualname__�__doc__Z__array_priority__rE Z _hidden_attrs� frozensetZ_typ�__annotations__r� �propertyri r� � classmethodr� r� r r� r� Zto_listr� r� ra �setterr] rd r� r� r� r� r� r r� r� r� r� r� r� r� r{ ry �eqrY rz rZ �ltrS �gtrT �lerU �gerV r� r� r� r� r� r� r� r9 Zisnullr: Znotnullr r r r r r� r r� r re r rg r@ r r r r! r* r9 r r r= r> rB rI r r� r� rS r� rT rV rb rY r? r` r* r` r� r1 rk r� ri rl � __classcell__ru ru )r� rv rP � s� f f9 CD % X Z= A E 6Q + 6W !% $ $ 5F ra r] rr )ZdelegateZ accessors�typr� r� r� r� r� r� r� r� r� c @ sH e Zd ZdZdd� Zedd� �Zdd� Zdd � Ze d d � �Z d d � Z dS )�CategoricalAccessora Accessor object for categorical properties of the Series values. Be aware that assigning to `categories` is a inplace operation, while all methods return new categorical data per default (but can be called with `inplace=True`). 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 C s. | � |� |j| _|j| _|j| _| �� d S )N)� _validater� �_parentr� �_indexr_ �_nameZ_freeze)rl �dataru ru rv r� ( s z CategoricalAccessor.__init__c C s t | j�std��d S )Nz2Can only use .cat accessor with a 'category' dtype)r' ri rZ )r� ru ru rv r} / s z CategoricalAccessor._validatec C s t | j|�S )N)rj r~ )rl r_ ru ru rv �_delegate_property_get4 s z*CategoricalAccessor._delegate_property_getc C s t | j||�S )N)�setattrr~ )rl r_ � new_valuesru ru rv �_delegate_property_set7 s z*CategoricalAccessor._delegate_property_setc C s ddl m} || jj| jd�S )z> Return Series of codes as well as the index. r )r� )r� )r� r� r~ rd r )rl r� ru ru rv rd : s zCategoricalAccessor.codesc O s@ ddl m} t| j|�}|||�}|d k r<||| j| jd�S d S )Nr )r� )r� r_ )r� r� rj r~ r r� )rl r_ �argsr� r� r� �resru ru rv �_delegate_methodC s z$CategoricalAccessor._delegate_methodN) rx rm rn ro r� � staticmethodr} r� r� rr rd r� ru ru ru rv r| � s } r| rN z np.ndarray)ra r� c C s� t | j|j�}t|j�rPt| �rP|j�� }t|| �} t| |�sdt| �} t|�}n|sdt| �} t|�}t|t�r~t |� | �|�S t | �\}}t |�\}}|t |��}|� |� t |�|�|�S )z� utility routine to turn values into codes given the specified categories If `values` is known to be a Categorical, use recode_for_categories instead. )r* ri r+ r/ Zconstruct_array_typer# r_ r% r6 r" Zget_indexer_forr? r[ Z map_locations�lookup) r� ra Z dtype_equalr� Z hash_klass�vals�_r� �tru ru rv r� O s" r� Tr� )rd rW r� c C sX t |�dkr |r| �� S | S |�|�r6|r2| �� S | S t|�|�|�}t|| dd�}|S )a# Convert a set of codes for to a new set of categories Parameters ---------- codes : np.ndarray old_categories, new_categories : Index copy: bool, default True Whether to copy if the codes are unchanged. Returns ------- new_codes : np.ndarray[np.int64] Examples -------- >>> old_cat = pd.Index(['b', 'a', 'c']) >>> new_cat = pd.Index(['a', 'b']) >>> codes = np.array([0, 1, 1, 2]) >>> recode_for_categories(codes, old_cat, new_cat) array([ 1, 0, 0, -1], dtype=int8) r rX )rr )r[ rW rb r" rA r@ )rd Zold_categoriesr� rW r r� ru ru rv rc w s rc ztuple[np.ndarray, Index])r� c C s� ddl m} t| �s td��t| �rdt| �} tjt| j �| j j d�}t j || j d�}||�}| j }nt | dd�}|j }|j }||fS )az Factorize an input `values` into `categories` and `codes`. Preserves categorical dtype in `categories`. Parameters ---------- values : list-like Returns ------- codes : ndarray categories : Index If `values` has a categorical dtype, then `categories` is a CategoricalIndex keeping the categories and order of `values`. r )r� zInput must be list-like)ri F)r] )r� r� r. r^ r' rG rk r� r[ ra rd ri rP r� )r� r� Z cat_codesr� ra rd ru ru rv �factorize_from_iterable� s r� z$tuple[list[np.ndarray], list[Index]]c C s: t | �dkrg g fS tdd� | D �� \}}t|�t|�fS )a$ A higher-level wrapper over `factorize_from_iterable`. Parameters ---------- iterables : list-like of list-likes Returns ------- codes : list of ndarrays categories : list of Indexes Notes ----- See `factorize_from_iterable` for more info. r c s s | ]}t |�V qd S )N)r� )r| �itru ru rv r � s z+factorize_from_iterables.<locals>.<genexpr>)r[ rF r� )� iterablesrd ra ru ru rv �factorize_from_iterables� s r� )T)�� __future__r �csvr � functoolsr ry �shutilr �typingr r r r r r �warningsr r r �numpyrk Zpandas._configr Z pandas._libsr r rE r rR r Zpandas._libs.arraysr Zpandas._libs.libr Zpandas._typingr r r r r r r Zpandas.compat.numpyr rL Zpandas.util._decoratorsr r Zpandas.util._exceptionsr Zpandas.util._validatorsr! Zpandas.core.dtypes.castr" r# Zpandas.core.dtypes.commonr$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 Zpandas.core.dtypes.dtypesr4 r5 Zpandas.core.dtypes.genericr6 r7 Zpandas.core.dtypes.missingr8 r9 r: Z pandas.corer; Zpandas.core.accessorr< r= Zpandas.core.algorithms�corera r> r? r@ rA Zpandas.core.arrays._mixinsrB Zpandas.core.baserC rD rE Zpandas.core.common�commonr� Zpandas.core.constructionrF r� rG rH Zpandas.core.indexersrI Zpandas.core.ops.commonrJ Zpandas.core.sortingrK Z pandas.core.strings.object_arrayrL r& rM r� rN rO r{ r� rP r| r� rc r� r� ru ru ru rv �<module> s� $ H I3 B )*'
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.05 |
proxy
|
phpinfo
|
Настройка