Pandas-2-2-中文文档-二十八-

Pandas 2.2 中文文档（二十八）

原文：pandas.pydata.org/docs/

`pandas.CategoricalIndex.ordered`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.ordered.html

property CategoricalIndex.ordered

分类是否具有有序关系。

示例

对于pandas.Series：

>>> ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
>>> ser.cat.ordered
False

>>> raw_cat = pd.Categorical(['a', 'b', 'c', 'a'], ordered=True)
>>> ser = pd.Series(raw_cat)
>>> ser.cat.ordered
True

对于pandas.Categorical：

>>> cat = pd.Categorical(['a', 'b'], ordered=True)
>>> cat.ordered
True

>>> cat = pd.Categorical(['a', 'b'], ordered=False)
>>> cat.ordered
False

对于pandas.CategoricalIndex：

>>> ci = pd.CategoricalIndex(['a', 'b'], ordered=True)
>>> ci.ordered
True

>>> ci = pd.CategoricalIndex(['a', 'b'], ordered=False)
>>> ci.ordered
False

`pandas.CategoricalIndex.rename_categories`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.rename_categories.html

CategoricalIndex.rename_categories(*args, **kwargs)

重命名类别。

参数：

new_categories类似列表、类似字典或可调用对象

将替换旧类别的新类别。

类似列表：所有项必须唯一，并且新类别的数量必须与现有类别的数量相匹配。
类似字典：指定从旧类别到新类别的映射。未包含在映射中的类别将通过，映射中的额外类别将被忽略。
可调用对象：一个在所有旧类别项上调用的可调用对象，其返回值包括新类别。

分类的

具有重命名类别的分类。

引发：

ValueError

如果新类别类似于列表，并且与当前类别的数量不同，或者不能验证为类别

另请参阅

reorder_categories

重新排序类别。

add_categories

添加新类别。

remove_categories

移除指定的类别。

remove_unused_categories

移除未使用的类别。

set_categories

设置为指定的类别。

示例

>>> c = pd.Categorical(['a', 'a', 'b'])
>>> c.rename_categories([0, 1])
[0, 0, 1]
Categories (2, int64): [0, 1]

对于类似字典的new_categories，额外的键将被忽略，不在字典中的类别将通过

>>> c.rename_categories({'a': 'A', 'c': 'C'})
['A', 'A', 'b']
Categories (2, object): ['A', 'b']

您还可以提供一个可调用对象来创建新类别

>>> c.rename_categories(lambda x: x.upper())
['A', 'A', 'B']
Categories (2, object): ['A', 'B']

`pandas.CategoricalIndex.reorder_categories`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.reorder_categories.html

CategoricalIndex.reorder_categories(*args, **kwargs)

按照 new_categories 指定的顺序重新排序类别。

new_categories 需要包括所有旧的类别，且不包含新的类别项。

参数：

new_categories 类似索引

新顺序中的类别。

ordered 布尔值，可选

是否将分类视为有序分类。如果未给出，则不更改有序信息。

分类

重新排序的分类。

引发：

ValueError

如果新类别不包含所有旧类别项或任何新类别项

另请参阅

重命名类别

重命名类别。

添加类别

添加新的类别。

移除类别

移除指定的类别。

移除未使用的类别

移除未使用的类别。

设置类别

将类别设置为指定的类别。

示例

对于 pandas.Series:

>>> ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
>>> ser = ser.cat.reorder_categories(['c', 'b', 'a'], ordered=True)
>>> ser
0   a
1   b
2   c
3   a
dtype: category
Categories (3, object): ['c' < 'b' < 'a']

>>> ser.sort_values()
2   c
1   b
0   a
3   a
dtype: category
Categories (3, object): ['c' < 'b' < 'a']

对于 pandas.CategoricalIndex:

>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a'])
>>> ci
CategoricalIndex(['a', 'b', 'c', 'a'], categories=['a', 'b', 'c'],
 ordered=False, dtype='category')
>>> ci.reorder_categories(['c', 'b', 'a'], ordered=True)
CategoricalIndex(['a', 'b', 'c', 'a'], categories=['c', 'b', 'a'],
 ordered=True, dtype='category')

`pandas.CategoricalIndex.add_categories`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.add_categories.html

CategoricalIndex.add_categories(*args, **kwargs)

添加新的类别。

新的类别将在类别中的最后/最高位置包含，并在此调用之后立即变为未使用。

参数：

new_categories类别或类别的类别列表

要包含的新类别。

分类

添加了新类别的分类索引。

Raises:

ValueError

如果新的类别包括旧的类别或者无法验证为类别

另请参阅

rename_categories

重命名类别。

reorder_categories

重新排序类别。

remove_categories

移除指定的类别。

remove_unused_categories

删除未使用的类别。

set_categories

将类别设置为指定的类别。

示例

>>> c = pd.Categorical(['c', 'b', 'c'])
>>> c
['c', 'b', 'c']
Categories (2, object): ['b', 'c']

>>> c.add_categories(['d', 'a'])
['c', 'b', 'c']
Categories (4, object): ['b', 'c', 'd', 'a']

`pandas.CategoricalIndex.remove_categories`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.remove_categories.html

CategoricalIndex.remove_categories(*args, **kwargs)

删除指定的类别。

删除必须包含在旧类别中。已从已删除类别中删除的值将设置为 NaN

参数：

removals类别或类别列表

应该删除的类别。

类别

移除了类别的类别。

引发：

ValueError

如果删除的内容不包含在类别中

另请参见

rename_categories

重命名类别。

reorder_categories

重新排序类别。

add_categories

添加新类别。

remove_unused_categories

删除未使用的类别。

set_categories

设置为指定的类别。

示例

>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
>>> c
['a', 'c', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']

>>> c.remove_categories(['d', 'a'])
[NaN, 'c', 'b', 'c', NaN]
Categories (2, object): ['b', 'c']

`pandas.CategoricalIndex.remove_unused_categories`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.remove_unused_categories.html

CategoricalIndex.remove_unused_categories(*args, **kwargs)

移除未使用的类别。

分类

去除未使用类别的分类。

另请参阅

重命名类别。

重新排序类别。

添加新类别。

移除指定的类别。

将类别设置为指定的类别。

示例

>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
>>> c
['a', 'c', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']

>>> c[2] = 'a'
>>> c[4] = 'c'
>>> c
['a', 'c', 'a', 'c', 'c']
Categories (4, object): ['a', 'b', 'c', 'd']

>>> c.remove_unused_categories()
['a', 'c', 'a', 'c', 'c']
Categories (2, object): ['a', 'c']

`pandas.CategoricalIndex.set_categories`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.set_categories.html

CategoricalIndex.set_categories(*args, **kwargs)

将类别设置为指定的新类别。

new_categories可以包括新类别（这将导致未使用的类别）或删除旧类别（这将导致值设置为NaN）。如果rename=True，则类别将简单重命名（少于或多于旧类别中的项目将导致值设置为NaN或未使用的类别）。

此方法可用于同时执行添加、删除和重新排序多个操作，因此比通过更专门的方法执行单个步骤更快。

另一方面，此方法不执行检查（例如，旧类别是否包含在新类别中以进行重新排序），这可能导致意外更改，例如在使用特殊字符串 dtype 时，不考虑 S1 字符串等于单个字符的 python 字符串。

参数：

new_categories类似于索引

新顺序中的类别。

ordered布尔值，默认为 False

是否将分类视为有序分类。如果未给出，则不更改有序信息。

rename布尔值，默认为 False

新类别应被视为旧类别的重命名还是重新排序类别。

具有重新排序类别的分类。

引发：

ValueError

如果新类别不符合类别验证

另请参阅

rename_categories

重命名类别。

reorder_categories

重新排序类别。

add_categories

添加新类别。

remove_categories

删除指定的类别。

remove_unused_categories

删除未使用的类别。

示例

对于pandas.Series:

>>> raw_cat = pd.Categorical(['a', 'b', 'c', 'A'],
...                           categories=['a', 'b', 'c'], ordered=True)
>>> ser = pd.Series(raw_cat)
>>> ser
0   a
1   b
2   c
3   NaN
dtype: category
Categories (3, object): ['a' < 'b' < 'c']

>>> ser.cat.set_categories(['A', 'B', 'C'], rename=True)
0   A
1   B
2   C
3   NaN
dtype: category
Categories (3, object): ['A' < 'B' < 'C']

对于pandas.CategoricalIndex:

>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'A'],
...                          categories=['a', 'b', 'c'], ordered=True)
>>> ci
CategoricalIndex(['a', 'b', 'c', nan], categories=['a', 'b', 'c'],
 ordered=True, dtype='category')

>>> ci.set_categories(['A', 'b', 'c'])
CategoricalIndex([nan, 'b', 'c', nan], categories=['A', 'b', 'c'],
 ordered=True, dtype='category')
>>> ci.set_categories(['A', 'b', 'c'], rename=True)
CategoricalIndex(['A', 'b', 'c', nan], categories=['A', 'b', 'c'],
 ordered=True, dtype='category')

`pandas.CategoricalIndex.as_ordered`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.as_ordered.html

CategoricalIndex.as_ordered(*args, **kwargs)

将分类设置为有序。

分类

有序分类。

示例

对于 pandas.Series：

>>> ser = pd.Series(['a', 'b', 'c', 'a'], dtype='category')
>>> ser.cat.ordered
False
>>> ser = ser.cat.as_ordered()
>>> ser.cat.ordered
True

对于 pandas.CategoricalIndex：

>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a'])
>>> ci.ordered
False
>>> ci = ci.as_ordered()
>>> ci.ordered
True

`pandas.CategoricalIndex.as_unordered`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.as_unordered.html

CategoricalIndex.as_unordered(*args, **kwargs)

将分类设置为无序。

分类（Categorical）

无序分类（Unordered Categorical）。

示例

对于 pandas.Series：

>>> raw_cat = pd.Categorical(['a', 'b', 'c', 'a'], ordered=True)
>>> ser = pd.Series(raw_cat)
>>> ser.cat.ordered
True
>>> ser = ser.cat.as_unordered()
>>> ser.cat.ordered
False

对于 pandas.CategoricalIndex：

>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a'], ordered=True)
>>> ci.ordered
True
>>> ci = ci.as_unordered()
>>> ci.ordered
False

`pandas.CategoricalIndex.map`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.map.html

CategoricalIndex.map(mapper, na_action=None)

使用输入映射或函数映射值。

将索引的值（它们的类别，而不是代码）映射到新的类别。如果映射对应是一对一的，则结果是一个CategoricalIndex，其具有与原始索引相同的顺序属性，否则将返回一个Index。

如果使用字典或Series，则任何未映射的类别将被映射为 NaN。请注意，如果发生这种情况，则将返回一个Index。

参数：

mapper函数，字典或者 Series。

映射对应。

pandas.CategoricalIndex 或 pandas.Index

映射后的索引。

另请参阅。

Index.map

在Index上应用映射对应。

Series.map

在Series上应用映射对应。

Series.apply

在Series上应用更复杂的函数。

示例

>>> idx = pd.CategoricalIndex(['a', 'b', 'c'])
>>> idx
CategoricalIndex(['a', 'b', 'c'], categories=['a', 'b', 'c'],
 ordered=False, dtype='category')
>>> idx.map(lambda x: x.upper())
CategoricalIndex(['A', 'B', 'C'], categories=['A', 'B', 'C'],
 ordered=False, dtype='category')
>>> idx.map({'a': 'first', 'b': 'second', 'c': 'third'})
CategoricalIndex(['first', 'second', 'third'], categories=['first',
 'second', 'third'], ordered=False, dtype='category')

如果映射是一对一的，则类别的顺序将被保留：

>>> idx = pd.CategoricalIndex(['a', 'b', 'c'], ordered=True)
>>> idx
CategoricalIndex(['a', 'b', 'c'], categories=['a', 'b', 'c'],
 ordered=True, dtype='category')
>>> idx.map({'a': 3, 'b': 2, 'c': 1})
CategoricalIndex([3, 2, 1], categories=[3, 2, 1], ordered=True,
 dtype='category')

如果映射不是一对一的，则返回一个Index：

>>> idx.map({'a': 'first', 'b': 'second', 'c': 'first'})
Index(['first', 'second', 'first'], dtype='object')

如果使用字典，则所有未映射的类别都将映射为 NaN，并且结果是一个Index：

>>> idx.map({'a': 'first', 'b': 'second'})
Index(['first', 'second', nan], dtype='object')

`pandas.CategoricalIndex.equals`

原文：pandas.pydata.org/docs/reference/api/pandas.CategoricalIndex.equals.html

CategoricalIndex.equals(other)

确定两个 CategoricalIndex 对象是否包含相同的元素。

布尔值

如果两个pandas.CategoricalIndex对象具有相同的元素，则为True，否则为False。

示例

