日期偏移#

DateOffset#

DateOffset

用于日期范围的标准日期增量类型。

属性#

`DateOffset.freqstr`	返回表示频率的字符串。
`DateOffset.kwds`	返回偏移的额外参数字典。
`DateOffset.name`	返回表示基本频率的字符串。
`DateOffset.nanos`
`DateOffset.normalize`
`DateOffset.rule_code`
`DateOffset.n`
`DateOffset.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`DateOffset.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。

方法#

`DateOffset.copy`()	返回频率的副本。
`DateOffset.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`DateOffset.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`DateOffset.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`DateOffset.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`DateOffset.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`DateOffset.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`DateOffset.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`DateOffset.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

工作日#

工作日

表示可能 n 个工作日的 DateOffset 子类。

别名

BDay

别名 BusinessDay

属性#

`BusinessDay.freqstr`	返回表示频率的字符串。
`BusinessDay.kwds`	返回偏移的额外参数字典。
`BusinessDay.name`	返回表示基本频率的字符串。
`BusinessDay.nanos`
`BusinessDay.normalize`
`BusinessDay.rule_code`
`BusinessDay.n`
`BusinessDay.weekmask`
`BusinessDay.holidays`
`BusinessDay.calendar`

方法#

`BusinessDay.copy`()	返回频率的副本。
`BusinessDay.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`BusinessDay.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BusinessDay.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BusinessDay.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BusinessDay.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BusinessDay.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BusinessDay.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BusinessDay.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

工作小时#

工作小时

表示可能 n 个工作小时的 DateOffset 子类。

属性#

`BusinessHour.freqstr`	返回表示频率的字符串。
`BusinessHour.kwds`	返回偏移的额外参数字典。
`BusinessHour.name`	返回表示基本频率的字符串。
`BusinessHour.nanos`
`BusinessHour.normalize`
`BusinessHour.rule_code`
`BusinessHour.n`
`BusinessHour.start`
`BusinessHour.end`
`BusinessHour.weekmask`
`BusinessHour.holidays`
`BusinessHour.calendar`

方法#

`BusinessHour.copy`()	返回频率的副本。
`BusinessHour.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`BusinessHour.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BusinessHour.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BusinessHour.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BusinessHour.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BusinessHour.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BusinessHour.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BusinessHour.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

CustomBusinessDay#

CustomBusinessDay

表示可能为 n 个自定义工作日的 DateOffset 子类。

别名

CDay

CustomBusinessDay 的别名

属性#

`CustomBusinessDay.freqstr`	返回表示频率的字符串。
`CustomBusinessDay.kwds`	返回偏移的额外参数字典。
`CustomBusinessDay.name`	返回表示基本频率的字符串。
`CustomBusinessDay.nanos`
`CustomBusinessDay.normalize`
`CustomBusinessDay.rule_code`
`CustomBusinessDay.n`
`CustomBusinessDay.weekmask`
`CustomBusinessDay.calendar`
`CustomBusinessDay.holidays`

方法#

`CustomBusinessDay.copy`()	返回频率的副本。
`CustomBusinessDay.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`CustomBusinessDay.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`CustomBusinessDay.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`CustomBusinessDay.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`CustomBusinessDay.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`CustomBusinessDay.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`CustomBusinessDay.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`CustomBusinessDay.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

CustomBusinessHour#

CustomBusinessHour

表示可能为 n 个自定义工作日的 DateOffset 子类。

属性#

`CustomBusinessHour.freqstr`	返回表示频率的字符串。
`CustomBusinessHour.kwds`	返回偏移的额外参数字典。
`CustomBusinessHour.name`	返回表示基本频率的字符串。
`CustomBusinessHour.nanos`
`CustomBusinessHour.normalize`
`CustomBusinessHour.rule_code`
`CustomBusinessHour.n`
`CustomBusinessHour.weekmask`
`CustomBusinessHour.calendar`
`CustomBusinessHour.holidays`
`CustomBusinessHour.start`
`CustomBusinessHour.end`

