文章目录

一、时间戳
- 1. unit 参数是 s
- 2. year、month、day、hour、minute、second、microsecond 单独设置时间
二、通过时间间隔实现 datetime 加减
三、时间转化
- 1. 处理各种输入格式
- 2. 将字符串转 datetime
- 3. 除了可以将文本数据转为时间戳外，还可以将 unix 时间转为时间戳。
- 4. 自动识别异常
- 5. 配合 unit 参数，使用非 unix 时间
- 6. 不可转换日期/时间
四、时期频率转换
五、shift() 时间频率进行移位

在开始之前，我们先导入 numpy 和 pandas 库，同时导入 python 内置的模块。

import pandas as pd
import numpy as np
import time
import datetime

一、时间戳

时间戳是 python datetime 的替代品。
时间戳相当于 python 的 Datetime，在大多数情况下可以与之互换。
该类型用于组成 DatetimeIndex 的条目，以及 pandas 中其他面向时间序列的数据结构。
其语法模板如下：

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

其部分参数含义如下：
ts_input 表示要转换为时间戳的值。
freq 表示时间戳将具有的偏移量。
unit 表示用于转换的单位。
我们可以转换类似日期时间的字符串，默认为 yyyy-mm-dd hh:mm:ss 格式。
示例 1：时间不设置的话默认为 0。

pd.Timestamp('2022-01-01')
#Timestamp('2022-01-01 00:00:00')

示例 2：

pd.Timestamp('2021-12-15 12')
#Timestamp('2021-12-15 12:00:00')

示例 3：如果我们输入的格式不满足上面的默认格式会进行自动调整。

pd.Timestamp('01-01-2022 12')
#Timestamp('2022-01-01 12:00:00')

示例 4：日期不设置的话默认为 1。

pd.Timestamp('2022-01')
#Timestamp('2022-01-01 00:00:00')

示例 5：

pd.Timestamp('2022') 
#Timestamp('2022-01-01 00:00:00')

这里需要注意的是，我们不能将错误日期转换为 Timestamp，否则会出现 ValueError: could not convert string to Timestamp 错误。
错误日期只要就是指不符合日期规范的，比如，平年的 2 月有 29 天等等。

pd.Timestamp('2022-01-50')
pd.Timestamp('2022-02-31')
pd.Timestamp('2022-02-29')

1. unit 参数是 s

这将转换以秒为单位表示 Unix 历元的浮点值。
1970 年 1 月 1 日这个时间正是 Unix 系统的起始时间。
具体可见如下示例。
示例 1：我们可以通过 time.time() 返回从 1970 年 1 月 1 日到现在一共有多少秒。

time.time()
#1650616591.3381748

示例 2：我们可以将其转换为 Unix 历元的浮点值。

pd.Timestamp(time.time(), unit="s")
#Timestamp('2022-04-22 08:36:15.079070091')

示例 3：也可以将其强制类型转换为整型。

pd.Timestamp(int(time.time()), unit="s")
#Timestamp('2022-04-22 08:36:56')

示例 4：

my_time = time.time()
print(my_time)
pd.Timestamp(my_time)
#1650616682.428626
#Timestamp('1970-01-01 00:00:01.650616682')

示例 5：也可以对他的数值进行设定。

pd.Timestamp(2)
#Timestamp('1970-01-01 00:00:00.000000002')

2. year、month、day、hour、minute、second、microsecond 单独设置时间

这里我们需要注意的是，最小的到 day。
示例 1：

pd.Timestamp(2022, 1, 10, 12)
#Timestamp('2022-01-10 12:00:00')

示例 2：在 pd.Timestamp() 中要注意一定的顺序问题，不然容易报错。

pd.Timestamp(1, 2022, 10, 12) 
#ValueError: month must be in 1..12

示例 3：我们可以设置年月日的具体数据，时间不设置的话就默认为 0。

pd.Timestamp(year=2022,day=10, month=1)
#Timestamp('2022-01-10 00:00:00')

示例 4：

pd.Timestamp(year=2022, month=1,day=1)
#Timestamp('2022-01-01 00:00:00')

示例 5：

pd.Timestamp(year=2022, month=1, day=10, hour=12)
#Timestamp('2022-01-10 12:00:00')

