上一篇：时间日期处理-mysql

文章目录

1.日期时间类型
2. Date times介绍

2.1 时间点的创建

2.1.1 to_datetime()

2.1.1.1 参数及返回形式
2.1.1.2 精度及范围限制

2.2 Timestamp&DatetimeIndex
2.3 date_range()

2.2 索引及属性

2.2.1索引切片
2.2.2 属性

3. Time deltas及Data offsets介绍
4. resample重采样
5. 窗口函数

5.1 rolling函数
5.2 expanding函数

6. 其他常用函数

1.日期时间类型

名称	描述	元素类型	数组类型	创建方式
Date times	描述特定日期或时间点，类似于datetime库的datetime类型	Timestamp	DatetimeIndex	to_datetime 或 date_range
Time deltas	绝对时间差，一段时间的绝对大小类似于datetime库的timedeltall类型（与冬/夏令时有关）	Timedelta	TimedeltaIndex	to_timedelta或timedelta_range
Time spans	由时间点定义的一段时期,与frequency间隔有关	Period	PeriodIndex	Period或Period_range
Data offsets	相对时间差，一段时间的相对大小 (与冬/夏令时无关)	None	None	DataOffset

2. Date times介绍

2.1 时间点的创建

2.1.1 to_datetime()

2.1.1.1 参数及返回形式

pandas.to_datetime() 将给定数据转化为日期时间。

pandas.to_datetime(arg, errors=‘raise’, dayfirst=False, yearfirst=False, utc=None, format=None, exact=True, unit=None, infer_datetime_format=False, origin=‘unix’, cache=True)

常用参数	说明	备注
arg	要转化为日期时间的对象	可以是 int, float, str, datetime（datetime第三方库）, list, tuple, 1-d array, Series,DataFrame/dict-like 形式
errors	错误处理方式	‘raise’:解析失败将报错 ’coerce’ 解析失败将被设置为时间数据的null值：NaT ’ignore’:解析失败将返回原输入值。
dayfirst	如果arg是str或类似列表，指定日期解析顺序;bool值	True:将第一位解析为天，如10/11/12将被解析为2012-11-10
yearfirst	如果arg是str或类似列表，则指定日期解析顺序；bool值	True:将第一位解析为年，如10/11/12将被解析为2010-11-12
format	明示arg的形式	常见的如%d %m %Y

pandas.to_datetime()能够解析大部分人类可理解的日期表示；如果因为格式解析失败，可使用format参数强行配置，format可选项看这里

# 如下形式都能正确解析为同一日期
In[15]: pd.to_datetime('2020.1.1')	pd.to_datetime('2020-1-1')pd.to_datetime('2020/1/1')pd.to_datetime('20200101')pd.to_datetime('2020.0101')
Out[15]:Timestamp('2020-01-01 00:00:00')# 也能解析unix时间戳
In [36]: pd.to_datetime(1490195805,unit='s')
Out[36]:Timestamp('2017-03-22 15:16:45')In [39]:n pd.to_datetime(1490195805433502912,unit='ns')
Out[39]:Timestamp('2017-03-22 15:16:45.433502912')

# 如下形式解析会报错
In[16]:pd.to_datetime('2020`1`1')pd.to_datetime('2020.1 1')pd.to_datetime('1 1.2020')
# 可利用format参数强行配置
In [20]:pd.to_datetime('2020`1`1',format='%Y`%m`%d')
Out[20]:Timestamp('2020-01-01 00:00:00')In [21]:pd.to_datetime('2020.1 1',format='%Y.%m %d')
Out[21]:Timestamp('2020-01-01 00:00:00')

解析失败的可以通过设置参数errors忽略错误，使其他能够正常解析的对象正常显示

# errors='coerce'解析错误将返回NaT
In [30]: pd.to_datetime(['2020`1`1','2020/1/1'],errors='coerce')           
Out[30]:DatetimeIndex(['NaT', '2020-01-01'], dtype='datetime64[ns]', freq=None)
# errors='ignore'解析错误将返回原值
In [23]: pd.to_datetime('2020`1`1',errors='ignore')
Out[23]:'2020`1`1'

