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

Pandas 2.2 中文文档（二十九）

原文：pandas.pydata.org/docs/

`pandas.DatetimeIndex.round`

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

DatetimeIndex.round(*args, **kwargs)

对数据执行到指定频率的四舍五入操作。

参数：

频率str 或偏移

将索引四舍五入到的频率级别。必须是固定频率，如‘S’（秒），而不是‘ME’（月末）。请参阅频率别名以获取可能的频率值列表。

模棱两可‘infer’，布尔 ndarray，‘NaT’，默认为‘raise’

仅对 DatetimeIndex 相关：

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

不存在‘shift_forward’，‘shift_backward’，‘NaT’，时间间隔，默认为‘raise’

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

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

DatetimeIndex、TimedeltaIndex 或 Series

DatetimeIndex 的相同类型的索引或 TimedeltaIndex 的索引，或具有相同索引的 Series。

引发：

如果无法转换频率，则引发 ValueError。

注意事项

如果时间戳具有时区，则将根据本地（“墙”）时间进行四舍五入，并重新本地化到相同的时区。在临近夏令时转换时，使用nonexistent和ambiguous来控制重新本地化行为。

示例

DatetimeIndex

>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
 '2018-01-01 12:01:00'],
 dtype='datetime64[ns]', freq='min')
>>> rng.round('h')
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
 '2018-01-01 12:00:00'],
 dtype='datetime64[ns]', freq=None)

系列

>>> pd.Series(rng).dt.round("h")
0   2018-01-01 12:00:00
1   2018-01-01 12:00:00
2   2018-01-01 12:00:00
dtype: datetime64[ns]

在临近夏令时转换时进行四舍五入时，使用ambiguous或nonexistent来控制时间戳的重新本地化。

>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.floor("2h", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.floor("2h", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

`pandas.DatetimeIndex.floor`

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

DatetimeIndex.floor(*args, **kwargs)

对数据执行 floor 操作到指定的频率。

参数：

freq str 或 Offset

将索引 floor 到的频率级别。必须是固定的频率，例如 ‘S’（秒），而不是 ‘ME’（月末）。参见 frequency aliases 获取可能的 freq 值列表。

ambiguous‘infer’、布尔值的 ndarray、‘NaT’，默认为 ‘raise’

仅适用于 DatetimeIndex：

如果存在秋季 DST 转换小时，则 ‘infer’ 将尝试根据顺序推断秋季 DST 转换小时。
布尔值的 ndarray，其中 True 表示 DST 时间，False 表示非 DST 时间（请注意，此标志仅适用于存在歧义的时间）
如果存在歧义的时间，‘NaT’ 选项将会返回 NaT
如果存在歧义的时间，则 ‘raise’ 选项将会抛出 AmbiguousTimeError。

nonexistent‘shift_forward’、‘shift_backward’、‘NaT’、timedelta，默认为 ‘raise’

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

如果不存在的时间，‘shift_forward’ 选项将会将不存在的时间向前移动到最接近的现有时间
如果不存在的时间，‘shift_backward’ 选项将会将不存在的时间向后移动到最接近的现有时间
如果不存在的时间，‘NaT’ 选项将会返回 NaT
timedelta 对象将会以 timedelta 来移动不存在的时间
如果不存在的时间，‘raise’ 选项将会抛出 NonExistentTimeError。

返回值：

DatetimeIndex、TimedeltaIndex 或 Series

用于 DatetimeIndex 或 TimedeltaIndex 的相同类型的索引，或用于 Series 的具有相同索引的 Series。

Raises：

如果无法转换频率，则引发 ValueError。

注意事项

如果时间戳具有时区，则将相对于本地（“墙”）时间进行 floor 操作，并重新本地化到相同的时区。在接近夏令时时进行 floor 操作时，使用 nonexistent 和 ambiguous 来控制重新本地化行为。

示例

DatetimeIndex

>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
 '2018-01-01 12:01:00'],
 dtype='datetime64[ns]', freq='min')
>>> rng.floor('h')
DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00',
 '2018-01-01 12:00:00'],
 dtype='datetime64[ns]', freq=None)

Series

