时间序列：time模块，timeit 模块，datetime模块

也就是那几个模块。。。。正好总结一下吧。。。。 小甲鱼的网站还是非常奈斯的

time模块

1. 一些术语和约定的解释：

• 时间戳（timestamp）的方式：通常来说，时间戳表示的是从 1970 年 1 月 1 日 00:00:00 开始按秒计算的偏移量（time.gmtime(0)）此模块中的函数无法处理 1970 纪元年以前的日期和时间或太遥远的未来（处理极限取决于 C 函数库，对于 32 位系统来说，是 2038 年）
• UTC（Coordinated Universal Time，世界协调时）也叫格林威治天文时间，是世界标准时间。在中国为 UTC+8
• DST（Daylight Saving Time）即夏令时的意思
  一些实时函数的计算精度可能低于它们建议的值或参数，例如在大部分 Unix 系统，时钟一秒钟“滴答”50~100 次

2. 时间元组是一个九个数字组成的元组。localtime() 和 strptime() 等以时间元组（struct_time）的形式返回。

索引值（Index）	属性（Attribute）	值（Values）
0	tm_year（年）	（例如：2015）
1	tm_mon（月）	1 ~ 12
2	tm_mday（日）	1 ~ 31
3	tm_hour（时）	0 ~ 23
4	tm_min（分）	0 ~ 59
5	tm_sec（秒）	0 ~ 61（历史原因）
6	tm_wday（星期几）	0 ~ 6（0 表示星期一）
7	tm_yday（一年中的第几天）	1 ~ 366
8	tm_isdst（是否为夏令时）	0， 1， -1（-1 代表夏令时）

a=gmtime()
a.tm_year  >>>2020  #我寻思这不是字典的功能嘛，，这不是时间元组嘛。。。。

3. 相关函数（我感觉有用的。。）

函数	实例
time.asctime([tupletime])	接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。(可以不给参数返回当前时间）
time.ctime([secs])	作用相当于asctime(localtime(secs))，未给参数相当于asctime()
time.gmtime([secs])	接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。
time.localtime([secs]	接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组
time.mktime(t)	接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）
time.sleep(secs)	推迟调用线程的运行，secs指秒数。
time.time( )	返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
time.strftime()	接收以时间元组，并返回以可读字符串表示的当地时间，
time.strptime()	把一个格式化时间字符串转化为 struct_time。实际上它和 strftime() 是逆操作。

import time
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))   >>>>2020-03-21 10:04:03
time.strptime('Sat Mar 21 09:51:47 2020')    >>>>time.struct_time(tm_year=2020, tm_mon=3, tm_mday=21, tm_hour=9, tm_min=51, tm_sec=47, tm_wday=5, tm_yday=81, tm_isdst=-1)

python中时间日期格式化符号：
%y	两位数的年份表示（00-99）
%Y	四位数的年份表示（000-9999）
%m	月份（01-12）
%d	月内中的一天（0-31）
%H	24小时制小时数（0-23）
%I	12小时制小时数（01-12）
%M	分钟数（00=59）
%S	秒（00-59）
%a	本地简化星期名称
%A	本地完整星期名称
%b	本地简化的月份名称
%B	本地完整的月份名称
%c	本地相应的日期表示和时间表示
%j	年内的一天（001-366）
%p	本地A.M.或P.M.的等价符
%U	一年中的星期数（00-53）星期天为星期的开始
%w	星期（0-6），星期天为星期的开始
%W	一年中的星期数（00-53）星期一为星期的开始
%x	本地相应的日期表示
%X	本地相应的时间表示
%Z	当前时区的名称

time.perf_counter()

返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。调用一次 perf_counter()，从计算机系统里随机选一个时间点A，计算其距离当前时间点B1有多少秒。当第二次调用该函数时，默认从第一次调用的时间点A算起，距离当前时间点B2有多少秒。两个函数取差，即实现从时间点B1到B2的计时功能。

time.process_time()

返回当前进程执行 CPU 的时间总和，不包含睡眠时间。由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。

timeit 模块

timeit 模块提供了测量 Python 小段代码执行时间的方法。它既可以在命令行界面直接使用，也可以通过导入模块进行调用。该模块灵活地避开了测量执行时间所容易出现的错误。

>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
0.8187260627746582
>>> timeit.timeit('"-".join([str(n) for n in range(100)])', number=10000)
0.7288308143615723
>>> timeit.timeit('"-".join(map(str, range(100)))', number=10000)
0.5858950614929199