>>> ci = pd.CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'])
>>> ci2 = pd.CategoricalIndex(pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c']))
>>> ci.equals(ci2)
True

元素的顺序很重要。

>>> ci3 = pd.CategoricalIndex(['c', 'b', 'a', 'a', 'b', 'c'])
>>> ci.equals(ci3)
False

有序性也很重要。

>>> ci4 = ci.as_ordered()
>>> ci.equals(ci4)
False

类别很重要，但是只有在ordered=True时类别的顺序才重要。

>>> ci5 = ci.set_categories(['a', 'b', 'c', 'd'])
>>> ci.equals(ci5)
False

>>> ci6 = ci.set_categories(['b', 'c', 'a'])
>>> ci.equals(ci6)
True
>>> ci_ordered = pd.CategoricalIndex(['a', 'b', 'c', 'a', 'b', 'c'],
...                                  ordered=True)
>>> ci2_ordered = ci_ordered.set_categories(['b', 'c', 'a'])
>>> ci_ordered.equals(ci2_ordered)
False

pandas 区间索引

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.html

class pandas.IntervalIndex(data, closed=None, dtype=None, copy=False, name=None, verify_integrity=True)

包含在同一侧关闭的区间的不可变索引。

参数：

data类似数组（1 维）

类似数组（ndarray，DateTimeArray，TimeDeltaArray），其中包含用于构建区间索引的区间对象。

closed，默认为 'right'

区间是否在左侧、右侧、两侧还是无侧。

dtypedtype 或 None，默认为 None

如果为 None，则将推断出 dtype。

copy布尔值，默认为 False

复制输入数据。

name对象，可选

要存储在索引中的名称。

verify_integrity布尔值，默认为 True

验证区间索引是否有效。

另请参阅

pandas 基本索引类型。

有界切片样式的区间；区间索引的元素。

创建固定频率区间索引的函数。

将值分成离散的区间。

根据排名或样本分位数将值分成大小相等的区间。

注意

有关更多信息，请参阅用户指南。

示例

通常使用 interval_range() 构造新的 IntervalIndex：

>>> pd.interval_range(start=0, end=5)
IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
 dtype='interval[int64, right]')

也可以使用以下构造方法之一构造：IntervalIndex.from_arrays()、IntervalIndex.from_breaks() 和 IntervalIndex.from_tuples()。

请参阅 interval_range 和上述构造方法的文档字符串中的更多示例。

属性

`closed`	描述区间包含侧的字符串。
`is_empty`	指示区间是否为空，即不包含任何点。
`is_non_overlapping_monotonic`	返回布尔值，指示 IntervalArray 是否不重叠且单调。
`is_overlapping`	如果 IntervalIndex 存在重叠的区间，则返回 True，否则返回 False。
`values`	返回表示索引中数据的数组。
左边
右边
中间
长度

方法

`from_arrays`(left, right[, closed, name, ...])	从定义左右边界的两个数组构造。
`from_tuples`(data[, closed, name, copy, dtype])	从元组数组构造一个 IntervalIndex。
`from_breaks`(breaks[, closed, name, copy, dtype])	从一个分割数组构造一个 IntervalIndex。
`contains`(args, *kwargs)	逐个元素检查区间是否包含该值。
`overlaps`(args, *kwargs)	逐个元素检查一个区间是否与 IntervalArray 中的值重叠。
`set_closed`(args, *kwargs)	返回一个在指定边上相同的 IntervalArray。
`to_tuples`(args, *kwargs)	返回一个元组数组（如果 self 是 IntervalArray）或索引（如果 self 是 IntervalIndex），形式为 (左边界, 右边界)。

`pandas.IntervalIndex.from_arrays`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.from_arrays.html

classmethod IntervalIndex.from_arrays(left, right, closed='right', name=None, copy=False, dtype=None)

从定义左边界和右边界的两个数组构造。

参数：

leftarray-like（1 维）

每个区间的左边界。

rightarray-like（1 维）

每个区间的右边界。

closed，默认为 ‘right’

区间是在左侧、右侧、两侧还是都不封闭。

namestr，可选

结果 IntervalIndex 的名称。

copybool，默认为 False

复制数据。

dtypedtype，可选

如果为 None，则 dtype 将被推断。

IntervalIndex

引发：

ValueError

当一个值只在左边或右边缺失时。当左边的一个值大于右边的相应值时。

另请参阅

interval_range

创建固定频率 IntervalIndex 的函数。

IntervalIndex.from_breaks

从一个分割数组构建一个 IntervalIndex。

IntervalIndex.from_tuples

从元组的数组样式构建 IntervalIndex。

注释

左边的每个元素必须小于或等于相同位置处的右边元素。如果一个元素缺失，则左边和右边都必须缺失。使用不受支持的 left 或 right 类型时会引发 TypeError。目前，不支持 ‘category’、‘object’ 和 ‘string’ 子类型。

示例

>>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
IntervalIndex([(0, 1], (1, 2], (2, 3]],
 dtype='interval[int64, right]')

`pandas.IntervalIndex.from_tuples`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.from_tuples.html

classmethod IntervalIndex.from_tuples(data, closed='right', name=None, copy=False, dtype=None)

从元组的类似数组构造一个区间索引。

参数：

data类似数组（1 维）

元组数组。

closed, 默认 ‘right’

区间是否在左侧、右侧、两侧或无一侧闭合。

namestr, 可选

结果区间索引的名称。

copy布尔值，默认为 False

默认情况下复制数据，这只是兼容性的，会被忽略。

dtypedtype 或 None，默认为 None

如果为 None，则 dtype 将被推断。

区间索引

另请参阅

interval_range

创建一个固定频率区间索引的函数。

IntervalIndex.from_arrays

从左侧和右侧数组构造一个区间索引。

IntervalIndex.from_breaks

从分割数组构造一个区间索引。

示例

>>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
IntervalIndex([(0, 1], (1, 2]],
 dtype='interval[int64, right]')

`pandas.IntervalIndex.from_breaks`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.from_breaks.html

classmethod IntervalIndex.from_breaks(breaks, closed='right', name=None, copy=False, dtype=None)

从分割数组构建 IntervalIndex。

参数：

breaks类似数组（一维）

每个区间的左右边界。

closed，默认为‘right’

区间在左侧、右侧、两侧还是无侧是否封闭。

name字符串，可选

结果 IntervalIndex 的名称。

copy布尔值，默认为 False

复制数据。

dtypedtype 或 None，默认为 None

如果为 None，则将推断 dtype。

IntervalIndex

另请参阅

interval_range

创建固定频率 IntervalIndex 的函数。

IntervalIndex.from_arrays

从左侧和右侧数组构建。

IntervalIndex.from_tuples

从元组序列构建。

示例

>>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])
IntervalIndex([(0, 1], (1, 2], (2, 3]],
 dtype='interval[int64, right]')

`pandas.IntervalIndex.left`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.left.html

IntervalIndex.left

`pandas.IntervalIndex.right`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.right.html

IntervalIndex.right

`pandas.IntervalIndex.mid`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.mid.html

IntervalIndex.mid

`pandas.IntervalIndex.closed`

pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.closed.html

IntervalIndex.closed

描述区间的包含侧的字符串。

可以是left、right、both或neither。

例子

对于数组：

>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])
>>> interv_arr
<IntervalArray>
[(0, 1], (1, 5]]
Length: 2, dtype: interval[int64, right]
>>> interv_arr.closed
'right'

对于区间索引：

>>> interv_idx = pd.interval_range(start=0, end=2)
>>> interv_idx
IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]')
>>> interv_idx.closed
'right'

`pandas.IntervalIndex.length`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.length.html

property IntervalIndex.length

`pandas.IntervalIndex.values`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.values.html

property IntervalIndex.values

返回表示索引中数据的数组。

警告

我们建议使用 Index.array 或 Index.to_numpy()，取决于您需要对底层数据的引用还是一个 NumPy 数组。

array: numpy.ndarray 或 ExtensionArray

另请参阅

Index.array

对底层数据的引用。

Index.to_numpy

表示底层数据的 NumPy 数组。

示例

对于 pandas.Index：

>>> idx = pd.Index([1, 2, 3])
>>> idx
Index([1, 2, 3], dtype='int64')
>>> idx.values
array([1, 2, 3])

对于 pandas.IntervalIndex：

>>> idx = pd.interval_range(start=0, end=5)
>>> idx.values
<IntervalArray>
[(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]]
Length: 5, dtype: interval[int64, right]

`pandas.IntervalIndex.is_empty`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.is_empty.html

property IntervalIndex.is_empty

表示间隔是否为空，即它不包含任何点。

bool 或 ndarray

一个布尔型，指示标量 Interval 是否为空，或者在 IntervalArray 或 IntervalIndex 中，布尔型 ndarray 表示 Interval 是否为空。

另请参阅

Interval.length

返回间隔的长度。

示例

包含点的 Interval 不为空：

>>> pd.Interval(0, 1, closed='right').is_empty
False

不包含任何点的 Interval 是空的：

>>> pd.Interval(0, 0, closed='right').is_empty
True
>>> pd.Interval(0, 0, closed='left').is_empty
True
>>> pd.Interval(0, 0, closed='neither').is_empty
True

包含单个点的 Interval 不为空：

>>> pd.Interval(0, 0, closed='both').is_empty
False

IntervalArray 或 IntervalIndex 返回一个布尔型 ndarray，位置表示 Interval 是否为空：

>>> ivs = [pd.Interval(0, 0, closed='neither'),
...        pd.Interval(1, 2, closed='neither')]
>>> pd.arrays.IntervalArray(ivs).is_empty
array([ True, False])

缺失值不视为空：

>>> ivs = [pd.Interval(0, 0, closed='neither'), np.nan]
>>> pd.IntervalIndex(ivs).is_empty
array([ True, False])

`pandas.IntervalIndex.is_non_overlapping_monotonic`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.is_non_overlapping_monotonic.html

IntervalIndex.is_non_overlapping_monotonic

返回一个布尔值，指示 IntervalArray 是否是非重叠且单调的。

非重叠意味着（没有区间共享点），单调意味着单调递增或单调递减。

示例

对于数组：

>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])
>>> interv_arr
<IntervalArray>
[(0, 1], (1, 5]]
Length: 2, dtype: interval[int64, right]
>>> interv_arr.is_non_overlapping_monotonic
True

>>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1),
...                                       pd.Interval(-1, 0.1)])
>>> interv_arr
<IntervalArray>
[(0.0, 1.0], (-1.0, 0.1]]
Length: 2, dtype: interval[float64, right]
>>> interv_arr.is_non_overlapping_monotonic
False

对于区间索引：

>>> interv_idx = pd.interval_range(start=0, end=2)
>>> interv_idx
IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]')
>>> interv_idx.is_non_overlapping_monotonic
True

>>> interv_idx = pd.interval_range(start=0, end=2, closed='both')
>>> interv_idx
IntervalIndex([[0, 1], [1, 2]], dtype='interval[int64, both]')
>>> interv_idx.is_non_overlapping_monotonic
False

`pandas.IntervalIndex.is_overlapping`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.is_overlapping.html

property IntervalIndex.is_overlapping

如果 IntervalIndex 具有重叠的区间，则返回 True，否则返回 False。

如果两个区间共享一个公共点，包括闭合端点，则它们重叠。只有一个共同的开放端点的区间不重叠。

布尔值

布尔值，指示 IntervalIndex 是否具有重叠的区间。

另请参见

Interval.overlaps

检查两个 Interval 对象是否重叠。

IntervalIndex.overlaps

逐个元素检查 IntervalIndex 是否存在重叠。

示例

>>> index = pd.IntervalIndex.from_tuples([(0, 2), (1, 3), (4, 5)])
>>> index
IntervalIndex([(0, 2], (1, 3], (4, 5]],
 dtype='interval[int64, right]')
>>> index.is_overlapping
True

具有相同闭合端点的区间重叠：

>>> index = pd.interval_range(0, 3, closed='both')
>>> index
IntervalIndex([[0, 1], [1, 2], [2, 3]],
 dtype='interval[int64, both]')
>>> index.is_overlapping
True

只有一个共同的开放端点的区间不重叠：

>>> index = pd.interval_range(0, 3, closed='left')
>>> index
IntervalIndex([[0, 1), [1, 2), [2, 3)],
 dtype='interval[int64, left]')
>>> index.is_overlapping
False

`pandas.IntervalIndex.get_loc`

参考链接：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.get_loc.html

IntervalIndex.get_loc(key)

返回请求标签的整数位置、切片或布尔掩码。

参数：

关键字标签

返回结果：

如果索引是唯一的，返回整数；如果索引是单调的，返回切片；否则返回掩码。

示例

>>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2)
>>> index = pd.IntervalIndex([i1, i2])
>>> index.get_loc(1)
0

您还可以提供一个区间内的点。

>>> index.get_loc(1.5)
1

如果一个标签在多个区间中，你将会得到所有相关区间的位置。

>>> i3 = pd.Interval(0, 2)
>>> overlapping_index = pd.IntervalIndex([i1, i2, i3])
>>> overlapping_index.get_loc(0.5)
array([ True, False,  True])

如果提供了一个区间，只会返回完全匹配的结果。

>>> index.get_loc(pd.Interval(0, 1))
0

`pandas.IntervalIndex.get_indexer`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.get_indexer.html

IntervalIndex.get_indexer(target, method=None, limit=None, tolerance=None)

计算给定当前索引的新索引的索引器和掩码。

然后应使用索引器作为 ndarray.take 的输入，以将当前数据与新索引对齐。

参数：

targetIndex

method，可选

default：仅进行精确匹配。
pad / ffill：如果没有精确匹配，则找到上一个索引值。
backfill / bfill：如果没有精确匹配，则使用下一个索引值
nearest：如果没有精确匹配，则使用最近的索引值。如果距离相同，则偏好较大的索引值。

limitint，可选

要匹配的 target 中的最大连续标签数，用于不精确匹配。

tolerance，可选

原标签与新标签之间的最大距离，用于不精确匹配。在匹配位置的索引值必须满足方程 abs(index[indexer] - target) <= tolerance。

容差可以是一个标量值，适用于所有值的相同容差，也可以是类似列表的值，适用于每个元素的可变容差。类似列表的包括列表、元组、数组、Series，必须与索引的大小完全匹配且其 dtype 必须与索引的类型完全匹配。

返回值：

np.ndarray[np.intp]

整数从 0 到 n - 1 表示这些位置的索引与相应的目标值匹配。目标中的缺失值由 -1 标记。

注意事项

对于不匹配的值返回 -1，详细解释请参见下面的示例。

示例

>>> index = pd.Index(['c', 'a', 'b'])
>>> index.get_indexer(['a', 'b', 'x'])
array([ 1,  2, -1])

