pandas时间序列——时间基础、时间增量、时间周期、日期偏移处理
Pandas基于时间应用
1 时间处理基础
Pandas提供了四种类型的生成日期时间的对象：日期时间、时间增量、时间跨度、日期偏移量
（1）日期时间(Date Times)：具有时区支持的特定日期和时间。与Python标准库中的datetime.datetime类似。如2020年12月6日13点37分50秒；
（2）时间增量(Time Deltas)：绝对持续时间，用于在指定时间点基础上增加指定的增量，如在某年月日的基础上增加2天、增加2个月、减少4小时等，最后产生一个新的时间点；
（3）时间跨度(Time Span)：由时间点及其相关周期定义的时间跨度，如连续产生一年四个季度的时间序列；
（4）日期偏移(Date Offsets)：以日历计算的相对持续时间，表示时间间隔，两个时间点之间的长度，如日、周、月、季度、年。
1.1 获取当前时刻的时间
获取当前时刻的时间就是获取此时此刻与时间相关的数据，除了具体的年、月、日、时、分、秒，还会单独看年、月、周、日等指标。
1.1.1 返回当前时刻的日期和时间
返回当前时刻的日期和时间在Python中借助函数 now() 实现。
from datetime import datetime
datetime.now()
datetime.datetime(2020, 12, 6, 14, 9, 55, 720085)
datetime.date(datetime.now()) # 获取当前日期
datetime.date(2020, 12, 6)
datetime.time(datetime.now()) # 获取当前时间
datetime.time(14, 11, 51, 776782)
1.1.2 分别返回当前时刻的年、月、日
返回当前时刻的年份在Python中借助函数 year 实现
datetime.now().year
2020
返回当前时刻的月份在Python中借助函数 month 实现
datetime.now().month
11
返回当前时刻的日在Excel和Python中都借助函数 day 实现
datetime.now().day
19
1.1.3 返回当前时刻的周数
与当前时刻的周相关的数据有两个，一个是当前时刻是一周中的周几，另一个是返回当前时刻所在的周在全年的周里面是第几周。
返回当前时刻是周几在Python中借助 weekday() 函数实现。
datetime.now().weekday()+1
4
Attention ：Python中周几是从0开始数的，所以在后面加1
返回当前时刻所在周的周数，在Python中使用的是 isocalendar() 函数。
datetime.now().isocalendar()
(2020, 47, 4)
2020年的第47周的第4天
datetime.now().isocalendar()[1]
47
1.2 pd.Timestamp创建日期时间对象
Pandas库也提供了类似的日期时间对象 pd.Timestamp
import pandas as pd
pd.Timestamp("2020-12-06")
Timestamp('2020-12-06 00:00:00')
pd.Timestamp(2020,12,6,13,19,52)
Timestamp('2020-12-06 13:19:52')
pd.Timestamp(year=2020,month=12,day=6,hour=14,minute=19,second=52) # 键值对形式指定年月日时分秒
Timestamp('2020-12-06 14:19:52')
pd.Timestamp(2020,12,6,13,19,52).year # 通过year、month、day属性获取年月日
2020
1.4 指定日期和时间的格式
借助 date() 函数将日期和时间设置成只展示日期。
datetime.now().date()
datetime.date(2020, 11, 19)
借助 time() 函数将日期和时间设置成只展示时间。
datetime.now().time()
datetime.time(15, 1, 27, 19303)
借助 strftime() 函数可以自定义时间和日期的格式，strftime() 函数是将日期和时间的格式转化为某些自定义的格式，具体的格式有以下几种
datetime.now().strftime("%F")
'2020-11-19'
datetime.now().strftime("%F %H:%M:%S")
'2020-11-19 15:04:31'
2 时间序列
基于时间序列的数据记录，可以通过Series、DataFrame的索引值来记录时间点，可以同步记录对应时间点的数据元素。
2.1 指定时间点建立时间序列的Series对象
通过 pd.Timestamp 与 pd.DatetimeIndex 方法建立指定时间序列的Series对象
import pandas as pd
import numpy as np
T1 = pd.Series(np.arange(4),index=[pd.Timestamp("2020-12-6"),pd.Timestamp("2020-12-7"),pd.Timestamp("2020-12-8"),pd.Timestamp("2020-12-9")])
print(T1) # 指定4个时间点为索引值
print("="*30)
T1.index # pandas 自动把索引归类为日期时间索引
2020-12-06 0
2020-12-07 1
2020-12-08 2
2020-12-09 3
dtype: int32
==============================
DatetimeIndex(['2020-12-06', '2020-12-07', '2020-12-08', '2020-12-09'], dtype='datetime64[ns]', freq=None)
T1 = pd.Series(np.arange(4),index=pd.DatetimeIndex(["2020-12-6","2020-12-7","2020-12-8","2020-12-9"]))
print(T1)
print("="*30)
T1.index
2020-12-06 0
2020-12-07 1
2020-12-08 2
2020-12-09 3
dtype: int32
==============================
DatetimeIndex(['2020-12-06', '2020-12-07', '2020-12-08', '2020-12-09'], dtype='datetime64[ns]', freq=None)
2.2 时间范围函数建立时间序列
pd.date_range()函数用于产生连续的时间序列
pd.date_range(start=None，end=None，periods=None，freq=None，tz=None，normalize=False，name=None，close=None，**kwargs)
start ：字符串或者类似datetime类型的值，可选，设置开始日期，必须与end参数搭配使用
end ：字符串或者类似datetime类型的值，可选，设置结束日期
periods ：整数，可选，设置要生成的日期周期数(也叫绝对增量)，或者说在start指定开始日期的基础上，按照指定频率(freq)需要连续生成的日期数量，结合freq参数一起使用
freq ：字符串或者DateOffest类型值设置需要生成的日期间隔频率，默认值为"D"，"D"代表以Day(天)为频率，可以用数值加频率扩展频率范围，如"2D"代表以2天为一个周期频率 Attention：在以周为频率的情况下，都是从周日开始，不一定是指定的开始时间开始
tz ：字符串或者tzinfor值，可选，用于指定本地时区的名称
normalize ：默认值为False，为True时则设置开始、结束日期的时间为午夜，即零点
name ：字符串，默认值为None，可以设置生成DatetimeIndex对象的名称
closed ：可选，可选项为{None，"left"，"right"}可以理解为时间范围，左右边界可以设置为开闭区间，"left"表示左闭区间，"right"表示右闭区间，None表示两边都为闭区间
pd.date_range(start="2020-12-6 15:02:30",end="2020-12-9 15:02:30") # 生成2020-12-06 15:02:30至2020-12-09 15:02:30按天为间隔的连续时间序列
DatetimeIndex(['2020-12-06 15:02:30', '2020-12-07 15:02:30',
'2020-12-08 15:02:30', '2020-12-09 15:02:30'],
dtype='datetime64[ns]', freq='D')
pd.date_range(start="2020-12-6 15:02:30",periods=4,freq="2D",name="时间索引") # 生成以2020-12-06 15:02:30为始的按2天为间隔的连续4个时间序列
DatetimeIndex(['2020-12-06 15:02:30', '2020-12-08 15:02:30',
'2020-12-10 15:02:30', '2020-12-12 15:02:30'],
dtype='datetime64[ns]', name='时间索引', freq='2D')
pd.date_range(start="2020-12-6 15:02:30",end="2020-12-9 15:02:30",closed="left") # 生成2020-12-06 15:02:30至2020-12-09 15:02:30按天为间隔左闭右开的连续时间序列
DatetimeIndex(['2020-12-06 15:02:30', '2020-12-07 15:02:30',
'2020-12-08 15:02:30'],
dtype='datetime64[ns]', freq='D')
2.3 时间转换
在不同时间场合，时间使用的要求也不一样，有需要字符串形式的，有需要datetime形式的，有日期、时间的不同组合的，因此需要灵活转换
2.3.1 pd.to_datetime方法将字符串转为datetime型
pd.to_datetime(arg，errors=“raise”，dayfirst=False，yearfirst=False，utc=None，box=True，format=None，exact=True，unit=None，infer_datetime_format=False，origin=“unix”，cache=False)
arg ：指定转换的数据对象，可以是整型、浮点型、字符串、列表、元组、一维数组、Serise、DataFrame和字典
errors ：设置出错提示方式，可选{"ignore","raise","coercec"}，默认值为"raise"，如果转换失败，则给出出错提示信息；"ignore"则不出发出错提示信息；"coercec"在转换过程存在无效时间值时，自动转为NaT值
dayfirst ：指定arg参数转换时的顺序，设置为True时，则先转换日期，再转换时间，默认值为False
yearfirst ：值为True时则先转换日期，默认值为False
utc ：值为True返回UTC DatetimeIndex，默认值为None
box ：默认值为True返回DatetimeIndex或相关索引对象；值为False则返回多维数组
format ：字符串，默认值为None，指定字符串时间转化为时间时的strftime的格式，类似strftime方法转化为时间的使用方法
exact ：默认值为True表示精确匹配格式，值为False则允许匹配目标字符串中的任何位置
unit ：字符串，默认值为"ns"，对转换对象指定时间单位（D天、s秒、ma毫秒、ns纳秒）
infer_datetime_format ：默认值为False，如果为True，且没有给出转换固定格式（format参数），且字符串日期时间格式确定，则可以提高转换速度
origin ：确定日期的开始点，默认值为"unix"，则日期的开始点为1970-01-01，若提供值为Timestamp日期，则以Timestamp的起点日期作为开始点日期
cache ：默认值为False，如果为True，则是用唯一的转换日期缓存来应用日期时间转换，解析重复的日期字符串时可以提高转换速度
import pandas as pd
from datetime import datetime
filename = r"D:\data_test.xlsx"
df = pd.read_excel(filename)
print(df.head())
print("="*30)
print(df.info())
name gender birthday start_work income tel email \
0 赵一 男 1989/8/10 2012-09-08 15000 13611011234 [email protected]
1 王二 男 1990/10/2 2014-03-06 12500 13500012234 [email protected]
2 张三 女 1987/3/12 2009-01-08 18500 13515273330 [email protected]
3 李四 女 1991/8/16 2014-06-04 13000 13923673388 [email protected]
4 刘五 女 1992/5/24 2014-08-10 8500 17823117890 [email protected]
other
0 {教育：本科，专业：电子商务，爱好：运动}
1 {教育：大专，专业：汽修，爱好：}
2 {教育：本科，专业：数学，爱好：打篮球}
3 {教育：硕士，专业：统计学，爱好：唱歌}
4 {教育：本科，专业：美术，爱好：}
==============================
RangeIndex: 8 entries, 0 to 7
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 name 8 non-null object
1 gender 8 non-null object
2 birthday 8 non-null object
3 start_work 8 non-null datetime64[ns]
4 income 8 non-null int64
5 tel 8 non-null int64
6 email 8 non-null object
7 other 8 non-null object
dtypes: datetime64[ns](1), int64(2), object(5)
memory usage: 640.0+ bytes
None
df.birthday=pd.to_datetime(df.birthday,format="%Y-%m-%d")
df.info()
RangeIndex: 8 entries, 0 to 7
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 name 8 non-null object
1 gender 8 non-null object
2 birthday 8 non-null datetime64[ns]
3 start_work 8 non-null datetime64[ns]
4 income 8 non-null int64
5 tel 8 non-null int64
6 email 8 non-null object
7 other 8 non-null object
dtypes: datetime64[ns](2), int64(2), object(4)
memory usage: 640.0+ bytes
data = pd.DataFrame({"客户":["李","张","刘","宋"],"工资":[3500,2500,1500,500],"日期":["2020-11-19","2020-11-20","2020-12-19","2020-12-20"]},index = ["A","B","C","D"])
print(data.info)
2.3.2 parse()函数将字符串格式转换为时间格式
使用 parse() 函数将字符串格式转换为时间格式
from dateutil.parser import parse
time ="2020-12-06"
print(type(time))
print("="*30)
print(parse(time))
print("="*30)
print(type(parse(time)))
==============================
2020-12-06 00:00:00
==============================
2.3.3 str方法将时间格式转换为字符串格式
使用 str() 函数将时间格式转换为字符串格式
now = str(datetime.now())
type(now)
str
2.4 时间索引
2.4.1 关键字检索
import numpy as np
import pandas as pd
index = pd.DatetimeIndex(["2020-11-19","2020-11-20","2020-12-19","2020-12-20"])
data = pd.DataFrame(np.arange(1,5),columns= ["num"],index = index)
data
| num | |
|---|---|
| 2020-11-19 | 1 |
| 2020-11-20 | 2 |
| 2020-12-19 | 3 |
| 2020-12-20 | 4 |
data["2020"] # 年索引
| num | |
|---|---|
| 2020-11-19 | 1 |
| 2020-11-20 | 2 |
| 2020-12-19 | 3 |
| 2020-12-20 | 4 |
data["2020-11"] # 年月索引
| num | |
|---|---|
| 2020-11-19 | 1 |
| 2020-11-20 | 2 |
data["2020-11-19":"2020-12-20"] # 指定时间范围索引
| num | |
|---|---|
| 2020-11-19 | 1 |
| 2020-11-20 | 2 |
| 2020-12-19 | 3 |
| 2020-12-20 | 4 |
上面的索引方法适用于索引是时间的情况下，但是并不是在所有情况下，时间都可以做索引，比如说时间只是一个普通列
from datetime import datetime
from dateutil.parser import parse
index =["A","B","C","D"]
data = pd.DataFrame({"客户":["李","张","刘","宋"],"成交时间":[parse("2020-11-19"),parse("2020-11-20"),parse("2020-12-19"),parse("2020-12-20")]},index = index)
data
| 客户 | 成交时间 | |
|---|---|---|
| A | 李 | 2020-11-19 |
| B | 张 | 2020-11-20 |
| C | 刘 | 2020-12-19 |
| D | 宋 | 2020-12-20 |
data[data["成交时间"] == datetime(2020,11,20)] # 选择成交时间是2020-11-20的行
| 客户 | 成交时间 | |
|---|---|---|
| B | 张 | 2020-11-20 |
data[(data["成交时间"] > datetime(2020,11,19)) & (data["成交时间"] < datetime(2020,12,21))] # 选择成交时间大于2020-11-19和成交时间小于2020-11-21的所有行
| 客户 | 成交时间 | |
|---|---|---|
| B | 张 | 2020-11-20 |
| C | 刘 | 2020-12-19 |
| D | 宋 | 2020-12-20 |
2.4.2 truncate方法截取时间
通过 truncate 方法实现对Series或DataFrame对象日期的截取
truncate(before=None，after=None，axis=None，copy=True)
before ：指定行索引值或列索引值，用于截取前面的值
after ：指定行索引值或列索引值，用于截取后面的值
axis ：0为行索引，1为列索引
copy ：复制数据
T = pd.date_range("2020-12-6",periods=5,freq="2D")
df1 = pd.DataFrame(("a","b","c","d","e"),index=T)
print(df1)
print("="*30)
df1.truncate(before = pd.Timestamp("2020-12-07"),after= pd.Timestamp("2020-12-13")) # 截取2020-12-07到2020-12-13这个时间段的数据
0
2020-12-06 a
2020-12-08 b
2020-12-10 c
2020-12-12 d
2020-12-14 e
==============================
| 0 | |
|---|---|
| 2020-12-08 | b |
| 2020-12-10 | c |
| 2020-12-12 | d |
2.5 时间增量处理
时间增量是相对时间点上的绝对时间差异，用不同的单位表示，如天、小时、分钟、秒。可以是正数也可以是负数
2.5.1 Timedelta()增量函数
Timedelta 是 datetime 的一个子类，用于提供时间增量计算功能
pd.Timedelta(value，unit，days，seconds，microseconds，milliseconds，minutes，hours，weeks)
value ：字符串、整型、Timedelta、timedelta、np.timedelta64，指定时间增量
unit ：字符串，可选，时间增量单位，默认值为"ns"，可选值为{"Y","M","W","D","days","day","hours","hour",.....}
days,seconds,microseconds,milliseconds,minutes,hours,weeks ：用键值对形式显示指定增量数值
（1）字符串形式增减日期、小时
import pandas as pd
import datetime as dt
import numpy as np
today = dt.datetime.now()
print(today)
print("="*30)
today.date() + pd.Timedelta("2 day") # 提供增量为两天的时间增量
2020-12-08 10:24:15.549743
==============================
datetime.date(2020, 12, 10)
today + pd.Timedelta("2 hours") # 提供增量为两小时的时间增量
datetime.datetime(2020, 12, 8, 12, 24, 15, 549743)
today + pd.Timedelta("-2 hours") # 提供两小时的时间减量
datetime.datetime(2020, 12, 8, 8, 24, 15, 549743)
（2）以整数和时间形式提供增减量
today + pd.Timedelta(2 ,unit="hours") # 提供增量为两小时的时间增量
datetime.datetime(2020, 12, 8, 12, 24, 15, 549743)
today + pd.Timedelta(2 ,unit="W") # 提供增量为两周的时间增量
datetime.datetime(2020, 12, 22, 10, 24, 15, 549743)
（3）以datetime.datetime、np.timedelta64形式提供增减量
today + pd.Timedelta(weeks=2) #提供增量为两周的时间增量
datetime.datetime(2020, 12, 22, 10, 24, 15, 549743)
today + pd.Timedelta(np.timedelta64(2,"W"))
datetime.datetime(2020, 12, 22, 10, 24, 15, 549743)
2.5.2 to_timedelta()转为增量函数
pd.to_timedelta(arg，unit=“ns”，box=True，errors=“raise”)
arg ：字符串、timedelta、类似列表、Series，指定需要转换为增量的数据对象
unit ：增量时间单位，同pd.Timedelta的unit
box ：默认值为True返回Timedelta\TimedeltaIndex结果，值为False则返回timedelta64类型数据
pd.to_timedelta(np.arange(5),unit="s") # 返回连续5个秒值的时间增量
TimedeltaIndex(['00:00:00', '00:00:01', '00:00:02', '00:00:03', '00:00:04'], dtype='timedelta64[ns]', freq=None)
2.5.3 timedelta_range()产生连续增量函数
timedelta_range(start=None，end=None，periods=None，freq=None，name==None，closed=None)
start ：字符串、类似timedelta对象，默认值为None，指定时间增量左边边界
end ：字符串、类似timedelta对象，默认值为None，指定时间增量右边边界
periods ：整型，默认值为None，指定周期数，即增量个数
freq ：字符串、DateOffest，默认值为"D"，指定增量频率，可以使用倍数方式指定，如"5D"
name ：字符串，默认值为None，指定生成TimedeltaIndex的名称
closed ：字符串，默认值为None，限制左右区间值得范围，可选项为{"right","left",None}
pd.timedelta_range(start="1 day",end="10 day",periods=5,name="索引")
TimedeltaIndex([ '1 days 00:00:00', '3 days 06:00:00', '5 days 12:00:00',
'7 days 18:00:00', '10 days 00:00:00'],
dtype='timedelta64[ns]', name='索引', freq=None)
pd.timedelta_range(start="1 day", periods=5,freq= "2D",name="索引")
TimedeltaIndex(['1 days', '3 days', '5 days', '7 days', '9 days'], dtype='timedelta64[ns]', name='索引', freq='2D')
2.5.4 时间增量属性、增量索引
Timedelta、TimedeltaIndex对象提供了增量相关的属性，用于增量不同单位的数值的获取。当想单独获取增量的天（days）、秒（seconds）、毫秒（milliseconds）、微妙（microseconds）、纳秒（nanoseconds）值时，可以通过上述两对象所提供的属性对象进行获取。
1、Timedelta对象
import pandas as pd
d1 = pd.Timedelta("31 days 10 min 20 sec") # 建立一个Timedelta对象
d1
Timedelta('31 days 00:10:20')
(1) components属性，以获取增量的所有值
d1.components # 显示增量的所有内容
Components(days=31, hours=0, minutes=10, seconds=20, milliseconds=0, microseconds=0, nanoseconds=0)
d1.components[2] # 通过下标值，获取增量的分钟值
10
(2) days属性
d1.days # 从增量中获取天的数值
31
(3) seconds属性
d1.seconds # 从增量中获取秒的数值（分钟+秒）
620
(3) microseconds属性
d1.microseconds # 从增量中获取微秒的数值（分钟+秒）
0
Attention：Timedelta并没有提供hours、week等类似的其他属性，而TimedeltaIndex提供的属性也略有差异
2、TimedeltaIndex 时间增量索引对象
TimedeltaIndex(data，unit，freq，copy，start，periods，end，closed，name)
data ：一维数组、一维列表，可选，用于建立timedelta类似数据的索引值
unit ：整数、浮点数，可选，指定增量时间单位（D、h、m、s、ms、ns）
freq ：字符串、偏移对象，可选，指定时间频率，可以传递字符串"infer"，以便在创建时将索引的频率设置为推断频率
copy ：可选，默认值True为复制数据，值为False为数据视图
start ：可选， timedelta类似类型，指定增量开始值，如果data参数为None，则用该参数指定timedelta数据的起点
periods ：整数，可选，指定值要求大于0，指定增量数，优先end参数设置
end ： timedelta类似类型，指定结東时间，可选，如果 periods为None，则生效
closed ：字符串或默认值None，可选，指定生成值的开闭区间范围，可选择值{"left","right", None}
name ：可选，指定时间增量索引的名称
用 Timedeltalndex建立时间增量索引对象
import numpy as np
import datetime as dt
t = pd.TimedeltaIndex(["1 days","10 days","10:20:05",np.timedelta64(10,"D"),dt.timedelta(days=10,seconds=2)])
t
TimedeltaIndex([ '1 days 00:00:00', '10 days 00:00:00', '0 days 10:20:05',
'10 days 00:00:00', '10 days 00:00:02'],
dtype='timedelta64[ns]', freq=None)
t.days
Int64Index([1, 10, 0, 10, 10], dtype='int64')
生成连续时间增量还可以使用 pd.timedelta_range()，方法类似 pd.date_range()
2.6 时间周期处理
周期表示一段范围的时间，如一天、一月、一季度、一年等，规则的时间周期用pandas中的pd Period对象表示，pd Period_range()产生连续的时间周期序列对象PeriodsIndex
2.6.1 时间周期建立
通过时间周期的建立，可以更加灵活地控制年、月等时间周期的变化。
pd Period(value， freq， year，month，quarter，day，hour，minute，second)
value : Period或 compat.string_types类型，默认值None表示时间段，如4Q2005代表2005年第四季度
freq : 字符串，默认值None，指定字符串型的 Pandas时间周期。
year : 整数，默认值None，指定年数
month : 整数，默认值1，指定月数
quarter : 整数，默认值None，指定季度数
day : 整数，默认值1，指定天数。
hour : 整数，默认值0，指定小时数。
minute : 整数，默认值0，指定分钟数
second:整数，默认值0，指定秒数。
M = pd.Period("2020-12",freq="M")
M
Period('2020-12', 'M')
M+2
Period('2021-02', 'M')
2.6.2 时间周期序列
在需要固定时间序列的地方，可以通过 pd.period_range() 函数产生
period_range(start=None，end= None， periods= None， freq=None，name=None)
start : 字符串或 period对象，指定周期序列的开始时间点，默认值为None
end : 字符串或 period对象，指定周期序列的结東时间点，默认值为None
periods : 整数，指定周期个数，默认值None
freq : 字符串或 Dateoffset，指定周期名称，如Y、MI、D、h、m、、ms、ns，默认值D(天)
name : 字符串，默认值None，指定 Periodindex名称
(1) 以月为周期产生连续的时间序列
M = pd.period_range("2020-12-12","2021-12-12",freq="M")
M
PeriodIndex(['2020-12', '2021-01', '2021-02', '2021-03', '2021-04', '2021-05',
'2021-06', '2021-07', '2021-08', '2021-09', '2021-10', '2021-11',
'2021-12'],
dtype='period[M]', freq='M')
(2) 以季度为周期产生连续的时间序列
Q = pd.period_range("12/12/2020","12/12/2021",freq="Q")
Q
PeriodIndex(['2020Q4', '2021Q1', '2021Q2', '2021Q3', '2021Q4'], dtype='period[Q-DEC]', freq='Q-DEC')
(3)以PeriodIndex对象为基础建立二维表
a=pd.DataFrame({"韦德":[25,28,23,27,26]},index=Q)
a
| 韦德 | |
|---|---|
| 2020Q4 | 25 |
| 2021Q1 | 28 |
| 2021Q2 | 23 |
| 2021Q3 | 27 |
| 2021Q4 | 26 |
2.7 日期偏移处理
类似时间增量，只存在细微的区别
2.7.1 时间偏移量建立
日期偏移量更加遵循日历持续时间规则，如 Dateoffset在增加日时总是增加到指定日的同时间，而忽略夏令时等所带来的时间差异:而 Timedelta（）在增加日时，每天增加24小时
pd.DateOffset(n，normalize，**kwds)
n : 整数，默认值为1，指定产生偏移量数
normalize : 默认值为 False，当值为True时将DateOffset添加的时间结果含入到半夜0点。
kwds : 以键值对形式指定偏移量周期
import pandas as pd
t1 = pd.Timestamp("2020-12-14")
print(t1)
t1 + pd.DateOffset(n=2,months=3) # 增加2*3=6个月
2020-12-14 00:00:00
Timestamp('2021-06-14 00:00:00')
2.7.2 用offsets对象附带的方法调整日期
t2 = pd.Timestamp(2020,12,14,13,19,52)
print(t2)
t2 + pd.offsets.YearEnd() # 增加到年度结束日期
2020-12-14 13:19:52
Timestamp('2020-12-31 13:19:52')
t2 + pd.offsets.MonthBegin(n=2) # 增加到2个月后的月初
Timestamp('2021-02-01 13:19:52')
2.7.3 用pd.DateOffset()函数调整日期
t1 + pd.DateOffset(n=2,months=3)
Timestamp('2021-06-14 00:00:00')
2.8 时间运算
2.8.1 计算时间差
在Python中两个时间做差会返回一个timedelta对象，该对象中包含天数、秒、微秒三个等级，如果要获取小时、分钟，则需要进行换算。
time_cha = datetime(2020,11,19,18,5,50)-datetime(2020,11,18,17,5,50)
time_cha
datetime.timedelta(days=1, seconds=3600)
差值为1天3600秒
time_cha.days
1
time_cha.seconds
3600
import pandas as pd
from datetime import datetime
filename = r"D:\data_test.xlsx"
df = pd.read_excel(filename)
print(df.head())
print("="*30)
df.birthday=pd.to_datetime(df.birthday,format="%Y-%m-%d")
df["年龄"]= datetime.now().year-df.birthday.dt.year
print(df.head())
name gender birthday start_work income tel email \
0 赵一 男 1989/8/10 2012-09-08 15000 13611011234 [email protected]
1 王二 男 1990/10/2 2014-03-06 12500 13500012234 [email protected]
2 张三 女 1987/3/12 2009-01-08 18500 13515273330 [email protected]
3 李四 女 1991/8/16 2014-06-04 13000 13923673388 [email protected]
4 刘五 女 1992/5/24 2014-08-10 8500 17823117890 [email protected]
other
0 {教育：本科，专业：电子商务，爱好：运动}
1 {教育：大专，专业：汽修，爱好：}
2 {教育：本科，专业：数学，爱好：打篮球}
3 {教育：硕士，专业：统计学，爱好：唱歌}
4 {教育：本科，专业：美术，爱好：}
==============================
name gender birthday start_work income tel email \
0 赵一 男 1989-08-10 2012-09-08 15000 13611011234 [email protected]
1 王二 男 1990-10-02 2014-03-06 12500 13500012234 [email protected]
2 张三 女 1987-03-12 2009-01-08 18500 13515273330 [email protected]
3 李四 女 1991-08-16 2014-06-04 13000 13923673388 [email protected]
4 刘五 女 1992-05-24 2014-08-10 8500 17823117890 [email protected]
other 年龄
0 {教育：本科，专业：电子商务，爱好：运动} 31
1 {教育：大专，专业：汽修，爱好：} 30
2 {教育：本科，专业：数学，爱好：打篮球} 33
3 {教育：硕士，专业：统计学，爱好：唱歌} 29
4 {教育：本科，专业：美术，爱好：} 28
2.8.2 时间偏移
时间偏移是指给时间往前推或往后推一段时间，即加或减一段时间
在Python中实现时间偏移的方式有两种：第一种是借助timedelta，但是它只能偏移天、秒、微秒单位的时间；第二种是用Pandas中的日期偏移量（date offset）。
● timedelta
由于timedelta只支持天、秒、微秒单位的时间运算，如果是其他单位的时间运算，则需要换算成以上三种单位中的一种方可进行偏移。
from datetime import timedelta
data = datetime(2020,11,19,18,5,50)
data + timedelta(days=1)
datetime.datetime(2020, 11, 20, 18, 5, 50)
data + timedelta(seconds=1)
datetime.datetime(2020, 11, 19, 18, 5, 51)
data - timedelta(days=1)
datetime.datetime(2020, 11, 18, 18, 5, 50)
data - timedelta(seconds=1)
datetime.datetime(2020, 11, 19, 18, 5, 49)
● date offset
date offset 可以直接实现天、小时、分钟单位的时间偏移，不需要换算，相比timedelta要方便一些。
from pandas.tseries.offsets import Day,Hour,Minute
data = datetime.now()
data
datetime.datetime(2020, 11, 19, 18, 21, 20, 937641)
data + Day(1)
Timestamp('2020-11-20 18:21:20.937641')
data + Hour(1)
Timestamp('2020-11-19 19:21:20.937641')
data + Minute(10)
Timestamp('2020-11-19 18:31:20.937641')
data - Day(1)
Timestamp('2020-11-18 18:21:20.937641')
data - Hour(1)
Timestamp('2020-11-19 17:21:20.937641')
data - Minute(10)
Timestamp('2020-11-19 18:11:20.937641')