timeit 模块定义了三个实用函数和一个公共类

timeit.timeit(stmt=‘pass’, setup=‘pass’, timer=, number=1000000)

创建一个 Timer 实例，参数分别是 stmt（需要测量的语句或函数），setup（初始化代码或构建环境的导入语句），timer（计时函数），number（每一次测量中语句被执行的次数）

注：由于 timeit() 正在执行语句，语句中如果存在返回值的话会阻止 timeit() 返回执行时间。timeit() 会取代原语句中的返回值。

timeit.repeat(stmt=‘pass’, setup=‘pass’, timer=, repeat=3, number=1000000)

创建一个 Timer 实例，参数分别是 stmt（需要测量的语句或函数），setup（初始化代码或构建环境的导入语句），timer（计时函数），repeat（重复测量的次数），number（每一次测量中语句被执行的次数）

timeit.default_timer()

默认的计时器，一般是 time.perf_counter()，time.perf_counter() 方法能够在任一平台提供最高精度的计时器（它也只是记录了自然时间，记录自然时间会被很多其他因素影响，例如计算机的负载）。

class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=)

计算小段代码执行速度的类，构造函数需要的参数有 stmt（需要测量的语句或函数），setup（初始化代码或构建环境的导入语句），timer（计时函数）。前两个参数的默认值都是 ‘pass’，timer 参数是平台相关的；前两个参数都可以包含多个语句，多个语句间使用分号（;）或新行分隔开。

第一次测试语句的时间，可以使用 timeit() 方法；repeat() 方法相当于持续多次调用 timeit() 方法并将结果返回为一个列表。

stmt 和 setup 参数也可以是可供调用但没有参数的对象，这将会在一个计时函数中嵌套调用它们，然后被 timeit() 所执行。注意，由于额外的调用，计时开销会相对略到。

- timeit(number=1000000)

功能：计算语句执行 number 次的时间。

它会先执行一次 setup 参数的语句，然后计算 stmt 参数的语句执行 number 次的时间，返回值是以秒为单位的浮点数。number 参数的默认值是一百万，stmt、setup 和 timer 参数由 timeit.Timer 类的构造函数传递。

注意：默认情况下，timeit() 在计时的时候会暂时关闭 Python 的垃圾回收机制。这样做的优点是计时结果更具有可比性，但缺点是 GC（garbage collection，垃圾回收机制的缩写）有时候是测量函数性能的一个重要组成部分。如果是这样的话，GC 可以在 setup 参数执行第一条语句的时候被重新启动，例如：

timeit.Timer('for i in range(10): oct(i)', 'gc.enable()').timeit()

- repeat(repeat=3, number=1000000)

功能：重复调用 timeit()。

repeat() 方法相当于持续多次调用 timeit() 方法并将结果返回为一个列表。repeat 参数指定重复的次数，number 参数传递给 timeit() 方法的 number 参数。

注意：人们很容易计算出平均值和标准偏差，但这并不是非常有用。在典型的情况下，最低值取决于你的机器可以多快地运行给定的代码段；在结果中更高的那些值通常不是由于 Python 的速度导致，而是因为其他进程干扰了你的计时精度。所以，你所应感兴趣的只有结果的最低值（可以用 min() 求出）。

使用 timeit 模块：

>>> import timeit
>>> timeit.timeit('char in text', setup='text = "I love FishC.com!"; char = "o"')
0.41440500499993504
>>> timeit.timeit('text.find(char)', setup='text = "I love FishC.com!"; char = "o"')
1.7246671520006203

使用 Timer 对象：

>>> import timeit
>>> t = timeit.Timer('char in text', setup='text = "I love FishC.com!"; char = "o"')
>>> t.timeit()
0.3955516149999312
>>> t.repeat()
[0.40193588800002544, 0.3960157959998014, 0.39594301399984033]

以下演示包含多行语句如何进行测量：

（我们通过 hasattr() 和 try/except 两种方法测试属性是否存在，并且比较它们之间的效率）

使用 timeit 模块：

