Файловый менеджер - Редактировать - /home/digitalm/venv/lib/python3.7/site-packages/pandas/core/indexes/__pycache__/base.cpython-37.pyc
Назад
B �5�g6 � @ sb U d dl mZ d dlmZ d dlZd dlmZ d dlZd dlmZm Z m Z m Z m Z m Z mZmZ d dlZd dlZd dlmZmZmZ d dlm mZ d dl m Z m Z d dl m!Z!m"Z"m#Z#m$Z$m%Z% d d l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. d d l/m0Z1 d d l2m3Z3m4Z4 d d l5m6Z6m7Z7m8Z8m9Z9 d d l:m;Z;m<Z<m=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZU d dlVmWZW d dlXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ d dl_m`Z`maZambZbmcZcmdZd d dlemfZf d dlgmhZhmiZimjZj d dlkmlZlmmZm d dlnmoZo d dlpmq mrZ d dlsmtZtmuZu d dlvmwZwmxZx d dlymzZzm{Z{ d dl|m}Z} d dl~mZm�Z� d dl�mq m�Z� d dl�m�Z�m�Z�m�Z� d d l�m�Z� d d l�m�Z� d d l�m�Z� d d l�m�Z� d d l�m�Z�m�Z�m�Z� d d!l�m�Z� d d"l�m�Z�m�Z�m�Z�m�Z�m�Z� e�r:d d#lm�Z� d d$l�m�Z�m�Z�m�Z�m�Z�m�Z�m�Z� d%gZ�e�d&�Z�d%d'd%d'd%d(d)�Z�d*e�d+< i Z�d*e�d,< e�Z�e��d-�Z�d.d.d/�d0d1�Z�d2d3d4�d5d6�Z�d7d8� Z�e d9d%d:�Z�G d;d%� d%ee��Z�ddd<d=�Z�ded?d@d%dA�dBdC�Z�dDdE� Z�dFdFdG�dHdI�Z�dJd3dK�dLdM�Z�dNdOdP�dQdR�Z�dSdT�dUdV�Z�d(dWdX�dYdZ�Z�d%d[d\�d]d^�Z�d9d9d_�d`da�Z�dbdc� Z�dS )f� )� annotations)�datetimeN)� zip_longest)� TYPE_CHECKING�Any�Callable�Hashable�Sequence�TypeVar�cast�overload)�algos�index�lib)�is_datetime_array� no_default)�IncompatibleFrequency�NaTType�OutOfBoundsDatetime� Timestamp� tz_compare)� AnyArrayLike� ArrayLike�Dtype�DtypeObj�F�Shape�T�final)�function)�DuplicateLabelError�InvalidIndexError)�Appender�cache_readonly� deprecate_nonkeyword_arguments�doc)�can_hold_element�find_common_type�infer_dtype_from�validate_numeric_casting)� ensure_int64� ensure_object�ensure_platform_int� is_bool_dtype�is_categorical_dtype�is_dtype_equal�is_ea_or_datetimelike_dtype�is_extension_array_dtype�is_float�is_float_dtype� is_hashable� is_integer�is_interval_dtype� is_iterator� is_list_like�is_object_dtype� is_scalar�is_signed_integer_dtype�is_unsigned_integer_dtype�needs_i8_conversion� pandas_dtype�validate_all_hashable)� concat_compat)�CategoricalDtype�DatetimeTZDtype�ExtensionDtype� IntervalDtype� PandasDtype� PeriodDtype)�ABCDatetimeIndex� ABCMultiIndex�ABCPeriodIndex� ABCSeries�ABCTimedeltaIndex)� is_dict_like)�array_equivalent�is_valid_na_for_dtype�isna)�missing�ops)�CachedAccessor)�setitem_datetimelike_compat�validate_putmask)� Categorical�ExtensionArray)� tz_to_dtype�validate_tz_from_dtype)� SparseDtype)� IndexOpsMixin� PandasObject)� ensure_wrapped_if_datetimelike� extract_array�sanitize_array)�deprecate_ndim_indexing)� FrozenList)�get_op_result_name)�make_invalid_op)�ensure_key_mapped�get_group_index_sorter�nargsort)� StringMethods)� PrettyDict�default_pprint�format_object_attrs�format_object_summary� pprint_thing)�Literal)�CategoricalIndex� DataFrame� IntervalIndex� MultiIndex� RangeIndex�Series�Index)�mixedz mixed-integer� z np.ndarray)�klass�inplaceZ target_klassZraises_section�unique� duplicatedzdict[str, str]�_index_doc_kwargs�_index_shared_docs�objectr )�meth�returnc s, t �� �d dddd�� fdd� �}tt|�S ) zG Decorator to simplify 'return_indexers' checks in Index.join. �leftNF�str_t�bool)�how�return_indexers�sortc sJ � | ||||d�\}}}|s |S |d k r0t |�}|d k r@t |�}|||fS )N)r� �levelr� )r, ) �self�otherr� r� r� r� � join_index�lidx�ridx)r} � �N/home/digitalm-up/venv/lib/python3.7/site-packages/pandas/core/indexes/base.py�join� s z$_maybe_return_indexers.<locals>.join)r NFF)� functools�wrapsr r )r} r� r� )r} r� �_maybe_return_indexers� s r� zdict[str, Any]�None)�kwargsr~ c C s | rt dtt| ��� ���d S )Nz Unexpected keyword arguments )� TypeError�repr�set)r� r� r� r� �disallow_kwargs� s r� c C sX t | t�r"ddlm} || f|�S t | t�rJd|krJd|krJ|�d�|d< | j| f|�S )zv This is called upon unpickling, rather than the default which doesn't have arguments and breaks __new__. r )�_new_PeriodIndex�labels�codes)� issubclassrI Zpandas.core.indexes.periodr� rH �pop�__new__)�cls�dr� r� r� r� � _new_Index� s r� �_IndexT)�boundc s� e Zd ZU dZejejB eddg�B Zded< dZ e dddd �d d ��Z e ddd d �d d��Z e ddd d �dd��Z e ddd d �dd��ZdZded< ded< dZded< dZded < d Zd ed < d gZd!ed"< d gZd!ed#< d Zd ed$< d%Zd ed&< d%Zd ed'< ejZd(ed)< d ZdhZ e de �Z �dBd d*�d+d,�Z e!d d-�d.d/��Z"e e!d0d1�d2d3���Z#e$d4d5� �Z%e!�dCd6ddd7�d8d9��Z&e'dd6d:�d;d<��Z(e d=d*�d>d?��Z)e d@d*�dAdB��Z*e dCd*�dDdE��Z+e,fddddF�dGdH�Z-ddd:�dIdJ�Z.e ddddF�dKdL��Z/e d d*�dMdN��Z0e d=d*�dOdP��Z1e d=d*�dQdR��Z2e'dSd*�dTdU��Z3e e'dVd*�dWdX���Z4dYd*�dZd[�Z5�dDdd*�d\d]�Z6�dEd^d_�Z7e'd0d*�d`da��Z8e �dFdcdd��Z9�dGdedf�Z:�dHdgdh�Z;die<dj< e=e<dj e> ��dIdYd dl�dmdn��Z?e d d do�dpdq��Z@dre<ds< e=e<ds e> ��dJdtdu��ZA�dKddvd dwdxddy�dzd{�ZBe ddd:�d|d}��ZCe �dLddd:�d~d��ZDe d�d*�d�d���ZEd�d*�d�d��ZFe$d�d�� �ZG�dMd�d*�d�d��ZHd�d*�d�d��ZIe dd*�d�d���ZJ�dNd d�d�d�d��d�d��ZK�dOd�d�d�d��d�d��ZLe �dPdd*�d�d���ZM�dQd�d��ZN�dRd�d*�d�d��ZOd�d�� ZP�dSdd�d��d�d��ZQ�dTd dd@d��d�d��ZRe$d�d�� �ZSeSjTdd��d�d���ZSe �dUd d�d��d�d���ZUd�d*�d�d��ZV�dVd=d*�d�d��ZWe$eWeVd��ZXeYdd�d�gd���dWd d��d�d���ZZ�dXd�d��Z[e$dYd*�d�d���Z\ddd:�d�d��Z]e d=d*�d�d�Z^dYd*�d�dĄZ_�dYd�dƄZ`d d*�d�dȄZaeaZbe �dZd�dʄ�Zce d�d̜d�d΄�Zd�d[d�dЄZee e$d d*�d�d҄��Zfe$d d*�d�dԄ�Zge$d d*�d�dք�Zhe e$d d*�d�d��Zie e$d d*�d�dڄ��Zje'd d*�d�d܄�Zke e$d d*�d�dބ��Zle d d*�d�d��Zme d d*�d�d��Zne d d*�d�d��Zoe d d*�d�d��Zpe d d*�d�d��Zqe d d*�d�d��Zre d d*�d�d��Zse d d*�d�d��Zte d d*�d�d��Zue'd�d*�d�d��Zve'd d*�d�d��Zwe'e d d*�d�d����Zxe'd d*�d�d���Zyd�d�� Zze{j|Z}d�ed�< e'dd*�d�d���Z~e'd d*�d��d ��Ze dd*��d�d��Z�e�Z�e dd*��d�d��Z�e�Z��d\�d�d�Z��d]dd�d�d��d �d �Z��d^ddvd�d �� f�d �d � Z�eYdd�gd���d_d�dd�d�� f�d�d� �Z��d`�dd�d��d�d�Z�ddd:��d�d�Z��d�d� Z�e �d�d � �Z�e �d �d � �Z�e �d �d � �Z�e �d!�d"� �Z�e�Z��d#�d$� Z�e �d%�d&� �Z�e �da�d'�d(��Z�d �d)��d*�d+�Z�e d d �d,��d-�d.��Z�e �db�d/�d0��Z��dcd �d)��d1�d2�Z��d3�d4� Z�d �d5�d,��d6�d7�Z�e �dd�d8�d9��Z��d:�d;� Z��de�d<�d=�Z�e d d*��d>�d?��Z��d@d*��dA�dB�Z��df�dC�dD�Z��dEe<�dF< e=e<�dF e> �e �dg�dG�dHd�dI��dJ�dK���Z��dhd �dG�dHd�dL��dM�dN�Z�e �di�dG�dHd=�dI��dO�dP��Z��dQd�dR��dS�dT�Z�e �djd d��dHd�dL��dU�dV��Z�e �dkd d��dHd�dL��dW�dX��Z�e d �dHd�dY��dZ�d[��Z�e �d\dd�d]��d^�d_��Z��d`�d`�da��db�dc�Z�e �ddd=�da��de�df��Z��ddd��dg��dh�di�Z�e d��dj�dk��dl�dm��Z�e dd=�dn��do�dp��Z��dl�dqd*��dr�ds�Z�d �dt�dR��du�dv�Z�e��dmd�d d �dx��dy�dz��Z�e d d��d{��d|�d}��Z�e �dnd d��d~�d��d��d���Z�e �dod d�d �d��d���d��d���Z�e �dpd d��d{��d��d���Z�d�d5dd�d���d��d��Z�e$�d5d*��d��d���Z�e'e�ej���d�d*��d��d����Z�e$dd*��d��d���Z�dd*��d��d��Z�dd*��d��d��Z�d�d5�d���d��d��Z�e�ej���dqd dYd���d��d���Z�e �drd d*��d��d���Z�e e!�d��d�� ��Z�e e!�d��d�� ��Z��d��d�� Z�e �d��d�� �Z�e$d d*��d��d���Z�d d*��d��d��Z�d�d �d���d��d��ZŐd�d �da��d��d��Z�d=e�d�< e �d��d�� �Zǐd��d�� Z�d�ddd�d���d��d��Z�e d d*��d��d���Zʐd�d �d,��d��d��Zːd�dd �d���d��d��Z�d d*��d��d��Z͐d�d �d,��ddÄZ�e d d*��dĐdń�Z�e �dƐdDŽ �Z�d dd�dȜ�dɐdʄZ�e �dsd d d�d��d̜�d͐d΄�Z�e �dϐdЄ �ZӐdt�dѐd҄Z�dd*��dӐdԄZ�e d��d՜�ddׄ�Zdؐdل Z�d d*��dڐdۄZ�d��d՜�dܐd݄Z�e �dސd߄ �Zڐd�e<�d�< e=e<�d� e> ��d�d*��d�d��Z�e dd*��d�d��Z�eݐdud �d�d�d��d�d��Z�e�d �d�d�d��d�d��Z�eݐdvd d �d�d��d�d��Z�e �dwd d �d�d��d�d��Z�e$d d*��d�d��Zߐd�Z�e d �d�d,��d��d���Z�e d0d*��d��d���Z�e d d �d,��d��d���Z�d0d �d���d��d��Z�e �d�d*��d��d ��Z�dx�d�d�Z�e �dyd d*��d�d��Z�dzdd*��d�d�Z�d��d��d�d �Z�d{dvdv�dH�dG�dd�d ��d �d �Z�d �d� Z�d d*��d�d�Z�e d�d��d��d�d��Z�e,fd��d��d�d�Z�d|d��d��d�d�Z�d}d�dY�d��d�d�Z�d~�d �d �Z�ddd:��d �d �Z�dYd �d ��d!�d"�Z�dd�d �d$��d%�d&�Z�d'�d(� Z��d)�d*� Z�e �d+�d,� �Z��d-�d.� Z��d/�d0� Z��d1�d2� Z��d3�d4� Z��d5�d6� Z��d7�d8� Z�e d��d9��d:�d;��Z�e e$�d<d*��d=�d>���Z�e d�d�d=�d?��d@�dA���Z � �ZS (� rs a� Immutable sequence used for indexing and alignment. The basic object storing axis labels for all pandas objects. Parameters ---------- data : array-like (1-dimensional) dtype : NumPy dtype (default: object) If dtype is None, we find the dtype that best fits the data. If an actual dtype is provided, we coerce to that dtype if it's safe. Otherwise, an error will be raised. copy : bool Make a copy of input ndarray. name : object Name to be stored in the index. tupleize_cols : bool (default: True) When True, attempt to create a MultiIndex if possible. See Also -------- RangeIndex : Index implementing a monotonic integer range. CategoricalIndex : Index of :class:`Categorical` s. MultiIndex : A multi-level, or hierarchical Index. IntervalIndex : An Index of :class:`Interval` s. DatetimeIndex : Index of datetime64 data. TimedeltaIndex : Index of timedelta64 data. PeriodIndex : Index of Period data. Int64Index : A special case of :class:`Index` with purely integer labels. UInt64Index : A special case of :class:`Index` with purely unsigned integer labels. Float64Index : A special case of :class:`Index` with purely float labels. Notes ----- An Index instance can **only** contain hashable objects Examples -------- >>> pd.Index([1, 2, 3]) Int64Index([1, 2, 3], dtype='int64') >>> pd.Index(list('abc')) Index(['a', 'b', 'c'], dtype='object') �contains� set_valuezfrozenset[str]� _hidden_attrs� r� z np.ndarray)r� r� r~ c C s | � � }|� � }t�||�S )N)�_get_join_target�libjoinZleft_join_indexer_unique)r� r� �sv�ovr� r� r� �_left_indexer_unique4 s zIndex._left_indexer_uniquez(tuple[ArrayLike, np.ndarray, np.ndarray]c C s6 | � � }|� � }t�||�\}}}| �|�}|||fS )N)r� r� Zleft_join_indexer�_from_join_target)r� r� r� r� �joined_ndarrayr� r� �joinedr� r� r� � _left_indexer< s zIndex._left_indexerc C s6 | � � }|� � }t�||�\}}}| �|�}|||fS )N)r� r� Zinner_join_indexerr� )r� r� r� r� r� r� r� r� r� r� r� �_inner_indexerG s zIndex._inner_indexerc C s6 | � � }|� � }t�||�\}}}| �|�}|||fS )N)r� r� Zouter_join_indexerr� )r� r� r� r� r� r� r� r� r� r� r� �_outer_indexerR s zIndex._outer_indexerr �str�_typzExtensionArray | np.ndarray�_dataNz object | None�_idr �_nameFr� �_no_setting_name�namez list[str]� _comparables� _attributes�_is_numeric_dtypeT� _can_hold_na�_can_hold_stringsztype[libindex.IndexEngine]� _engine_type)r~ c K s\ |rt jdtdd� ddlm} ddlm} t||| �}|d k rHt|�}d|krl|� d�} t || � t | �}t ||�r~|� � }t |t�r�|j}t|dd �} t |t|f�r�||||d �} |d k r�| j|d d �S | S t|��rB| �|�} | tk �r| |f|||d �|��S |�� } | j|||d �}tj|td�}t|� tj ||d�S t| ��r�| �| �} | tk �r�| |f||d�|��} |d k �r�| j|d d �S | S tj |t|d �}t|� tj ||d�S t |tj tt f��r�t |t ��r�|j!}|d k �r�t"|d ||d �}|j#}|j#j$dk�r|}nJt%j&|t�#d�d�}|d k�r\t'|�}|j#}|�r\| ||f||d�|��S | �|j#�} | �(|||�}t|� | � ||�S t)|��r�| �*|��n�t+|d��r�tt�|�f|||d �|��S |�r,t,|��r,t-|��r�t.|�}|�r,t/dd� |D ���r,ddl0m1} |j2||�p&|�3d�d�S t%j&|t�#d�d�}t|f|||d �|��S d S )Nz�Passing keywords other than 'data', 'dtype', 'copy', 'name', 'tupleize_cols' is deprecated and will raise TypeError in a future version. Use the specific Index subclass directly instead� )� stacklevelr )� PandasArray)rq �tz�dtype)�start�copyr� F)r� )r� r� r� )r� r� )r� )r� )r� r� )�i�u�fr| � __array__c s s | ]}t |t�V qd S )N)� isinstance�tuple)�.0�er� r� r� � <genexpr>� s z Index.__new__.<locals>.<genexpr>)rp �names)r� )4�warnings�warn� FutureWarning�pandas.core.arraysr� �pandas.core.indexes.rangerq �maybe_extract_namer> r� rX rW r� Zto_numpyrE Z numpy_dtype�getattr�range�astyper0 �_dtype_to_subclassrs �construct_array_type�_from_sequence�np�asarrayr| r� � _simple_new�array�ndarrayrJ rH �_valuesr^ r� �kind�comZasarray_tuplesafe� _maybe_cast_data_without_dtype� _ensure_arrayr: �_scalar_data_error�hasattrr8 r7 �list�all�pandas.core.indexes.multirp � from_tuples�get)r� �datar� r� r� � tupleize_colsr� r� rq r� Z data_dtype�resultrv Zea_cls�arrrp �subarrr� r� r� r� w s� z Index.__new__)r� c C s" |j dkrtd��|r |�� }|S )zF Ensure we have a valid array to pass to _simple_new. r� z Index data must be 1-dimensional)�ndim� ValueErrorr� )r� r� r� r� r� r� r� r� � s zIndex._ensure_arrayr )r� c C s@ t |t�r�t |t�r$ddlm} |S t |t�r>ddlm} |S t |t�rXddlm} |S t |t �rrddlm } |S t |t �r�| � |j �S tS |jdkr�ddlm} |S |jdkr�ddlm} |S t|�r�dd lm} |S t|�� r�dd lm} |S t|��r dd lm} | S |tk�rtS t|jttt j f��r4tS t |��d S ) Nr )� DatetimeIndex)rm )ro )� PeriodIndex�M�m)�TimedeltaIndex)� Float64Index)� UInt64Index)� Int64Index) r� rC rB �pandasr� rA rm rD ro rF r� rY r� �subtypers r� r� r3 r� r< r� r; r� r| r� �typer� r� r� �bool_�NotImplementedError) r� r� r� rm ro r� r� r� r� r� r� r� r� r� � sH zIndex._dtype_to_subclassc C s t jdtdd� dS )z� Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. z@Index.asi8 is deprecated and will be removed in a future versionr� )r� N)r� r� r� )r� r� r� r� �asi8L s z Index.asi8z type[_IndexT])r� r� r~ c C sF t |tj�stt|���t�| �}||_||_||_ i |_ |� � |S )z� We require that we have a dtype compat for the values. If we are passed a non-dtype compat, then coerce using the constructor. Must be careful not to recurse. ) r� r� r� �AssertionErrorr� r| r� r� Z _index_datar� �_cache�_reset_identity)r� �valuesr� r� r� r� r� r� ] s zIndex._simple_new)r� r~ c C s t | �S )N)r� )r� r� r� r� � _constructort s zIndex._constructorr� c C s, | j s(d}| �� }|d|� �7 }t|��dS )a: Check that an Index has no duplicates. This is typically only called via `NDFrame.flags.allows_duplicate_labels.setter` when it's set to True (duplicates aren't allowed). Raises ------ DuplicateLabelError When the index is not unique. zIndex has duplicates.� N)� is_unique�_format_duplicate_messager )r� �msg� duplicatesr� r� r� �_maybe_check_uniquex s zIndex._maybe_check_uniquern c C sn ddl m} | | jdd� �� }t|�s,t�|t�t| ����| �� t �| }| j dkrb|� d�}|j dd�S ) a� Construct the DataFrame for a DuplicateLabelError. This returns a DataFrame indicating the labels and positions of duplicates in an index. This should only be called when it's already known that duplicates are present. Examples -------- >>> idx = pd.Index(['a', 'b', 'a']) >>> idx._format_duplicate_message() positions label a [0, 2] r )rr �first)�keepr� �labelZ positions)r� )r� rr ry rx �lenr r� �arange�groupbyZaggr� �nlevelsZ rename_axis�to_frame)r� rr r �outr� r� r� r � s " z Index._format_duplicate_messagezdict[str_t, Any]c s � fdd�� j D �S )z9 Return an attributes dict for my class. c s i | ]}t � |d �|�qS )N)r� )r� �k)r� r� r� � <dictcomp>� s z.Index._get_attributes_dict.<locals>.<dictcomp>)r� )r� r� )r� r� �_get_attributes_dict� s zIndex._get_attributes_dict)r� r� r~ c C s |t kr| jn|}| j||d�S )az Create a new Index with the same class as the caller, don't copy the data, use the same object attributes with passed in attributes taking precedence. *this is an internal non-public method* Parameters ---------- values : the values to create the new Index, optional name : Label, defaults to self.name )r� )r r� r� )r� r r� r� r� r� � _shallow_copy� s zIndex._shallow_copyc C s | j | j| jd�}| j|_|S )zR fastpath to make a shallow copy, i.e. new object with same data. )r� )r� r� r� r )r� r� r� r� r� �_view� s z Index._viewc C s | � � }||_|S )zG fastpath for rename if new name is already validated. )r r� )r� r� r� r� r� r� �_rename� s z Index._renamec C sB | |kr dS t |d�sdS | jdks.|jdkr2dS | j|jkS dS )a More flexible, faster check like ``is`` but that works through views. Note: this is *not* the same as ``Index.identical()``, which checks that metadata is also the same. Parameters ---------- other : object Other object to compare against. Returns ------- bool True if both have same underlying data, False otherwise. See Also -------- Index.identical : Works like ``Index.is_`` but also checks metadata. Tr� FN)r� r� )r� r� r� r� r� �is_� s z Index.is_c C s t � | _dS )zJ Initializes or resets ``_id`` attribute with new object. N)r| r� )r� r� r� r� r � s zIndex._reset_identityc C s | j �� d S )N)�_engineZ clear_mapping)r� r� r� r� �_cleanup� s zIndex._cleanupzlibindex.IndexEnginec s | � � � | �� fdd�t| ��S )Nc s � S )Nr� r� )� target_valuesr� r� �<lambda> � z Index._engine.<locals>.<lambda>)�_get_engine_targetr� r )r� r� )r r� r � s z Index._enginez set[str_t]c C s dd� | j dd�dd� D �S )z� Add the string-like labels to the owner dataframe/series dir output. If this is a MultiIndex, it's first level values are used. c S s" h | ]}t |t�r|�� r|�qS r� )r� r� � isidentifier)r� �cr� r� r� � <setcomp> s z1Index._dir_additions_for_owner.<locals>.<setcomp>r )r� N�d )rx )r� r� r� r� �_dir_additions_for_owner s z Index._dir_additions_for_owner�intc C s t | j�S )z1 Return the length of the Index. )r r� )r� r� r� r� �__len__ s z Index.__len__c C s t j| j|d�S )z8 The array interface, return my values. )r� )r� r� r� )r� r� r� r� r� r� s zIndex.__array__c C sN t �|�}t|�s*t �|�s*t�|�dkr.|S | �� }|�dd� t|f|�S )z@ Gets called after a ufunc and other functions. r� �freqN) r �item_from_zerodimr- r: r� r� r r� rs )r� r� �context�attrsr� r� r� �__array_wrap__& s zIndex.__array_wrap__c C s | j jS )zA Return the dtype object of the underlying data. )r� r� )r� r� r� r� r� 2 s z Index.dtype�Cc C s$ t jdtdd� | �� }|j|d�S )a Return an ndarray of the flattened values of the underlying data. Returns ------- numpy.ndarray Flattened array. See Also -------- numpy.ndarray.ravel : Return a flattened array. zaIndex.ravel returning ndarray is deprecated; in a future version this will return a view on self.r� )r� )�order)r� r� r� r! �ravel)r� r/ r r� r� r� r0 9 s z Index.ravelc C s� |d k r�t |d�s�|}t|t�r(t|�}t|tjtf�r�t|�r�|jdkr^|dkr^| j � |�S | j � d�}| � |�}|j }|| j � d�|d�}|j || jd�S | j � |�}n| �� }t|t�r�| j|_|S )Nr� r� zm8[ns]�i8)r� )r� )r� r� r� r> r� r� rC r= r� r� �viewr� Z _data_clsr� r� r rs r� )r� r� r� r� Zidx_clsZarr_clsr� r� r� r� r2 P s$ z Index.viewc C s� |dk rt |�}t| j|�r,|r(| �� S | S t|t�r`|�� }|j| |dd�}t|||| j d�S y| j j ||d�}W nB t t fk r� } z t dt| �j� d|� ��|�W dd}~X Y nX t|| j |d�S ) a[ Create an Index with values cast to dtypes. The class of a new Index is determined by dtype. When conversion is impossible, a TypeError exception is raised. Parameters ---------- dtype : numpy dtype or pandas type Note that any signed integer `dtype` is treated as ``'int64'``, and any unsigned integer `dtype` is treated as ``'uint64'``, regardless of the size. copy : bool, default True By default, astype always returns a newly allocated object. If copy is set to False and internal requirements on dtype are satisfied, the original data is used to create a new Index or the original Index is returned. Returns ------- Index Index with values cast to specified dtype. NF)r� r� )r� r� r� )r� z Cannot cast z to dtype )r� r� )r> r/ r� r� r� rC r� r� rs r� r� r� r� r� r� �__name__)r� r� r� r� � new_valuesZcasted�errr� r� r� r� m s z Index.astypeas Return a new %(klass)s of the values selected by the indices. For internal compatibility with numpy arrays. Parameters ---------- indices : array-like Indices to be taken. axis : int, optional The axis over which to select values, always 0. allow_fill : bool, default True fill_value : scalar, default None If allow_fill=True and fill_value is not None, indices specified by -1 are regarded as NA. If Index doesn't hold NA, raise ValueError. Returns ------- Index An index formed of elements at the given indices. Will be the same type as self, except for RangeIndex. See Also -------- numpy.ndarray.take: Return an array formed from the elements of a at the given indices. �taker )�axis� allow_fillc K sP |rt �d|� t|�}| �|||�}tj| j||| jd�}t| �j || j d�S )Nr� )r8 � fill_value)r� ) �nvZ validate_taker, �_maybe_disallow_fillr r6 r� � _na_valuer� r� r� )r� �indicesr7 r8 r9 r� Ztakenr� r� r� r6 � s z Index.take)r8 r~ c C sL |rD|dk rD| j r(|dk �� rBtd��qHt| �j}td|� d���nd}|S )zm We only use pandas-style take when allow_fill is True _and_ fill_value is not None. N���zJWhen allow_fill=True and fill_value is not None, all indices must be >= -1z Unable to fill values because z cannot contain NAF)r� �anyr� r� r3 )r� r8 r9 r= �cls_namer� r� r� r; � s zIndex._maybe_disallow_filla� Repeat elements of a %(klass)s. Returns a new %(klass)s where each element of the current %(klass)s is repeated consecutively a given number of times. Parameters ---------- repeats : int or array of ints The number of repetitions for each element. This should be a non-negative integer. Repeating 0 times will return an empty %(klass)s. axis : None Must be ``None``. Has no effect but is accepted for compatibility with numpy. Returns ------- repeated_index : %(klass)s Newly created %(klass)s with repeated elements. See Also -------- Series.repeat : Equivalent function for Series. numpy.repeat : Similar method for :class:`numpy.ndarray`. Examples -------- >>> idx = pd.Index(['a', 'b', 'c']) >>> idx Index(['a', 'b', 'c'], dtype='object') >>> idx.repeat(2) Index(['a', 'a', 'b', 'b', 'c', 'c'], dtype='object') >>> idx.repeat([1, 2, 3]) Index(['a', 'b', 'b', 'c', 'c', 'c'], dtype='object') �repeatc C s8 t |�}t�dd|i� | j�|�}t| �j|| jd�S )Nr� r7 )r� )r, r: Zvalidate_repeatr� rA r� r� r� )r� Zrepeatsr7 � res_valuesr� r� r� rA s z Index.repeatzHashable | Nonez Dtype | NonezSequence[Hashable] | None)r� r� �deepr� r� r~ c C sd | j |||d�d }|r6| j�� }t| �j||d�}n | j|d�}|r`tjdtdd� |� |�}|S )a; Make a copy of this object. Name and dtype sets those attributes on the new object. Parameters ---------- name : Label, optional Set name for new object. deep : bool, default False dtype : numpy dtype or pandas type, optional Set dtype for new object. .. deprecated:: 1.2.0 use ``astype`` method instead. names : list-like, optional Kept for compatibility with MultiIndex. Should not be used. Returns ------- Index Index refer to new object which is a copy of this object. Notes ----- In most cases, there should be no functional difference from using ``deep``, but if ``deep`` is passed it will attempt to deepcopy. )r� r� rC r )r� zeparameter dtype is deprecated and will be removed in a future version. Use the astype method instead.r� )r� ) �_validate_namesr� r� r� r� r r� r� r� r� )r� r� rC r� r� Znew_data� new_indexr� r� r� r� s # z Index.copyc K s | j f |�S )N)r� )r� r� r� r� r� �__copy__C s zIndex.__copy__c C s | j dd�S )zq Parameters ---------- memo, default None Standard signature. Unused T)rC )r� )r� �memor� r� r� � __deepcopy__G s zIndex.__deepcopy__r� c C s` t | �j}| �� }| �� }| �� }dd� |D �}d|� ��|�}|dkrLd}|� d|� |� d�S )zA Return a string representation for this object. c S s g | ]\}}|� d |� ��qS )�=r� )r� r �vr� r� r� � <listcomp>] s z"Index.__repr__.<locals>.<listcomp>�,Nru �(�))r� r3 � _format_data� _format_attrs� _format_spacer� )r� � klass_namer� r, �spaceZ attrs_strZpreprr� r� r� �__repr__T s zIndex.__repr__c C s dS )N� r� )r� r� r� r� rQ f s zIndex._format_spacec C s t S )z0 Return the formatter function. )rh )r� r� r� r� �_formatter_funcp s zIndex._formatter_funcc C sL d}| j dkrd}n"| j dkr6td| �} t| j�r6d}t| | j||| jd�S )z@ Return the formatted data as a unicode string. T�stringF� categoricalrm )� is_justifyr� Zline_break_each_value)� inferred_typer r9 � categoriesrj rV � _is_multi)r� r� rY r� r� r� rO w s zIndex._format_dataz list[tuple[str_t, str_t | int]]c C s t | | j d�S )zH Return a list of tuples of the (attr,formatted_value). )Z include_dtype)ri r\ )r� r� r� r� rP � s zIndex._format_attrsc C s8 t | jtj�r(| jjdkr(ttj| j�S | jtdd�j S )Nr� F)r� ) r� r� r� r� r r� r r� r| r� )r� r� r� r� � _mpl_repr� s zIndex._mpl_repr�NaNzCallable | Nonez list[str_t])r� � formatter�na_repr~ c C sR g }|r*|� | jdk r$t| jdd�nd� |dk rD|t| �|�� S | j||d�S )z> Render a string representation of the Index. N)� � r )� escape_charsru )r` )�appendr� rk r� �map�_format_with_header)r� r� r_ r` �headerr� r� r� �format� s z Index.format)rg r` r~ c C s� ddl m} | j}t|j�rpttj|�}tj |dd�}dd� |D �}t |�}|� � r�t� |�}|||< |� � }nt||d dd��}|| S ) Nr )� format_arrayT)�safec S s g | ]}t |d d��qS ))ra rb r )rc )rk )r� �xr� r� r� rK � s z-Index._format_with_header.<locals>.<listcomp>r )�justify)Zpandas.io.formats.formatri r� r9 r� r r� r� r �maybe_convert_objectsrO r? r� �tolist� trim_front)r� rg r` ri r r� �maskZ result_arrr� r� r� rf � s zIndex._format_with_headerc K s0 t jdtdd� | }|dk r$|| }|jf |�S )a( Format specified values of `self` and return them. .. deprecated:: 1.2.0 Parameters ---------- slicer : int, array-like An indexer into `self` that specifies which values are used in the formatting process. kwargs : dict Options for specifying how the values should be formatted. These options include the following: 1) na_rep : str The value that serves as a placeholder for NULL values 2) quoting : bool or None Whether or not there are quoted values in `self` 3) date_format : str The format used to represent date-like values. Returns ------- numpy.ndarray Formatted values. znThe 'to_native_types' method is deprecated and will be removed in a future version. Use 'astype(str)' instead.r� )r� N)r� r� r� �_format_native_types)r� Zslicerr� r r� r� r� �to_native_types� s zIndex.to_native_typesru c K sB t | �}| �� s&|s&t�| ��t�}ntj| tdd�}|||< |S )z> Actually format specific types of the index. T)r� r� )rO � is_objectr� r� r� r� r� r| )r� r` �quotingr� rp r r� r� r� rq � s zIndex._format_native_typesc C s� t | �dkrf| d }t|d�r0t|t�s0|�� }| d }t|d�rTt|t�sT|�� }d|� d|� �}nd}|dkr|t| �j}|� dt | �� d |� �S ) a Return a summarized representation. Parameters ---------- name : str name to use in the summary representation Returns ------- String with a summarized representation of the index r rh r> z, z to ru Nz: z entries)r r� r� r� rh r� r3 )r� r� �head�tailZ index_summaryr� r� r� �_summary� s zIndex._summaryc C s | S )a+ Identity method. This is implemented for compatibility with subclass implementations when chaining. Returns ------- pd.Index Caller. See Also -------- MultiIndex.to_flat_index : Subclass implementation. r� )r� r� r� r� � to_flat_index s zIndex.to_flat_indexrr )r� r~ c C s> ddl m} |dkr | �� }|dkr*| j}|| j�� ||d�S )a� Create a Series with both index and values equal to the index keys. Useful with map for returning an indexer based on an index. Parameters ---------- index : Index, optional Index of resulting Series. If None, defaults to original index. name : str, optional Name of resulting Series. If None, defaults to name of original index. Returns ------- Series The dtype will be based on the type of the Index values. See Also -------- Index.to_frame : Convert an Index to a DataFrame. Series.to_frame : Convert Series to DataFrame. Examples -------- >>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal') By default, the original Index and original name is reused. >>> idx.to_series() animal Ant Ant Bear Bear Cow Cow Name: animal, dtype: object To enforce a new Index, specify new labels to ``index``: >>> idx.to_series(index=[0, 1, 2]) 0 Ant 1 Bear 2 Cow Name: animal, dtype: object To override the name of the resulting column, specify `name`: >>> idx.to_series(name='zoo') animal Ant Ant Bear Bear Cow Cow Name: zoo, dtype: object r )rr N)r r� )r� rr r r� r� r� )r� r r� rr r� r� r� � to_series, s 6 zIndex.to_series)r r� r~ c C s> ddl m} |dkr | jp d}||| j�� i�}|r:| |_|S )a� Create a DataFrame with a column containing the Index. Parameters ---------- index : bool, default True Set the index of the returned DataFrame as the original Index. name : object, default None The passed name should substitute for the index name (if it has one). Returns ------- DataFrame DataFrame containing the original Index data. See Also -------- Index.to_series : Convert an Index to a Series. Series.to_frame : Convert Series to DataFrame. Examples -------- >>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal') >>> idx.to_frame() animal animal Ant Ant Bear Bear Cow Cow By default, the original Index is reused. To enforce a new Index: >>> idx.to_frame(index=False) animal 0 Ant 1 Bear 2 Cow To override the name of the resulting column, specify `name`: >>> idx.to_frame(index=False, name='zoo') zoo 0 Ant 1 Bear 2 Cow r )rn N)r� rn r� r� r� r )r� r r� rn r� r� r� r� r k s 1 zIndex.to_framec C s | j S )z2 Return Index or MultiIndex name. )r� )r� r� r� r� r� � s z Index.name)�valuec C s( | j rtd��t|d t| �� || _d S )NzOCannot set name on a level of a MultiIndex. Use 'MultiIndex.set_names' instead.)r� � RuntimeErrorr� r� r� )r� rz r� r� r� r� � s zlist[Hashable])rC r~ c C s� ddl m} |dk r&|dk r&td��nX|dkrL|dkrL|rD|| j�n| j}n2|dk rjt|�sdtd��|}nt|�sz|g}n|}t|�t| j�kr�tdt| j�� dt|�� ���t|dt| �j � d �i� |S ) z� Handles the quirks of having a singular 'name' parameter for general Index and plural 'names' parameter for MultiIndex. r )�deepcopyNz*Can only provide one of `names` and `name`z Must pass list-like as `names`.z Length of new names must be z, got � error_namez.name) r� r| r� r� r8 r r� r? r� r3 )r� r� r� rC r| � new_namesr� r� r� rD � s" zIndex._validate_namesr` c C s t | jf�S )N)r` r� )r� r� r� r� � _get_names� s zIndex._get_namesc C sV t |�std��t|�dkr.tdt|�� ���t|dt| �j� d�i� |d | _dS )a� Set new names on index. Each name has to be a hashable type. Parameters ---------- values : str or sequence name(s) to set level : int, level name, or sequence of int/level names (default None) If the index is a MultiIndex (hierarchical), level(s) to set (None for all levels). Otherwise level must be None Raises ------ TypeError if each name is not hashable. zNames must be a list-liker� z#Length of new names must be 1, got r} z.namer N)r8 r� r r? r� r3 r� )r� r r� r� r� r� � _set_names� s zIndex._set_names)�fset�fgetr� r� )�versionZ allowed_args)rw c C sT |dk r t | t�s td��nz|dk r>t|�s>t|�r>td��nXt|�sb|dkrb| jdkrbtd��n4t|�r~t | t�s~td��nt|�r�|dk r�td��t | t�r�t|�r�|dkr�g g }}x:t| j�D ],\}}||� � kr�|� |� |� || � q�W |}t|��s |g}|dk �r$t|��s$|g}|�r0| }n| � � }|j ||d� |�sP|S dS ) a� Set Index or MultiIndex name. Able to set new names partially and by level. Parameters ---------- names : label or list of label or dict-like for MultiIndex Name(s) to set. .. versionchanged:: 1.3.0 level : int, label or list of int or label, optional If the index is a MultiIndex and names is not dict-like, level(s) to set (None for all levels). Otherwise level must be None. .. versionchanged:: 1.3.0 inplace : bool, default False Modifies the object directly, instead of creating a new Index or MultiIndex. Returns ------- Index or None The same type as the caller or None if ``inplace=True``. See Also -------- Index.rename : Able to set new names without level. Examples -------- >>> idx = pd.Index([1, 2, 3, 4]) >>> idx Int64Index([1, 2, 3, 4], dtype='int64') >>> idx.set_names('quarter') Int64Index([1, 2, 3, 4], dtype='int64', name='quarter') >>> idx = pd.MultiIndex.from_product([['python', 'cobra'], ... [2018, 2019]]) >>> idx MultiIndex([('python', 2018), ('python', 2019), ( 'cobra', 2018), ( 'cobra', 2019)], ) >>> idx.set_names(['kind', 'year'], inplace=True) >>> idx MultiIndex([('python', 2018), ('python', 2019), ( 'cobra', 2018), ( 'cobra', 2019)], names=['kind', 'year']) >>> idx.set_names('species', level=0) MultiIndex([('python', 2018), ('python', 2019), ( 'cobra', 2018), ( 'cobra', 2019)], names=['species', 'year']) When renaming levels with a dict, levels can not be passed. >>> idx.set_names({'kind': 'snake'}) MultiIndex([('python', 2018), ('python', 2019), ( 'cobra', 2018), ( 'cobra', 2019)], names=['snake', 'year']) Nz%Level must be None for non-MultiIndexz7Names must be a string when a single level is provided.r� z Must pass list-like as `names`.z2Can only pass dict-like as `names` for MultiIndex.z(Can not pass level for dictlike `names`.)r� ) r� rH r� r8 r� r rL � enumerater� �keysrd r r� )r� r� r� rw Znames_adjustedr� r� �idxr� r� r� � set_names� s6 I zIndex.set_namesc C s | j |g|d�S )aq Alter Index or MultiIndex name. Able to set new names without level. Defaults to returning new index. Length of names must match number of levels in MultiIndex. Parameters ---------- name : label or list of labels Name(s) to set. inplace : bool, default False Modifies the object directly, instead of creating a new Index or MultiIndex. Returns ------- Index or None The same type as the caller or None if ``inplace=True``. See Also -------- Index.set_names : Able to set new names partially and by level. Examples -------- >>> idx = pd.Index(['A', 'C', 'A', 'B'], name='score') >>> idx.rename('grade') Index(['A', 'C', 'A', 'B'], dtype='object', name='grade') >>> idx = pd.MultiIndex.from_product([['python', 'cobra'], ... [2018, 2019]], ... names=['kind', 'year']) >>> idx MultiIndex([('python', 2018), ('python', 2019), ( 'cobra', 2018), ( 'cobra', 2019)], names=['kind', 'year']) >>> idx.rename(['species', 'year']) MultiIndex([('python', 2018), ('python', 2019), ( 'cobra', 2018), ( 'cobra', 2019)], names=['species', 'year']) >>> idx.rename('species') Traceback (most recent call last): TypeError: Must pass list-like as `names`. )rw )r� )r� r� rw r� r� r� �renamek s 1z Index.renamec C s dS )z# Number of levels. r� r� )r� r� r� r� r � s z Index.nlevelsc C s | S )z) Compat with MultiIndex. r� )r� r� r� r� �_sort_levels_monotonic� s z Index._sort_levels_monotonicc C sn t |t�rH|dk r,|dkr,td|� d���qj|dkrjtd|d � ���n"|| jkrjtd|� d| j� d ���d S ) z� Validate index level. For single-level Index getting level number is a no-op, but some verification must be done like in MultiIndex. r r> z)Too many levels: Index has only 1 level, z is not a valid level numberz-Too many levels: Index has only 1 level, not r� zRequested level (z ) does not match index name (rN N)r� r' � IndexErrorr� �KeyError)r� r� r� r� r� �_validate_index_level� s zIndex._validate_index_levelc C s | � |� dS )Nr )r� )r� r� r� r� r� �_get_level_number� s zIndex._get_level_numberc C s\ t |ttf�std��t |t�r<t|�dkr4td��|d }t |t�sNtd��| jd|d�S )a\ For internal compatibility with the Index API. Sort the Index. This is for compat with MultiIndex Parameters ---------- ascending : bool, default True False to sort in descending order level, sort_remaining are compat parameters Returns ------- Index zIascending must be a single bool value ora list of bool values of length 1r� z3ascending must be a list of bool values of length 1r z ascending must be a bool valueT)�return_indexer� ascending)r� r� r� r� r � sort_values)r� r� r� Zsort_remainingr� r� r� � sortlevel� s zIndex.sortlevelc C s | � |� | S )a� Return an Index of values for requested level. This is primarily useful to get an individual level of values from a MultiIndex, but is provided on Index as well for compatibility. Parameters ---------- level : int or str It is either the integer position or the name of the level. Returns ------- Index Calling object, as there is only one level in the Index. See Also -------- MultiIndex.get_level_values : Get values for a level of a MultiIndex. Notes ----- For Index, level should be 0, since there are no multiple levels. Examples -------- >>> idx = pd.Index(list('abc')) >>> idx Index(['a', 'b', 'c'], dtype='object') Get level values by supplying `level` as integer: >>> idx.get_level_values(0) Index(['a', 'b', 'c'], dtype='object') )r� )r� r� r� r� r� �_get_level_values� s $ zIndex._get_level_valuesc s> t |ttf�s|g}t� fdd�|D ��ddd� }� �|�S )a� Return index with requested level(s) removed. If resulting index has only 1 level left, the result will be of Index type, not MultiIndex. Parameters ---------- level : int, str, or list-like, default 0 If a string is given, must be the name of a level If list-like, elements must be names or indexes of levels. Returns ------- Index or MultiIndex Examples -------- >>> mi = pd.MultiIndex.from_arrays( ... [[1, 2], [3, 4], [5, 6]], names=['x', 'y', 'z']) >>> mi MultiIndex([(1, 3, 5), (2, 4, 6)], names=['x', 'y', 'z']) >>> mi.droplevel() MultiIndex([(3, 5), (4, 6)], names=['y', 'z']) >>> mi.droplevel(2) MultiIndex([(1, 3), (2, 4)], names=['x', 'y']) >>> mi.droplevel('z') MultiIndex([(1, 3), (2, 4)], names=['x', 'y']) >>> mi.droplevel(['x', 'y']) Int64Index([5, 6], dtype='int64', name='z') c 3 s | ]}� � |�V qd S )N)r� )r� Zlev)r� r� r� r� D s z"Index.droplevel.<locals>.<genexpr>Nr> )r� r� r� �sorted�_drop_level_numbers)r� r� �levnumsr� )r� r� � droplevel s - zIndex.droplevelz list[int])r� c C s� |st | t�s| S t|�| jkr<tdt|�� d| j� d���td| �} t| j�}t| j�}t| j �}x*|D ]"}|� |� |� |� |� |� qjW t|�dkr�|d dk}|d � |d �}|� � r�|� |tj�}|d |_|S ddlm} ||||d d �S d S ) zE Drop MultiIndex levels by level _number_, not name. zCannot remove z levels from an index with z) levels: at least one level must be left.rp r� r r> )rp F)�levelsr� r� �verify_integrityN)r� rH r r r� r r� r� r� r� r� r6 r? �putmaskr� �nanr� r� rp ) r� r� � new_levels� new_codesr~ r� rp r� rp r� r� r� r� H s4 zIndex._drop_level_numbersc C s6 |dks|dkst �|dkr"| }n | �|�}|ddfS )a Get index grouper corresponding to an index level Parameters ---------- mapper: Group mapping function or None Function mapping index values to groups level : int or None Index level Returns ------- grouper : Index Index of values to group on. labels : ndarray of int or None Array of locations in level_index. uniques : Index or None Index of unique values for level. Nr )r re )r� �mapperr� Zgrouperr� r� r� �_get_grouper_for_levelu s z Index._get_grouper_for_levelc C s | j S )z4 Alias for is_monotonic_increasing. )�is_monotonic_increasing)r� r� r� r� � is_monotonic� s zIndex.is_monotonicc C s | j jS )aR Return if the index is monotonic increasing (only equal or increasing) values. Examples -------- >>> Index([1, 2, 3]).is_monotonic_increasing True >>> Index([1, 2, 2]).is_monotonic_increasing True >>> Index([1, 3, 2]).is_monotonic_increasing False )r r� )r� r� r� r� r� � s z Index.is_monotonic_increasingc C s | j jS )aR Return if the index is monotonic decreasing (only equal or decreasing) values. Examples -------- >>> Index([3, 2, 1]).is_monotonic_decreasing True >>> Index([3, 2, 2]).is_monotonic_decreasing True >>> Index([3, 1, 2]).is_monotonic_decreasing False )r �is_monotonic_decreasing)r� r� r� r� r� � s z Index.is_monotonic_decreasingc C s | j o | jS )aq Return if the index is strictly monotonic increasing (only increasing) values. Examples -------- >>> Index([1, 2, 3])._is_strictly_monotonic_increasing True >>> Index([1, 2, 2])._is_strictly_monotonic_increasing False >>> Index([1, 3, 2])._is_strictly_monotonic_increasing False )r r� )r� r� r� r� �!_is_strictly_monotonic_increasing� s z'Index._is_strictly_monotonic_increasingc C s | j o | jS )aq Return if the index is strictly monotonic decreasing (only decreasing) values. Examples -------- >>> Index([3, 2, 1])._is_strictly_monotonic_decreasing True >>> Index([3, 2, 2])._is_strictly_monotonic_decreasing False >>> Index([3, 1, 2])._is_strictly_monotonic_decreasing False )r r� )r� r� r� r� �!_is_strictly_monotonic_decreasing� s z'Index._is_strictly_monotonic_decreasingc C s | j jS )z8 Return if the index has unique values. )r r )r� r� r� r� r � s zIndex.is_uniquec C s | j S )a� Check if the Index has duplicate values. Returns ------- bool Whether or not the Index has duplicate values. Examples -------- >>> idx = pd.Index([1, 5, 7, 7]) >>> idx.has_duplicates True >>> idx = pd.Index([1, 5, 7]) >>> idx.has_duplicates False >>> idx = pd.Index(["Watermelon", "Orange", "Apple", ... "Watermelon"]).astype("category") >>> idx.has_duplicates True >>> idx = pd.Index(["Orange", "Apple", ... "Watermelon"]).astype("category") >>> idx.has_duplicates False )r )r� r� r� r� �has_duplicates� s zIndex.has_duplicatesc C s | j dkS )a� Check if the Index only consists of booleans. Returns ------- bool Whether or not the Index only consists of booleans. See Also -------- is_integer : Check if the Index only consists of integers. is_floating : Check if the Index is a floating type. is_numeric : Check if the Index only consists of numeric data. is_object : Check if the Index is of the object dtype. is_categorical : Check if the Index holds categorical data. is_interval : Check if the Index holds Interval objects. is_mixed : Check if the Index holds data with mixed data types. Examples -------- >>> idx = pd.Index([True, False, True]) >>> idx.is_boolean() True >>> idx = pd.Index(["True", "False", "True"]) >>> idx.is_boolean() False >>> idx = pd.Index([True, False, "True"]) >>> idx.is_boolean() False )�boolean)rZ )r� r� r� r� � is_boolean s "zIndex.is_booleanc C s | j dkS )a� Check if the Index only consists of integers. Returns ------- bool Whether or not the Index only consists of integers. See Also -------- is_boolean : Check if the Index only consists of booleans. is_floating : Check if the Index is a floating type. is_numeric : Check if the Index only consists of numeric data. is_object : Check if the Index is of the object dtype. is_categorical : Check if the Index holds categorical data. is_interval : Check if the Index holds Interval objects. is_mixed : Check if the Index holds data with mixed data types. Examples -------- >>> idx = pd.Index([1, 2, 3, 4]) >>> idx.is_integer() True >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0]) >>> idx.is_integer() False >>> idx = pd.Index(["Apple", "Mango", "Watermelon"]) >>> idx.is_integer() False )�integer)rZ )r� r� r� r� r5 . s "zIndex.is_integerc C s | j dkS )a� Check if the Index is a floating type. The Index may consist of only floats, NaNs, or a mix of floats, integers, or NaNs. Returns ------- bool Whether or not the Index only consists of only consists of floats, NaNs, or a mix of floats, integers, or NaNs. See Also -------- is_boolean : Check if the Index only consists of booleans. is_integer : Check if the Index only consists of integers. is_numeric : Check if the Index only consists of numeric data. is_object : Check if the Index is of the object dtype. is_categorical : Check if the Index holds categorical data. is_interval : Check if the Index holds Interval objects. is_mixed : Check if the Index holds data with mixed data types. Examples -------- >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0]) >>> idx.is_floating() True >>> idx = pd.Index([1.0, 2.0, np.nan, 4.0]) >>> idx.is_floating() True >>> idx = pd.Index([1, 2, 3, 4, np.nan]) >>> idx.is_floating() True >>> idx = pd.Index([1, 2, 3, 4]) >>> idx.is_floating() False )�floatingzmixed-integer-floatz integer-na)rZ )r� r� r� r� � is_floatingR s *zIndex.is_floatingc C s | j dkS )a� Check if the Index only consists of numeric data. Returns ------- bool Whether or not the Index only consists of numeric data. See Also -------- is_boolean : Check if the Index only consists of booleans. is_integer : Check if the Index only consists of integers. is_floating : Check if the Index is a floating type. is_object : Check if the Index is of the object dtype. is_categorical : Check if the Index holds categorical data. is_interval : Check if the Index holds Interval objects. is_mixed : Check if the Index holds data with mixed data types. Examples -------- >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0]) >>> idx.is_numeric() True >>> idx = pd.Index([1, 2, 3, 4.0]) >>> idx.is_numeric() True >>> idx = pd.Index([1, 2, 3, 4]) >>> idx.is_numeric() True >>> idx = pd.Index([1, 2, 3, 4.0, np.nan]) >>> idx.is_numeric() True >>> idx = pd.Index([1, 2, 3, 4.0, np.nan, "Apple"]) >>> idx.is_numeric() False )r� r� )rZ )r� r� r� r� � is_numeric~ s *zIndex.is_numericc C s t | j�S )a� Check if the Index is of the object dtype. Returns ------- bool Whether or not the Index is of the object dtype. See Also -------- is_boolean : Check if the Index only consists of booleans. is_integer : Check if the Index only consists of integers. is_floating : Check if the Index is a floating type. is_numeric : Check if the Index only consists of numeric data. is_categorical : Check if the Index holds categorical data. is_interval : Check if the Index holds Interval objects. is_mixed : Check if the Index holds data with mixed data types. Examples -------- >>> idx = pd.Index(["Apple", "Mango", "Watermelon"]) >>> idx.is_object() True >>> idx = pd.Index(["Apple", "Mango", 2.0]) >>> idx.is_object() True >>> idx = pd.Index(["Watermelon", "Orange", "Apple", ... "Watermelon"]).astype("category") >>> idx.is_object() False >>> idx = pd.Index([1.0, 2.0, 3.0, 4.0]) >>> idx.is_object() False )r9 r� )r� r� r� r� rs � s 'zIndex.is_objectc C s | j dkS )a� Check if the Index holds categorical data. Returns ------- bool True if the Index is categorical. See Also -------- CategoricalIndex : Index for categorical data. is_boolean : Check if the Index only consists of booleans. is_integer : Check if the Index only consists of integers. is_floating : Check if the Index is a floating type. is_numeric : Check if the Index only consists of numeric data. is_object : Check if the Index is of the object dtype. is_interval : Check if the Index holds Interval objects. is_mixed : Check if the Index holds data with mixed data types. Examples -------- >>> idx = pd.Index(["Watermelon", "Orange", "Apple", ... "Watermelon"]).astype("category") >>> idx.is_categorical() True >>> idx = pd.Index([1, 3, 5, 7]) >>> idx.is_categorical() False >>> s = pd.Series(["Peter", "Victor", "Elisabeth", "Mar"]) >>> s 0 Peter 1 Victor 2 Elisabeth 3 Mar dtype: object >>> s.index.is_categorical() False )rX )rZ )r� r� r� r� �is_categorical� s *zIndex.is_categoricalc C s | j dkS )a� Check if the Index holds Interval objects. Returns ------- bool Whether or not the Index holds Interval objects. See Also -------- IntervalIndex : Index for Interval objects. is_boolean : Check if the Index only consists of booleans. is_integer : Check if the Index only consists of integers. is_floating : Check if the Index is a floating type. is_numeric : Check if the Index only consists of numeric data. is_object : Check if the Index is of the object dtype. is_categorical : Check if the Index holds categorical data. is_mixed : Check if the Index holds data with mixed data types. Examples -------- >>> idx = pd.Index([pd.Interval(left=0, right=5), ... pd.Interval(left=5, right=10)]) >>> idx.is_interval() True >>> idx = pd.Index([1, 3, 5, 7]) >>> idx.is_interval() False )�interval)rZ )r� r� r� r� � is_interval� s zIndex.is_intervalc C s t jdtdd� | jdkS )a� Check if the Index holds data with mixed data types. Returns ------- bool Whether or not the Index holds data with mixed data types. See Also -------- is_boolean : Check if the Index only consists of booleans. is_integer : Check if the Index only consists of integers. is_floating : Check if the Index is a floating type. is_numeric : Check if the Index only consists of numeric data. is_object : Check if the Index is of the object dtype. is_categorical : Check if the Index holds categorical data. is_interval : Check if the Index holds Interval objects. Examples -------- >>> idx = pd.Index(['a', np.nan, 'b']) >>> idx.is_mixed() True >>> idx = pd.Index([1.0, 2.0, 3.0, 5.0]) >>> idx.is_mixed() False zqIndex.is_mixed is deprecated and will be removed in a future version. Check index.inferred_type directly instead.r� )r� )rt )r� r� r� rZ )r� r� r� r� �is_mixed! s zIndex.is_mixedc C s | j dkS )z6 Whether the type is an integer type. )r� z mixed-integer)rZ )r� r� r� r� � holds_integerG s zIndex.holds_integerc C s t j| jdd�S )zG Return a string of the type inferred from the values. F)Zskipna)r Z infer_dtyper� )r� r� r� r� rZ N s zIndex.inferred_typec C s t t| j��S )zH Whether or not the index values only consist of dates. )r r+ r� )r� r� r� r� � _is_all_datesU s zIndex._is_all_datesc C s t jdtdd� | jS )zH Whether or not the index values only consist of dates. ziIndex.is_all_dates is deprecated, will be removed in a future version. check index.inferred_type insteadr� )r� )r� r� r� r� )r� r� r� r� � is_all_dates\ s zIndex.is_all_datesc C s t | t�S )zI Cached check equivalent to isinstance(self, MultiIndex) )r� rH )r� r� r� r� r\ j s zIndex._is_multic C s* d| j i}|�| �� � tt| �|fd fS )Nr� )r� �updater r� r� )r� r� r� r� r� � __reduce__t s zIndex.__reduce__zfloat | NaTTyper< c C s4 | j rt| �S tjt| �tjd�}|�d� |S dS )z. Return if each value is NaN. )r� FN)r� rO r� �emptyr r� �fill)r� r r� r� r� �_isnan s z Index._isnanc C s | j rt| j�� �S dS dS )zK Return if I have any nans; enables various perf speedups. FN)r� r� r� r? )r� r� r� r� �hasnans� s z Index.hasnansc C s | j S )a Detect missing values. Return a boolean same-sized object indicating if the values are NA. NA values, such as ``None``, :attr:`numpy.NaN` or :attr:`pd.NaT`, get mapped to ``True`` values. Everything else get mapped to ``False`` values. Characters such as empty strings `''` or :attr:`numpy.inf` are not considered NA values (unless you set ``pandas.options.mode.use_inf_as_na = True``). Returns ------- numpy.ndarray[bool] A boolean array of whether my values are NA. See Also -------- Index.notna : Boolean inverse of isna. Index.dropna : Omit entries with missing values. isna : Top-level isna. Series.isna : Detect missing values in Series object. Examples -------- Show which entries in a pandas.Index are NA. The result is an array. >>> idx = pd.Index([5.2, 6.0, np.NaN]) >>> idx Float64Index([5.2, 6.0, nan], dtype='float64') >>> idx.isna() array([False, False, True]) Empty strings are not considered NA values. None is considered an NA value. >>> idx = pd.Index(['black', '', 'red', None]) >>> idx Index(['black', '', 'red', None], dtype='object') >>> idx.isna() array([False, False, False, True]) For datetimes, `NaT` (Not a Time) is considered as an NA value. >>> idx = pd.DatetimeIndex([pd.Timestamp('1940-04-25'), ... pd.Timestamp(''), None, pd.NaT]) >>> idx DatetimeIndex(['1940-04-25', 'NaT', 'NaT', 'NaT'], dtype='datetime64[ns]', freq=None) >>> idx.isna() array([False, True, True, True]) )r� )r� r� r� r� rO � s 6z Index.isnac C s | � � S )a Detect existing (non-missing) values. Return a boolean same-sized object indicating if the values are not NA. Non-missing values get mapped to ``True``. Characters such as empty strings ``''`` or :attr:`numpy.inf` are not considered NA values (unless you set ``pandas.options.mode.use_inf_as_na = True``). NA values, such as None or :attr:`numpy.NaN`, get mapped to ``False`` values. Returns ------- numpy.ndarray[bool] Boolean array to indicate which entries are not NA. See Also -------- Index.notnull : Alias of notna. Index.isna: Inverse of notna. notna : Top-level notna. Examples -------- Show which entries in an Index are not NA. The result is an array. >>> idx = pd.Index([5.2, 6.0, np.NaN]) >>> idx Float64Index([5.2, 6.0, nan], dtype='float64') >>> idx.notna() array([ True, True, False]) Empty strings are not considered NA values. None is considered a NA value. >>> idx = pd.Index(['black', '', 'red', None]) >>> idx Index(['black', '', 'red', None], dtype='object') >>> idx.notna() array([ True, True, True, False]) )rO )r� r� r� r� �notna� s +z Index.notnac C s< | � |�}| jr4| �| j|�}|dkr4t|| jd�S | �� S )a� Fill NA/NaN values with the specified value. Parameters ---------- value : scalar Scalar value to use to fill holes (e.g. 0). This value cannot be a list-likes. downcast : dict, default is None A dict of item->dtype of what to downcast if possible, or the string 'infer' which will try to downcast to an appropriate equal type (e.g. float64 to int64 if possible). Returns ------- Index See Also -------- DataFrame.fillna : Fill NaN values of a DataFrame. Series.fillna : Fill NaN Values of a Series. N)r� )�_require_scalarr� r� r� rs r� r )r� rz Zdowncastr� r� r� r� �fillna� s z Index.fillnar? )r� r� r~ c C sF |dkrt d|� ���| jr>| j| j }t| �j|| jd�S | �� S )a Return Index without NA/NaN values. Parameters ---------- how : {'any', 'all'}, default 'any' If the Index is a MultiIndex, drop the value when any or all levels are NaN. Returns ------- Index )r? r� zinvalid how option: )r� )r� r� r� r� r� r� r� r )r� r� rB r� r� r� �dropna s z Index.dropna)r� r� r~ c s4 |dk r| � |� | jr | �� S t� �� }| �|�S )a6 Return unique values in the index. Unique values are returned in order of appearance, this does NOT sort. Parameters ---------- level : int or hashable, optional Only return values from specified level (for MultiIndex). If int, gets the level by integer position, else by level name. Returns ------- Index See Also -------- unique : Numpy array of unique values in that column. Series.unique : Return unique values of Series object. N)r� r r �superrx r )r� r� r� )� __class__r� r� rx 8 s z Index.uniquer z str_t | bool)r� r r~ c s | j r| �� S t� j|d�S )a Return Index with duplicate values removed. Parameters ---------- keep : {'first', 'last', ``False``}, default 'first' - 'first' : Drop duplicates except for the first occurrence. - 'last' : Drop duplicates except for the last occurrence. - ``False`` : Drop all duplicates. Returns ------- deduplicated : Index See Also -------- Series.drop_duplicates : Equivalent method on Series. DataFrame.drop_duplicates : Equivalent method on DataFrame. Index.duplicated : Related method on Index, indicating duplicate Index values. Examples -------- Generate an pandas.Index with duplicate values. >>> idx = pd.Index(['lama', 'cow', 'lama', 'beetle', 'lama', 'hippo']) The `keep` parameter controls which duplicate values are removed. The value 'first' keeps the first occurrence for each set of duplicated entries. The default value of keep is 'first'. >>> idx.drop_duplicates(keep='first') Index(['lama', 'cow', 'beetle', 'hippo'], dtype='object') The value 'last' keeps the last occurrence for each set of duplicated entries. >>> idx.drop_duplicates(keep='last') Index(['cow', 'beetle', 'lama', 'hippo'], dtype='object') The value ``False`` discards all sets of duplicated entries. >>> idx.drop_duplicates(keep=False) Index(['cow', 'beetle', 'hippo'], dtype='object') )r )r r r� �drop_duplicates)r� r )r� r� r� r� V s /zIndex.drop_duplicatesz!Literal[('first', 'last', False)])r r~ c C s$ | j rtjt| �td�S | j|d�S )a Indicate duplicate index values. Duplicated values are indicated as ``True`` values in the resulting array. Either all duplicates, all except the first, or all except the last occurrence of duplicates can be indicated. Parameters ---------- keep : {'first', 'last', False}, default 'first' The value or values in a set of duplicates to mark as missing. - 'first' : Mark duplicates as ``True`` except for the first occurrence. - 'last' : Mark duplicates as ``True`` except for the last occurrence. - ``False`` : Mark all duplicates as ``True``. Returns ------- np.ndarray[bool] See Also -------- Series.duplicated : Equivalent method on pandas.Series. DataFrame.duplicated : Equivalent method on pandas.DataFrame. Index.drop_duplicates : Remove duplicate values from Index. Examples -------- By default, for each set of duplicated values, the first occurrence is set to False and all others to True: >>> idx = pd.Index(['lama', 'cow', 'lama', 'beetle', 'lama']) >>> idx.duplicated() array([False, False, True, False, True]) which is equivalent to >>> idx.duplicated(keep='first') array([False, False, True, False, True]) By using 'last', the last occurrence of each set of duplicated values is set on False and all others on True: >>> idx.duplicated(keep='last') array([ True, False, True, False, False]) By setting keep on ``False``, all duplicates are True: >>> idx.duplicated(keep=False) array([ True, False, True, False, True]) )r� )r )r r� �zerosr r� Z _duplicated)r� r r� r� r� ry � s 6zIndex.duplicatedc C s | � � S )zk Returns an index containing unique values. Returns ------- Index )rx )r� r� r� r� �_get_unique_index� s zIndex._get_unique_indexc C s | | S )Nr� )r� r� r� r� r� �__iadd__� s zIndex.__iadd__c C s t jdtdd� | �|�S )Nz�Index.__and__ operating as a set operation is deprecated, in the future this will be a logical operation matching Series.__and__. Use index.intersection(other) insteadr� )r� )r� r� r� � intersection)r� r� r� r� r� �__and__� s z Index.__and__c C s t jdtdd� | �|�S )Nz�Index.__or__ operating as a set operation is deprecated, in the future this will be a logical operation matching Series.__or__. Use index.union(other) insteadr� )r� )r� r� r� �union)r� r� r� r� r� �__or__� s z Index.__or__c C s t jdtdd� | �|�S )Nz�Index.__xor__ operating as a set operation is deprecated, in the future this will be a logical operation matching Series.__xor__. Use index.symmetric_difference(other) insteadr� )r� )r� r� r� �symmetric_difference)r� r� r� r� r� �__xor__� s z Index.__xor__c C s t dt| �j� d���d S )NzThe truth value of a zC is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().)r� r� r3 )r� r� r� r� � __nonzero__� s zIndex.__nonzero__c C s" t | |�}| j|kr | �|�S | S )z� If the result of a set operation will be self, return self, unless the name changes, in which case make a shallow copy of self. )ra r� r� )r� r� r� r� r� r� �_get_reconciled_name_object s z!Index._get_reconciled_name_objectc C s |dkrt d|� d���d S )N)NFz;The 'sort' keyword only takes the values of None or False; z was passed.)r� )r� r� r� r� r� �_validate_sort_keyword s z Index._validate_sort_keywordc C s | � |� | �|� | �|�\}}t| j|j�s�t| t�rZtt|��sZt |�dkrZt d��t| t �r�t|t �r�| j dk r�|j dk r�t jdtdd� | �|�}| j|dd�}|j|dd�}|j||d �S t |�r�| �|�r�| �|�S t | �s�|�| �S | j||d �}| �||�S ) a� Form the union of two Index objects. If the Index objects are incompatible, both Index objects will be cast to dtype('object') first. .. versionchanged:: 0.25.0 Parameters ---------- other : Index or array-like sort : bool or None, default None Whether to sort the resulting Index. * None : Sort the result, except when 1. `self` and `other` are equal. 2. `self` or `other` has length 0. 3. Some values in `self` or `other` cannot be compared. A RuntimeWarning is issued in this case. * False : do not sort the result. Returns ------- union : Index Examples -------- Union matching dtypes >>> idx1 = pd.Index([1, 2, 3, 4]) >>> idx2 = pd.Index([3, 4, 5, 6]) >>> idx1.union(idx2) Int64Index([1, 2, 3, 4, 5, 6], dtype='int64') Union mismatched dtypes >>> idx1 = pd.Index(['a', 'b', 'c', 'd']) >>> idx2 = pd.Index([1, 2, 3, 4]) >>> idx1.union(idx2) Index(['a', 'b', 'c', 'd', 1, 2, 3, 4], dtype='object') MultiIndex case >>> idx1 = pd.MultiIndex.from_arrays( ... [[1, 1, 2, 2], ["Red", "Blue", "Red", "Blue"]] ... ) >>> idx1 MultiIndex([(1, 'Red'), (1, 'Blue'), (2, 'Red'), (2, 'Blue')], ) >>> idx2 = pd.MultiIndex.from_arrays( ... [[3, 3, 2, 2], ["Red", "Green", "Red", "Green"]] ... ) >>> idx2 MultiIndex([(3, 'Red'), (3, 'Green'), (2, 'Red'), (2, 'Green')], ) >>> idx1.union(idx2) MultiIndex([(1, 'Blue'), (1, 'Red'), (2, 'Blue'), (2, 'Green'), (2, 'Red'), (3, 'Green'), (3, 'Red')], ) >>> idx1.union(idx2, sort=False) MultiIndex([(1, 'Red'), (1, 'Blue'), (2, 'Red'), (2, 'Blue'), (3, 'Red'), (3, 'Green'), (2, 'Green')], ) r zjCan only union MultiIndex with MultiIndex or Index of tuples, try mi.to_flat_index().union(other) instead.Nz�In a future version, the union of DatetimeIndex objects with mismatched timezones will cast both to UTC instead of object dtype. To retain the old behavior, use `index.astype(object).union(other)`r� )r� F)r� )r� )r� �_assert_can_do_setop�_convert_can_do_setopr/ r� r� rH r9 �unpack_nested_dtyper r� rG r� r� r� r� �_find_common_type_compatr� r� �equalsr� �_union�_wrap_setop_result)r� r� r� � result_namer� r �rightr� r� r� r� r� s6 T z Index.union)r� c s" | j }|j }|dkr�| jr�|jr�| jr,|js�y| �|�d S ttfk r� t|�}t|�� |�� fdd�|D �� t j |t d�S X n |j s�t �||�}t||�S | jr�| �|�}|dk�� d }nt �| �|�d �}t|�dk�r |�|�} t|| f�}n|}| j�r|j�s t||�}|S )a Specific union logic should go here. In subclasses, union behavior should be overwritten here rather than in `self.union`. Parameters ---------- other : Index or array-like sort : False or None, default False Whether to sort the resulting index. * False : do not sort the result. * None : sort the result, except when `self` and `other` are equal or when the values cannot be compared. Returns ------- Index Nr c s g | ]}|� kr|�qS r� r� )r� rk )� value_setr� r� rK � s z Index._union.<locals>.<listcomp>)r� r> r� )r� r� r� r� r� r r� r� �extendr� r� r| r r Zunion_with_duplicates�_maybe_try_sort�_index_as_unique� get_indexer�nonzero�unique1d�get_indexer_non_uniquer r6 r@ ) r� r� r� ZlvalsZrvalsZ value_listr� �indexerrP Z other_diffr� )r� r� r� � s6 z Index._union)r� r~ c C s> t | |�}t|t�r,|j|kr(|�|�S |S | j||d�S d S )N)r� )ra r� rs r� r� r )r� r� r� r� r� r� r� r� � s zIndex._wrap_setop_resultc C s� | � |� | �|� | �|�\}}| �|�rJ| jr@| �� �|�S | �|�S | �|�s|t| t �rp| dd� � |�S t g |d�S t | j |j �s�t| j |j g�}| j|dd�}|j|dd�}|j||d�S | j||d�}| �||�S )a� Form the intersection of two Index objects. This returns a new Index with elements common to the index and `other`. Parameters ---------- other : Index or array-like sort : False or None, default False Whether to sort the resulting index. * False : do not sort the result. * None : sort the result, except when `self` and `other` are equal or when the values cannot be compared. Returns ------- intersection : Index Examples -------- >>> idx1 = pd.Index([1, 2, 3, 4]) >>> idx2 = pd.Index([3, 4, 5, 6]) >>> idx1.intersection(idx2) Int64Index([3, 4], dtype='int64') Nr )r� F)r� )r� )r� r� r� r� r� rx r� �_should_comparer� rH r� rs r/ r� r' r� r� � _intersection�_wrap_intersection_result)r� r� r� r� r� �thisr� r� r� r� r� � s$ zIndex.intersectionc C sl | j rP|j rPt| j�sPy| �|�d }W n tk r< Y nX t�|�}t|�S | j||d�}t ||�}|S )zL intersection specialized to the case with matching dtypes. r )r� ) r� r6 r� r� r� r r� r\ � _intersection_via_get_indexerr� )r� r� r� r� �resrB r� r� r� r� s zIndex._intersectionc C s | � ||�S )N)r� )r� r� r� r� r� r� r� 2 s z Index._wrap_intersection_resultr c C sV | � � }|� � }|�|�}|dk}|�|�� d �}|dkrFt�|�}|�|�j}|S )z� Find the intersection of two Indexes using get_indexer. Returns ------- np.ndarray or ExtensionArray The returned array will be unique. r> r F)rx �get_indexer_forr6 r� r� r� r� ) r� r� r� Z left_uniqueZ right_uniquer� rp �takerr� r� r� r� r� 6 s z#Index._intersection_via_get_indexerc C s� | � |� | �|� | �|�\}}| �|�r>| dd� �|�S t|�dkrT| �|�S | �|�sh| �|�S | j||d�}| �||�S )a� Return a new Index with elements of index not in `other`. This is the set difference of two Index objects. Parameters ---------- other : Index or array-like sort : False or None, default None Whether to sort the resulting index. By default, the values are attempted to be sorted, but any TypeError from incomparable elements is caught by pandas. * None : Attempt to sort the result, but catch any TypeErrors from comparing incomparable elements. * False : Do not sort the result. Returns ------- difference : Index Examples -------- >>> idx1 = pd.Index([2, 1, 3, 4]) >>> idx2 = pd.Index([3, 4, 5, 6]) >>> idx1.difference(idx2) Int64Index([1, 2], dtype='int64') >>> idx1.difference(idx2, sort=False) Int64Index([2, 1], dtype='int64') Nr )r� ) r� r� r� r� r� r r� � _differencer� )r� r� r� r� r� r� r� r� � differenceP s zIndex.differencec C sZ | � � }|�|�}|�|dk�� d �}tjt�|j�|dd�}|j�|�}t ||�}|S )Nr> r T)� assume_unique) r� r� r6 r� r� � setdiff1dr �sizer� r� )r� r� r� r� r� Z label_diffZthe_diffr� r� r� r� � s zIndex._differencec C s� | � |� | �|� | �|�\}}|dkr.|}| �|�sL| j||d��|�S t| j|j�s�| �|�}| j |dd�}|j |dd�}|j ||d��|�S | � � }|� � }|� |�}|� |dk�� d �} tjt�|j�| dd�} |j� | �} |dk�� d } |j� | �} t| | g�}t||�}t||d �}| j�r�td | �} t|�dk�rzt| �d d � t| j �D �d d � t| j �D �|j d�S t| �j ||j d�S |S )ae Compute the symmetric difference of two Index objects. Parameters ---------- other : Index or array-like result_name : str sort : False or None, default None Whether to sort the resulting index. By default, the values are attempted to be sorted, but any TypeError from incomparable elements is caught by pandas. * None : Attempt to sort the result, but catch any TypeErrors from comparing incomparable elements. * False : Do not sort the result. Returns ------- symmetric_difference : Index Notes ----- ``symmetric_difference`` contains elements that appear in either ``idx1`` or ``idx2`` but not both. Equivalent to the Index created by ``idx1.difference(idx2) | idx2.difference(idx1)`` with duplicates dropped. Examples -------- >>> idx1 = pd.Index([1, 2, 3, 4]) >>> idx2 = pd.Index([2, 3, 4, 5]) >>> idx1.symmetric_difference(idx2) Int64Index([1, 5], dtype='int64') N)r� F)r� r> r T)r� )r� rp c S s g | ]}g �qS r� r� )r� �_r� r� r� rK � s z.Index.symmetric_difference.<locals>.<listcomp>c S s g | ]}g �qS r� r� )r� r� r� r� r� rK � s )r� r� r� )r� ) r� r� r� r� r� r� r/ r� r� r� r� rx r� r6 r� r� r� r r� r� r@ r� rs r\ r r r� r� r r� r� )r� r� r� r� Zresult_name_updater� r� �thatr� Zcommon_indexer� left_indexerZ left_diff� right_indexerZ right_diffrB r� r� r� r� r� � sB # zIndex.symmetric_differencec C s t |�std��dS )Nz!Input must be Index or array-likeT)r8 r� )r� r� r� r� r� r� � s zIndex._assert_can_do_setopztuple[Index, Hashable]c C s2 t |t�s t|| jd�}| j}n t| |�}||fS )N)r� )r� rs r� ra )r� r� r� r� r� r� r� � s zIndex._convert_can_do_setopc C s� |dkr\|dk rt d��| �|�}y | j�|�S tk rZ } zt|�|�W dd}~X Y nX t|�rzt|�rz| jszt|��|dk r�| �|t � |��}| j |g||d�}|j dks�|j dkr�td��|�� }|dkr�t|��|S )a Get integer location, slice or boolean mask for requested label. Parameters ---------- key : label method : {None, 'pad'/'ffill', 'backfill'/'bfill', 'nearest'}, optional * default: exact matches only. * pad / ffill: find the PREVIOUS index value if no exact match. * backfill / bfill: use NEXT index value if no exact match * nearest: use the NEAREST index value if no exact match. Tied distances are broken by preferring the larger index value. tolerance : int or float, optional Maximum distance from index value for inexact matches. The value of the index at the matching location must satisfy the equation ``abs(index[loc] - key) <= tolerance``. Returns ------- loc : int if unique index, slice if monotonic index, else mask Examples -------- >>> unique_index = pd.Index(list('abc')) >>> unique_index.get_loc('b') 1 >>> monotonic_index = pd.Index(list('abbc')) >>> monotonic_index.get_loc('b') slice(1, 3, None) >>> non_monotonic_index = pd.Index(list('abcb')) >>> non_monotonic_index.get_loc('b') array([False, True, False, True]) NzGtolerance argument only valid if using pad, backfill or nearest lookups)�method� tolerancer� z$get_loc requires scalar valued inputr> )r� �_maybe_cast_indexerr �get_locr� r: rO r� �_convert_tolerancer� r� r� r� r� r� �item)r� �keyr� r� Z casted_keyr5 r� �locr� r� r� r� � s( $ z Index.get_loca� Compute indexer and mask for new index given the current index. The indexer should be then used as an input to ndarray.take to align the current data to the new index. Parameters ---------- target : %(target_klass)s method : {None, 'pad'/'ffill', 'backfill'/'bfill', 'nearest'}, optional * default: exact matches only. * pad / ffill: find the PREVIOUS index value if no exact match. * backfill / bfill: use NEXT index value if no exact match * nearest: use the NEAREST index value if no exact match. Tied distances are broken by preferring the larger index value. limit : int, optional Maximum number of consecutive labels in ``target`` to match for inexact matches. tolerance : optional Maximum distance between original and new labels for inexact matches. The values of the index at the matching locations must satisfy the equation ``abs(index[indexer] - target) <= tolerance``. Tolerance may be a scalar value, which applies the same tolerance to all values, or list-like, which applies variable tolerance per element. List-like includes list, tuple, array, Series, and must be the same size as the index and its dtype must exactly match the index's type. Returns ------- indexer : np.ndarray[np.intp] Integers from 0 to n - 1 indicating that the index at these positions matches the corresponding target values. Missing values in the target are marked by -1. %(raises_section)s Examples -------- >>> index = pd.Index(['c', 'a', 'b']) >>> index.get_indexer(['a', 'b', 'x']) array([ 1, 2, -1]) Notice that the return value is an array of locations in ``index`` and ``x`` is marked by -1, as it is not in ``index``. r� z str_t | Nonez int | None)r� �limitr~ c C sV t �|�}| �|�}| �|||� | js2t| j��| �|�sVt| j �sV| j ||dd�S t | j �r�t | j |j �srt �| j�|j�}| jr�|jr�| �tj�}|�� }|||< |S t |j ��r| �|j�}tj||jdd�}| j�s | j�r |j�r | �tj�}|�� }|||< t|�S | �|�\} } | | k �s4| |k �rF| j| |||d�S | � ||||�S )NT)r� rx r> )r9 )r� r� r� ) rP Zclean_reindex_fill_method� _maybe_cast_listlike_indexer�_check_indexing_methodr� r! �_requires_unique_msgr� r6 r� �_get_indexer_non_comparabler. r/ r r r� r� r� r� r� r� rO r[ r Ztake_ndr\ r, �_maybe_promote� _get_indexer) r� �targetr� r� r� r� r� rp Zcategories_indexer�pself�ptargetr� r� r� r� b s8 zIndex.get_indexer)r� r� r� r~ c C s� |d k r| � ||�}t| j|j�sZ| �|�}| j|dd�}|j|dd�}|j||||d�S |dkrt| �||||�}n(|dkr�| �|||�}n| j�|� � �}t |�S )NF)r� )r� r� r� )�pad�backfill�nearest) r� r/ r� r� r� r� �_get_fill_indexer�_get_nearest_indexerr r! r, )r� r� r� r� r� r� r� r� r� r� r� r� � s zIndex._get_indexerc C s� |dkrt d��| jrH|dkr(td��n |dks8|dkrH|dk rHtd��t| j�s\t| j�r~|dk r~td |� d t| �j� ���|dkr�|dk r�t d ��|dk r�t d ��dS ) zY Raise if we have a get_indexer `method` that is not supported or valid. )NZbfillr r Zffillr zInvalid fill methodr zJmethod='nearest' not implemented yet for MultiIndex; see GitHub issue 9365r r Nz,tolerance not implemented yet for MultiIndexzmethod z not yet implemented for zJtolerance argument only valid if doing pad, backfill or nearest reindexingzFlimit argument only valid if doing pad, backfill or nearest reindexing)r� r\ r� r6 r� r. r� r3 )r� r� r� r� r� r� r� r� � s* z Index._check_indexing_methodznp.ndarray | Index)r� r~ c C s, t �|�}|j|jkr(|jdkr(td��|S )Nr� z5list-like tolerance size must match target index size)r� r� r� r� )r� r� r� r� r� r� r� � s zIndex._convert_tolerancec C sh |� � }| jr8|jr8|dkr$| jjn| jj}|||�}n| �|||�}|d k rdt| �rd| �|||�}|S )Nr )r! r� r Zget_pad_indexerZget_backfill_indexer� _get_fill_indexer_searchsortedr �_filter_indexer_tolerance)r� r� r� r� r� r Z engine_methodr� r� r� r� r � s zIndex._get_fill_indexerc C s� |dk r t dt|�� d���|dkr(dnd}| �|�}|dk}| �|| |�||< |dkrl|| d8 < nd||t| �k< |S ) z� Fallback pad/backfill get_indexer that works for monotonic decreasing indexes and non-monotonic targets. Nzlimit argument for z; method only well-defined if index and target are monotonicr r r� r> r� )r� r� r� �_searchsorted_monotonicr )r� r� r� r� �sider� Znonexactr� r� r� r s z$Index._get_fill_indexer_searchsorted)r� r� r~ c C s� t | �s| �|d�S | j|d|d�}| j|d|d�}|�� }| �� }t�|| | �}t�|| | �} | jrttjntj } t� | || �|dkB ||�} |dk r�| � || |�} | S )z� Get the indexer for the nearest index labels; requires an index with values that can be subtracted from each other (e.g., not strings or tuples). r )r� r r> N) r r r� r! r� �absr� �operator�lt�le�wherer ) r� r� r� r� r� r� r � own_valuesZleft_distancesZright_distances�opr� r� r� r� r ' s zIndex._get_nearest_indexerz#Index | np.ndarray | ExtensionArray)r� r� r~ c C s* | � � }t|| | �}t�||k|d�S )Nr> )r! r r� r )r� r� r� r� r Zdistancer� r� r� r E s z Index._filter_indexer_tolerancer )r� r~ c C s |S )z� Translate any partial string timestamp matches in key, returning the new key. Only relevant for MultiIndex. r� )r� r� r� r� r� �'_get_partial_string_timestamp_match_keyS s z-Index._get_partial_string_timestamp_match_key�slicec C s4 | � d|jd� | � d|jd� | � d|jd� dS )zz For positional indexing, a slice must have either int or None for each of start, stop, and step. � positional�ilocN)�_validate_indexerr� �stop�step)r� r� r� r� r� �_validate_positional_slice] s z Index._validate_positional_slice)r� r� c C s2 |dkst |��|j|j|j }}}dd� }||�oD||�oD||�}|oZ| �� pX| �� }|dkr�| �� sp|r�| �d|jd� | �d|jd� | �d|jd� |S |r�y,|dk r�| �|� |dk r�| �|� d}W n tk r� Y nX t � |�r�|} n4|�r |dk�rt j d t d d � |} n| �|||�} | S ) a( Convert a slice indexer. By definition, these are labels unless 'iloc' is passed in. Floats are not allowed as the start, step, or stop of the slice. Parameters ---------- key : label of the slice bound kind : {'loc', 'getitem'} )r� �getitemc S s | d kpt | �S )N)r5 )rJ r� r� r� �is_inty s z,Index._convert_slice_indexer.<locals>.is_intr r NFr� z�Slicing a positional slice with .loc is not supported, and will raise TypeError in a future version. Use .loc with labels or .iloc with positions instead.� )r� )r r� r r r5 r� r r� r� r� Z is_null_slicer� r� r� � slice_indexer) r� r� r� r� r r r Zis_index_sliceZ is_positionalr� r� r� r� �_convert_slice_indexerg s@ z Index._convert_slice_indexerr� )�formr~ c C s, t d|� dt| �j� d|� dt|�j� ��S )z5 Consistent invalid indexer message. z cannot do z indexing on z with these indexers [z ] of type )r� r� r3 )r� r r� r� r� r� �_invalid_indexer� s zIndex._invalid_indexer)r� r~ c C s | j st|�rtd��dS )z� Check if we are allowing reindexing with this particular indexer. Parameters ---------- indexer : an integer ndarray Raises ------ ValueError if its a duplicate axis z$cannot reindex from a duplicate axisN)r� r r� )r� r� r� r� r� �_validate_can_reindex� s zIndex._validate_can_reindexz tuple[Index, np.ndarray | None]c C s� t |d� }t|�}t|t�s8t|�dkr8| dd� }nt|�}|dk rp|dk rXtd��| j||dd�\}}}nP| �|�r�d}n@| j r�| j ||||d�}n&|dk s�|dk r�t d��| � |�\}}|r�|j d kr�|j| jkr�|�� }| j|_||fS ) a9 Create index with target's values. Parameters ---------- target : an iterable Returns ------- new_index : pd.Index Resulting index. indexer : np.ndarray[np.intp] or None Indices of output values in original index. r� r Nz)Fill method not supported if level passedr� )r� )r� r� r� z8cannot reindex a non-unique index with a method or limitr� )r� �ensure_has_lenr� rs r � ensure_indexr� � _join_levelr� r� r� r� r� r r� r� ) r� r� r� r� r� r� Zpreserve_namesr� r� r� r� r� �reindex� s, z Index.reindexz+tuple[Index, np.ndarray, np.ndarray | None]c C s� t |�}t|�dkr2| dd� tjg tjd�dfS | �|�\}}|dk}| �|| �}d}t|��rRt�t|��}t|�}|�|�}t|| �} | �|| �j } t|| �} tj t|�ft d�}| || < ||| < t| �s�tjdtjd�}nf|j �r$tjt|�tjd�}t�t| ��|| < d|| < n.d|| < tjt| �|��tjd�}d|| < t | t��rtt| �j|| jd�} nt|| jd�} | ||fS )a� Create a new index with target's values (move/add/delete values as necessary) use with non-unique Index and a possibly non-unique target. Parameters ---------- target : an iterable Returns ------- new_index : pd.Index Resulting index. indexer : np.ndarray[np.intp] Indices of output values in original index. new_indexer : np.ndarray[np.intp] or None r N)r� r> )r� )r� )r! r r� r� �intpr� r6 r r, r r� r| r r� rH r� r� r� rs r� ) r� r� r� rP �checkZ new_labelsZ new_indexer�lengthZmissing_labelsZmissing_indexerZ cur_labelsZ cur_indexerrE r� r� r� �_reindex_non_unique s< zIndex._reindex_non_uniquer )r� r� r� c C s� t |�}t| t�}t|t�}|dkrH|s,|rH| j|jkr:n| j||d�S |dk rh|sX|rh| j|||d�S t|�dkr�|dkr�| �� }t� t� d�t|��} |d| fS t| �dkr�|dkr�|�� }t� t� d�t|��} || dfS | j |j k �r,ddd �� ||�}|j | ||d d �\}} } | | } } || | fS t| j|j��s`| �d �} |�d �}| j ||d d �S t|� | j�s�|j�s�| j||d�S | j�r�|j�s�| j�r�|j�r�| j||d�S | j||d�S nX| j�r |j�r t| t��r�tdd� | jD ���s y| j||d�S tk �r Y nX |dk�r,| }n>|dk�r<|}n.|dk�rV| j|dd�}n|dk�rj| �|�}|�rx|�� }|| k�r�d} n | � |�} ||k�r�d} n |� |�} || | fS )aH Compute join_index and indexers to conform data structures to the new index. Parameters ---------- other : Index how : {'left', 'right', 'inner', 'outer'} level : int or level name, default None return_indexers : bool, default False sort : bool, default False Sort the join keys lexicographically in the result Index. If False, the order of the join keys depends on the join type (how keyword). Returns ------- join_index, (left_indexer, right_indexer) N)r� r )r �outerr> )r� r( r r� )r� r T)r� r� r� �O)r� r� c s s | ]}t |�V qd S )N)r. )r� r� r� r� r� r� � s z Index.join.<locals>.<genexpr>�innerF)r� r( ) r! r� rH r� � _join_multir" r r r� rA r$ �_join_precedencer� r� r/ r� r� �_validate_join_methodr �_join_non_uniquer� �_join_monotonicr? Zdtypesr� r� r� r� r� )r� r� r� r� r� r� Z self_is_miZ other_is_mir� ZrindexerZlindexerr� r� r� r� r� r� r� N sv z Index.join)r� r� c C s� ddl m} ddlm} ttj| j� �}ttj|j� �}|j}|j}t |�} t |�} | | @ } | sht d��t | |��r*t ||��r*t | | |d�} t | | |d�} t | | �s�| }|�| j�}n| �| �}|�| �}|j||dd�\}}}| | }|| |||||�\}}}||||dd �}|�� }|||fS t| �d }d}t | |��rf|| } }d}d d d ��||�}|j�|�}| j|||d �}|�r�|d |d |d fS |S )Nr )rp )� restore_dropped_levels_multijoinz+cannot join with no overlapping index names)r� T)r� F)r� r� r� r� r r� )r� r )r� r� r� )r� rp �pandas.core.reshape.merger0 r� r� Znot_noner� r r� r� r� r� r Zreorder_levelsr� r� Zremove_unused_levelsr� r" ) r� r� r� rp r0 Zself_names_listZother_names_listZself_names_orderZother_names_orderZ self_namesZ other_names�overlapZ ldrop_namesZ rdrop_namesZ self_jnlevelsZother_jnlevelsZjoin_idxr� r� Z dropped_namesr� r� r� Zmulti_join_idx�jl� flip_orderr� r� r� r� r� r+ � sN zIndex._join_multiz$tuple[Index, np.ndarray, np.ndarray])r� r� r~ c C s� ddl m} | j|jks t�| �� }|�� }||g|g|dd�\}}t|�}t|�}t�|�|��}|dk} t� || |�|�� | � |�} | � | |�} | ||fS )Nr )�get_join_indexersT)r� r� r> ) r1 r5 r� r r� r, r� r� r6 r� r� �_wrap_joined_index) r� r� r� r5 ZlvaluesZrvaluesZleft_idxZ right_idx� join_arrayrp Zjoin_arrayliker� r� r� r� r. s zIndex._join_non_uniquez7tuple[MultiIndex, np.ndarray | None, np.ndarray | None])r� r� � keep_orderr~ c s� ddl m} ddd�dd�}t| |�r8t||�r8td��| | }}t| |� } | rn|| }}d d d ��||�}t||�s|t�|�|�}|j| } |js�t d ��| j ||d d�\} } } | dkr�|s�t |�dkr�d� |}n ||j d|d � �� |� }�n�t | �} t�| t | ��}|j | }||dk }|�|�}t|j �}|||< t|j�}| ||< |�r�tjt |�tjd�� ttj� �� |dk���� �sl�fdd�|D �}� � � n�|dk�rt |�dk�r�dn|�� }d| }t�||�\� }� |d d� � � fdd�|D �}nd|dk���� }|�s0�fdd�|D �}||d|d � �� � fdd�|D �}|�sl��� d � � ||||j dd�}| dk �r�| �|j | �}n |j | }| �r�|� � }� dk�r�dnt � �� |dk�r�dnt |�}|� |fS )ai The join method *only* affects the level of the resulting MultiIndex. Otherwise it just exactly aligns the Index data to the labels of the level in the MultiIndex. If ```keep_order == True```, the order of the data indexed by the MultiIndex will not be changed; otherwise, it will tie out with `other`. r )rp zlist[np.ndarray]z np.ndarray)r� r~ c S s� | d j dkr tjdtjd�S t| �dkr:tt| d ��S | d dd� | d dd� k}x0| dd� D ] }||dd� |dd� kO }qhW t�dg|dgf��� d }t | d �}t � |t|��S )aj Returns sorter for the inner most level while preserving the order of higher levels. Parameters ---------- labels : list[np.ndarray] Each ndarray has signed integer dtype, not necessarily identical. Returns ------- np.ndarray[np.intp] r )r� r� Nr> T) r� r� r� r$ r rd r, Zhstackr� r* r Zget_level_sorter)r� Ztic�labZstartsr� r� r� �_get_leaf_sorter> s z+Index._join_level.<locals>._get_leaf_sorterz9Join on level between two MultiIndex objects is ambiguousr r� )r� r z8Index._join_level on non-unique index is not implementedT)r� r� Nr� r> )r� c s g | ] }|� �qS r� r� )r� r9 )rp r� r� rK � s z%Index._join_level.<locals>.<listcomp>c s g | ] }|� �qS r� r� )r� r9 )r� r� r� rK � s c s g | ] }|� �qS r� r� )r� r9 )rp r� r� rK � s c s g | ] }|� �qS r� r� )r� r9 )r� r� r� rK � s F)r� r� r� r� ) r� rp r� r� r� r r� r� r r� r� r r� r, r Zget_reverse_indexerr6 r� r� r r$ r r� r� �max�libalgosZgroupsort_indexerr� r� )r� r� r� r� r8 rp r: r r� r4 Z old_levelZ new_levelZleft_lev_indexerZright_lev_indexerr� Z rev_indexerZ old_codesr� Z new_lev_codesr� r� Z max_new_levZngroups�countsZmask_allr� r� )r� rp r� r" . s� zIndex._join_levelc C sp |j | j kst�| �|�r4|dkr&|n| }|d d fS | jr�|jr�|dkr\| }d }| �|�}nf|dkrx|}|�| �}d }nJ|dkr�| �|�\}}}| �||�}n$|dkr�| �|�\}}}| �||�}nv|dkr�| �|�\}}}nP|dkr�|�| �\}}}n6|dk�r| �|�\}}}n|dk�r.| �|�\}}}| �||�}|d k�rHd nt |�}|d k�r^d nt |�}|||fS )Nr� r r* r( ) r� r r� r r� r� r6 r� r� r, )r� r� r� Z ret_indexr� r� r� r7 r� r� r� r/ � s> zIndex._join_monotonic)r� r� r� r~ c C sJ |j | j kst�t| t�r2| j|jkr,| jnd }n t| |�}| j||d�S )N)r� )r� r r� rH r� ra r )r� r� r� r� r� r� r� r6 � s zIndex._wrap_joined_indexc C s | j S )a Return an array representing the data in the Index. .. warning:: We recommend using :attr:`Index.array` or :meth:`Index.to_numpy`, depending on whether you need a reference to the underlying data or a NumPy array. Returns ------- array: numpy.ndarray or ExtensionArray See Also -------- Index.array : Reference to the underlying data. Index.to_numpy : A NumPy array representing the underlying data. )r� )r� r� r� r� r � s z Index.valuesrV c C s* | j }t|tj�r&ddlm} ||�}|S )Nr )r� )r� r� r� r� Zpandas.core.arrays.numpy_r� )r� r� r� r� r� r� r� s z Index.arrayc C s | j S )a The best array representation. This is an ndarray or ExtensionArray. ``_values`` are consistent between ``Series`` and ``Index``. It may differ from the public '.values' method. index | values | _values | ----------------- | --------------- | ------------- | Index | ndarray | ndarray | CategoricalIndex | Categorical | Categorical | DatetimeIndex | ndarray[M8ns] | DatetimeArray | DatetimeIndex[tz] | ndarray[M8ns] | DatetimeArray | PeriodIndex | ndarray[object] | PeriodArray | IntervalIndex | IntervalArray | IntervalArray | See Also -------- values : Values )r� )r� r� r� r� r� s z Index._valuesc C s | j S )zR Get the ndarray that we can pass to the IndexEngine constructor. )r� )r� r� r� r� r! 5 s zIndex._get_engine_targetc C s | � � S )zI Get the ndarray that we will pass to libjoin functions. )r! )r� r� r� r� r� = s zIndex._get_join_target)r� r~ c C s |S )z{ Cast the ndarray returned from one of the libjoin.foo_indexer functions back to type(self)._data. r� )r� r� r� r� r� r� C s zIndex._from_join_targetc C s" | j |d�}|| jj|d�7 }|S )N)rC )� _memory_usager Zsizeof)r� rC r� r� r� r� � memory_usageJ s zIndex.memory_usagec C s. t | t�rtd��tj|td�}| �| |�S )a� Replace values where the condition is False. The replacement is taken from other. Parameters ---------- cond : bool array-like with the same length as self Condition to select the values on. other : scalar, or array-like, default None Replacement if the condition is False. Returns ------- pandas.Index A copy of self with values replaced from other where the condition is False. See Also -------- Series.where : Same method for Series. DataFrame.where : Same method for DataFrame. Examples -------- >>> idx = pd.Index(['car', 'bike', 'train', 'tractor']) >>> idx Index(['car', 'bike', 'train', 'tractor'], dtype='object') >>> idx.where(idx.isin(['car', 'train']), 'other') Index(['car', 'other', 'train', 'other'], dtype='object') z1.where is not supported for MultiIndex operations)r� )r� rH r� r� r� r� r� )r� Zcondr� r� r� r� r R s ! z Index.wherec C s t | j� dt|�� d��S )Nz5(...) must be called with a collection of some kind, z was passed)r� r3 r� )r� r� r� r� r� r� { s zIndex._scalar_data_errorc C s t d��d S )NzMString dtype not supported, you may need to explicitly cast to a numeric type)r� )r� r� r� r� r� �_string_data_error� s zIndex._string_data_errorc C s t | j|�st�|S )a Check if the value can be inserted into our array without casting, and convert it to an appropriate native type if necessary. Raises ------ TypeError If the value cannot be inserted into an array of this dtype. )r& r� r� )r� rz r� r� r� �_validate_fill_value� s zIndex._validate_fill_valuec C s t |�s tdt|�j� ���|S )z Check that this is a scalar value that we can use for setitem-like operations without changing dtype. z"'value' must be a scalar, passed: )r: r� r� r3 )r� rz r� r� r� r� � s zIndex._require_scalarc C s dS )zO Indicates if an index is not directly backed by a numpy array Fr� )r� r� r� r� �_has_complex_internals� s z Index._has_complex_internalsc C s | � � S )zH Return a boolean if we need a qualified .info display. )rs )r� r� r� r� �_is_memory_usage_qualified� s z Index._is_memory_usage_qualified)r� r~ c C s || j kS )zN Whether the index type is compatible with the provided type. )rZ )r� r� r� r� r� �is_type_compatible� s zIndex.is_type_compatibler c C s2 t |� y || jkS tttfk r, dS X dS )a� Return a boolean indicating whether the provided key is in the index. Parameters ---------- key : label The key to check if it is present in the index. Returns ------- bool Whether the key search is in the index. Raises ------ TypeError If the key is not hashable. See Also -------- Index.isin : Returns an ndarray of boolean dtype indicating whether the list-like key is in the index. Examples -------- >>> idx = pd.Index([1, 2, 3, 4]) >>> idx Int64Index([1, 2, 3, 4], dtype='int64') >>> 2 in idx True >>> 6 in idx False FN)�hashr � OverflowErrorr� r� )r� r� r� r� r� � __contains__� s # zIndex.__contains__�__hash__c C s t d��d S )Nz)Index does not support mutable operations)r� )r� r� rz r� r� r� � __setitem__� s zIndex.__setitem__c C s� | j j}t|�r&tj|dd�}||�S t|t�rL||�}t| �j|| j d�S t� |�rdt j |t d�}||�}t|�s�t �|�dkr�t|� |S | jj|| j d�S |S dS )aA Override numpy.ndarray's __getitem__ method to work as desired. This function adds lists and Series as valid boolean indexers (ndarrays only supports ndarray with dtype=bool). If resulting ndim != 1, plain ndarray is returned instead of corresponding `Index` subclass. T)Z warn_float)r� )r� r� N)r� � __getitem__r: r� �cast_scalar_indexerr� r r� r� r� Zis_bool_indexerr� r� r� r� r_ r )r� r� r r� r� r� r� rJ � s zIndex.__getitem__)r� �slobjr~ c C s | j | }t| �j|| jd�S )zH Fastpath for __getitem__ when we know we have a slice. )r� )r� r� r� r� )r� rL r� r� r� r� �_getitem_slice s zIndex._getitem_slicec C s | � � s| �� r|| kS dS )a] Faster check for ``name in self`` when we know `name` is a Python identifier (e.g. in NDFrame.__getattr__, which hits this to support . key lookup). For indexes that can't hold identifiers (everything but object & categorical) we just return False. https://github.com/pandas-dev/pandas/issues/19764 F)rs r� )r� r� r� r� r� �$_can_hold_identifiers_and_holds_name s z*Index._can_hold_identifiers_and_holds_namezIndex | Sequence[Index]c C s| | g}t |ttf�r"|t|�7 }n |�|� x |D ]}t |t�s2td��q2W dd� |D �}t|�dkrjdn| j}| �||�S )z� Append a collection of Index options together. Parameters ---------- other : Index or list/tuple of indices Returns ------- Index zall inputs must be Indexc S s h | ] }|j �qS r� )r� )r� �objr� r� r� r$ E s z Index.append.<locals>.<setcomp>r� N) r� r� r� rd rs r� r r� �_concat)r� r� � to_concatrO r� r� r� r� r� rd , s z Index.appendz list[Index])rQ r� r~ c C s" dd� |D �}t |�}t||d�S )z5 Concatenate multiple Index objects. c S s g | ] }|j �qS r� )r� )r� rk r� r� r� rK N s z!Index._concat.<locals>.<listcomp>)r� )r@ rs )r� rQ r� Zto_concat_valsr� r� r� r� rP J s z Index._concatc C s� t | j|�\}}|r | �� S |dkr:| js4| jtkr:| j}y| �|�}W nJ tt fk r� } z(t | �rj|�| � |�}| � |�� ||�S d}~X Y nX | j�� }t||�� |�}t� |||� | �|�S )a Return a new Index of the values set with the mask. Returns ------- Index See Also -------- numpy.ndarray.putmask : Changes elements of an array based on conditional and input values. N)rT r� r� r� r� r| r< rA r� r� r9 r� r� r� rS �sumr� r )r� rp rz ZnoopZ convertedr5 r� r r� r� r� r� S s" z Index.putmaskc C sp | � |�rdS t|t�s dS t| j�r:t|j�s:|�| �S t|t�rN|�| �S t|j�rb|�| �S t| j |j �S )a Determine if two Index object are equal. The things that are being compared are: * The elements inside the Index object. * The order of the elements inside the Index object. Parameters ---------- other : Any The other object to compare against. Returns ------- bool True if "other" is an Index and it has the same elements and order as the calling index; False otherwise. Examples -------- >>> idx1 = pd.Index([1, 2, 3]) >>> idx1 Int64Index([1, 2, 3], dtype='int64') >>> idx1.equals(pd.Index([1, 2, 3])) True The elements inside are compared >>> idx2 = pd.Index(["1", "2", "3"]) >>> idx2 Index(['1', '2', '3'], dtype='object') >>> idx1.equals(idx2) False The order is compared >>> ascending_idx = pd.Index([1, 2, 3]) >>> ascending_idx Int64Index([1, 2, 3], dtype='int64') >>> descending_idx = pd.Index([3, 2, 1]) >>> descending_idx Int64Index([3, 2, 1], dtype='int64') >>> ascending_idx.equals(descending_idx) False The dtype is *not* compared >>> int64_idx = pd.Int64Index([1, 2, 3]) >>> int64_idx Int64Index([1, 2, 3], dtype='int64') >>> uint64_idx = pd.UInt64Index([1, 2, 3]) >>> uint64_idx UInt64Index([1, 2, 3], dtype='uint64') >>> int64_idx.equals(uint64_idx) True TF) r r� rs r9 r� r� rH r1 rM r� )r� r� r� r� r� r� x s ; z Index.equalsc s4 �� � �o2t� �fdd��jD ��o2t��t� �kS )z� Similar to equals, but checks that object attributes and types are also equal. Returns ------- bool If two Index objects have equal elements and same type True, otherwise False. c 3 s& | ] }t �|d �t � |d �kV qd S )N)r� )r� r# )r� r� r� r� r� � s z"Index.identical.<locals>.<genexpr>)r� r� r� r� )r� r� r� )r� r� r� � identical� s zIndex.identicalc C sR y| j |dd�}W n tk r( | jS X t|t�rF|�t| ��d }| | S dS )aB Return the label from the index, or, if not present, the previous one. Assuming that the index is sorted, return the passed index label if it is in the index, or return the previous index label if the passed one is not in the index. Parameters ---------- label : object The label up to which the method returns the latest index label. Returns ------- object The passed label if it is in the index. The previous label if the passed label is not in the sorted index or `NaN` if there is no such label. See Also -------- Series.asof : Return the latest value in a Series up to the passed index. merge_asof : Perform an asof merge (similar to left join but it matches on nearest key rather than equal key). Index.get_loc : An `asof` is a thin wrapper around `get_loc` with method='pad'. Examples -------- `Index.asof` returns the latest index label up to the passed label. >>> idx = pd.Index(['2013-12-31', '2014-01-02', '2014-01-03']) >>> idx.asof('2014-01-01') '2013-12-31' If the label is in the index, the method returns the passed label. >>> idx.asof('2014-01-02') '2014-01-02' If all of the labels in the index are later than the passed label, NaN is returned. >>> idx.asof('1999-01-02') nan If the index is not sorted, an error is raised. >>> idx_not_sorted = pd.Index(['2013-12-31', '2015-01-02', ... '2014-01-03']) >>> idx_not_sorted.asof('2013-12-31') Traceback (most recent call last): ValueError: index must be monotonic increasing or decreasing r )r� r> N)r� r� r< r� r r= r )r� r r� r� r� r� �asof� s 9 z Index.asof)r rp r~ c C sx | j | j|j dd�}t�|dk|d d�}tjt| �tjd�| �|�}tt | j |� � �}d||dk|j |k @ < |S )a� Return the locations (indices) of labels in the index. As in the `asof` function, if the label (a particular entry in `where`) is not in the index, the latest index label up to the passed label is chosen and its index returned. If all of the labels in the index are later than a label in `where`, -1 is returned. `mask` is used to ignore NA values in the index during calculation. Parameters ---------- where : Index An Index consisting of an array of timestamps. mask : np.ndarray[bool] Array of booleans denoting where values in the original data are not NA. Returns ------- np.ndarray[np.intp] An array of locations (indices) of the labels from the Index which correspond to the return values of the `asof` function for every element in `where`. r� )r r r� )r� r> ) r� � searchsortedr� r r r r$ r6 r r Zargmax)r� r rp Zlocsr� Z first_valuer� r� r� � asof_locs s zIndex.asof_locs�last)r� r� � na_positionr� c C s^ t | |�}t| t�s&t||||d�}n|�� }|s@|ddd� }| �|�}|rV||fS |S dS )a� Return a sorted copy of the index. Return a sorted copy of the index, and optionally return the indices that sorted the index itself. Parameters ---------- return_indexer : bool, default False Should the indices that would sort the index be returned. ascending : bool, default True Should the index values be sorted in an ascending order. na_position : {'first' or 'last'}, default 'last' Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at the end. .. versionadded:: 1.2.0 key : callable, optional If not None, apply the key function to the index values before sorting. This is similar to the `key` argument in the builtin :meth:`sorted` function, with the notable difference that this `key` function should be *vectorized*. It should expect an ``Index`` and return an ``Index`` of the same shape. .. versionadded:: 1.1.0 Returns ------- sorted_index : pandas.Index Sorted copy of the index. indexer : numpy.ndarray, optional The indices that the index itself was sorted by. See Also -------- Series.sort_values : Sort values of a Series. DataFrame.sort_values : Sort values in a DataFrame. Examples -------- >>> idx = pd.Index([10, 100, 1, 1000]) >>> idx Int64Index([10, 100, 1, 1000], dtype='int64') Sort values in ascending order (default behavior). >>> idx.sort_values() Int64Index([1, 10, 100, 1000], dtype='int64') Sort values in descending order, and also get the indices `idx` was sorted by. >>> idx.sort_values(ascending=False, return_indexer=True) (Int64Index([1000, 100, 10, 1], dtype='int64'), array([3, 1, 0, 2])) )�itemsr� rX r� Nr> )rc r� rH re �argsortr6 )r� r� r� rX r� r� Z_asZ sorted_indexr� r� r� r� D s @ zIndex.sort_valuesc O s t d��dS )z* Use sort_values instead. z=cannot sort an Index object in-place, use sort_values insteadN)r� )r� �argsr� r� r� r� r� � s z Index.sortc C s t dt| �j� ���dS )a� Shift index by desired number of time frequency increments. This method is for shifting the values of datetime-like indexes by a specified time increment a given number of times. Parameters ---------- periods : int, default 1 Number of periods (or increments) to shift by, can be positive or negative. freq : pandas.DateOffset, pandas.Timedelta or str, optional Frequency increment to shift by. If None, the index is shifted by its own `freq` attribute. Offset aliases are valid strings, e.g., 'D', 'W', 'M' etc. Returns ------- pandas.Index Shifted index. See Also -------- Series.shift : Shift values of Series. Notes ----- This method is only implemented for datetime-like index classes, i.e., DatetimeIndex, PeriodIndex and TimedeltaIndex. Examples -------- Put the first 5 month starts of 2011 into an index. >>> month_starts = pd.date_range('1/1/2011', periods=5, freq='MS') >>> month_starts DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01', '2011-04-01', '2011-05-01'], dtype='datetime64[ns]', freq='MS') Shift the index by 10 days. >>> month_starts.shift(10, freq='D') DatetimeIndex(['2011-01-11', '2011-02-11', '2011-03-11', '2011-04-11', '2011-05-11'], dtype='datetime64[ns]', freq=None) The default value of `freq` is the `freq` attribute of the index, which is 'MS' (month start) in this example. >>> month_starts.shift(10) DatetimeIndex(['2011-11-01', '2011-12-01', '2012-01-01', '2012-02-01', '2012-03-01'], dtype='datetime64[ns]', freq='MS') z\This method is only implemented for DatetimeIndex, PeriodIndex and TimedeltaIndex; Got type N)r� r� r3 )r� Zperiodsr) r� r� r� �shift� s 8z Index.shiftc O s | j j||�S )aK Return the integer indices that would sort the index. Parameters ---------- *args Passed to `numpy.ndarray.argsort`. **kwargs Passed to `numpy.ndarray.argsort`. Returns ------- np.ndarray[np.intp] Integer indices that would sort the index if used as an indexer. See Also -------- numpy.argsort : Similar method for NumPy arrays. Index.sort_values : Return sorted copy of Index. Examples -------- >>> idx = pd.Index(['b', 'a', 'd', 'c']) >>> idx Index(['b', 'a', 'd', 'c'], dtype='object') >>> order = idx.argsort() >>> order array([1, 0, 3, 2]) >>> idx[order] Index(['a', 'b', 'c', 'd'], dtype='object') )r� rZ )r� r[ r� r� r� r� rZ � s %z Index.argsort)�seriesc C sh t jdtdd� | �|� y| �|�}W n0 tk rX | �� sD� nt|�rR|}n� Y nX | �|||�S )z� Fast lookup of value from 1-dimensional ndarray. Only use this if you know what you're doing. Returns ------- scalar or Series zXget_value is deprecated and will be removed in a future version. Use Series[key] insteadr� )r� ) r� r� r� �_check_indexing_errorr� r� � _should_fallback_to_positionalr5 �_get_values_for_loc)r� r] r� r� r� r� r� � get_value s zIndex.get_valuec C s t |�st|��d S )N)r: r! )r� r� r� r� r� r^ * s zIndex._check_indexing_errorc C s | � � o| �� S )zA Should an integer key be treated as positional? )r� r� )r� r� r� r� r_ 0 s z$Index._should_fallback_to_positionalc C s t |�r|j| S |j| S )z� Do a positional lookup on the given Series, returning either a scalar or a Series. Assumes that `series.index is self` key is included for MultiIndex compat. )r5 r� r )r� r] r� r� r� r� r� r` 6 s zIndex._get_values_for_locc C s4 t jdtdd� | j�|�}t|j|� |||< dS )z� Fast lookup of value from 1-dimensional ndarray. .. deprecated:: 1.0 Notes ----- Only use this if you know what you're doing. zNThe 'set_value' method is deprecated, and will be removed in a future version.r� )r� N)r� r� r� r r� r) r� )r� r� r� rz r� r� r� r� r� D s zIndex.set_valuea� Compute indexer and mask for new index given the current index. The indexer should be then used as an input to ndarray.take to align the current data to the new index. Parameters ---------- target : %(target_klass)s Returns ------- indexer : np.ndarray[np.intp] Integers from 0 to n - 1 indicating that the index at these positions matches the corresponding target values. Missing values in the target are marked by -1. missing : np.ndarray[np.intp] An indexer into the target of the values not found. These correspond to the -1 in the indexer array. r� z tuple[np.ndarray, np.ndarray]c C s� t |�}| �|�s,t| j�s,| j|d dd�S | �|�\}}|| k sJ||k rT|�|�S t| j|j�s�| �|�}| j |dd�}|j |dd�}|�|�S |� � }| j �|�\}} t |�t | �fS )NF)r� rx )r� ) r! r� r6 r� r� r� r� r/ r� r� r! r r, ) r� r� r� r� r� r� r� Z tgt_valuesr� rP r� r� r� r� q s z Index.get_indexer_non_uniquec K s& | j r| j|f|�S | �|�\}}|S )z� Guaranteed return of an indexer even when non-unique. This dispatches to get_indexer or get_indexer_non_unique as appropriate. Returns ------- np.ndarray[np.intp] List of indices. )r� r� r� )r� r� r� r� r� r� r� r� r� � s zIndex.get_indexer_for.z Literal[True])r� rx r~ c C s d S )Nr� )r� r� r� rx r� r� r� r� � s z!Index._get_indexer_non_comparablezLiteral[False]c C s d S )Nr� )r� r� r� rx r� r� r� r� � s z*np.ndarray | tuple[np.ndarray, np.ndarray]c C s d S )Nr� )r� r� r� rx r� r� r� r� � s c C sf |dk r(t |�}td| j� d|j� ���dtj|jtjd� }|rF|S tjt|�tjd�}||fS dS )a Called from get_indexer or get_indexer_non_unique when the target is of a non-comparable dtype. For get_indexer lookups with method=None, get_indexer is an _equality_ check, so non-comparable dtypes mean we will always have no matches. For get_indexer lookups with a method, get_indexer is an _inequality_ check, so non-comparable dtypes mean we will always raise TypeError. Parameters ---------- target : Index method : str or None unique : bool, default True * True if called from get_indexer. * False if called from get_indexer_non_unique. Raises ------ TypeError If doing an inequality check, i.e. method is not None. NzCannot compare dtypes z and r> )r� ) r� r� r� r� �ones�shaper$ r r )r� r� r� rx r� Z no_matchesrP r� r� r� r� � s c C s | j S )z� Whether we should treat this as unique for the sake of get_indexer vs get_indexer_non_unique. For IntervalIndex compat. )r )r� r� r� r� r� � s zIndex._index_as_uniquez8Reindexing only valid with uniquely valued Index objectsztuple[Index, Index]c C sB t | t�rLt |t�rL| jdk rJ|jdk rJt| j|j�sJ| �d�|�d�fS n�| jdkr�t |t�r�yt|�| �|fS tk r� | |fS X n�| jdkr�t |t�r�t|�| �|fS | jdkr�t | j �s�| � d�|� d�fS n:| j j dk�r|j j dk�r|� � d k�r| |� | j �fS t | j ��s:t |j ��r:|�| �\}} | |fS ) z� When dealing with an object-dtype Index and a non-object Index, see if we can upcast the object-dtype one to improve performance. N�UTC�date� timedeltar� r| r� r� r )r� rG r� r Z tz_convertrZ r� r rK r9 r� r� r� �minr� )r� r� r� r� r� r� � s* zIndex._maybe_promotec C s� t | j�r0t|| j�r0td| �} ttj| jd�S t|dd�\}}| jdksR|dkrnt | j�sdt |�rnt�d�S t | j|g�}|j dkr�t |t �r�t|j�r�|jr�t�tj�}|j dkr�t�t�}|S ) zk Implementation of find_common_type that adjusts for Index-specific special cases. ro )�closedT)r> Zuint64r| )r� r� r# )r6 r� rN r rD r� Zfloat64rh r( r; r' r� r� rs r. r� r| )r� r� Z target_dtyper� r� r� r� r� r� s" z Index._find_common_type_compatc C sD |� � r| �� s | � � r$|�� r$dS t|�}|j}| �|�pBt|�S )zK Check if `self == other` can ever have non-False entries. F)r� r� r� r� �_is_comparable_dtyper9 )r� r� r� r� r� r� r� : s zIndex._should_compare)r� r~ c C s dS )zF Can we compare values of the given dtype to our own? Tr� )r� r� r� r� r� ri L s zIndex._is_comparable_dtypez PrettyDict[Hashable, np.ndarray]c s> t |t�r|j}t|�}|�� }� fdd�|�� D �}t|�S )a Group the index labels by a given array of values. Parameters ---------- values : array Values used to determine the groups. Returns ------- dict {group name -> group labels} c s i | ]\}}� � |�|�qS r� )r6 )r� r rJ )r� r� r� r i s z!Index.groupby.<locals>.<dictcomp>)r� rH r� rU Z_reverse_indexerrY rg )r� r r� r� )r� r� r R s z Index.groupbyc C s� ddl m} | j||d�}| �� }|jr~t|d t�r~t| |�rH| j}n(|�d�rl|�d�gt |d � }nd}|j ||d�S d|d< |js�| j |d < t |f|�S ) al Map values using input correspondence (a dict, Series, or function). Parameters ---------- mapper : function, dict, or Series Mapping correspondence. na_action : {None, 'ignore'} If 'ignore', propagate NA values, without passing them to the mapping correspondence. Returns ------- applied : Union[Index, MultiIndex], inferred The output of the mapping function applied to the index. If the function returns a tuple with more than one element a MultiIndex will be returned. r )rp )� na_actionr� N)r� Fr� r� ) r� rp Z _map_valuesr r� r� r� r� r� r r� r� rs )r� r� rj rp r4 � attributesr� r� r� r� re m s z Index.mapc st t | t�rN�dk r(� �fdd�| D �}n� fdd�| D �}t| �j|| jd�S � fdd�| D �}t|| jdd�S dS ) z� Apply function to all values found in index. This includes transforming multiindex entries separately. Only apply function to one level of the MultiIndex if level is specified. Nc s( g | ] }t � �fd d�t|�D ���qS )c 3 s& | ] \}}|�kr� |�n|V qd S )Nr� )r� r� �y)�funcr� r� r� r� � s z4Index._transform_index.<locals>.<listcomp>.<genexpr>)r� r� )r� rk )rm r� r� r� rK � s z*Index._transform_index.<locals>.<listcomp>c s" g | ]}t � fd d�|D ���qS )c 3 s | ]}� |�V qd S )Nr� )r� rl )rm r� r� r� � s z4Index._transform_index.<locals>.<listcomp>.<genexpr>)r� )r� rk )rm r� r� rK � s )r� c s g | ] }� |��qS r� r� )r� rk )rm r� r� rK � s F)r� r� )r� rH r� r� r� rs r� )r� rm r� rY r� )rm r� r� �_transform_index� s zIndex._transform_indexc C s |dk r| � |� t�| j|�S )a Return a boolean array where the index values are in `values`. Compute boolean array of whether each index value is found in the passed set of values. The length of the returned boolean array matches the length of the index. Parameters ---------- values : set or list-like Sought values. level : str or int, optional Name or position of the index level to use (if the index is a `MultiIndex`). Returns ------- np.ndarray[bool] NumPy array of boolean values. See Also -------- Series.isin : Same for Series. DataFrame.isin : Same method for DataFrames. Notes ----- In the case of `MultiIndex` you must either specify `values` as a list-like object containing tuples that are the same length as the number of levels, or specify `level`. Otherwise it will raise a ``ValueError``. If `level` is specified: - if it is the name of one *and only one* index level, use that level; - otherwise it should be a number indicating level position. Examples -------- >>> idx = pd.Index([1,2,3]) >>> idx Int64Index([1, 2, 3], dtype='int64') Check whether each index value in a list of values. >>> idx.isin([1, 4]) array([ True, False, False]) >>> midx = pd.MultiIndex.from_arrays([[1,2,3], ... ['red', 'blue', 'green']], ... names=('number', 'color')) >>> midx MultiIndex([(1, 'red'), (2, 'blue'), (3, 'green')], names=['number', 'color']) Check whether the strings in the 'color' level of the MultiIndex are in a list of colors. >>> midx.isin(['red', 'orange', 'yellow'], level='color') array([ True, False, False]) To check across the levels of a MultiIndex, pass a list of tuples: >>> midx.isin([(1, 'red'), (3, 'red')]) array([ True, False, False]) For a DatetimeIndex, string values in `values` are converted to Timestamps. >>> dates = ['2000-03-11', '2000-03-12', '2000-03-13'] >>> dti = pd.to_datetime(dates) >>> dti DatetimeIndex(['2000-03-11', '2000-03-12', '2000-03-13'], dtype='datetime64[ns]', freq=None) >>> dti.isin(['2000-03-11']) array([ True, False, False]) N)r� r �isinr� )r� r r� r� r� r� ro � s Q z Index.isin)r� c C s t �d S )N)r� )r� r� r� r� r� �_get_string_slice s zIndex._get_string_slice)r� �endr r� r~ c C s@ | j |||d�\}}t|�s$td��t|�s4td��t|||�S )a$ Compute the slice indexer for input labels and step. Index needs to be ordered and unique. Parameters ---------- start : label, default None If None, defaults to the beginning. end : label, default None If None, defaults to the end. step : int, default None kind : str, default None Returns ------- indexer : slice Raises ------ KeyError : If key does not exist, or key is not unique and index is not ordered. Notes ----- This function assumes that the data is sorted, so use at your own peril Examples -------- This is a method on all index types. For example you can do: >>> idx = pd.Index(list('abcd')) >>> idx.slice_indexer(start='b', end='c') slice(1, 3, None) >>> idx = pd.MultiIndex.from_arrays([list('abcd'), list('efgh')]) >>> idx.slice_indexer(start='b', end=('c', 'g')) slice(1, 3, None) )r z Start slice bound is non-scalarz End slice bound is non-scalar)� slice_locsr: r r )r� r� rq r r� � start_slice� end_slicer� r� r� r s .zIndex.slice_indexerc C s | � � st�|�S |S )zx If we have a float key and are not a floating index, then try to cast to an int if equivalent. )r� r� rK )r� r� r� r� r� r� ? s zIndex._maybe_cast_indexerc C s t |�S )zT Analogue to maybe_cast_indexer for get_indexer instead of get_loc. )r! )r� r� r� r� r� r� H s z"Index._maybe_cast_listlike_indexer)r r� c C s, |dks t �|dk r(t|�s(| �||��dS )zz If we are positional indexer, validate that we have appropriate typed bounds must be an integer. )r r N)r r5 r )r� r r� r� r� r� r� r N s zIndex._validate_indexer)r c C sL |dddt gkst�| �|dd� t|�s2t|�rH|| jkrH| �d|��|S )a� This function should be overloaded in subclasses that allow non-trivial casting on label-slice bounds, e.g. datetime-like indices allowing strings containing formatted datetimes. Parameters ---------- label : object side : {'left', 'right'} kind : {'loc', 'getitem'} or None Returns ------- label : object Notes ----- Value of `side` parameter should be validated in caller. r� r Nr� �_maybe_cast_slice_boundr )r r �_deprecated_argr2 r5 r� r )r� r r r� r� r� r� ru Y s z Index._maybe_cast_slice_boundc C sV | j r| j||d�S | jrJ| d d d� j||dkr6dndd�}t| �| S td��d S )N)r r> r r� z0index must be monotonic increasing or decreasing)r� rU r� r r� )r� r r �posr� r� r� r y s z Index._searchsorted_monotonic)r r~ c C s. |dks t �|dkr"td|� ���|}| �||�}y| �|�}W nH tk r� } z*y | �||�S tk rv |�Y nX W dd}~X Y nX t|tj�r�t |�r�t � |� d��}n t � |jtjdd�t| ��}t|tj�r�td|� d t|�� ���t|t��r|d k�r |jS |jS n|d k�r&|d S |S dS ) a� Calculate slice bound that corresponds to given label. Returns leftmost (one-past-the-rightmost if ``side=='right'``) position of given label. Parameters ---------- label : object side : {'left', 'right'} kind : {'loc', 'getitem'} or None Returns ------- int Index of label. )r� r N)r r� z@Invalid value for side kwarg, must be either 'left' or 'right': N�u1F)r� z Cannot get z# slice bound for non-unique label: r r� r� )r r� ru r� r� r r� r� r� r- r Zmaybe_booleans_to_slicer2 Zmaybe_indices_to_slicer� r$ r r� r r� r )r� r r r� Zoriginal_labelZslcr5 r� r� r� �get_slice_bound� s8 zIndex.get_slice_boundc C s |dkp|dk}|s || }}t |ttf�r~t |ttf�r~yt|�}t|�}W n ttfk rf Y nX t|j|j�s~td��d}|dk r�| �|d�}|dkr�d}d} |dk r�| �|d�} | dkr�t | �} |�s |d | d } }| dkr�| t | �8 } |dk�r |t | �8 }|| fS )a� Compute slice locations for input labels. Parameters ---------- start : label, default None If None, defaults to the beginning. end : label, default None If None, defaults to the end. step : int, defaults None If None, defaults to 1. kind : {'loc', 'getitem'} or None Returns ------- start, end : int See Also -------- Index.get_loc : Get location for a single label. Notes ----- This method only works if the index is monotonic or unique. Examples -------- >>> idx = pd.Index(list('abcd')) >>> idx.slice_locs(start='b', end='c') (1, 3) Nr z(Both dates must have the same UTC offsetr r� r� r> ) r� r� r r r� r� r �tzinfory r ) r� r� rq r r� �incZts_startZts_endrs rt r� r� r� rr � s8 zIndex.slice_locsc C s" t �| j|�}t| �j|| jd�S )a� Make new Index with passed location(-s) deleted. Parameters ---------- loc : int or list of int Location of item(-s) which will be deleted. Use a list of locations to delete more than one value at the same time. Returns ------- Index Will be same type as self, except for RangeIndex. See Also -------- numpy.delete : Delete any rows and column from NumPy array (ndarray). Examples -------- >>> idx = pd.Index(['a', 'b', 'c']) >>> idx.delete(1) Index(['a', 'c'], dtype='object') >>> idx = pd.Index(['a', 'b', 'c']) >>> idx.delete([0, 2]) Index(['b'], dtype='object') )r� )r� �deleter� r� r� r� )r� r� rB r� r� r� r| $ s z Index.delete)r� r~ c C s� t �|�}t|| j�r&| jtkr&| j}y| �|�}W n< tk rp t|�\}}t | j|g�}| � |�� ||�S X t � | �}t|g| jd�j}t �|d|� |||d� f�}t|| jd�S )a Make new Index inserting new item at location. Follows Python list.append semantics for negative values. Parameters ---------- loc : int item : object Returns ------- new_index : Index )r� N)r� )r r* rN r� r| r< rA r� r( r' r� �insertr� r� rs r� Z concatenater� )r� r� r� �inferredr� r� r� r� r� r� r� r} D s z Index.insert�raise)�errorsr~ c C sh | j dkrdnd}tj||d�}| �|�}|dk}|�� r^|dkrTt|| � d���|| }| �|�S )a� Make new Index with passed list of labels deleted. Parameters ---------- labels : array-like errors : {'ignore', 'raise'}, default 'raise' If 'ignore', suppress error and existing labels are dropped. Returns ------- dropped : Index Will be same type as self, except for RangeIndex. Raises ------ KeyError If not all of the labels are found in the selected axis r| N)r� r> �ignorez not found in axis)r� r� Zindex_labels_to_arrayr� r? r� r| )r� r� r� Z arr_dtyper� rp r� r� r� �dropg s z Index.dropc C sp | � |�rv|tjtjtjhkrPtjt| �td�}| j rLt | t �sLd|| � � < |S |tj tjtjhkrvtjt| �td�S t |tjtttf�r�t| �t|�kr�td��t |t �s�t|dd�}n t�|�}t| j��rt |t��rtjdd�� || j|�}W dQ R X njt| j��rDt | t ��sDtjdd�� t � || j|�}W dQ R X n(tjdd�� t � | j||�}W dQ R X |S ) zA Wrapper used to dispatch comparison operations. )r� Fz Lengths must match to compareT)Z extract_numpyr� )r� N) r r �eqr �ger� rb r r� r� r� rH rO �ner �gtr� r� rs rJ rV r� r] r� r9 r� Zerrstater� rQ Zcomp_method_OBJECT_ARRAYZ comparison_op)r� r� r r� r� r� r� r� � _cmp_method� s0 zIndex._cmp_methodc C sD ddl m} ||| �|�}t|t�r<t|d �t|d �fS t|�S )zA Wrapper used to dispatch arithmetic operations. r )rr r� )r� rr r� r� rs )r� r� r rr r� r� r� r� � _arith_method� s zIndex._arith_methodc C s || j �}t|| jd�S )N)r� )r� rs r� )r� r r� r� r� r� � _unary_method� s zIndex._unary_methodc C s | � tj�S )N)r� r r )r� r� r� r� �__abs__� s z Index.__abs__c C s | � tj�S )N)r� r �neg)r� r� r� r� �__neg__� s z Index.__neg__c C s | � tj�S )N)r� r rw )r� r� r� r� �__pos__� s z Index.__pos__c C s | � dd� �S )Nc S s | S )Nr� )rk r� r� r� r � r z Index.__inv__.<locals>.<lambda>)r� )r� r� r� r� �__inv__� s z Index.__inv__c O s" t �||� | �d� t�| j�S )at Return whether any element is Truthy. Parameters ---------- *args Required for compatibility with numpy. **kwargs Required for compatibility with numpy. Returns ------- any : bool or array-like (if axis is specified) A single element array-like may be converted to bool. See Also -------- Index.all : Return whether all elements are True. Series.all : Return whether all elements are True. Notes ----- Not a Number (NaN), positive infinity and negative infinity evaluate to True because these are not equal to zero. Examples -------- >>> index = pd.Index([0, 1, 2]) >>> index.any() True >>> index = pd.Index([0, 0, 0]) >>> index.any() False r? )r: Z validate_any� _maybe_disable_logical_methodsr� r? r )r� r[ r� r� r� r� r? � s $ z Index.anyc O s" t �||� | �d� t�| j�S )a� Return whether all elements are Truthy. Parameters ---------- *args Required for compatibility with numpy. **kwargs Required for compatibility with numpy. Returns ------- all : bool or array-like (if axis is specified) A single element array-like may be converted to bool. See Also -------- Index.any : Return whether any element in an Index is True. Series.any : Return whether any element in a Series is True. Series.all : Return whether all elements in a Series are True. Notes ----- Not a Number (NaN), positive infinity and negative infinity evaluate to True because these are not equal to zero. Examples -------- **all** True, because nonzero integers are considered True. >>> pd.Index([1, 2, 3]).all() True False, because ``0`` is considered False. >>> pd.Index([0, 1, 2]).all() False **any** True, because ``1`` is considered True. >>> pd.Index([0, 0, 1]).any() True False, because ``0`` is considered False. >>> pd.Index([0, 0, 0]).any() False r� )r: Z validate_allr� r� r� r )r� r[ r� r� r� r� r� � s 5 z Index.all)�opnamec C sB t | t�s2t| j�s2t| j�s2t| j�s2t| j�r>t|�| � dS )zK raise if this Index subclass does not support any or all. N)r� rH r= r� r6 r. r3 rb )r� r� r� r� r� r� 9 s z$Index._maybe_disable_logical_methodsr c C s t | �fS )zE Return a tuple of the shape of the underlying data. )r )r� r� r� r� rc H s z Index.shape)r� � methodnamer~ c C s* |t k r&tjd|� d|� d�tdd� dS )zK Issue a FutureWarning if the arg/kwarg is not no_default. �'z' argument in zH is deprecated and will be removed in a future version. Do not pass it.� )r� N)r r� r� r� )r� rz r� r� r� r� r� rv Q s zIndex._deprecated_arg)NNFNT)N)N)N)r. )N)T)r TN)N)NFNN)N)N)FNr^ )r^ )N)ru N)N)NN)TN)NNF)N)NF)F)NTN)r )N)NN)r? )N)r )r )N)F)F)N)NN)NN)NNN)NNN)NN)NN)N)NNNN)r NFF)r )r T)r )F)N)FTrW N)r� N).)T)T)N)N)N)NNNN)r )N)NNNN)r ( r3 � __module__� __qualname__�__doc__r[ r� rZ � frozenset�__annotations__r, r r� r� r� r� r� r� r� r� r� r� r� r� r� �libindexZ ObjectEnginer� Z!_supports_partial_string_indexingZ _accessorsrR rf r� r� � classmethodr� r� �propertyr r� r# r r r r r r r r r r r r r& r( r� r- r� r0 r2 r� r{ r" rz r6 r; rA r� rF rH rT rQ rV rO rP r] rh rf rr rq rw rx ry r r� �setterrD r r� r� r$ r� r� r r� r� r� r� r� Zget_level_valuesr� r� r� r� r� r� r� r� r r� r� r5 r� r� rs r� r� r� r� rZ r� r� r\ r� r� r� r< r� r� rO Zisnullr� Znotnullr� r� rx r� ry r� r� r� r� r� r� �__bool__r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r# r' r� r� r+ r. r" r/ r6 r r% r� r� r! r� r� r> r? r r� r@ rA r� rB rC rD rG rI rJ rM rN rd rP r� r� rS rT rV r� r� r\ rZ ra r^ r_ r` r� r� r� r r� r� r� r� r� r� ri r re rn ro rp r r� r� r ru r ry rr r| r} r� r� r� r� r� r� r� r� r? r� r� rc rv � __classcell__r� r� )r� r� rs � sZ + yL G< / & ?> n 6 !'3- $$,,),"& 8- $3 ; B 3 2 T k $: " ")"" F 6L rJ " + ( , , %OB' N='' + & & ))+U &3 DY #! ) , =c C sJ ddl m} t| �dkr8|dk r(|d }t| d |d�S |j| |d�S dS )a� Construct an index from sequences of data. A single sequence returns an Index. Many sequences returns a MultiIndex. Parameters ---------- sequences : sequence of sequences names : sequence of str Returns ------- index : Index or MultiIndex Examples -------- >>> ensure_index_from_sequences([[1, 2, 3]], names=["name"]) Int64Index([1, 2, 3], dtype='int64', name='name') >>> ensure_index_from_sequences([["a", "a"], ["a", "b"]], names=["L1", "L2"]) MultiIndex([('a', 'a'), ('a', 'b')], names=['L1', 'L2']) See Also -------- ensure_index r )rp r� N)r� )r� )r� rp r rs � from_arrays)� sequencesr� rp r� r� r� �ensure_index_from_sequences_ s r� FzAnyArrayLike | Sequencer� )� index_liker� r~ c C s� t | t�r|r| �� } | S t | t�r8| j}t| ||d�S t| �rHt| �} t | t�r�t| �tk rft| �} t| �r�t � | �r�ddl m } |� | �S t| |dd�S n t| |d�S dS )ak Ensure that we have an index from some index-like object. Parameters ---------- index_like : sequence An Index or other sequence copy : bool, default False Returns ------- index : Index or MultiIndex See Also -------- ensure_index_from_sequences Examples -------- >>> ensure_index(['a', 'b']) Index(['a', 'b'], dtype='object') >>> ensure_index([('a', 'a'), ('b', 'c')]) Index([('a', 'a'), ('b', 'c')], dtype='object') >>> ensure_index([['a', 'a'], ['b', 'c']]) MultiIndex([('a', 'b'), ('a', 'c')], ) )r� r� r )rp F)r� r� )r� N)r� rs r� rJ r� r7 r� r� r r Zis_all_arrayliker� rp r� )r� r� r� rp r� r� r� r! � s" r! c C s. y t | � W n tk r$ t| �S X | S dS )z< If seq is an iterator, put its values into a list. N)r r� r� )�seqr� r� r� r � s r z list[str])�stringsr~ c C s: | s| S x,t | �r4t dd� | D ��r4dd� | D �} q W | S )z� Trims zeros and decimal points. Examples -------- >>> trim_front([" a", " b"]) ['a', 'b'] >>> trim_front([" a", " "]) ['a', ''] c s s | ]}|d dkV qdS )r rU Nr� )r� rk r� r� r� r� � s z trim_front.<locals>.<genexpr>c S s g | ]}|d d� �qS )r� Nr� )r� rk r� r� r� rK � s z trim_front.<locals>.<listcomp>)r� )r� r� r� r� ro � s ro r� )r� r~ c C s | dkrt d| � ���d S )N)r r� r* r( z do not recognize join method )r� )r� r� r� r� r- � s r- r' rq )�nr~ c C s ddl m} |d| d d�S )Nr )rq )r� )r� rq )r� rq r� r� r� � default_index� s r� r )r~ c C s8 | dkr t |ttf�r |j} t| �s4t|j� d���| S )zR If no name is passed, then extract it from data, validating hashability. Nz .name must be a hashable type)r� rs rJ r� r4 r� r3 )r� rO r� r� r� r� r� � s r� r )r� r~ c C s8 t j| ddddt�d�d�}|jjdkr,| S t|�}|S )z� If we have an arraylike input but no passed dtype, try to infer a supported dtype. Parameters ---------- subarr : np.ndarray[object] Returns ------- np.ndarray or ExtensionArray Tzdatetime64[ns])Zconvert_datetimeZconvert_timedeltaZconvert_periodZconvert_intervalZdtype_if_all_nat)�br# )r rm r� r� r� r\ )r� r� r� r� r� r� � s r� ztuple[Hashable, ...])�indexesr~ c G s6 dd� | D �}dd� t |� D �}tdd� |D ��}|S )z� Return common name if all indices agree, otherwise None (level-by-level). Parameters ---------- indexes : list of Index objects Returns ------- list A list representing the unanimous 'names' found. c S s g | ]}t |j��qS r� )r� r� )r� r� r� r� r� rK & s z'get_unanimous_names.<locals>.<listcomp>c S s g | ] }|��qS r� r� )r� �nsr� r� r� rK ' s c s s& | ] }t |�d kr|�� ndV qdS )r� N)r r� )r� r� r� r� r� r� ( s z&get_unanimous_names.<locals>.<genexpr>)r r� )r� Z name_tupsZ name_setsr� r� r� r� �get_unanimous_names s r� )r� r~ c C s | j }t|�r|jS | S )z� When checking if our dtype is comparable with another, we need to unpack CategoricalDtype to look at its categories.dtype. Parameters ---------- other : Index Returns ------- Index )r� r. r[ )r� r� r� r� r� r� , s r� c C sT |d krPyt �| �} W n8 tk rN } ztj|� d�tdd� W d d }~X Y nX | S )Nz2, sort order is undefined for incomparable objects� )r� )r Z safe_sortr� r� r� �RuntimeWarning)r� r� r5 r� r� r� r� A s r� )N)F)�� __future__r r r� � itertoolsr r �typingr r r r r r r r r� �numpyr� Z pandas._libsr r< r r� r Zpandas._libs.joinZ_libsr� r� Zpandas._libs.libr r Zpandas._libs.tslibsr r r r r Zpandas._typingr r r r r r r r Zpandas.compat.numpyr r: Z pandas.errorsr r! Zpandas.util._decoratorsr" r# r$ r% Zpandas.core.dtypes.castr& r' r( r) Zpandas.core.dtypes.commonr* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> r? Zpandas.core.dtypes.concatr@ Zpandas.core.dtypes.dtypesrA rB rC rD rE rF Zpandas.core.dtypes.genericrG rH rI rJ rK Z pandas.core.dtypes.inferencerL Zpandas.core.dtypes.missingrM rN rO Z pandas.corerP rQ Zpandas.core.accessorrR Zpandas.core.algorithms�coreZ algorithmsZ pandas.core.array_algos.putmaskrS rT r� rU rV Z pandas.core.arrays.datetimesrW rX Zpandas.core.arrays.sparserY Zpandas.core.baserZ r[ Zpandas.core.common�commonr� Zpandas.core.constructionr\ r] r^ Zpandas.core.indexersr_ Zpandas.core.indexes.frozenr` Zpandas.core.opsra Zpandas.core.ops.invalidrb Zpandas.core.sortingrc rd re Zpandas.core.stringsrf Zpandas.io.formats.printingrg rh ri rj rk rl r� rm rn ro rp rq rr �__all__r� Z_unsortable_typesrz r� r{ r� r� r� Z_o_dtyper� r� r� r� rs r� r! r ro r- r� r� r� r� r� r� r� r� r� r� �<module> s� ( ( ` (<
| ver. 1.4 |
Github
|
.
| PHP 8.3.23 | Генерация страницы: 0.05 |
proxy
|
phpinfo
|
Настройка