整合营销服务商
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
在 Python 中是没有原生数据类型支持时间的，日期与时间的操作需要借助三个模块，分别是 time、datetime、calendar。
在学习之前，还有一些术语要补充一下，这些术语你当成惯例即可。这里在 Python 官方文档中也有相关说明，不过信息比较多，橡皮擦为你摘录必须知道的一部分。
epoch（纪元） 是时间开始的点，其值取决于平台。
对于 Unix， epoch（纪元） 是 1970年1月1日00:00:00（UTC）。要找出给定平台上的 epoch ，请使用 time.gmtime(0) 进行查看，例如橡皮擦电脑显示：
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)术语 纪元秒数 是指自 epoch （纪元）时间点以来经过的总秒数，通常不包括闰秒。 在所有符合 POSIX 标准的平台上，闰秒都不会记录在总秒数中。
程序员中常把 纪元秒数 称为 时间戳。
该模块核心为控制时钟时间。
该函数获取时钟的基本信息，得到的值因不同系统存在差异，函数原型比较简单：
time.get_clock_info(name)其中 name 可以取下述值：
该函数的返回值具有以下属性：
import time
available_clocks = [
('clock', time.clock),
('monotonic', time.monotonic),
('perf_counter', time.perf_counter),
('process_time', time.process_time),
('time', time.time),
]
for clock_name, func in available_clocks:
print('''
{name}:
adjustable : {info.adjustable}
implementation: {info.implementation}
monotonic : {info.monotonic}
resolution : {info.resolution}
current : {current}
'''.format(
name=clock_name,
info=time.get_clock_info(clock_name),
current=func()))运行结果如下图所示。
上图显示橡皮擦的计算机在 clock 与 perf_counter 中，调用底层 C 函数是一致的。
在 Python 中通过 time.time() 函数获取纪元秒数，它可以把从 epoch 开始之后的秒数以浮点数格式返回。
import time
print(time.time())
# 输出结果 1615257195.558105时间戳大量用于计算时间相关程序，属于必须掌握内容。
时间戳主要用于时间上的方便计算，对于人们阅读是比较难理解的，如果希望获取可读时间，使用 ctime() 函数获取。
import time
print(time.ctime())
# 输出内容：Tue Mar 9 10:35:51 2021如何将时间戳转换为可读时间，使用 localtime 函数即可。
localtime = time.localtime(time.time())
print("本地时间为 :", localtime)输出结果为 <class 'time.struct_time'> 类型数据，后文将对其进行格式化操作：
本地时间为 : time.struct_time(tm_year=2021, tm_mon=3, tm_mday=9, tm_hour=10, tm_min=37, tm_sec=27, tm_wday=1, tm_yday=68, tm_isdst=0)上述代码中的时间戳最小值是 0，最大值由于 Python 环境和操作系统决定，我本地 64 位操作系统进行测试的时候，得到的数据如下：
import time
localtime = time.localtime(0)
print("时间为 :", localtime)
# 时间为 : time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
localtime = time.localtime(32536799999)
print("时间为 :", localtime)
# 时间为 : time.struct_time(tm_year=3001, tm_mon=1, tm_mday=19, tm_hour=15, tm_min=59, tm_sec=59, tm_wday=0, tm_yday=19, tm_isdst=0)
localtime = time.localtime(99999999999)
print("时间为 :", localtime)
# OSError: [Errno 22] Invalid argument
print(type(localtime))monotonic time 从系统启动开始计时，从 0 开始单调递增。
操作系统的时间可能不是从 0 开始，而且会因为时间出错而回调。
该函数原型如下，不需要任何参数，返回一个浮点数，表示小数秒内的单调时钟的值：
time.monotonic()测试代码如下：
print("单调时间",time.monotonic())
# 输出：单调时间 12279.244time() 函数返回的是纪元秒数（时间戳）， clock() 函数返回的是处理器时钟时间。
该函数函数的返回值：
需要注意的是 Python 3.8 已移除 clock() 函数，用 time.perf_counter() 或 time.process_time() 方法替代。
t0 = time.clock()
# 运行一段代码
print(time.clock() - t0, "程序运行时间")我使用的 Python 版本较高，提示异常如下：
time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead t0 = time.clock()perf_counter() 函数的 epoch （纪元）是未定义的。一般使用该函数都是为了比较和计算，不是为了用作绝对时间，该点需要注意下。
该函数用于测量较短持续时间的具有最高有效精度的时钟，包括睡眠状态消耗的时间，使用两次调用才会有效。
测试代码如下：
t0 = time.perf_counter()
# 运行一段代码
for i in range(100000):
pass
print("程序运行时间", time.perf_counter() - t0)与其类似的函数有 perf_counter_ns()、process_time()、process_time_ns()，具体可以查询手册进行学习，先掌握 perf_counter() 函数即可。
上文已经涉及了时间组件相关的知识，通过 localtime 得到的 struct_time 类型的数据。
这里涉及到的函数有 gmtime() 返回 UTC 中的当前时间，localtime() 返回当前时区对应的时间，mktime() 接收 struce_time 类型数据并将其转换成浮点型数值，即时间戳。
print("*"*10)
print(time.gmtime())
print("*"*10)
print(time.localtime())
print("*"*10)
print(time.mktime(time.localtime()))struct_time 类型包含的内容
上述代码返回的数据格式为：
time.struct_time(tm_year=2021, tm_mon=3, tm_mday=9, tm_hour=12, tm_min=50, tm_sec=35, tm_wday=1, tm_yday=68, tm_isdst=0)其中各值可以根据英文含义进行理解 ：tm_year 年份（range[1,12]），tm_mon 月份（range[1,12]），tm_mday 天数（range[1,31]），tm_hour 天数（range[0,23]），tm_min 分钟 （range[0,59]）， tm_sec 秒数 （range[0,61]）， tm_wday 星期 （range[0,6]，0 是星期日）， tm_yday 一年中的一天（range[1,366] ），tm_isdst 在夏令时生效时设置为 1，而在夏令时不生效时设置为 0，值-1 表示这是未知的。
strptime() 和 strftime() 函数可以使时间值在 struct_time 表示和字符串表示之间相互转换。
对于 strftime 函数，其中的参数参考官方即可。
x = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(x)这里的学习，没有什么难度大的点，孰能生巧的知识。
strptime 函数的应用
x = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(x)
# 方向操作，字符串格式化成 time.struct_time
struct_time = time.strptime(x, "%Y-%m-%d %H:%M:%S")
print(struct_time)需要记忆的就是 strftime 与 strptime 函数只有中间的字符不同，一个是 f ，另一个是 p。
对于 time 模块，sleep 函数属于必备知识点，但是太常用了，你肯定已经很熟悉了。
对于模块的学习，最权威的就是官方手册了——time 模块。
该模块比 time 模块高级了很多，并且对 time 模块进行了封装，提供的功能更加强大了。
在 datetime 模块中，Python 提供了 5 个主要的对象类，分别如下：
优先展示部分该类的属性和方法，都是记忆层面的知识。
测试代码如下：
from datetime import date
import time
print('date.min:', date.min)
print('date.max:', date.max)
print('date.resolution:', date.resolution)
print('date.today():', date.today())
print('date.fromtimestamp():', date.fromtimestamp(time.time()))输出结果：
date.min: 0001-01-01
date.max: 9999-12-31
date.resolution: 1 day, 0:00:00
date.today(): 2021-03-09
date.fromtimestamp(): 2021-03-09date 对象的属性和方法
通过下述代码创建一个 date 对象：
d = date(year=2021,month=3,day=9)
print(d)该对象具备下述属性和方法：
time 类定义的类属性：
通过其构造函数可以创建一个 time 对象。
t = time(hour=20, minute=20, second=40)
print(t)time 类提供的实例方法和属性：
该类是 date 类与 time 类的结合体，很多属性和方法前文已经介绍，再补充一些比较常用的属性和方法。
获取当前的日期与时间：
from datetime import datetime
dt = datetime.now()
print(dt)获取时间戳：
dt = datetime.now()
# 使用 datetime 的内置函数 timestamp()
stamp = datetime.timestamp(dt)
print(stamp)通过 timedelta 函数返回一个 timedelta 时间间隔对象，该函数没有必填参数，如果写入一个整数就是间隔多少天的的意思。
# 间隔 10 天
timedelta(10)
# 跨度为1 周
timedelta(weeks=1)两个时间间隔对象可以彼此之间相加或相减，返回的仍是一个时间间隔对象。
一个 datetime 对象如果减去一个时间间隔对象，那么返回的对应减去之后的 datetime 对象，然后两个 datetime 对象如果相减，返回的是一个时间间隔对象。
更多关于 datetime 类使用的知识，可以参考官方手册。
此模块的函数都是日历相关的，例如打印某月的字符月历。
calendar 模块定义了 Calendar 类，它封装了值的计算， 例如给定月份或年份中周的日期。通过 TextCalendar 和 HTMLCalendar 类可以生成预格式化的输出。
基本代码：
import calendar
c = calendar.TextCalendar(calendar.SUNDAY)
c.prmonth(2021, 3)上述代码，默认是从周日开始的，输出结果：
March 2021
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 31该模块使用频率较低，详细使用参考地址 进行学习。
本篇博客为大家补充了一下时间和日期库的相关知识，希望能进入你的收藏夹。
作者：梦想橡皮擦
原文链接：https://blog.csdn.net/hihell/article/details/114413866
秒 在1967年的第13届国际度量衡会议上决定以原子时定义的秒作为时间的国际标准单位：铯133原子基态的两个超精细能阶间跃迁对应辐射的9,192,631,770个周期的持续时间, 起始历元定在1958年1月1日0时。
原子钟是一种时钟，它以原子共振频率标准来计算及保持时间的准确。原子钟是世界上已知最准确的时间测量和频率标准。
GMT 格林威治标准时间（Greenwich Mean Time），是指位于伦敦郊区的皇家格林威治天文台的标准时间，因为本初子午线（Prime meridian）被定义为通过那里的经线。GMT也叫世界时UT。
UTC 协调世界时间（Coordinated Universal Time）, 又称世界标准时间，基于国际原子钟，误差为每日数纳秒。协调世界时的秒长与原子时的秒长一致，在时刻上则要求尽量与世界时接近（规定二者的差值保持在 0.9秒以内）。
闰秒 不只有闰年，还有闰秒。闰秒是指为保持协调世界时接近于世界时时刻，由国际计量局统一规定在年底或年中（也可能在季末）对协调世界时增加或减少1秒的调整。由于地球自转的不均匀性和长期变慢性（主要由潮汐摩擦引起的），会使世界时（民用时）和原子时之间相差超过到±0.9秒时，就把世界时向前拨1秒（负闰秒，最后一分钟为59秒）或向后拨1秒（正闰秒，最后一分钟为61秒）；闰秒一般加在公历年末或公历六月末。
时区 是地球上的区域使用同一个时间定义。有关国际会议决定将地球表面按经线从南到北，划分成24个时区，并且规定相邻区域的时间相差1小时。当人们跨过一个区域，就将自己的时钟校正1小时（向西减1小时，向东加1小时），跨过几个区域就加或减几小时。比如我大中国处于东八区，表示为GMT+8。
夏令时 （Daylight Saving Time：DST），又称日光节约时制、日光节约时间或夏令时间。这是一种为节约能源而人为规定地方时间的制度，在夏天的时候，白天的时间会比较长，所以为了节约用电，因此在夏天的时候某些地区会将他们的时间定早一小时，也就是说，原本时区是8点好了，但是因为夏天太阳比较早出现，因此把时间向前挪，在原本8点的时候，订定为该天的9点(时间提早一小时)～如此一来，我们就可以利用阳光照明，省去了花费电力的时间，因此才会称之为夏季节约时间！
Unix时间戳 指的是从协调世界时（UTC）1970年1月1日0时0分0秒开始到现在的总秒数，不考虑闰秒。
在 Python 文档里，time是归类在Generic Operating System Services中，换句话说， 它提供的功能是更加接近于操作系统层面的。通读文档可知，time 模块是围绕着 Unix Timestamp 进行的。
该模块主要包括一个类 struct_time，另外其他几个函数及相关常量。需要注意的是在该模块中的大多数函数是调用了所在平台C library的同名函数， 所以要特别注意有些函数是平台相关的，可能会在不同的平台有不同的效果。另外一点是，由于是基于Unix Timestamp，所以其所能表述的日期范围被限定在 1970 – 2038 之间，如果你写的代码需要处理在前面所述范围之外的日期，那可能需要考虑使用datetime模块更好。
获取当前时间和转化时间格式
>>> import time
>>> time.time()
1473386416.954
>>> time.ctime()
'Fri Sep 09 10:00:25 2016'
>>> time.ctime(time.time())
'Fri Sep 09 10:28:08 2016'
>>> time.asctime()
'Fri Sep 09 10:22:40 2016'
>>> time.asctime(time.localtime())
'Fri Sep 09 10:33:00 2016'
>>> time.localtime()
time.struct_time(tm_year=2016, tm_mon=9, tm_mday=9, tm_hour=10, tm_min=1, tm_sec=19, tm_wday=4, tm_yday=253, tm_isdst=0)
>>> time.localtime(time.time())
time.struct_time(tm_year=2016, tm_mon=9, tm_mday=9, tm_hour=10, tm_min=19, tm_sec=11, tm_wday=4, tm_yday=253, tm_isdst=0)
>>> time.gmtime()
time.struct_time(tm_year=2016, tm_mon=9, tm_mday=9, tm_hour=2, tm_min=13, tm_sec=10, tm_wday=4, tm_yday=253, tm_isdst=0)
>>> time.gmtime(time.time())
time.struct_time(tm_year=2016, tm_mon=9, tm_mday=9, tm_hour=2, tm_min=15, tm_sec=35, tm_wday=4, tm_yday=253, tm_isdst=0)
struct_time共有9个元素，其中前面6个为年月日时分秒，后面三个分别代表的含义为：
time.mktime()
将一个以struct_time格式转换为时间戳
>>> time.mktime(time.localtime())
1473388585.0
time.strftime(format[,t]) 把一个struct_time时间转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素越界，ValueError的错误将会被抛出。
>>> time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
'2016-09-09 10:54:21'
time.strptime(string[,format])
把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
>>> time.strptime(time.ctime())
time.struct_time(tm_year=2016, tm_mon=9, tm_mday=9, tm_hour=11, tm_min=0, tm_sec=4, tm_wday=4, tm_yday=253, tm_isdst=-1)
time.sleep(secs)
线程推迟指定的时间运行。单位为秒。
time.clock()
这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）
import time
time.sleep(1)
print("clock1:%s" % time.clock())
time.sleep(1)
print("clock2:%s" % time.clock())
time.sleep(1)
print("clock3:%s" % time.clock())
运行结果为：
clock1:1.57895443216e-06
clock2:1.00064381867
clock3:2.00158724394
其中第一个clock()输出的是程序运行时间，第二、三个clock()输出的都是与第一个clock的时间间隔
import time
print(time.timezone)
print(time.tzname)
print(time.tzname[0].decode("GBK"))
print(time.tzname[1].decode("GBK"))
运行结果
-28800
('\xd6\xd0\xb9\xfa\xb1\xea\xd7\xbc\xca\xb1\xbc\xe4', '\xd6\xd0\xb9\xfa\xcf\xc4\xc1\xee\xca\xb1')
中国标准时间
中国夏令时
datetime 比 time 高级了不少，可以理解为 datetime 基于 time 进行了封装，提供了更多实用的函数。
datetime模块定义了下面这几个类：
注：上面这些类型的对象都是不可变（immutable）的。
date类定义了一些常用的类方法与类属性:
from datetime import date
import time
print('date.max:', date.max)
print('date.min:', date.min)
print('date.resolution:', date.resolution)
print('date.today():', date.today())
print('date.fromtimestamp():', date.fromtimestamp(time.time()))
执行结果：
date.max: 9999-12-31
date.min: 0001-01-01
date.resolution: 1 day, 0:00:00
date.today(): 2016-09-12
date.fromtimestamp(): 2016-09-12
date提供的实例方法和属性：
from datetime import date
today = date.today()
print('today:', today)
print('.year:', today.year)
print('.month:', today.month)
print('.replace():', today.replace(year=2017) )
print('.weekday():', today.weekday())
print('.isoweekday():', today.isoweekday())
print('.isocalendar():', today.isocalendar())
print('.isoformat():', today.isoformat())
print('.strftime():', today.strftime('%Y-%m-%d') )
print('.toordinal():', today.toordinal())
执行结果：
today: 2016-09-12
.year: 2016
.month: 9
.replace(): 2017-09-12
.weekday(): 0
.isoweekday(): 1
.isocalendar(): (2016, 37, 1)
.isoformat(): 2016-09-12
.strftime(): 2016-09-12
.toordinal(): 736219
date还对某些操作进行了重载，它允许我们对日期进行如下一些操作：
time类的构造函数如下：（其中参数tzinfo，它表示时区信息。）
class datetime.time(hour[, minute[, second[, microsecond[, tzinfo]]]])
time类定义的类属性：
time类提供的实例方法和属性：
像date一样，也可以对两个time对象进行比较，或者相减返回一个时间间隔对象。这里就不提供例子了。
datetime是date与time的结合体，包括date与time的所有信息。它的构造函数如下：datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])，各参数的含义与date、time的构造函数中的一样，要注意参数值的范围。
datetime类定义的类属性与方法：
from datetime import datetime
import time
print('datetime.max:', datetime.max)
print('datetime.min:', datetime.min)
print('datetime.resolution:', datetime.resolution)
print('today():', datetime.today())
print('now():', datetime.now())
print('utcnow():', datetime.utcnow())
print('fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time()))
print('utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time()))
运行结果：
datetime.max: 9999-12-31 23:59:59.999999
datetime.min: 0001-01-01 00:00:00
datetime.resolution: 0:00:00.000001
today(): 2016-09-12 19:57:00.761000
now(): 2016-09-12 19:57:00.761000
utcnow(): 2016-09-12 11:57:00.761000
fromtimestamp(tmstmp): 2016-09-12 19:57:00.761000
utcfromtimestamp(tmstmp): 2016-09-12 11:57:00.761000
datetime类提供的实例方法与属性（很多属性或方法在date和time中已经出现过，在此有类似的意义，这里只罗列这些方法名，具体含义不再逐个展开介绍，可以参考上文对date与time类的讲解。）：
year、month、day、hour、minute、second、microsecond、tzinfo：
像date一样，也可以对两个datetime对象进行比较，或者相减返回一个时间间隔对象，或者日期时间加上一个间隔返回一个新的日期时间对象。
通过timedelta函数返回一个timedelta对象，也就是一个表示时间间隔的对象。函数参数情况如下所示:
class datetime.timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
其没有必填参数，简单控制的话第一个整数就是多少天的间隔的意思:
datetime.timedelta(10)
两个时间间隔对象可以彼此之间相加或相减，返回的仍是一个时间间隔对象。而更方便的是一个datetime对象如果减去一个时间间隔对象，那么返回的对应减去之后的datetime对象，然后两个datetime对象如果相减返回的是一个时间间隔对象。这很是方便。
tzinfo是一个抽象类，不能被直接实例化。需要派生子类，提供相应的标准方法。datetime模块并不提供tzinfo的任何子类。最简单的方式是使用pytz模块。
pytz是Python的一个时区处理模块（同时也包括夏令时），在理解时区处理模块之前，需要先要了解一些时区的概念。
要知道时区之间的转换关系，其实这很简单：把当地时间减去当地时区，剩下的就是格林威治时间了。例如北京时间的18:00就是18:00+08:00，相减以后就是10:00+00:00，因此就是格林威治时间的10:00。
Python的datetime可以处理2种类型的时间，分别为offset-naive和offset-aware。前者是指没有包含时区信息的时间，后者是指包含时区信息的时间，只有同类型的时间才能进行减法运算和比较。
datetime模块的函数在默认情况下都只生成offset-naive类型的datetime对象，例如now()、utcnow()、fromtimestamp()、utcfromtimestamp()和strftime()。其中now()和fromtimestamp()可以接受一个tzinfo对象来生成offset-aware类型的datetime对象，但是标准库并不提供任何已实现的tzinfo类，只能自己实现。
下面就是实现格林威治时间和北京时间的tzinfo类的例子：
ZERO_TIME_DELTA = timedelta(0)
LOCAL_TIME_DELTA = timedelta(hours=8) # 本地时区偏差
class UTC(tzinfo):
def utcoffset(self, dt):
return ZERO_TIME_DELTA
def dst(self, dt):
return ZERO_TIME_DELTA
class LocalTimezone(tzinfo):
def utcoffset(self, dt):
return LOCAL_TIME_DELTA
def dst(self, dt):
return ZERO_TIME_DELTA
def tzname(self, dt):
return '+08:00'
一个tzinfo类需要实现utcoffset、dst和tzname这3个方法。其中utcoffset需要返回夏时令的时差调整；tzname需要返回时区名，如果你不需要用到的话，也可以不实现。
一旦生成了一个offset-aware类型的datetime对象，我们就能调用它的astimezone()方法，生成其他时区的时间（会根据时差来计算）。而如果拿到的是offset-naive类型的datetime对象，也是可以调用它的replace()方法来替换tzinfo的，只不过这种替换不会根据时差来调整其他时间属性。因此，如果拿到一个格林威治时间的offset-naive类型的datetime对象，直接调用replace(tzinfo=UTC())即可转换成offset-aware类型，然后再调用astimezone()生成其他时区的datetime对象。
看上去一切都很简单，但不知道你还是否记得上文所述的夏时令。提起夏时令这个玩意，真是让我头疼，因为它没有规则可循：有的国家实行夏时令，有的国家不实行，有的国家只在部分地区实行夏时令，有的地区只在某些年实行夏时令，每个地区实行夏时令的起止时间都不一定相同，而且有的地方TMD还不是用几月几日来指定夏时令的起止时间的，而是用某月的第几个星期几这种形式。
pytz模块，使用Olson TZ Database解决了跨平台的时区计算一致性问题，解决了夏令时带来的计算问题。由于国家和地区可以自己选择时区以及是否使用夏令时，所以pytz模块在有需要的情况下得更新自己的时区以及夏令时相关的信息。
pytz提供了全部的timezone信息，如：
import pytz
print(len(pytz.all_timezones))
print(len(pytz.common_timezones))
运行结果：
588
436
如果需要获取某个国家的时区，可以使用如下方式：
import pytz
print(pytz.country_timezones('cn'))
执行结果：
[u'Asia/Shanghai', u'Asia/Urumqi']
中国一个有两个时区，一个为上海，一个为乌鲁木齐，我们来看下我们有什么区别：
from datetime import datetime
import pytz
print(pytz.country_timezones('cn'))
tz1 = pytz.timezone(pytz.country_timezones('cn')[0])
print(tz1)
print(datetime.now(tz1))
tz2 = pytz.timezone(pytz.country_timezones('cn')[1])
print(tz2)
print(datetime.now(tz2))
执行结果：
[u'Asia/Shanghai', u'Asia/Urumqi']
Asia/Shanghai
2016-09-14 09:55:39.384000+08:00
Asia/Urumqi
2016-09-14 07:55:39.385000+06:00
可以看到上海是东八区，而乌鲁木齐是东六区。
操作起来有而比较简单，本地时区与UTC的互转：
from datetime import datetime
import pytz
now = datetime.now()
tz = pytz.timezone('Asia/Shanghai')
print(tz.localize(now))
print(pytz.utc.normalize(tz.localize(now)))
执行结果：
2016-09-14 10:25:44.633000+08:00
2016-09-14 02:25:44.633000+00:00
使用astimezone()可以进行时区与时区之间的转换。
from datetime import datetime
import pytz
utc = pytz.utc
beijing_time = pytz.timezone('Asia/Shanghai')
japan_time = pytz.timezone('Asia/Tokyo')
now = datetime.now(beijing_time)
print("Beijing Time:",now)
print("UTC:",now.astimezone(utc))
print("JAPAN TIME:",now.astimezone(japan_time))
执行结果：
Beijing Time: 2016-09-14 10:19:22.671000+08:00
UTC: 2016-09-14 02:19:22.671000+00:00
JAPAN TIME: 2016-09-14 11:19:22.671000+09:00
另外可以采用 replace来修改时区，时区多出6分钟（不要使用）。具体原因为：
民國17年（1928年），國民政府統一中國，原中央觀象台的業務由南京政府中央研究院的天文研究所和氣象研究所分別接收。天文研究所編寫的曆書基本上沿襲中央觀象台的做法，仍將全國劃分為5個標準時區，只是在有關交氣、合朔、太陽出沒時刻等處，不再使用北平的地方平時，而改以南京所在的標準時區的區時即東經120°標準時替代。從北平地方平時改為東經120°標準時，兩者相差了352秒。
from datetime import datetime
import pytz
now = datetime.now()
print(now)
tz = pytz.timezone('Asia/Shanghai')
print(now.replace(tzinfo=tz))
执行结果：
2016-09-14 10:29:20.200000
2016-09-14 10:29:20.200000+08:06
由于用到的场景比较少，不做细化学习。
安装模块：pip install Python-dateutil
解析时间到datetime格式，支持大部分时间字符串。没指定时间默认是0点，没指定日期默认是今天，没指定年份默认是今年。
from dateutil import parser
print(parser.parse("8th March,2004"))
print(parser.parse("8 March,2004"))
print(parser.parse("March 8th,2004"))
print(parser.parse("March 8,2004"))
print(parser.parse("2016-09-14"))
print(parser.parse("20160914"))
print(parser.parse("2016/09/14"))
print(parser.parse("09/14/2016"))
print(parser.parse("09,14"))
print(parser.parse("12:00:00"))
print(parser.parse("Wed, Nov 12"))
执行结果：
2004-03-08 00:00:00
2004-03-08 00:00:00
2004-03-08 00:00:00
2004-03-08 00:00:00
2016-09-14 00:00:00
2016-09-14 00:00:00
2016-09-14 00:00:00
2016-09-14 00:00:00
2016-09-09 00:00:00
2016-09-14 12:00:00
2016-11-12 00:00:00
函数主要功能：按照规则生成日期和时间。函数原型如下。
rrule(self, freq, dtstart=None, interval=1, wkst=None, count=None, until=None, bysetpos=None, bymonth=None, bymonthday=None, byyearday=None, byeaster=None, byweekno=None, byweekday=None, byhour=None, byminute=None, bysecond=None, cache=False)
其中：
更多参考：http://dateutil.readthedocs.io/en/stable/index.html
Arrow 提供了一个友好而且非常易懂的方法，用于创建时间、计算时间、格式化时间，还可以对时间做转化、提取、兼容 python datetime 类型。它包括dateutil模块，根据其文档描述Arrow旨在“帮助你使用更少的代码来处理日期和时间”。
使用utcnow()功能创建 UTC 时间。
使用to()方法，我们将 UTC 时间转换为本地时间。
import arrow
utc = arrow.utcnow()
print(utc)
print(utc.to('local'))
本地时间是特定区域或时区中的时间。
import arrow
now = arrow.now()
print(now)
print(now.to('UTC'))
使用now()功能创建本地时间。to()方法用于将本地时间转换为 UTC 时间。
get()方法用于解析时间。
import arrow
d1 = arrow.get('2012-06-05 16:20:03', 'YYYY-MM-DD HH:mm:ss')
print(d1)
d2 = arrow.get(1504384602)
print(d2)
该示例从日期和时间字符串以及时间戳解析时间。
import arrow
utc = arrow.utcnow()
print(utc)
unix_time = utc.timestamp
print(unix_time)
date = arrow.Arrow.fromtimestamp(unix_time)
print(date)
该示例显示本地时间和 Unix 时间。然后，它将 Unix 时间转换回 date 对象。
使用fromtimestamp()方法，我们将 Unix 时间转换回 Arrow 日期对象。
也可以将日期格式化为 Unix 时间。
import arrow
utc = arrow.utcnow()
print(utc.format('X'))
通过将’X’说明符传递给format()方法，我们将当前本地日期打印为 Unix 时间。
日期和时间可以用format()方法格式化。
import arrow
now = arrow.now()
year = now.format('YYYY')
print("Year: {0}".format(year))
date = now.format('YYYY-MM-DD')
print("Date: {0}".format(date))
date_time = now.format('YYYY-MM-DD HH:mm:ss')
print("Date and time: {0}".format(date_time))
date_time_zone = now.format('YYYY-MM-DD HH:mm:ss ZZ')
print("Date and time and zone: {0}".format(date_time_zone))
格式说明：
import arrow
utc = arrow.utcnow()
print(utc.to('US/Pacific').format('HH:mm:ss'))
print(utc.to('Europe/Bratislava').format('HH:mm:ss'))
print(utc.to('Europe/Moscow').format('HH:mm:ss'))
可以使用weekday()或format()方法找到日期的工作日。
import arrow
d1 = arrow.get('1948-12-13')
print(d1.weekday())
print(d1.format('dddd'))
shift()方法用于移动时间。
import arrow
now = arrow.now()
print(now.shift(hours=5).time())
print(now.shift(days=5).date())
print(now.shift(years=-8).date())
import arrow
now = arrow.now()
print(now.format("YYYY-MM-DD HH:mm:ss ZZ"))
print(now.dst())
该示例使用dst()显示夏令时。
在社交网站上，我们经常可以看到诸如“一个小时前”或“ 5 分钟前”之类的术语，这些术语可以为人们提供有关帖子创建或修改时间的快速信息。Arrow 包含humanize()方法来创建此类术语。
import arrow
now = arrow.now()
d1 = now.shift(minutes=-15).humanize()
print(d1)
d2 = now.shift(hours=5).humanize()
print(d2)
国际标准ISO 8601，是国际标准化组织的日期和时间的表示方法，全称为《数据存储和交换形式·信息交换·日期和时间的表示方法》，在API接口开发中涉及的比较多。
>>> import dateutil.parser
>>> dateutil.parser.parse('2008-09-03T20:56:35.450686Z') # RFC 3339 format
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686, tzinfo=tzutc())
>>> dateutil.parser.parse('2008-09-03T20:56:35.450686') # ISO 8601 extended format
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686)
>>> dateutil.parser.parse('20080903T205635.450686') # ISO 8601 basic format
datetime.datetime(2008, 9, 3, 20, 56, 35, 450686)
>>> dateutil.parser.parse('20080903') # ISO 8601 basic format, date only
datetime.datetime(2008, 9, 3, 0, 0)
或者使用如下方式解析：
>>> datetime.datetime.strptime("2008-09-03T20:56:35.450686Z", "%Y-%m-%dT%H:%M:%S.%fZ")
另外还可以使用iso8601模块：http://pyiso8601.readthedocs.io/en/latest/
其他日期与时间工具：
atejs 是一个开源的JavaScript库，用来解析、格式化和处理日期数据，支持多种语言的日期格式处理；官网：www.datejs.com/
Moment.js 是一个简单易用的轻量级JavaScript日期处理类库，提供了日期格式化、日期解析等功能。它支持在浏览器和NodeJS两种环境中运行；
date-fns库：
现代 JavaScript 日期实用程序库。date-fns 提供了最全面，最简单和一致的工具集，用于在浏览器和 Node.js 中操作 JavaScript 日期；官网：date-fns.org
Prettydate 是一个 jQuery 用来显示一些用户友好的日期格式的插件，例如Posted 2 days ago by John Resig；
Countdown是jQuery的一个用于显示倒计时的插件；
XDate是一个对Javascirpt本地Date对象的轻度包装，它提供对日期的解析、格式化以及其他操作的较强功能；
DP_DateExtensions库继承了JavaScript的Date对象，并添加了一些新特性和功能。
组件类：
layDate 日期与时间组件，layDate 是 layui 独立维护的三大组件之一；官网：www.layui.com/laydate/
Datejs 日期库：是一个开源的JavaScript库，用来解析、格式化和处理日期数据，支持多种语言的日期格式处理；
官网：www.datejs.com/
基本用法：
// 返回今天的日期，时间设置为00:00（一天的开始）
console.log(Date.today().toString("yyyy-MM-d HH:m:s"));
//返回下一个星期五的日期
console.log(Date.today().next().friday().toString("yyyy-MM-d HH:m:s"));
Date.today().last().monday() //返回上一个星期一的日期
new Date().next().march() //返回下一个三月的日期。
new Date().last().week() //返回一周前的日期。
Date.today().is().friday() //如果星期几匹配，则返回true | false.
Date.today().is().fri() //缩写的日期名称.
Date.today().is().november() //月名称
Date.today().is().nov() //月份的缩写.
Date.today().is().weekday() //今天是工作日吗？
Date.today().addDays(1); //添加一天（+1）
Date.today().addMonths(-3); //减去三个月内（-3）
//添加一（+1）天。支持所有日期部分（年，月，日，时，分，秒，毫秒和周）
Date.today().add(1).day();
Date.today().add(-3).months(); //减去三（-3）个月
// (1).day().fromNow() //从现在起一（1）天。
// (3).months().ago() //三（3）个月前。
var n = 6;
console.log(n.months().fromNow().toString('d')); //从现在起六（6）个月。
Date.monday(); //返回当前星期的星期一。
Date.mon(); // Date.monday（）的缩写版本
Date.march(); //返回今年3月1日。
Date.mar(); // Date.march（）的缩写版本
Date.today().first().thursday(); //返回当年3月的第一个星期四。
Date.today().second().thursday();//返回当前月份的第二个星期四。
Date.march().third().thursday(); //返回当年3月的第三个星期四。
Date.october().fourth().sunday();//返回十月的第四个星期日。
//返回当前月份的第五个星期日，如果当前月份没有5个星期日，则抛出RangeError异常。
// Date.today().fifth().sunday();
Date.october().final().sunday(); //返回十月的最后一个星期日。
Date.january().first().monday(); //返回当年的第一个星期一。
Date.december().final().friday();//返回当年的最后一个星期五。
Date.today().at("6:15pm"); //返回今天的日期为6:15 pm。
var time = {hour:18, minute:15};
Date.today().at(time); //使用配置对象设置时间。
var birthDayParty = {month: 1, day: 20, hour: 20, minute: 30};
Date.today().set(birthDayParty);//使用配置对象设置日期和时间。日期解析转换：
Date.parse("t"); //返回今天的日期
Date.parse("today"); //返回今天的日期。
Date.parse("tomorrow"); //返回明天的日期
Date.parse("yesterday"); //返回昨天的日期
Date.parse("next friday"); //返回下一个星期五的日期
Date.parse("last monday"); //返回上一个星期一的日期。
Date.parse("July 8th, 2004"); // 2004年7月8日星期四
Date.parse("15-Jan-2004"); // 2004年1月15日星期四
Date.parse("7/1/2004"); // 2004年7月1日星期四
Date.parse("7.1.2004"); // 2004年7月1日星期四
Date.parse("07.15.04"); // 2004年7月15日星期四
Date.parse("July 23rd 2004"); //周五2004年7月23日
Date.parse("Sat July 3, 2004"); // 2004年7月3日星期六
Date.parse("10:30 PM EST"); // 2007年10月31日星期三20:30:00
Date.parse("10PM"); // 2007年10月31日星期三22:00:00
Date.parse("t + 5d"); //将5天加到今天
Date.parse("today - 1 month"); //从今天开始减去1个月
Date.parse("+"); //将1天添加到今天=明天
Date.parse("- 3months"); //减去3个月
Date.parse("+1year"); //在今天加上一年
Date.parse("-12 months"); //从今天起减去12个月（1年）
Date.parse("July 4th"); //今年7月4日
Date.parse("15"); //当前月份/年份的第15天
Date.parse("July 8th, 2004, 10:30 PM");// 2004年7月8日，星期四
Date.parse("2004-07-15T06:45:00"); // 2004年7月15日星期四
Date.parse("Thu, 1 July 2004 22:30:00 GMT");//星期四，2004年7月1日16:30:00
Date.parse("1997-07-16T19:20:15"); // ISO 8601格式
Date.parse("1997-07-16T19:20:30+01:00");//具有时区偏移
Date.parse("1985-04-12T23:20:50Z"); // RFC 3339格式链接操作：
//添加1个月零5天，然后检查该日期是否为星期五
Date.today().add({ months: 1, days: 5 }).is().fri();
//输入日期，然后移至下一个星期五，减去一个月
Date.parse("10-July-2004").next().friday().add(-1).month();日期比较：
Date.today().equals( Date.parse("today")); // true|false
Date.parse("last Tues").equals(Date.today()); // true|false
Date.equals(Date.today(), Date.parse("today")); // true|false
Date.compare(Date.today(), Date.parse("today")); // 1 = greater, -1 = less than,
Date.today().compareTo(Date.parse("yesterday")); // 1 = greater, -1 = less than, 0 = equal
Date.today().between(startDate, endDate); // true|false转换为字符串：
注意该format参数对于该.toString()功能是可选的。如果未提供format，.toString()则将调用本地JavaScript Date 函数。
标准日期和时间格式说明符
自定义日期和时间格式说明符
分隔符：
/ 正斜杠、空格、- 连字号、逗号
new Date().toString(); //星期三2007年10月31日格林尼治标准时间0700（太平洋夏令时间）
new Date().toString("M/d/yyyy"); //2007年10月31日
Date.today().toString("d-MMM-yyyy"); //2007年10月31日
new Date().toString("HH:mm"); // 16:18
Date.today().toString("MMMM dS, yyyy"); // April 12th, 2008
Date.today().toShortDateString();// "10/31/2007". 根据Date.CultureInfo.shortDatePattern特定于区域性
Date.today().toLongDateString();// "Wednesday, October 31, 2007". 根据Date.CultureInfo.longDatePattern特定于区域性
new Date().toShortTimeString();// "4:18 PM". 根据Date.CultureInfo.shortTimePattern特定于区域性
new Date().toLongTimeString();// "4:18:34 PM". 根据Date.CultureInfo.longTimePattern特定于区域性核心用法：
//将日期设置为当前月份和年份的15号；
//其他对象值包括year|month|day|hour|minute|second。
Date.today().set({ day: 15 });
Date.today().set({ year: 2007, month: 1, day: 20 });
//将Date添加2天。其他对象值包括 year|month|day|hour|minute|second.
Date.today().add({ days: 2 });
Date.today().add({ years: -1, months: 6, hours: 3 });
Date.today().addYears(1); //增加1年
Date.today().addMonths(-2); //相减2个月
Date.today().addWeeks(1); //增加1周
Date.today().addDays(4); //增加4天
Date.today().addHours(6); //增加6小时
Date.today().addMinutes(-30); //相减30分钟
Date.today().addSeconds(15); //增加15秒
Date.today().addMilliseconds(200); //增加200毫秒
Date.today().moveToFirstDayOfMonth();//返回当前月份的第一天
Date.today().moveToLastDayOfMonth();//返回当前月份的最后一天
new Date().clearTime(); //将时间设置为00:00（一天的开始）
Date.today().setTimeToNow();//将时间重置为当前时间；与clearTime()的功能相反ISO 8601：
其他用法：
Date.getMonthNumberFromName("March");// 2-特定于CultureInfo。<static>
Date.getDayNumberFromName("sat");// 6-特定于CultureInfo。<静态>
Date.isLeapYear(2008) // true|false. <static>
Date.getDaysInMonth(2007, 9) // 31 <static>
Date.today().getWeek();//返回一年中的第几周。根据年份Date 返回1到（52 | 53）
Date.today().setWeek(1); //将一年中的星期几设置为星期几
var test = new Date(); // Do something... like run a test...
test.getElapsed(); //返回距现在的毫秒数
Date.today().isDaylightSavingTime();// true|false. 在夏令时之内
Date.today().hasDaylightSavingTime();// true|false. 是否遵守夏令时Web前端开发之Javascript-零点程序员-王唯
*请认真填写需求信息，我们会在24小时内与您取得联系。