>>> import timeit
>>> # attribute is missing
>>> s = """\
... try:
...     str.__bool__
... except AttributeError:
...     pass
... """
>>> timeit.timeit(stmt=s, number=100000)
0.9138244460009446
>>> s = "if hasattr(str, '__bool__'): pass"
>>> timeit.timeit(stmt=s, number=100000)
0.5829014980008651
>>>
>>> # attribute is present
>>> s = """\
... try:
...     int.__bool__
... except AttributeError:
...     pass
... """
>>> timeit.timeit(stmt=s, number=100000)
0.04215312199994514
>>> s = "if hasattr(int, '__bool__'): pass"
>>> timeit.timeit(stmt=s, number=100000)
0.08588060699912603

为了使 timeit 模块可以测量你的函数，你可以在 setup 参数中通过 import 语句导入：

def test():
    """Stupid test function"""
    L = [i for i in range(100)]
 
if __name__ == '__main__':
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))

datetime模块（基本的日期和时间类型）

datetime 模块中定义的类：

• datetime.date - 表示日期的类，常用属性：year, month, day
• datetime.time - 表示时间的类，常用属性：hour, minute, second, microsecond, tzinfo
• datetime.datetime - 表示日期和时间的类，常用属性： year, month, day, hour, minute, second, microsecond, tzinfo
• datetime.timedelta - 表示时间间隔，即两个时间点（date，time，datetime）之间的长度

注：上边这些类的对象是不可变的

timedelta

timedelta 对象表示两个日期或时间之间的间隔

datetime.timedelta(days=0, seconds=0, microseconds=0 , milliseconds=0, minutes=0, hours=0, weeks=0) 

timedelta 对象支持的操作：

操作	结果
t1 = t2 + t3	t2 和 t3 的和
t1 = t2 - t3	t2 和 t3 的差
t1 = t2 * i	对象乘以一个整数
t1 = t2 * f	对象乘以一个浮点数，结果四舍五入
f = t2 / t3	t2 和 t3 的商，返回一个 float 对象
t1 = t2 / f 或 t1 = t2 / i	对象除以一个整数或浮点数，结果四舍五入
t1 = t2 // i 或 t1 = t2 // t3	对象地板除一个整数或浮点数，结果舍去小数，返回一个整数
t1 = t2 % t3	t2 和 t3 的余数，返回一个 timedelta 对象
q, r = divmod(t1, t2)	计算 t1 和 t2 的商和余数，q = t1 // t2（注3），r = t1 % t2，q 是一个整数，r 是一个 timedelta 对象
+t1	返回一个 timedelta 对象，且值相同
-t1	等同于 timedelta(-t1.days, -t1.seconds, -t1.microseconds)，并且相当于 t1 * -1
abs(t)	当 t.days >= 0 时，等同于 +t；当 t.days < = 时，等同于 -t
str(t)	返回一个字符串，按照此格式：[D day[ s ], ][H]H:MM:SS[.UUUUUU]
repr(t)	返回一个字符串，按照此格式：datetime.timedelta(D[, S[, U]])

import datetime as dt
t=dt.timedelta(6,6,6,6,6,6,6)
str(t)
'48 days, 6:06:06.006006'
repr(t)
'datetime.timedelta(days=48, seconds=21966, microseconds=6006)'

timedelta 实例方法：

timedelta.total_seconds()

• 返回 timedelta 对象所包含的总秒数，相当于 td / timedelta(seconds=1)

请注意，对于非常大的时间间隔（在大多数平台上是大于270年），这种方法将失去微秒（microsecond）精度

timedelta 用法示例：

>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23,
...                          minutes=50, seconds=600)  # 加起来是365天
>>> year.total_seconds()
31536000.0
>>> year == another_year
True
>>> ten_years = 10 * year
>>> ten_years, ten_years.days // 365
(datetime.timedelta(3650), 10)
>>> nine_years = ten_years - year
>>> nine_years, nine_years.days // 365
(datetime.timedelta(3285), 9)
>>> three_years = nine_years // 3;
>>> three_years, three_years.days // 365
(datetime.timedelta(1095), 3)
>>> abs(three_years - ten_years) == 2 * three_years + year
True

date对象

date 对象表示一个日期，在一个理想化的日历里，日期由 year（年）、month（月）、day（日）组成

datetime.date(year, month, day)

date 对象支持的操作：

操作	结果
date2 = date1 + timedelta	日期加上一个时间间隔，返回一个新的日期对象
date2 = date1 - timedelta	日期减去一个时间间隔，相当于 date2 + timedelta == date
timedelta = date1 - date2
date1 < date2	当 date1 的日期在 date2 之前时，我们认为 date1 < date2