方法#

`CustomBusinessHour.copy`()	返回频率的副本。
`CustomBusinessHour.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`CustomBusinessHour.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`CustomBusinessHour.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`CustomBusinessHour.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`CustomBusinessHour.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`CustomBusinessHour.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`CustomBusinessHour.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`CustomBusinessHour.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

月底#

`月底`	一个月的最后一天的 DateOffset。

属性#

`MonthEnd.freqstr`	返回表示频率的字符串。
`MonthEnd.kwds`	返回偏移的额外参数字典。
`MonthEnd.name`	返回表示基本频率的字符串。
`MonthEnd.nanos`
`MonthEnd.normalize`
`MonthEnd.rule_code`
`MonthEnd.n`

方法#

`MonthEnd.copy`()	返回频率的副本。
`MonthEnd.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`MonthEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`MonthEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`MonthEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`MonthEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`MonthEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`MonthEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`MonthEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

MonthBegin#

MonthBegin

每月开始的 DateOffset。

属性#

`MonthBegin.freqstr`	返回表示频率的字符串。
`MonthBegin.kwds`	返回偏移的额外参数字典。
`MonthBegin.name`	返回表示基本频率的字符串。
`MonthBegin.nanos`
`MonthBegin.normalize`
`MonthBegin.rule_code`
`MonthBegin.n`

方法#

`MonthBegin.copy`()	返回频率的副本。
`MonthBegin.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`MonthBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`MonthBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`MonthBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`MonthBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`MonthBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`MonthBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`MonthBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

BusinessMonthEnd#

BusinessMonthEnd

DateOffset 在每月最后一个工作日之间递增。

别名

BMonthEnd

BusinessMonthEnd 的别名

属性#

`BusinessMonthEnd.freqstr`	返回表示频率的字符串。
`BusinessMonthEnd.kwds`	返回偏移的额外参数字典。
`BusinessMonthEnd.name`	返回表示基本频率的字符串。
`BusinessMonthEnd.nanos`
`BusinessMonthEnd.normalize`
`BusinessMonthEnd.rule_code`
`BusinessMonthEnd.n`

方法#

`BusinessMonthEnd.copy`()	返回频率的副本。
`BusinessMonthEnd.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`BusinessMonthEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BusinessMonthEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BusinessMonthEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BusinessMonthEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BusinessMonthEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BusinessMonthEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BusinessMonthEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

BusinessMonthBegin#

BusinessMonthBegin

第一个工作日的每月 DateOffset。

别名

BMonthBegin

BusinessMonthBegin 的别名

属性#

`BusinessMonthBegin.freqstr`	返回表示频率的字符串。
`BusinessMonthBegin.kwds`	返回偏移的额外参数字典。
`BusinessMonthBegin.name`	返回表示基本频率的字符串。
`BusinessMonthBegin.nanos`
`BusinessMonthBegin.normalize`
`BusinessMonthBegin.rule_code`
`BusinessMonthBegin.n`

方法#

`BusinessMonthBegin.copy`()	返回频率的副本。
`BusinessMonthBegin.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`BusinessMonthBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BusinessMonthBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BusinessMonthBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BusinessMonthBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BusinessMonthBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BusinessMonthBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BusinessMonthBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

CustomBusinessMonthEnd#

CustomBusinessMonthEnd

表示自定义工作日月份（月）的 DateOffset 子类。

别名

CBMonthEnd

CustomBusinessMonthEnd 的别名

属性#

`CustomBusinessMonthEnd.freqstr`	返回表示频率的字符串。
`CustomBusinessMonthEnd.kwds`	返回偏移的额外参数字典。
`CustomBusinessMonthEnd.m_offset`
`CustomBusinessMonthEnd.name`	返回表示基本频率的字符串。
`CustomBusinessMonthEnd.nanos`
`CustomBusinessMonthEnd.normalize`
`CustomBusinessMonthEnd.rule_code`
`CustomBusinessMonthEnd.n`
`CustomBusinessMonthEnd.weekmask`
`CustomBusinessMonthEnd.calendar`
`CustomBusinessMonthEnd.holidays`

