Pandas 2.2 中文文档（二十五）

原文：pandas.pydata.org/docs/

pandas 数组

pandas.pydata.org/docs/reference/api/pandas.array.html

pandas.array(data, dtype=None, copy=True)

创建一个数组。

参数：

data对象序列

数据中的标量应该是数据类型的实例。预期数据表示一维数据数组。

当数据是索引或 Series 时，将从数据中提取基础数组。

dtypestr、np.dtype 或者 ExtensionDtype，可选

数组的数据类型。可以是 NumPy 的数据类型或者使用 pandas.api.extensions.register_extension_dtype() 注册到 pandas 中的扩展类型。

如果未指定，则有两种可能性：

当数据是一个 Series、Index 或者 ExtensionArray 时，数据类型将从数据中获取。
否则，pandas 将尝试从数据中推断数据类型。

注意，当数据是 NumPy 数组时，data.dtype 不会用于推断数组类型。这是因为 NumPy 无法表示扩展数组中可以保存的所有数据类型。

目前，pandas 会为对象序列推断一个扩展数据类型。

标量类型	数组类型
`pandas.Interval`	`pandas.arrays.IntervalArray`
`pandas.Period`	`pandas.arrays.PeriodArray`
`datetime.datetime`	`pandas.arrays.DatetimeArray`
`datetime.timedelta`	`pandas.arrays.TimedeltaArray`
`int`	`pandas.arrays.IntegerArray`
`float`	`pandas.arrays.FloatingArray`
`str`	`pandas.arrays.StringArray` 或 `pandas.arrays.ArrowStringArray`
`bool`	`pandas.arrays.BooleanArray`

当 dtype 没有明确给出时，标量类型为 str 时创建的 ExtensionArray 受 pd.options.mode.string_storage 的影响。

对于其他所有情况，将使用 NumPy 的通常推理规则。

copybool，默认为 True

是否复制数据，即使不必要。根据数据类型，即使 copy=False，创建新数组也可能需要复制数据。

ExtensionArray

新创建的数组。

引发：

ValueError

当数据不是 1 维时。

另请参见

numpy.array

构造一个 NumPy 数组。

Series

构造一个 Pandas Series。

Index

构造一个 pandas Index。

arrays.NumpyExtensionArray

包装 NumPy 数组的 ExtensionArray。

Series.array

从 Series 中提取存储的数组。

注意事项

省略 dtype 参数意味着 Pandas 将尝试从数据中推断出最佳数组类型。随着 Pandas 和第三方库添加新的数组类型，"最佳" 数组类型可能会更改。我们建议指定 dtype 以确保

返回数据的正确数组类型
返回的数组类型不会随着 pandas 和第三方库添加新的扩展类型而改变

另外，如果返回数组的底层内存表示很重要，则建议将 dtype 指定为具体对象，而不是字符串别名或允许推断。例如，Pandas 的未来版本或第三方库可能会包含专用于字符串数据的 ExtensionArray。在这种情况下，以下内容将不再返回由 NumPy 数组支持的 arrays.NumpyExtensionArray。

>>> pd.array(['a', 'b'], dtype=str)
<NumpyExtensionArray>
['a', 'b']
Length: 2, dtype: str32

相反，将返回专用于字符串数据的新 ExtensionArray。如果您真的需要新数组由 NumPy 数组支持，请在 dtype 中指定。

>>> pd.array(['a', 'b'], dtype=np.dtype("<U1"))
<NumpyExtensionArray>
['a', 'b']
Length: 2, dtype: str32

最后，Pandas 的数组与 NumPy 大部分重叠。

arrays.DatetimeArray

arrays.TimedeltaArray

当传递了datetime64[ns]或timedelta64[ns]数据类型的数据时，pandas 将始终返回DatetimeArray或TimedeltaArray而不是NumpyExtensionArray。这是为了与有时区意识的数据情况保持对称，NumPy 本身不支持这种情况。

>>> pd.array(['2015', '2016'], dtype='datetime64[ns]')
<DatetimeArray>
['2015-01-01 00:00:00', '2016-01-01 00:00:00']
Length: 2, dtype: datetime64[ns]

>>> pd.array(["1h", "2h"], dtype='timedelta64[ns]')
<TimedeltaArray>
['0 days 01:00:00', '0 days 02:00:00']
Length: 2, dtype: timedelta64[ns]

示例

如果未指定 dtype，pandas 将从值中推断出最佳 dtype。查看 pandas 为其推断的类型的 dtype 的描述。

>>> pd.array([1, 2])
<IntegerArray>
[1, 2]
Length: 2, dtype: Int64

>>> pd.array([1, 2, np.nan])
<IntegerArray>
[1, 2, <NA>]
Length: 3, dtype: Int64

>>> pd.array([1.1, 2.2])
<FloatingArray>
[1.1, 2.2]
Length: 2, dtype: Float64

>>> pd.array(["a", None, "c"])
<StringArray>
['a', <NA>, 'c']
Length: 3, dtype: string

>>> with pd.option_context("string_storage", "pyarrow"):
...     arr = pd.array(["a", None, "c"])
...
>>> arr
<ArrowStringArray>
['a', <NA>, 'c']
Length: 3, dtype: string

>>> pd.array([pd.Period('2000', freq="D"), pd.Period("2000", freq="D")])
<PeriodArray>
['2000-01-01', '2000-01-01']
Length: 2, dtype: period[D]

您可以使用 dtype 的字符串别名。

>>> pd.array(['a', 'b', 'a'], dtype='category')
['a', 'b', 'a']
Categories (2, object): ['a', 'b']

或者指定实际的数据类型。

>>> pd.array(['a', 'b', 'a'],
...          dtype=pd.CategoricalDtype(['a', 'b', 'c'], ordered=True))
['a', 'b', 'a']
Categories (3, object): ['a' < 'b' < 'c']

如果 pandas 没有推断出专用的扩展类型，将返回arrays.NumpyExtensionArray。

>>> pd.array([1 + 1j, 3 + 2j])
<NumpyExtensionArray>
[(1+1j), (3+2j)]
Length: 2, dtype: complex128

如“注意”部分所述，未来可能会添加新的扩展类型（由 pandas 或第三方库添加），这将导致返回值不再是arrays.NumpyExtensionArray。如果您需要确保未来行为没有更改，请将 dtype 指定为 NumPy dtype。

>>> pd.array([1, 2], dtype=np.dtype("int32"))
<NumpyExtensionArray>
[1, 2]
Length: 2, dtype: int32

数据必须是 1 维的。当输入的维度错误时，将引发 ValueError。

>>> pd.array(1)
Traceback (most recent call last):
  ...
ValueError: Cannot pass scalar '1' to 'pandas.array'.

`pandas.arrays.ArrowExtensionArray`

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

class pandas.arrays.ArrowExtensionArray(values)

由 PyArrow ChunkedArray 支持的 Pandas ExtensionArray。

警告

ArrowExtensionArray 被视为实验性功能。实现和部分 API 可能会在没有警告的情况下更改。

参数：

valuespyarrow.Array 或 pyarrow.ChunkedArray

ArrowExtensionArray

注意事项

大多数方法都是使用pyarrow 计算函数实现的。如果基于安装的 PyArrow 版本，某些方法可能会引发异常或引发 PerformanceWarning。

请安装最新版本的 PyArrow 以启用最佳功能，并避免在之前的 PyArrow 版本中出现潜在的错误。

示例

使用pandas.array()创建一个 ArrowExtensionArray：

>>> pd.array([1, 1, None], dtype="int64[pyarrow]")
<ArrowExtensionArray>
[1, 1, <NA>]
Length: 3, dtype: int64[pyarrow]

属性

无

方法

无

`pandas.ArrowDtype`

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

class pandas.ArrowDtype(pyarrow_dtype)

用于 PyArrow 数据类型的 ExtensionDtype。

警告

ArrowDtype 被视为实验性质。实现和部分 API 可能会在没有警告的情况下更改。

虽然大多数dtype参数可以接受“string”构造函数，例如"int64[pyarrow]"，但如果数据类型包含像pyarrow.timestamp这样的参数，ArrowDtype 就很有用。

参数：

pyarrow_dtypepa.DataType

一个pyarrow.DataType的实例。

ArrowDtype

示例

>>> import pyarrow as pa
>>> pd.ArrowDtype(pa.int64())
int64[pyarrow]

必须使用 ArrowDtype 构造带有参数的类型。

>>> pd.ArrowDtype(pa.timestamp("s", tz="America/New_York"))
timestamp[s, tz=America/New_York][pyarrow]
>>> pd.ArrowDtype(pa.list_(pa.int64()))
list<item: int64>[pyarrow]

属性

pyarrow_dtype

方法

None

`pandas.Timestamp`

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

class pandas.Timestamp(ts_input=<object object>, year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, tzinfo=None, *, nanosecond=None, tz=None, unit=None, fold=None)

Python datetime.datetime 对象的 pandas 替代品。

Timestamp 是 pandas 中等价于 Python 的 Datetime 的类型，在大多数情况下可以互换使用。它是构成 DatetimeIndex 和 pandas 中其他面向时间序列的数据结构的条目所使用的类型。

参数：

ts_input类似于 datetime 的对象，字符串，整数，浮点数

要转换为 Timestamp 的值。

year, month, day整数

hour, minute, second, microsecond整数，可��，默认为 0

tzinfodatetime.tzinfo，可选，默认为 None

nanosecond整数，可选，默认为 0

tz字符串，pytz.timezone，dateutil.tz.tzfile 或 None

时间戳将具有的时区。

unit字符串

如果 ts_input 的类型为整数或浮点数，则用于转换的单位。有效值为‘D’、‘h’、‘m’、‘s’、‘ms’、‘us’和‘ns’。例如，‘s’表示秒，‘ms’表示毫秒。

对于浮点输入，结果将以纳秒为单位存储，并且单位属性将设置为'ns'。

fold{0, 1}, 默认为 None, 仅限关键字参数

由于夏令时的存在，当从夏季时间转换为冬季时间时，一个壁钟时间可能会发生两次；fold 描述了 datetime-like 对应于壁钟第一次（0）或第二次（1）命中模糊时间的情况。

注意

构造函数基本上有三种调用约定。主要形式接受四个参数。它们可以按位置或关键字传递。

另外两种形式模仿了datetime.datetime的参数。它们可以按位置或关键字传递，但不能混合使用。

示例

使用主要的调用约定：

这将转换一个类似于 datetime 的字符串

>>> pd.Timestamp('2017-01-01T12')
Timestamp('2017-01-01 12:00:00')

这将转换一个表示 Unix 时间戳的浮点数，单位为秒

>>> pd.Timestamp(1513393355.5, unit='s')
Timestamp('2017-12-16 03:02:35.500000')

这将转换一个表示 Unix 时间戳的整数，以秒为单位，并且为特定时区

>>> pd.Timestamp(1513393355, unit='s', tz='US/Pacific')
Timestamp('2017-12-15 19:02:35-0800', tz='US/Pacific')

使用另外两种模仿datetime.datetime API 的形式：

>>> pd.Timestamp(2017, 1, 1, 12)
Timestamp('2017-01-01 12:00:00')

>>> pd.Timestamp(year=2017, month=1, day=1, hour=12)
Timestamp('2017-01-01 12:00:00')

属性