>>> pd.Series(rng).dt.floor("h")
0   2018-01-01 11:00:00
1   2018-01-01 12:00:00
2   2018-01-01 12:00:00
dtype: datetime64[ns]

在接近夏令时转换时进行四舍五入时，使用 ambiguous 或 nonexistent 来控制时间戳的重新本地化。

>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.floor("2h", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.floor("2h", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

`pandas.DatetimeIndex.ceil`

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

DatetimeIndex.ceil(*args, **kwargs)

对数据执行指定频率的 ceil 操作。

Parameters:

freqstr 或 Offset

将索引取整到的频率级别。必须是固定的频率，如 ‘S’（秒），而不是 ‘ME’（月底）。有关可能的 freq 值的列表，请参见 frequency aliases。

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

仅适用于 DatetimeIndex:

‘infer’ 将尝试根据顺序推断秋天的 dst 过渡小时数
布尔型 ndarray，其中 True 表示夏令时，False 表示非夏令时（请注意，此标志仅适用于模糊时间）
‘NaT’ 将在存在模糊时间时返回 NaT
‘raise’ 将在存在模糊时间时引发 AmbiguousTimeError。

nonexistent‘shift_forward’、‘shift_backward’、‘NaT’、timedelta，默认为 ‘raise’

不存在的时间在由于夏令时而向前移动时不存在于特定时区。

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

Returns:

DatetimeIndex、TimedeltaIndex 或 Series

适用于 DatetimeIndex 或 TimedeltaIndex 的相同类型的索引，或者适用于 Series 的具有相同索引的 Series。

Raises:

如果无法转换 freq，则引发 ValueError。

Notes

如果时间戳具有时区，则取整将相对于本地 (“wall”) 时间进行，并重新定位到相同的时区。在接近夏令时的取整时，请使用 nonexistent 和 ambiguous 控制重新定位行为。

Examples

DatetimeIndex

>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
 '2018-01-01 12:01:00'],
 dtype='datetime64[ns]', freq='min')
>>> rng.ceil('h')
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
 '2018-01-01 13:00:00'],
 dtype='datetime64[ns]', freq=None)

Series

>>> pd.Series(rng).dt.ceil("h")
0   2018-01-01 12:00:00
1   2018-01-01 12:00:00
2   2018-01-01 13:00:00
dtype: datetime64[ns]

在接近夏令时转换时，使用 ambiguous 或 nonexistent 控制时间戳应如何重新定位。

>>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.ceil("h", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.ceil("h", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

`pandas.DatetimeIndex.month_name`

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

DatetimeIndex.month_name(*args, **kwargs)

返回指定语言环境的月份名称。

参数：

localestr，可选

确定返回月份名称的语言环境。默认为英语环境（'en_US.utf8'）。在 Unix 系统上使用命令 locale -a 可以找到您的语言环境代码。

Series 或 Index

月份名称的 Series 或 Index。

示例

>>> s = pd.Series(pd.date_range(start='2018-01', freq='ME', periods=3))
>>> s
0   2018-01-31
1   2018-02-28
2   2018-03-31
dtype: datetime64[ns]
>>> s.dt.month_name()
0     January
1    February
2       March
dtype: object

>>> idx = pd.date_range(start='2018-01', freq='ME', periods=3)
>>> idx
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'],
 dtype='datetime64[ns]', freq='ME')
>>> idx.month_name()
Index(['January', 'February', 'March'], dtype='object')

使用 locale 参数可以设置不同的语言环境，例如：idx.month_name(locale='pt_BR.utf8') 将返回巴西葡萄牙语的月份名称。

>>> idx = pd.date_range(start='2018-01', freq='ME', periods=3)
>>> idx
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31'],
 dtype='datetime64[ns]', freq='ME')
>>> idx.month_name(locale='pt_BR.utf8')  
Index(['Janeiro', 'Fevereiro', 'Março'], dtype='object')

`pandas.DatetimeIndex.day_name`

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

DatetimeIndex.day_name(*args, **kwargs)

返回指定区域语言的星期几名称。

参数：

localestr，可选