date 实例方法：

date.replace(year, month, day)

• 生成一个新的日期对象，用参数指定的年、月、日代替原有对象中的属性

date.timetuple()

• 返回日期对应的 time.struct_time 对象（类似于 time 模块 的 time.localtime()）

date.weekday()

• 返回 0 ~ 6 表示星期几（星期一是 0，依此类推）

date.isoweekday()

• 返回 1 ~ 7 表示星期几（星期一是1， 依此类推）

date.isocalendar()

• 返回一个三元组格式 (year, month, day)

date.isoformat()

• 返回一个 ISO 8601 格式的日期字符串，如 “YYYY-MM-DD” 的字符串

date.__str__()

• 对于 date 对象 d 来说，str(d) 相当于 d.isoformat()

date.ctime()

• 返回一个表示日期的字符串，相当于 time 模块的 time.ctime(time.mktime(d.timetuple()))

date.strftime(format)

• 返回自定义格式化字符串表示日期，下面有详解

date.__format__(format)

• 跟 date.strftime(format) 一样，这使得调用 str.format() 时可以指定 data 对象的字符串

计算天数

>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2014, 8, 31)
>>> today == date.fromtimestamp(time.time())      # 接受时间戳的。。
True
>>> my_birthday = date(today.year, 6, 24)
>>> if my_birthday < today:
        my_birthday = my_birthday.replace(year = today.year + 1)
 
>>> my_birthday
datetime.date(2015, 6, 24)
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
297

关于 date 的综合应用：

>>> from datetime import date
>>> d = date.fromordinal(735678)  # 自日期 1.1.0001 之后的第 735678 天
>>> d
datetime.date(2015, 3, 21)
>>> t = d.timetuple()
>>> for i in t:
        print(i)
        
2015
3
21
0
0
0
5
80
-1
>>> ic = d.isocalendar()
>>> for i in ic:
        print(i)
        
2015
12
6
>>> d.isoformat()
'2015-03-21'
>>> d.strftime("%d/%m/%y")
'21/03/15'
>>> d.strftime("%A %d. %B %Y")
'Saturday 21. March 2015'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 21, the month is March.'

time 对象

datetime.tzinfo - 表示时区的基类，为 time 和 datetime 类提供调整的基准

time 对象表示一天中的一个时间 datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

tzinfo 可以是none 或是 tzinfo 的示例，其他参数的范围：如果参数超出范围，将引发 ValueError 异常

0 <= hour < 24
0 <= minute < 60
0 <= second < 60
0 <= microsecond < 1000000

time类的属性

time.min/max time(0, 0, 0, 0)/time(23, 59, 59, 999999) 所能表示的最早最晚时间

time.resolution - time 对象表示时间的最小单位，在这里是 1 毫秒，timedelta(microseconds=1)

time.hour/minute/second/microsecond/tzinfo 这是实例属性，只读的

实例方法：

time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]])

• 生成一个新的时间对象，用参数指定时间代替原有对象中的属性

time.isoformat()

• 返回一个 ISO 8601 格式的日期字符串，如 “HH:MM:SS.mmmmmm” 的字符串

time.str()

• 对于 time 对象 t 来说，str(t) 相当于 t.isoformat()

time.strftime(format)

• 返回自定义格式化字符串表示时间，下面有详解

time.format(format)

• 跟 time.strftime(format) 一样，这使得调用 str.format() 时可以指定 time 对象的字符串

time.utcoffset()

• 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.utcoffset(self)

time.dst()

• 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.dst(self)

time.tzname()

• 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.tzname(self)

>>> from datetime import time, timedelta, tzinfo
>>> class GMT1(tzinfo):
        def utcoffset(self, dt):
                return timedelta(hours=1)
        def dst(self, dt):
                return timedelta(0)
        def tzname(self, dt):
                return "欧洲/布拉格"
 
>>> t = time(14, 10, 30, tzinfo=GMT1())
>>> t
datetime.time(14, 10, 30, tzinfo=<__main__.GMT1 object at 0x02D7FE90>)
>>> gmt = GMT1()
>>> t.isoformat()
'14:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'欧洲/布拉格'
>>> t.strftime("%H:%M:%S %Z")
'14:10:30 欧洲/布拉格'
>>> 'The {} is {:%H:%M}.'.format("time", t)
'The time is 14:10.'

