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.

© 2008–2021, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
Licensed under the 3-clause BSD License.
https://pandas.pydata.org/pandas-docs/version/1.3.4/reference/indexing.html