方法#

`CustomBusinessMonthEnd.copy`()	返回频率的副本。
`CustomBusinessMonthEnd.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`CustomBusinessMonthEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`CustomBusinessMonthEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`CustomBusinessMonthEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`CustomBusinessMonthEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`CustomBusinessMonthEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`CustomBusinessMonthEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`CustomBusinessMonthEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

CustomBusinessMonthBegin#

CustomBusinessMonthBegin

表示自定义工作日月份（月）的 DateOffset 子类。

别名

CBMonthBegin

别名 CustomBusinessMonthBegin

属性#

`CustomBusinessMonthBegin.freqstr`	返回表示频率的字符串。
`CustomBusinessMonthBegin.kwds`	返回偏移的额外参数字典。
`CustomBusinessMonthBegin.m_offset`
`CustomBusinessMonthBegin.name`	返回表示基本频率的字符串。
`CustomBusinessMonthBegin.nanos`
`CustomBusinessMonthBegin.normalize`
`CustomBusinessMonthBegin.rule_code`
`CustomBusinessMonthBegin.n`
`CustomBusinessMonthBegin.weekmask`
`CustomBusinessMonthBegin.calendar`
`CustomBusinessMonthBegin.holidays`

方法#

`CustomBusinessMonthBegin.copy`()	返回频率的副本。
`CustomBusinessMonthBegin.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`CustomBusinessMonthBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`CustomBusinessMonthBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`CustomBusinessMonthBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`CustomBusinessMonthBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`CustomBusinessMonthBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`CustomBusinessMonthBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`CustomBusinessMonthBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

半月结束#

半月结束

每月两个 DateOffset，分别在月底和 day_of_month 重复。

属性#

`SemiMonthEnd.freqstr`	返回表示频率的字符串。
`SemiMonthEnd.kwds`	返回偏移的额外参数字典。
`SemiMonthEnd.name`	返回表示基本频率的字符串。
`SemiMonthEnd.nanos`
`SemiMonthEnd.normalize`
`SemiMonthEnd.rule_code`
`SemiMonthEnd.n`
`SemiMonthEnd.day_of_month`

方法#

`SemiMonthEnd.copy`()	返回频率的副本。
`SemiMonthEnd.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`SemiMonthEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`SemiMonthEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`SemiMonthEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`SemiMonthEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`SemiMonthEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`SemiMonthEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`SemiMonthEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

半月开始#

半月开始

每月重复两次，分别在月初和每月第几天。

属性#

`SemiMonthBegin.freqstr`	返回表示频率的字符串。
`SemiMonthBegin.kwds`	返回偏移的额外参数字典。
`SemiMonthBegin.name`	返回表示基本频率的字符串。
`SemiMonthBegin.nanos`
`SemiMonthBegin.normalize`
`SemiMonthBegin.rule_code`
`SemiMonthBegin.n`
`SemiMonthBegin.day_of_month`

方法#

`SemiMonthBegin.copy`()	返回频率的副本。
`SemiMonthBegin.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`SemiMonthBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`SemiMonthBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`SemiMonthBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`SemiMonthBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`SemiMonthBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`SemiMonthBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`SemiMonthBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

周#

周

每周偏移。

属性#

`Week.freqstr`	返回表示频率的字符串。
`Week.kwds`	返回偏移的额外参数字典。
`Week.name`	返回表示基本频率的字符串。
`Week.nanos`
`Week.normalize`
`Week.rule_code`
`Week.n`
`Week.weekday`

方法#