注意返回值是一个由 index 和 x 中的位置组成的数组，其中没有在 index 中的值由 -1 标记。

`pandas.IntervalIndex.set_closed`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.set_closed.html

IntervalIndex.set_closed(*args, **kwargs)

返回一个在指定侧关闭的相同 IntervalArray。

参数：

closed

区间是否在左侧、右侧、两侧或者都不闭合。

返回值：

IntervalArray

示例

>>> index = pd.arrays.IntervalArray.from_breaks(range(4))
>>> index
<IntervalArray>
[(0, 1], (1, 2], (2, 3]]
Length: 3, dtype: interval[int64, right]
>>> index.set_closed('both')
<IntervalArray>
[[0, 1], [1, 2], [2, 3]]
Length: 3, dtype: interval[int64, both]

`pandas.IntervalIndex.contains`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.contains.html

IntervalIndex.contains(*args, **kwargs)

逐个元素地检查区间是否包含该值。

返回一个布尔蒙版，指示值是否包含在 IntervalArray 的区间中。

参数：

其他标量

要检查的值是否包含在区间内。

返回值：

布尔数组

另请参阅

Interval.contains

检查区间对象是否包含值。

IntervalArray.overlaps

检查一个区间是否与 IntervalArray 中的值重叠。

示例

>>> intervals = pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 3), (2, 4)])
>>> intervals
<IntervalArray>
[(0, 1], (1, 3], (2, 4]]
Length: 3, dtype: interval[int64, right]

>>> intervals.contains(0.5)
array([ True, False, False])

`pandas.IntervalIndex.overlaps`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.overlaps.html

IntervalIndex.overlaps(*args, **kwargs)

逐元素检查一个区间是否与 IntervalArray 中的值重叠。

两个区间重叠，如果它们共享一个公共点，包括封闭端点。只有共享一个开放端点的区间不会重叠。

参数：

otherIntervalArray

要检查重叠的区间。

ndarray

布尔数组，指示重叠发生的位置。

另请参阅

Interval.overlaps

检查两个 Interval 对象是否重叠。

示例

>>> data = [(0, 1), (1, 3), (2, 4)]
>>> intervals = pd.arrays.IntervalArray.from_tuples(data)
>>> intervals
<IntervalArray>
[(0, 1], (1, 3], (2, 4]]
Length: 3, dtype: interval[int64, right]

>>> intervals.overlaps(pd.Interval(0.5, 1.5))
array([ True,  True, False])

共享封闭端点的区间会重叠：

>>> intervals.overlaps(pd.Interval(1, 3, closed='left'))
array([ True,  True, True])

只有共享一个开放端点的区间不会重叠：

>>> intervals.overlaps(pd.Interval(1, 2, closed='right'))
array([False,  True, False])

`pandas.IntervalIndex.to_tuples`

原文：pandas.pydata.org/docs/reference/api/pandas.IntervalIndex.to_tuples.html

IntervalIndex.to_tuples(*args, **kwargs)

返回一个元组形式为（left，right）的 ndarray（如果 self 是 IntervalArray）或 Index（如果 self 是 IntervalIndex）。

参数：

na_tuplebool，默认为 True

如果为True，返回NA作为元组(nan, nan)。如果为False，只返回NA作为nan。

元组：ndarray（如果 self 是 IntervalArray）或 Index（如果 self 是 IntervalIndex）

示例

对于pandas.IntervalArray：

>>> idx = pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2)])
>>> idx
<IntervalArray>
[(0, 1], (1, 2]]
Length: 2, dtype: interval[int64, right]
>>> idx.to_tuples()
array([(0, 1), (1, 2)], dtype=object)

对于pandas.IntervalIndex：

>>> idx = pd.interval_range(start=0, end=2)
>>> idx
IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]')
>>> idx.to_tuples()
Index([(0, 1), (1, 2)], dtype='object')

`pandas.MultiIndex`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.html

class pandas.MultiIndex(levels=None, codes=None, sortorder=None, names=None, dtype=None, copy=False, name=None, verify_integrity=True)

pandas 对象的多级或分层索引对象。

参数：

levels数组序列

每个级别的唯一标签。

codes数组序列

每个级别的整数指定每个位置的标签。

sortorder可选整数

排序级别（必须按该级别的字典顺序排序）。

names可选对象序列

每个索引级别的名称（name 用于兼容）。

copy布尔值，默认为 False

复制元数据。

verify_integrity布尔值，默认为 True

检查级别/代码是否一致且有效。

另请参阅

MultiIndex.from_arrays

将数组列表转换为 MultiIndex。

MultiIndex.from_product

从可迭代对象的笛卡尔积创建 MultiIndex。

MultiIndex.from_tuples

将元组列表转换为 MultiIndex。

MultiIndex.from_frame

从 DataFrame 创建 MultiIndex。

Index

基础 pandas Index 类型。

注释

请参阅用户指南了解更多信息。

示例

通常使用其中一个辅助方法 MultiIndex.from_arrays()、MultiIndex.from_product() 和 MultiIndex.from_tuples() 构建新的 MultiIndex。例如（使用 .from_arrays）：

>>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
>>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
MultiIndex([(1,  'red'),
 (1, 'blue'),
 (2,  'red'),
 (2, 'blue')],
 names=['number', 'color'])

在提到的辅助方法的文档字符串中查看更多构建 MultiIndex 的示例。

属性

`names`	MultiIndex 中各级别的名称。
`levels`	MultiIndex 的级别。
`nlevels`	此 MultiIndex 中级别的整数数量。
`levshape`	各级别的长度的元组。
`dtypes`	返回基础 MultiIndex 的 dtypes 作为 Series。
codes

方法

`from_arrays`(arrays[, sortorder, names])	将数组转换为 MultiIndex。
`from_tuples`(tuples[, sortorder, names])	将元组列表转换为 MultiIndex。
`from_product`(iterables[, sortorder, names])	从多个可迭代对象的笛卡尔积创建 MultiIndex。
`from_frame`(df[, sortorder, names])	从 DataFrame 创建 MultiIndex。
`set_levels`(levels, *[, level, verify_integrity])	在 MultiIndex 上设置新级别。
`set_codes`(codes, *[, level, verify_integrity])	设置 MultiIndex 上的新编码。
`to_frame`([index, name, allow_duplicates])	将 MultiIndex 的级别作为列创建 DataFrame。
`to_flat_index`()	将 MultiIndex 转换为包含级别值的元组的索引。
`sortlevel`([level, ascending, ...])	按请求的级别对 MultiIndex 进行排序。
`droplevel`([level])	返回删除请求级别的索引。
`swaplevel`([i, j])	交换级别 i 和级别 j。
`reorder_levels`(order)	使用输入顺序重新排列级别。
`remove_unused_levels`()	从当前 MultiIndex 创建新的 MultiIndex，删除未使用的级别。
`get_level_values`(level)	返回请求级别的标签值向量。
`get_indexer`(target[, method, limit, tolerance])	给定当前索引，计算新索引的索引器和掩码。
`get_loc`(key)	获取标签或标签元组的位置。
`get_locs`(seq)	获取一系列标签的位置。
`get_loc_level`(key[, level, drop_level])	获取所请求的标签/级别的位置和切片索引。
`drop`(codes[, level, errors])	用传入的代码列表删除一个新的`pandas.MultiIndex`。

`pandas.MultiIndex.from_arrays`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.from_arrays.html

classmethod MultiIndex.from_arrays(arrays, sortorder=None, names=_NoDefault.no_default)

将数组转换为 MultiIndex。

参数：

arrays列表 / 数组样式序列

每个数组样式为每个数据点提供一个级别的值。数组的长度为级别数。

sortorderint 或 None

排序级别（必须按该级别的字典顺序排序）。

names列表 / 字符串序列，可选

索引中各级别的名称。

MultiIndex

参见

MultiIndex.from_tuples

将元组列表转换为 MultiIndex。

MultiIndex.from_product

从可迭代对象的笛卡尔积中创建 MultiIndex。

MultiIndex.from_frame

从 DataFrame 创建 MultiIndex。

示例

>>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
>>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
MultiIndex([(1,  'red'),
 (1, 'blue'),
 (2,  'red'),
 (2, 'blue')],
 names=['number', 'color'])

`pandas.MultiIndex.from_tuples`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.from_tuples.html

classmethod MultiIndex.from_tuples(tuples, sortorder=None, names=None)

将元组列表转换为 MultiIndex。

参数：

tuples列表 / 元组序列

每个元组是一行/列的索引。

sortorderint 或 None

排序级别（必须按该级别的词典顺序排序）。

names列表 / 字符串序列，可选

索引中级别的名称。

MultiIndex

另请参阅

MultiIndex.from_arrays

将数组列表转换为 MultiIndex。

MultiIndex.from_product

从可迭代对象的笛卡尔积中创建 MultiIndex。

MultiIndex.from_frame

从 DataFrame 创建 MultiIndex。

示例

>>> tuples = [(1, 'red'), (1, 'blue'),
...           (2, 'red'), (2, 'blue')]
>>> pd.MultiIndex.from_tuples(tuples, names=('number', 'color'))
MultiIndex([(1,  'red'),
 (1, 'blue'),
 (2,  'red'),
 (2, 'blue')],
 names=['number', 'color'])

`pandas.MultiIndex.from_product`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.from_product.html

classmethod MultiIndex.from_product(iterables, sortorder=None, names=_NoDefault.no_default)

从多个可迭代对象的笛卡尔积创建 MultiIndex。

参数：

iterableslist / 可迭代对象序列

每个可迭代对象都具有索引每个级别的唯一标签。

sortorderint 或 None

排序程度（必须按该级别的字典顺序排序）。

nameslist / 字符串序列，可选

索引级别的名称。如果未显式提供，则名称将从可迭代对象的元素中推断出来，如果元素具有 name 属性。

MultiIndex

另请参阅

MultiIndex.from_arrays

将数组列表转换为 MultiIndex。

MultiIndex.from_tuples

将元组列表转换为 MultiIndex。

MultiIndex.from_frame

从 DataFrame 创建 MultiIndex。

示例

>>> numbers = [0, 1, 2]
>>> colors = ['green', 'purple']
>>> pd.MultiIndex.from_product([numbers, colors],
...                            names=['number', 'color'])
MultiIndex([(0,  'green'),
 (0, 'purple'),
 (1,  'green'),
 (1, 'purple'),
 (2,  'green'),
 (2, 'purple')],
 names=['number', 'color'])

`pandas.MultiIndex.from_frame`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.from_frame.html

classmethod MultiIndex.from_frame(df, sortorder=None, names=None)

从 DataFrame 构造 MultiIndex。

参数：

dfDataFrame

待转换为 MultiIndex 的 DataFrame。

sortorder整数，可选

排序级别（必须按照该级别的词典顺序排序）。

names类似列表，可选

如果未提供名称，则使用列名，或者如果列是 MultiIndex，则使用列名的元组。如果是序列，则使用给定序列覆盖名称。

MultiIndex

给定 DataFrame 的 MultiIndex 表示。

也可参见

MultiIndex.from_arrays

将数组列表转换为 MultiIndex。

MultiIndex.from_tuples

将元组列表转换为 MultiIndex。

MultiIndex.from_product

从可迭代对象的笛卡尔积构造 MultiIndex。

示例

>>> df = pd.DataFrame([['HI', 'Temp'], ['HI', 'Precip'],
...                    ['NJ', 'Temp'], ['NJ', 'Precip']],
...                   columns=['a', 'b'])
>>> df
 a       b
0    HI    Temp
1    HI  Precip
2    NJ    Temp
3    NJ  Precip

>>> pd.MultiIndex.from_frame(df)
MultiIndex([('HI',   'Temp'),
 ('HI', 'Precip'),
 ('NJ',   'Temp'),
 ('NJ', 'Precip')],
 names=['a', 'b'])

使用显式名称，而不是列名

>>> pd.MultiIndex.from_frame(df, names=['state', 'observation'])
MultiIndex([('HI',   'Temp'),
 ('HI', 'Precip'),
 ('NJ',   'Temp'),
 ('NJ', 'Precip')],
 names=['state', 'observation'])

`pandas.MultiIndex.names`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.names.html

property MultiIndex.names

多重索引中级别的名称。

示例

>>> mi = pd.MultiIndex.from_arrays(
... [[1, 2], [3, 4], [5, 6]], names=['x', 'y', 'z'])
>>> mi
MultiIndex([(1, 3, 5),
 (2, 4, 6)],
 names=['x', 'y', 'z'])
>>> mi.names
FrozenList(['x', 'y', 'z'])

`pandas.MultiIndex.levels`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.levels.html

MultiIndex.levels

多重索引的层级。

层级指的是多重索引中的不同层级或层次。在多重索引中，每个层级代表索引的一个不同维度或类别。

要访问层级，可以使用多重索引的 levels 属性，它返回一个 Index 对象的元组。每个 Index 对象代表多重索引中的一个层级，并包含该特定层级中找到的唯一值。

如果使用层级 A、B、C 创建了一个多重索引，并且使用它的 DataFrame 过滤掉了所有层级 C 的行，MultiIndex.levels 仍然会返回 A、B、C。

示例

>>> index = pd.MultiIndex.from_product([['mammal'],
...                                     ('goat', 'human', 'cat', 'dog')],
...                                    names=['Category', 'Animals'])
>>> leg_num = pd.DataFrame(data=(4, 2, 4, 4), index=index, columns=['Legs'])
>>> leg_num
 Legs
Category Animals
mammal   goat        4
 human       2
 cat         4
 dog         4

>>> leg_num.index.levels
FrozenList([['mammal'], ['cat', 'dog', 'goat', 'human']])

即使使用多重索引的 DataFrame 不再包含所有层级，多重索引的层级也不会改变。看看“human”不在 DataFrame 中，但它仍然在层级中：

