# Index objects

## Index

Many of these methods or variants thereof are available on the objects that contain an index (Series/DataFrame) and those should most likely be used before calling these methods directly.

`Index`([data, dtype, copy, name, tupleize_cols]) | Immutable sequence used for indexing and alignment.

### Properties

`Index.values` | Return an array representing the data in the Index.
`Index.is_monotonic` | Alias for is_monotonic_increasing.
`Index.is_monotonic_increasing` | Return if the index is monotonic increasing (only equal or increasing) values.
`Index.is_monotonic_decreasing` | Return if the index is monotonic decreasing (only equal or decreasing) values.
`Index.is_unique` | Return if the index has unique values.
`Index.has_duplicates` | Check if the Index has duplicate values.
`Index.hasnans` | Return if I have any nans; enables various perf speedups.
`Index.dtype` | Return the dtype object of the underlying data.
`Index.inferred_type` | Return a string of the type inferred from the values.
`Index.is_all_dates` | Whether or not the index values only consist of dates.
`Index.shape` | Return a tuple of the shape of the underlying data.
`Index.name` | Return Index or MultiIndex name.
`Index.names` |
`Index.nbytes` | Return the number of bytes in the underlying data.
`Index.ndim` | Number of dimensions of the underlying data, by definition 1.
`Index.size` | Return the number of elements in the underlying data.
`Index.empty` |
`Index.T` | Return the transpose, which is by definition self.
`Index.memory_usage`([deep]) | Memory usage of the values.

### Modifying and computations

`Index.all`(*args, **kwargs) | Return whether all elements are Truthy.
`Index.any`(*args, **kwargs) | Return whether any element is Truthy.
`Index.argmin`([axis, skipna]) | Return int position of the smallest value in the Series.
`Index.argmax`([axis, skipna]) | Return int position of the largest value in the Series.
`Index.copy`([name, deep, dtype, names]) | Make a copy of this object.
`Index.delete`(loc) | Make new Index with passed location(-s) deleted.
`Index.drop`(labels[, errors]) | Make new Index with passed list of labels deleted.
`Index.drop_duplicates`([keep]) | Return Index with duplicate values removed.
`Index.duplicated`([keep]) | Indicate duplicate index values.
`Index.equals`(other) | Determine if two Index object are equal.
`Index.factorize`([sort, na_sentinel]) | Encode the object as an enumerated type or categorical variable.
`Index.identical`(other) | Similar to equals, but checks that object attributes and types are also equal.
`Index.insert`(loc, item) | Make new Index inserting new item at location.
`Index.is_`(other) | More flexible, faster check like `is` but that works through views.
`Index.is_boolean`() | Check if the Index only consists of booleans.
`Index.is_categorical`() | Check if the Index holds categorical data.
`Index.is_floating`() | Check if the Index is a floating type.
`Index.is_integer`() | Check if the Index only consists of integers.
`Index.is_interval`() | Check if the Index holds Interval objects.
`Index.is_mixed`() | Check if the Index holds data with mixed data types.
`Index.is_numeric`() | Check if the Index only consists of numeric data.
`Index.is_object`() | Check if the Index is of the object dtype.
`Index.min`([axis, skipna]) | Return the minimum value of the Index.
`Index.max`([axis, skipna]) | Return the maximum value of the Index.
`Index.reindex`(target[, method, level, ...]) | Create index with target's values.
`Index.rename`(name[, inplace]) | Alter Index or MultiIndex name.
`Index.repeat`(repeats[, axis]) | Repeat elements of a Index.
`Index.where`(cond[, other]) | Replace values where the condition is False.
`Index.take`(indices[, axis, allow_fill, ...]) | Return a new Index of the values selected by the indices.
`Index.putmask`(mask, value) | Return a new Index of the values set with the mask.
`Index.unique`([level]) | Return unique values in the index.
`Index.nunique`([dropna]) | Return number of unique elements in the object.
`Index.value_counts`([normalize, sort, ...]) | Return a Series containing counts of unique values.

### Compatibility with MultiIndex

`Index.set_names`(names[, level, inplace]) | Set Index or MultiIndex name.
`Index.droplevel`([level]) | Return index with requested level(s) removed.

### Missing values

`Index.fillna`([value, downcast]) | Fill NA/NaN values with the specified value.
`Index.dropna`([how]) | Return Index without NA/NaN values.
`Index.isna`() | Detect missing values.
`Index.notna`() | Detect existing (non-missing) values.