区域确定返回星期几名称的语言。默认为英语区域（'en_US.utf8'）。在 Unix 系统上的终端上使用命令locale -a来查找您的区域语言代码。

Series 或 Index

星期几名称的 Series 或 Index。

示例

>>> s = pd.Series(pd.date_range(start='2018-01-01', freq='D', periods=3))
>>> s
0   2018-01-01
1   2018-01-02
2   2018-01-03
dtype: datetime64[ns]
>>> s.dt.day_name()
0       Monday
1      Tuesday
2    Wednesday
dtype: object

>>> idx = pd.date_range(start='2018-01-01', freq='D', periods=3)
>>> idx
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'],
 dtype='datetime64[ns]', freq='D')
>>> idx.day_name()
Index(['Monday', 'Tuesday', 'Wednesday'], dtype='object')

使用locale参数可以设置不同的区域语言，例如：idx.day_name(locale='pt_BR.utf8')将返回巴西葡萄牙语的星期几名称。

>>> idx = pd.date_range(start='2018-01-01', freq='D', periods=3)
>>> idx
DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03'],
 dtype='datetime64[ns]', freq='D')
>>> idx.day_name(locale='pt_BR.utf8') 
Index(['Segunda', 'Terça', 'Quarta'], dtype='object')

`pandas.DatetimeIndex.as_unit`

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

DatetimeIndex.as_unit(*args, **kwargs)

转换为给定单位分辨率的数据类型。

参数：

unit

与自身相同类型

示例

对于 pandas.DatetimeIndex：

>>> idx = pd.DatetimeIndex(['2020-01-02 01:02:03.004005006'])
>>> idx
DatetimeIndex(['2020-01-02 01:02:03.004005006'],
 dtype='datetime64[ns]', freq=None)
>>> idx.as_unit('s')
DatetimeIndex(['2020-01-02 01:02:03'], dtype='datetime64[s]', freq=None)

对于 pandas.TimedeltaIndex：