>>> large_leg_num = leg_num[leg_num.Legs > 2]
>>> large_leg_num
 Legs
Category Animals
mammal   goat        4
 cat         4
 dog         4

>>> large_leg_num.index.levels
FrozenList([['mammal'], ['cat', 'dog', 'goat', 'human']])

`pandas.MultiIndex.codes`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.codes.html

property MultiIndex.codes

`pandas.MultiIndex.nlevels`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.nlevels.html

property MultiIndex.nlevels

多级索引中的整数级别。

示例

>>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']])
>>> mi
MultiIndex([('a', 'b', 'c')],
 )
>>> mi.nlevels
3

`pandas.MultiIndex.levshape`

pandas.pydata.org/docs/reference/api/pandas.MultiIndex.levshape.html

property MultiIndex.levshape

一个包含每个层级长度的元组。

示例

>>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']])
>>> mi
MultiIndex([('a', 'b', 'c')],
 )
>>> mi.levshape
(1, 1, 1)

`pandas.MultiIndex.dtypes`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.dtypes.html

MultiIndex.dtypes

返回基础 MultiIndex 的数据类型作为 Series。

示例

>>> idx = pd.MultiIndex.from_product([(0, 1, 2), ('green', 'purple')],
...                                  names=['number', 'color'])
>>> idx
MultiIndex([(0,  'green'),
 (0, 'purple'),
 (1,  'green'),
 (1, 'purple'),
 (2,  'green'),
 (2, 'purple')],
 names=['number', 'color'])
>>> idx.dtypes
number     int64
color     object
dtype: object

`pandas.MultiIndex.set_levels`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.set_levels.html

MultiIndex.set_levels(levels, *, level=None, verify_integrity=True)

在 MultiIndex 上设置新的级别。默认返回新索引。

参数：

levels序列或序列列表

要应用的新级别。

levelint、级别名称或 int/级别名称序列（默认为 None）

要设置的级别（所有级别为 None）。

verify_integritybool，默认为 True

如果为 True，则检查级别和代码是否兼容。

MultiIndex

示例

>>> idx = pd.MultiIndex.from_tuples(
...     [
...         (1, "one"),
...         (1, "two"),
...         (2, "one"),
...         (2, "two"),
...         (3, "one"),
...         (3, "two")
...     ],
...     names=["foo", "bar"]
... )
>>> idx
MultiIndex([(1, 'one'),
 (1, 'two'),
 (2, 'one'),
 (2, 'two'),
 (3, 'one'),
 (3, 'two')],
 names=['foo', 'bar'])

>>> idx.set_levels([['a', 'b', 'c'], [1, 2]])
MultiIndex([('a', 1),
 ('a', 2),
 ('b', 1),
 ('b', 2),
 ('c', 1),
 ('c', 2)],
 names=['foo', 'bar'])
>>> idx.set_levels(['a', 'b', 'c'], level=0)
MultiIndex([('a', 'one'),
 ('a', 'two'),
 ('b', 'one'),
 ('b', 'two'),
 ('c', 'one'),
 ('c', 'two')],
 names=['foo', 'bar'])
>>> idx.set_levels(['a', 'b'], level='bar')
MultiIndex([(1, 'a'),
 (1, 'b'),
 (2, 'a'),
 (2, 'b'),
 (3, 'a'),
 (3, 'b')],
 names=['foo', 'bar'])

如果传递给 set_levels() 的任何级别超过现有长度，则将该参数的所有值存储在 MultiIndex 级别中，尽管在 MultiIndex 输出中，这些值将被截断。

>>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1])
MultiIndex([('a', 1),
 ('a', 2),
 ('b', 1),
 ('b', 2),
 ('c', 1),
 ('c', 2)],
 names=['foo', 'bar'])
>>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1]).levels
FrozenList([['a', 'b', 'c'], [1, 2, 3, 4]])

`pandas.MultiIndex.set_codes`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.set_codes.html

MultiIndex.set_codes(codes, *, level=None, verify_integrity=True)

在 MultiIndex 上设置新的代码。默认返回新索引。

参数：

codes 序列或序列的列表

要应用的新代码。

level 整数，级别名称，或整数/级别名称的序列（默认为 None）

要设置的级别（如果要设置所有级别，则为 None）。

verify_integrity 布尔值，默认为 True

如果为 True，则检查级别和代码是否兼容。

新索引（与调用者相同类型和类等）或 None

与调用者相同类型，如果inplace=True则为 None。

示例

>>> idx = pd.MultiIndex.from_tuples(
...     [(1, "one"), (1, "two"), (2, "one"), (2, "two")], names=["foo", "bar"]
... )
>>> idx
MultiIndex([(1, 'one'),
 (1, 'two'),
 (2, 'one'),
 (2, 'two')],
 names=['foo', 'bar'])

>>> idx.set_codes([[1, 0, 1, 0], [0, 0, 1, 1]])
MultiIndex([(2, 'one'),
 (1, 'one'),
 (2, 'two'),
 (1, 'two')],
 names=['foo', 'bar'])
>>> idx.set_codes([1, 0, 1, 0], level=0)
MultiIndex([(2, 'one'),
 (1, 'two'),
 (2, 'one'),
 (1, 'two')],
 names=['foo', 'bar'])
>>> idx.set_codes([0, 0, 1, 1], level='bar')
MultiIndex([(1, 'one'),
 (1, 'one'),
 (2, 'two'),
 (2, 'two')],
 names=['foo', 'bar'])
>>> idx.set_codes([[1, 0, 1, 0], [0, 0, 1, 1]], level=[0, 1])
MultiIndex([(2, 'one'),
 (1, 'one'),
 (2, 'two'),
 (1, 'two')],
 names=['foo', 'bar'])

`pandas.MultiIndex.to_flat_index`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.to_flat_index.html

MultiIndex.to_flat_index()

将 MultiIndex 转换为包含级别值的元组索引。

pd.Index

用元组表示的 MultiIndex 数据的索引。

另请参阅

MultiIndex.from_tuples

将平面索引转换回 MultiIndex。

注意

如果被调用者不是 MultiIndex，则此方法将简单地返回调用者。

示例

>>> index = pd.MultiIndex.from_product(
...     [['foo', 'bar'], ['baz', 'qux']],
...     names=['a', 'b'])
>>> index.to_flat_index()
Index([('foo', 'baz'), ('foo', 'qux'),
 ('bar', 'baz'), ('bar', 'qux')],
 dtype='object')

`pandas.MultiIndex.to_frame`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.to_frame.html

MultiIndex.to_frame(index=True, name=_NoDefault.no_default, allow_duplicates=False)

创建一个将 MultiIndex 的级别作为列的 DataFrame。

列的顺序由 DataFrame 构造函数确定，数据为字典。

参数：

index布尔值，默认为 True

将返回的 DataFrame 的索引设置为原始的 MultiIndex。

name列表 / 字符串序列，可选

传递的名称应该替换索引级别的名称。

allow_duplicates布尔值，可选，默认为 False

允许创建重复的列标签。

自 1.5.0 版本新增。

返回值：

DataFrame

另请参见

DataFrame

二维、大小可变、可能异构的表格数据。

示例

>>> mi = pd.MultiIndex.from_arrays([['a', 'b'], ['c', 'd']])
>>> mi
MultiIndex([('a', 'c'),
 ('b', 'd')],
 )

>>> df = mi.to_frame()
>>> df
 0  1
a c  a  c
b d  b  d

>>> df = mi.to_frame(index=False)
>>> df
 0  1
0  a  c
1  b  d

>>> df = mi.to_frame(name=['x', 'y'])
>>> df
 x  y
a c  a  c
b d  b  d

`pandas.MultiIndex.sortlevel`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.sortlevel.html

MultiIndex.sortlevel(level=0, ascending=True, sort_remaining=True, na_position='first')

在所请求的级别上对 MultiIndex 进行排序。

结果将尊重该级别上相关因子的原始顺序。

参数：

level类似列表，int 或 str，默认为 0

如果给定了字符串，必须是级别的名称。如果类似列表必须是级别的名称或 int。

ascendingbool，默认为 True

False 为降序排序。也可以是一个列表以指定有向顺序。

sort_remaining在级别之后对剩余级别进行排序

na_position，默认为 ‘first’

参数 ‘first’ 将 NaN 放在开头，‘last’ 将 NaN 放在末尾。

新版本 2.1.0 中新增。

sorted_indexpd.MultiIndex

结果索引。

indexernp.ndarray[np.intp]

输出值在原始索引中的索引。

示例

>>> mi = pd.MultiIndex.from_arrays([[0, 0], [2, 1]])
>>> mi
MultiIndex([(0, 2),
 (0, 1)],
 )

>>> mi.sortlevel()
(MultiIndex([(0, 1),
 (0, 2)],
 ), array([1, 0]))

>>> mi.sortlevel(sort_remaining=False)
(MultiIndex([(0, 2),
 (0, 1)],
 ), array([0, 1]))

>>> mi.sortlevel(1)
(MultiIndex([(0, 1),
 (0, 2)],
 ), array([1, 0]))

>>> mi.sortlevel(1, ascending=False)
(MultiIndex([(0, 2),
 (0, 1)],
 ), array([0, 1]))

`pandas.MultiIndex.droplevel`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.droplevel.html

MultiIndex.droplevel(level=0)

返回删除请求级别的索引。

如果结果索引只剩下 1 个级别，则结果将是索引类型，而不是多重索引。原始索引不会被就地修改。

参数：

levelint、str 或类似列表，默认为 0

如果给定一个字符串，则必须是级别的名称。如果是类似列表，则元素必须是级别的名称或索引。

索引或多重索引

示例

>>> mi = pd.MultiIndex.from_arrays(
... [[1, 2], [3, 4], [5, 6]], names=['x', 'y', 'z'])
>>> mi
MultiIndex([(1, 3, 5),
 (2, 4, 6)],
 names=['x', 'y', 'z'])

>>> mi.droplevel()
MultiIndex([(3, 5),
 (4, 6)],
 names=['y', 'z'])

>>> mi.droplevel(2)
MultiIndex([(1, 3),
 (2, 4)],
 names=['x', 'y'])

>>> mi.droplevel('z')
MultiIndex([(1, 3),
 (2, 4)],
 names=['x', 'y'])

>>> mi.droplevel(['x', 'y'])
Index([5, 6], dtype='int64', name='z')

`pandas.MultiIndex.swaplevel 方法。`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.swaplevel.html

MultiIndex.swaplevel(i=-2, j=-1)

将第 i 级别与第 j 级别交换。

调用此方法不会改变值的排序。

参数：

i：整数，字符串，默认值为-2。

要交换的索引的第一级别。可以将级别名称作为字符串传递。参数类型可以混合使用。

j：整数，字符串，默认值为-1。

要交换的索引的第二级别。可以将级别名称作为字符串传递。参数类型可以混合使用。

多级索引。

新的多级索引。

另请参见。

Series.swaplevel方法。

在多级索引中交换第 i 和第 j 级别。

DataFrame.swaplevel方法。

在特定轴上交换多级索引中的第 i 和第 j 级别。

示例。

>>> mi = pd.MultiIndex(levels=[['a', 'b'], ['bb', 'aa']],
...                    codes=[[0, 0, 1, 1], [0, 1, 0, 1]])
>>> mi
MultiIndex([('a', 'bb'),
 ('a', 'aa'),
 ('b', 'bb'),
 ('b', 'aa')],
 )
>>> mi.swaplevel(0, 1)
MultiIndex([('bb', 'a'),
 ('aa', 'a'),
 ('bb', 'b'),
 ('aa', 'b')],
 )

`pandas.MultiIndex.reorder_levels`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.reorder_levels.html

MultiIndex.reorder_levels(order)

使用输入顺序重新排列级别。可能不会删除或重复级别。

参数：

order列表中的整数或字符串

表示新级别顺序的列表。通过数字（位置）或键（标签）引用级别。

MultiIndex

示例

>>> mi = pd.MultiIndex.from_arrays([[1, 2], [3, 4]], names=['x', 'y'])
>>> mi
MultiIndex([(1, 3),
 (2, 4)],
 names=['x', 'y'])

>>> mi.reorder_levels(order=[1, 0])
MultiIndex([(3, 1),
 (4, 2)],
 names=['y', 'x'])

>>> mi.reorder_levels(order=['y', 'x'])
MultiIndex([(3, 1),
 (4, 2)],
 names=['y', 'x'])

`pandas.MultiIndex.remove_unused_levels`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.remove_unused_levels.html

MultiIndex.remove_unused_levels()

从当前 MultiIndex 创建新的 MultiIndex，移除未使用的级别。

未使用的级别表示在标签中没有表达出来的级别。生成的 MultiIndex 将具有相同的外观，意味着相同的 .values 和顺序。它还将与原始 MultiIndex 的 .equals()。

MultiIndex

示例

>>> mi = pd.MultiIndex.from_product([range(2), list('ab')])
>>> mi
MultiIndex([(0, 'a'),
 (0, 'b'),
 (1, 'a'),
 (1, 'b')],
 )

>>> mi[2:]
MultiIndex([(1, 'a'),
 (1, 'b')],
 )

第一级中的 0 未表示，可以被移除。

>>> mi2 = mi[2:].remove_unused_levels()
>>> mi2.levels
FrozenList([[1], ['a', 'b']])

`pandas.MultiIndex.drop`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.drop.html

MultiIndex.drop(codes, level=None, errors='raise')

创建一个新的pandas.MultiIndex，删除传递的代码列表。

参数：

codes 数组样式

当未指定level时，必须是元组列表。

level 整数或级别名称，默认为 None

errors 字符串，默认为 'raise'

MultiIndex

示例