### Conversion

`Index.astype`(dtype[, copy]) | Create an Index with values cast to dtypes.
`Index.item`() | Return the first element of the underlying data as a Python scalar.
`Index.map`(mapper[, na_action]) | Map values using input correspondence (a dict, Series, or function).
`Index.ravel`([order]) | Return an ndarray of the flattened values of the underlying data.
`Index.to_list`() | Return a list of the values.
`Index.to_native_types`([slicer]) | (DEPRECATED) Format specified values of self and return them.
`Index.to_series`([index, name]) | Create a Series with both index and values equal to the index keys.
`Index.to_frame`([index, name]) | Create a DataFrame with a column containing the Index.
`Index.view`([cls]) |

### Sorting

`Index.argsort`(*args, **kwargs) | Return the integer indices that would sort the index.
`Index.searchsorted`(value[, side, sorter]) | Find indices where elements should be inserted to maintain order.
`Index.sort_values`([return_indexer, ...]) | Return a sorted copy of the index.

### Time-specific operations

`Index.shift`([periods, freq]) | Shift index by desired number of time frequency increments.

### Combining / joining / set operations

`Index.append`(other) | Append a collection of Index options together.
`Index.join`(other[, how, level, ...]) | Compute join_index and indexers to conform data structures to the new index.
`Index.intersection`(other[, sort]) | Form the intersection of two Index objects.
`Index.union`(other[, sort]) | Form the union of two Index objects.
`Index.difference`(other[, sort]) | Return a new Index with elements of index not in other.
`Index.symmetric_difference`(other[, ...]) | Compute the symmetric difference of two Index objects.

### Selecting

`Index.asof`(label) | Return the label from the index, or, if not present, the previous one.
`Index.asof_locs`(where, mask) | Return the locations (indices) of labels in the index.
`Index.get_indexer`(target[, method, limit, ...]) | Compute indexer and mask for new index given the current index.
`Index.get_indexer_for`(target, **kwargs) | Guaranteed return of an indexer even when non-unique.
`Index.get_indexer_non_unique`(target) | Compute indexer and mask for new index given the current index.
`Index.get_level_values`(level) | Return an Index of values for requested level.
`Index.get_loc`(key[, method, tolerance]) | Get integer location, slice or boolean mask for requested label.
`Index.get_slice_bound`(label, side[, kind]) | Calculate slice bound that corresponds to given label.
`Index.get_value`(series, key) | Fast lookup of value from 1-dimensional ndarray.
`Index.isin`(values[, level]) | Return a boolean array where the index values are in values.
`Index.slice_indexer`([start, end, step, kind]) | Compute the slice indexer for input labels and step.
`Index.slice_locs`([start, end, step, kind]) | Compute slice locations for input labels.

## Numeric Index

`RangeIndex`([start, stop, step, dtype, copy, ...]) | Immutable Index implementing a monotonic integer range.
`Int64Index`([data, dtype, copy, name]) | Immutable sequence used for indexing and alignment.
`UInt64Index`([data, dtype, copy, name]) | Immutable sequence used for indexing and alignment.
`Float64Index`([data, dtype, copy, name]) | Immutable sequence used for indexing and alignment.

`RangeIndex.start` | The value of the start parameter (`0` if this was not supplied).
`RangeIndex.stop` | The value of the stop parameter.
`RangeIndex.step` | The value of the step parameter (`1` if this was not supplied).
`RangeIndex.from_range`(data[, name, dtype]) | Create RangeIndex from a range object.

## CategoricalIndex

`CategoricalIndex`([data, categories, ...]) | Index based on an underlying `Categorical`.

### Categorical components

`CategoricalIndex.codes` | The category codes of this categorical.
`CategoricalIndex.categories` | The categories of this categorical.
`CategoricalIndex.ordered` | Whether the categories have an ordered relationship.
`CategoricalIndex.rename_categories`(*args, ...) | Rename categories.
`CategoricalIndex.reorder_categories`(*args, ...) | Reorder categories as specified in new_categories.
`CategoricalIndex.add_categories`(*args, **kwargs) | Add new categories.
`CategoricalIndex.remove_categories`(*args, ...) | Remove the specified categories.
`CategoricalIndex.remove_unused_categories`(...) | Remove categories which are not used.
`CategoricalIndex.set_categories`(*args, **kwargs) | Set the categories to the specified new_categories.
`CategoricalIndex.as_ordered`(*args, **kwargs) | Set the Categorical to be ordered.
`CategoricalIndex.as_unordered`(*args, **kwargs) | Set the Categorical to be unordered.