`asm8`	返回以纳秒为单位的 numpy datetime64 格式。
`day`
`day_of_week`	返回一周中的星期几。
`day_of_year`	返回一年中的第几天。
`dayofweek`	返回一周中的星期几。
`dayofyear`	返回一年中的第几天。
`days_in_month`	返回该月的天数。
`daysinmonth`	返回月份的天数。
`fold`
`hour`
`is_leap_year`	如果年份为闰年则返回 True。
`is_month_end`	检查日期是否为月末。
`is_month_start`	检查日期是否为月初。
`is_quarter_end`	检查日期是否为季末。
`is_quarter_start`	检查日期是否为季初。
`is_year_end`	如果日期为年末则返回 True。
`is_year_start`	如果日期为年初则返回 True。
`max`
`microsecond`
`min`
`minute`
`month`
`nanosecond`
`quarter`	返回年份的季度。
`resolution`
`second`
`tz`	tzinfo 的别名。
`tzinfo`
`unit`	与 self._creso 相关的缩写。
`value`
`week`	返回年份的周数。
`weekofyear`	返回年份的周数。
`year`

方法

`as_unit`(unit[, round_ok])	将底层 int64 表示转换为给定单位。
`astimezone`(tz)	将时区感知的时间戳转换为另一个时区。
`ceil`(freq[, ambiguous, nonexistent])	返回向上舍入到此分辨率的新时间戳。
`combine`(date, time)	将日期、时间组合成具有相同日期和时间字段的日期时间。
`ctime`()	返回 ctime() 格式的字符串。
`date`()	返回具有相同年、月和日的日期对象。
`day_name`([locale])	返回具有指定区域设置的 Timestamp 的星期几名称。
`dst`()	返回夏令时（DST）调整。
`floor`(freq[, ambiguous, nonexistent])	返回向下舍入到此分辨率的新时间戳。
`fromisocalendar`	int, int, int -> 从 ISO 年份、周数和星期几构造日期。
`fromisoformat`	字符串 -> 从 datetime.isoformat() 输出中获取日期时间
`fromordinal`(ordinal[, tz])	从普通公历序数构造时间戳。
`fromtimestamp`(ts)	将时间戳[, tz] 从 POSIX 时间戳转换为 tz 的本地时间。
`isocalendar`()	返回一个包含 ISO 年份、周数和星期几的命名元组。
`isoformat`([sep, timespec])	返回根据 ISO 8601 格式化的时间。
`isoweekday`()	返回日期表示的星期几。
`month_name`([locale])	返回具有指定区域设置的时间戳的月份名称。
`normalize`()	将时间戳规范化为午夜，保留时区信息。
`now`([tz])	返回表示当前本地时间的新时间戳对象。
`replace`([year, month, day, hour, minute, ...])	实现 datetime.replace，处理纳秒。
`round`(freq[, ambiguous, nonexistent])	将时间戳舍入到指定的分辨率。
`strftime`(format)	返回时间戳的格式化字符串。
`strptime`(string, format)	该函数未实现。
`time`()	返回具有相同时间但 tzinfo=None 的时间对象。
`timestamp`()	返回 POSIX 时间戳作为浮点数。
`timetuple`()	返回与 time.localtime() 兼容的时间元组。
`timetz`()	返回具有相同时间和时区信息的时间对象。
`to_datetime64`()	返回具有相同精度的 numpy.datetime64 对象。
`to_julian_date`()	将 TimeStamp 转换为儒略日。
`to_numpy`([dtype, copy])	将时间戳转换为 NumPy datetime64。
`to_period`([freq])	返回此时间戳是观测��周期。
`to_pydatetime`([warn])	将时间戳对象转换为本机 Python datetime 对象。
`today`([tz])	返回本地时区中的当前时间。
`toordinal`()	返回普罗利普特格里高利纪元。
`tz_convert`(tz)	将时区感知的 Timestamp 转换为另一个时区。
`tz_localize`(tz[, ambiguous, nonexistent])	将时间戳本地化到特定时区。
`tzname`()	返回时区名称。
`utcfromtimestamp`(ts)	从 POSIX 时间戳构造一个时区感知的 UTC 日期时间。
`utcnow`()	返回一个表示 UTC 日期和时间的新 Timestamp。
`utcoffset`()	返回 UTC 偏移量。
`utctimetuple`()	返回 UTC 时间元组，与 time.localtime() 兼容。
`weekday`()	返回日期所代表的星期几。

`pandas.Timestamp.asm8`

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

Timestamp.asm8

返回纳秒级别的 numpy datetime64 格式。

示例

>>> ts = pd.Timestamp(2020, 3, 14, 15)
>>> ts.asm8
numpy.datetime64('2020-03-14T15:00:00.000000')

`pandas.Timestamp.day`

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

Timestamp.day

`pandas.Timestamp.dayofweek`

pandas.pydata.org/docs/reference/api/pandas.Timestamp.dayofweek.html

Timestamp.dayofweek

返回一周的哪一天。

返回值：

int

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_week
5

`pandas.Timestamp.day_of_week`

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

Timestamp.day_of_week

返回星期几。

返回值：

int

Examples

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_week
5

`pandas.Timestamp.dayofyear`

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

Timestamp.dayofyear

返回一年中的第几天。

int

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_year
74

`pandas.Timestamp.day_of_year`

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

Timestamp.day_of_year

返回一年中的日期。

int

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_year
74

`pandas.Timestamp.days_in_month`

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

Timestamp.days_in_month

返回该月的天数。

返回结果：

int

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.days_in_month
31

`pandas.Timestamp.daysinmonth`

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

Timestamp.daysinmonth

返回该月的天数。

int

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.days_in_month
31

`pandas.Timestamp.fold`

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

Timestamp.fold

`pandas.Timestamp.hour`

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

Timestamp.hour

`pandas.Timestamp.is_leap_year`

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

Timestamp.is_leap_year

如果年份是闰年，则返回 True。

bool

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_leap_year
True

`pandas.Timestamp.is_month_end`

pandas.pydata.org/docs/reference/api/pandas.Timestamp.is_month_end.html

Timestamp.is_month_end

检查日期是否为月末。

布尔值

如果日期是月末则返回 True。

另请参阅

Timestamp.is_month_start

表示是否为月初的类似属性。

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_month_end
False

>>> ts = pd.Timestamp(2020, 12, 31)
>>> ts.is_month_end
True

`pandas.Timestamp.is_month_start`

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

Timestamp.is_month_start

检查日期是否是月初。

布尔值

如果日期是月初，则返回 True。

另请参阅

Timestamp.is_month_end

类似的属性指示月末。

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_month_start
False

>>> ts = pd.Timestamp(2020, 1, 1)
>>> ts.is_month_start
True

`pandas.Timestamp.is_quarter_end`

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

Timestamp.is_quarter_end

检查日期是否是季度的最后一天。

布尔值

如果日期是季度的最后一天，则返回 True。

另请参阅

Timestamp.is_quarter_start

类似的属性，指示季度的开始。

Timestamp.quarter

返回日期所在的季度。

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_quarter_end
False

>>> ts = pd.Timestamp(2020, 3, 31)
>>> ts.is_quarter_end
True

`pandas.Timestamp.is_quarter_start`

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

Timestamp.is_quarter_start

检查日期是否为季度的第一天。

布尔值

如果日期是季度的第一天，则为 True。

另请参阅

Timestamp.is_quarter_end

具有相似特性，指示季度结束。

Timestamp.quarter

返回日期所在的季度。

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_quarter_start
False

>>> ts = pd.Timestamp(2020, 4, 1)
>>> ts.is_quarter_start
True

`pandas.Timestamp.is_year_end`

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

Timestamp.is_year_end

如果日期是一年的最后一天，则返回 True。

布尔值

另请参阅

Timestamp.is_year_start

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

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_year_end
False

>>> ts = pd.Timestamp(2020, 12, 31)
>>> ts.is_year_end
True

`pandas.Timestamp.is_year_start`

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

Timestamp.is_year_start

如果日期是一年的第一天，则返回 True。

布尔值

另请参阅

Timestamp.is_year_end

表示年末的类似属性。

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_year_start
False

>>> ts = pd.Timestamp(2020, 1, 1)
>>> ts.is_year_start
True

`pandas.Timestamp.max`

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

Timestamp.max = Timestamp('2262-04-11 23:47:16.854775807')

`pandas.Timestamp.microsecond`

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

Timestamp.microsecond

`pandas.Timestamp.min`

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

Timestamp.min = Timestamp('1677-09-21 00:12:43.145224193')

`pandas.Timestamp.minute`

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

Timestamp.minute

`pandas.Timestamp.month`

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

Timestamp.month

`pandas.Timestamp.nanosecond`

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

Timestamp.nanosecond

`pandas.Timestamp.quarter`

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

Timestamp.quarter

Return the quarter of the year.

Returns:

int

Examples

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.quarter
1

`pandas.Timestamp.resolution`

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

Timestamp.resolution = Timedelta('0 days 00:00:00.000000001')

`pandas.Timestamp.second`

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

Timestamp.second

`pandas.Timestamp.tz`

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

property Timestamp.tz

别名为 tzinfo。

示例

>>> ts = pd.Timestamp(1584226800, unit='s', tz='Europe/Stockholm')
>>> ts.tz
<DstTzInfo 'Europe/Stockholm' CET+1:00:00 STD>

`pandas.Timestamp.tzinfo`

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

Timestamp.tzinfo

`pandas.Timestamp.unit`

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

Timestamp.unit

与 self._creso 相关联的缩写。

示例

>>> pd.Timestamp("2020-01-01 12:34:56").unit
's'

>>> pd.Timestamp("2020-01-01 12:34:56.123").unit
'ms'

>>> pd.Timestamp("2020-01-01 12:34:56.123456").unit
'us'

>>> pd.Timestamp("2020-01-01 12:34:56.123456789").unit
'ns'

`pandas.Timestamp.value`

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

Timestamp.value

`pandas.Timestamp.week`

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

Timestamp.week

返回一年中的周数。

整数

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.week
11

`pandas.Timestamp.weekofyear`

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

Timestamp.weekofyear

返回一年中的周数。

整数

示例

>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.week
11

`pandas.Timestamp.year`

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

Timestamp.year

`pandas.Timestamp.as_unit`

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

Timestamp.as_unit(unit, round_ok=True)

将底层 int64 表示转换为给定的单位。

参数：

unit {"ns", "us", "ms", "s"}

round_ok 布尔型，默认为 True

如果为 False 并且转换需要四舍五入，则引发异常。

返回值：

时间戳

示例

>>> ts = pd.Timestamp('2023-01-01 00:00:00.01')
>>> ts
Timestamp('2023-01-01 00:00:00.010000')
>>> ts.unit
'ms'
>>> ts = ts.as_unit('s')
>>> ts
Timestamp('2023-01-01 00:00:00')
>>> ts.unit
's'

`pandas.Timestamp.astimezone`

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

Timestamp.astimezone(tz)

将时区感知的时间戳转换为另一个时区。

参数：

tzstr，pytz.timezone，dateutil.tz.tzfile 或无

时间戳将被转换为的时间的时区。 None 将移除持有 UTC 时间的时区。

转换后时间戳

引发：

类型错误

如果时间戳是时区无关的。

示例

使用 UTC 时区创建时间戳对象：

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651', tz='UTC')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651+0000', tz='UTC')

转换为东京时区：