>>> tdelta_idx = pd.to_timedelta(['1 day 3 min 2 us 42 ns'])
>>> tdelta_idx
TimedeltaIndex(['1 days 00:03:00.000002042'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.as_unit('s')
TimedeltaIndex(['1 days 00:03:00'], dtype='timedelta64[s]', freq=None)

`pandas.DatetimeIndex.to_period`

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

DatetimeIndex.to_period(*args, **kwargs)

在特定频率下转换为 PeriodArray/PeriodIndex。

将 DatetimeArray/Index 转换为 PeriodArray/PeriodIndex。

参数：

freqstr 或 Period，可选

pandas 的 period 别名之一或 Period 对象。默认情况下将被推断。

PeriodArray/PeriodIndex

引发：

ValueError

当转换具有非规则值的 DatetimeArray/Index 时，无法推断频率。

另请参见

PeriodIndex

不可变的 ndarray，保存序数值。

DatetimeIndex.to_pydatetime

返回对象 DatetimeIndex。

示例

>>> df = pd.DataFrame({"y": [1, 2, 3]},
...                   index=pd.to_datetime(["2000-03-31 00:00:00",
...                                         "2000-05-31 00:00:00",
...                                         "2000-08-31 00:00:00"]))
>>> df.index.to_period("M")
PeriodIndex(['2000-03', '2000-05', '2000-08'],
 dtype='period[M]')

推断每日频率

>>> idx = pd.date_range("2017-01-01", periods=2)
>>> idx.to_period()
PeriodIndex(['2017-01-01', '2017-01-02'],
 dtype='period[D]')

`pandas.DatetimeIndex.to_pydatetime`

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

DatetimeIndex.to_pydatetime(*args, **kwargs)

返回一个由datetime.datetime对象组成的 ndarray。

numpy.ndarray

示例

>>> idx = pd.date_range('2018-02-27', periods=3)
>>> idx.to_pydatetime()
array([datetime.datetime(2018, 2, 27, 0, 0),
 datetime.datetime(2018, 2, 28, 0, 0),
 datetime.datetime(2018, 3, 1, 0, 0)], dtype=object)

`pandas.DatetimeIndex.to_series`

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

DatetimeIndex.to_series(index=None, name=None)

创建一个索引和值都等于索引键的 Series。

与 map 一起使用，基于索引返回一个索引器很有用。

参数：

index索引，可选

结果 Series 的索引。如果为 None，则默认为原始索引。

name字符串，可选

结果 Series 的名称。如果为 None，则默认为原始索引的名称。

Series

数据类型将基于索引值的类型。

另请参阅

Index.to_frame

将索引转换为 DataFrame。

Series.to_frame

将 Series 转换为 DataFrame。

示例

>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')

默认情况下，重用原始索引和原始名称。

>>> idx.to_series()
animal
Ant      Ant
Bear    Bear
Cow      Cow
Name: animal, dtype: object

要强制使用新索引，请指定index的新标签：

>>> idx.to_series(index=[0, 1, 2])
0     Ant
1    Bear
2     Cow
Name: animal, dtype: object

要覆盖结果列的名称，请指定name：

>>> idx.to_series(name='zoo')
animal
Ant      Ant
Bear    Bear
Cow      Cow
Name: zoo, dtype: object

`pandas.DatetimeIndex.to_frame`

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

DatetimeIndex.to_frame(index=True, name=_NoDefault.no_default)

创建一个包含索引的列的 DataFrame。

参数：

index 布尔值，默认为 True

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

name 对象，默认为 index.name

传递的名称应该替代索引名称（如果有的话）。

DataFrame

包含原始索引数据的 DataFrame。

另请参阅

Index.to_series

将索引转换为 Series。

Series.to_frame

将 Series 转换为 DataFrame。

示例

>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')
>>> idx.to_frame()
 animal
animal
Ant       Ant
Bear     Bear
Cow       Cow

默认情况下，将重用原始索引。要强制使用新索引：

>>> idx.to_frame(index=False)
 animal
0   Ant
1  Bear
2   Cow

要覆盖结果列的名称，请指定名称：

>>> idx.to_frame(index=False, name='zoo')
 zoo
0   Ant
1  Bear
2   Cow

`pandas.DatetimeIndex.mean`

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

DatetimeIndex.mean(*, skipna=True, axis=0)

返回数组的平均值。

参数：

skipnabool，默认为 True

是否忽略任何 NaT 元素。

axisint，可选，默认 0

标量

时间戳或时间间隔。

另请参阅

numpy.ndarray.mean

返回沿给定轴的数组元素的平均值。

Series.mean

在一个 Series 中返回平均值。

注

mean 仅适用于 Datetime 和 Timedelta 数据类型，而不适用于 Period。

示例

对于pandas.DatetimeIndex：

>>> idx = pd.date_range('2001-01-01 00:00', periods=3)
>>> idx
DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'],
 dtype='datetime64[ns]', freq='D')
>>> idx.mean()
Timestamp('2001-01-02 00:00:00')

对于pandas.TimedeltaIndex：

>>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='D')
>>> tdelta_idx
TimedeltaIndex(['1 days', '2 days', '3 days'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.mean()
Timedelta('2 days 00:00:00')

`pandas.DatetimeIndex.std`

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

DatetimeIndex.std(*args, **kwargs)

返回请求轴上的样本标准差。

默认情况下通过 N-1 进行归一化。可以使用 ddof 进行更改。

参数：

axisint，可选

函数要应用的轴。对于 pandas.Series，此参数未使用，默认为 None。

ddofint，默认为 1

自由度。计算中使用的除数为 N - ddof，其中 N 表示元素数量。

skipnabool，默认为 True

排除 NA/null 值。如果整行/整列为 NA，结果将为 NA。

时间差

另请参见

numpy.ndarray.std

返回沿指定轴的数组元素的标准差。

Series.std

返回请求轴上的样本标准差。

示例

对于 pandas.DatetimeIndex：

>>> idx = pd.date_range('2001-01-01 00:00', periods=3)
>>> idx
DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'],
 dtype='datetime64[ns]', freq='D')
>>> idx.std()
Timedelta('1 days 00:00:00')

`pandas.TimedeltaIndex`

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

class pandas.TimedeltaIndex(data=None, unit=_NoDefault.no_default, freq=_NoDefault.no_default, closed=_NoDefault.no_default, dtype=None, copy=False, name=None)

不可变的 timedelta64 数据索引。

在内部表示为 int64，并且标量返回 Timedelta 对象。

参数：

data类似数组（1 维），可选

可选的类似时间差的数据用于构建索引。

unit，可选

data的单位。

自版本 2.2.0 起弃用：请改用pd.to_timedelta。

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

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

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

有效的numpy数据类型为timedelta64[ns]、timedelta64[us]、timedelta64[ms]和timedelta64[s]。

copy布尔值

复制输入数组。

name对象

要存储在索引中的名称。

另请参见

Index

基本的 pandas 索引类型。

Timedelta

表示两个日期或时间之间的持续时间。

DatetimeIndex

datetime64 数据的索引。

PeriodIndex

Period 数据的索引。

timedelta_range

创建一个固定频率的 TimedeltaIndex。

注意

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

示例

>>> pd.TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'])
TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
 dtype='timedelta64[ns]', freq=None)