示例 6：

pd.Timestamp(year=2022, month=1, day=10)
#Timestamp('2022-01-10 00:00:00')

总结：Timestamp 可以将字符串或者 unix 时间转化为 pandas对应的时间戳。

二、通过时间间隔实现 datetime 加减

表示持续时间，即两个日期或时间之间的差异。
相当于 python 的 datetime.timedelta，在大多数情况下可以与之互换。
其语法模板如下：

pd.Timedelta(value=<object object at 0x000001BE55DCFE80>,unit=None,**kwargs）

其部分参数含义如下：
value 表示数值或者 Timedelta。
unit 表示如果输入是整数，则表示输入的单位 ‘M’,‘W’, ‘D’, ‘T’, ‘S’。
具体可见如下示例。
示例 1：老例子了，不多叙述了。

ts = pd.Timestamp('2022-01-01 12')
ts
#Timestamp('2022-01-01 12:00:00')

示例 2：我们可以在 ts 的基础上使用 pd.Timedelta() 函数减少一天。

ts + pd.Timedelta(-1, "D")
#Timestamp('2021-12-31 12:00:00')

示例 3：计算时间间隔。

td = pd.Timedelta(days=5, minutes=50, seconds=20)
td
#Timedelta('5 days 00:50:20')

示例 4：时间相加运算。

ts + td
Timestamp('2022-01-06 12:50:20')

示例 5：可以使用 td.total_seconds() 将 td 转换为秒钟数。

td.total_seconds()
#435020.0

示例 6：返回现在的时间。

datetime.datetime.now()
#datetime.datetime(2023, 2, 22, 15, 22, 19, 554438)

示例 7：我们可以设置时区，例如，中国上海所在的时区，我们可以设置为 tz=“Asia/Shanghai”。

pd.Timestamp(int(time.time()) + 435020, unit="s", tz="Asia/Shanghai")
#Timestamp('2022-04-27 17:41:29+0800', tz='Asia/Shanghai')

示例 8：将其强制转换为整型。

pd.Timestamp(int(time.time()), unit="s", tz="Asia/Shanghai")
Timestamp('2022-04-22 16:51:25+0800', tz='Asia/Shanghai')

示例 9：

time.time()+ td.total_seconds()
pd.Timestamp(int(time.time()+ td.total_seconds()),unit='s')
#Timestamp('2022-04-27 09:38:11')

示例 10：我们可以取得当前时间，计算前时间往后 100 天的日期，并只显示年月日。

import datetime
now = datetime.datetime.now()
print(now)
dt = now + datetime.timedelta(days=100)
print(dt,type(dt))
dt.strftime('%Y-%m-%d')
#2022-04-22 16:54:11.351536
#2022-07-31 16:54:11.351536 <class 'datetime.datetime'>
#'2022-07-31'

三、时间转化

我们可以使用 to_datetime 转换时间戳。
通过 to_datetime 函数，我们可以快速将文本数据转为时间戳。
当传递一个 Series 时，它会返回一个 Series（具有相同的索引），而类似列表的则转换为 DatetimeIndex。
其语法模板如下：

to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False, utc=None, format=None, unit=None, infer_datetime_format=False, origin='unix')

其部分参数含义如下：
arg 表示要转换为日期时间的对象。
errors 表示错误处理。
（1） If ‘raise’，将引发异常。
（2） If ‘coerce’，无效的转换，使用 NaN。
（3） If ‘ignore’，无效的转换，将使用输入的数据。
dayfirst 表示转换时指定日期分析顺序 yearfirst。
utc 表示控制与时区相关的解析、本地化和转换（忽略）。
format 表示用于分析时间的 strftime，例如 “%d/%m/%Y”，自定义格式。
unit 表示 D,s,ms 将时间戳转 datetime。
origin 表示定义参考日期。数值将被解析为自该参考日期起的单位数。

1. 处理各种输入格式

从一个数据帧的多个列中组装日期时间。
这些键可以是常见的缩写，如 [‘year’、‘month’、‘day’、‘minute’、‘second’、‘ms’、‘us’、‘ns’]），也可以是相同的复数形式。
具体可见如下示例。
示例 1：我们可以通过 pd.DataFrame() 存储时间数据。