函数返回形式取决于输入形式

输入形式（也就是参数arg形式）	返回形式
list-like类似列表形式	返回DatetimeIndex
Series	返回Series of datetime64 dtype
标量值	返回Timestamp

# 类似列表形式
In [2]: d = ['20100213','20190918','20200625']pd.to_datetime(d)
Out[2]:DatetimeIndex(['2010-02-13', '2019-09-18', '2020-06-25'], dtype='datetime64[ns]', freq=None)# Series
In [3]: s = pd.Series(['3/11/2000', '3/12/2000', '3/13/2000'])s
Out[3]:0    3/11/20001    3/12/20002    3/13/2000dtype: objectIn [4]: pd.to_datetime(s)
Out[4]:0   2000-03-111   2000-03-122   2000-03-13dtype: datetime64[ns]# 标量
In [5]: pd.to_datetime('20200101')
Out[5]:Timestamp('2020-01-01 00:00:00')# DataFrame多个列组合成一个日期形式
In [34]: df = pd.DataFrame({'year': [2015, 2016],'month': [2, 3],                   'day': [4, 5]})pd.to_datetime(df)
Out[34]:0   2015-02-041   2016-03-05dtype: datetime64[ns]

2.1.1.2 精度及范围限制

Timestamp的精度最小可以精确到ns（纳秒)
同时，它带来的范围代价只有大约584年可用的，从1677年到2262年；
可以通过pd.Timestamp.min及pd.Timestamp.max查看时间范围

In [41]:pd.Timestamp.min
Out[41]:Timestamp('1677-09-21 00:12:43.145225')In [42]:max pd.Timestamp.max
Out[42]:Timestamp('2262-04-11 23:47:16.854775807')

2.2 Timestamp&DatetimeIndex

Timestamp也接受单个str输入，将其转换为日期时间格式。

In [59]: pd.Timestamp('2020-06-26')
Out[59]:Timestamp('2020-06-26 00:00:00')In [60]: pd.to_datetime('2020-06-26')
Out[60]:Timestamp('2020-06-26 00:00:00')

DatetimeIndex也可以接受列表形式输入，转换为DatetimeIndex形式

In [61]: pd.DatetimeIndex(['2018-01-01', '2018-01-03', '2018-01-05'])
Out[61]:DatetimeIndex(['2018-01-01', '2018-01-03', '2018-01-05'], dtype='datetime64[ns]', freq=None)

2.3 date_range()

返回一个固定间隔的DatetimeIndex.

pandas.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)

参数start、end、periods、freq只要确定了其中三个，另外一个就自动确定了。
freq参数有许多选项看这里

In[13]：pd.date_range(start='2020/1/1',periods=3,freq='D')
Out[13]:DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03'], dtype='datetime64[ns]', freq='D')In[14]:pd.date_range(start='2020/1/1',periods=3,freq='M')
Out[14]:DatetimeIndex(['2020-01-31', '2020-02-29', '2020-03-31'], dtype='datetime64[ns]', freq='M')# 也可以使用freq频率的倍数来生成`在这里插入代码片`
In[56]:pd.date_range(start='2020/1/1',periods=3,freq='4D')
Out[56]:DatetimeIndex(['2020-01-01', '2020-01-05', '2020-01-09'], dtype='datetime64[ns]', freq='4D')

2.2 索引及属性

DatetimeIndex对象具有常规Index 对象的所有基本功能，以及一系列用于简化频率处理的高级时间序列特定方法。

2.2.1索引切片

与其他Pandas.Series类似，也适用于DateFrame上
最好将时间索引按时间顺序排序则，否则其中某些方法可能会出现意外或错误的行为。