`Week.copy`()	返回频率的副本。
`Week.is_anchored`()	返回一个布尔值，指示频率是否为单位频率（n=1）。
`Week.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Week.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Week.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Week.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Week.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Week.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Week.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

WeekOfMonth#

WeekOfMonth

描述每月日期，例如“每个月的第二周的星期二”。

属性#

`WeekOfMonth.freqstr`	返回表示频率的字符串。
`WeekOfMonth.kwds`	返回偏移的额外参数字典。
`WeekOfMonth.name`	返回表示基本频率的字符串。
`WeekOfMonth.nanos`
`WeekOfMonth.normalize`
`WeekOfMonth.rule_code`
`WeekOfMonth.n`
`WeekOfMonth.week`

方法#

`WeekOfMonth.copy`()	返回频率的副本。
`WeekOfMonth.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`WeekOfMonth.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`WeekOfMonth.weekday`
`WeekOfMonth.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`WeekOfMonth.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`WeekOfMonth.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`WeekOfMonth.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`WeekOfMonth.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`WeekOfMonth.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

LastWeekOfMonth#

LastWeekOfMonth

描述每月最后一周的日期。

属性#

`LastWeekOfMonth.freqstr`	返回表示频率的字符串。
`LastWeekOfMonth.kwds`	返回偏移的额外参数字典。
`LastWeekOfMonth.name`	返回表示基本频率的字符串。
`LastWeekOfMonth.nanos`
`LastWeekOfMonth.normalize`
`LastWeekOfMonth.rule_code`
`LastWeekOfMonth.n`
`LastWeekOfMonth.weekday`
`LastWeekOfMonth.week`

方法#

`LastWeekOfMonth.copy`()	返回频率的副本。
`LastWeekOfMonth.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`LastWeekOfMonth.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`LastWeekOfMonth.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`LastWeekOfMonth.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`LastWeekOfMonth.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`LastWeekOfMonth.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`LastWeekOfMonth.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`LastWeekOfMonth.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

BQuarterEnd#

BQuarterEnd

DateOffset 在每个季度的最后一个工作日之间递增。

属性#

`BQuarterEnd.freqstr`	返回表示频率的字符串。
`BQuarterEnd.kwds`	返回偏移的额外参数字典。
`BQuarterEnd.name`	返回表示基本频率的字符串。
`BQuarterEnd.nanos`
`BQuarterEnd.normalize`
`BQuarterEnd.rule_code`
`BQuarterEnd.n`
`BQuarterEnd.startingMonth`

方法#

`BQuarterEnd.copy`()	返回频率的副本。
`BQuarterEnd.is_anchored`()	返回一个布尔值，指示频率是否为单位频率（n=1）。
`BQuarterEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BQuarterEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BQuarterEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BQuarterEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BQuarterEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BQuarterEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BQuarterEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

BQuarterBegin#

BQuarterBegin

DateOffset 在每个季度的第一个工作日之间递增。

属性#

`BQuarterBegin.freqstr`	返回表示频率的字符串。
`BQuarterBegin.kwds`	返回偏移的额外参数字典。
`BQuarterBegin.name`	返回表示基本频率的字符串。
`BQuarterBegin.nanos`
`BQuarterBegin.normalize`
`BQuarterBegin.rule_code`
`BQuarterBegin.n`
`BQuarterBegin.startingMonth`

方法#

`BQuarterBegin.copy`()	返回频率的副本。
`BQuarterBegin.is_anchored`()	返回一个布尔值，指示频率是否为单位频率（n=1）。
`BQuarterBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BQuarterBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BQuarterBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BQuarterBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BQuarterBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BQuarterBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BQuarterBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

QuarterEnd#

QuarterEnd

DateOffset 在季度结束日期之间递增。

属性#

`QuarterEnd.freqstr`	返回表示频率的字符串。
`QuarterEnd.kwds`	返回偏移的额外参数字典。
`QuarterEnd.name`	返回表示基本频率的字符串。
`QuarterEnd.nanos`
`QuarterEnd.normalize`
`QuarterEnd.rule_code`
`QuarterEnd.n`
`QuarterEnd.startingMonth`

方法#

`QuarterEnd.copy`()	返回频率的副本。
`QuarterEnd.is_anchored`()	返回一个布尔值，指示频率是否为单位频率（n=1）。
`QuarterEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`QuarterEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`QuarterEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`QuarterEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`QuarterEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`QuarterEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`QuarterEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