>>> ts.tz_convert(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')

也可以使用astimezone：

>>> ts.astimezone(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')

pd.NaT的类似情况：

>>> pd.NaT.tz_convert(tz='Asia/Tokyo')
NaT

`pandas.Timestamp.ceil`

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

Timestamp.ceil(freq, ambiguous='raise', nonexistent='raise')

返回一个新的时间戳，使其分辨率为天花板。

参数：

freq 字符串

频率字符串表示天花板分辨率。

ambiguous 布尔值或 {‘raise’, ‘NaT’}，默认为 ‘raise’

行为如下：

布尔值包含用于确定时间是否为夏令时的标志（请注意，此标志仅适用于模糊的秋季夏令时日期）。
‘NaT’ 将在存在模糊时间时返回 NaT。
‘raise’ 将在存在模糊时间时引发 AmbiguousTimeError。

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

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

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

引发：

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

注意事项

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

示例

创建一个时间戳对象：

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')

时间戳可以使用多个频率单位进行天花板处理：

>>> ts.ceil(freq='h') # hour
Timestamp('2020-03-14 16:00:00')

>>> ts.ceil(freq='min') # minute
Timestamp('2020-03-14 15:33:00')

>>> ts.ceil(freq='s') # seconds
Timestamp('2020-03-14 15:32:53')

>>> ts.ceil(freq='us') # microseconds
Timestamp('2020-03-14 15:32:52.192549')

freq 也可以是单个单位的倍数，比如 ‘5min’（即 5 分钟）：

>>> ts.ceil(freq='5min')
Timestamp('2020-03-14 15:35:00')

或多个单位的组合，比如 ‘1h30min’（即 1 小时 30 分钟）：

>>> ts.ceil(freq='1h30min')
Timestamp('2020-03-14 16:30:00')

对于 pd.NaT 类似：

>>> pd.NaT.ceil()
NaT

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

>>> ts_tz = pd.Timestamp("2021-10-31 01:30:00").tz_localize("Europe/Amsterdam")

>>> ts_tz.ceil("h", ambiguous=False)
Timestamp('2021-10-31 02:00:00+0100', tz='Europe/Amsterdam')

>>> ts_tz.ceil("h", ambiguous=True)
Timestamp('2021-10-31 02:00:00+0200', tz='Europe/Amsterdam')

`pandas.Timestamp.combine`

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

classmethod Timestamp.combine(date, time)

将日期和时间组合成具有相同日期和时间字段的日期时间。

示例

>>> from datetime import date, time
>>> pd.Timestamp.combine(date(2020, 3, 14), time(15, 30, 15))
Timestamp('2020-03-14 15:30:15')

`pandas.Timestamp.ctime`

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

Timestamp.ctime()

返回 ctime() 格式的字符串。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00.00')
>>> ts
Timestamp('2023-01-01 10:00:00')
>>> ts.ctime()
'Sun Jan  1 10:00:00 2023'

`pandas.Timestamp.date`

pandas.pydata.org/docs/reference/api/pandas.Timestamp.date.html

Timestamp.date()

返回具有相同年、月和日的日期对象。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00.00')
>>> ts
Timestamp('2023-01-01 10:00:00')
>>> ts.date()
datetime.date(2023, 1, 1)

`pandas.Timestamp.day_name`

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

Timestamp.day_name(locale=None)

返回指定语言环境下的时间戳的星期几名称。

Parameters:

localestr, 默认为 None（英语语言环境）

用于确定返回星期几名称的语言环境。

Returns:

str

Examples

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.day_name()
'Saturday'

Analogous for pd.NaT:

>>> pd.NaT.day_name()
nan

`pandas.Timestamp.dst`

pandas.pydata.org/docs/reference/api/pandas.Timestamp.dst.html

Timestamp.dst()

返回夏令时（DST）调整。

示例

>>> ts = pd.Timestamp('2000-06-01 00:00:00', tz='Europe/Brussels')
>>> ts
Timestamp('2000-06-01 00:00:00+0200', tz='Europe/Brussels')
>>> ts.dst()
datetime.timedelta(seconds=3600)

`pandas.Timestamp.floor`

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

Timestamp.floor(freq, ambiguous='raise', nonexistent='raise')

返回一个新的时间戳，按照此分辨率进行地板操作。

参数：

freqstr

频率字符串表示地板分辨率。

ambiguousbool 或 {‘raise’, ‘NaT’}，默认为 ‘raise’

行为如下：

bool 包含用于确定时间是否为夏令时的标志（请注意，此标志仅适用于模糊的秋季夏令时日期）。
‘NaT’ 将返回一个模糊时间的 NaT。
‘raise’ 将在模糊时间时引发 AmbiguousTimeError。

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

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

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

引发：

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

注意

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

示例

创建一个时间戳对象：

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')

时间戳可以使用多个频率单位进行地板操作：

>>> ts.floor(freq='h') # hour
Timestamp('2020-03-14 15:00:00')

>>> ts.floor(freq='min') # minute
Timestamp('2020-03-14 15:32:00')

>>> ts.floor(freq='s') # seconds
Timestamp('2020-03-14 15:32:52')

>>> ts.floor(freq='ns') # nanoseconds
Timestamp('2020-03-14 15:32:52.192548651')

freq 也可以是单个单位的倍数，比如 ‘5min’（即 5 分钟）：

>>> ts.floor(freq='5min')
Timestamp('2020-03-14 15:30:00')

或多个单位的组合，比如 ‘1h30min’（即 1 小时 30 分钟）：

>>> ts.floor(freq='1h30min')
Timestamp('2020-03-14 15:00:00')

对于 pd.NaT 类似：

>>> pd.NaT.floor()
NaT

在接近夏令时转换时进行四舍五入时，使用 ambiguous 或 nonexistent 来控制时间戳应如何重新定位。

>>> ts_tz = pd.Timestamp("2021-10-31 03:30:00").tz_localize("Europe/Amsterdam")

>>> ts_tz.floor("2h", ambiguous=False)
Timestamp('2021-10-31 02:00:00+0100', tz='Europe/Amsterdam')

>>> ts_tz.floor("2h", ambiguous=True)
Timestamp('2021-10-31 02:00:00+0200', tz='Europe/Amsterdam')

`pandas.Timestamp.fromordinal`

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

classmethod Timestamp.fromordinal(ordinal, tz=None)

从先期格里高利日期构造时间戳。

参数：

ordinalint

对应于先期格里高利日期的日期。

tzstr、pytz.timezone、dateutil.tz.tzfile 或 None

时间戳的时区。

注释

根据定义，先期格里高利日期本身不可能有任何时区信息。

示例

>>> pd.Timestamp.fromordinal(737425)
Timestamp('2020-01-01 00:00:00')

`pandas.Timestamp.fromtimestamp`

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

classmethod Timestamp.fromtimestamp(ts)

将时间戳[, 时区]从 POSIX 时间戳转换为时区的本地时间。

示例

>>> pd.Timestamp.fromtimestamp(1584199972)  
Timestamp('2020-03-14 15:32:52')

请注意，输出可能会根据您的本地时间而变化。

`pandas.Timestamp.isocalendar`

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

Timestamp.isocalendar()

返回一个包含 ISO 年份、周数和星期几的命名元组。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00')
>>> ts
Timestamp('2023-01-01 10:00:00')
>>> ts.isocalendar()
datetime.IsoCalendarDate(year=2022, week=52, weekday=7)

`pandas.Timestamp.isoformat`

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

Timestamp.isoformat(sep='T', timespec='auto')

返回按照 ISO 8601 格式化的时间。

完整格式如下 ‘YYYY-MM-DD HH:MM:SS.mmmmmmnnn’。默认情况下，如果 self.microsecond == 0 和 self.nanosecond == 0，则省略小数部分。

如果 self.tzinfo 不为 None，则还会附加 UTC 偏移，得到完整格式为 ‘YYYY-MM-DD HH:MM:SS.mmmmmmnnn+HH:MM’。

参数：

sep 字符串，默认为 ‘T’

用作日期和时间之间分隔符的字符串。

timespec 字符串，默认为 ‘auto’

指定要包含的时间的附加项数。有效值为 'auto'、'hours'、'minutes'、'seconds'、'milliseconds'、'microseconds' 和 'nanoseconds'。

字符串

示例

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.isoformat()
'2020-03-14T15:32:52.192548651'
>>> ts.isoformat(timespec='microseconds')
'2020-03-14T15:32:52.192548'

`pandas.Timestamp.isoweekday`

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

Timestamp.isoweekday()

返回表示日期的星期几。

Monday == 1 … Sunday == 7.

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00')
>>> ts
Timestamp('2023-01-01 10:00:00')
>>> ts.isoweekday()
7

`pandas.Timestamp.month_name`

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

Timestamp.month_name(locale=None)

返回具有指定语言环境的时间戳的月份名称。

参数：

localestr，默认为 None（英语语言环境）

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

返回值：

str

示例

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.month_name()
'March'

pd.NaT的类比：

>>> pd.NaT.month_name()
nan

`pandas.Timestamp.normalize`

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

Timestamp.normalize()

将时间戳规范化为午夜时分，并保留时区信息。

示例

>>> ts = pd.Timestamp(2020, 3, 14, 15, 30)
>>> ts.normalize()
Timestamp('2020-03-14 00:00:00')

`pandas.Timestamp.now`

pandas.pydata.org/docs/reference/api/pandas.Timestamp.now.html

classmethod Timestamp.now(tz=None)

返回一个新的 Timestamp 对象，表示当前本地化到 tz 的时间。

参数：

tzstr 或时区对象，默认为 None

本地化的时区。

示例

>>> pd.Timestamp.now()  
Timestamp('2020-11-16 22:06:16.378782')

对于 pd.NaT 也是类似的：

>>> pd.NaT.now()
NaT

`pandas.Timestamp.replace`

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

Timestamp.replace(year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, nanosecond=None, tzinfo=<class 'object'>, fold=None)

实现 datetime.replace，处理纳秒。

参数：

yearint，可选

monthint，可选

dayint，可选

hourint，可选

minuteint，可选

secondint，可选

microsecondint，可选

nanosecondint，可选

tzinfotz-convertible，可选

foldint，可选

替换字段的时间戳

示例

创建时间戳对象：

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651', tz='UTC')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651+0000', tz='UTC')

替换年份和小时：

>>> ts.replace(year=1999, hour=10)
Timestamp('1999-03-14 10:32:52.192548651+0000', tz='UTC')

替换时区（不是转换）：

>>> import pytz
>>> ts.replace(tzinfo=pytz.timezone('US/Pacific'))
Timestamp('2020-03-14 15:32:52.192548651-0700', tz='US/Pacific')

对于pd.NaT类似：

>>> pd.NaT.replace(tzinfo=pytz.timezone('US/Pacific'))
NaT

`pandas.Timestamp.round`

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

Timestamp.round(freq, ambiguous='raise', nonexistent='raise')

将时间戳舍入到指定的分辨率。

参数：

freq字符串

指示舍入分辨率的频率字符串。

ambiguous布尔值或{‘raise’，‘NaT’}，默认为‘raise’

行为如下：

布尔值包含用于确定时间是否为夏令时的标志（请注意，此标志仅适用于模糊的秋季夏令时日期）。
‘NaT’会在时间模糊时返回 NaT。
‘raise’会在时间模糊时引发一个 AmbiguousTimeError。

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

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

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

一个新的时间戳舍入到给定频率的分辨率

引发：

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

注意事项

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

示例

创建时间戳对象：

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')

时间戳可以使用多个频率单位进行舍入：

>>> ts.round(freq='h') # hour
Timestamp('2020-03-14 16:00:00')

>>> ts.round(freq='min') # minute
Timestamp('2020-03-14 15:33:00')

>>> ts.round(freq='s') # seconds
Timestamp('2020-03-14 15:32:52')

>>> ts.round(freq='ms') # milliseconds
Timestamp('2020-03-14 15:32:52.193000')

freq也可以是单个单位的倍数，比如‘5min’（即 5 分钟）：

>>> ts.round(freq='5min')
Timestamp('2020-03-14 15:35:00')

或者多个单位的组合，比如‘1h30min’（即 1 小时 30 分钟）：

>>> ts.round(freq='1h30min')
Timestamp('2020-03-14 15:00:00')

对于pd.NaT也是类似的：

>>> pd.NaT.round()
NaT

在夏令时转换附近进行舍入时，请使用ambiguous或nonexistent来控制时间戳应如何重新定位。

>>> ts_tz = pd.Timestamp("2021-10-31 01:30:00").tz_localize("Europe/Amsterdam")

>>> ts_tz.round("h", ambiguous=False)
Timestamp('2021-10-31 02:00:00+0100', tz='Europe/Amsterdam')

>>> ts_tz.round("h", ambiguous=True)
Timestamp('2021-10-31 02:00:00+0200', tz='Europe/Amsterdam')

`pandas.Timestamp.strftime`

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

Timestamp.strftime(format)

返回一个格式化的时间戳字符串。

参数：

formatstr

将时间戳转换为字符串的格式字符串。有关格式字符串的更多信息，请参阅 strftime 文档：docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior。

示例

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.strftime('%Y-%m-%d  %X')
'2020-03-14 15:32:52'

`pandas.Timestamp.strptime`

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

classmethod Timestamp.strptime(string, format)

该函数未实现。请使用 pd.to_datetime()。

示例

>>> pd.Timestamp.strptime("2023-01-01", "%d/%m/%y")
Traceback (most recent call last):
NotImplementedError

`pandas.Timestamp.time`

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

Timestamp.time()

返回具有相同时间但 tzinfo=None 的时间对象。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00')
>>> ts
Timestamp('2023-01-01 10:00:00')
>>> ts.time()
datetime.time(10, 0)

`pandas.Timestamp.timestamp`

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

Timestamp.timestamp()

返回 POSIX 时间戳作为浮点数。

Examples

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548')
>>> ts.timestamp()
1584199972.192548

`pandas.Timestamp.timetuple`

pandas.pydata.org/docs/reference/api/pandas.Timestamp.timetuple.html

Timestamp.timetuple()

返回时间元组，与 time.localtime()兼容。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00')
>>> ts
Timestamp('2023-01-01 10:00:00')
>>> ts.timetuple()
time.struct_time(tm_year=2023, tm_mon=1, tm_mday=1,
tm_hour=10, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=1, tm_isdst=-1)

`pandas.Timestamp.timetz`

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

Timestamp.timetz()

返回具有相同时间和时区信息的时间对象。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00', tz='Europe/Brussels')
>>> ts
Timestamp('2023-01-01 10:00:00+0100', tz='Europe/Brussels')
>>> ts.timetz()
datetime.time(10, 0, tzinfo=<DstTzInfo 'Europe/Brussels' CET+1:00:00 STD>)

`pandas.Timestamp.to_datetime64`

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

Timestamp.to_datetime64()

返回一个具有相同精度的 numpy.datetime64 对象。

示例

>>> ts = pd.Timestamp(year=2023, month=1, day=1,
...                   hour=10, second=15)
>>> ts
Timestamp('2023-01-01 10:00:15')
>>> ts.to_datetime64()
numpy.datetime64('2023-01-01T10:00:15.000000')

`pandas.Timestamp.to_numpy`

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

Timestamp.to_numpy(dtype=None, copy=False)

将时间戳转换为 NumPy datetime64。

这是 Timestamp.to_datetime64() 的别名方法。dtype 和 copy 参数仅用于兼容性。它们的值不会影响返回值。

numpy.datetime64

另请参阅

DatetimeIndex.to_numpy

DatetimeIndex 的类似方法。

示例

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.to_numpy()
numpy.datetime64('2020-03-14T15:32:52.192548651')

对于 pd.NaT 也是类似的：

>>> pd.NaT.to_numpy()
numpy.datetime64('NaT')

`pandas.Timestamp.to_julian_date`

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

Timestamp.to_julian_date()

将时间戳转换为儒略日。

0 儒略日为公元前 4713 年 1 月 1 日中午。

示例

>>> ts = pd.Timestamp('2020-03-14T15:32:52')
>>> ts.to_julian_date()
2458923.147824074

`pandas.Timestamp.to_period`

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

Timestamp.to_period(freq=None)

返回一个时间戳所观察到的周期。

示例

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> # Year end frequency
>>> ts.to_period(freq='Y')
Period('2020', 'Y-DEC')

>>> # Month end frequency
>>> ts.to_period(freq='M')
Period('2020-03', 'M')

>>> # Weekly frequency
>>> ts.to_period(freq='W')
Period('2020-03-09/2020-03-15', 'W-SUN')

>>> # Quarter end frequency
>>> ts.to_period(freq='Q')
Period('2020Q1', 'Q-DEC')

`pandas.Timestamp.to_pydatetime`

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

Timestamp.to_pydatetime(warn=True)

将一个 Timestamp 对象转换为本地的 Python datetime 对象。

如果 warn=True，则在纳秒不为零时发出警告。

例子

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548')
>>> ts.to_pydatetime()
datetime.datetime(2020, 3, 14, 15, 32, 52, 192548)

对于pd.NaT也是类似的：

>>> pd.NaT.to_pydatetime()
NaT

`pandas.Timestamp.today`

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

classmethod Timestamp.today(tz=None)

返回当前时间在本地时区。

与 datetime.today()不同之处在于它可以本地化到传递的时区。

参数：

tz字符串或时区对象，默认为 None

要本地化的时区。

示例

>>> pd.Timestamp.today()    
Timestamp('2020-11-16 22:37:39.969883')

对于pd.NaT类似：

>>> pd.NaT.today()
NaT

`pandas.Timestamp.toordinal`

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

Timestamp.toordinal()

返回先行格里历序数。公元元年的 1 月 1 日是第 1 天。

例子

>>> ts = pd.Timestamp('2023-01-01 10:00:50')
>>> ts
Timestamp('2023-01-01 10:00:50')
>>> ts.toordinal()
738521

`pandas.Timestamp.tz_convert`

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

Timestamp.tz_convert(tz)

将时区感知的时间戳转换为另一个时区。

参数：

tzstr、pytz.timezone、dateutil.tz.tzfile 或 None

时间戳将被转换为的时区。None 将移除保存 UTC 时间的时区。

convertedTimestamp

异常：

TypeError

如果时间戳是 tz-naive。

示例

创建一个带有 UTC 时区的时间戳对象：

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651', tz='UTC')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651+0000', tz='UTC')