In [68]:rng = pd.date_range('2020-01-01', '2020-12-01', freq='BM')In [69]:ts = pd.Series(np.random.randn(len(rng)),index=rng)In [70]:ts.index
Out[77]:DatetimeIndex(['2020-01-31', '2020-02-28', '2020-03-31', '2020-04-30','2020-05-29', '2020-06-30', '2020-07-31', '2020-08-31','2020-09-30', '2020-10-30', '2020-11-30'],dtype='datetime64[ns]', freq='BM')# 1、可以传递能解析为时间日期的字符串：
In [78]:ts['2020-01-31']
Out[78]:0.4828613289035814In [79]: ts['20200131']
Out[79]:0.4828613289035814# 2、为了获取较长时间段，可以传递一个年份或年份和月份的字符串：
In [73]: ts['2020-02']
Out[73]:2020-02-28   -0.194006Freq: BM, dtype: float64In [74]: ts['2020']
Out[74]:2020-01-31    0.4828612020-02-28   -0.1940062020-03-31    0.4949792020-04-30   -0.3407452020-05-29    1.1959662020-06-30   -0.0953832020-07-31   -0.7027012020-08-31    0.6426592020-09-30   -0.9675482020-10-30    0.5376932020-11-30    1.513260Freq: BM, dtype: float64# 切片
In[79]:dft = pd.DataFrame(np.random.randn(100000, 1), columns=['A'],index=pd.date_range('20130101', periods=100000, freq='T'))
In [80]:dft 
Out[80]:    A2013-01-01 00:00:00  0.2762322013-01-01 00:01:00 -1.0874012013-01-01 00:02:00 -0.6736902013-01-01 00:03:00  0.1136482013-01-01 00:04:00 -1.478427...                       ...2013-03-11 10:35:00 -0.7479672013-03-11 10:36:00 -0.0345232013-03-11 10:37:00 -0.2017542013-03-11 10:38:00 -1.5090672013-03-11 10:39:00 -1.693043[100000 rows x 1 columns]In [81]:dft['2013-1':'2013-2']	  # 从2013-01-01 00:00:00 到 2013-02-28 23:59:59
Out[81]:A
2013-01-01 00:00:00  0.276232
2013-01-01 00:01:00 -1.087401
2013-01-01 00:02:00 -0.673690
2013-01-01 00:03:00  0.113648
2013-01-01 00:04:00 -1.478427
...                       ...
2013-02-28 23:55:00  0.850929
2013-02-28 23:56:00  0.976712
2013-02-28 23:57:00 -2.693884
2013-02-28 23:58:00 -1.575535
2013-02-28 23:59:00 -1.573517[84960 rows x 1 columns]In [82]: dft['2013-1-12':'2013-2-3'] # 从2013-01-12 00:00:00 到 2013-02-03 23:59:59
In [83]: dft['2013-1-15':'2013-1-15 12:30:00'] #从2013-01-15 00:00:00 到 2013-01-15 12:30:00

2.2.2 属性

Timestamp & DatetimeIndex形式的可使用以下属性获得相对应的年份、月份等（对应mysql中的时间选取函数）：
year、month、day、date、hour、minute…更多看这里

# 接上个代码数据
In [95]: ts.index.day
Out[95]:Int64Index([31, 28, 31, 30, 29, 30, 31, 31, 30, 30, 30], dtype='int64')In [92]:rng = pd.date_range('2020-01-01', '2020-12-01', freq='BM')
In [93]: rng.month
Out[93]:Int64Index([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], dtype='int64')

对于含有datetime值的Series，可以使用.dt方式获得如上的属性：

In [98]:s = pd.Series(pd.date_range('2020-01-01', '2020-12-01', freq='BM'))s
Out[98]:
0    2020-01-31
1    2020-02-28
2    2020-03-31
3    2020-04-30
4    2020-05-29
5    2020-06-30
6    2020-07-31
7    2020-08-31
8    2020-09-30
9    2020-10-30
10   2020-11-30
dtype: datetime64[ns]In [97]:s.dt.year
rOut[97]:
0     2020
1     2020
2     2020
3     2020
4     2020
5     2020
6     2020
7     2020
8     2020
9     2020
10    2020
dtype: int64

3. Time deltas及Data offsets介绍

DataOffset与Timedelta的区别：