>>> idx = pd.MultiIndex.from_product([(0, 1, 2), ('green', 'purple')],
...                                  names=["number", "color"])
>>> idx
MultiIndex([(0,  'green'),
 (0, 'purple'),
 (1,  'green'),
 (1, 'purple'),
 (2,  'green'),
 (2, 'purple')],
 names=['number', 'color'])
>>> idx.drop([(1, 'green'), (2, 'purple')])
MultiIndex([(0,  'green'),
 (0, 'purple'),
 (1, 'purple'),
 (2,  'green')],
 names=['number', 'color'])

我们还可以从特定级别删除。

>>> idx.drop('green', level='color')
MultiIndex([(0, 'purple'),
 (1, 'purple'),
 (2, 'purple')],
 names=['number', 'color'])

>>> idx.drop([1, 2], level=0)
MultiIndex([(0,  'green'),
 (0, 'purple')],
 names=['number', 'color'])

`pandas.MultiIndex.copy`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.copy.html

MultiIndex.copy(names=None, deep=False, name=None)

复制此对象。

可以传递 Names、dtype、levels 和 codes，并将在新副本上设置。

参数：

names序列，可选

deep布尔值，默认为 False

name标签

为了与一维索引兼容而保留。不应使用。

MultiIndex

注解

在大多数情况下，与使用 deep 没有功能上的区别，但如果传递了 deep，它将尝试深度复制。这在大型 MultiIndex 对象上可能是昂贵的。

示例

>>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']])
>>> mi
MultiIndex([('a', 'b', 'c')],
 )
>>> mi.copy()
MultiIndex([('a', 'b', 'c')],
 )

`pandas.MultiIndex.append`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.append.html

MultiIndex.append(other)

将一组索引选项连接在一起。

参数：

other索引或索引的列表/元组

索引

组合后的索引。

示例

>>> mi = pd.MultiIndex.from_arrays([['a'], ['b']])
>>> mi
MultiIndex([('a', 'b')],
 )
>>> mi.append(mi)
MultiIndex([('a', 'b'), ('a', 'b')],
 )

`pandas.MultiIndex.truncate`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.truncate.html

MultiIndex.truncate(before=None, after=None)

位于两个标签/元组之间的切片索引，返回新的 MultiIndex。

参数：

before标签或元组，可以是部分。默认为 None。

None 默认为起始。

after标签或元组，可以是部分。默认为 None。

None 默认为末尾。

MultiIndex

截断后的 MultiIndex。

示例

>>> mi = pd.MultiIndex.from_arrays([['a', 'b', 'c'], ['x', 'y', 'z']])
>>> mi
MultiIndex([('a', 'x'), ('b', 'y'), ('c', 'z')],
 )
>>> mi.truncate(before='a', after='b')
MultiIndex([('a', 'x'), ('b', 'y')],
 )

`pandas.MultiIndex.get_loc`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.get_loc.html

MultiIndex.get_loc(key)

获取标签或标签元组的位置。

位置以整数/切片或布尔掩码形式返回。

参数：

key标签或标签元组（每个级别一个）

整数、切片对象或布尔掩码

如果键超出了 lexsort 深度，则返回可能是一个布尔掩码数组，否则始终是一个切片或整数。

另请参见

Index.get_loc

（单级）索引的 get_loc 方法。

MultiIndex.slice_locs

给定起始标签和结束标签，获取切片位置。

MultiIndex.get_locs

获取标签/切片/列表/掩码或这些序列的位置。

注意事项

键不能是切片、相同级别标签的列表、布尔掩码或这些的序列。如果要使用这些，请改用MultiIndex.get_locs()。

示例

>>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')])

>>> mi.get_loc('b')
slice(1, 3, None)

>>> mi.get_loc(('b', 'e'))
1

`pandas.MultiIndex.get_locs`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.get_locs.html

MultiIndex.get_locs(seq)

获取标签序列的位置。

参数：

序列标签、切片、列表、掩码或这些的序列

对于每个级别，您应该使用上面的一个。如果一个级别不应该使用，请将其设置为slice(None)。

返回值：

numpy.ndarray

适合传递给 iloc 的整数的 NumPy 数组。

参见

MultiIndex.get_loc

获取标签或标签元组的位置。

MultiIndex.slice_locs

给定起始标签和结束标签，获取切片位置。

示例

>>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')])

>>> mi.get_locs('b')  
array([1, 2], dtype=int64)

>>> mi.get_locs([slice(None), ['e', 'f']])  
array([1, 2], dtype=int64)

>>> mi.get_locs([[True, False, True], slice('e', 'f')])  
array([2], dtype=int64)

`pandas.MultiIndex.get_loc_level`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.get_loc_level.html

MultiIndex.get_loc_level(key, level=0, drop_level=True)

获取请求标签/级别的位置和切片索引。

参数：

键标签或标签序列

level整数/级别名称或其列表，可选

drop_level布尔值，默认为 True

如果为False，结果索引将不会删除任何级别。

元组

一个包含元素的 2 元组：

元素 0：整数、切片对象或布尔数组。

元素 1：结果切片的多重索引/索引。如果键包含所有级别，则为None。

另请参阅

MultiIndex.get_loc

获取标签或标签元组的位置。

MultiIndex.get_locs

获取标签/切片/列表/掩码或其序列的位置。

示例

>>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')],
...                                names=['A', 'B'])

>>> mi.get_loc_level('b')
(slice(1, 3, None), Index(['e', 'f'], dtype='object', name='B'))

>>> mi.get_loc_level('e', level='B')
(array([False,  True, False]), Index(['b'], dtype='object', name='A'))

>>> mi.get_loc_level(['b', 'e'])
(1, None)

`pandas.MultiIndex.get_indexer`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.get_indexer.html

MultiIndex.get_indexer(target, method=None, limit=None, tolerance=None)

计算当前索引给定目标值时的索引和掩码。

然后应将索引器用作 ndarray.take 的输入，以将当前数据对齐到新索引。

参数：

target索引

method，可选

默认：仅精确匹配。
pad / ffill：如果没有精确匹配，则查找前一个索引值。
backfill / bfill：如果没有精确匹配，则使用下一个索引值。
nearest：如果没有精确匹配，则使用最接近的索引值。相同距离的情况下，通过选择较大的索引值来打破平局。

limitint，可选

target中要匹配的最大连续标签数。

tolerance（可选）

对于不精确匹配，原始标签和新标签之间的最大距离。匹配位置的索引值必须满足等式abs(index[indexer] - target) <= tolerance。

容差可以是标量值，将相同的容差应用于所有值，也可以是类似列表的值，对每个元素应用可变容差。类似列表包括列表、元组、数组、Series，且必须与索引的大小完全匹配，并且其 dtype 必须与索引的类型完全匹配。

np.ndarray[np.intp]

从 0 到 n-1 的整数表示这些位置上的索引与相应的目标值匹配。目标中的缺失值由-1 标记。

注释

对于不匹配的值返回-1，详细说明请参见下面的示例。

示例

>>> index = pd.Index(['c', 'a', 'b'])
>>> index.get_indexer(['a', 'b', 'x'])
array([ 1,  2, -1])

注意返回值是一个包含index位置的数组，而x由-1 标记，因为它不在index中。

`pandas.MultiIndex.get_level_values`

原文：pandas.pydata.org/docs/reference/api/pandas.MultiIndex.get_level_values.html

MultiIndex.get_level_values(level)

返回请求级别的标签值向量。

返回向量的长度等于索引的长度。

参数：

level 整数或字符串

level 是 MultiIndex 中级别的整数位置或级别的名称。

索引

值是此 MultiIndex 的级别转换为单个 Index（或其子类）。

注意

如果级别包含缺失值，则结果可能被转换为 float，缺失值指定为 NaN。这是因为级别被转换为常规的 Index。

示例

创建 MultiIndex：

>>> mi = pd.MultiIndex.from_arrays((list('abc'), list('def')))
>>> mi.names = ['level_1', 'level_2']

通过提供整数或名称作为级别来获取级别值：

>>> mi.get_level_values(0)
Index(['a', 'b', 'c'], dtype='object', name='level_1')
>>> mi.get_level_values('level_2')
Index(['d', 'e', 'f'], dtype='object', name='level_2')

如果级别包含缺失值，则级别的返回类型可能被转换为 float。

>>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).dtypes
level_0    int64
level_1    int64
dtype: object
>>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).get_level_values(0)
Index([1.0, nan, 2.0], dtype='float64')

`pandas.IndexSlice`

原文：pandas.pydata.org/docs/reference/api/pandas.IndexSlice.html

pandas.IndexSlice = <pandas.core.indexing._IndexSlice object>

创建一个对象，更轻松地执行多级索引切片。

另请参阅

MultiIndex.remove_unused_levels

具有无未使用级别的新 MultiIndex。

注意事项

参见定义级别以获取有关切片多级索引的更多信息。

示例

>>> midx = pd.MultiIndex.from_product([['A0','A1'], ['B0','B1','B2','B3']])
>>> columns = ['foo', 'bar']
>>> dfmi = pd.DataFrame(np.arange(16).reshape((len(midx), len(columns))),
...                     index=midx, columns=columns)

使用默认的切片命令：

>>> dfmi.loc[(slice(None), slice('B0', 'B1')), :]
 foo  bar
 A0 B0    0    1
 B1    2    3
 A1 B0    8    9
 B1   10   11

使用 IndexSlice 类进行更直观的命令：

>>> idx = pd.IndexSlice
>>> dfmi.loc[idx[:, 'B0':'B1'], :]
 foo  bar
 A0 B0    0    1
 B1    2    3
 A1 B0    8    9
 B1   10   11

`pandas.DatetimeIndex`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.html

class pandas.DatetimeIndex(data=None, freq=_NoDefault.no_default, tz=_NoDefault.no_default, normalize=_NoDefault.no_default, closed=_NoDefault.no_default, ambiguous='raise', dayfirst=False, yearfirst=False, dtype=None, copy=False, name=None)

不可变 ndarray 类型的 datetime64 数据。

在内部表示为 int64，可以封装为继承自 datetime 并携带元数据的 Timestamp 对象。

从 2.0.0 版本开始更改：各种数值日期/时间属性（day、month、year 等）现在具有 dtype int32。以前它们的 dtype 为 int64。

参数：

data类似数组（1 维）

用于构建索引的类似日期时间的数据。

freq字符串或 pandas 偏移对象，可选

pandas 日期偏移字符串或相应的对象之一。可以传递字符串 ‘infer’ 以在创建时设置索引的频率为推断的频率。

tzpytz.timezone 或 dateutil.tz.tzfile 或 datetime.tzinfo 或字符串

设置数据的时区。

normalize布尔类型，默认为 False

在生成日期范围之前将开始/结束日期标准化为午夜。

自 2.1.0 版本后不推荐使用。

closed，可选

设置是否包含位于边界上的起始点和结束点。默认情况下包含两端的边界点。

自 2.1.0 版本后不推荐使用。

ambiguous‘infer’，布尔类型的 ndarray，‘NaT’，默认为 ‘raise’

由于 DST 导致时钟倒退，可能会出现模糊时间。例如，在中欧时间（UTC+01）中，从 03:00 DST 到 02:00 非 DST 时，当地时间 02:30:00 同时发生在 00:30:00 UTC 和 01:30:00 UTC。在这种情况下，模糊参数决定如何处理模糊时间。

‘infer’ 将尝试根据顺序推断秋季 DST 转换小时。
一个布尔类型的 ndarray，其中 True 表示 DST 时间，False 表示非 DST 时间（请注意，此标志仅适用于模糊时间）。
当存在模糊时间时，‘NaT’ 将返回 NaT。
如果存在模糊时间，则 ‘raise’ 将引发 AmbiguousTimeError。

dayfirst布尔类型，默认为 False

如果为 True，则使用日期优先顺序解析数据中的日期。

yearfirst布尔类型，默认为 False

如果为 True，则使用年份优先顺序解析数据中的日期。

dtypenumpy.dtype 或 DatetimeTZDtype 或字符串，默认为 None

请注意，唯一允许的 NumPy dtype 是 datetime64[ns]。

copy布尔类型，默认为 False

复制输入 ndarray。

name标签，默认为 None

要存储在索引中的名称。

另请参阅

Index

pandas 的基本索引类型。

TimedeltaIndex

timedelta64 数据的索引。

PeriodIndex

Period 数据的索引。

to_datetime

将参数转换为日期时间。

date_range

创建固定频率的日期时间索引。

注意事项

要了解更多关于频率字符串的信息，请参阅此链接。

示例

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
>>> idx
DatetimeIndex(['2020-01-01 10:00:00+00:00', '2020-02-01 11:00:00+00:00'],
dtype='datetime64[ns, UTC]', freq=None)

属性

`year`	日期时间的年份部分。
`month`	月份，一月=1，十二月=12。
`day`	日期时间的日期部分。
`hour`	日期时间的小时部分。
`minute`	日期时间的分钟部分。
`second`	日期时间的秒部分。
`microsecond`	日期时间的微秒部分。
`nanosecond`	日期时间的纳秒部分。
`date`	返回带有时区的 python `datetime.date` 对象的 numpy 数组。
`time`	返回带有时区的 `datetime.time` 对象的 numpy 数组。
`timetz`	返回带有时区的 `datetime.time` 对象的 numpy 数组。
`dayofyear`	年份中的第几天。
`day_of_year`	年份中的第几天。
`dayofweek`	星期几，星期一=0，星期日=6。
`day_of_week`	星期几，星期一=0，星期日=6。
`weekday`	一周中的星期几，星期一为 0，星期日为 6。
`quarter`	日期所在季度。
`tz`	返回时区信息。
`freqstr`	如果设置了频率对象，则返回字符串形式的频率，否则返回 None。
`is_month_start`	表示日期是否为月初。
`is_month_end`	表示日期是否为月末。
`is_quarter_start`	表示日期是否为季度的第一天。
`is_quarter_end`	表示日期是否为季度末。
`is_year_start`	表示日期是否为年初。
`is_year_end`	表示日期是否为年末。
`is_leap_year`	如果日期属于闰年，则为真。
`inferred_freq`	尝试返回由 infer_freq 生成的表示频率的字符串。
freq