我们也可以在可能的情况下让 pandas 推断频率。

>>> pd.TimedeltaIndex(np.arange(5) * 24 * 3600 * 1e9, freq='infer')
TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
 dtype='timedelta64[ns]', freq='D')

属性

`days`	每个元素的天数。
`seconds`	每个元素的秒数（大于等于 0 且小于 1 天）。
`microseconds`	每个元素的微秒数（大于等于 0 且小于 1 秒）。
`nanoseconds`	每个元素的纳秒数（大于等于 0 且小于 1 微秒）。
`components`	返回 Timedeltas 的各个分辨率组件的 DataFrame。
`inferred_freq`	尝试返回由 infer_freq 生成的表示频率的字符串。

方法

`to_pytimedelta`(args, *kwargs)	返回一个由 datetime.timedelta 对象组成的 ndarray。
`to_series`([index, name])	创建一个索引和值都等于索引键的 Series。
`round`(args, *kwargs)	对数据执行 round 操作到指定的频率。
`floor`(args, *kwargs)	对数据执行 floor 操作到指定的频率。
`ceil`(args, *kwargs)	对数据执行 ceil 操作到指定的频率。
`to_frame`([index, name])	创建一个包含索引的列的 DataFrame。
`mean`(*[, skipna, axis])	返回数组的平均值。

`pandas.TimedeltaIndex.days`

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

property TimedeltaIndex.days

每个元素的天数。

示例

对于 Series：

>>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='d'))
>>> ser
0   1 days
1   2 days
2   3 days
dtype: timedelta64[ns]
>>> ser.dt.days
0    1
1    2
2    3
dtype: int64

对于 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.days
Index([0, 10, 20], dtype='int64')

`pandas.TimedeltaIndex.seconds`

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

property TimedeltaIndex.seconds

每个元素的秒数（大于等于 0 且小于 1 天）。

示例

对于系列：

>>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='s'))
>>> ser
0   0 days 00:00:01
1   0 days 00:00:02
2   0 days 00:00:03
dtype: timedelta64[ns]
>>> ser.dt.seconds
0    1
1    2
2    3
dtype: int32

对于时间差索引：

>>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='s')
>>> tdelta_idx
TimedeltaIndex(['0 days 00:00:01', '0 days 00:00:02', '0 days 00:00:03'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.seconds
Index([1, 2, 3], dtype='int32')

`pandas.TimedeltaIndex.microseconds`

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

property TimedeltaIndex.microseconds

每个元素的微秒数（>= 0 且小于 1 秒）。

示例

对于 Series：

>>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='us'))
>>> ser
0   0 days 00:00:00.000001
1   0 days 00:00:00.000002
2   0 days 00:00:00.000003
dtype: timedelta64[ns]
>>> ser.dt.microseconds
0    1
1    2
2    3
dtype: int32

对于 TimedeltaIndex：

