# 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` | Immutable ndarray implementing an ordered, sliceable set.

### 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` |
`Index.hasnans` | Return if I have any nans; enables various perf speedups.
`Index.dtype` | Return the dtype object of the underlying data.
`Index.dtype_str` | (DEPRECATED) Return the dtype str of the underlying data.
`Index.inferred_type` | Return a string of the type inferred from the values.
`Index.is_all_dates` |
`Index.shape` | Return a tuple of the shape of the underlying data.
`Index.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.strides` | (DEPRECATED) Return the strides of the underlying data.
`Index.itemsize` | (DEPRECATED) Return the size of the dtype of the item of the underlying data.
`Index.base` | (DEPRECATED) Return the base object if the memory of the underlying data is shared.
`Index.T` | Return the transpose, which is by
`Index.memory_usage`([deep]) | Memory usage of the values

### Modifying and computations

`Index.all`(*args, **kwargs) | Return whether all elements are True.
`Index.any`(*args, **kwargs) | Return whether any element is True.
`Index.argmin`([axis, skipna]) | Return a ndarray of the minimum argument indexer.
`Index.argmax`([axis, skipna]) | Return an ndarray of the maximum argument indexer.
`Index.copy`([name, deep, dtype]) | 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 objects contain the same elements.
`Index.factorize`([sort, na_sentinel]) | Encode the object as an enumerated type or categorical variable.
`Index.identical`(other) | Similar to equals, but check that other comparable attributes 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`() |
`Index.is_categorical`() | Check if the Index holds categorical data.
`Index.is_floating`() |
`Index.is_integer`() |
`Index.is_interval`() |
`Index.is_mixed`() |
`Index.is_numeric`() |
`Index.is_object`() |
`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 (move/add/delete values as necessary).
`Index.rename`(name[, inplace]) | Alter Index or MultiIndex name.
`Index.repeat`(repeats[, axis]) | Repeat elements of a Index.
`Index.where`(cond[, other]) | Return an Index of same shape as self and whose corresponding entries are from self where cond is True and otherwise are from other.
`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.is_lexsorted_for_tuple`(tup) |
`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]) | 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 useful with map for returning an indexer based on an index.
`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, ascending]) | 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 from the index that are 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) | Find the locations (indices) of the labels from the index for every entry in the where argument.
`Index.contains`(key) | (DEPRECATED) Return a boolean indicating whether the provided key is in the index.
`Index.get_duplicates`() | (DEPRECATED) Extract duplicated index elements.
`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.get_values`() | (DEPRECATED) Return Index data as an numpy.ndarray.
`Index.set_value`(arr, key, value) | 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]) | For an ordered or unique index, 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` | Immutable Index implementing a monotonic integer range.
`Int64Index` | Immutable ndarray implementing an ordered, sliceable set.
`UInt64Index` | Immutable ndarray implementing an ordered, sliceable set.
`Float64Index` | Immutable ndarray implementing an ordered, sliceable set.

`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` | Index based on an underlying `Categorical`.

### Categorical components

`CategoricalIndex.codes` |
`CategoricalIndex.categories` |
`CategoricalIndex.ordered` |
`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` | 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` | Return the left endpoints of each Interval in the IntervalIndex as an Index
`IntervalIndex.right` | Return the right endpoints of each Interval in the IntervalIndex as an Index
`IntervalIndex.mid` | Return the midpoint of each Interval in the IntervalIndex as an Index
`IntervalIndex.closed` | Whether the intervals are closed on the left-side, right-side, both or neither
`IntervalIndex.length` | Return an Index with entries denoting the length of each Interval in the IntervalIndex
`IntervalIndex.values` | Return the IntervalIndex’s data as an IntervalArray.
`IntervalIndex.is_empty` | Indicates if an interval is empty, meaning it contains no points.
`IntervalIndex.is_non_overlapping_monotonic` | Return True if the IntervalIndex 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) | 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`(closed) | Return an IntervalIndex identical to the current one, but closed on the specified side
`IntervalIndex.contains`(other) | Check elementwise if the Intervals contain the value.
`IntervalIndex.overlaps`(other) | Check elementwise if an Interval overlaps the values in the IntervalIndex.
`IntervalIndex.to_tuples`([na_tuple]) | Return an Index of tuples of the form (left, right)

## MultiIndex

`MultiIndex` | 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 components

`MultiIndex.set_levels`(levels[, level, …]) | Set new levels on MultiIndex.
`MultiIndex.set_codes`(codes[, level, …]) | Set new codes on MultiIndex.
`MultiIndex.to_hierarchical`(n_repeat[, n_shuffle]) | (DEPRECATED) Return a MultiIndex reshaped to conform to the shapes given by n_repeat and n_shuffle.
`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.is_lexsorted`() | Return True if the codes are lexicographically sorted
`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 a new MultiIndex from the current that removes unused levels, meaning that they are not expressed in the labels.

### MultiIndex selecting

`MultiIndex.get_loc`(key[, method]) | Get location for a label or a tuple of labels as an integer, slice or boolean mask.
`MultiIndex.get_loc_level`(key[, level, …]) | Get both the location for the requested label(s) and the resulting sliced index.
`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, equal to the length of the index.

## DatetimeIndex

`DatetimeIndex` | Immutable ndarray of datetime64 data, represented internally as int64, and which can be boxed to Timestamp objects that are subclasses of datetime and carry metadata such as frequency information.

### Time/Date components

`DatetimeIndex.year` | The year of the datetime.
`DatetimeIndex.month` | The month as January=1, December=12.
`DatetimeIndex.day` | The days 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.weekofyear` | The week ordinal of the year.
`DatetimeIndex.week` | The week ordinal of the year.
`DatetimeIndex.dayofweek` | 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` |
`DatetimeIndex.freq` | Return the frequency object if it is set, otherwise None.
`DatetimeIndex.freqstr` | Return the frequency object as a string if it is 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` | Tryies to return a string representing a frequency guess, generated by infer_freq.

### Selecting

`DatetimeIndex.indexer_at_time`(time[, asof]) | Return index locations of index 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`(*args, **kwargs) | Convert tz-aware Datetime Array/Index from one time zone to another.
`DatetimeIndex.tz_localize`(*args, **kwargs) | 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`(*args, **kwargs) | 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` | 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` | Tryies 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 useful with map for returning an indexer based on an index.
`TimedeltaIndex.round`(freq[, ambiguous, …]) | Perform round operation on the data to the specified freq.
`TimedeltaIndex.floor`(freq[, ambiguous, …]) | Perform floor operation on the data to the specified freq.
`TimedeltaIndex.ceil`(freq[, ambiguous, …]) | 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` | Immutable ndarray holding ordinal values indicating regular periods in time such as particular years, quarters, months, etc.

### Properties

`PeriodIndex.day` | The days of the period
`PeriodIndex.dayofweek` | The day of the week with Monday=0, Sunday=6
`PeriodIndex.dayofyear` | 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 it is 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`(*args, **kwargs) | Convert the Period Array/Index to the specified frequency freq.
`PeriodIndex.strftime`(*args, **kwargs) | Convert to Index using specified date_format.
`PeriodIndex.to_timestamp`(*args, **kwargs) | Cast to DatetimeArray/Index.

Scroll To Top