方法

`normalize`(args, *kwargs)	将时间转换为午夜。
`strftime`(date_format)	使用指定的日期格式转换为索引。
`snap`([freq])	将时间戳调整到最接近的频率。
`tz_convert`(tz)	将具有时区信息的日期数组/索引从一个时区转换为另一个时区。
`tz_localize`(tz[, ambiguous, nonexistent])	将时区无关的日期时间数组/索引本地化为时区感知的日期时间数组/索引。
`round`(args, *kwargs)	对数据执行四舍五入操作，以指定的频率为准。
`floor`(args, *kwargs)	对数据执行向下取整操作，以指定的频率为准。
`ceil`(args, *kwargs)	对数据执行向上取整操作，以指定的频率为准。
`to_period`(args, *kwargs)	将日期时间转换为特定频率的 PeriodArray/PeriodIndex。
`to_pydatetime`(args, *kwargs)	返回一个由`datetime.datetime`对象组成的 ndarray。
`to_series`([index, name])	创建一个 Series，其索引和值都等于索引键。
`to_frame`([index, name])	创建一个包含索引的列的 DataFrame。
`month_name`(args, *kwargs)	返回指定语言环境下的月份名称。
`day_name`(args, *kwargs)	返回指定语言环境下的星期几名称。
`mean`(*[, skipna, axis])	返回数组的平均值。
`std`(args, *kwargs)	沿请求的轴返回样本标准差。

`pandas.DatetimeIndex.year`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.year.html

property DatetimeIndex.year

日期时间的年份。

示例

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="YE")
... )
>>> datetime_series
0   2000-12-31
1   2001-12-31
2   2002-12-31
dtype: datetime64[ns]
>>> datetime_series.dt.year
0    2000
1    2001
2    2002
dtype: int32

`pandas.DatetimeIndex.month`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.month.html

property DatetimeIndex.month

月份，一月为 1，十二月为 12。

示例

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="ME")
... )
>>> datetime_series
0   2000-01-31
1   2000-02-29
2   2000-03-31
dtype: datetime64[ns]
>>> datetime_series.dt.month
0    1
1    2
2    3
dtype: int32

`pandas.DatetimeIndex.day`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.day.html

property DatetimeIndex.day

日期时间的日期。

示例

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="D")
... )
>>> datetime_series
0   2000-01-01
1   2000-01-02
2   2000-01-03
dtype: datetime64[ns]
>>> datetime_series.dt.day
0    1
1    2
2    3
dtype: int32

`pandas.DatetimeIndex.hour`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.hour.html

property DatetimeIndex.hour

时间的小时。

示例

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="h")
... )
>>> datetime_series
0   2000-01-01 00:00:00
1   2000-01-01 01:00:00
2   2000-01-01 02:00:00
dtype: datetime64[ns]
>>> datetime_series.dt.hour
0    0
1    1
2    2
dtype: int32

`pandas.DatetimeIndex.minute`

pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.minute.html

property DatetimeIndex.minute

时间的分钟。

例子

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="min")
... )
>>> datetime_series
0   2000-01-01 00:00:00
1   2000-01-01 00:01:00
2   2000-01-01 00:02:00
dtype: datetime64[ns]
>>> datetime_series.dt.minute
0    0
1    1
2    2
dtype: int32

`pandas.DatetimeIndex.second`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.second.html

property DatetimeIndex.second

时间日期的秒数。

示例

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="s")
... )
>>> datetime_series
0   2000-01-01 00:00:00
1   2000-01-01 00:00:01
2   2000-01-01 00:00:02
dtype: datetime64[ns]
>>> datetime_series.dt.second
0    0
1    1
2    2
dtype: int32

`pandas.DatetimeIndex.microsecond`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.microsecond.html

property DatetimeIndex.microsecond

日期时间的微秒。

Examples

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="us")
... )
>>> datetime_series
0   2000-01-01 00:00:00.000000
1   2000-01-01 00:00:00.000001
2   2000-01-01 00:00:00.000002
dtype: datetime64[ns]
>>> datetime_series.dt.microsecond
0       0
1       1
2       2
dtype: int32

`pandas.DatetimeIndex.nanosecond`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.nanosecond.html

property DatetimeIndex.nanosecond

日期时间的纳秒部分。

示例

>>> datetime_series = pd.Series(
...     pd.date_range("2000-01-01", periods=3, freq="ns")
... )
>>> datetime_series
0   2000-01-01 00:00:00.000000000
1   2000-01-01 00:00:00.000000001
2   2000-01-01 00:00:00.000000002
dtype: datetime64[ns]
>>> datetime_series.dt.nanosecond
0       0
1       1
2       2
dtype: int32

`pandas.DatetimeIndex.date`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.date.html

property DatetimeIndex.date

返回由 Python datetime.date 对象组成的 NumPy 数组。

即，没有时间和时区信息的时间戳的日期部分。

例子

对于 Series：

>>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
>>> s = pd.to_datetime(s)
>>> s
0   2020-01-01 10:00:00+00:00
1   2020-02-01 11:00:00+00:00
dtype: datetime64[ns, UTC]
>>> s.dt.date
0    2020-01-01
1    2020-02-01
dtype: object

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",
...                         "2/1/2020 11:00:00+00:00"])
>>> idx.date
array([datetime.date(2020, 1, 1), datetime.date(2020, 2, 1)], dtype=object)

`pandas.DatetimeIndex.time`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.time.html

property DatetimeIndex.time

返回 datetime.time 对象的 numpy 数组。

时间戳的时间部分。

示例

对于 Series：

>>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
>>> s = pd.to_datetime(s)
>>> s
0   2020-01-01 10:00:00+00:00
1   2020-02-01 11:00:00+00:00
dtype: datetime64[ns, UTC]
>>> s.dt.time
0    10:00:00
1    11:00:00
dtype: object

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",
...                         "2/1/2020 11:00:00+00:00"])
>>> idx.time
array([datetime.time(10, 0), datetime.time(11, 0)], dtype=object)

`pandas.DatetimeIndex.timetz`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.timetz.html

property DatetimeIndex.timetz

返回带有时区的datetime.time对象的 numpy 数组。

时间戳的时间部分。

示例

对于 Series：

>>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
>>> s = pd.to_datetime(s)
>>> s
0   2020-01-01 10:00:00+00:00
1   2020-02-01 11:00:00+00:00
dtype: datetime64[ns, UTC]
>>> s.dt.timetz
0    10:00:00+00:00
1    11:00:00+00:00
dtype: object

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",
...                         "2/1/2020 11:00:00+00:00"])
>>> idx.timetz
array([datetime.time(10, 0, tzinfo=datetime.timezone.utc),
datetime.time(11, 0, tzinfo=datetime.timezone.utc)], dtype=object)

`pandas.DatetimeIndex.dayofyear`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.dayofyear.html

property DatetimeIndex.dayofyear

一年中的第几天。

示例

对于 Series：

>>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
>>> s = pd.to_datetime(s)
>>> s
0   2020-01-01 10:00:00+00:00
1   2020-02-01 11:00:00+00:00
dtype: datetime64[ns, UTC]
>>> s.dt.dayofyear
0    1
1   32
dtype: int32

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",
...                         "2/1/2020 11:00:00+00:00"])
>>> idx.dayofyear
Index([1, 32], dtype='int32')

`pandas.DatetimeIndex.day_of_year`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.day_of_year.html

property DatetimeIndex.day_of_year

年份中的序数日。

例子

对于 Series：

>>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
>>> s = pd.to_datetime(s)
>>> s
0   2020-01-01 10:00:00+00:00
1   2020-02-01 11:00:00+00:00
dtype: datetime64[ns, UTC]
>>> s.dt.dayofyear
0    1
1   32
dtype: int32

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",
...                         "2/1/2020 11:00:00+00:00"])
>>> idx.dayofyear
Index([1, 32], dtype='int32')

`pandas.DatetimeIndex.dayofweek`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.dayofweek.html

property DatetimeIndex.dayofweek

星期几，星期一=0，星期日=6。

返回星期几。假设一周从星期一开始，用 0 表示，到星期日结束，用 6 表示。此方法适用于具有日期时间值的系列（使用 dt 访问器）或 DatetimeIndex。

系列或索引

包含表示星期几的整数。

另请参阅

Series.dt.dayofweek

别名。

Series.dt.weekday

别名。

Series.dt.day_name

返回星期几的名称。

示例

>>> s = pd.date_range('2016-12-31', '2017-01-08', freq='D').to_series()
>>> s.dt.dayofweek
2016-12-31    5
2017-01-01    6
2017-01-02    0
2017-01-03    1
2017-01-04    2
2017-01-05    3
2017-01-06    4
2017-01-07    5
2017-01-08    6
Freq: D, dtype: int32

`pandas.DatetimeIndex.day_of_week`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.day_of_week.html

property DatetimeIndex.day_of_week

一周的星期几，星期一=0，星期日=6。

返回星期几。假设星期从星期一开始，用 0 表示，到星期日结束，用 6 表示。此方法可用于具有日期时间值（使用 dt 访问器）或 DatetimeIndex 的 Series。

Series 或 Index

包含表示日期数字的整数。

另请参见

Series.dt.dayofweek

别名。

Series.dt.weekday

别名。

Series.dt.day_name

返回星期几的名称。

示例

>>> s = pd.date_range('2016-12-31', '2017-01-08', freq='D').to_series()
>>> s.dt.dayofweek
2016-12-31    5
2017-01-01    6
2017-01-02    0
2017-01-03    1
2017-01-04    2
2017-01-05    3
2017-01-06    4
2017-01-07    5
2017-01-08    6
Freq: D, dtype: int32

`pandas.DatetimeIndex.weekday`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.weekday.html

property DatetimeIndex.weekday

星期几，星期一为 0，星期日为 6。

返回星期几。假设一周从星期一开始，用 0 表示，以星期日结束，用 6 表示。此方法可用于具有日期时间值的 Series（使用 dt 访问器）或 DatetimeIndex。

Series 或 Index

包含整数，表示日期编号。

另请参阅

Series.dt.dayofweek

别名。

Series.dt.weekday

别名。

Series.dt.day_name

返回星期几的名称。

示例

>>> s = pd.date_range('2016-12-31', '2017-01-08', freq='D').to_series()
>>> s.dt.dayofweek
2016-12-31    5
2017-01-01    6
2017-01-02    0
2017-01-03    1
2017-01-04    2
2017-01-05    3
2017-01-06    4
2017-01-07    5
2017-01-08    6
Freq: D, dtype: int32

`pandas.DatetimeIndex.quarter`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.quarter.html

property DatetimeIndex.quarter

日期的季度。

示例

对于 Series：

>>> s = pd.Series(["1/1/2020 10:00:00+00:00", "4/1/2020 11:00:00+00:00"])
>>> s = pd.to_datetime(s)
>>> s
0   2020-01-01 10:00:00+00:00
1   2020-04-01 11:00:00+00:00
dtype: datetime64[ns, UTC]
>>> s.dt.quarter
0    1
1    2
dtype: int32

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",
...                         "2/1/2020 11:00:00+00:00"])
>>> idx.quarter
Index([1, 1], dtype='int32')

`pandas.DatetimeIndex.tz`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.tz.html

property DatetimeIndex.tz

返回时区。

datetime.tzinfo，pytz.tzinfo.BaseTZInfo，dateutil.tz.tz.tzfile 或 None

当数组是时区无关的时候返回 None。

例子

对于 Series：

>>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])
>>> s = pd.to_datetime(s)
>>> s
0   2020-01-01 10:00:00+00:00
1   2020-02-01 11:00:00+00:00
dtype: datetime64[ns, UTC]
>>> s.dt.tz
datetime.timezone.utc

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",
...                         "2/1/2020 11:00:00+00:00"])
>>> idx.tz
datetime.timezone.utc

`pandas.DatetimeIndex.freq`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.freq.html

property DatetimeIndex.freq

`pandas.DatetimeIndex.freqstr`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.freqstr.html

property DatetimeIndex.freqstr

如果设置了频率，则返回频率对象作为字符串，否则返回 None。

示例

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00"], freq="D")
>>> idx.freqstr
'D'

如果有两个以上的点，则可以推断出频率：

>>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"],
...                        freq="infer")
>>> idx.freqstr
'2D'

对于 PeriodIndex：

>>> idx = pd.PeriodIndex(["2023-1", "2023-2", "2023-3"], freq="M")
>>> idx.freqstr
'M'

`pandas.DatetimeIndex.is_month_start`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.is_month_start.html

property DatetimeIndex.is_month_start

表示日期是否为月初。

Series 或数组

对于 Series，返回一个带有布尔值的 Series。对于 DatetimeIndex，返回一个布尔数组。

另请参见

is_month_start

返回一个布尔值，指示日期是否为该月的第一天。

is_month_end

返回一个布尔值，指示日期是否为该月的最后一天。

示例

此方法在具有日期时间值的 Series 下的 .dt 访问器下可用，并直接在 DatetimeIndex 上可用。

>>> s = pd.Series(pd.date_range("2018-02-27", periods=3))
>>> s
0   2018-02-27
1   2018-02-28
2   2018-03-01
dtype: datetime64[ns]
>>> s.dt.is_month_start
0    False
1    False
2    True
dtype: bool
>>> s.dt.is_month_end
0    False
1    True
2    False
dtype: bool

>>> idx = pd.date_range("2018-02-27", periods=3)
>>> idx.is_month_start
array([False, False, True])
>>> idx.is_month_end
array([False, True, False])