df = pd.DataFrame({'year': [2015, 2016],'month': [2, 3],'day': [4, 5]})
df
#year	month	day
#0	2015	2	4
#1	2016	3	5

示例 2：

pd.to_datetime(df)
#0   2015-02-04
#1   2016-03-05
#dtype: datetime64[ns]

2. 将字符串转 datetime

示例 1：

pd.to_datetime(['11-12-2021'])
#DatetimeIndex(['2021-11-12'], dtype='datetime64[ns]', freq=None)

示例 2：

pd.to_datetime(["2005/11/23", "2010.12.31"])
#DatetimeIndex(['2005-11-23', '2010-12-31'], dtype='datetime64[ns]', freq=None)

3. 除了可以将文本数据转为时间戳外，还可以将 unix 时间转为时间戳。

示例 1：

pd.to_datetime([1349720105, 1349806505, 1349892905], unit="s")
#DatetimeIndex(['2012-10-08 18:15:05', '2012-10-09 18:15:05',
#               '2012-10-10 18:15:05'],
#              dtype='datetime64[ns]', freq=None)

示例 2：

pd.to_datetime([1349720105100, 1349720105200, 1349720105300], unit="ms")
#DatetimeIndex(['2012-10-08 18:15:05.100000', '2012-10-08 18:15:05.200000',
#               '2012-10-08 18:15:05.300000'],
#              dtype='datetime64[ns]', freq=None)

4. 自动识别异常

譬如我们输入 210605 这一串数字，直接输出的结果似乎有点问题。

pd.to_datetime('210605')
#Timestamp('2005-06-21 00:00:00')

我们可以将 yearfirst 设置为 True，便得到了我们想要的时间。

pd.to_datetime('210605',yearfirst=True)
#Timestamp('2021-06-05 00:00:00')

5. 配合 unit 参数，使用非 unix 时间

示例 1：origin 参考起始时间 d（天数），生成后面的时间。

pd.to_datetime([1, 2, 3], unit='d', origin=pd.Timestamp('2020-01-11'))
#DatetimeIndex(['2020-01-12', '2020-01-13', '2020-01-14'], dtype='datetime64[ns]', freq=None)

示例 2：origin 参考起始时间 h（小时），生成后面的时间。

pd.to_datetime([1, 2, 3], unit='h', origin=pd.Timestamp('2020-01'))
#DatetimeIndex(['2020-01-01 01:00:00', '2020-01-01 02:00:00',
#               '2020-01-01 03:00:00'],
#              dtype='datetime64[ns]', freq=None)

示例 3：origin 参考起始时间 m（分钟），生成后面的时间。

pd.to_datetime([1, 2, 3], unit='m', origin=pd.Timestamp('2020-01'))
#DatetimeIndex(['2020-01-01 00:01:00', '2020-01-01 00:02:00',
#               '2020-01-01 00:03:00'],
#              dtype='datetime64[ns]', freq=None)

示例 4：origin 参考起始时间 s（秒钟），生成后面的时间。

pd.to_datetime([1, 2, 3], unit='s', origin=pd.Timestamp('2020-01'))
#DatetimeIndex(['2020-01-01 00:00:01', '2020-01-01 00:00:02',
#               '2020-01-01 00:00:03'],
#              dtype='datetime64[ns]', freq=None)

6. 不可转换日期/时间