### Modifying and computations

`CategoricalIndex.map`(mapper) | Map values using input correspondence (a dict, Series, or function).
`CategoricalIndex.equals`(other) | Determine if two CategoricalIndex objects contain the same elements.

## IntervalIndex

`IntervalIndex`(data[, closed, dtype, copy, ...]) | Immutable index of intervals that are closed on the same side.

### IntervalIndex components

`IntervalIndex.from_arrays`(left, right[, ...]) | Construct from two arrays defining the left and right bounds.
`IntervalIndex.from_tuples`(data[, closed, ...]) | Construct an IntervalIndex from an array-like of tuples.
`IntervalIndex.from_breaks`(breaks[, closed, ...]) | Construct an IntervalIndex from an array of splits.
`IntervalIndex.left` |
`IntervalIndex.right` |
`IntervalIndex.mid` |
`IntervalIndex.closed` | Whether the intervals are closed on the left-side, right-side, both or neither.
`IntervalIndex.length` |
`IntervalIndex.values` | Return an array representing the data in the Index.
`IntervalIndex.is_empty` | Indicates if an interval is empty, meaning it contains no points.
`IntervalIndex.is_non_overlapping_monotonic` | Return True if the IntervalArray is non-overlapping (no Intervals share points) and is either monotonic increasing or monotonic decreasing, else False.
`IntervalIndex.is_overlapping` | Return True if the IntervalIndex has overlapping intervals, else False.
`IntervalIndex.get_loc`(key[, method, tolerance]) | Get integer location, slice or boolean mask for requested label.
`IntervalIndex.get_indexer`(target[, method, ...]) | Compute indexer and mask for new index given the current index.
`IntervalIndex.set_closed`(*args, **kwargs) | Return an IntervalArray identical to the current one, but closed on the specified side.
`IntervalIndex.contains`(*args, **kwargs) | Check elementwise if the Intervals contain the value.
`IntervalIndex.overlaps`(*args, **kwargs) | Check elementwise if an Interval overlaps the values in the IntervalArray.
`IntervalIndex.to_tuples`(*args, **kwargs) | Return an ndarray of tuples of the form (left, right).

## MultiIndex

`MultiIndex`([levels, codes, sortorder, ...]) | A multi-level, or hierarchical, index object for pandas objects.

`IndexSlice` | Create an object to more easily perform multi-index slicing.

### MultiIndex constructors

`MultiIndex.from_arrays`(arrays[, sortorder, ...]) | Convert arrays to MultiIndex.
`MultiIndex.from_tuples`(tuples[, sortorder, ...]) | Convert list of tuples to MultiIndex.
`MultiIndex.from_product`(iterables[, ...]) | Make a MultiIndex from the cartesian product of multiple iterables.
`MultiIndex.from_frame`(df[, sortorder, names]) | Make a MultiIndex from a DataFrame.

### MultiIndex properties

`MultiIndex.names` | Names of levels in MultiIndex.
`MultiIndex.levels` |
`MultiIndex.codes` |
`MultiIndex.nlevels` | Integer number of levels in this MultiIndex.
`MultiIndex.levshape` | A tuple with the length of each level.
`MultiIndex.dtypes` | Return the dtypes as a Series for the underlying MultiIndex

### MultiIndex components

`MultiIndex.set_levels`(levels[, level, ...]) | Set new levels on MultiIndex.
`MultiIndex.set_codes`(codes[, level, ...]) | Set new codes on MultiIndex.
`MultiIndex.to_flat_index`() | Convert a MultiIndex to an Index of Tuples containing the level values.
`MultiIndex.to_frame`([index, name]) | Create a DataFrame with the levels of the MultiIndex as columns.
`MultiIndex.sortlevel`([level, ascending, ...]) | Sort MultiIndex at the requested level.
`MultiIndex.droplevel`([level]) | Return index with requested level(s) removed.
`MultiIndex.swaplevel`([i, j]) | Swap level i with level j.
`MultiIndex.reorder_levels`(order) | Rearrange levels using input order.
`MultiIndex.remove_unused_levels`() | Create new MultiIndex from current that removes unused levels.