>>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='us')
>>> tdelta_idx
TimedeltaIndex(['0 days 00:00:00.000001', '0 days 00:00:00.000002',
 '0 days 00:00:00.000003'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.microseconds
Index([1, 2, 3], dtype='int32')

`pandas.TimedeltaIndex.nanoseconds`

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

property TimedeltaIndex.nanoseconds

每个元素的纳秒数（大于等于 0 且小于 1 微秒）。

举例

对于系列：

>>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='ns'))
>>> ser
0   0 days 00:00:00.000000001
1   0 days 00:00:00.000000002
2   0 days 00:00:00.000000003
dtype: timedelta64[ns]
>>> ser.dt.nanoseconds
0    1
1    2
2    3
dtype: int32

对于时间增量索引：

>>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='ns')
>>> tdelta_idx
TimedeltaIndex(['0 days 00:00:00.000000001', '0 days 00:00:00.000000002',
 '0 days 00:00:00.000000003'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.nanoseconds
Index([1, 2, 3], dtype='int32')

`pandas.TimedeltaIndex.components`

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

property TimedeltaIndex.components

返回一个由时间增量的各个分辨率组件组成的 DataFrame。

这些组件（天、小时、分钟、秒、毫秒、微秒、纳秒）以 DataFrame 的列形式返回。

返回值：

DataFrame

示例

>>> tdelta_idx = pd.to_timedelta(['1 day 3 min 2 us 42 ns'])
>>> tdelta_idx
TimedeltaIndex(['1 days 00:03:00.000002042'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.components
 days  hours  minutes  seconds  milliseconds  microseconds  nanoseconds
0     1      0        3        0             0             2           42

`pandas.TimedeltaIndex.inferred_freq`

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

TimedeltaIndex.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.TimedeltaIndex.as_unit`

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

TimedeltaIndex.as_unit(unit)

将时间间隔转换为具有给定单位分辨率的 dtype。

参数：

unit

返回值：

与 self 相同的类型

示例

对于pandas.DatetimeIndex：

>>> idx = pd.DatetimeIndex(['2020-01-02 01:02:03.004005006'])
>>> idx
DatetimeIndex(['2020-01-02 01:02:03.004005006'],
 dtype='datetime64[ns]', freq=None)
>>> idx.as_unit('s')
DatetimeIndex(['2020-01-02 01:02:03'], dtype='datetime64[s]', freq=None)

对于pandas.TimedeltaIndex：

>>> tdelta_idx = pd.to_timedelta(['1 day 3 min 2 us 42 ns'])
>>> tdelta_idx
TimedeltaIndex(['1 days 00:03:00.000002042'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.as_unit('s')
TimedeltaIndex(['1 days 00:03:00'], dtype='timedelta64[s]', freq=None)

`pandas.TimedeltaIndex.to_pytimedelta`

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

TimedeltaIndex.to_pytimedelta(*args, **kwargs)

返回一个 datetime.timedelta 对象的 ndarray。

numpy.ndarray

例子

>>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='D')
>>> tdelta_idx
TimedeltaIndex(['1 days', '2 days', '3 days'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.to_pytimedelta()
array([datetime.timedelta(days=1), datetime.timedelta(days=2),
 datetime.timedelta(days=3)], dtype=object)

`pandas.TimedeltaIndex.to_series`

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

TimedeltaIndex.to_series(index=None, name=None)

创建一个索引和值都等于索引键的 Series。

与 map 结合使用，基于索引返回索引器。

参数：

indexIndex，可选

结果 Series 的索引。如果为 None，则默认为原始索引。

namestr，可选

结果 Series 的名称。如果为 None，则默认为原始索引的名称。

返回值：

Series

dtype 将基于索引值的类型确定。

另请参见

Index.to_frame

将索引转换为 DataFrame。

Series.to_frame

将 Series 转换为 DataFrame。

示例

>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')

默认情况下，重用原始索引和原始名称。

>>> idx.to_series()
animal
Ant      Ant
Bear    Bear
Cow      Cow
Name: animal, dtype: object

要强制使用新索引，请指定新标签给 index：

>>> idx.to_series(index=[0, 1, 2])
0     Ant
1    Bear
2     Cow
Name: animal, dtype: object

要覆盖结果列的名称，请指定 name：

>>> idx.to_series(name='zoo')
animal
Ant      Ant
Bear    Bear
Cow      Cow
Name: zoo, dtype: object

`pandas.TimedeltaIndex.round`

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

TimedeltaIndex.round(*args, **kwargs)

对数据执行指定频率的四舍五入操作。

参数：

freqstr 或偏移

将索引四舍五入到的频率级别。必须是固定的频率，如‘S’（秒），而不是‘ME’（月末）。参见频率别名以获取可能的频率值列表。

模糊‘推断’，布尔 ndarray，‘NaT’，默认为‘raise’

仅适用于 DatetimeIndex：

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

不存在‘shift_forward’，‘shift_backward’，‘NaT’，timedelta，默认为‘raise’

不存在的时间在由于夏令时向前移动时钟的特定时区不存在。

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

DatetimeIndex，TimedeltaIndex 或 Series

适用于 DatetimeIndex 或 TimedeltaIndex 的相同类型的索引，或者适用于 Series 的具有相同索引的 Series。

异常：

如果无法转换频率，则引发 ValueError。

注意事项

如果时间戳有时区，则舍入将相对于当地（“墙上”）时间进行，然后重新定位到相同的时区。在夏令时附近进行舍入时，使用不存在和模糊来控制重新本地化行为。

示例

DatetimeIndex

>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
 '2018-01-01 12:01:00'],
 dtype='datetime64[ns]', freq='min')
>>> rng.round('h')
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
 '2018-01-01 12:00:00'],
 dtype='datetime64[ns]', freq=None)

系列

>>> pd.Series(rng).dt.round("h")
0   2018-01-01 12:00:00
1   2018-01-01 12:00:00
2   2018-01-01 12:00:00
dtype: datetime64[ns]

在夏令时转换附近进行舍入时，使用模糊或不存在来控制时间戳应如何重新本地化。

>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.floor("2h", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.floor("2h", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

`pandas.TimedeltaIndex.floor`

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

TimedeltaIndex.floor(*args, **kwargs)

对数据执行到指定频率的 floor 操作。

Parameters:

freq str 或 Offset

要将索引向下取整到的频率级别。必须是固定的频率，如 ‘S’（秒），而不是 ‘ME’（月末）。有关可能的 freq 值列表，请参见频率别名。

ambiguous ‘infer’，bool-ndarray，‘NaT’，默认为‘raise’

仅对 DatetimeIndex 有效：

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

nonexistent ‘shift_forward’，‘shift_backward’，‘NaT’，timedelta，默认为‘raise’

在某个时区中不存在的时间不存在，因为时钟由于夏令时向前移动。

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

Returns:

DatetimeIndex、TimedeltaIndex 或 Series

对于 DatetimeIndex 或 TimedeltaIndex，类型相同的索引，或者对于 Series，索引相同的 Series。

Raises:

如果 freq 无法转换，则引发 ValueError。

Notes

如果时间戳具有时区，则将进行相对于本地（“墙”）时间的 floor 操作，并重新本地化到相同的时区。在夏令时附近进行 floor 时，请使用 nonexistent 和 ambiguous 来控制重新本地化行为。

Examples

DatetimeIndex

>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
 '2018-01-01 12:01:00'],
 dtype='datetime64[ns]', freq='min')
>>> rng.floor('h')
DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00',
 '2018-01-01 12:00:00'],
 dtype='datetime64[ns]', freq=None)

Series

>>> pd.Series(rng).dt.floor("h")
0   2018-01-01 11:00:00
1   2018-01-01 12:00:00
2   2018-01-01 12:00:00
dtype: datetime64[ns]

当在夏令时转换附近取整时，请使用 ambiguous 或 nonexistent 来控制时间戳应如何重新本地化。

>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.floor("2h", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.floor("2h", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

`pandas.TimedeltaIndex.ceil`

pandas.pydata.org/docs/reference/api/pandas.TimedeltaIndex.ceil.html

TimedeltaIndex.ceil(*args, **kwargs)

对数据执行指定频率的 ceil 操作。

参数：

freqstr 或 Offset

用于对索引进行 ceiling 的频率级别。必须是固定频率，如 ‘S’（秒），而不是 ‘ME’（月底）。有关可能的 freq 值列表，请参见频率别名。

模糊‘infer’、布尔型 ndarray、‘NaT’，默认为 ‘raise’

仅适用于 DatetimeIndex 的相关内容：

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

不存在‘shift_forward’、‘shift_backward’、‘NaT’、timedelta，默认为 ‘raise’

不存在的时间在某个时区不存在，该时区由于夏令时而向前移动。

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

DatetimeIndex、TimedeltaIndex 或 Series

DatetimeIndex 或 TimedeltaIndex 的相同类型索引，或者 Series 的相同索引。

引发：

如果频率无法转换，则引发 ValueError。

注意事项

如果时间戳有时区，则相对于本地（“墙”）时间进行 ceiling，并重新本地化到相同的时区。当接近夏令时时，请使用 nonexistent 和 ambiguous 控制重新本地化行为。

例子

DatetimeIndex

>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
 '2018-01-01 12:01:00'],
 dtype='datetime64[ns]', freq='min')
>>> rng.ceil('h')
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
 '2018-01-01 13:00:00'],
 dtype='datetime64[ns]', freq=None)

Series

>>> pd.Series(rng).dt.ceil("h")
0   2018-01-01 12:00:00
1   2018-01-01 12:00:00
2   2018-01-01 13:00:00
dtype: datetime64[ns]

当时间接近夏令时转换时，请使用 ambiguous 或 nonexistent 来控制时间戳的重新本地化方式。

>>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.ceil("h", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.ceil("h", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

`pandas.TimedeltaIndex.to_frame`

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

TimedeltaIndex.to_frame(index=True, name=_NoDefault.no_default)

创建一个包含索引的列的 DataFrame。

参数：

index布尔值，默认为 True

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

name对象，默认为 index.name

传递的名称应该替代索引名称（如果有的话）。

DataFrame

包含原始索引数据的 DataFrame。

另请参见

Index.to_series

将索引转换为 Series。

Series.to_frame

将 Series 转换为 DataFrame。

示例

>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')
>>> idx.to_frame()
 animal
animal
Ant       Ant
Bear     Bear
Cow       Cow

默认情况下，将重用原始索引。要强制使用新索引：

>>> idx.to_frame(index=False)
 animal
0   Ant
1  Bear
2   Cow

要覆盖结果列的名称，请指定 name：

>>> idx.to_frame(index=False, name='zoo')
 zoo
0   Ant
1  Bear
2   Cow

`pandas.TimedeltaIndex.mean`

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

TimedeltaIndex.mean(*, skipna=True, axis=0)

返回数组的平均值。

参数：

skipna 布尔值，默认为 True

是否忽略任何 NaT 元素。

axis 整数，可选，默认为 0

标量

时间戳或时间增量。

另请参阅

numpy.ndarray.mean

返回沿给定轴的数组元素的平均值。

Series.mean

返回 Series 中的均值。

注意事项

mean 仅适用于 Datetime 和 Timedelta dtypes，不适用于 Period。

示例

对于 pandas.DatetimeIndex：

>>> idx = pd.date_range('2001-01-01 00:00', periods=3)
>>> idx
DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'],
 dtype='datetime64[ns]', freq='D')
>>> idx.mean()
Timestamp('2001-01-02 00:00:00')

对于 pandas.TimedeltaIndex：

>>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='D')
>>> tdelta_idx
TimedeltaIndex(['1 days', '2 days', '3 days'],
 dtype='timedelta64[ns]', freq=None)
>>> tdelta_idx.mean()
Timedelta('2 days 00:00:00')

`pandas.PeriodIndex`

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

class pandas.PeriodIndex(data=None, ordinal=None, freq=None, dtype=None, copy=False, name=None, **fields)

不可变的 ndarray，其中包含表示时间中的常规周期的序数值。

索引键被封装到携带元数据的 Period 对象中（例如，频率信息）。

参数：

data：类数组（1 维 int np.ndarray 或 PeriodArray），可选

用于构建索引的可选的类似周期的数据。

copy：bool

复制输入 ndarray。

freq：str 或周期对象，可选

pandas 周期字符串或相应对象之一。

year：int、数组或序列，默认为 None