U
|
¬ý°d= ã
|
@ sH U d dl mZ d dlmZmZ d dlZd dlmZ d dl
|
m Z m Z m Z d dlmZmZ d dlmZmZ d dlmZmZmZ d d lmZmZ d d
|
lm Z d dl m m m Z! d d l m"Z"m#Z# d d l$m%Z%m&Z& d d l'm(Z( e)e!j*Z*de+d< e* ,ddi¡ e&dddddddddg ee&dd d d d d d!d"ged#d$G d%d de%Z-dS )&é )Ú annotations)ÚAnyÚHashableN)Úindex)ÚDtypeÚDtypeObjÚnpt)Úcache_readonlyÚdoc)Úis_categorical_dtypeÚ is_scalar)Úis_valid_na_for_dtypeÚisnaÚnotna)Ú CategoricalÚcontains)Ú extract_array)ÚIndexÚmaybe_extract_name)ÚNDArrayBackedExtensionIndexÚ inherit_names)Ú pprint_thingzdict[str, str]Ú_index_doc_kwargsZ target_klassÚCategoricalIndexZargsortÚtolistÚcodesÚ
|
categoriesÚorderedZ_reverse_indexerZ searchsortedÚminÚmaxZrename_categoriesZreorder_categoriesZadd_categoriesZremove_categoriesZremove_unused_categoriesZset_categoriesZ
|
as_orderedZ as_unorderedT)Úwrapc sZ e Zd ZU dZdZeZedd Ze ddddZ
|
d e d
|
< d e d < d e d< de d< de d< eddddZ dCdddd dddZ ddd d Zd dd d d!Zed"d# Z fd$d%Zd&d'd&d(d)d*Zed'dd+d,Zeejd-dd.d/d0ZdDd1d fd2d3 Zd4dd5d6Zd dd7d8Zd9dd:d;d<Zd=d> Zd?dd d@dAdBZ Z S )Er a]
|
Index based on an underlying :class:`Categorical`.
|
|
CategoricalIndex, like Categorical, can only take on a limited,
|
and usually fixed, number of possible values (`categories`). Also,
|
like Categorical, it might have an order, but numerical operations
|
(additions, divisions, ...) are not possible.
|
|
Parameters
|
----------
|
data : array-like (1-dimensional)
|
The values of the categorical. If `categories` are given, values not in
|
`categories` will be replaced with NaN.
|
categories : index-like, optional
|
The categories for the categorical. Items need to be unique.
|
If the categories are not given here (and also not in `dtype`), they
|
will be inferred from the `data`.
|
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`.
|
copy : bool, default False
|
Make a copy of input ndarray.
|
name : object, optional
|
Name to be stored in the index.
|
|
Attributes
|
----------
|
codes
|
categories
|
ordered
|
|
Methods
|
-------
|
rename_categories
|
reorder_categories
|
add_categories
|
remove_categories
|
remove_unused_categories
|
set_categories
|
as_ordered
|
as_unordered
|
map
|
|
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
|
--------
|
Index : The base pandas Index type.
|
Categorical : A categorical array.
|
CategoricalDtype : Type for categorical data.
|
|
Notes
|
-----
|
See the `user guide
|
<https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#categoricalindex>`__
|
for more.
|
|
Examples
|
--------
|
>>> pd.CategoricalIndex(["a", "b", "c", "a", "b", "c"])
|
CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'],
|
categories=['a', 'b', 'c'], ordered=False, dtype='category')
|
|
``CategoricalIndex`` can also be instantiated from a ``Categorical``:
|
|
>>> c = pd.Categorical(["a", "b", "c", "a", "b", "c"])
|
>>> pd.CategoricalIndex(c)
|
CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'],
|
categories=['a', 'b', 'c'], ordered=False, dtype='category')
|
|
Ordered ``CategoricalIndex`` can have a min and max value.
|
|
>>> ci = pd.CategoricalIndex(
|
... ["a", "b", "c", "a", "b", "c"], ordered=True, categories=["c", "b", "a"]
|
... )
|
>>> ci
|
CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'],
|
categories=['c', 'b', 'a'], ordered=True, dtype='category')
|
>>> ci.min()
|
'c'
|
Zcategoricalindexc C s | j jS ©N)r Ú_can_hold_strings©Úself© r% úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/indexes/category.pyr" ° s z"CategoricalIndex._can_hold_stringsÚbool)Úreturnc C s | j jS r! )r Ú _should_fallback_to_positionalr# r% r% r& r) ´ s z/CategoricalIndex._should_fallback_to_positionalz
|
np.ndarrayr r r z bool | Noner r Ú_dataÚ_valuesztype[libindex.IndexEngine]c C s. t jtjt jtjt jtjt jtj i| j
|
j j S r! ) ÚnpZint8ÚlibindexZ
|
Int8EngineÚint16Z Int16EngineÚint32Z Int32EngineÚint64Z Int64Enginer ÚdtypeÚtyper# r% r% r& Ú _engine_type¾ s üûz CategoricalIndex._engine_typeNFz Dtype | Noner )r1 ÚcopyÚnamer( c C s> t ||| }t|r | |¡ t|||||d}| j||dS )N)r r r1 r4 ©r5 )r r Z_raise_scalar_data_errorr Ú _simple_new)ÚclsÚdatar r r1 r4 r5 r% r% r& Ú__new__Ì s
|
ÿzCategoricalIndex.__new__c C s t |r$t|}| | ¡stdnj|jr4tdnZ|}t|| jd}t|}| |¡ ¡ sdtd|j
|
}||kt |t |@ B ¡ std|S )a\
|
*this is an internal non-public method*
|
|
provide a comparison between the dtype of self and other (coercing if
|
needed)
|
|
Parameters
|
----------
|
other : Index
|
|
Returns
|
-------
|
Categorical
|
|
Raises
|
------
|
TypeError if the dtypes are not compatible
|
z8categories must match existing categories when appendingz8MultiIndex is not dtype-compatible with CategoricalIndex)r1 z7cannot append a non-category item to a CategoricalIndex) r r Z#_categories_match_up_to_permutationÚ TypeErrorZ _is_multir r1 r ÚisinÚallr+ r )r$ ÚotherÚvaluesÚcatr% r% r& Ú_is_dtype_compatã s*
|
ÿ
|
ÿ ÿz!CategoricalIndex._is_dtype_compatÚobject)r> r( c C sR | |¡rdS t|ts dS z| |¡}W n ttfk
|
rD Y dS X | j |¡S )zç
|
Determine if two CategoricalIndex objects contain the same elements.
|
|
Returns
|
-------
|
bool
|
If two CategoricalIndex objects have equal elements True,
|
otherwise False.
|
TF)Úis_Ú
|
isinstancer rA r; Ú
|
ValueErrorr* Úequals)r$ r> r% r% r& rF s
|
|
|
zCategoricalIndex.equalsc C s | j jS r! )r Ú_formatter_funcr# r% r% r& rG - s z CategoricalIndex._formatter_funcc s8 ddd | j ¡ ¡ dfd| jfg}t ¡ }|| S )zG
|
Return a list of tuples of the (attr,formatted_value)
|
r ú[z, ú]r )Újoinr* Z_repr_categoriesr ÚsuperÚ _format_attrs)r$ ÚattrsÚextra©Ú __class__r% r& rL 1 s þû
|
z CategoricalIndex._format_attrsz list[str]Ústr)ÚheaderÚna_repr( c s fdd| j D }|| S )Nc s$ g | ] }t |r t|d dn qS ))ú ú Ú
|
)Z escape_chars)r r ©Ú.0Úx©rS r% r& Ú
|
<listcomp>B s ÿz8CategoricalIndex._format_with_header.<locals>.<listcomp>©r+ )r$ rR rS Úresultr% rZ r& Ú_format_with_headerA s
|
þz$CategoricalIndex._format_with_headerc C s dS )NZ categoricalr% r# r% r% r& Ú inferred_typeJ s z CategoricalIndex.inferred_typer )Úkeyr( c C s$ t || jjr| jS t| || jdS )N)Ú container)r r r1 Zhasnansr Z_engine©r$ r` r% r% r& Ú __contains__N s z CategoricalIndex.__contains__z)tuple[Index, npt.NDArray[np.intp] | None]c s< |dk rt d|dk r t d|dk r0t dt |¡S )a
|
Create index with target's values (move/add/delete values as necessary)
|
|
Returns
|
-------
|
new_index : pd.Index
|
Resulting index
|
indexer : np.ndarray[np.intp] or None
|
Indices of output values in original index
|
|
Nz?argument method is not implemented for CategoricalIndex.reindexz>argument level is not implemented for CategoricalIndex.reindexz>argument limit is not implemented for CategoricalIndex.reindex)ÚNotImplementedErrorrK Úreindex)r$ ÚtargetÚmethodÚlevelÚlimitZ tolerancerO r% r& re V s ÿÿÿzCategoricalIndex.reindexÚintc C s> z| j |¡W S tk
|
r8 t|| jjr2Y dS Y nX d S )Néÿÿÿÿ)r* Z _unbox_scalarÚKeyErrorr r r1 rb r% r% r& Ú_maybe_cast_indexeru s z$CategoricalIndex._maybe_cast_indexerc C sf t |tr|j}t |tr.| j |¡}|j}n*| j |¡}|j| j j
|
dd}| j |¡}t | |¡S )NF)r4 )rD r r* r Z_encode_with_my_categoriesÚ_codesr Z get_indexerZastyper r1 Z_from_backing_datar2 r7 )r$ r? r@ r r% r% r& Ú _maybe_cast_listlike_indexer s
|
|
z-CategoricalIndex._maybe_cast_listlike_indexerr )r1 r( c C s | j |¡S r! )r Ú_is_comparable_dtype)r$ r1 r% r% r& rp s z%CategoricalIndex._is_comparable_dtypec C s | j |¡}t|| jdS )aJ
|
|
Map values using input an input mapping or function.
|
|
Maps the values (their categories, not the codes) of the index to new
|
categories. If the mapping correspondence is one-to-one the result is a
|
:class:`~pandas.CategoricalIndex` which has the same order property as
|
the original, otherwise an :class:`~pandas.Index` is returned.
|
|
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.CategoricalIndex or pandas.Index
|
Mapped index.
|
|
See Also
|
--------
|
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
|
--------
|
>>> idx = pd.CategoricalIndex(['a', 'b', 'c'])
|
>>> idx
|
CategoricalIndex(['a', 'b', 'c'], categories=['a', 'b', 'c'],
|
ordered=False, dtype='category')
|
>>> idx.map(lambda x: x.upper())
|
CategoricalIndex(['A', 'B', 'C'], categories=['A', 'B', 'C'],
|
ordered=False, dtype='category')
|
>>> idx.map({'a': 'first', 'b': 'second', 'c': 'third'})
|
CategoricalIndex(['first', 'second', 'third'], categories=['first',
|
'second', 'third'], ordered=False, dtype='category')
|
|
If the mapping is one-to-one the ordering of the categories is
|
preserved:
|
|
>>> idx = pd.CategoricalIndex(['a', 'b', 'c'], ordered=True)
|
>>> idx
|
CategoricalIndex(['a', 'b', 'c'], categories=['a', 'b', 'c'],
|
ordered=True, dtype='category')
|
>>> idx.map({'a': 3, 'b': 2, 'c': 1})
|
CategoricalIndex([3, 2, 1], categories=[3, 2, 1], ordered=True,
|
dtype='category')
|
|
If the mapping is not one-to-one an :class:`~pandas.Index` is returned:
|
|
>>> idx.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`:
|
|
>>> idx.map({'a': 'first', 'b': 'second'})
|
Index(['first', 'second', nan], dtype='object')
|
r6 )r+ Úmapr r5 )r$ ZmapperZmappedr% r% r& rq s C zCategoricalIndex.mapz list[Index])Ú to_concatr5 r( c sr z t fdd|D ¡}W n> tk
|
rZ ddlm} |dd |D }t||d Y S X t j||dS d S )Nc s g | ]} |¡qS r% )rA )rX Úcr# r% r& r[ Ý s z,CategoricalIndex._concat.<locals>.<listcomp>r )Ú concat_compatc S s g | ]
|
}|j qS r% r\ rW r% r% r& r[ ã s r6 )r Z_concat_same_typer; Zpandas.core.dtypes.concatrt r r2 r7 )r$ rr r5 r@ rt Úresr% r# r& Ú_concatÙ s ÿ zCategoricalIndex._concat)NNNNFN)NNNN) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Z_typr Z _data_clsÚpropertyr" r r) Ú__annotations__r3 r: rA rF rG rL r^ r_ r
|
r rc re rm ro rp rq rv Ú __classcell__r% r% rO r& r 4 sR
|
\
|
ù0
|
ÿ
|
F).Ú
|
__future__r Útypingr r Únumpyr, Z pandas._libsr r- Zpandas._typingr r r Zpandas.util._decoratorsr r
|
Zpandas.core.dtypes.commonr r Zpandas.core.dtypes.missingr r r Z pandas.core.arrays.categoricalr r Zpandas.core.constructionr Zpandas.core.indexes.baseÚcoreZindexesÚbaseZibaser r Z pandas.core.indexes.extensionr r Zpandas.io.formats.printingr Údictr r| Úupdater r% r% r% r& Ú<module> sV ÷ ôø
|
ô
|