QuarterBegin#

QuarterBegin

DateOffset 增量，介于季度开始日期之间。

属性#

`QuarterBegin.freqstr`	返回表示频率的字符串。
`QuarterBegin.kwds`	返回偏移的额外参数字典。
`QuarterBegin.name`	返回表示基本频率的字符串。
`QuarterBegin.nanos`
`QuarterBegin.normalize`
`QuarterBegin.rule_code`
`QuarterBegin.n`
`QuarterBegin.startingMonth`

方法#

`QuarterBegin.copy`()	返回频率的副本。
`QuarterBegin.is_anchored`()	返回一个布尔值，指示频率是否为单位频率（n=1）。
`QuarterBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`QuarterBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`QuarterBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`QuarterBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`QuarterBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`QuarterBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`QuarterBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

BYearEnd#

BYearEnd

DateOffset 在一年中最后一个工作日之间递增。

属性#

`BYearEnd.freqstr`	返回表示频率的字符串。
`BYearEnd.kwds`	返回偏移的额外参数字典。
`BYearEnd.name`	返回表示基本频率的字符串。
`BYearEnd.nanos`
`BYearEnd.normalize`
`BYearEnd.rule_code`
`BYearEnd.n`
`BYearEnd.month`

方法#

`BYearEnd.copy`()	返回频率的副本。
`BYearEnd.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`BYearEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BYearEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BYearEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BYearEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BYearEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BYearEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BYearEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

BYearBegin#

BYearBegin

DateOffset 在一年中第一个工作日之间递增。

属性#

`BYearBegin.freqstr`	返回表示频率的字符串。
`BYearBegin.kwds`	返回偏移的额外参数字典。
`BYearBegin.name`	返回表示基本频率的字符串。
`BYearBegin.纳秒`
`BYearBegin.规范化`
`BYearBegin.规则代码`
`BYearBegin.n`
`BYearBegin.月份`

方法#

`BYearBegin.copy`()	返回频率的副本。
`BYearBegin.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`BYearBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`BYearBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`BYearBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`BYearBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`BYearBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`BYearBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`BYearBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

YearEnd#

YearEnd

DateOffset 在日历年末日期之间递增。

属性#

`YearEnd.freqstr`	返回表示频率的字符串。
`YearEnd.kwds`	返回偏移的额外参数字典。
`YearEnd.name`	返回表示基本频率的字符串。
`YearEnd.纳秒`
`YearEnd.规范化`
`YearEnd.规则代码`
`YearEnd.n`
`YearEnd.月份`

方法#

`YearEnd.copy`()	返回频率的副本。
`YearEnd.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`YearEnd.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`YearEnd.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`YearEnd.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`YearEnd.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`YearEnd.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`YearEnd.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`YearEnd.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

YearBegin#

YearBegin

DateOffset 在日历年开始日期之间递增。

属性#

`YearBegin.freqstr`	返回表示频率的字符串。
`YearBegin.kwds`	返回偏移的额外参数字典。
`YearBegin.name`	返回表示基本频率的字符串。
`YearBegin.nanos`
`YearBegin.normalize`
`YearBegin.rule_code`
`YearBegin.n`
`YearBegin.month`

方法#

`YearBegin.copy`()	返回频率的副本。
`YearBegin.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`YearBegin.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`YearBegin.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`YearBegin.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`YearBegin.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`YearBegin.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`YearBegin.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`YearBegin.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

FY5253#

FY5253

描述 52-53 周财政年度。

属性#

`FY5253.freqstr`	返回表示频率的字符串。
`FY5253.kwds`	返回偏移的额外参数字典。
`FY5253.name`	返回表示基本频率的字符串。
`FY5253.nanos`
`FY5253.normalize`
`FY5253.rule_code`
`FY5253.n`
`FY5253.startingMonth`
`FY5253.variation`
`FY5253.weekday`

方法#

`FY5253.copy`()	返回频率的副本。
`FY5253.get_rule_code_suffix`()
`FY5253.get_year_end`(dt)
`FY5253.is_anchored`()	返回一个布尔值，指示频率是否为单位频率（n=1）。
`FY5253.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`FY5253.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`FY5253.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`FY5253.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`FY5253.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`FY5253.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`FY5253.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