### MultiIndex selecting

`MultiIndex.get_loc`(key[, method]) | Get location for a label or a tuple of labels.
`MultiIndex.get_locs`(seq) | Get location for a sequence of labels.
`MultiIndex.get_loc_level`(key[, level, ...]) | Get location and sliced index for requested label(s)/level(s).
`MultiIndex.get_indexer`(target[, method, ...]) | Compute indexer and mask for new index given the current index.
`MultiIndex.get_level_values`(level) | Return vector of label values for requested level.

## DatetimeIndex

`DatetimeIndex`([data, freq, tz, normalize, ...]) | Immutable ndarray-like of datetime64 data.

### Time/date components

`DatetimeIndex.year` | The year of the datetime.
`DatetimeIndex.month` | The month as January=1, December=12.
`DatetimeIndex.day` | The day of the datetime.
`DatetimeIndex.hour` | The hours of the datetime.
`DatetimeIndex.minute` | The minutes of the datetime.
`DatetimeIndex.second` | The seconds of the datetime.
`DatetimeIndex.microsecond` | The microseconds of the datetime.
`DatetimeIndex.nanosecond` | The nanoseconds of the datetime.
`DatetimeIndex.date` | Returns numpy array of python datetime.date objects (namely, the date part of Timestamps without timezone information).
`DatetimeIndex.time` | Returns numpy array of datetime.time.
`DatetimeIndex.timetz` | Returns numpy array of datetime.time also containing timezone information.
`DatetimeIndex.dayofyear` | The ordinal day of the year.
`DatetimeIndex.day_of_year` | The ordinal day of the year.
`DatetimeIndex.weekofyear` | (DEPRECATED) The week ordinal of the year.
`DatetimeIndex.week` | (DEPRECATED) The week ordinal of the year.
`DatetimeIndex.dayofweek` | The day of the week with Monday=0, Sunday=6.
`DatetimeIndex.day_of_week` | The day of the week with Monday=0, Sunday=6.
`DatetimeIndex.weekday` | The day of the week with Monday=0, Sunday=6.
`DatetimeIndex.quarter` | The quarter of the date.
`DatetimeIndex.tz` | Return timezone, if any.
`DatetimeIndex.freq` | Return the frequency object if it is set, otherwise None.
`DatetimeIndex.freqstr` | Return the frequency object as a string if its set, otherwise None.
`DatetimeIndex.is_month_start` | Indicates whether the date is the first day of the month.
`DatetimeIndex.is_month_end` | Indicates whether the date is the last day of the month.
`DatetimeIndex.is_quarter_start` | Indicator for whether the date is the first day of a quarter.
`DatetimeIndex.is_quarter_end` | Indicator for whether the date is the last day of a quarter.
`DatetimeIndex.is_year_start` | Indicate whether the date is the first day of a year.
`DatetimeIndex.is_year_end` | Indicate whether the date is the last day of the year.
`DatetimeIndex.is_leap_year` | Boolean indicator if the date belongs to a leap year.
`DatetimeIndex.inferred_freq` | Tries to return a string representing a frequency guess, generated by infer_freq.

### Selecting