Timedelta绝对时间差的特点指无论是冬令时还是夏令时，增减1day都只计算24小时
DataOffset相对时间差指，无论一天是23\24\25小时，增减1day都与当天相同的时间保持一致
但如果不去管时区及冬/夏令时，两者保持一致

例如，英国当地时间 2020年03月29日，01:00:00 时钟向前调整 1 小时变为 2020年03月29日，02:00:00，开始夏令时：

In[19]:ts = pd.Timestamp('2020-3-29 01:00:00', tz='Europe/Helsinki')ts + pd.Timedelta(days=1)
Out[19]:Timestamp('2020-03-30 02:00:00+0300', tz='Europe/Helsinki')In[20]: ts + pd.DateOffset(days=1)
Out[20]:Timestamp('2020-03-30 01:00:00+0300', tz='Europe/Helsinki')

两个datetime相减是Timedelta形式
Timedelta有属性.days，表示间隔多少天；同样，Series可以用.dt.days调用
另外，还有seconds,microseconds,nanoseconds，但无months,years等

In [117]:delta = pd.Timestamp('2020-06-25') - pd.Timestamp('20200101')delta
Out[117]:Timedelta('176 days 00:00:00')In [118]:delta.days
Out[118]:176In [119]:s = pd.Series(pd.date_range('2020-01-01', '2020-12-01', freq='BM')) sm =pd.Series(pd.date_range('2002-01-01', '2002-12-01', freq='BM'))s-sm
Out[119]:
0    6574 days
1    6574 days
2    6577 days
3    6575 days
4    6573 days
5    6577 days
6    6575 days
7    6576 days
8    6575 days
9    6574 days
10   6576 days
dtype: timedelta64[ns]In [120]:(s-sm).dt.days
Out[120]:
0     6574
1     6574
2     6577
3     6575
4     6573
5     6577
6     6575
7     6576
8     6575
9     6574
10    6576
dtype: int64

4. resample重采样

它可以看做时序版本的groupby函数；例如有股票每日的收盘价，想计算每周或每月的(相当于按时间分组)最高的收盘价，可以使用resample函数轻松实现。
分为下采样和上采样：
1. 下采样downsample：将更高频率的数据聚合大低频率，如将分钟数据聚合到小时数据；
  
  下采样要搭配聚合函数一起使用，先利用resample进行分组，之后在调用聚合函数；当然也可以搭配用户自编的函数。
  
  可以使用agg()或apply()函数
2. 上采样upsample：从低频率数据转换为高频率，如将小时数据转换为分钟数据；
  不需要搭配聚合函数；新增的高频率会产生缺失值；
3. 当然也有不属于上面两种的，如将W-WED(每周三)转换到W-FRI(每周五)。
下采样要搭配聚合函数一起使用，先利用resample进行分组，之后在调用聚合函数；当然也可以搭配用户自编的函数。