datetime对象

datetime 对象是 date 对象和 time 对象的结合体，并且包含他们的所有信息

datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None) 其中year 在1到9999.。。

类方法

datetime.today()

• 返回一个表示当前本地时间的 datetime 对象，等同于 datetime.fromtimestamp(time.time())

datetime.now(tz=None)

• 返回一个表示当前本地时间的 datetime 对象；如果提供了参数 tz，则获取 tz 参数所指时区的本地时间

datetime.utcnow()

• 返回一个当前 UTC 时间的 datetime 对象

datetime.fromtimestamp(timestamp, tz=None)

• 根据时间戮创建一个 datetime 对象，参数 tz 指定时区信息

datetime.utcfromtimestamp(timestamp)

• 根据时间戮创建一个 UTC 时间的 datetime 对象

datetime.fromordinal(ordinal)

• 返回对应 Gregorian 日历时间对应的 datetime 对象

datetime.combine(date, time)

• 根据参数 date 和 time，创建一个 datetime 对象

datetime.strptime(date_string, format)

• 将格式化字符串转换为 datetime 对象

类属性： datetime.min/max/resolution(最小单位毫秒）

实例属性：datetime.year/mouth/day/hour/minte/second/microsecond/tzinfo 只读的

datetime1 < datetime2 当 datetime1 的日期在 datetime2 之前时，我们认为 datetime1 < datetime2

如果 datetime1 和 datetime2 的 tzinfo 属性不一样（指向不同时区），则 datetime1 和 datetime2 会先被转换为 UTC 时区时间，在进行计算，

datetime 实例方法：

datetime.date()

• 返回一个 date 对象datetime.time() - 返回一个 time 对象（tzinfo 属性为 None）

datetime.timetz()

• 返回一个 time() 对象（带有 tzinfo 属性）

datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])

• 生成一个新的日期对象，用参数指定日期和时间代替原有对象中的属性

datetime.astimezone(tz=None)

• 传入一个新的 tzinfo 属性，返回根据新时区调整好的 datetime 对象

datetime.utcoffset()

• 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.utcoffset(self)

datetime.dst()

• 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.dst(self)

datetime.tzname()

• 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.tzname(self)

datetime.timetuple()

• 返回日期对应的 time.struct_time 对象（类似于 time 模块的 time.localtime()）

datetime.utctimetuple()

• 返回 UTC 日期对应的 time.struct_time 对象

datetime.toordinal()

• 返回日期对应的 Gregorian Calendar 日期（类似于 self.date().toordinal()）

datetime.timestamp()

• 返回当前时间的时间戳（类似于 time 模块的 time.time()）

datetime.weekday()

• 返回 0 ~ 6 表示星期几（星期一是 0，依此类推）

datetime.isoweekday()

• 返回 1 ~ 7 表示星期几（星期一是1， 依此类推）

datetime.isocalendar()

• 返回一个三元组格式 (year, month, day)

datetime.isoformat(sep=‘T’)

• 返回一个 ISO 8601 格式的日期字符串，如 “YYYY-MM-DD” 的字符串

datetime.__str__()

• 对于 date 对象 d 来说，str(d) 相当于 d.isoformat()

datetime.ctime()

• 返回一个表示日期的字符串，相当于 time 模块的 time.ctime(time.mktime(d.timetuple()))

datetime.strftime(format)

• 返回自定义格式化字符串表示日期，下面有详解

datetime.__format__(format)

• 跟 datetime.strftime(format) 一样，这使得调用 str.format() 时可以指定 data 对象的字符串

datetime综合应用

>>> from datetime import datetime, date, time
 
# 使用 datetime.combine()
>>> d = date(2015, 8, 1)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2015, 8, 1, 12, 30)
 
# 使用 datetime.now() 或 datetime.utcnow()
>>> datetime.now()
datetime.datetime(2014, 8, 31, 18, 13, 40, 858954)
>>> datetime.utcnow()
datetime.datetime(2014, 8, 31, 10, 13, 49, 347984)
 