转换为东京时区：

>>> ts.tz_convert(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')

也可以使用astimezone：

>>> ts.astimezone(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')

对于pd.NaT的类比：

>>> pd.NaT.tz_convert(tz='Asia/Tokyo')
NaT

`pandas.Timestamp.tz_localize`

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

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

将时间戳本地化到时区。

将简单时间戳转换为本地时区或从具有时区信息的时间戳中移除时区。

参数：

tzstr、pytz.timezone、dateutil.tz.tzfile 或 None

将时间戳转换为将要转换为的时间区域。None 将移除保持本地时间的时区。

模棱两可的bool、‘NaT’，默认为‘raise’

当由于夏令时而将时钟向后移动时，可能会出现模棱两可的时间。例如，在中欧时间（UTC+01）中，从 03:00 夏令时切换到 02:00 非夏令时时，当地时间 02:30:00 同时发生在 UTC 的 00:30:00 和 01:30:00。在这种情况下，ambiguous 参数规定了如何处理模棱两可的时间。

行为如下：

布尔型的 contains 标志用于确定时间是否为夏令时（请注意，此标志仅适用于模棱两可的秋季夏令时日期）。
‘NaT’ 将在模棱两可的时间处返回 NaT。
‘raise’ 对于模棱两可的时间将引发 AmbiguousTimeError。

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

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

行为如下：

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

本地化的Timestamp

引发：

TypeError

如果时间戳是时区感知的且时区不是 None。

示例

创建一个简单的时间戳对象：

>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651')

添加‘Europe/Stockholm’作为时区：

>>> ts.tz_localize(tz='Europe/Stockholm')
Timestamp('2020-03-14 15:32:52.192548651+0100', tz='Europe/Stockholm')

对于 pd.NaT 类似：

>>> pd.NaT.tz_localize()
NaT

`pandas.Timestamp.tzname`

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

Timestamp.tzname()

返回时区名称。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00', tz='Europe/Brussels')
>>> ts
Timestamp('2023-01-01 10:00:00+0100', tz='Europe/Brussels')
>>> ts.tzname()
'CET'

`pandas.Timestamp.utcfromtimestamp`

pandas.pydata.org/docs/reference/api/pandas.Timestamp.utcfromtimestamp.html

classmethod Timestamp.utcfromtimestamp(ts)

从 POSIX 时间戳构造一个带有时区信息的 UTC 日期时间。

注意事项

Timestamp.utcfromtimestamp 的行为与 datetime.utcfromtimestamp 不同，它返回一个带有时区信息的对象。

示例

>>> pd.Timestamp.utcfromtimestamp(1584199972)
Timestamp('2020-03-14 15:32:52+0000', tz='UTC')

`pandas.Timestamp.utcnow`

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

classmethod Timestamp.utcnow()

返回一个表示 UTC 日期和时间的新时间戳。

示例

>>> pd.Timestamp.utcnow()   
Timestamp('2020-11-16 22:50:18.092888+0000', tz='UTC')

`pandas.Timestamp.utcoffset`

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

Timestamp.utcoffset()

返回 UTC 偏移量。

示例

>>> ts = pd.Timestamp('2023-01-01 10:00:00', tz='Europe/Brussels')
>>> ts
Timestamp('2023-01-01 10:00:00+0100', tz='Europe/Brussels')
>>> ts.utcoffset()
datetime.timedelta(seconds=3600)

`pandas.Timestamp.utctimetuple`

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

Timestamp.utctimetuple()

返回与 time.localtime()兼容的 UTC 时间元组。

Examples

>>> ts = pd.Timestamp('2023-01-01 10:00:00', tz='Europe/Brussels')
>>> ts
Timestamp('2023-01-01 10:00:00+0100', tz='Europe/Brussels')
>>> ts.utctimetuple()
time.struct_time(tm_year=2023, tm_mon=1, tm_mday=1, tm_hour=9,
tm_min=0, tm_sec=0, tm_wday=6, tm_yday=1, tm_isdst=0)

`pandas.Timestamp.weekday`

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

Timestamp.weekday()

返回由日期表示的星期几。

Monday == 0 … Sunday == 6.

Examples

>>> ts = pd.Timestamp('2023-01-01')
>>> ts
Timestamp('2023-01-01  00:00:00')
>>> ts.weekday()
6

`pandas.arrays.DatetimeArray`

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

class pandas.arrays.DatetimeArray(values, dtype=None, freq=_NoDefault.no_default, copy=False)

用于时区无关或时区感知日期时间数据的 Pandas ExtensionArray。

警告

DatetimeArray 目前处于实验阶段，其 API 可能会在没有警告的情况下更改。特别是，DatetimeArray.dtype预计会更改为始终是ExtensionDtype子类的实例。

参数：

valuesSeries、Index、DatetimeArray、ndarray

日期时间数据。

对于 DatetimeArray 数值（或包含其数值的 Series 或 Index），dtype 和 freq 将从数值中提取。

dtypenumpy.dtype 或 DatetimeTZDtype

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

freqstr 或 Offset，可选

频率。

copybool，默认为 False

是否复制数值的基础数组。

示例

>>> pd.arrays.DatetimeArray._from_sequence(
...    pd.DatetimeIndex(['2023-01-01', '2023-01-02'], freq='D'))
<DatetimeArray>
['2023-01-01 00:00:00', '2023-01-02 00:00:00']
Length: 2, dtype: datetime64[ns]

属性

None

方法

None

`pandas.DatetimeTZDtype`

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

class pandas.DatetimeTZDtype(unit='ns', tz=None)

用于时区感知日期时间数据的扩展数据类型。

这不是实际的 numpy 数据类型，而是一个鸭子类型。

参数:

unitstr，默认为“ns”

日期时间数据的精度。目前仅限于"ns"。

tzstr、int 或 datetime.tzinfo

时区。

引发:

ZoneInfoNotFoundError

当请求的时区无法找到时。

示例

>>> from zoneinfo import ZoneInfo
>>> pd.DatetimeTZDtype(tz=ZoneInfo('UTC'))
datetime64[ns, UTC]

>>> pd.DatetimeTZDtype(tz=ZoneInfo('Europe/Paris'))
datetime64[ns, Europe/Paris]

属性

`unit`	日期时间数据的精度。
`tz`	时区。

方法

无

`pandas.Timedelta`

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

class pandas.Timedelta(value=<object object>, unit=None, **kwargs)

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

Timedelta 是 pandas 中等同于 python 的datetime.timedelta，在大多数情况下可以互换使用。

参数：

valueTimedelta, timedelta, np.timedelta64, str, 或 int

unitstr，默认为‘ns’

表示输入的单位，如果输入是整数。

可能的取值：

‘W’, 或 ‘D’
‘天’, 或 ‘天’
‘小时’, ‘小时’, ‘小时’, 或 ‘h’
‘分钟’, ‘分钟’, ‘分’, 或 ‘m’
‘秒’, ‘秒’, ‘秒’, 或 ‘s’
‘毫秒’, ‘毫秒’, ‘毫秒’, ‘毫秒’, 或 ‘ms’
‘微秒’, ‘微秒’, ‘微秒’, ‘微秒’, 或 ‘us’
‘纳秒’, ‘纳秒’, ‘纳秒’, ‘纳秒’, 或 ‘ns’。

自版本 2.2.0 起弃用：值 H、T、S、L、U 和 N 已弃用，推荐使用 h、min、s、ms、us 和 ns。

**kwargs

可用的 kwargs：{days, seconds, microseconds, milliseconds, minutes, hours, weeks}。与 datetime.timedelta 兼容的构造值。Numpy 的整数和浮点数将被强制转换为 Python 的整数和浮点数。

注意

构造函数可以接受值��单位的两个值或上述 kwargs。在初始化过程中必须使用其中之一

.value属性始终为 ns。

如果精度高于纳秒，则持续时间的精度将被截断为纳秒。

示例

在这里我们使用值和单位初始化 Timedelta 对象

>>> td = pd.Timedelta(1, "d")
>>> td
Timedelta('1 days 00:00:00')

在这里我们使用 kwargs 初始化 Timedelta 对象

>>> td2 = pd.Timedelta(days=1)
>>> td2
Timedelta('1 days 00:00:00')

我们看到无论哪种方式，我们都会得到相同的结果

属性

`asm8`	返回一个 numpy timedelta64 数组标量视图。
`components`	返回类似于命名元组的组件。
`days`	返回时间间隔的天数。
`max`
`microseconds`
`min`
`nanoseconds`	返回纳秒数（n），其中 0 <= n < 1 微秒。
`resolution`
`resolution_string`	返回表示最低时间间隔分辨率的字符串。
`seconds`	返回时间间隔的总小时、分钟和秒数（以秒为单位）。
`unit`
`value`

方法

`as_unit`(unit[, round_ok])	将底层 int64 表示转换为给定单位。
`ceil`(freq)	返回一个新的 Timedelta，按此分辨率向上取整。
`floor`(freq)	返回一个新的 Timedelta，按此分辨率向下取整。
`isoformat`()	将 Timedelta 格式化为 ISO 8601 时长。
`round`(freq)	将 Timedelta 四舍五入到指定的分辨率。
`to_numpy`([dtype, copy])	将 Timedelta 转换为 NumPy timedelta64。
`to_pytimedelta`()	将 pandas Timedelta 对象转换为 python `datetime.timedelta` 对象。
`to_timedelta64`()	返回一个具有 'ns' 精度的 numpy.timedelta64 对象。
`total_seconds`()	时长中的总秒数。
`view`(dtype)	数组视图兼容性。

`pandas.Timedelta.asm8`

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

Timedelta.asm8

返回一个 numpy timedelta64 数组标量视图。

提供对与 numpy.timedelta64().view()关联的数组标量视图（即值和单位的组合）的访问，包括以纳秒为单位的时间增量的 64 位整数表示（与 Python int 兼容）。

numpy timedelta64 数组标量视图

时间增量的数组标量视图，以纳秒为单位。

示例

>>> td = pd.Timedelta('1 days 2 min 3 us 42 ns')
>>> td.asm8
numpy.timedelta64(86520000003042,'ns')

>>> td = pd.Timedelta('2 min 3 s')
>>> td.asm8
numpy.timedelta64(123000000000,'ns')

>>> td = pd.Timedelta('3 ms 5 us')
>>> td.asm8
numpy.timedelta64(3005000,'ns')

>>> td = pd.Timedelta(42, unit='ns')
>>> td.asm8
numpy.timedelta64(42,'ns')

`pandas.Timedelta.components`

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

Timedelta.components

返回类似于组件的命名元组。

示例

>>> td = pd.Timedelta('2 day 4 min 3 us 42 ns')
>>> td.components
Components(days=2, hours=0, minutes=4, seconds=0, milliseconds=0,
 microseconds=3, nanoseconds=42)

`pandas.Timedelta.days`

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

Timedelta.days

返回时间间隔的天数。

int

示例

>>> td = pd.Timedelta(1, "d")
>>> td.days
1

>>> td = pd.Timedelta('4 min 3 us 42 ns')
>>> td.days
0

`pandas.Timedelta.max`

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

Timedelta.max = Timedelta('106751 days 23:47:16.854775807')

`pandas.Timedelta.microseconds`

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

Timedelta.microseconds

`pandas.Timedelta.min`

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

Timedelta.min = Timedelta('-106752 days +00:12:43.145224193')

`pandas.Timedelta.nanoseconds`

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

Timedelta.nanoseconds

返回纳秒数（n），其中 0 <= n < 1 微秒。

int

纳秒的数量。

另请参阅

Timedelta.components

返回所有具有赋值的属性（即天数、小时、分钟、秒、毫秒、微秒、纳秒）。

示例

使用字符串输入

>>> td = pd.Timedelta('1 days 2 min 3 us 42 ns')

>>> td.nanoseconds
42

使用整数输入

>>> td = pd.Timedelta(42, unit='ns')
>>> td.nanoseconds
42

`pandas.Timedelta.resolution`

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

Timedelta.resolution = Timedelta('0 days 00:00:00.000000001')

`pandas.Timedelta.seconds`

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

Timedelta.seconds

返回时间增量的总小时、分钟和秒数，以秒为单位。

Timedelta.seconds = hours * 3600 + minutes * 60 + seconds.

int

秒数。

另请参阅

Timedelta.components

返回所有具有赋值的属性（即天数、小时、分钟、秒、毫秒、微秒、纳秒）。

Timedelta.total_seconds

将时间增量表示为总秒数。

示例

使用字符串输入

>>> td = pd.Timedelta('1 days 2 min 3 us 42 ns')
>>> td.seconds
120

使用整数输入

>>> td = pd.Timedelta(42, unit='s')
>>> td.seconds
42

`pandas.Timedelta.unit`

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

Timedelta.unit

`pandas.Timedelta.value`

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

Timedelta.value

`pandas.Timedelta.view`

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

Timedelta.view(dtype)

数组视图兼容性。

参数：

dtypestr 或 dtype

将底层数据视为的数据类型。

示例

>>> td = pd.Timedelta('3D')
>>> td
Timedelta('3 days 00:00:00')
>>> td.view(int)
259200000000000

`pandas.Timedelta.as_unit`

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

Timedelta.as_unit(unit, round_ok=True)

将底层 int64 表示转换为给定的单位。

参数：

unit{“ns”, “us”, “ms”, “s”}

round_ok布尔值，默认为 True

如果为 False 且转换需要四舍五入，则引发异常。

返回值：

时间差

示例

>>> td = pd.Timedelta('1001ms')
>>> td
Timedelta('0 days 00:00:01.001000')
>>> td.as_unit('s')
Timedelta('0 days 00:00:01')

`pandas.Timedelta.ceil`

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

Timedelta.ceil(freq)

返回一个按照指定分辨率向上取整的新时间增量。

参数：

freqstr

表示向上取整分辨率的频率字符串。它使用与类构造函数Timedelta相同的单位。

示例

>>> td = pd.Timedelta('1001ms')
>>> td
Timedelta('0 days 00:00:01.001000')
>>> td.ceil('s')
Timedelta('0 days 00:00:02')

`pandas.Timedelta.floor`

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

Timedelta.floor(freq)

返回一个新的时间间隔，按此分辨率取整。

参数：

freqstr

表示时间间隔的频率字符串。它使用与类构造函数Timedelta相同的单位。

示例

>>> td = pd.Timedelta('1001ms')
>>> td
Timedelta('0 days 00:00:01.001000')
>>> td.floor('s')
Timedelta('0 days 00:00:01')

`pandas.Timedelta.isoformat`

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

Timedelta.isoformat()

将 Timedelta 格式化为 ISO 8601 持续时间。

P[n]Y[n]M[n]DT[n]H[n]M[n]S，其中[n]被值替换。参见en.wikipedia.org/wiki/ISO_8601#Durations。

str

另请参见

Timestamp.isoformat

此函数用于将给定的 Timestamp 对象转换为 ISO 格式。

注意事项

最长的组件是天数，其值可能大于 365。每个组件始终包含在内，即使其值为 0。Pandas 使用纳秒精度，因此秒组件中可能包含多达 9 位小数。小数点后的尾随 0 会被删除。我们不会用 0 填充组件，所以是…T5H…，而不是…T05H…

示例

>>> td = pd.Timedelta(days=6, minutes=50, seconds=3,
...                   milliseconds=10, microseconds=10, nanoseconds=12)

>>> td.isoformat()
'P6DT0H50M3.010010012S'
>>> pd.Timedelta(hours=1, seconds=10).isoformat()
'P0DT1H0M10S'
>>> pd.Timedelta(days=500.5).isoformat()
'P500DT12H0M0S'

`pandas.Timedelta.round`

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

Timedelta.round(freq)

将 Timedelta 四舍五入到指定的分辨率。

参数：

freqstr

频率字符串，指示舍入分辨率。它使用与类构造函数 Timedelta 相同的单位。

一个新的 Timedelta，四舍五入到给定的 freq 分辨率

引发：

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

示例

>>> td = pd.Timedelta('1001ms')
>>> td
Timedelta('0 days 00:00:01.001000')
>>> td.round('s')
Timedelta('0 days 00:00:01')

`pandas.Timedelta.to_pytimedelta`

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

Timedelta.to_pytimedelta()

将 pandas Timedelta 对象转换为 python datetime.timedelta对象。

Timedelta 对象在内部保存为 numpy datetime64[ns] dtype。使用 to_pytimedelta()将其转换为对象 dtype。

datetime.timedelta 或 numpy.array of datetime.timedelta

另请参阅

to_timedelta

将参数转换为 Timedelta 类型。

注意事项

任何纳秒分辨率都将丢失。

示例

>>> td = pd.Timedelta('3D')
>>> td
Timedelta('3 days 00:00:00')
>>> td.to_pytimedelta()
datetime.timedelta(days=3)

`pandas.Timedelta.to_timedelta64`

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

Timedelta.to_timedelta64()

返回一个具有‘ns’精度的 numpy.timedelta64 对象。

示例

>>> td = pd.Timedelta('3D')
>>> td
Timedelta('3 days 00:00:00')
>>> td.to_timedelta64()
numpy.timedelta64(259200000000000,'ns')

`pandas.Timedelta.to_numpy`

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

Timedelta.to_numpy(dtype=None, copy=False)

将 Timedelta 转换为 NumPy timedelta64。

这是 Timedelta.to_timedelta64() 的别名方法。这里的 dtype 和 copy 参数仅供兼容性使用。它们的值不会影响返回值。

numpy.timedelta64

另请参阅

Series.to_numpy

Series 的类似方法。

示例

>>> td = pd.Timedelta('3D')
>>> td
Timedelta('3 days 00:00:00')
>>> td.to_numpy()
numpy.timedelta64(259200000000000,'ns')

`pandas.Timedelta.total_seconds`

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

Timedelta.total_seconds()

持续时间的总秒数。

Examples

>>> td = pd.Timedelta('1min')
>>> td
Timedelta('0 days 00:01:00')
>>> td.total_seconds()
60.0

`pandas.arrays.TimedeltaArray`

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

class pandas.arrays.TimedeltaArray(values, dtype=None, freq=_NoDefault.no_default, copy=False)

用于时间数据的 Pandas ExtensionArray。

警告

TimedeltaArray 目前处于实验阶段，其 API 可能会在没有警告的情况下更改。特别是，预计TimedeltaArray.dtype将更改为ExtensionDtype子类的实例。

参数：

values类似数组

时间数据。

dtypenumpy.dtype

目前，仅接受numpy.dtype("timedelta64[ns]")。

freqOffset，可选

copy布尔值，默认为 False

是否复制数据的基础数组。

示例

>>> pd.arrays.TimedeltaArray._from_sequence(pd.TimedeltaIndex(['1h', '2h']))
<TimedeltaArray>
['0 days 01:00:00', '0 days 02:00:00']
Length: 2, dtype: timedelta64[ns]

属性

None

方法

None

`pandas.Period`

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

class pandas.Period(value=None, freq=None, ordinal=None, year=None, month=None, quarter=None, day=None, hour=None, minute=None, second=None)

表示一段时间。

参数：

valuePeriod、str、datetime、date 或 pandas.Timestamp，默认为 None

所代表的时间段（例如，'4Q2005'）。这既不代表期间的开始也不代表结束，而是整个期间本身。

freqstr，默认为 None

pandas 期间��符串或相应对象之一。接受的字符串在用户文档中的期间别名部分中列出。如果值为 datetime，则需要 freq。

ordinalint，默认为 None

从公历纪元开始的 Period 偏移量。

yearint，默认为 None

Period 的年份值。

monthint，默认为 1

Period 的月份值。

quarterint，默认为 None

Period 的季度值。

dayint，默认为 1

Period 的日期值。

hourint，默认为 0

Period 的小时值。

minuteint，默认为 0

Period 的分钟值。

secondint，默认为 0

Period 的第二个值。

示例

>>> period = pd.Period('2012-1-1', freq='D')
>>> period
Period('2012-01-01', 'D')

属性

`day`	获取 Period 所在月份的日期。
`day_of_week`	Period 所在星期的日期，星期一为 0，星期日为 6。
`day_of_year`	返回一年中的第几天。
`dayofweek`	Period 所在星期的日期，星期一为 0，星期日为 6。
`dayofyear`	返回一年中的第几天。
`days_in_month`	获取该 Period 所在月份的总天数。
`daysinmonth`	获取该 Period 所在月份的总天数。
`end_time`	获取 Period 结束时的时间戳。
`freq`
`freqstr`	返回频率的字符串表示。
`hour`	获取 Period 的小时分量的小时数。
`is_leap_year`	如果 Period 的年份是闰年，则返回 True。
`minute`	获取 Period 的小时分量的分钟数。
`month`	返回此 Period 所在的月份。
`ordinal`
`quarter`	返回此 Period 所在的季度。
`qyear`	根据其起始季度确定 Period 所在的财政年度。
`second`	获取 Period 的秒组件。
`start_time`	获取该期间开始的时间戳。
`week`	获取给定 Period 的年周数。
`weekday`	Period 所在的星期几，星期一为 0，星期日为 6。
`weekofyear`	获取给定 Period 的年周数。
`year`	返回此 Period 所在的年份。

方法

`asfreq`(freq[, how])	将 Period 转换为所需频率，位于间隔的开始或结束处。
`now`(freq)	返回当前日期的 Period。
`strftime`(fmt)	返回 `Period` 的格式化字符串表示。
`to_timestamp`([freq, how])	返回 Period 的时间戳表示。

`pandas.Period.day`

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

Period.day

获取 Period 所在月份的日期。

int

另请参阅

Period.dayofweek

获取一周中的日期。

Period.dayofyear

获取一年中的日期。

示例

>>> p = pd.Period("2018-03-11", freq='h')
>>> p.day
11

`pandas.Period.dayofweek`

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

Period.dayofweek

周期所在的星期几，星期一为 0，星期日为 6。

如果周期频率低于每日（例如每小时），并且周期跨越多天，则使用周期开始的那一天。

如果频率高于每日（例如每月），则使用周期的最后一天。

int

周期所在的星期几。

另请参阅

Period.day_of_week

周期所在的星期几。

Period.weekday

Period.day_of_week 的别名。

Period.day

月份的日期。

Period.dayofyear

年份的日期。

示例

>>> per = pd.Period('2017-12-31 22:00', 'h')
>>> per.day_of_week
6

对于跨越多天的周期，返回周期开始的那一天。

>>> per = pd.Period('2017-12-31 22:00', '4h')
>>> per.day_of_week
6
>>> per.start_time.day_of_week
6

对于频率高于天的周期，返回周期的最后一天。

>>> per = pd.Period('2018-01', 'M')
>>> per.day_of_week
2
>>> per.end_time.day_of_week
2

`pandas.Period.day_of_week`

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

Period.day_of_week

周期所在的星期几，星期一为 0，星期日为 6。

如果周期频率低于每日（例如每小时），并且周期跨越多天，则使用周期开始时的那一天。

如果频率高于每日（例如每月），则使用周期的最后一天。

返回值：

int

星期几。

另请参阅

Period.day_of_week

周期所在的星期几。

Period.weekday

Period.day_of_week 的别名。

Period.day

月份中的哪一天。

Period.dayofyear

年份中的哪一天。

示例

>>> per = pd.Period('2017-12-31 22:00', 'h')
>>> per.day_of_week
6

对于跨越多天的周期，返回周期开始时的那一天。

>>> per = pd.Period('2017-12-31 22:00', '4h')
>>> per.day_of_week
6
>>> per.start_time.day_of_week
6

对于频率高于每日的周期，返回周期的最后一天。

>>> per = pd.Period('2018-01', 'M')
>>> per.day_of_week
2
>>> per.end_time.day_of_week
2

`pandas.Period.dayofyear`

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

Period.dayofyear

返回年份中的日期。

此属性返回特定日期所在年份的日期。返回值范围为常规年份的 1 到 365，闰年的 1 到 366。

int

年份中的日期。

另请参见

Period.day

返回月份中的日期。

Period.day_of_week

返回星期几。

PeriodIndex.day_of_year

返回所有索引的年份中的日期。

示例

>>> period = pd.Period("2015-10-23", freq='h')
>>> period.day_of_year
296
>>> period = pd.Period("2012-12-31", freq='D')
>>> period.day_of_year
366
>>> period = pd.Period("2013-01-01", freq='D')
>>> period.day_of_year
1

`pandas.Period.day_of_year`

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

Period.day_of_year

返回一年中的第几天。

此属性返回特定日期所在年份的第几天。返回值范围为 1 到 365（普通年份）和 1 到 366（闰年）。

整数

一年中的第几天。

另请参阅

Period.day

返回一个月中的第几天。

Period.day_of_week

返回一周的星期几。

PeriodIndex.day_of_year

返回所有索引的一年中的第几天。

示例

>>> period = pd.Period("2015-10-23", freq='h')
>>> period.day_of_year
296
>>> period = pd.Period("2012-12-31", freq='D')
>>> period.day_of_year
366
>>> period = pd.Period("2013-01-01", freq='D')
>>> period.day_of_year
1

`pandas.Period.days_in_month`

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

Period.days_in_month

获取此时期所在月份的总天数。

整型

另请参阅

Period.daysinmonth

获取月份中的天数。

DatetimeIndex.daysinmonth

获取月份中的天数。

calendar.monthrange

返回包含星期几（0-6 ~ 星期一至星期日）和天数（28-31）的元组。

示例

>>> p = pd.Period('2018-2-17')
>>> p.days_in_month
28

>>> pd.Period('2018-03-01').days_in_month
31

处理闰年情况：

>>> p = pd.Period('2016-2-17')
>>> p.days_in_month
29

`pandas.Period.daysinmonth`

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

Period.daysinmonth

获取该时期所在月份的总天数。

返回值：

int

另请参阅

Period.days_in_month

返回月份的天数。

Period.dayofyear

返回一年中的第几天。

示例

>>> p = pd.Period("2018-03-11", freq='h')
>>> p.daysinmonth
31

`pandas.Period.end_time`

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

Period.end_time

获取期间结束的时间戳。

时间戳

请参见

返回开始的时间戳。

返回一年中的第几天。

返回该月份的天数。

返回星期几。

示例

对于 Period：

>>> pd.Period('2020-01', 'D').end_time
Timestamp('2020-01-01 23:59:59.999999999')

对于 Series：

>>> period_index = pd.period_range('2020-1-1 00:00', '2020-3-1 00:00', freq='M')
>>> s = pd.Series(period_index)
>>> s
0   2020-01
1   2020-02
2   2020-03
dtype: period[M]
>>> s.dt.end_time
0   2020-01-31 23:59:59.999999999
1   2020-02-29 23:59:59.999999999
2   2020-03-31 23:59:59.999999999
dtype: datetime64[ns]

对于 PeriodIndex：

>>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")
>>> idx.end_time
DatetimeIndex(['2023-01-31 23:59:59.999999999',
 '2023-02-28 23:59:59.999999999',
 '2023-03-31 23:59:59.999999999'],
 dtype='datetime64[ns]', freq=None)

`pandas.Period.freq`

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

Period.freq

`pandas.Period.freqstr`

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

Period.freqstr

返回频率的字符串表示。

示例

>>> pd.Period('2020-01', 'D').freqstr
'D'

`pandas.Period.hour`

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

Period.hour

获取周期的一天中的小时组件。

整数

小时，作为一个介于 0 和 23 之间的整数。

另请参阅

Period.second

获取周期的秒部分。

Period.minute

获取周期的分钟部分。

示例

>>> p = pd.Period("2018-03-11 13:03:12.050000")
>>> p.hour
13

周期长于一天

>>> p = pd.Period("2018-03-11", freq="M")
>>> p.hour
0

`pandas.Period.is_leap_year`

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

Period.is_leap_year

如果该时间段所在的年份是闰年，则返回 True。

Examples

>>> period = pd.Period('2022-01', 'M')
>>> period.is_leap_year
False

>>> period = pd.Period('2020-01', 'M')
>>> period.is_leap_year
True

`pandas.Period.minute`

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

Period.minute

获取 Period 的小时组件的分钟。

整数

分钟作为一个整数，范围在 0 到 59 之间。

另请参阅

Period.hour

获取 Period 的小时组件。

Period.second

获取 Period 的秒组件。

例子

>>> p = pd.Period("2018-03-11 13:03:12.050000")
>>> p.minute
3

`pandas.Period.month`

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

Period.month

返回此 Period 所在的月份。

Examples

>>> period = pd.Period('2022-01', 'M')
>>> period.month
1

`pandas.Period.ordinal`

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

Period.ordinal

`pandas.Period.quarter`

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

Period.quarter

返回此期间所在的季度。

示例

>>> period = pd.Period('2022-04', 'M')
>>> period.quarter
2

`pandas.Period.qyear`

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

Period.qyear

期间所属的财政年度，根据其起始季度确定。

如果财政年度和日历年度相同，则该期间的年份和财政年份将相同。当它们不同时，财政年度可能与期间的日历年度不同。

int

期间的财政年度。

另请参阅

Period.year

返回期间的日历年度。

示例

如果自然年和财政年相同，则 qyear 和 year 将相同。

>>> per = pd.Period('2018Q1', freq='Q')
>>> per.qyear
2018
>>> per.year
2018

如果财政年度从四月开始（Q-MAR），则 2018 年的第一个季度将从 2017 年四月开始。年份将是 2017，但 qyear 将是财政年度，即 2018 年。

>>> per = pd.Period('2018Q1', freq='Q-MAR')
>>> per.start_time
Timestamp('2017-04-01 00:00:00')
>>> per.qyear
2018
>>> per.year
2017

`pandas.Period.second`

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

Period.second

获取周期的秒组成部分。

返回值：

整数

周期的秒（范围从 0 到 59）。

参见

Period.hour

获取周期的小时组成部分。

Period.minute

获取周期的分钟组成部分。

示例

>>> p = pd.Period("2018-03-11 13:03:12.050000")
>>> p.second
12

`pandas.Period.start_time`

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

Period.start_time

获取周期开始的时间戳。

时间戳

另请参阅

Period.end_time

返回结束时间戳。

Period.dayofyear

返回一年的第几天。

Period.daysinmonth

返回该月的天数。

Period.dayofweek

返回一周的第几天。

示例

>>> period = pd.Period('2012-1-1', freq='D')
>>> period
Period('2012-01-01', 'D')

>>> period.start_time
Timestamp('2012-01-01 00:00:00')

>>> period.end_time
Timestamp('2012-01-01 23:59:59.999999999')

`pandas.Period.week`

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

Period.week

获取给定周期的一年中的周数。

整数

另请参阅

Period.dayofweek

获取周期的日期组件。

Period.weekday

获取周期的日期组件。

示例

>>> p = pd.Period("2018-03-11", "h")
>>> p.week
10

>>> p = pd.Period("2018-02-01", "D")
>>> p.week
5

>>> p = pd.Period("2018-01-06", "D")
>>> p.week
1

`pandas.Period.weekday`

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

Period.weekday

一周中的日期，星期一为 0，星期日为 6。

如果周期频率低于每日（例如每小时），并且周期跨越多天，则使用周期开始时的日期。

如果频率高于每日（例如每月），则使用周期的最后一天。

整数

一周中的日期。

另请参阅

Period.dayofweek

一周中的日期。

Period.weekday

Period.dayofweek 的别名。

Period.day

一个月中的日期。

Period.dayofyear

一年中的日期。

示例

>>> per = pd.Period('2017-12-31 22:00', 'h')
>>> per.dayofweek
6

对于跨越多天的周期，返回周期开始时的日期。

>>> per = pd.Period('2017-12-31 22:00', '4h')
>>> per.dayofweek
6
>>> per.start_time.dayofweek
6

对于频率高于天的周期，返回周期的最后一天。

>>> per = pd.Period('2018-01', 'M')
>>> per.dayofweek
2
>>> per.end_time.dayofweek
2

`pandas.Period.weekofyear`

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

Period.weekofyear

获取给定周期的年份周数。

整型

另请参阅

Period.dayofweek

获取周期的日组成部分。

Period.weekday

获取周期的日组成部分。

示例

>>> p = pd.Period("2018-03-11", "h")
>>> p.weekofyear
10

>>> p = pd.Period("2018-02-01", "D")
>>> p.weekofyear
5

>>> p = pd.Period("2018-01-06", "D")
>>> p.weekofyear
1

`pandas.Period.year`

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

Period.year

返回此 Period 所在的年份。

示例

>>> period = pd.Period('2022-01', 'M')
>>> period.year
2022

`pandas.Period.asfreq`

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

Period.asfreq(freq, how='E')

将周期转换为所需频率，在时间间隔的开始或结束。

参数：

freqstr，BaseOffset

所需的频率。如果传递一个字符串，它需要是一个有效的周期别名。

how{‘E’, ‘S’, ‘end’, ‘start’}，默认为‘end’

开始或结束时间跨度。

返回值：

resampledPeriod

示例

>>> period = pd.Period('2023-1-1', freq='D')
>>> period.asfreq('h')
Period('2023-01-01 23:00', 'h')

`pandas.Period.now`

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

classmethod Period.now(freq)

返回当前日期的周期。

参数：

freqstr，BaseOffset

返回周期所使用的频率。

示例

>>> pd.Period.now('h')  
Period('2023-06-12 11:00', 'h')

`pandas.Period.strftime`

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

Period.strftime(fmt)

返回一个格式化的字符串表示形式的 Period。

fmt 必须为 None 或包含一个或多个指令的字符串。当为 None 时，将根据 Period 的频率确定格式。该方法识别与标准 Python 发行版的 time.strftime() 函数相同的指令，以及特定的额外指令 %f、%F、%q、%l、%u、%n。 (格式化和文档原始来自 scikits.timeries)。

指令	意义	注意事项
`%a`	本地化的缩写星期几名称。
`%A`	本地化的完整星期几名称。
`%b`	本地化的缩写月份名称。
`%B`	本地化的完整月份名称。
`%c`	本地化的适当日期和时间表示形式。
`%d`	以十进制数表示的月份中的日期 [01,31]。
`%f`	不带世纪的“财政”年份以十进制数表示 [00,99]。	(1)
`%F`	以十进制数表示的“财政”年份，含有世纪信息。	(2)
`%H`	小时（24 小时制）以十进制数表示 [00,23]。
`%I`	时（12 小时制）以十进制数表示 [01,12]。
`%j`	一年中的日期，以十进制数表示 [001,366]。
`%m`	以十进制数表示的月份 [01,12]。
`%M`	以十进制数表示的分钟 [00,59]。
`%p`	本地化的上午或下午的等价表示形式。	(3)
`%q`	以十进制数表示的季度 [1,4]。
`%S`	以十进制数表示的秒 [00,61]。	(4)
`%l`	以十进制数表示的毫秒 [000,999]。
`%u`	以十进制数表示的微秒 [000000,999999]。
`%n`	以十进制数表示的纳秒 [000000000,999999999]。
`%U`	一年中的周数（将周日作为一周的第一天），以十进制数表示 [00,53]。新年的第一天之前的所有天被视为第 0 周。	(5)
`%w`	一周中的星期几，以十进制数表示 [0（星期日），6]。
`%W`	一年中的周数（将周一作为一周的第一天），以十进制数表示 [00,53]。新年的第一天之前的所有天被视为第 0 周。	(5)
`%x`	本地化的适当日期表示形式。
`%X`	本地化的适当时间表示形式。
`%y`	年份（不含世纪）以十进制数表示 [00,99]。
`%Y`	带世纪的年份以十进制数表示。
`%Z`	时区名称（如果不存在时区则为空字符）。
`%%`	文字 `'%'` 字符。

Notes

如果频率不是季度，%f 指令与 %y 相同。否则，它对应于由 qyear 属性定义的“财政”年份。
%F 指令如果频率不是季度，则与 %Y 相同。否则，它对应于由qyear属性定义的“财政”年。
%p 指令仅在使用 %I 指令解析小时时影响输出小时字段。
范围实际上是0到61；这考虑了闰秒和（非常罕见的）双闰秒。
%U 和 %W 指令仅在指定星期几和年份时用于计算。

例子

>>> from pandas import Period
>>> a = Period(freq='Q-JUL', year=2006, quarter=1)
>>> a.strftime('%F-Q%q')
'2006-Q1'
>>> # Output the last month in the quarter of this date
>>> a.strftime('%b-%Y')
'Oct-2005'
>>>
>>> a = Period(freq='D', year=2001, month=1, day=1)
>>> a.strftime('%d-%b-%Y')
'01-Jan-2001'
>>> a.strftime('%b. %d, %Y was a %A')
'Jan. 01, 2001 was a Monday'

`pandas.Period.to_timestamp`

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

Period.to_timestamp(freq=None, how='start')

返回周期的时间戳表示。

使用在指定周期部分指定的目标频率，该周期部分可以是开始或结束。

参数：

freqstr 或 DateOffset

目标频率。如果 self.freq 是一周或更长，则默认为‘D’，否则为‘S’。

howstr，默认为‘S’（开始）

‘S’、‘E’之一。可以不区分大小写地别名为‘Start’、‘Finish’、‘Begin’、‘End’。

时间戳

示例

>>> period = pd.Period('2023-1-1', freq='D')
>>> timestamp = period.to_timestamp()
>>> timestamp
Timestamp('2023-01-01 00:00:00')

`pandas.arrays.PeriodArray`

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

class pandas.arrays.PeriodArray(values, dtype=None, freq=None, copy=False)

用于存储 Period 数据的 Pandas ExtensionArray。

用户应该使用array()来创建新实例。

参数：

valuesUnion[PeriodArray，Series[period]，ndarray[int]，PeriodIndex]

要存储的数据。这些应该是可以直接转换为序数而无需推断或复制的数组（PeriodArray，ndarray[int64]），或者是围绕这样一个数组的框（Series[period]，PeriodIndex）。

dtypePeriodDtype，可选

一个 PeriodDtype 实例，用于提取频率。如果同时指定了 freq 和 dtype，则频率必须匹配。

freqstr 或 DateOffset

用于数组的频率。当 values 是整数的 ndarray 时大部分适用，此时需要 freq。当 values 是 PeriodArray（或 box around）时，会检查values.freq是否与 freq 匹配。

copybool，默认为 False

是否在存储前复制序数。

另请参阅

Period

表示一段时间。

PeriodIndex

用于期间数据的不可变索引。

period_range

创建一个固定频率的 PeriodArray。

array

构造一个 pandas 数组。

注释

一个 PeriodArray 有两个组成部分

序数：整数 ndarray
freq：pd.tseries.offsets.Offset

值以 1-D 整数的 ndarray 形式物理存储。这些称为“序数”，表示相对于某个基准的某种偏移量。

freq 表示数组中每个元素覆盖的跨度。PeriodArray 中的所有元素都具有相同的频率。

示例

>>> pd.arrays.PeriodArray(pd.PeriodIndex(['2023-01-01',
...                                       '2023-01-02'], freq='D'))
<PeriodArray>
['2023-01-01', '2023-01-02']
Length: 2, dtype: period[D]

属性

None

方法

None

`pandas.PeriodDtype`

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

class pandas.PeriodDtype(freq)

用于 Period 数据的 ExtensionDtype。

这不是一个实际的 numpy dtype，而是一个鸭子类型。

参数:

freqstr 或 DateOffset

此 PeriodDtype 的频率。

示例

>>> pd.PeriodDtype(freq='D')
period[D]

>>> pd.PeriodDtype(freq=pd.offsets.MonthEnd())
period[M]

属性

`freq`	此 PeriodDtype 的频率对象。

方法

无

`pandas.Interval`

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

class pandas.Interval

实现区间的不可变对象，类似于有界切片的区间。

参数：

左可排序标量

区间的左边界。

右可排序标量

区间的右边界。

closed{‘right’, ‘left’, ‘both’, ‘neither’}，默认为‘right’

区间是否在左侧、右侧、两侧或无一侧闭合。更详细的解释请参见注意事项。

另请参阅

IntervalIndex

一个所有区间都在同一侧闭合的区间对象索引。

cut

将连续数据转换为离散区间（区间对象的分类）。

qcut

将连续数据根据分位数转换为区间（区间对象的分类）。

Period

表示一段时间。

注意事项

参数 left 和 right 必须是相同类型的，您必须能够比较它们，并且它们必须满足 left <= right。

闭合区间（在数学中用方括号表示）包含其端点，即闭合区间 [0, 5] 的特征是条件 0 <= x <= 5。这就是 closed='both' 的含义。开区间（在数学中用圆括号表示）不包含其端点，即开区间 (0, 5) 的特征是条件 0 < x < 5。这就是 closed='neither' 的含义。区间也可以是半开或半闭的，即 [0, 5) 由 0 <= x < 5 描述（closed='left'），(0, 5] 由 0 < x <= 5 描述（closed='right'）。

示例

可以构建不同类型的区间，比如数值类型的区间：

>>> iv = pd.Interval(left=0, right=5)
>>> iv
Interval(0, 5, closed='right')

您可以检查一个元素是否属于它，或者它是否包含另一个区间：

>>> 2.5 in iv
True
>>> pd.Interval(left=2, right=5, closed='both') in iv
True

您可以测试边界（closed='right'，所以 0 < x <= 5）：

>>> 0 in iv
False
>>> 5 in iv
True
>>> 0.0001 in iv
True

计算其长度

>>> iv.length
5

您可以对区间执行 + 和 * 操作，操作将应用于其每个边界，因此结果取决于边界元素的类型

>>> shifted_iv = iv + 3
>>> shifted_iv
Interval(3, 8, closed='right')
>>> extended_iv = iv * 10.0
>>> extended_iv
Interval(0.0, 50.0, closed='right')

要创建时间区间，您可以使用时间戳作为边界

>>> year_2017 = pd.Interval(pd.Timestamp('2017-01-01 00:00:00'),
...                         pd.Timestamp('2018-01-01 00:00:00'),
...                         closed='left')
>>> pd.Timestamp('2017-01-01 00:00') in year_2017
True
>>> year_2017.length
Timedelta('365 days 00:00:00')

属性

`closed`	描述区间的包含侧的字符串。
`closed_left`	检查区间左侧是否闭合。
`closed_right`	检查区间右侧是否闭合。
`is_empty`	指示区间是否为空，即不包含任何点。
`left`	区间的左边界。
`length`	返回区间的长度。
`mid`	返回区间的中点。
`open_left`	检查区间左侧是否为开区间。
`open_right`	检查区间右侧是否为开区间。
`right`	区间的右边界。

方法

`overlaps`(other)	检查两个区间对象是否重叠。

`pandas.Interval.closed`

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

Interval.closed

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

可以是left、right、both或neither。

示例

>>> interval = pd.Interval(left=1, right=2, closed='left')
>>> interval
Interval(1, 2, closed='left')
>>> interval.closed
'left'

`pandas.Interval.closed_left`

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

Interval.closed_left

检查区间是否在左侧闭合。

关于闭合和开放的含义，请参见Interval。

布尔值

如果区间在左侧闭合，则为真。

另请参阅

Interval.closed_right

检查区间是否在右侧闭合。

Interval.open_left

闭合左侧的布尔值的反义。

示例

>>> iv = pd.Interval(0, 5, closed='left')
>>> iv.closed_left
True

>>> iv = pd.Interval(0, 5, closed='right')
>>> iv.closed_left
False

`pandas.Interval.closed_right`

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

Interval.closed_right

检查区间是否在右侧是闭合的。

关于闭合和开放的含义，请参见 Interval。

布尔值

如果区间在左侧是闭合的，则为 True。

另请参阅

Interval.closed_left

检查区间是否在左侧是闭合的。

Interval.open_right

左闭区间的布尔反义。

例子

>>> iv = pd.Interval(0, 5, closed='both')
>>> iv.closed_right
True

>>> iv = pd.Interval(0, 5, closed='left')
>>> iv.closed_right
False

`pandas.Interval.is_empty`

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

Interval.is_empty

指示一个区间是否为空，即它不包含任何点。

布尔值或 ndarray

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

另请参阅

Interval.length

返回 Interval 的长度。

示例

一个包含点的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.Interval.left`

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

Interval.left

区间的左边界。

示例

>>> interval = pd.Interval(left=1, right=2, closed='left')
>>> interval
Interval(1, 2, closed='left')
>>> interval.left
1

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

Pandas 2.2 中文文档（二十五）

pandas 数组

pandas.arrays.ArrowExtensionArray

pandas.ArrowDtype

pandas.Timestamp

pandas.Timestamp.asm8

pandas.Timestamp.day

pandas.Timestamp.dayofweek

pandas.Timestamp.day_of_week

pandas.Timestamp.dayofyear

pandas.Timestamp.day_of_year

pandas.Timestamp.days_in_month

pandas.Timestamp.daysinmonth

pandas.Timestamp.fold

pandas.Timestamp.hour

pandas.Timestamp.is_leap_year

pandas.Timestamp.is_month_end

pandas.Timestamp.is_month_start

pandas.Timestamp.is_quarter_end

pandas.Timestamp.is_quarter_start

pandas.Timestamp.is_year_end

pandas.Timestamp.is_year_start

pandas.Timestamp.max

pandas.Timestamp.microsecond

pandas.Timestamp.min

pandas.Timestamp.minute

pandas.Timestamp.month

pandas.Timestamp.nanosecond

pandas.Timestamp.quarter

pandas.Timestamp.resolution

pandas.Timestamp.second

pandas.Timestamp.tz

pandas.Timestamp.tzinfo

pandas.Timestamp.unit

pandas.Timestamp.value

pandas.Timestamp.week

pandas.Timestamp.weekofyear

pandas.Timestamp.year

pandas.Timestamp.as_unit

pandas.Timestamp.astimezone

pandas.Timestamp.ceil

pandas.Timestamp.combine

pandas.Timestamp.ctime

pandas.Timestamp.date

pandas.Timestamp.day_name

pandas.Timestamp.dst

pandas.Timestamp.floor

pandas.Timestamp.fromordinal

pandas.Timestamp.fromtimestamp

pandas.Timestamp.isocalendar

pandas.Timestamp.isoformat

pandas.Timestamp.isoweekday

pandas.Timestamp.month_name

pandas.Timestamp.normalize

pandas.Timestamp.now

pandas.Timestamp.replace

pandas.Timestamp.round

pandas.Timestamp.strftime

pandas.Timestamp.strptime

pandas.Timestamp.time

pandas.Timestamp.timestamp

pandas.Timestamp.timetuple

pandas.Timestamp.timetz

pandas.Timestamp.to_datetime64

pandas.Timestamp.to_numpy

pandas.Timestamp.to_julian_date

pandas.Timestamp.to_period

pandas.Timestamp.to_pydatetime

pandas.Timestamp.today

pandas.Timestamp.toordinal

pandas.Timestamp.tz_convert

pandas.Timestamp.tz_localize

pandas.Timestamp.tzname

pandas.Timestamp.utcfromtimestamp

pandas.Timestamp.utcnow

pandas.Timestamp.utcoffset

pandas.Timestamp.utctimetuple

pandas.Timestamp.weekday

pandas.arrays.DatetimeArray

`pandas.arrays.ArrowExtensionArray`

`pandas.ArrowDtype`

`pandas.Timestamp`

`pandas.Timestamp.asm8`

`pandas.Timestamp.day`

`pandas.Timestamp.dayofweek`

`pandas.Timestamp.day_of_week`

`pandas.Timestamp.dayofyear`

`pandas.Timestamp.day_of_year`

`pandas.Timestamp.days_in_month`

`pandas.Timestamp.daysinmonth`

`pandas.Timestamp.fold`

`pandas.Timestamp.hour`

`pandas.Timestamp.is_leap_year`

`pandas.Timestamp.is_month_end`

`pandas.Timestamp.is_month_start`

`pandas.Timestamp.is_quarter_end`

`pandas.Timestamp.is_quarter_start`

`pandas.Timestamp.is_year_end`

`pandas.Timestamp.is_year_start`

`pandas.Timestamp.max`

`pandas.Timestamp.microsecond`

`pandas.Timestamp.min`

`pandas.Timestamp.minute`

`pandas.Timestamp.month`

`pandas.Timestamp.nanosecond`

`pandas.Timestamp.quarter`

`pandas.Timestamp.resolution`

`pandas.Timestamp.second`

`pandas.Timestamp.tz`

`pandas.Timestamp.tzinfo`

`pandas.Timestamp.unit`

`pandas.Timestamp.value`

`pandas.Timestamp.week`

`pandas.Timestamp.weekofyear`

`pandas.Timestamp.year`

`pandas.Timestamp.as_unit`

`pandas.Timestamp.astimezone`

`pandas.Timestamp.ceil`

`pandas.Timestamp.combine`

`pandas.Timestamp.ctime`

`pandas.Timestamp.date`

`pandas.Timestamp.day_name`

`pandas.Timestamp.dst`

`pandas.Timestamp.floor`

`pandas.Timestamp.fromordinal`

`pandas.Timestamp.fromtimestamp`

`pandas.Timestamp.isocalendar`

`pandas.Timestamp.isoformat`

`pandas.Timestamp.isoweekday`

`pandas.Timestamp.month_name`

`pandas.Timestamp.normalize`

`pandas.Timestamp.now`

`pandas.Timestamp.replace`

`pandas.Timestamp.round`

`pandas.Timestamp.strftime`

`pandas.Timestamp.strptime`

`pandas.Timestamp.time`

`pandas.Timestamp.timestamp`

`pandas.Timestamp.timetuple`

`pandas.Timestamp.timetz`

`pandas.Timestamp.to_datetime64`

`pandas.Timestamp.to_numpy`

`pandas.Timestamp.to_julian_date`

`pandas.Timestamp.to_period`

`pandas.Timestamp.to_pydatetime`

`pandas.Timestamp.today`

`pandas.Timestamp.toordinal`

`pandas.Timestamp.tz_convert`

`pandas.Timestamp.tz_localize`

`pandas.Timestamp.tzname`

`pandas.Timestamp.utcfromtimestamp`

`pandas.Timestamp.utcnow`

`pandas.Timestamp.utcoffset`

`pandas.Timestamp.utctimetuple`

`pandas.Timestamp.weekday`

`pandas.arrays.DatetimeArray`

`pandas.DatetimeTZDtype`

`pandas.Timedelta`

`pandas.Timedelta.asm8`