resample(
*rule,
axis=0,
closed: Union[str, NoneType] = None,
label: Union[str, NoneType] = None,
convention: str = ‘start’,
kind: Union[str, NoneType] = None,
loffset=None,
base: int = 0,
on=None,
level=None）
对Serise及DataFrame均适用。

常用参数	说明	参数	说明
rule	表明所需采样频率的字符串或DataOffset对象,如‘M’,'5min’等	axis	轴向，按行还是列进行采样，默认按行
closed	right或left ，表示每段间隔中哪端是包含的	label	right或left,表示每段间隔中用左端还是右端来标记结果
loffset	对上面label参数显示进行校正，如‘-1s/Second(-1)可以将标签向前移动一秒’	on	在DataFrame中，可以使用某一列来替代时序索引，但这列也必须是datetime相关时间类型

In [132]: index = pd.date_range('1/1/2000', periods=9, freq='T')series = pd.Series(range(9), index=index)series
Out[132]:
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: T, dtype: int64# 下采样# 按3分钟采样，求和
# 结果第一行包含[0秒、1秒、2秒）,第二行[3秒，4秒，5秒），第三行[6秒，7秒，8秒），取左侧边作为标签
In [133]: series.resample('3T').sum()
Out[133]:
2000-01-01 00:00:00     3
2000-01-01 00:03:00    12
2000-01-01 00:06:00    21
Freq: 3T, dtype: int64
# 将右侧边作为标签
In [134]: series.resample('3T', label='right').sum()
Out[134]:
2000-01-01 00:03:00     3
2000-01-01 00:06:00    12
2000-01-01 00:09:00    21
Freq: 3T, dtype: int64
# 将区间变为左开右闭( ]
In [138]:series.resample('3T', closed='right').sum()
Out[138]:
1999-12-31 23:57:00     0
2000-01-01 00:00:00     6
2000-01-01 00:03:00    15
2000-01-01 00:06:00    15
Freq: 3T, dtype: int64

# 上采样
# 会产生缺失值，使用asfreq()转换到高频率
In [140]: series.resample('30S').asfreq()[0:5]  # 只选前5行数据
Out[140]:
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    NaN
2000-01-01 00:01:00    1.0
2000-01-01 00:01:30    NaN
2000-01-01 00:02:00    2.0
Freq: 30S, dtype: float64
# 也可以对缺失值进行填充
In [146]:0: series.resample('30S').ffill()[0:5]  # 向前填充
Out[146]:
2000-01-01 00:00:00    0
2000-01-01 00:00:30    0
2000-01-01 00:01:00    1
2000-01-01 00:01:30    1
2000-01-01 00:02:00    2
Freq: 30S, dtype: int64In [147]:0:5 series.resample('30S').bfill()[0:5]  # 向后填充
Out[147]:
2000-01-01 00:00:00    0
2000-01-01 00:00:30    1
2000-01-01 00:01:00    1
2000-01-01 00:01:30    2
2000-01-01 00:02:00    2
Freq: 30S, dtype: int64

# 使用agg或apply
In [148]:series.resample('3T').agg([np.sum,np.mean,np.max])In [149]:series.resample('3T').apply(lambda x:max(x)-min(x))

5. 窗口函数

pandas常用的两种窗口函数，对Series和DataFrame可以使用

rolling()
expanding()

5.1 rolling函数

rolling行为与resample和groupby类似，它通过规定一个window窗口，搭配聚合函数使用或者调用agg或apply使用。

rolling(
window,
min_periods=None,
center=False,
win_type=None,
on=None,
axis=0,
closed=None)

参数	说明	参数	说明
window	表示移动窗口的大小，用于聚合的观测值个数；每个窗口是固定大小可以是offset或int型	min_periods	在窗口中需要的最小观测值个数。一般默认是window窗口的大小。如果是offset指定的窗口，则默认为1
center	bool型，如果为True,表示以当前label为窗口中心，向两边取值；默认为False,表示以当前label为窗口下侧，向上取值	win_type	提供一个窗口类型。如果为None，则对所有点进行平均加权
on	对于DataFrame，是类似于日期时间的列或MultiIndex级别，在该列或MultiIndex级别上计算滚动窗口，而不是DataFrame的索引	axis	默认为0
closed	区别包含两端的情况： ‘right’, ‘left’, ‘both’ or ‘neither’；offset指定的窗口默认为’right’;固定窗口默认为‘both’

rolling要求window窗口中所有的值必须是非NA的，特别是在数据起始位置拥有的数据是少于窗口空间的。
可使用min_periods参数，在数据少于窗口空间的按min_period规定的个数计算，等到后面满足window窗口大小后再按window窗口大小计算。

In [2]:df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})    df       
In [3]:df.rolling(2).sum()
# 将window为2，min_periods设为1，在索引为3处，应计算【2+Nan】的和为Nan，但因为min_periods可以为1，故可以只取一个数，取非Nan数，故为2.
In [4]:df.rolling(2, min_periods=1).sum()

结果如下：
在这里插入图片描述

5.2 expanding函数

普通的expanding函数等价与rolling(window=len(s),min_periods=1)，是对序列的累计计算。
比如df.expanding().sum()就等同于cumsum函数，另外还有cumprod/cummax/cummin等都是特殊expanding累计计算方法

df.expanding(min_periods=1, center=False, axis=0)

In [6]:df.expanding().sum()