如果日期不符合时间戳限制，则传递 errors=‘ignore’ 将返回原始输入，而不是引发任何异常。
除了将非日期（或不可解析的日期）强制传递给 NaT 之外，传递 errors=‘coerce’ 还会将越界日期强制传递给 NaT。
errors`：错误处理。
（1） If ‘raise’，将引发异常。
（2） If ‘coerce’，无效的转换，使用 NaT。
（3） If ‘ignore’，无效的转换，将使用输入的数据。
示例 1：ParserError: year 120211204 is out of range: 120211204。

pd.to_datetime(['120211204','20210101'])

示例 2：如果出现无效的转换，将使用输入的数据。

pd.to_datetime(['202102.01','2021.02.01'], errors="ignore")
#Index(['202102.01', '2021.02.01'], dtype='object')

示例 3：无效的转换，使用 NaT。

pd.to_datetime(['120211204','2021.02.01'], errors="coerce")
#DatetimeIndex(['NaT', '2021-02-01'], dtype='datetime64[ns]', freq=None)

示例 4：可以自动识别。

pd.to_datetime(pd.Series(["Jul 31, 2018", "2018.05.10", None]))
#0   2018-07-31
#1   2018-05-10
#2          NaT
#dtype: datetime64[ns]

对于 float arg，可能会发生精确舍入。要防止意外行为，请使用固定宽度的精确类型。

四、时期频率转换

其语法模板如下：

asfreq(freq, method=None, how=None, normalize=False, fill_value=None)

我们可以将时间序列转换为指定的频率。
如果此数据帧的索引是 PeriodIndex，则新索引是使用 PeriodIndex 转换原始索引的结果。
否则，新指数将相当于 pd。date_range（start，end，freq=freq），其中 start 和 end 分别是原始索引中的第一个和最后一个条目。
与新索引中未出现在原始索引中的任何时间步对应的值将为空（NaN），除非提供了填充此类未知值的方法。
示例 1：我们可以使用 asfreq 进行时期频率转换，我们先以 D 为初始时期频率。

ts = pd.Series(np.random.rand(4),index = pd.date_range('20170101','20170104'))
print(ts)
#2017-01-01    0.212259
#2017-01-02    0.475196
#2017-01-03    0.186119
#2017-01-04    0.355026
#Freq: D, dtype: float64

我们改变频率，这里是将 D 改为 4H（每隔 4H 生成一个），由于我们最开始没有设置时间，因此他们默认是 0，除 0 以外的时间均变成 NaN。

ts.asfreq('4H')
#2017-01-01 00:00:00    0.212259
#2017-01-01 04:00:00         NaN
#2017-01-01 08:00:00         NaN
#2017-01-01 12:00:00         NaN
#2017-01-01 16:00:00         NaN
#2017-01-01 20:00:00         NaN
#2017-01-02 00:00:00    0.475196
#2017-01-02 04:00:00         NaN
#2017-01-02 08:00:00         NaN
#2017-01-02 12:00:00         NaN
#2017-01-02 16:00:00         NaN
#2017-01-02 20:00:00         NaN
#2017-01-03 00:00:00    0.186119
#2017-01-03 04:00:00         NaN
#2017-01-03 08:00:00         NaN
#2017-01-03 12:00:00         NaN
#2017-01-03 16:00:00         NaN
#2017-01-03 20:00:00         NaN
#2017-01-04 00:00:00    0.355026
Freq: 4H, dtype: float64

我们可以使用 method 进入插值模式，None 代表不插值，ffill 表示用之前值填充，bfill 表示用之后值填充。
先以 ffill 为例。

ts.asfreq('4H', method = 'ffill')
#2017-01-01 00:00:00    0.212259
#2017-01-01 04:00:00    0.212259
#2017-01-01 08:00:00    0.212259
#2017-01-01 12:00:00    0.212259
#2017-01-01 16:00:00    0.212259
#2017-01-01 20:00:00    0.212259
#2017-01-02 00:00:00    0.475196
#2017-01-02 04:00:00    0.475196
#2017-01-02 08:00:00    0.475196
#2017-01-02 12:00:00    0.475196
#2017-01-02 16:00:00    0.475196
#2017-01-02 20:00:00    0.475196
#2017-01-03 00:00:00    0.186119
#32017-01-03 04:00:00    0.186119
#2017-01-03 08:00:00    0.186119
#2017-01-03 12:00:00    0.186119
#2017-01-03 16:00:00    0.186119
#2017-01-03 20:00:00    0.186119
#2017-01-04 00:00:00    0.355026
#Freq: 4H, dtype: float64

然后以 bfill 为例。

ts.asfreq('4H', method = 'bfill')
#2017-01-01 00:00:00    0.212259
#2017-01-01 04:00:00    0.475196
#2017-01-01 08:00:00    0.475196
#2017-01-01 12:00:00    0.475196
#2017-01-01 16:00:00    0.475196
#2017-01-01 20:00:00    0.475196
#2017-01-02 00:00:00    0.475196
#2017-01-02 04:00:00    0.186119
#2017-01-02 08:00:00    0.186119
#2017-01-02 12:00:00    0.186119
#2017-01-02 16:00:00    0.186119
#2017-01-02 20:00:00    0.186119
#2017-01-03 00:00:00    0.186119
#2017-01-03 04:00:00    0.355026
#2017-01-03 08:00:00    0.355026
#2017-01-03 12:00:00    0.355026
#2017-01-03 16:00:00    0.355026
#2017-01-03 20:00:00    0.355026
#2017-01-04 00:00:00    0.355026
#Freq: 4H, dtype: float64

五、shift() 时间频率进行移位

他可以按所需的时段数和可选的时间频率进行移位索引。
其语法模板如下：

shift(periods=1, freq=None, axis=0, fill_value=None)

如果未传递 freq，则在不重新调整数据的情况下移动索引。如果传递了 freq（在这种情况下，索引必须是 date 或 datetime，否则将引发 NotImplementedError），只要在索引中设置了 freq 或推断的 _freq 属性，就可以推断 freq。
其参数含义如下：
periods 表示要转换的时段数。可以是正面的，也可以是负面的。
freq 表示如果指定了 freq，则索引值会移位，但数据不会重新对齐。也就是说，如果要在移动时扩展索引并保留原始数据
axis:{0 or ‘index’, 1 or ‘columns’, None} 表示转换方向。
fill_value 表示填充值。
示例 1：我们生成一个 4 行 4 列的随机数数组，行标签是 20210101 到 20210104，列标签是 A、B、C、D。

df = pd.DataFrame(np.random.rand(16).reshape((4,4)), index = pd.date_range('20210101','20210104'),columns=list('ABCD'))
df
#                  A	       B	       C	       D
#2021-01-01	0.435600	0.899540	0.146171	0.543191
#2021-01-02	0.978700	0.824476	0.015656	0.862976
#2021-01-03	0.069611	0.503938	0.215017	0.677024
#2021-01-04	0.112235	0.352456	0.026572	0.103668

我们将 periods 设置为 2，为正数，数值后移（滞后），模式为行。

df.shift(periods=2)
#                  A	       B	       C	       D
#2021-01-01	     NaN	     NaN	     NaN	      NaN
#2021-01-02	     NaN	     NaN	     NaN	      NaN
#2021-01-03	  0.4356	 0.899540	0.146171	  0.543191
#2021-01-04	  0.9787	 0.824476	0.015656	  0.862976

我们将 periods 设置为 1，正数，数值后移（滞后），模式为列。

df.shift(periods=1, axis="columns")
#                  A	       B	       C	       D
#2021-01-01		  NaN	0.435600	0.899540	0.146171
#2021-01-02		  NaN	0.978700	0.824476	0.015656
#2021-01-03		  NaN	0.069611	0.503938	0.215017
#2021-01-04	   	  NaN	0.112235	0.352456	0.026572

我们将 periods 设置为 3，正数，数值后移，NaN 填充为 0。

df.shift(periods=3, fill_value=0)
#                  A	       B	       C	       D
#2021-01-01	  0.0000	 0.00000	0.000000	0.000000
#2021-01-02	  0.0000	 0.00000	0.000000	0.000000
#2021-01-03	  0.0000	 0.00000	0.000000	0.000000
#2021-01-04	  0.4356	 0.89954	0.146171	0.543191

当我们设置 freq 时，表示对时间索引移动。

df.shift(periods=3, freq="D")
#                  A	       B	       C	       D
#2021-01-04	0.435600	0.899540	0.146171	0.543191
#2021-01-05	0.978700	0.824476	0.015656	0.862976
#2021-01-06	0.069611	0.503938	0.215017	0.677024
#2021-01-07	0.112235	0.352456	0.026572	0.103668

我们可以计算变化百分比，这里计算：该时间戳与上一个时间戳相比，变化百分比。

per = df/df.shift(1) - 1
print(per)
#                  A	       B	       C	       D
#2021-01-01       NaN       NaN        NaN       NaN
#2021-01-02  1.246787 -0.083447  -0.892891  0.588714
#2021-01-03 -0.928874 -0.388779  12.733554 -0.215477
#2021-01-04  0.612317 -0.300595  -0.876419 -0.846877