FY5253Quarter#

FY5253Quarter

DateOffset 在 52-53 周财政年度的商业季度日期之间递增。

属性#

`FY5253Quarter.freqstr`	返回表示频率的字符串。
`FY5253Quarter.kwds`	返回偏移的额外参数字典。
`FY5253Quarter.name`	返回表示基本频率的字符串。
`FY5253Quarter.nanos`
`FY5253Quarter.normalize`
`FY5253Quarter.rule_code`
`FY5253Quarter.n`
`FY5253Quarter.qtr_with_extra_week`
`FY5253Quarter.startingMonth`
`FY5253Quarter.variation`
`FY5253Quarter.weekday`

方法#

`FY5253Quarter.copy`()	返回频率的副本。
`FY5253Quarter.get_rule_code_suffix`()
`FY5253Quarter.get_weeks`(dt)
`FY5253Quarter.is_anchored`()	返回一个布尔值，指示频率是否为单位频率（n=1）。
`FY5253Quarter.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`FY5253Quarter.year_has_extra_week`(dt)
`FY5253Quarter.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`FY5253Quarter.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`FY5253Quarter.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`FY5253Quarter.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`FY5253Quarter.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`FY5253Quarter.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

Easter#

复活节

使用 dateutil 中定义的逻辑计算复活节假期的 DateOffset。

属性#

`Easter.freqstr`	返回表示频率的字符串。
`Easter.kwds`	返回偏移的额外参数字典。
`Easter.name`	返回表示基本频率的字符串。
`Easter.nanos`
`Easter.normalize`
`Easter.rule_code`
`Easter.n`

方法#

`Easter.copy`()	返回频率的副本。
`Easter.is_anchored`()	(已弃用) 返回一个布尔值，表示频率是否为单位频率 (n=1)。
`Easter.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Easter.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Easter.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Easter.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Easter.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Easter.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Easter.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

Tick#

Tick

属性#

`Tick.delta`
`Tick.freqstr`	返回表示频率的字符串。
`Tick.kwds`	返回偏移的额外参数字典。
`Tick.name`	返回表示基本频率的字符串。
`Tick.nanos`	返回纳秒总数的整数。
`Tick.normalize`
`Tick.rule_code`
`Tick.n`

方法#

`Tick.copy`()	返回频率的副本。
`Tick.is_anchored`()	(已弃用) 返回 False。
`Tick.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Tick.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Tick.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Tick.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Tick.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Tick.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Tick.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

天#

天

偏移 n 天。

属性#

`Day.delta`
`Day.freqstr`	返回表示频率的字符串。
`Day.kwds`	返回偏移的额外参数字典。
`Day.name`	返回表示基本频率的字符串。
`Day.nanos`	返回纳秒总数的整数。
`Day.normalize`
`Day.rule_code`
`Day.n`

方法#

`Day.copy`()	返回频率的副本。
`Day.is_anchored`()	(已弃用) 返回 False。
`Day.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Day.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Day.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Day.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Day.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Day.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Day.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

小时#

`小时`	偏移 `n` 小时。

属性#

`Hour.delta`
`Hour.freqstr`	返回表示频率的字符串。
`Hour.kwds`	返回偏移的额外参数字典。
`Hour.name`	返回表示基本频率的字符串。
`Hour.nanos`	返回纳秒总数的整数。
`Hour.normalize`
`Hour.rule_code`
`Hour.n`

方法#

