1、time 模块
1.1、time模块中时间表现的格式主要有三种：
a、timestamp时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
b、struct_time时间元组，共有九个元素组。
c、format time格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
import time
#当前时间戳
t1 = time.time()
print(t1)
#将时间戳转化为struct_time
t2 = time.localtime(t1)
print (t2)
print (time.localtime())
t22 = time.gmtime(t1)
print (t22)
print (time.gmtime())
#将time.struct_time转化为时间戳
t3 = time.mktime(t2)
print('t3 = ',t3,'\n')
#当前时间的自定义格式，str时间
t4 = time.strftime('%Y-%m-%d')
t44 = time.strftime('%Y-%m-%d %X')
print(type(t4))
print('t4 =',t4,'\n',t44)
#将str时间转化为time.struct_time，前后格式形式要对应
t5 = time.strptime(t4,'%Y-%m-%d')
print(type(t5))
print('t5 = ',t5,'\n')
#将time.struct_time转化为asctime形式
t6 = time.asctime(t2)
print(type(t6))
print('t6 = ',t6,'\n')
#将时间戳转化为str--%a %b %d %H %M %S %Y,形式为time.asctime()形式
t7 = time.ctime(t1)
print('t7 = ',t7,'\n')
t77 = time.strftime('%c')
print('t77 =',t77,'\n')
1553556035.8537471
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=7, tm_min=20, tm_sec=35, tm_wday=1, tm_yday=85, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=7, tm_min=20, tm_sec=35, tm_wday=1, tm_yday=85, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=25, tm_hour=23, tm_min=20, tm_sec=35, tm_wday=0, tm_yday=84, tm_isdst=0)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=25, tm_hour=23, tm_min=20, tm_sec=35, tm_wday=0, tm_yday=84, tm_isdst=0)
t3 = 1553556035.0
<class 'str'>
t4 = 2019-03-26
2019-03-26 07:20:35
<class 'time.struct_time'>
t5 = time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=85, tm_isdst=-1)
<class 'str'>
t6 = Tue Mar 26 07:20:35 2019
t7 = Tue Mar 26 07:20:35 2019
t77 = Tue Mar 26 07:20:35 2019
1.2、format time结构化表示
| 格式 | 含义 |
|---|---|
| %a | 本地（locale）简化星期名称 |
| %A | 本地完整星期名称 |
| %b | 本地简化月份名称 |
| %B | 本地完整月份名称 |
| %c | 本地相应的日期和时间表示 |
| %d | 一个月中的第几天（01 - 31） |
| %H | 一天中的第几个小时（24小时制，00 - 23） |
| %I | 第几个小时（12小时制，01 - 12） |
| %j | 一年中的第几天（001 - 366） |
| %m | 月份（01 - 12） |
| %M | 分钟数（00 - 59） |
| %p | 本地am或者pm的相应符 |
| %S | 秒（01 - 61） |
| %U | 一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周 |
| %W | 和%U基本相同，不同的是%W以星期一为一个星期的开始 |
| %w | 一个星期中的第几天（0 - 6，0是星期天） |
| %x | 本地相应日期 |
| %X | 本地相应时间 |
| %y | 去掉世纪的年份（00 - 99） |
| %Y | 完整的年份 |
| %Z | 时区的名字（如果不存在为空字符） |
| %% | ‘%’字符 |
print (time.strftime('%Y-%m-%d %X'))
print (time.strftime('%a %A %b %B'))
print (time.strftime('%c'))
print (time.strftime('%d'))
print (time.strftime('%j'))
print (time.strftime('%U'))
print (time.strftime('%W'))
print (time.strftime('%z'))
2019-03-26 07:20:36
Tue Tuesday Mar March
Tue Mar 26 07:20:36 2019
26
085
12
12
+0800
1.3、time.clock( )
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用
1.4、time.sleep() 函数推迟调用线程的运行，可通过参数secs指秒数，表示进程挂起的时间
sleep()方法语法：
time.sleep(t) #t – 推迟执行的秒数
2、datetime模块
datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
datetime.tzinfo：与时区有关的相关信息
from datetime import *
import time
2.1、date类
date类表示一个日期。日期由年、月、日组成。
date类的构造函数如：class datetime.date(year, month, day)
date类定义了一些常用的类方法与类属性：
date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；
date.fromordinal(ordinal)：将Gregorian日历时间转换为date对象；（Gregorian Calendar ：一种日历表示方法，类似于我国的农历，西方国家使用比较多，此处不详细展开讨论。）
print (date.max)
print (date.min)
print (date.resolution)
print (date.today())
t0 = time.time()
print (t0)
print (date.fromtimestamp(t0))
t1 = date.toordinal(date.today())
print (t1)
print (date.fromordinal(t1))
9999-12-31
0001-01-01
1 day, 0:00:00
2019-03-26
1553556036.3595684
2019-03-26
737144
2019-03-26
date提供的实例方法和属性:
date.year、date.month、date.day：年、月、日；
date.replace(year, month,day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
date.timetuple()：返回日期对应的time.struct_time对象；
date.toordinal()：返回日期对应的Gregorian Calendar日期；
date.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
data.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
date.isocalendar()：返回格式如(year，month，day)的元组；
date.isoformat()：返回格式如’YYYY-MM-DD’的字符串；
date.strftime(fmt)：自定义格式化字符串。
t2 = date.today()
print (t2)
print (t2.year,t2.month,t2.day)
# 生成新的日期，对原来的日期没有做改动
t3 = t2.replace(2019,2,28)
print (t2,id(t2))
print (t3,id(t3))
# date转化为time.struct_time对象
t4 = t2.timetuple()
print (t4)
# 查看星期几
w1 = t2.weekday()
print (w1)
w2 = t2.isoweekday()
print (w2)
t5 = t2.isocalendar()
print (t5,t5[0])
t6 = t2.isoformat()
print (t6)
# date转化为指定格式time
t7 = t2.strftime('%Y-%m-%d')
print (t7)
t77 = t2.strftime('%Y-%m-%d %X')
print (t77)
2019-03-26
2019 3 26
2019-03-26 2255488638032
2019-02-28 2255488637616
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=85, tm_isdst=-1)
1
2
(2019, 13, 2) 2019
2019-03-26
2019-03-26
2019-03-26 00:00:00
date还对某些操作进行了重载，它允许我们对日期进行如下一些操作：
date2 = date1 + timedelta # 日期加上一个间隔，返回一个新的日期对象（timedelta将在下面介绍，表示时间间隔）
date2 = date1 - timedelta # 日期隔去间隔，返回一个新的日期对象
timedelta = date1 - date2 # 两个日期相减，返回一个时间间隔对象
date1 < date2 # 两个日期进行比较
timedelta = t2 - t3
print (timedelta)
t8 = t3 + timedelta
print (t8)
t9 = t2 - timedelta
print (t9)
print (t3 < t2)
26 days, 0:00:00
2019-03-26
2019-02-28
True
2.2、time类
time类表示时间，由时、分、秒以及微秒组成。
time类的构造函数如下：class datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] )
time类定义的类属性：
time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)，time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；
time类提供的实例方法和属性：
time.hour、time.minute、time.second、time.microsecond：时、分、秒、微秒；
time.tzinfo：时区信息；
time.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ]] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
time.isoformat()：返回型如”HH:MM:SS”格式的字符串表示；
time.strftime(fmt)：返回自定义格式化字符串
from datetime import time as dtime
print (dtime.min)
print (dtime.max)
print (dtime.resolution)
t0 = datetime.now()
print (t0)
t1 = t0.time()
print (t1)
print (t1.hour,t1.minute,t1.second,t1.microsecond)
t2 = t1.replace(18,0,0,0)
print (t1)
print (t2)
print (t1.isoformat())
print (t0.strftime('%X'))
00:00:00
23:59:59.999999
0:00:00.000001
2019-03-26 07:20:37.066138
07:20:37.066138
7 20 37 66138
07:20:37.066138
18:00:00
07:20:37.066138
07:20:37
time类不能进行相加减操作，如果只是简单的时间相加减没有意义，必须带上日期相比较才行
2.3、datetime类
datetime是date与time的结合体，包括date与time的所有信息。
它的构造函数如下：datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )，各参数的含义与date、time的构造函数中的一样，要注意参数值的范围。
datetime类定义的类属性与方法：
datetime.min、datetime.max：datetime所能表示的最小值与最大值；
datetime.resolution：datetime最小单位；
datetime.today()：返回一个表示当前本地时间的datetime对象；
datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
datetime.utcnow()：返回一个当前utc时间的datetime对象；
datetime.fromtimestamp(timestamp[,tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
datetime.combine(date, time)：根据date和time，创建一个datetime对象；
datetime.strptime(date_string, format)：将格式字符串转换为datetime对象,format与date_string格式要一致；
print (datetime.min)
print (datetime.max)
# 创建指定日期
tt = datetime(2018,5,20)
print (tt)
t0 = datetime.today()
t00 = datetime.now()
t01 = datetime.utcnow()
print (t0)
print (t00)
print (t01)
t1 = t0.timestamp()
print (t1)
t2 = datetime.fromtimestamp(t1)
print (t2)
date0 = t0.date()
print (date0)
time0 = t0.time()
print (time0)
t3 = datetime.combine(date0,time0)
print (t3)
t4 = t3.strftime('%Y-%m-%d %X')
print (t4,type(t4))
t5 = datetime.strptime(t4,'%Y-%m-%d %X')
print (t5)
0001-01-01 00:00:00
9999-12-31 23:59:59.999999
2018-05-20 00:00:00
2019-03-26 07:20:37.190235
2019-03-26 07:20:37.190235
2019-03-25 23:20:37.191235
1553556037.190235
2019-03-26 07:20:37.190235
2019-03-26
07:20:37.190235
2019-03-26 07:20:37.190235
2019-03-26 07:20:37 <class 'str'>
2019-03-26 07:20:37
datetime类是date类与time类的结合，其实例属性与方法也在前面date类与time类中出现，其中有：
datetime.year、month、day、hour、minute、second、microsecond、tzinfo：
datetime.date()：获取date对象；
datetime.time()：获取time对象；
datetime. replace ([ year[ , month[ , day[ , hour[ , minute[ ,
second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])：
datetime. timetuple ()
datetime. utctimetuple ()
datetime. toordinal ()
datetime. weekday ()
datetime. isocalendar ()
datetime. isoformat ([ sep] )
datetime. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
datetime. strftime (format)
datetime、date、time都提供了strftime()方法，格式字符串，在前面time模块里面已经做过说明，此方法使用一样
2.4、timedelta 对象
timedelta 对象表示两个日期或时间之间的间隔。
datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
以上所有的参数都是可选的（默认为 0），参数的可以是整数或浮点数，正数或负数。
内部的存储单位只有 days（天）、seconds（秒）、microseconds（毫秒），其他单位均先转换后再存储
1 millisecond = 1000 microseconds
1 minute = 60 seconds
1 hour = 3600 seconds
1 week = 7 days
timedelta类属性：
timedelta.min：负数最大时间差，相当于 timedelta(-999999999)。
timedelta.max：正数最大时间差，相当于 timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)。
timedelta.resolution：两个时间的最小差值 相当于 timedelta(microseconds=1)
print (timedelta.min)
print (timedelta.max)
print (timedelta.resolution)
-999999999 days, 0:00:00
999999999 days, 23:59:59.999999
0:00:00.000001
timedelta 实例方法：
timedelta.total_seconds() 返回 timedelta 对象所包含的总秒数，相当于timedelta(seconds=1)
from datetime import timedelta
t1 = datetime.now()
print (t1)
# 加一秒
t3 = t1 + timedelta(seconds = 1)
print (t3)
# 加一分钟
t4 = t1 + timedelta(minutes = 1)
print (t4)
#加一小时
t5 = t1 + timedelta(hours = 1)
print (t5)
# 加一天
t6 = t1 + timedelta(days = 1)
print (t6)
# 加一个星期
t7 = t1 + timedelta(weeks = 1)
print (t7)
# timedelta转化为其对应的秒数
dt1 = t6 - t1
print (dt1)
dt11 = dt1.total_seconds()
print (dt11)
2019-03-26 07:20:37.385598
2019-03-26 07:20:38.385598
2019-03-26 07:21:37.385598
2019-03-26 08:20:37.385598
2019-03-27 07:20:37.385598
2019-04-02 07:20:37.385598
1 day, 0:00:00
86400.0
3、日历（Calendar）模块
此模块的函数都是日历相关的，例如打印某月的字符月历。
星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。
模块包含了以下内置函数：
| 函数 | 描述 |
|---|---|
| calendar.calendar((year, w=2, l=1, c=6, m=3)) | 打印一年的日历，w每个单元格宽度，默认2，l每列换l行，默认1行，c表示月与月之间的间隔宽度，默认为6，m表示将12个月分为m列。 |
| calendar.firstweekday( ) | 返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。 |
| calendar.isleap(year) | 是闰年返回True，否则为false。 |
| calendar.leapdays(y1,y2) | 返回在Y1，Y2两年之间的闰年总数。计算不包含y2年 |
| calendar.month(year,month,w=2,l=1) | 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行间距数。 |
| calendar.monthcalendar(year,month) | 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。 |
| calendar.monthrange(year,month) | 返回一个由一个月第一个天的星期与当前月的天数组成的元组。 |
| calendar.prcal(year,w=2,l=1,c=6) | 相当于 print calendar.calendar(year,w,l,c). |
| calendar.prmonth(year,month,w=2,l=1) | 相当于 print calendar.month(year,month,w=2,l=1) |
| calendar.setfirstweekday(weekday) | 设置每周的起始日期码。0（星期一）到6（星期日）。 |
| calendar.timegm(tupletime) | 和time.gmtime相反，与time.mktime类似：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。 |
| calendar.weekday(year,month,day) | 获取指定日期为星期几。0（星期一）到6（星期日）。 |
import calendar
print (calendar.calendar(2019,m=4))
calendar.setfirstweekday(firstweekday=0)
print (calendar.firstweekday())
calendar.setfirstweekday(firstweekday=6)
print (calendar.firstweekday())
print (calendar.isleap(2019))
print (calendar.leapdays(2008,2019))
print (calendar.month(2019,4))
print (calendar.monthcalendar(2019,4))
print (calendar.monthrange(2019,4))
calendar.prcal(2019,m=4)
print (calendar.weekday(2019,3,25))
import time
t1 = time.gmtime()
print (t1)
t2 = calendar.timegm(t1)
print (t2)
t11 = time.localtime()
print (t11)
t22 = calendar.timegm(t11)
print (t22)
print (time.mktime(t11))
2019
January February March April
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31 29 30
May June July August
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7 1 2 3 4
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14 5 6 7 8 9 10 11
13 14 15 16 17 18 19 10 11 12 13 14 15 16 15 16 17 18 19 20 21 12 13 14 15 16 17 18
20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28 19 20 21 22 23 24 25
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31 26 27 28 29 30 31
September October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 1 2 3 4 5 6 1 2 3 1
2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8
9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15
16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22
23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29
30 30 31
0
6
False
3
April 2019
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30
[[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13], [14, 15, 16, 17, 18, 19, 20], [21, 22, 23, 24, 25, 26, 27], [28, 29, 30, 0, 0, 0, 0]]
(0, 30)
2019
January February March April
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 1 2 1 2 1 2 3 4 5 6
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9 7 8 9 10 11 12 13
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16 14 15 16 17 18 19 20
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23 21 22 23 24 25 26 27
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30 28 29 30
31
May June July August
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 1 1 2 3 4 5 6 1 2 3
5 6 7 8 9 10 11 2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10
12 13 14 15 16 17 18 9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17
19 20 21 22 23 24 25 16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24
26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30 31
30
September October November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7 1 2 3 4 5 1 2 1 2 3 4 5 6 7
8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16 15 16 17 18 19 20 21
22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28
29 30 27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
0
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=25, tm_hour=23, tm_min=20, tm_sec=37, tm_wday=0, tm_yday=84, tm_isdst=0)
1553556037
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=7, tm_min=20, tm_sec=37, tm_wday=1, tm_yday=85, tm_isdst=0)
1553584837
1553556037.0
4、pandas时间日期
pd.datetime
pd.Timestamp
pd.date_range
pd.to_date
import pandas as pd
4.1、pd.datetime(%Y,%m,%d,%H,%M,%S)获取指定的时间和日期
共有6个参数，分别代表的是年月日时分秒。其中年月日是必须要传入的参数，时分秒可以不传入，默认全为零
与datetime模块里面的datetime类方法属性一样
t1 = pd.datetime(2019,3,25,8,0,1)
print (t1)
print (type(t1))
print (t1.weekday())
print (t1.timetuple())
2019-03-25 08:00:01
<class 'datetime.datetime'>
0
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=25, tm_hour=8, tm_min=0, tm_sec=1, tm_wday=0, tm_yday=84, tm_isdst=-1)
4.2、pd.Timestamp时间戳,表示时间轴上的一个时刻，提供了时区转换功能
pd.Timestamp(ts_input, freq=None, tz=None, unit=None,year=None, month=None, day=None, hour=None, minute=None,second=None, microsecond=None, nanosecond=None, tzinfo=None)
| 参数 | 意义 |
|---|---|
| ts_input | datetime-like,str,int,float#要转换为时间戳的值 |
| freq | str,DateOffset |
| tz | str,pytz.timezone,dateutil.tz.tzfile或None#时间时区 |
| unit | str#如ts_input为int或float,则用于转换的单位。该有效值为’D’,‘h’,‘m’,‘s’,‘ms’,‘us’和’ns’ |
| year, month, day | int |
| hour, minute, second, microsecond | int, optional, default 0 |
| nanosecond | int,optional,默认值为0 |
| tzinfo | datetime.tzinfo,可选,默认无 |
创建Timestamp：
# date_like
t1 = pd.Timestamp(2019,3,26,7,45)
print (t1)
# str
t2 = pd.Timestamp('2019-03-26 7:45:00')
print (t2)
# int or float
a = (t2 - pd.Timestamp("1970-01-01")) // pd.Timedelta('1s')
print (a)
a1 = t2.timestamp()
print (a1)
t3 = pd.Timestamp(a,unit='s')
print (t3)
t4 = pd.Timestamp(year=2019, month=3, day=26, hour=22,minute=43)
print (t4)
t5 = pd.Timestamp.now()
print (t5)
2019-03-26 07:45:00
2019-03-26 07:45:00
1553586300
1553586300.0
2019-03-26 07:45:00
2019-03-26 22:43:00
2019-03-26 22:48:10.009572
Timestamp实例属性和方法：
a2 = t5.value #时间戳单位为ns
a21 = t5.timestamp() #时间戳单位为s
print (a2)
print (a21)
# 返回一年中第多少周
print (t5.weekofyear)
# 设置时区
t5 = pd.Timestamp(t5,tz='Asia/Shanghai')
print (t5.tz)
print (t5.tzinfo)
print (t5.is_leap_year )
print (t5.is_month_end )
print (t5.is_month_start )
print (t5.is_quarter_end )
print (t5.is_quarter_start)
print (t5.is_year_end )
print (t5.is_year_start )
print (t5.year,t5.month,t5.day)
print (t5.ctime())
print (t5.timetuple())
print (t5.timestamp())
print (t5.to_datetime64())
1553611690009572000
1553611690.009572
13
Asia/Shanghai
Asia/Shanghai
False
False
False
False
False
False
False
2019 3 26
Tue Mar 26 22:48:10 2019
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=26, tm_hour=22, tm_min=48, tm_sec=10, tm_wday=1, tm_yday=85, tm_isdst=0)
1553611690.009572
2019-03-26T14:48:10.009572000
4.3、pd.date_range作用是创建一个时间序列的索引，其原型为：
pandas.data_range(start=None, end=None, periods=None, freq=’D’, tz=None, normalize=False, name=None, closed=None, **kwargs)
| 参数 | 意义 |
|---|---|
| start | string类型，默认为None，表示时间起点 |
| end | 同上，表示时间终点 |
| periods | int类型，默认为None，表示日期索引个数。若为None，则start和end不能为空 |
| freq | string类型，默认为‘D’，表示计时单位（frequence），例如‘D’表示每隔1天，‘3H’表示每隔3小时 |
| tz | string类型，表示时区，默认为None |
| normalize | bool类型， 默认为False，若为True，则将强行将start和end转化为当天的0点 |
| name | string类型，给返回的时间索引值一个name |
| closed | string类型，默认为None，表示start和end这个区间的端点是否包含在内，‘left’表示左闭右开，‘right’表示右闭左开，None则表示两边都为闭区间 |
t1 = pd.date_range(start='20190326',periods = 3,freq = '3D')
print (t1)
t2 = pd.date_range(start='20190326',end='20190812',periods = 6)
print (t2)
print (type(t2))
DatetimeIndex(['2019-03-26', '2019-03-29', '2019-04-01'], dtype='datetime64[ns]', freq='3D')
DatetimeIndex(['2019-03-26 00:00:00', '2019-04-22 19:12:00',
'2019-05-20 14:24:00', '2019-06-17 09:36:00',
'2019-07-15 04:48:00', '2019-08-12 00:00:00'],
dtype='datetime64[ns]', freq=None)
<class 'pandas.core.indexes.datetimes.DatetimeIndex'>
4.4、pd.to_datetime方法可以解析多种不同的日期表示形式
pandas.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 : integer, float, string, datetime, list, tuple, 1-d array, Series,DataFrame/dict-like
errors : {‘ignore’, ‘raise’, ‘coerce’}, default ‘raise’
If ‘raise’, then invalid parsing will raise an exception
If ‘coerce’, then invalid parsing will be set as NaT
If ‘ignore’, then invalid parsing will return the input
# int or float 以ns为单位的时间戳
t0 = pd.Timestamp.now()
a1 = t0.value
print (a1)
t00 = pd.to_datetime(a1)
print (t00)
# str
t1 = pd.to_datetime('20190325')
print (t1)
print (type(t1))
t2 = pd.to_datetime('2019/03/25')
print (t2)
t3 = pd.to_datetime('2019-03-25')
print (t3)
t4 = pd.to_datetime('03/25/2019')
print (t4)
t5 = pd.to_datetime('2019/03/25',format='%Y-%m-%d')
print (t5)
print(t5.day_name())
print(t5.day)
# list
s1 = ['20190324','20190325','20190326']
t6 = pd.to_datetime(s1)
print (t6)
# tuple
t1 = ('20190324','20190325','20190326')
t7 = pd.to_datetime(t1)
print (t7)
# Series
sr1 = pd.Series(['20190324','20190325','20190326'])
print (sr1)
t8 = pd.to_datetime(sr1)
print (t8)
print ('*-'*30)
print (type(t8.dt))
print (t8.dt.year,'\n',t8.dt.month,'\n',t8.dt.day)
print (t8.dt.is_month_end)
print ('*-'*40)
print (t8[0])
print (t8[0].ctime())
print (t8[0].timetuple())
print (t8[0].timestamp())
print (t8[0].to_datetime64())
1553646269938539000
2019-03-27 00:24:29.938539
2019-03-25 00:00:00
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
2019-03-25 00:00:00
2019-03-25 00:00:00
2019-03-25 00:00:00
2019-03-25 00:00:00
Monday
25
DatetimeIndex(['2019-03-24', '2019-03-25', '2019-03-26'], dtype='datetime64[ns]', freq=None)
DatetimeIndex(['2019-03-24', '2019-03-25', '2019-03-26'], dtype='datetime64[ns]', freq=None)
0 20190324
1 20190325
2 20190326
dtype: object
0 2019-03-24
1 2019-03-25
2 2019-03-26
dtype: datetime64[ns]
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
<class 'pandas.core.indexes.accessors.DatetimeProperties'>
0 2019
1 2019
2 2019
dtype: int64
0 3
1 3
2 3
dtype: int64
0 24
1 25
2 26
dtype: int64
0 False
1 False
2 False
dtype: bool
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
2019-03-24 00:00:00
Sun Mar 24 00:00:00 2019
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=83, tm_isdst=-1)
1553385600.0
2019-03-24T00:00:00.000000000
0 2019
1 2019
2 2019
dtype: int64
0 3
1 3
2 3
dtype: int64
0 24
1 25
2 26
dtype: int64
0 False
1 False
2 False
dtype: bool
<class 'pandas.core.indexes.accessors.DatetimeProperties'>