`pandas.DatetimeIndex.is_month_end`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.is_month_end.html

property DatetimeIndex.is_month_end

指示日期是否为月末。

Series 或数组

对于 Series，返回一个带有布尔值的 Series。对于 DatetimeIndex，返回一个布尔数组。

另请参见

is_month_start

返回一个布尔值，指示日期是否为月初。

is_month_end

返回一个布尔值，指示日期是否为月末。

示例

该方法适用于具有日期时间值的 Series，使用.dt访问器，以及直接适用于 DatetimeIndex。

>>> s = pd.Series(pd.date_range("2018-02-27", periods=3))
>>> s
0   2018-02-27
1   2018-02-28
2   2018-03-01
dtype: datetime64[ns]
>>> s.dt.is_month_start
0    False
1    False
2    True
dtype: bool
>>> s.dt.is_month_end
0    False
1    True
2    False
dtype: bool

>>> idx = pd.date_range("2018-02-27", periods=3)
>>> idx.is_month_start
array([False, False, True])
>>> idx.is_month_end
array([False, True, False])

`pandas.DatetimeIndex.is_quarter_start`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.is_quarter_start.html

property DatetimeIndex.is_quarter_start

指示日期是否为季度的第一天的指示器。

is_quarter_start系列或 DatetimeIndex

与原始数据相同类型的具有布尔值的数据。系列将具有相同的名称和索引。DatetimeIndex 将具有相同的名称。

另请参阅

quarter

返回日期的季度。

is_quarter_end

指示季度结束的类似属性。

示例

此方法在具有日期时间值的系列上通过.dt访问器，并直接在 DatetimeIndex 上可用。

>>> df = pd.DataFrame({'dates': pd.date_range("2017-03-30",
...                   periods=4)})
>>> df.assign(quarter=df.dates.dt.quarter,
...           is_quarter_start=df.dates.dt.is_quarter_start)
 dates  quarter  is_quarter_start
0 2017-03-30        1             False
1 2017-03-31        1             False
2 2017-04-01        2              True
3 2017-04-02        2             False

>>> idx = pd.date_range('2017-03-30', periods=4)
>>> idx
DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'],
 dtype='datetime64[ns]', freq='D')

>>> idx.is_quarter_start
array([False, False,  True, False])

`pandas.DatetimeIndex.is_quarter_end`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.is_quarter_end.html

property DatetimeIndex.is_quarter_end

指示日期是否为季度的最后一天的指标。

is_quarter_endSeries 或 DatetimeIndex

与具有布尔值的原始数据相同类型。 Series 将具有相同的名称和索引。 DatetimeIndex 将具有相同的名称。

另请参阅

quarter

返回日期的季度。

is_quarter_start

表示季度开始的相似属性。

示例

此方法可在具有日期时间值的 Series 上通过 .dt 访问器使用，并直接在 DatetimeIndex 上使用。

>>> df = pd.DataFrame({'dates': pd.date_range("2017-03-30",
...                    periods=4)})
>>> df.assign(quarter=df.dates.dt.quarter,
...           is_quarter_end=df.dates.dt.is_quarter_end)
 dates  quarter    is_quarter_end
0 2017-03-30        1             False
1 2017-03-31        1              True
2 2017-04-01        2             False
3 2017-04-02        2             False

>>> idx = pd.date_range('2017-03-30', periods=4)
>>> idx
DatetimeIndex(['2017-03-30', '2017-03-31', '2017-04-01', '2017-04-02'],
 dtype='datetime64[ns]', freq='D')

>>> idx.is_quarter_end
array([False,  True, False, False])

`pandas.DatetimeIndex.is_year_start`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.is_year_start.html

property DatetimeIndex.is_year_start

判断日期是否为一年的第一天。

Series 或 DatetimeIndex

与原始数据相同类型，具有布尔值。Series 将具有相同的名称和索引。DatetimeIndex 将具有相同的名称。

另请参阅

is_year_end

类似的属性指示一年的最后一天。

示例

此方法适用于具有日期时间值的 Series 在 .dt 访问器下，以及直接在 DatetimeIndex 上。

>>> dates = pd.Series(pd.date_range("2017-12-30", periods=3))
>>> dates
0   2017-12-30
1   2017-12-31
2   2018-01-01
dtype: datetime64[ns]

>>> dates.dt.is_year_start
0    False
1    False
2    True
dtype: bool

>>> idx = pd.date_range("2017-12-30", periods=3)
>>> idx
DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'],
 dtype='datetime64[ns]', freq='D')

>>> idx.is_year_start
array([False, False,  True])

`pandas.DatetimeIndex.is_year_end`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.is_year_end.html

property DatetimeIndex.is_year_end

指示日期是否为一年中的最后一天。

系列或 DatetimeIndex

返回与原始数据相同类型的布尔值。系列将具有相同的名称和索引。DatetimeIndex 将具有相同的名称。

另请参阅

is_year_start

类似的属性指示年的开始。

示例

此方法在具有日期时间值的系列下使用.dt访问器，并直接在 DatetimeIndex 上使用。

>>> dates = pd.Series(pd.date_range("2017-12-30", periods=3))
>>> dates
0   2017-12-30
1   2017-12-31
2   2018-01-01
dtype: datetime64[ns]

>>> dates.dt.is_year_end
0    False
1     True
2    False
dtype: bool

>>> idx = pd.date_range("2017-12-30", periods=3)
>>> idx
DatetimeIndex(['2017-12-30', '2017-12-31', '2018-01-01'],
 dtype='datetime64[ns]', freq='D')

>>> idx.is_year_end
array([False,  True, False])

`pandas.DatetimeIndex.is_leap_year`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.is_leap_year.html

property DatetimeIndex.is_leap_year

布尔指示符，用于判断日期是否属于闰年。

闰年是指一年有 366 天（而不是 365 天），包括 2 月 29 日作为闰日。闰年是 4 的倍数的年份，但除以 100 但不能被 400 整除的年份除外。

Series 或 ndarray

布尔值，指示日期是否属于闰年。

示例

该方法可在带有日期时间值的序列中通过.dt访问器使用，也可以直接在 DatetimeIndex 上使用。

>>> idx = pd.date_range("2012-01-01", "2015-01-01", freq="YE")
>>> idx
DatetimeIndex(['2012-12-31', '2013-12-31', '2014-12-31'],
 dtype='datetime64[ns]', freq='YE-DEC')
>>> idx.is_leap_year
array([ True, False, False])

>>> dates_series = pd.Series(idx)
>>> dates_series
0   2012-12-31
1   2013-12-31
2   2014-12-31
dtype: datetime64[ns]
>>> dates_series.dt.is_leap_year
0     True
1    False
2    False
dtype: bool

`pandas.DatetimeIndex.inferred_freq`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.inferred_freq.html

DatetimeIndex.inferred_freq

尝试返回一个由 infer_freq 生成的表示频率的字符串。

如果无法自动检测到频率，则返回 None。

示例

对于 DatetimeIndex：

>>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"])
>>> idx.inferred_freq
'2D'

对于 TimedeltaIndex：

>>> tdelta_idx = pd.to_timedelta(["0 days", "10 days", "20 days"])
>>> tdelta_idx
TimedeltaIndex(['0 days', '10 days', '20 days'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.inferred_freq
'10D'

`pandas.DatetimeIndex.indexer_at_time`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.indexer_at_time.html

DatetimeIndex.indexer_at_time(time, asof=False)

返回特定时间的值的索引位置。

参数:

timedatetime.time 或 str

时间以对象（datetime.time）或适当格式的字符串传入（“%H:%M”, “%H%M”, “%I:%M%p”, “%I%M%p”, “%H:%M:%S”, “%H%M%S”, “%I:%M:%S%p”, “%I%M%S%p”）。

np.ndarray[np.intp]

另请参阅

indexer_between_time

获取特定时间段内值的索引位置。

DataFrame.at_time

选择特定时间的值。

示例

>>> idx = pd.DatetimeIndex(["1/1/2020 10:00", "2/1/2020 11:00",
...                         "3/1/2020 10:00"])
>>> idx.indexer_at_time("10:00")
array([0, 2])

`pandas.DatetimeIndex.indexer_between_time`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.indexer_between_time.html

DatetimeIndex.indexer_between_time(start_time, end_time, include_start=True, include_end=True)

返回特定时间段内数值的索引位置。

参数：

start_time, end_timedatetime.time, str

时间以对象（datetime.time）或适当格式的字符串传递（“%H:%M”，“%H%M”，“%I:%M%p”，“%I%M%p”，“%H:%M:%S”，“%H%M%S”，“%I:%M:%S%p”，“%I%M%S%p”）。

include_startbool, default True

include_endbool, default True

np.ndarray[np.intp]

参见

indexer_at_time

获取特定时间段数值的索引位置。

DataFrame.between_time

选择特定时间段内的数值。

示例

>>> idx = pd.date_range("2023-01-01", periods=4, freq="h")
>>> idx
DatetimeIndex(['2023-01-01 00:00:00', '2023-01-01 01:00:00',
 '2023-01-01 02:00:00', '2023-01-01 03:00:00'],
 dtype='datetime64[ns]', freq='h')
>>> idx.indexer_between_time("00:00", "2:00", include_end=False)
array([0, 1])

`pandas.DatetimeIndex.normalize`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.normalize.html

DatetimeIndex.normalize(*args, **kwargs)

将时间转换为午夜。

时间日期的时间组件被转换为午夜即00:00:00。这在时间不重要的情况下很有用。长度不变。时区不受影响。

此方法适用于具有.dt访问器下的日期时间值的 Series，以及直接适用于 Datetime Array/Index。

DatetimeArray、DatetimeIndex 或 Series

与原始数据相同的类型。Series 将具有相同的名称和索引。DatetimeIndex 将具有相同的名称。

另请参阅

floor

将日期时间向下取整到指定的频率。

ceil

将日期时间向上取整到指定的频率。

round

将日期时间向上取整到指定的频率。

示例

>>> idx = pd.date_range(start='2014-08-01 10:00', freq='h',
...                     periods=3, tz='Asia/Calcutta')
>>> idx
DatetimeIndex(['2014-08-01 10:00:00+05:30',
 '2014-08-01 11:00:00+05:30',
 '2014-08-01 12:00:00+05:30'],
 dtype='datetime64[ns, Asia/Calcutta]', freq='h')
>>> idx.normalize()
DatetimeIndex(['2014-08-01 00:00:00+05:30',
 '2014-08-01 00:00:00+05:30',
 '2014-08-01 00:00:00+05:30'],
 dtype='datetime64[ns, Asia/Calcutta]', freq=None)

`pandas.DatetimeIndex.strftime`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.strftime.html

DatetimeIndex.strftime(date_format)

使用指定的日期格式转换为索引。

返回按照指定的日期格式格式化的索引字符串，支持与 Python 标准库相同的字符串格式。字符串格式的详细信息可以在python string format doc中找到。

C strftime API 支持的格式，但不在 python string format doc 中支持的格式（如“%R”、“%r”）不受官方支持，最好用其支持的等价格式替换（如“%H:%M”、“%I:%M:%S %p”）。

请注意，PeriodIndex 支持附加指令，详细信息请参见 Period.strftime。

参数：

date_formatstr

日期格式字符串（例如“%Y-%m-%d”）。

ndarray[object]

NumPy ndarray 的格式化字符串。

另请参见

to_datetime

将给定参数转换为日期时间。

DatetimeIndex.normalize

返回具有午夜时间的 DatetimeIndex。

DatetimeIndex.round

将 DatetimeIndex 四舍五入到指定的频率。

DatetimeIndex.floor

将 DatetimeIndex 向下取整到指定的频率。

Timestamp.strftime

格式化单个时间戳。

Period.strftime

格式化单个周期。

示例

>>> rng = pd.date_range(pd.Timestamp("2018-03-10 09:00"),
...                     periods=3, freq='s')
>>> rng.strftime('%B %d, %Y, %r')
Index(['March 10, 2018, 09:00:00 AM', 'March 10, 2018, 09:00:01 AM',
 'March 10, 2018, 09:00:02 AM'],
 dtype='object')

`pandas.DatetimeIndex.snap`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.snap.html

DatetimeIndex.snap(freq='S')

将时间戳捕捉到最近的发生频率。

DatetimeIndex

例子

>>> idx = pd.DatetimeIndex(['2023-01-01', '2023-01-02',
...                        '2023-02-01', '2023-02-02'])
>>> idx
DatetimeIndex(['2023-01-01', '2023-01-02', '2023-02-01', '2023-02-02'],
dtype='datetime64[ns]', freq=None)
>>> idx.snap('MS')
DatetimeIndex(['2023-01-01', '2023-01-01', '2023-02-01', '2023-02-01'],
dtype='datetime64[ns]', freq=None)

`pandas.DatetimeIndex.tz_convert`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.tz_convert.html

DatetimeIndex.tz_convert(tz)

将 tz-aware 的 Datetime 数组/索引从一个时区转换为另一个时区。

参数：

tzstr，pytz.timezone，dateutil.tz.tzfile，datetime.tzinfo 或 None

时间的时区。相应的时间戳将被转换为 Datetime 数组/索引的这个时区。tz 为 None 将转换为 UTC 并移除时区信息。

数组或索引

引发：

类型错误

如果 Datetime 数组/索引是 tz-naive。

另请参阅

DatetimeIndex.tz

一个与 UTC 具有可变偏移量的时区。

DatetimeIndex.tz_localize

将 tz-naive 的 DatetimeIndex 本地化到给定时区，或从 tz-aware 的 DatetimeIndex 中移除时区。

示例

使用 tz 参数，我们可以将 DatetimeIndex 更改为其他时区：

>>> dti = pd.date_range(start='2014-08-01 09:00',
...                     freq='h', periods=3, tz='Europe/Berlin')

>>> dti
DatetimeIndex(['2014-08-01 09:00:00+02:00',
 '2014-08-01 10:00:00+02:00',
 '2014-08-01 11:00:00+02:00'],
 dtype='datetime64[ns, Europe/Berlin]', freq='h')

>>> dti.tz_convert('US/Central')
DatetimeIndex(['2014-08-01 02:00:00-05:00',
 '2014-08-01 03:00:00-05:00',
 '2014-08-01 04:00:00-05:00'],
 dtype='datetime64[ns, US/Central]', freq='h')

使用tz=None，我们可以移除时区（在必要时转换为 UTC）：

>>> dti = pd.date_range(start='2014-08-01 09:00', freq='h',
...                     periods=3, tz='Europe/Berlin')

>>> dti
DatetimeIndex(['2014-08-01 09:00:00+02:00',
 '2014-08-01 10:00:00+02:00',
 '2014-08-01 11:00:00+02:00'],
 dtype='datetime64[ns, Europe/Berlin]', freq='h')

>>> dti.tz_convert(None)
DatetimeIndex(['2014-08-01 07:00:00',
 '2014-08-01 08:00:00',
 '2014-08-01 09:00:00'],
 dtype='datetime64[ns]', freq='h')

`pandas.DatetimeIndex.tz_localize`

原文：pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.tz_localize.html

DatetimeIndex.tz_localize(tz, ambiguous='raise', nonexistent='raise')

将 tz-naive 的 Datetime Array/Index 本地化为 tz-aware 的 Datetime Array/Index。

此方法接受一个时区（tz）naive 的 Datetime Array/Index 对象，并使其具有时区意识。它不会将时间移动到另一个时区。

该方法也可用于执行相反操作 - 从 aware 对象创建一个无时区的对象。为此，传递 tz=None。

参数：

tzstr，pytz.timezone，dateutil.tz.tzfile，datetime.tzinfo 或 None

要将时间戳转换为的时区。传递None将删除时区信息，保留本地时间。

模糊‘infer’，‘NaT’，布尔数组，默认‘raise’

由于 DST 而向后移动时钟时，可能会出现模糊时间。例如，在中欧时间（UTC+01）中，从 03:00 DST 到 02:00 非 DST 时，当本地时间 02:30:00 同时出现在 00:30:00 UTC 和 01:30:00 UTC。在这种情况下，模糊参数决定如何处理模糊时间。

‘infer’将尝试根据顺序推断秋季 dst 转换小时
布尔 ndarray，其中 True 表示 DST 时间，False 表示非 DST 时间（请注意，此标志仅适用于模糊时间）
‘NaT’将在存在模糊时间时返回 NaT
如果存在模糊时间，‘raise’将引发 AmbiguousTimeError。

不存在的‘shift_forward’，‘shift_backward’，‘NaT’，时间差，默认‘raise’

不存在的时间在由于 DST 而向前移动时钟的特定时区中不存在。

‘shift_forward’将不存在的时间向前移动到最接近的现有时间
‘shift_backward’将不存在的时间向后移动到最接近的现有时间
‘NaT’将在不存在时间时返回 NaT
时间差对象将通过时间差移动不存在的时间
如果存在不存在时间，‘raise’将引发 NonExistentTimeError。

与 self 相同类型

转换为指定时区的 Array/Index。

引发：

类型错误

如果 Datetime Array/Index 是 tz-aware 且 tz 不为 None。

另请参阅

DatetimeIndex.tz_convert

将 tz-aware 的 DatetimeIndex 从一个时区转换为另一个时区。

示例

>>> tz_naive = pd.date_range('2018-03-01 09:00', periods=3)
>>> tz_naive
DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00',
 '2018-03-03 09:00:00'],
 dtype='datetime64[ns]', freq='D')