`Hour.copy`()	返回频率的副本。
`Hour.is_anchored`()	(已弃用) 返回 False。
`Hour.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Hour.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Hour.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Hour.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Hour.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Hour.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Hour.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

分钟#

`分钟`	偏移 `n` 分钟。

属性#

`Minute.delta`
`Minute.freqstr`	返回表示频率的字符串。
`Minute.kwds`	返回偏移的额外参数字典。
`Minute.name`	返回表示基本频率的字符串。
`Minute.nanos`	返回纳秒总数的整数。
`Minute.normalize`
`Minute.rule_code`
`Minute.n`

方法#

`Minute.copy`()	返回频率的副本。
`Minute.is_anchored`()	(已弃用) 返回 False。
`Minute.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Minute.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Minute.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Minute.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Minute.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Minute.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Minute.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

秒#

秒

偏移 n 秒。

属性#

`Second.delta`
`Second.freqstr`	返回表示频率的字符串。
`Second.kwds`	返回偏移的额外参数字典。
`Second.name`	返回表示基本频率的字符串。
`Second.nanos`	返回纳秒总数的整数。
`秒.normalize`
`秒.rule_code`
`秒.n`

方法#

`秒.copy`()	返回频率的副本。
`秒.is_anchored`()	(已弃用) 返回 False。
`秒.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`秒.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`秒.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`秒.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`秒.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`秒.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`秒.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

毫秒#

`毫秒`	偏移 `n` 毫秒。

属性#

`毫秒.delta`
`毫秒.freqstr`	返回表示频率的字符串。
`毫秒.kwds`	返回偏移的额外参数字典。
`毫秒.name`	返回表示基本频率的字符串。
`毫秒.nanos`	返回纳秒总数的整数。
`毫秒.normalize`
`毫秒.rule_code`
`毫秒.n`

方法#

`毫秒.copy`()	返回频率的副本。
`毫秒.is_anchored`()	(已弃用) 返回 False。
`毫秒.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Milli.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Milli.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Milli.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Milli.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Milli.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Milli.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

微秒#

`微秒`	偏移 `n` 微秒。

属性#

`Micro.delta`
`Micro.freqstr`	返回表示频率的字符串。
`Micro.kwds`	返回偏移的额外参数字典。
`Micro.name`	返回表示基本频率的字符串。
`Micro.nanos`	返回纳秒总数的整数。
`Micro.normalize`
`Micro.rule_code`
`Micro.n`

方法#

`Micro.copy`()	返回频率的副本。
`Micro.is_anchored`()	(已弃用) 返回 False。
`Micro.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Micro.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Micro.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Micro.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Micro.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Micro.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Micro.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

纳秒#

`纳秒`	偏移量 `n` 纳秒。

属性#

`Nano.delta`
`Nano.freqstr`	返回表示频率的字符串。
`Nano.kwds`	返回偏移的额外参数字典。
`Nano.name`	返回表示基本频率的字符串。
`Nano.nanos`	返回纳秒总数的整数。
`Nano.normalize`
`Nano.rule_code`
`Nano.n`

方法#

`Nano.copy`()	返回频率的副本。
`Nano.is_anchored`()	(已弃用) 返回 False。
`Nano.is_on_offset`(dt)	返回一个布尔值，表示时间戳是否与该频率相交。
`Nano.is_month_start`(ts)	返回一个布尔值，表示时间戳是否发生在月初。
`Nano.is_month_end`(ts)	返回一个布尔值，表示时间戳是否发生在月末。
`Nano.is_quarter_start`(ts)	返回一个布尔值，表示时间戳是否发生在季度开始。
`Nano.is_quarter_end`(ts)	返回一个布尔值，表示时间戳是否发生在季度结束。
`Nano.is_year_start`(ts)	返回一个布尔值，表示时间戳是否发生在年份开始。
`Nano.is_year_end`(ts)	返回一个布尔值，表示时间戳是否发生在年份结束。

频率#

to_offset(freq[, is_period])

从字符串或 datetime.timedelta 对象返回 DateOffset 对象。