`DatetimeIndex.indexer_at_time`(time[, asof]) | Return index locations of values at particular time of day (e.g.
`DatetimeIndex.indexer_between_time`(...[, ...]) | Return index locations of values between particular times of day (e.g., 9:00-9:30AM).

### Time-specific operations

`DatetimeIndex.normalize`(*args, **kwargs) | Convert times to midnight.
`DatetimeIndex.strftime`(*args, **kwargs) | Convert to Index using specified date_format.
`DatetimeIndex.snap`([freq]) | Snap time stamps to nearest occurring frequency.
`DatetimeIndex.tz_convert`(tz) | Convert tz-aware Datetime Array/Index from one time zone to another.
`DatetimeIndex.tz_localize`(tz[, ambiguous, ...]) | Localize tz-naive Datetime Array/Index to tz-aware Datetime Array/Index.
`DatetimeIndex.round`(*args, **kwargs) | Perform round operation on the data to the specified freq.
`DatetimeIndex.floor`(*args, **kwargs) | Perform floor operation on the data to the specified freq.
`DatetimeIndex.ceil`(*args, **kwargs) | Perform ceil operation on the data to the specified freq.
`DatetimeIndex.month_name`(*args, **kwargs) | Return the month names of the DateTimeIndex with specified locale.
`DatetimeIndex.day_name`(*args, **kwargs) | Return the day names of the DateTimeIndex with specified locale.

### Conversion

`DatetimeIndex.to_period`(*args, **kwargs) | Cast to PeriodArray/Index at a particular frequency.
`DatetimeIndex.to_perioddelta`(freq) | Calculate TimedeltaArray of difference between index values and index converted to PeriodArray at specified freq.
`DatetimeIndex.to_pydatetime`(*args, **kwargs) | Return Datetime Array/Index as object ndarray of datetime.datetime objects.
`DatetimeIndex.to_series`([keep_tz, index, name]) | Create a Series with both index and values equal to the index keys useful with map for returning an indexer based on an index.
`DatetimeIndex.to_frame`([index, name]) | Create a DataFrame with a column containing the Index.

### Methods

`DatetimeIndex.mean`(*args, **kwargs) | Return the mean value of the Array.

## TimedeltaIndex

`TimedeltaIndex`([data, unit, freq, closed, ...]) | Immutable ndarray of timedelta64 data, represented internally as int64, and which can be boxed to timedelta objects.

### Components

`TimedeltaIndex.days` | Number of days for each element.
`TimedeltaIndex.seconds` | Number of seconds (>= 0 and less than 1 day) for each element.
`TimedeltaIndex.microseconds` | Number of microseconds (>= 0 and less than 1 second) for each element.
`TimedeltaIndex.nanoseconds` | Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.
`TimedeltaIndex.components` | Return a dataframe of the components (days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds) of the Timedeltas.
`TimedeltaIndex.inferred_freq` | Tries to return a string representing a frequency guess, generated by infer_freq.

### Conversion

`TimedeltaIndex.to_pytimedelta`(*args, **kwargs) | Return Timedelta Array/Index as object ndarray of datetime.timedelta objects.
`TimedeltaIndex.to_series`([index, name]) | Create a Series with both index and values equal to the index keys.
`TimedeltaIndex.round`(*args, **kwargs) | Perform round operation on the data to the specified freq.
`TimedeltaIndex.floor`(*args, **kwargs) | Perform floor operation on the data to the specified freq.
`TimedeltaIndex.ceil`(*args, **kwargs) | Perform ceil operation on the data to the specified freq.
`TimedeltaIndex.to_frame`([index, name]) | Create a DataFrame with a column containing the Index.

### Methods

`TimedeltaIndex.mean`(*args, **kwargs) | Return the mean value of the Array.

## PeriodIndex

`PeriodIndex`([data, ordinal, freq, dtype, ...]) | Immutable ndarray holding ordinal values indicating regular periods in time.

### Properties

`PeriodIndex.day` | The days of the period.
`PeriodIndex.dayofweek` | The day of the week with Monday=0, Sunday=6.
`PeriodIndex.day_of_week` | The day of the week with Monday=0, Sunday=6.
`PeriodIndex.dayofyear` | The ordinal day of the year.
`PeriodIndex.day_of_year` | The ordinal day of the year.
`PeriodIndex.days_in_month` | The number of days in the month.
`PeriodIndex.daysinmonth` | The number of days in the month.
`PeriodIndex.end_time` |
`PeriodIndex.freq` | Return the frequency object if it is set, otherwise None.
`PeriodIndex.freqstr` | Return the frequency object as a string if its set, otherwise None.
`PeriodIndex.hour` | The hour of the period.
`PeriodIndex.is_leap_year` | Logical indicating if the date belongs to a leap year.
`PeriodIndex.minute` | The minute of the period.
`PeriodIndex.month` | The month as January=1, December=12.
`PeriodIndex.quarter` | The quarter of the date.
`PeriodIndex.qyear` |
`PeriodIndex.second` | The second of the period.
`PeriodIndex.start_time` |
`PeriodIndex.week` | The week ordinal of the year.
`PeriodIndex.weekday` | The day of the week with Monday=0, Sunday=6.
`PeriodIndex.weekofyear` | The week ordinal of the year.
`PeriodIndex.year` | The year of the period.

### Methods

`PeriodIndex.asfreq`([freq, how]) | Convert the PeriodArray to the specified frequency freq.
`PeriodIndex.strftime`(*args, **kwargs) | Convert to Index using specified date_format.
`PeriodIndex.to_timestamp`([freq, how]) | Cast to DatetimeArray/Index.