将 DatetimeIndex 本地化为美国/东部时区：

>>> tz_aware = tz_naive.tz_localize(tz='US/Eastern')
>>> tz_aware
DatetimeIndex(['2018-03-01 09:00:00-05:00',
 '2018-03-02 09:00:00-05:00',
 '2018-03-03 09:00:00-05:00'],
 dtype='datetime64[ns, US/Eastern]', freq=None)

使用tz=None，我们可以删除时区信息，同时保留本地时间（未转换为 UTC）：

>>> tz_aware.tz_localize(None)
DatetimeIndex(['2018-03-01 09:00:00', '2018-03-02 09:00:00',
 '2018-03-03 09:00:00'],
 dtype='datetime64[ns]', freq=None)

在处理 DST 更改时要小心。当存在连续数据时，pandas 可以推断 DST 时间：

>>> s = pd.to_datetime(pd.Series(['2018-10-28 01:30:00',
...                               '2018-10-28 02:00:00',
...                               '2018-10-28 02:30:00',
...                               '2018-10-28 02:00:00',
...                               '2018-10-28 02:30:00',
...                               '2018-10-28 03:00:00',
...                               '2018-10-28 03:30:00']))
>>> s.dt.tz_localize('CET', ambiguous='infer')
0   2018-10-28 01:30:00+02:00
1   2018-10-28 02:00:00+02:00
2   2018-10-28 02:30:00+02:00
3   2018-10-28 02:00:00+01:00
4   2018-10-28 02:30:00+01:00
5   2018-10-28 03:00:00+01:00
6   2018-10-28 03:30:00+01:00
dtype: datetime64[ns, CET]

在某些情况下，推断 DST 是不可能的。在这种情况下，您可以将一个 ndarray 传递给模糊参数，以明确设置 DST

>>> s = pd.to_datetime(pd.Series(['2018-10-28 01:20:00',
...                               '2018-10-28 02:36:00',
...                               '2018-10-28 03:46:00']))
>>> s.dt.tz_localize('CET', ambiguous=np.array([True, True, False]))
0   2018-10-28 01:20:00+02:00
1   2018-10-28 02:36:00+02:00
2   2018-10-28 03:46:00+01:00
dtype: datetime64[ns, CET]

如果 DST 转换导致不存在时间，您可以使用时间差对象或‘shift_forward’或‘shift_backwards’将这些日期向前或向后移动。

>>> s = pd.to_datetime(pd.Series(['2015-03-29 02:30:00',
...                               '2015-03-29 03:30:00']))
>>> s.dt.tz_localize('Europe/Warsaw', nonexistent='shift_forward')
0   2015-03-29 03:00:00+02:00
1   2015-03-29 03:30:00+02:00
dtype: datetime64[ns, Europe/Warsaw]

>>> s.dt.tz_localize('Europe/Warsaw', nonexistent='shift_backward')
0   2015-03-29 01:59:59.999999999+01:00
1   2015-03-29 03:30:00+02:00
dtype: datetime64[ns, Europe/Warsaw]

>>> s.dt.tz_localize('Europe/Warsaw', nonexistent=pd.Timedelta('1h'))
0   2015-03-29 03:30:00+02:00
1   2015-03-29 03:30:00+02:00
dtype: datetime64[ns, Europe/Warsaw]

posted @ 2024-06-24 16:14 绝不原创的飞龙阅读(2) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Pandas-2-2-中文文档-二十八-

Pandas 2.2 中文文档（二十八）

pandas.CategoricalIndex.ordered

pandas.CategoricalIndex.rename_categories

pandas.CategoricalIndex.reorder_categories

pandas.CategoricalIndex.add_categories

pandas.CategoricalIndex.remove_categories

pandas.CategoricalIndex.remove_unused_categories

pandas.CategoricalIndex.set_categories

pandas.CategoricalIndex.as_ordered

pandas.CategoricalIndex.as_unordered

pandas.CategoricalIndex.map

pandas.CategoricalIndex.equals

pandas 区间索引

pandas.IntervalIndex.from_arrays

pandas.IntervalIndex.from_tuples

pandas.IntervalIndex.from_breaks

pandas.IntervalIndex.left

pandas.IntervalIndex.right

pandas.IntervalIndex.mid

pandas.IntervalIndex.closed

pandas.IntervalIndex.length

pandas.IntervalIndex.values

pandas.IntervalIndex.is_empty

pandas.IntervalIndex.is_non_overlapping_monotonic

pandas.IntervalIndex.is_overlapping

pandas.IntervalIndex.get_loc

pandas.IntervalIndex.get_indexer

pandas.IntervalIndex.set_closed

pandas.IntervalIndex.contains

pandas.IntervalIndex.overlaps

pandas.IntervalIndex.to_tuples

pandas.MultiIndex

pandas.MultiIndex.from_arrays

pandas.MultiIndex.from_tuples

pandas.MultiIndex.from_product

pandas.MultiIndex.from_frame

pandas.MultiIndex.names

pandas.MultiIndex.levels

pandas.MultiIndex.codes

pandas.MultiIndex.nlevels

pandas.MultiIndex.levshape

pandas.MultiIndex.dtypes

pandas.MultiIndex.set_levels

pandas.MultiIndex.set_codes

pandas.MultiIndex.to_flat_index

pandas.MultiIndex.to_frame

pandas.MultiIndex.sortlevel

pandas.MultiIndex.droplevel

pandas.MultiIndex.swaplevel 方法。

pandas.MultiIndex.reorder_levels

pandas.MultiIndex.remove_unused_levels

pandas.MultiIndex.drop

pandas.MultiIndex.copy

pandas.MultiIndex.append

pandas.MultiIndex.truncate

pandas.MultiIndex.get_loc

pandas.MultiIndex.get_locs

pandas.MultiIndex.get_loc_level

pandas.MultiIndex.get_indexer

pandas.MultiIndex.get_level_values

pandas.IndexSlice

pandas.DatetimeIndex

pandas.DatetimeIndex.year

pandas.DatetimeIndex.month

pandas.DatetimeIndex.day

pandas.DatetimeIndex.hour

pandas.DatetimeIndex.minute

pandas.DatetimeIndex.second

pandas.DatetimeIndex.microsecond

pandas.DatetimeIndex.nanosecond

pandas.DatetimeIndex.date

pandas.DatetimeIndex.time

pandas.DatetimeIndex.timetz

pandas.DatetimeIndex.dayofyear

pandas.DatetimeIndex.day_of_year

pandas.DatetimeIndex.dayofweek

pandas.DatetimeIndex.day_of_week

`pandas.CategoricalIndex.ordered`

`pandas.CategoricalIndex.rename_categories`

`pandas.CategoricalIndex.reorder_categories`

`pandas.CategoricalIndex.add_categories`

`pandas.CategoricalIndex.remove_categories`

`pandas.CategoricalIndex.remove_unused_categories`

`pandas.CategoricalIndex.set_categories`

`pandas.CategoricalIndex.as_ordered`

`pandas.CategoricalIndex.as_unordered`

`pandas.CategoricalIndex.map`

`pandas.CategoricalIndex.equals`

`pandas.IntervalIndex.from_arrays`

`pandas.IntervalIndex.from_tuples`

`pandas.IntervalIndex.from_breaks`

`pandas.IntervalIndex.left`

`pandas.IntervalIndex.right`

`pandas.IntervalIndex.mid`

`pandas.IntervalIndex.closed`

`pandas.IntervalIndex.length`

`pandas.IntervalIndex.values`

`pandas.IntervalIndex.is_empty`

`pandas.IntervalIndex.is_non_overlapping_monotonic`

`pandas.IntervalIndex.is_overlapping`

`pandas.IntervalIndex.get_loc`

`pandas.IntervalIndex.get_indexer`

`pandas.IntervalIndex.set_closed`

`pandas.IntervalIndex.contains`

`pandas.IntervalIndex.overlaps`

`pandas.IntervalIndex.to_tuples`

`pandas.MultiIndex`

`pandas.MultiIndex.from_arrays`

`pandas.MultiIndex.from_tuples`

`pandas.MultiIndex.from_product`

`pandas.MultiIndex.from_frame`

`pandas.MultiIndex.names`

`pandas.MultiIndex.levels`

`pandas.MultiIndex.codes`

`pandas.MultiIndex.nlevels`

`pandas.MultiIndex.levshape`

`pandas.MultiIndex.dtypes`

`pandas.MultiIndex.set_levels`

`pandas.MultiIndex.set_codes`

`pandas.MultiIndex.to_flat_index`

`pandas.MultiIndex.to_frame`

`pandas.MultiIndex.sortlevel`

`pandas.MultiIndex.droplevel`

`pandas.MultiIndex.swaplevel 方法。`

`pandas.MultiIndex.reorder_levels`

`pandas.MultiIndex.remove_unused_levels`

`pandas.MultiIndex.drop`

`pandas.MultiIndex.copy`

`pandas.MultiIndex.append`

`pandas.MultiIndex.truncate`

`pandas.MultiIndex.get_loc`

`pandas.MultiIndex.get_locs`

`pandas.MultiIndex.get_loc_level`

`pandas.MultiIndex.get_indexer`

`pandas.MultiIndex.get_level_values`

`pandas.IndexSlice`

`pandas.DatetimeIndex`

`pandas.DatetimeIndex.year`

`pandas.DatetimeIndex.month`

`pandas.DatetimeIndex.day`

`pandas.DatetimeIndex.hour`

`pandas.DatetimeIndex.minute`

`pandas.DatetimeIndex.second`

`pandas.DatetimeIndex.microsecond`

`pandas.DatetimeIndex.nanosecond`

`pandas.DatetimeIndex.date`

`pandas.DatetimeIndex.time`

`pandas.DatetimeIndex.timetz`

`pandas.DatetimeIndex.dayofyear`

`pandas.DatetimeIndex.day_of_year`

`pandas.DatetimeIndex.dayofweek`

`pandas.DatetimeIndex.day_of_week`

`pandas.DatetimeIndex.weekday`

`pandas.DatetimeIndex.quarter`

`pandas.DatetimeIndex.tz`

`pandas.DatetimeIndex.freq`

`pandas.DatetimeIndex.freqstr`