3
���h � � @ s� d dl m Z d dlmZ d dlZd dlmZ d dlmZmZm Z m
Z
m Z m Z m
Z
mZ d dlZd dlZd dlmZmZmZ d dljjZd dl m Z m Z d dl m Z m!Z! d d l"m#Z# d d
l$m%Z% d d l&m'Z'm(Z( d d l)m*Z* d d
l+m,Z- d dl.m/Z/ d dl0m1Z1m2Z2m3Z3m4Z4 d dl5m6Z7 d dl8m9Z9m:Z: d dl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZS d dlTmUZU d dlVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_ d dl`maZambZb d dlcmdZd d dlemfZf d dlgjhjiZd dljmkZkmlZl d dlmmnZnmoZo d dlpmqZqmrZr d dlsjhjtZud dlvmwZw d d lxmyZy d dlzjhj{Z{d d l|m}Z} d d l~mZ d d l�m�Z� d d l�m�Z� d d!l�m�Z�m�Z�m�Z�m�Z�m�Z� e�r�d d"l�m�Z� d#gZ�e�dM�Z�e�d#d&d#d&d#d'd(�Z�e�� Z�e�Z�d)d*� Z�d+d,� Z�ej�e��Z�e�Z�d-d.� Z�G d/d#� d#eqer�Z�e�j�� e�j�� e�j�� dNd0d1�Z�dOe�d�d3d4�Z�d5d6� Z�e e� e e� d7�d8d9�Z�e�d:�d;d<�Z�d=d>� Z�e(d?�d@dA�Z�ej�ej�e�ej�dB�dCdD�Z�dEdF� Z�ej�e�ej�ej�dG�dHdI�Z�e�e(dJ�dKdL�Z�dS )P� )�copy)�datetimeN)�dedent)�
TYPE_CHECKING�Any�Callable� FrozenSet�Hashable�List�Optional�Union)�algos�index�lib)�is_datetime_array�
no_default)�OutOfBoundsDatetime� Timestamp)�IncompatibleFrequency)�
tz_compare)�DtypeObj�Label)�set_function_name)�function)�InvalidIndexError)�Appender� Substitution�cache_readonly�doc)�concat)�maybe_cast_to_integer_array�validate_numeric_casting)� ensure_int64�
ensure_object�ensure_platform_int�is_bool�
is_bool_dtype�is_categorical_dtype�is_datetime64_any_dtype�is_dtype_equal�is_extension_array_dtype�is_float�is_float_dtype� is_hashable�
is_integer�is_integer_dtype�is_interval_dtype� is_iterator� is_list_like�is_object_dtype�is_period_dtype� is_scalar�is_signed_integer_dtype�is_timedelta64_dtype�is_unsigned_integer_dtype� pandas_dtype)�
concat_compat) �ABCCategorical� ABCDataFrame�ABCDatetimeIndex�
ABCMultiIndex�ABCPandasArray�ABCPeriodIndex�
ABCRangeIndex� ABCSeries�ABCTimedeltaIndex)�array_equivalent�isna)�ops)�CachedAccessor)� Categorical�ExtensionArray)� tz_to_dtype�validate_tz_from_dtype)�
IndexOpsMixin� PandasObject)�deprecate_ndim_indexing)�
FrozenList)�get_op_result_name)�make_invalid_op)�ensure_key_mapped)�
StringMethods)�
PrettyDict�default_pprint�format_object_attrs�format_object_summary� pprint_thing)�Series�Index�mixed�
mixed-integer� z
np.ndarray)�klass�inplaceZ target_klassZraises_section�unique�
duplicatedc s& � fdd�}d� j � d�}t|||�S )Nc sd t |tjtttf�r6|jdkr6t| �t|�kr6td��t | j
�rht |t �rht |�| j
|j
d�}� ||�S t | j
�r�t |t�r�tjdd�� � | j
|�}W d Q R X n�t | j
�r�t | t� r�tjdd�� tj� | j
|�}W d Q R X nft| j
��rtjdd�� � | j
tj|��}W d Q R X n.tjdd�� tj| j
tj|�� �}W d Q R X t|��rV|S tj| |� �S )Nr z Lengths must match to compare)�dtype�ignore)�all)�
isinstance�np�ndarrayrZ rB rI �ndim�len�
ValueErrorr3 rb r; �type�_valuesZerrstater> rF Zcomp_method_OBJECT_ARRAYr0 �asarrayZ
comparison_opr& Zinvalid_comparison)�self�other�left�result)�op� �:/tmp/pip-build-5_djhm0z/pandas/pandas/core/indexes/base.py�
cmp_methodx s(
z'_make_comparison_op.<locals>.cmp_method�__)�__name__r )rr �clsru �namers )rr rt �_make_comparison_opw s rz c s& � fdd�}d� j � d�}t|||�S )Nc sX t |tttf�rtS ddlm} � || �|�}t |t�rPt|d �t|d �fS t|�S )Nr )rY � ) re rB r< rC �NotImplemented�pandasrY �tuplerZ )rn ro rY rq )rr rs rt �index_arithmetic_method� s
z4_make_arithmetic_op.<locals>.index_arithmetic_methodrv )rw r )rr rx r ry rs )rr rt �_make_arithmetic_op� s r� c C sX t | t�r"ddlm} || f|�S t | t�rJd|krJd|krJ|jd�|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)�
issubclassr@ Zpandas.core.indexes.periodr� r> �pop�__new__)rx �dr� rs rs rt �
_new_Index� s
r� c s� e Zd ZU dZejejB eddg�B Zee dZ
dd� Z dd� Z d d
� Z
d d � Zd
Zeeejf dZdZedZedgZdgZdZ dZ dZ e j Z!dZ"dhZ#e$de%�Z �d�d d�dd�Z&e'dd� �Z(e)�d�ed�dd��Z*e+dd � �Z,d d � Z-de.fed�d d �Z/ed�d!d"�Z0d#d$� Z1d%d&� Z2e+d'd(� �Z3e4d�d)d*�Z5�d�ejd�d+d,�Z6�d�d-d.�Z7e+d/d0� �Z8�d�d2d3�Z9�d�d4d5�Z:�d�d6d7�Z;d8e<d9< e=e<d9 e> ��d�d;d<��Z?ddej@fd=d>�ZAd?e<d@< e=e<d@ e> ��d�dAdB��ZB�d�dCdD�ZCdEdF� ZD�d�dGdH�ZEeFd�dIdJ�ZGeFd�dKdL�ZHe'dMdN� �ZI�d�eFd�dOdP�ZJdQdR� ZKdSdT� ZL�d�eeMeN eFeOeF dV�dWdX�ZP�d�eOeF eFeOeF dY�dZd[�ZQ�d�d\d]�ZR�d�d_d`�ZS�d�eFd�dadb�ZTdcdd� ZU�d�dedf�ZV�d�edg�dhdi�ZWe'djdk� �ZXeXjYdldk� �ZX�d�edm�dndo�ZZdpdq� Z[�d�drds�Z\e'e\e[dt�Z]�d�edu�dvdw�Z^�d�dxdy�Z_e'e4d�dzd{��Z`d|d}� Zad~d� Zbe4d�d�d��Zc�d�d�d��Zdd�d�� ZeeeZf�d�d�d��Zg�d�d�d��Zhe'ed�d�d���Zie'ed�d�d���Zje'ed�d�d���Zke'ed�d�d���Zle'ed�d�d���Zme+ed�d�d���Zne'ed�d�d���Zoed�d�d��Zped�d�d��Zqed�d�d��Zred�d�d��Zsed�d�d��Zted�d�d��Zued�d�d��Zved�d�d��Zwed�d�d��Zxe+eFd�d�d���Zye+ed�d�d���Zzd�d�� Z{ej@Z|e+d�d�� �Z}e+d�d�� �Z~e+ed�d�d���Zd�d�� Z�e�Z�d�d�� Z�e�Z��d�d�d��Z��d�d�d��Z��d؇ fd�d�� Z��dه fd�dÄ Z��dڇ fd�dń Z��d�edƜd�dȄZ�d�dʄ Z�d�d̄ Z�d�d΄ Z�d�dЄ Z�d�d҄ Z�d�dԄ Z�d�dք Z�d�d Z�d�dڄ Z�e�Z�d�d܄ Z�d�dބ Z�ed�d�d�Z�d�d� Z��d�d�d�Z�d�d� Z�d�d� Z��d�d�d�Z��d�d�d�Z��d�d�d�Z�d�d� Z�d�d� Z��d�d�d�Z�d�e<d�< e=e<d� e> ��d�ejd�d�d���Z�d�d�� Z��d�d eFejd��d�d��Z��d�d eFejd��d�d��Z�d ej�d ��d�d�Z�ed ejef ejej�d��d�d�Z��d�d� Z�e��d��d �d
�Z�e�eF�d ��d �d
�Z��d�d� Z��d�d� Z��d�d� Z��d�d� Z�eF�d��d�d�Z��d�d� Z��d�d�d �Z��d �d � Z��d�d �d!�Z��d�d"�d#�Z��d�d$�d%�Z��d�d&�d'�Z��d�d(�d)�Z��d*�d+� Z�e'ejd��d,�d-��Z�e+e�ej��ed��d.�d/���Z�e'eeejf d��d0�d1��Z�ejd��d2�d3�Z�e�ej���d�ee4�d4�� f�d5�d6�
�Z��d�d7�d8�Z�e)�d9�d:� �Z�e)�d;�d<� �Z��d=�d>� Zd?�d@� ZÐdA�dB� ZĐdC�dD� Z�e'ed��dE�dF��Z�ed��dG�dH�Z�ed��dI�dJ�Z�e�e�dK��dL�dM�ZʐdN�dO� ZːdP�dQ� Z̐dR�dS� Z�ed��dT�dU�ZΐdV�dW� ZϐdX�dY� ZАdZ�d[� Z�e�e�d\��d]�d^�Z�ed��d_�d`�ZӐda�db� ZԐdc�dd� ZՐd�eMeN �d��de�df�Zdg�dh� Zאd�di�dj�Z�ejd��dk�dl�Zِdm�dn��do�dp�Zڐdq�dr� Z�ed��ds�dt�Zܐdm�dn��du�dv�Zݐdw�dx� Zސdye<�dz< e=e<�dz e> ��d{�d|� �Zߐd}�d~� Z�d �d��d��d��Z�e�e�d���d��d��Z�e�e�ejf d��d��d��Z�d� f�d��d�� Z�d�d d��d��d��Z�d�d��d��Z�d�eFee�d���d��d��Z�d�d��d��Z�d��d�� Z�eFeF�d���d��d��Z�eF�d���d��d��Z�d�d��d��Z�eFe4�d���d��d��Z�d�d��d��Z�d��d�� Z�e4�d���d��d��Z�d�eF�d���d��d��Z�e)�d��d�� �Z�e)�d��d�� �Z�e)�d��d�� �Z�e)�d��d�� �Z�e)�d��d�� �Z�e)�d��d�� �Z�e)�d��d�� �Z�e)�d��d�� �Z�e'�d��d�� �Z�� Z�S (� rZ a�
Immutable ndarray implementing an ordered, sliceable set. 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_valuer{ c C s t j||�S )N)�libjoinZleft_join_indexer_unique)rn rp �rightrs rs rt �_left_indexer_unique� s zIndex._left_indexer_uniquec C s t j||�S )N)r� Zleft_join_indexer)rn rp r� rs rs rt �
_left_indexer s zIndex._left_indexerc C s t j||�S )N)r� Zinner_join_indexer)rn rp r� rs rs rt �_inner_indexer s zIndex._inner_indexerc C s t j||�S )N)r� Zouter_join_indexer)rn rp r� rs rs rt �_outer_indexer s zIndex._outer_indexerr NFry T�str)�returnc K s2 ddl m} t||| �}|d k r(t|�}d|krL|jd�}t||� t|�}t|t�r^|j � }t
|dd �} t||�r�|||||d�S t|t �r�|j |||d�S t
| �s�t
|�r�ddlm}
t||
|||f|�S t| �s�t|��r ddlm} t|| |||f|�S t| ��st|��r4dd lm} t|| |||f|�S t| ��sHt|��rhdd
lm}
t||
|||f|�S t| ��s|t|��r�dd lm} t|||||f|�S t| ��s�t|��r|d k�p�t |��s�|j � }|j ||d d
�}nt j |t!d�}|j"t!�}t#|ft!||d�|��S t|t j$t#t%f��r\ddl&m'}m(}m)} |d k �rRt*|||�}|j+}t,|j+��rn|||||d�S t-|j+��r�|||||d�S t.|j+��r�|||||d�S t/|j+j0t1��s�t2|��r�|j"d�}nt3j4|t!d�}|�r�|j5� }|d k�r t6|�\}}|d k �r | |f|d |d�|��S |�r<t7dt8t9|��� ���|j:dk�rPt;d��| j<||�S |d k�spt=|��r|| j>|��n�t?|d��r�t#t j |�f|||d�|��S |�rt@|��rtA|��r�tB|�}|�rtCdd� |D ���rddlDmE} |jF||�p|jGd�d�S t3j4|t!d�}t#|f|||d�|��S d S ) Nr )�
RangeIndex�tzrb )�startr rb ry )rb ry )�CategoricalIndex)�
IntervalIndex)�
DatetimeIndex)�TimedeltaIndex)� PeriodIndexF)rb r )rb )rb r ry )� Float64Index�
Int64Index� UInt64Index)r rb ry �objectz Unexpected keyword arguments r{ z Index data must be 1-dimensional� __array__c s s | ]}t |t�V qd S )N)re r~ )�.0�ers rs rt � <genexpr>� s z Index.__new__.<locals>.<genexpr>)�
MultiIndex�names)r� )H�pandas.core.indexes.ranger� �maybe_extract_namer9 r� rK rJ re r? Zto_numpy�getattr�rangeZ
from_ranger' � pandas.core.indexes.categoryr� �_maybe_asobjectr0 Z pandas.core.indexes.intervalr� r( r} r� r7 r� r4 r� r* r3 Zconstruct_array_type�_from_sequencerf rm r� �astyperZ rg rB Zpandas.core.indexes.numericr� r� r� �_maybe_cast_with_dtyperb r6 r8 r, r� rk �boolr& �com�asarray_tuplesafer � _maybe_cast_data_without_dtype� TypeError�repr�setrh rj � _simple_newr5 �_scalar_data_error�hasattrr2 r1 �listrd �pandas.core.indexes.multir� � from_tuples�get)rx �datarb r ry �
tupleize_cols�kwargsr� r� Z
data_dtyper� r� r� r� r� Zea_clsr� r� r� �subarrZnew_dataZ new_dtyper� rs rs rt r� % s�
z
Index.__new__c C s dS )z�
Integer representation of the values.
Returns
-------
ndarray
An ndarray with int64 dtype.
Nrs )rn rs rs rt �asi8� s
z
Index.asi8)ry c C sB t |tj�stt|���tj| �}||_||_||_ i |_
|j � 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.
) re rf rg �AssertionErrorrk r� r� �_dataZ _index_data�_name�_cache�_reset_identity)rx �valuesry rq rs rs rt r� � s
zIndex._simple_newc C s t | �S )N)rk )rn rs rs rt � _constructor� s zIndex._constructorc s � fdd�� j D �S )z9
Return an attributes dict for my class.
c s i | ]}t � |d �|�qS )N)r� )r� �k)rn rs rt �
<dictcomp>� s z.Index._get_attributes_dict.<locals>.<dictcomp>)� _attributes)rn rs )rn rt �_get_attributes_dict� s zIndex._get_attributes_dictc C sN |t kr| jn|}|dkr$| jj� ni }|dkr6| j}| 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
N)ry )r ry r� r rl r� )rn r� ry �cacherq rs rs rt �
_shallow_copy� s
zIndex._shallow_copyc C s | j t|dt�ko| j dk S )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.
�_idN)r� r� �Ellipsis)rn ro rs rs rt �is_ s z Index.is_c C s t � | _| S )zJ
Initializes or resets ``_id`` attribute with new object.
)� _Identityr� )rn rs rs rt r� s zIndex._reset_identityc C s | j j� d S )N)�_engineZ
clear_mapping)rn rs rs rt �_cleanup' s zIndex._cleanupc s | j � � | j� fdd�t| ��S )Nc s � S )Nrs rs )�
target_valuesrs rt �<lambda>1 s z Index._engine.<locals>.<lambda>)�_get_engine_target� _engine_typeri )rn rs )r� rt r� * s z
Index._enginec C s
t | j�S )z1
Return the length of the Index.
)ri r� )rn rs rs rt �__len__7 s z
Index.__len__c C s t j| j|d�S )z8
The array interface, return my values.
)rb )rf rm r� )rn rb rs rs rt r� = s zIndex.__array__c C sB t j|�}t|�s*t j|�s*tj|�dkr.|S | j� }t|f|�S )z,
Gets called after a ufunc.
r{ )r Zitem_from_zerodimr& r5 rf rh r� rZ )rn rq �context�attrsrs rs rt �__array_wrap__C s
zIndex.__array_wrap__c C s | j jS )zA
Return the dtype object of the underlying data.
)r� rb )rn rs rs rt rb N s z Index.dtype�Cc C s | j � }|j|d�S )z�
Return an ndarray of the flattened values of the underlying data.
Returns
-------
numpy.ndarray
Flattened array.
See Also
--------
numpy.ndarray.ravel
)�order)r� �ravel)rn r� r� rs rs rt r� U s
z Index.ravelc C s@ |d k r"t |d� r"| jj|�}n| j� }t|t�r<| j|_|S )N�_typ)r� r� �viewr� re rZ r� )rn rx rq rs rs rt r� e s
z
Index.viewc C s� |dk rt |�}t| j|�r,|r(| j� S | S t|�rTddlm} || j| j||d�S t |�rtt
t j | �| j||d�S y| jj
||d�}W nB ttfk
r� } z"tdt| �j� d|� ��|�W Y dd}~X 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 ValueError 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.
Nr )r� )ry rb r )r z Cannot cast z
to dtype )ry rb )r9 r) rb r r' r� r� rl ry r* rZ rf rm r� r� rj rk rw )rn rb r r� Zcasted�errrs rs rt r� q s" z Index.astypea�
Return a new %(klass)s of the values selected by the indices.
For internal compatibility with numpy arrays.
Parameters
----------
indices : list
Indices to be taken.
axis : int, optional
The axis over which to select values, always 0.
allow_fill : bool, default True
fill_value : bool, default None
If allow_fill=True and fill_value is not None, indices specified by
-1 is regarded as NA. If Index doesn't hold NA, raise ValueError.
Returns
-------
numpy.ndarray
Elements of given indices.
See Also
--------
numpy.ndarray.take
�taker c K sv |rt jt� |� t|�}| jr:| j| j|||| jd�}n2|r`|d k r`t| �j }t
d|� d���| jj |�}| j |�S )N)�
allow_fill�
fill_value�na_valuez Unable to fill values because z cannot contain NA)
�nvZ
validate_taker~ r$ � _can_hold_na�_assert_take_fillablerl � _na_valuerk rw rj r� r� )rn �indices�axisr� r� r� �takenZcls_namers rs rt r� � s
z
Index.takec C sJ t |�}|r<|dk r<|dk j� r(td��tj||||d�}n
|j|�}|S )z?
Internal method to handle NA filling of take.
Nr{ zJWhen allow_fill=True and fill_value is not None, all indices must be >= -1)r� r� ���)r$ �anyrj r
r� )rn r� r� r� r� r� r� rs rs rt r� � s
zIndex._assert_take_fillablea�
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 s. t |�}tjt� t|d�� | j| jj|��S )N)r� )r$ r� Zvalidate_repeatr~ �dictr� rl r� )rn Zrepeatsr� rs rs rt r� s z Index.repeatc C sJ |r| j | jj� �}n| j � }| j|||d�}|j|�}|rF|j|�}|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.
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.
)ry r� �deep)r� r� r �_validate_names� set_namesr� )rn ry r� rb r� � new_indexrs rs rt r s
z
Index.copyc K s | j f |�S )N)r )rn r� rs rs rt �__copy__? s zIndex.__copy__c C s | j dd�S )zq
Parameters
----------
memo, default None
Standard signature. Unused
T)r� )r )rn �memors rs rt � __deepcopy__B s zIndex.__deepcopy__c C sd t | �j}| j� }| j� }| j� }dd� |D �}d|� �j|�}|dkrLd}|� d|� |� d�}|S )zA
Return a string representation for this object.
c S s g | ]\}}|� d |� ��qS )�=rs )r� r� �vrs rs rt �
<listcomp>V s z"Index.__repr__.<locals>.<listcomp>�,Nr] �(�))rk rw � _format_data�
_format_attrs�
_format_space�join)rn �
klass_namer� r� �spaceZ attrs_strZprepr�resrs rs rt �__repr__N s
zIndex.__repr__c C s dS )N� rs )rn rs rs rt r a s zIndex._format_spacec C s t S )z0
Return the formatter function.
)rU )rn rs rs rt �_formatter_funck s zIndex._formatter_funcc C s> d}| j dkrd}n| j dkr,t| j�r,d}t| | j||d�S )z@
Return the formatted data as a unicode string.
T�stringF� categorical)�
is_justifyry )�
inferred_typer3 �
categoriesrW r )rn ry r
rs rs rt r� r s
zIndex._format_datac C s t | �S )zH
Return a list of tuples of the (attr,formatted_value).
)rV )rn rs rs rt r� � s zIndex._format_attrsc C s | j S )N)r� )rn rs rs rt � _mpl_repr� s zIndex._mpl_repr�NaN)ry � formatter�na_repr� c C sR g }|r*|j | jdk r$t| jdd�nd� |dk rD|t| j|�� S | j||d�S ) z>
Render a string representation of the Index.
N� �
�
)� escape_charsr] )r )r r r )�appendry rX r� �map�_format_with_header)rn ry r r �headerrs rs rt �format� s z Index.format)r r r� c C s� ddl m} | j}t|j�r*tj|dd�}t|j�rndd� |D �}t|�}|j� r�t j
|�}|||< |j � }nt ||d dd��}|| S ) Nr )� format_arrayr{ )�safec S s g | ]}t |dd��qS )r r r )r )r r r )rX )r� �xrs rs rt r� � s z-Index._format_with_header.<locals>.<listcomp>rp )Zjustify)
Zpandas.io.formats.formatr rl r3 rb r Zmaybe_convert_objectsrE r� rf �array�tolist�
trim_front)rn r r r r� rq �maskrs rs rt r � s
zIndex._format_with_headerc K s | }|dk r|| }|j f |�S )a
Format specified values of `self` and return them.
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.
N)�_format_native_types)rn Zslicerr� r� rs rs rt �to_native_types� s zIndex.to_native_typesr] c K sF t | �}| j� r*| r*tj| �jt�}ntj| tdd�}|||< |S )z>
Actually format specific types of the index.
T)rb r )rE � is_objectrf rm r� r� r r� )rn r �quotingr� r r� rs rs rt r! � s zIndex._format_native_typesc C s� t | �dkrj| d }t|d�r2t|t� r2|j� }| d
}t|d�rXt|t� rX|j� }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 r r{ z, z to r] Nz: z entriesr� )ri r� re r� r rk rw )rn ry �head�tailZ
index_summaryrs rs rt �_summary� s
zIndex._summaryc C s | S )aM
Identity method.
.. versionadded:: 0.24.0
This is implemented for compatibility with subclass implementations
when chaining.
Returns
-------
pd.Index
Caller.
See Also
--------
MultiIndex.to_flat_index : Subclass implementation.
rs )rn rs rs rt �
to_flat_index s zIndex.to_flat_indexc C s> ddl m} |dkr | j� }|dkr*| j}|| jj� ||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 )rY N)r ry )r} rY r� ry r� r )rn r ry rY rs rs rt � to_series s 6 zIndex.to_series)r c C s> ddl m} |dkr | jp d}||| jj� i�}|r:| |_|S )a�
Create a DataFrame with a column containing the Index.
.. versionadded:: 0.24.0
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 )� DataFrameN)r} r* ry rl r r )rn r ry r* rq rs rs rt �to_frameW s 3
zIndex.to_framec C s | j S )z2
Return Index or MultiIndex name.
)r� )rn rs rs rt ry � s z
Index.namec C s( | j rtd��t|d t| �� || _d S )NzOCannot set name on a level of a MultiIndex. Use 'MultiIndex.set_names' instead.)�_no_setting_name� RuntimeErrorr� rk r� )rn �valuers rs rt ry � s
)r� c C s| ddl m} |dk r&|dk r&td��nR|dkrJ|dkrJ|rD|| j�S | jS |dk rft|�sbtd��|S t|�st|gS |S dS )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`.)r r/ r� r� r2 )rn ry r� r� r/ rs rs rt r� � s
zIndex._validate_namesc C s t | jf�S )N)rO ry )rn rs rs rt �
_get_names� s zIndex._get_namesc C sf t |�std��t|�dkr.tdt|�� ���x(|D ] }t|�s4tt| �j� d���q4W |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 z .name must be a hashable typer N)r2 rj ri r- r� rk rw r� )rn r� �levelry rs rs rt �
_set_names� s
zIndex._set_names)�fset�fget)r_ c C s� |dk r t | t� r td��|dk r>t|� r>t|�r>td��t|� rb|dkrb| jdkrbtd��t|�sp|g}|dk r�t|� r�|g}|r�| }n| j� }|j||d� |s�|S dS )a
Set Index or MultiIndex name.
Able to set new names partially and by level.
Parameters
----------
names : label or list of label
Name(s) to set.
level : int, label or list of int or label, optional
If the index is a MultiIndex, level(s) to set (None for all
levels). Otherwise level must be None.
inplace : bool, default False
Modifies the object directly, instead of creating a new Index or
MultiIndex.
Returns
-------
Index
The same type as the caller or None if inplace is 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'])
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`.)r1 )re r> rj r2 r� �nlevelsr� r2 )rn r� r1 r_ �idxrs rs rt r� � s 8 zIndex.set_namesc C s | j |g|d�S )ah
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
The same type as the caller or None if inplace is 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`.
)r_ )r� )rn ry r_ rs rs rt �rename, s 1z Index.renamec C s dS )z#
Number of levels.
r{ rs )rn rs rs rt r5 b s z
Index.nlevelsc C s | S )z)
Compat with MultiIndex.
rs )rn rs rs rt �_sort_levels_monotonici s z Index._sort_levels_monotonicc C sn t |t�rH|dk r,|d
kr,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 zRequested level (z ) does not match index name (r� Nr� )re �int�
IndexErrorry �KeyError)rn r1 rs rs rt �_validate_index_levelo s
zIndex._validate_index_levelc C s | j |� dS )Nr )r< )rn r1 rs rs rt �_get_level_number� s
zIndex._get_level_numberc C s | j d|d�S )aa
For internal compatibility with 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
T)�return_indexer� ascending)� sort_values)rn r1 r? Zsort_remainingrs rs rt � sortlevel� s zIndex.sortlevelc C s | j |� | 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< )rn r1 rs rs rt �_get_level_values� s $
zIndex._get_level_valuesc
s* t |ttf�s|g}t� fdd�|D ��ddd � }t|�dkrD� S t|�� jkrntdt|�� d� j� d���t� j�}t� j�}t� j �}x*|D ]"}|j
|� |j
|� |j
|� q�W t|�dk�r
|d d
k}|d j |d �}|j � � r�|j
|tj�}|d |_|S dd lm} | |||d
d �S dS )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.
.. versionadded:: 0.23.1 (support for non-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
c 3 s | ]}� j |�V qd S )N)r= )r� Zlev)rn rs rt r� � s z"Index.droplevel.<locals>.<genexpr>Nr{ r zCannot remove z levels from an index with z) levels: at least one level must be left.)r� F)�levelsr� r� �verify_integrityr� r� )re r~ r� �sortedri r5 rj rC r� r� r� r� r� �putmaskrf �nanr� r� r� )
rn r1 Zlevnums�
new_levels� new_codesZ new_names�ir rq r� rs )rn rt � droplevel� s8
zIndex.droplevelc C s6 |dks|dkst �|dkr"| }n
| j|�}|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� r )rn �mapperr1 Zgrouperrs rs rt �_get_grouper_for_level s
z Index._get_grouper_for_levelc C s | j S )z4
Alias for is_monotonic_increasing.
)�is_monotonic_increasing)rn rs rs rt � 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� rN )rn rs rs rt rN * 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)rn rs rs rt rP ; 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
)� is_uniquerN )rn rs rs rt �!_is_strictly_monotonic_increasingL 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
)rQ rP )rn rs rs rt �!_is_strictly_monotonic_decreasing] s z'Index._is_strictly_monotonic_decreasingc C s | j jS )z8
Return if the index has unique values.
)r� rQ )rn rs rs rt rQ n 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
)rQ )rn rs rs rt �has_duplicatesu 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)rU )r )rn rs rs rt �
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)rW )r )rn rs rs rt r. � 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
�floating�mixed-integer-float�
integer-na)rX rY rZ )r )rn rs rs rt � is_floating� 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
rW rX )rW rX )r )rn rs rs rt �
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
)r3 rb )rn rs rs rt r# 1 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
r )r )r )rn rs rs rt �is_categoricalY 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)r^ )r )rn rs rs rt � 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.� )�
stacklevelr[ )r[ )�warnings�warn�
FutureWarningr )rn rs rs rt �is_mixed� s
zIndex.is_mixedc C s
| j dkS )z6
Whether the type is an integer type.
rW �
mixed-integer)rW rf )r )rn rs rs rt �
holds_integer� s zIndex.holds_integerc C s t j| jdd�S )zG
Return a string of the type inferred from the values.
F)�skipna)r � infer_dtyperl )rn rs rs rt r � s zIndex.inferred_typec C s t t| j��S )zH
Whether or not the index values only consist of dates.
)r r# rl )rn rs rs rt � is_all_dates� s zIndex.is_all_datesc C s, t | jd�}|j| j� � tt| �|fd fS )N)r� )r� r� �updater� r� rk )rn r� rs rs rt �
__reduce__� s zIndex.__reduce__c C s4 | j rt| �S tjt| �tjd�}|jd� |S dS )z.
Return if each value is NaN.
)rb FN)r� rE rf �emptyri Zbool_�fill)rn r� rs rs rt �_isnan� s
z Index._isnanc C s( | j r| jj� d S tjg tjd�S d S )Nr )rb )r� ro �nonzerorf r �int64)rn rs rs rt � _nan_idxs� s zIndex._nan_idxsc C s | j rt| jj� �S dS dS )zK
Return if I have any nans; enables various perf speedups.
FN)r� r� ro r� )rn rs rs rt �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
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])
)ro )rn rs rs rt rE
s 5z
Index.isnac C s
| j � 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
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])
)rE )rn rs rs rt �notnaC s *z Index.notnac C s< | j |� | jr4| j| j|�}|dkr4t|| jd�S | j� 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)ry )�_assert_can_do_oprs rF ro rZ ry r� )rn r. Zdowncastrq rs rs rt �fillnaq s
z Index.fillnar� c C s8 |dkrt d|� ���| jr0| j| j| j �S | j� 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� rd zinvalid how option: )r� rd )rj rs r� rl ro )rn �howrs rs rt �dropna� s
z Index.dropnac s& |dk r| j |� t� j� }| j|�S )a�
Return unique values in the index.
Unique values are returned in order of appearance, this does NOT sort.
Parameters
----------
level : int or str, optional, default None
Only return values from specified level (for MultiIndex).
.. versionadded:: 0.23.0
Returns
-------
Index without duplicates
See Also
--------
unique
Series.unique
N)r< �superr` r� )rn r1 rq )� __class__rs rt r` � s
z Index.unique�firstc 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')
)�keep)ry �drop_duplicates)rn r| )rz rs rt r} � s .zIndex.drop_duplicatesc s t � 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
-------
numpy.ndarray
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| )ry ra )rn r| )rz rs rt ra � s 6zIndex.duplicated)rx c C sr | j r| r| S | j s0| j� }t| t�s6|j}n| j}|rhy| jrP|t|� }W n tk
rf Y nX | j |�S )z�
Returns an index containing unique values.
Parameters
----------
dropna : bool, default False
If True, NaN values are dropped.
Returns
-------
uniques : index
)
rQ r` re r> r� rl rs rE �NotImplementedErrorr� )rn rx r� rs rs rt �_get_unique_index, s
zIndex._get_unique_indexc C s. t |ttf�rtS ddlm} t|| �| �S )Nr )rY )re rB r< r| r} rY rZ )rn ro rY rs rs rt �__add__P s z
Index.__add__c C s ddl m} t||| � �S )Nr )rY )r} rY rZ )rn ro rY rs rs rt �__radd__W s zIndex.__radd__c C s | | S )Nrs )rn ro rs rs rt �__iadd__\ s zIndex.__iadd__c C s t tj| �| �S )N)rZ rf r )rn ro rs rs rt �__sub__` s z
Index.__sub__c C s ddl m} t||| � �S )Nr )rY )r} rY rZ )rn ro rY rs rs rt �__rsub__c s zIndex.__rsub__c C s
| j |�S )N)� intersection)rn ro rs rs rt �__and__i s z
Index.__and__c C s
| j |�S )N)�union)rn ro rs rs rt �__or__l s z Index.__or__c C s
| j |�S )N)�symmetric_difference)rn ro rs rs rt �__xor__o 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().)rj rk rw )rn rs rs rt � __nonzero__r s zIndex.__nonzero__c C s$ t | |�}| j|kr | j|d�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.
)ry )rP ry r� )rn ro ry rs rs rt �_get_reconciled_name_object} s
z!Index._get_reconciled_name_objectc C s: | j tdd�}t|�j tdd�}tj|||d�j tdd�S )a
Casts this and other index to object dtype to allow the formation
of a union between incompatible types.
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
F)r )�sort)r� r� rZ r� )rn ro r� �thisrs rs rt �_union_incompatible_dtypes� s z Index._union_incompatible_dtypesc C s t | �t |�ko t| j|j�S )a8
Check whether this and the other dtype are compatible with each other.
Meaning a union can be formed between them without needing to be cast
to dtype object.
Parameters
----------
other : Index or array-like
Returns
-------
bool
)rk r) rb )rn ro rs rs rt �_is_compatible_with_other� s z Index._is_compatible_with_otherc C s |dkrt d|� d���d S )NFz;The 'sort' keyword only takes the values of None or False; z was passed.)NF)rj )rn r� rs rs rt �_validate_sort_keyword� s z Index._validate_sort_keywordc C s: | j |� | j|� | j|�s,| j||d�S | j||d�S )at
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.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
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')
)r� )r� �_assert_can_do_setopr� r� �_union)rn ro r� rs rs rt r� � s
3
z Index.unionc st t |� s| j|�r | j|�S t | �s0|j| �S | j}|j}|dkr�| jr�|jr�y| j||�d }W nF tk
r� t|�}t|�� |j � fdd�|D �� t
|�j}Y nX n�| j r�| j |�}|d kj
� d }ntj| j|�d �}t |�dk�rtj||dd�}t||f�}n|}|dk�rhytj|�}W n: tk
�rf } z tj|� d�td d
� W Y dd}~X nX | j||�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 rs rs )r� r )� value_setrs rt r�
s z Index._union.<locals>.<listcomp>r{ F)r� z2, sort order is undefined for incomparable objects� )ra r� )ri �equalsr� rl rO r� r� r� r� �extendrZ rQ � get_indexerrp r
�unique1d�get_indexer_non_unique�take_ndr: � safe_sortrb rc �RuntimeWarning�_wrap_setop_result) rn ro r� �lvals�rvalsrq �indexerZ
other_diffr� rs )r� rt r� � s>
z Index._unionc C s t | |�}| j||d�S )N)ry )rP r� )rn ro rq ry rs rs rt r� 6
s
zIndex._wrap_setop_resultc
C s� | j |� | j|� t|�}| j|�r8| j r8| j|�S t| j|j�sh| jd�}|jd�}|j ||d�S | j
}|j
}| j r�|j r�y| j ||�d }W n t
k
r� Y nX | j|tj|��S y(t|�j|�}|j|dkj� d �}W n> ttfk
�r" tjt|�j|�d �}||dk }Y nX |j|�j� }t| |�} |dk�r`tj|j�}| j || d�S tj|j
�j |j
j k�s|t �| |_ |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.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default from ``True`` to ``False``, to match
the behaviour of 0.23.4 and earlier.
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')
�O)r� r r{ N)ry r� r� ) r� r� � ensure_indexr� rT r� r) rb r� r� rl rO r� r� r� r
r� rZ r� r� rp r r r� r` rP r� r� r� �shaper� ry )
rn ro r� r� r� r� rq r� r� Zres_namers rs rt r� ;
s> "
zIndex.intersectionc C s� | j |� | j|� | j|�r2| j| jdd� �S | j|�\}}| j� }|j|�}|j|dkj � d �}t
j t
j |j
�|dd�}|jj|�}|dkr�ytj|�}W n tk
r� Y nX |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.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
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{ T)�
assume_unique)ry r� )r� r� r� r� r� �_convert_can_do_setopr r� r� rp rf � setdiff1d�arange�sizer� r
r� r� )rn ro r� � result_namer� r� Z
label_diff�the_diffrs rs rt �
difference�
s &
zIndex.differencec
C s� | j |� | j|� | j|�\}}|dkr.|}| j� }|j� }|j|�}|j|dkj� d �}tjtj |j
�|dd�}|j j|�} |dkj� d }
|j j|
�} t | | g�} |dkr�yt
j| �} W n tk
r� Y nX t| | j|d�S ) a�
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.
.. versionadded:: 0.24.0
.. versionchanged:: 0.24.1
Changed the default value from ``True`` to ``None``
(without change in behaviour).
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')
You can also use the ``^`` operator:
>>> idx1 ^ idx2
Int64Index([1, 5], dtype='int64')
Nr{ r T)r� )rb ry r� r� )r� r� r� r r� r� rp rf r� r� r� rl r: r
r� r� rZ rb )
rn ro r� r� Zresult_name_updater� r� Zcommon_indexer� left_indexerZ left_diff�
right_indexerZ
right_diffr� rs rs rt r� �
s* /
zIndex.symmetric_differencec C s t |�std��dS )Nz!Input must be Index or array-likeT)r2 r� )rn ro rs rs rt r� s zIndex._assert_can_do_setopc C s2 t |t�s t|| jd�}| j}n
t| |�}||fS )N)ry )re rZ ry rP )rn ro r� rs rs rt r� s
zIndex._convert_can_do_setopc C s� |dkr\|dk rt d��| j|�}y | jj|�S tk
rZ } zt|�|�W Y dd}~X nX |dk rv| j|tj|��}| j|g||d�}|j dks�|j
dkr�t d��|j � }|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 most 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� )
rj �_maybe_cast_indexerr� �get_locr; �_convert_tolerancerf rm r� rh r� r� �item)rn �keyr� r� Z
casted_keyr� r� �locrs rs rt 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 most
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 : ndarray of int
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� c C s0 t j|�}t|�}|d k r&| j||�}|j� rH| j� rHttjd |j ��S | j
|�\}}|| k sf||k rx|j ||||d�S t | j
|j
�s�| jt�}|jt�}|j ||||d�S | js�td��|dks�|dkr�| j||||�}nL|dkr�| j|||�}n4|d k �rtd��|d k �rtd��| jj |j� �}t|�S )
Nr{ )r� �limitr� z8Reindexing only valid with uniquely valued Index objects�pad�backfillZnearestzJtolerance argument only valid if doing pad, backfill or nearest reindexingzFlimit argument only valid if doing pad, backfill or nearest reindexingr� )�missingZclean_reindex_fill_methodr� r� rV r\ r$ rf r� r� �_maybe_promoter� r) rb r� r� rQ r �_get_fill_indexer�_get_nearest_indexerrj r� r� ) rn �targetr� r� r� �pself�ptargetr� r� rs rs rt r� � s<
zIndex.get_indexerc C s, t j|�}|j|jkr(|jdkr(td��|S )Nr{ z5list-like tolerance size must match target index size)rf rm r� rj )rn r� r� rs rs rt r� � s
zIndex._convert_tolerance)r� r� r� c C s` |j � }| jr8|jr8|dkr$| jjn| jj}|||�}n| j|||�}|d k r\| j|||�}|S )Nr� )r� rN r� Zget_pad_indexerZget_backfill_indexer� _get_fill_indexer_searchsorted�_filter_indexer_tolerance)rn r� r� r� r� r� Z
engine_methodr� rs rs rt r� � s zIndex._get_fill_indexerc C s� |dk r t dt|�� d���|dkr(dnd}| j|�}|dk}| j|| |�||< |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� rp r� r{ r� r� )rj r� r� �_searchsorted_monotonicri )rn r� r� r� �sider� Znonexactrs rs rt r� � s
z$Index._get_fill_indexer_searchsorted)r� r� c C s� | j |d|d�}| j |d|d�}|j}tj| j| | �}tj| j| | �}| jrZtjntj} tj| ||�|dkB ||�}
|dk r�| j ||
|�}
|
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{ Nr� )
r� rl rf �absrN �operator�lt�le�wherer� ) rn r� r� r� r� r� r� Zleft_distancesZright_distancesrr r� rs rs rt r� s zIndex._get_nearest_indexer)r� r� r� c C s( t | j| | �}tj||k|d�}|S )Nr{ r� )r� rl rf r� )rn r� r� r� Zdistancers rs rt r� s z Index._filter_indexer_tolerancec C s |S )z�
Translate any partial string timestamp matches in key, returning the
new key.
Only relevant for MultiIndex.
rs )rn r� rs rs rt �'_get_partial_string_timestamp_match_key$ s z-Index._get_partial_string_timestamp_match_key)r� c C s4 | j d|jd� | j d|jd� | j d|jd� dS )zz
For positional indexing, a slice must have either int or None
for each of start, stop, and step.
Z
positional�ilocN)�_validate_indexerr� �stop�step)rn r� rs rs rt �_validate_positional_slice. s z Index._validate_positional_slice)r� �kindc
C s6 |d kst |��|j|j|j }}}dd� }||�oD||�oD||�}|oZ| j� pX| j� }|dkr�| j� sp|r�| jd|jd� | jd|jd� | jd|jd� |S |r�y,|dk r�| j|� |dk r�| j|� d}W n tk
r� Y nX t j
|�r�|} n8|�r |dk�rt j dt
d d
� |} n| j||||d �} | 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)r. )r� rs rs rt �is_intI s z,Index._convert_slice_indexer.<locals>.is_int�sliceNFz�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.� )ra )r� )r� r� )r� r� r� r� r. r] r� r� r; r� Z
is_null_slicerb rc rd �
slice_indexer)
rn r� r� r� r� r� r� Zis_index_sliceZ
is_positionalr� rs rs rt �_convert_slice_indexer7 s@
z Index._convert_slice_indexerc C s2 t |t�r| j|�}n
| j|�}| j|�}||fS )a/
Parameters
----------
keyarr : list-like
Indexer to convert.
Returns
-------
indexer : numpy.ndarray or None
Return an ndarray or None if cannot convert.
keyarr : numpy.ndarray
Return tuple-safe keys.
)re rZ �_convert_index_indexer�_convert_arr_indexer�_convert_list_indexer)rn �keyarrr� rs rs rt �_convert_listlike_indexer} s
z Index._convert_listlike_indexerc C s t j|�}|S )z�
Convert an array-like indexer to the appropriate dtype.
Parameters
----------
keyarr : array-like
Indexer to convert.
Returns
-------
converted_keyarr : array-like
)r� r� )rn r� rs rs rt r� � s
zIndex._convert_arr_indexerc C s |S )a
Convert an Index indexer to the appropriate dtype.
Parameters
----------
keyarr : Index (or sub-class)
Indexer to convert.
Returns
-------
converted_keyarr : Index (or sub-class)
rs )rn r� rs rs rt r� � s
z Index._convert_index_indexerc C s dS )a
Convert a list-like indexer to the appropriate dtype.
Parameters
----------
keyarr : Index (or sub-class)
Indexer to convert.
kind : iloc, loc, optional
Returns
-------
positional indexer or None
Nrs )rn r� rs rs rt r� � s zIndex._convert_list_indexer)�formc
C s0 t d|� dt| �j� d|� dt|�j� ���dS )z5
Consistent invalid indexer message.
z
cannot do z
indexing on z with these indexers [z
] of type N)r� rk rw )rn r� r� rs rs rt �_invalid_indexer� s zIndex._invalid_indexerc C s | j rt|�rtd��dS )z�
Check if we are allowing reindexing with this particular indexer.
Parameters
----------
indexer : an integer indexer
Raises
------
ValueError if its a duplicate axis
z$cannot reindex from a duplicate axisN)rQ ri rj )rn r� rs rs rt � _can_reindex� s
zIndex._can_reindexc C s0 t |d� }t|�}t|t� r`t|�dkr`t| t�r@td�}n| jdd� }| j|| j d�}nt
|�}|dk r�|dk r�t d��| j ||ddd�\}} }n^| j
|�r�d} nN| jr�t| d d
� r�| j||||d �} n&|dk s�|dk r�td ��| j|�\} }
|�r(|jd
k�r(|j | j k�r(|j� }| j |_ || fS )a0
Create index with target's values.
Parameters
----------
target : an iterable
Returns
-------
new_index : pd.Index
Resulting index.
indexer : np.ndarray or None
Indices of output values in original index.
ry r N)ry z)Fill method not supported if level passedr� T)rw �return_indexersZis_overlappingF)r� r� r� z8cannot reindex a non-unique index with a method or limitr{ )r� �ensure_has_lenre rZ ri rA r� r� r� ry r� r� � _join_levelr� rQ r� r� rj r� r5 r ) rn r� r� r1 r� r� Zpreserve_namesr� �_r� r� rs rs rt �reindex� s4
z
Index.reindexc
C s> t |�}| j|�\}}|dk}| j|| �}d}t|��rtjt|��}t|�}|j|�}t|| �} | j|| �j}
t|| �} tj t
t|�g�t d�}|
|| < ||| < |j r�tjt|��}tjt|
��|| < d|| < n(d|| < tjt| j|���}d || < t
| t��r&t| �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 or None
Indices of output values in original index.
r{ N)rb )r� )ry r� r� r� r� )r� r� r� ri rf r� r$ r" r� rm r~ r� rQ re r> rk r� r� rZ ry )
rn r� r� r� �checkZ
new_labelsZ new_indexer�lengthZmissing_labelsZmissing_indexerZ
cur_labelsZ cur_indexerr� rs rs rt �_reindex_non_unique
s4
zIndex._reindex_non_uniquerp c C s� t |�}t| t�}t|t�}|dkrJ|s,|rJ| j|jkr:n| j|||d�S |dk rl|sZ|rl| j||||d�S t|�dkr�|dkr�| j� }|r�tj dt|��} |d| fS |S t| �dkr�|dkr�|j� }|r�tj dt|��}
||
dfS |S | j
|j
k �r8ddd�j ||�}|j | |||d �} |�r4| \} }
}| ||
f} | S t
| j|j��sl| jd
�}|jd
�}|j |||d�S t|� | j �r�|j �r�| j|||d�S | j �s�|j �r�| j�r�|j�r�| j|||d�S | j|||d�S n8| j�r|j�ry| j|||d�S tk
�r Y nX |dk�r&| }n>|dk�r6|}n.|d k�rP| j|d d
�}n|dk�rd| j|�}|�rr|j� }|�r�|| k�r�d}
n
| j|�}
||k�r�d} n
|j|�} ||
| fS |S dS )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)rw r� r rp �outerr{ r� )r� rp )rw r1 r� r� �innerF)r� )rp r� r� )r� r� r� )r� re r> r� � _join_multir� ri r� rf r� �_join_precedencer� r r) rb r� �_validate_join_methodrQ �_join_non_uniquerO �_join_monotonicr� r� r� r@ r� )rn ro rw r1 r� r� �
self_is_mi� other_is_mi�
join_indexZrindexerZlindexerrq r �y�zr� rs rs rt r Z
s�
z
Index.joinc C s� ddl m} ddlm} ttj| j� �}ttj|j� �}||@ }|sLtd��t | t
�} t |t
�}
| of|
�rt || �} t || �} t | | �s�| }
|j
| j�}n| j| �}
|j| �}|
j||dd�\}}}| | }|| |||||�\}}}||||dd�}|j� }|�r|||fS |S t |�d }d}| �rL|| } }d}d d
d �j||�}|jj|�}| j||||d �}|�r�t |t��r�|d |d
|d fS |S )Nr )r� )�!_restore_dropped_levels_multijoinz+cannot join with no overlapping index namesT)r� F)rC r� r� rD rp r� )r� rp )rw r� r` r{ )r� r� �pandas.core.reshape.merger� r� r� Znot_noner� rj re r> r� ri Zreorder_levelsrK r Zremove_unused_levelsr� r r� r~ )rn ro rw r� r� r� Z
self_namesZ other_names�overlapr� r� Z ldrop_namesZ rdrop_namesZ
self_jnlevelsZother_jnlevelsZjoin_idx�lidx�ridxZ
dropped_namesrC r� r� Zmulti_join_idxZjl�
flip_orderr1 rq rs rs rt r� �
sR
zIndex._join_multic C s� ddl m} | j|jks t�| j� }|j� }||g|g|dd�\}}t|�}t|�}tj|j|��} |dk}
tj | |
|j|�� | j
| |�} |r�| ||fS | S d S )Nr )�_get_join_indexersT)rw r� r{ r� ) r� r� rb r� r� r$ rf rm r� rF �_wrap_joined_index) rn ro rw r� r� ZlvaluesZrvaluesZleft_idxZ right_idxr� r rs rs rt r� " s
zIndex._join_non_uniquec s� ddl m} dd� }t| |�r0t||�r0td��| | }} t| |� }
|
rf| | }} ddd�j||�}|j|�}|j| } | js�td ��| j | |d
d �\} }
}|
d kr�|s�t
|�dkr�d � |}n ||j d |d
� �� |� }�nZt |
�}
t
j|
t
| ��}tj||j | dd�}t|j �}|||< t|j�}| ||< |�r|tjt
|�tjd�� |dk��j� �s*�fdd�|D �}� � � n�|dk�r�d
|j� }tj||�\� }� |d d � � � fdd�|D �}nd|dk��j� }|�s�fdd�|D �}||d |d
� �� � fdd�|D �}|�s*�j� d � � ||||jdd�}|d k �r^tj||j | dd�}n
|j | }|
�rx|� � }|�r�� d k�r�d nt� �� |d k�r�d nt|�}|� |fS |S d S )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 )r� c S s� | d j dkr tjddd�S t| �dkrPt| d �}tj|d|j� �\}}|S | d dd� | d dd� k}x0| dd� D ] }||dd � |dd� kO }q~W tjdg|dgf�j � d }t| d
�}t
j |t|��S ) zz
Returns sorter for the inner most level while preserving the
order of higher levels.
r rq )rb r{ NTr� r� r� r� ) r� rf rm ri r" �libalgos�groupsort_indexer�maxZhstackrp r Zget_level_sorter)r� �labZsorterr� ZticZstartsrs rs rt �_get_leaf_sorterK s z+Index._join_level.<locals>._get_leaf_sorterz9Join on level between two MultiIndex objects is ambiguousrp r� )r� rp z8Index._join_level on non-unique index is not implementedT)rw r� Nr{ F)r� )rb c s g | ] }|� �qS rs rs )r� r� )r rs rt r� � s z%Index._join_level.<locals>.<listcomp>c s g | ] }|� �qS rs rs )r� r� )r� rs rt r� � s c s g | ] }|� �qS rs rs )r� r� )r rs rt r� � s c s g | ] }|� �qS rs rs )r� r� )r� rs rt r� � s )rC r� r� rD r� r� ) r� r� re r� r� r= rC rQ r~ r ri r� r" r Zget_reverse_indexerr
r� r� rf r� �intprd r� r� r� rp r� r$ )rn ro r1 rw r� Z
keep_orderr� r� rp r� r� Z old_levelZ new_levelZleft_lev_indexerZright_lev_indexerr� Z rev_indexerZ
new_lev_codesrI rH Zngroups�countsZmask_allr� rs )r� r rt r� = s�
zIndex._join_levelc
C s� |j | j kst�| j|�r<|dkr&|n| }|r8|d d fS |S | j� }|j� }| jr�|jr�|dkrv| }d }| j||�} nl|dkr�|}| j||�}d } nN|dkr�| j||�\}}} | j||�}n&|dkr�| j||�\}}} | j||�}n�|dk�r| j ||�\}}} nX|dk�r | j ||�\}} }n:|dk�r>| j||�\}}} n |dk�rZ| j||�\}}} | j||�}|�r�|d k�rzd nt
|�}| d k�r�d nt
| �} ||| fS |S d S )Nr� rp r� r� ) rb r� r� r� rQ r� r� r� r� r� r$ )
rn ro rw r� Z ret_index�sv�ovr� r� r� rs rs rt r� � sJ
zIndex._join_monotonicc C s t | |�}t||d�S )N)ry )rP rZ )rn Zjoinedro ry rs rs rt r� � s
zIndex._wrap_joined_indexc C s | j jtj�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� rf rg )rn rs rs rt r� s z Index.valuesc C s* | j }t|tj�r&ddlm} ||�}|S )Nr )� PandasArray)r� re rf rg Zpandas.core.arrays.numpy_r )rn r r rs rs rt 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
)r� )rn rs rs rt rl ! s z
Index._valuesc C s | j S )zR
Get the ndarray that we can pass to the IndexEngine constructor.
)rl )rn rs rs rt r� ; s zIndex._get_engine_target)r� r� c s$ t � j|d�}|| jj|d�7 }|S )N)r� )ry � memory_usager� �sizeof)rn r� rq )rz rs rt r A s zIndex.memory_usagec C sn |dkr| j }| j}| j}t|�s*t|�r8|jt�}d}tj|||�}| j r^tj
t |��r^d}t ||| j
d�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')
N)rb ry )r� rb r� r% r& r� r� rf r� �_is_numeric_dtyper� rE rZ ry )rn Zcondro rb r� rs rs rt r� I 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� rw r� )rx r� rs rs rt 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� )rx r� rs rs rt �_string_data_error� s zIndex._string_data_errorc C s2 | j }| jrt|�rd}t|gfd|i| j� ��S )z�
We need to coerce a scalar to a compat for our index type.
Parameters
----------
item : scalar item to coerce
Nrb )rb r rE rZ r� )rn r� rb rs rs rt �_coerce_scalar_to_index� s z Index._coerce_scalar_to_indexc C s | S )z<
Convert to object if we are a categorical.
rs )rn rs rs rt �_to_safe_for_reshape� s zIndex._to_safe_for_reshapec C s |S )z<
Convert value to be insertable to ndarray.
rs )rn r. rs rs rt �_convert_for_op� s zIndex._convert_for_opc C s t |�s tdt|�j� ���dS )z5
Check value is valid for scalar op.
z"'value' must be a scalar, passed: N)r5 r� rk rw )rn r. rs rs rt ru � s zIndex._assert_can_do_opc C s dS )zO
Indicates if an index is not directly backed by a numpy array
Frs )rn rs rs rt �_has_complex_internals� s z Index._has_complex_internalsc C s | j � S )zH
Return a boolean if we need a qualified .info display.
)r# )rn rs rs rt �_is_memory_usage_qualified� s z Index._is_memory_usage_qualifiedc C s
|| j kS )zN
Whether the index type is compatible with the provided type.
)r )rn r� rs rs rt �is_type_compatible� s zIndex.is_type_compatible)r� r� 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� rj )rn r� rs rs rt � __contains__� s
#
zIndex.__contains__c C s t dtt| �j�� ���d S )Nzunhashable type: )r� r� rk rw )rn rs rs rt �__hash__� s zIndex.__hash__c C s t d��d S )Nz)Index does not support mutable operations)r� )rn r� r. rs rs rt � __setitem__� s zIndex.__setitem__c C s� | j j}| j}t|�r,tj|dd�}||�S t|t�rB|||��S tj|�rZt j
|t d�}||�}t|�s�t j |�dkr�t
|� |S ||�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)rb r{ N)r� � __getitem__r� r5 r� �cast_scalar_indexerre r� Zis_bool_indexerrf rm r� rh rN )rn r� r� Zpromoterq rs rs rt r � s
zIndex.__getitem__c C s | j � s| j� 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)r# r] )rn ry rs rs rt �$_can_hold_identifiers_and_holds_name s z*Index._can_hold_identifiers_and_holds_namec C s| | g}t |ttf�r"|t|� }n
|j|� x |D ]}t |t�s2td��q2W dd� |D �}t|�dkrjdn| j}| j||�S )z�
Append a collection of Index options together.
Parameters
----------
other : Index or list/tuple of indices
Returns
-------
appended : Index
zall inputs must be Indexc S s h | ]
}|j �qS rs )ry )r� �objrs rs rt � <setcomp>? s z Index.append.<locals>.<setcomp>r{ N) re r� r~ r rZ r� ri ry �_concat)rn ro � to_concatr r� ry rs rs rt r ( s
z Index.appendc C s$ dd� |D �}t j|�}t||d�S )z5
Concatenate multiple Index objects.
c S s g | ]}t |t�r|jn|�qS rs )re rZ rl )r� r rs rs rt r� H s z!Index._concat.<locals>.<listcomp>)ry )r r: rZ )rn r ry rq rs rs rt r D s
z
Index._concatc C s� | j j� }y6tj||| j|�� t| j�r8t| �|�j}| j |�S t
t fk
r~ } z t | �rb|�| j
t�j||�S d}~X nX dS )z�
Return a new Index of the values set with the mask.
Returns
-------
Index
See Also
--------
numpy.ndarray.putmask
N)r� r rf rF r r4 rb rk r� r� rj r� r3 r� r� )rn r r. r� r� rs rs rt rF M s
z
Index.putmask)ro r� c C sr | j |�rdS t|t�s dS t| j�r<t|j� r<|j| �S t|t�rP|j| �S t|j�rd|j| �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� re rZ r3 rb r� r> r* rD rl )rn ro rs rs rt r� g s ;
z Index.equalsc s4 �j � �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� �c)ro rn rs rt r� � s z"Index.identical.<locals>.<genexpr>)r� rd � _comparablesrk )rn ro rs )ro rn rt � identical� s
zIndex.identicalc C sR y| j |dd�}W n tk
r( | jS X t|t�rF|jt| ��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{ Nr� )r� r; r� re r� r� ri )rn �labelr� rs rs rt �asof� s 8
z
Index.asofc C sl | j | j|j dd�}tj|dk|d d�}tjt| ��| j|�}|j� }d||dk|j | 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 : array-like
Array of booleans denoting where values in the original
data are not NA.
Returns
-------
numpy.ndarray
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� � searchsortedrf r� r� ri r� Zargmax)rn r� r Zlocsrq r{ rs rs rt � asof_locs s zIndex.asof_locsc C sB t | |�}|j� }|s$|ddd� }| j|�}|r:||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.
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]))
Nr{ r� )rR �argsortr� )rn r> r? r� r6 Z_asZ sorted_indexrs rs rt r@ 2 s 5
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� )rn �argsr� rs rs rt r� t 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')
zNot supported for type N)r~ rk rw )rn Zperiods�freqrs rs rt �shiftz s 8z Index.shiftc O s$ | j }|dkrtj| �}|j||�S )aE
Return the integer indices that would sort the index.
Parameters
----------
*args
Passed to `numpy.ndarray.argsort`.
**kwargs
Passed to `numpy.ndarray.argsort`.
Returns
-------
numpy.ndarray
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')
N)r� rf r r" )rn r# r� rq rs rs rt r" � s #
z
Index.argsortrY )�seriesc C sh t jdtdd� | j|� y| j|�}W n0 tk
rX | j� sD� nt|�rR|}n� Y nX | j|||�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` )ra ) rb rc rd �_check_indexing_errorr� r; � _should_fallback_to_positionalr. �_get_values_for_loc)rn r& r� r� rs rs rt � get_value� s
zIndex.get_valuec C s t |�st|��d S )N)r5 r )rn r� rs rs rt r' s zIndex._check_indexing_errorc C s | j � s| j� rdS dS )zA
Should an integer key be treated as positional?
FT)rg rV )rn rs rs rt r(
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.
)r. rl r� )rn r& r� r� rs rs rt r) s
zIndex._get_values_for_locc C s4 t jdtdd� | jj|�}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` )ra N)rb rc rd r� r� r! rb )rn �arrr� r. r� rs rs rt r� 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 : ndarray of int
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 : ndarray of int
An indexer into the target of the values not found.
These correspond to the -1 in the indexer array.
r� c C s� t |�}| j|�\}}|| k s&||k r0|j|�S | j|j�sZdtj| jtjd� }||fS t |j�rptj
|�}n|j � }| j j|�\}}t
|�|fS )Nr{ )rb r� )r� r� r� �_is_comparable_dtyperb rf Zonesr� r r' rm r� r� r$ )rn r� r� r� Z
no_matchesZ
tgt_valuesr� r� rs rs rt r� L s
z Index.get_indexer_non_uniquec K s* | j r| j|f|�S | j|f|�\}}|S )z�
Guaranteed return of an indexer even when non-unique.
This dispatches to get_indexer or get_indexer_non_unique
as appropriate.
Returns
-------
numpy.ndarray
List of indices.
)rQ r� r� )rn r� r� r� r� rs rs rt �get_indexer_for_ s zIndex.get_indexer_for)ro c C s� | j dkr@t|t�r@yt|�| �|fS tk
r< | |fS X nL| j dkrdt|t�rdt|�| �|fS | j dkr�t| j�s�| jd�|jd�fS t| j� r�t|j�r�|j | �\}} | |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.
�date� timedeltarU r� )
r re r= rk r rC r3 rb r� r� )rn ro rs rs rt r� p s
zIndex._maybe_promote)rb r� c C s dS )zF
Can we compare values of the given dtype to our own?
Trs )rn rb rs rs rt r, � s zIndex._is_comparable_dtypec s> t |t�r|j}t|�}|j� }� fdd�|j� 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 | ]\}}� j |�|�qS rs )r� )r� r� r� )rn rs rt r� � s z!Index.groupby.<locals>.<dictcomp>)re r> rl rH Z_reverse_indexer�itemsrT )rn r� rq rs )rn rt �groupby� s
z
Index.groupbyc s� ddl m} t� j||d�}| j� }|jr�t|d t�r�t| |�rJ| j}n(|j d�rn|j 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 )r� )� na_actionry N)r� Fr rb )r� r� ry Z _map_valuesr� r� re r~ r� r� ri r� rb rZ )rn rL r2 r� Z
new_values�
attributesr� )rz rs rt r � 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 )Nrs )r� rJ r� )�funcr1 rs rt r� � s z4Index._transform_index.<locals>.<listcomp>.<genexpr>)r~ � enumerate)r� r )r4 r1 rs rt r� � s z*Index._transform_index.<locals>.<listcomp>c s" g | ]}t � fd d�|D ���qS )c 3 s | ]}� |�V qd S )Nrs )r� r� )r4 rs rt r� � s z4Index._transform_index.<locals>.<listcomp>.<genexpr>)r~ )r� r )r4 rs rt r� � s )r� c s g | ] }� |��qS rs rs )r� r )r4 rs rt r� � s F)ry r� )re r> rk r� r� rZ ry )rn r4 r1 r0 rs )r4 r1 rt �_transform_index� s
zIndex._transform_indexc C s |dk r| j |� tj| |�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
-------
is_contained : ndarray
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
�isin)rn r� r1 rs rs rt r7 � s Q
z
Index.isin)r� �use_lhs�use_rhsc C s t �d S )N)r~ )rn r� r8 r9 rs rs rt �_get_string_slice< s zIndex._get_string_slicec C sB | j ||||d�\}}t|�s&td��t|�s6td��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� r� z Start slice bound is non-scalarz End slice bound is non-scalar)�
slice_locsr5 r� r� )rn r� �endr� r� � start_slice� end_slicers rs rt r� A s (zIndex.slice_indexerc C s | j � stj|�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� r )rn r� rs rs rt r� s s
zIndex._maybe_cast_indexer)r� r� c C s0 |dks t �|dkrnt|�r n | j||� dS )zz
If we are positional indexer, validate that we have appropriate
typed bounds must be an integer.
r� r� N)r� r� )r� r. r� )rn r� r� r� rs rs rt r� | s zIndex._validate_indexer)r� c C s: |dks t �t|�r"| jd|� nt|�r6| jd|� |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� )r� r� N)r� r+ r� r. )rn r r� r� rs rs rt �_maybe_cast_slice_bound� 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{ rp r� z0index must be monotonic increasing or decreasingr� )rN r rP ri rj )rn r r� �posrs rs rt r� � s z Index._searchsorted_monotonic)r� r� c C s4 |d
ks t �|dkr"td|� ���|}| j|||�}y| j|�}W nH tk
r� } z,y | j||�S tk
rx |�Y nX W Y dd}~X nX t|tj�� r�t |�r�t
j |j d��}n t
j
|jtjdd �t| ��}t|tj�� r�td
|� d t|�� ���t|t��r|dk�r|jS |jS n|dk�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� Nrp r� z@Invalid value for side kwarg, must be either 'left' or 'right': �u1F)r z Cannot get z# slice bound for non-unique label: r{ )r� r� N)rp r� )r� rj r? r� r; r� re rf rg r& r Zmaybe_booleans_to_slicer� Zmaybe_indices_to_slicer� r ri r� r� r� r� )rn r r� r� Zoriginal_labelZslcr� rs rs rt �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�| j|d|�}|dkr�d}d} |dk r�| j|d|�} | dkr�t | �} |�s|d | d } }| dk� r�| 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 offsetrp r� r{ r� r� )
re r� r r rj r� r �tzinforB ri )
rn r� r< r� r� �incZts_startZts_endr= r> rs rs rt r; s8
zIndex.slice_locsc C s | j tj| j|��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
New Index with passed location(-s) deleted.
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� rf �deleter� )rn r� rs rs rt rE Y s z Index.delete)r� c C sD t j| �}| j|�j}t j|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
N)ry )rf rm r rl Z concatenaterZ ry )rn r� r� r+ r6 rs rs rt �insertx s
z Index.insert�raise)�errorsc C sh | j dkrdnd}tj||d�}| j|�}|dk}|j� r^|dkrTt|| � d���|| }| j|�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
Raises
------
KeyError
If not all of the labels are found in the selected axis
r� N)rb r{ rc z not found in axisr� )rb r� Zindex_labels_to_arrayr� r� r; rE )rn r� rH Z arr_dtyper� r rs rs rt �drop� s
z
Index.dropc C sX t tj| �| _t tj| �| _t tj| �| _t tj| �| _ t tj
| �| _ t tj | �| _
dS )z,
Add in comparison methods.
N)rz r� �eq�__eq__�ne�__ne__r� �__lt__�gt�__gt__r� �__le__�ge�__ge__)rx rs rs rt �_add_comparison_methods� s z Index._add_comparison_methodsc C s@ t d�| _t d�| _t d�| _t d�| _t d�| _t d�| _dS )z@
Add in the numeric add/sub methods to disable.
r� r� r� r� r� �__isub__N)rQ r� r� r� r� r� rU )rx rs rs rt �%_add_numeric_methods_add_sub_disabled� s
z+Index._add_numeric_methods_add_sub_disabledc C s� t d�| _t d�| _t d�| _t d�| _t d�| _t d�| _t d�| _t d�| _t d �| _ t d
�| _
t d �| _ t d �| _ t d
�| _
t d�| _dS )zG
Add in numeric methods to disable other than add/sub.
�__pow__�__rpow__�__mul__�__rmul__� __floordiv__�
__rfloordiv__� __truediv__� __rtruediv__�__mod__�
__divmod__�__neg__�__pos__�__abs__�__inv__N)rQ rW rX rY rZ r[ r\ r] r^ r_ r` ra rb rc rd )rx rs rs rt � _add_numeric_methods_disabled� s
z#Index._add_numeric_methods_disabledc C s� t tj| �| _t tj| �| _t tj| �| _t tj | �| _
t tj | �| _ t tj
| �| _t tj| �| _t tj| �| _t tj| �| _t tj| �| _t tj| �| _t t| �| _t tj| �| _ t tj | �| _ dS )z)
Add in numeric methods.
N) r� r� �addr� rF Zraddr� �subr� Zrsubr� ZrpowrX �powrW �truedivr] Zrtruedivr^ �modr_ �floordivr[ Z rfloordivr\ �divmodr` �mulrY ZrmulrZ )rx rs rs rt �_add_numeric_methods_binary� s z!Index._add_numeric_methods_binaryc C sL t d�dd�}|tjd�| _|tjd�| _|tjd�| _|dd� d �| _ d
S ) z/
Add in numeric unary methods.
)�opstrc s � fdd�}||_ |S )Nc s | j � }t� | j�f|�S )N)r� rZ r� )rn r� )rr rs rt �_evaluate_numeric_unary� s z_Index._add_numeric_methods_unary.<locals>._make_evaluate_unary.<locals>._evaluate_numeric_unary)rw )rr ro rp rs )rr rt �_make_evaluate_unary� s z>Index._add_numeric_methods_unary.<locals>._make_evaluate_unaryra rb rc c S s | S )Nrs )r rs rs rt r� s z2Index._add_numeric_methods_unary.<locals>.<lambda>rd N)
�str_tr� �negra r@ rb rf r� rc rd )rx rq rs rs rt �_add_numeric_methods_unary� s
z Index._add_numeric_methods_unaryc C s | j � | j� d S )N)rt rn )rx rs rs rt �_add_numeric_methods s zIndex._add_numeric_methodsc sT d� t d�td< t d�td< ttd�� fdd� }|d d
tj�| _|d d tj�| _d
S )z)
Add in logical methods.
a~
%(desc)s
Parameters
----------
*args
These parameters will be passed to numpy.%(outname)s.
**kwargs
These parameters will be passed to numpy.%(outname)s.
Returns
-------
%(outname)s : bool or array_like (if axis is specified)
A single element array_like may be converted to bool.a�
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
Z index_alla�
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
Z index_any)ry �descc s: t | |d�ttd| �t��� fdd����}| |_|S )N)�outnamerv Zindex_c s> � | j �}t|tjttf�r6|jdkr6|jj|j � �S |S d S )Nr )
r� re rf rg rB rZ rh rb rk r� )rn r# r� rq )�frs rt � logical_funcb s
zPIndex._add_logical_methods.<locals>._make_logical_function.<locals>.logical_func)r r �_index_shared_docsrw )ry rv rx ry )�_doc)rx rt �_make_logical_functiona s
z:Index._add_logical_methods.<locals>._make_logical_functionrd z%Return whether all elements are True.r� z#Return whether any element is True.N)r rz rr rf rd r� )rx r| rs )r{ rt �_add_logical_methods
s '
zIndex._add_logical_methodsc C s t d�| _t d�| _dS )z4
Add in logical methods to disable.
rd r� N)rQ rd r� )rx rs rs rt � _add_logical_methods_disabledz s
z#Index._add_logical_methods_disabledc C s | j jS )zE
Return a tuple of the shape of the underlying data.
)rl r� )rn rs rs rt r� � s z Index.shape)NNFNT)N)N)N)r� )N)T)r TN)N)NFNN)N)N)FNr )r )N)r] N)N)NN)TN)NNF)N)NF)F)NTN)r )N)NN)r� )N)r{ )r{ )F)N)F)N)NN)NN)NNN)NN)N)NNNN)rp NFF)T)rp F)rp FT)rp F)F)N)FTN)r{ N)N)N)N)TT)NNNN)rp )NNNN)rG )�rw �
__module__� __qualname__�__doc__rM Z
_deprecationsrL � frozensetr r� r� r� r� r� r� r� r rI rf rg r� r� r� r r, r� r r� r r� Z_defer_to_indexing�libindexZ ObjectEnginer� Z!_supports_partial_string_indexingZ
_accessorsrG rS r� �propertyr� � classmethodr� r r� r� r r� r� r� r� r� r9 r� r� r� rb r� r� r� rz r �_index_doc_kwargsr� rG r� r� r r� r� rr r r r r� r� r
r r r
r r r" r! r' r( r) r+ ry �setterr� r0 r2 r� r� r7 r5 r8 r< r= rA rB Zget_level_valuesrK rM rO rN rP rR rS rQ rT rV r. r[ r\ r# r] r_ re rg r rj rl r� ro rr rs rE Zisnullrt Znotnullrv rx r` r} ra r r� r� r� 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� r� r� r r rl r� r r� r� r r r
r ru r r
r r r r r r r r r rF r� r r r! r@ r� r% r" r* r' r( r) r� r� r- r� r r, rT r r1 r r6 r7 r: r� r� r� r? r� rB r; rE rF rI rT rV re rn rt ru r} r~ r� �
__classcell__rs rs )rz rt rZ � s�
+
J: &
?@ N 6 ' > ##++(+!%
7, 08$ ;D P > M h2
F < @zN
0 6 ) %
O A ' A :*& * +U 2 $DY pc 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 )r� r{ N)ry )r� )r� r� ri rZ � from_arrays)� sequencesr� r� rs rs rt �ensure_index_from_sequences� s r� Fc C s� t | t�r|r| j� } | S t| d�r4t| | j|d�S t| �rDt| �} t | t�r�t| �tkrbt| �} tj | �\}}t
|�dkr�|r�ddl m } |j
|�S |} n |r�t| �} t| �S )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')],
)
ry )ry r r )r� )re rZ r r� ry r1 r� rk r Zclean_index_listri r� r� r� � copy_func)Z
index_liker Z convertedZ
all_arraysr� rs rs rt 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)ri r� r� )�seqrs rs rt r� � s
r� )�stringsr� c C s: | }x0t | �dkr4tdd� |D ��r4dd� |D �}qW |S )z)
Trims zeros and decimal points.
r c s s | ]}|d dkV qdS )r r Nrs )r� r rs rs rt r� s z trim_front.<locals>.<genexpr>c S s g | ]}|d d� �qS )r{ Nrs )r� r rs rs rt r� s z trim_front.<locals>.<listcomp>)ri rd )r� Ztrimmedrs rs rt r s r )r� c C s | dkrt d| � ���d S )Nrp r� r� r� z do not recognize join method )rp r� r� r� )rj )r� rs rs rt r� s r� c C s ddl m} |d| d d�S )Nr )r� )ry )r� r� )�nr� rs rs rt �
default_index s 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)re rZ rB ry r- r� rw )ry r rx rs rs rt r� s
r� )r� rb r r� c C s� t |�r�tj| dd�}|dkr.t| ||d�} q�|d
kr�t| �j� rJtd��|dkr\t| |�} yt| ||�} W q� tk
r� tj | tj
|d�} Y q�X q�|d kr�q�| j |�} n<t |�r�tj| dd�}|d kr�q�| j |�} ntj | ||d�} | S ) z�
If a dtype is passed, cast to the closest matching dtype that is supported
by Index.
Parameters
----------
data : np.ndarray
dtype : np.dtype
copy : bool
Returns
-------
np.ndarray
F)rh rW )r rX �mixed-integer-floatz#cannot convert float NaN to integer)rb r r )rX r� )
r/ r ri r rE r� rj �_try_convert_to_int_arrayrf r �float64r� r, )r� rb r �inferredrs rs rt r� + s.
r� c C sf ddl m}m}m}m} tj| dd�}|dkrbyt| dd�}||jfS t k
rX Y nX | t
fS |dkrt| t j fS |d
kr�y|j
| dd �}||jfS t k
r� Y nX n�|d kr�n�|d
k�r\|jd��ry|j
| dd �}||jfS t tfk
� r� Y nX nZ|jd��r&|j
| dd �}||jfS |dk�r\y|j
| �}||jfS tk
�rZ Y nX | | jfS )a
If we have an arraylike input but no passed dtype, try to infer
a supported dtype.
Parameters
----------
subarr : np.ndarray, Index, or Series
Returns
-------
converted : np.ndarray or ExtensionArray
dtype : np.dtype or ExtensionDtype
r )�
DatetimeArray�
IntervalArray� PeriodArray�TimedeltaArrayF)rh rW NrX �mixed-integer-float�
integer-nar^ )r rU r r r/ Zperiod)rX r� r� )�pandas.core.arraysr� r� r� r� r ri r� rb rj r� rf r� r� �
startswithr r )r� r� r� r� r� r� r� rs rs rt r� a sH
r� )r� r rb r� c C s� t |�sFy"| jddd�}|| kj� r(|S W n tttfk
rD Y nX y"| jddd�}|| kj� rf|S W n tttfk
r� Y nX t�dS )a�
Attempt to convert an array of data into an integer array.
Parameters
----------
data : The data to convert.
copy : bool
Whether to copy the data or not.
dtype : np.dtype
Returns
-------
int_array : data converted to either an ndarray[int64] or ndarray[uint64]
Raises
------
ValueError if the conversion was not successful.
�i8F)r �u8N)r8 r� rd r r� rj )r� r rb r rs rs rt r� � s r� )r ry c K sB t t| �r*||fd|d�|��}|jt�S ||f| ||d�|��S )a�
If an object dtype was specified, create the non-object Index
and then convert it to object.
Parameters
----------
dtype : np.dtype, ExtensionDtype, str
klass : Index subclass
data : list-like
copy : bool
name : hashable
**kwargs
Returns
-------
Index
Notes
-----
We assume that calling .astype(object) on this klass will make a copy.
F)r ry )rb r ry )r) �_o_dtyper� r� )rb r^ r� r ry r� r rs rs rt r� � s
r� )r[ r\ )N)F)�r r� r r� �textwrapr Ztypingr r r r r r
r r rb Znumpyrf Z pandas._libsr
r� r r� r Zpandas._libs.joinZ_libsr r� Zpandas._libs.libr r Zpandas._libs.tslibsr r Zpandas._libs.tslibs.periodr Z pandas._libs.tslibs.timezonesr Zpandas._typingr r Z
pandas.compatr Zpandas.compat.numpyr r� Z
pandas.errorsr Zpandas.util._decoratorsr r r r Zpandas.core.dtypesr r Zpandas.core.dtypes.castr r! Zpandas.core.dtypes.commonr" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 Zpandas.core.dtypes.concatr: Zpandas.core.dtypes.genericr; r< r= r> r? r@ rA rB rC Zpandas.core.dtypes.missingrD rE Z pandas.corerF Zpandas.core.accessorrG Zpandas.core.algorithms�coreZ
algorithmsr� rH rI Z pandas.core.arrays.datetimesrJ rK Zpandas.core.baserL rM Zpandas.core.common�commonr� Zpandas.core.indexersrN Zpandas.core.indexes.frozenrO Zpandas.core.missingr� Zpandas.core.opsrP Zpandas.core.ops.invalidrQ Zpandas.core.sortingrR Zpandas.core.stringsrS Zpandas.io.formats.printingrT rU rV rW rX r} rY �__all__r� Z_unsortable_typesr� r� rz r� rr rz r� rb r� r� r� r� rZ re r} rT r� r� r� r� r r� r� r� rg r� r� r� r� rs rs rs rt �<module> s� (
h , #
t
(@
6H
) |