# 使用 datetime.srptime()
>>> dt = datetime.strptime("21/11/14 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2014, 11, 21, 16, 30)
 
# 使用 datetime.timetuple()
>>> tt = dt.timetuple()
>>> for it in tt:
        print(it)
 
2014
11
21
16
30
0
4
325
-1
 
# ISO 格式的日期
>>> ic = dt.isocalendar()
>>> for it in ic:
        print(it)
 
2014
47
5
 
# 格式化 datetime 对象
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Friday, 21. November 2014 04:30PM'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
'The day is 21, the month is November, the time is 04:30PM.'


# 格式化字符串：strftime() 和 strptime()
>>> from datetime import timedelta, datetime, tzinfo
>>> class GMT1(tzinfo):
        def utcoffset(self, dt):
                return timedelta(hours=1) + self.dst(dt)
        def dst(self, dt):
                # DST 开始于三月最后一个星期天
                # 结束于十月最后一个星期天
                d = datetime(dt.year, 4, 1)
                self.dston = d - timedelta(days=d.weekday() + 1)
                d = datetime(dt.year, 11, 1)
                self.dstoff = d - timedelta(days=d.weekday() + 1)
                if self.dston <= dt.replace(tzinfo=None) < self.dstoff:
                        return timedelta(hours=1)
                else:
                        return timedelta(0)
        def tzname(self, dt):
                return "GMT +1"
        
>>> class GMT2(tzinfo):
        def utcoffset(self, dt):
                return timedelta(hours=2) + self.dst(dt)
        def dst(self, dt):
                d = datetime(dt.year, 4, 1)
                self.dston = d - timedelta(days=d.weekday() + 1)
                d = datetime(dt.year, 11, 1)
                self.dstoff = d - timedelta(days=d.weekday() + 1)
                if self.dston <=  dt.replace(tzinfo=None) < self.dstoff:
                        return timedelta(hours=1)
                else:
                        return timedelta(0)
        def tzname(self, dt):
                return "GMT +2"
        
>>> gmt1 = GMT1()
 
# 夏令时
>>> dt1 = datetime(2014, 11, 21, 16, 30, tzinfo=gmt1)
>>> dt1.dst()
datetime.timedelta(0)
>>> dt1.utcoffset()
datetime.timedelta(0, 3600)
>>> dt2 = datetime(2014, 6, 14, 13, 0, tzinfo=gmt1)
>>> dt2.dst()
datetime.timedelta(0, 3600)
>>> dt2.utcoffset()
datetime.timedelta(0, 7200)
 
# 将 datetime 转换到另一个时区
>>> dt3 = dt2.astimezone(GMT2())
>>> dt3
datetime.datetime(2014, 6, 14, 14, 0, tzinfo=<__main__.GMT2 object at 0x036C0F70>)
>>> dt2
datetime.datetime(2014, 6, 14, 13, 0, tzinfo=<__main__.GMT1 object at 0x036C0B10>)
>>> dt2.utctimetuple() == dt3.utctimetuple()
True

格式化指令	含义
%a	星期的简写（星期一 ~ 天：Mon, Tue, Wed, Thu, Fri, Sat, Sun）
%A	星期的全写（星期一 ~ 天：Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday）
%w	在一个星期中的第几天（ 0 表示星期天 … 6 表示星期六）
%d	在一个月中的第几天（01, 02, …, 31）
%b	月份的简写（一月 ~ 十二月：Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec）
%B	月份的全写（一月 ~ 十二月：January, February, March, April, May, June, July, August, September, October, November, December）
%m	月份（01, 02, …, 12）
%y	用两个数字表示年份（例如 2014年 == 14）
%Y	用四个数字表示年份
%H	二十四小时制（00, 01, …, 23）
%I	十二小时制（01, 02, …, 11）
%p	AM 或者 PM
%M	分钟（00, 01, …, 59）
%S	秒（00, 01, …, 59）
%f	微秒（000000, 000001, …, 999999）
%z	与 UTC 时间的间隔 ；如果是本地时间，返回空字符串（(empty), +0000, -0400, +1030）
%Z	时区名称；如果是本地时间，返回空字符串（(empty), UTC, EST, CST）
%j	在一年中的第几天（001, 002, …, 366）
%U	在一年中的第几周，星期天作为第一天（00, 01, …, 53）
%W	在一年中的第几周，星期一作为第一天（00, 01, …, 53）
%c	用字符串表示日期和时间（Tue Aug 16 21:30:00 2014）
%x	用字符串表示日期（08/16/14）
%X	用字符串表示时间（21:30:00）
%%	表示百分号
%F	%Y-%m-%d的简写
%D	%m/%d/%y 的简写

好多啊。。。。