datetime 模块详解 -- 基本的⽇期和时间类型
datetime 模块提供了各种类⽤于操作⽇期和时间，该模块侧重于⾼效率的格式化输出在 Python 中，与时间处理有关的模块包括：，datetime 以及 calendar
datetime 模块定义了两个常量：
datetime.MINYEAR - date 和 datetime 对象所能⽀持的最⼩年份，object.MINYEAR 的值为 1
datetime.MAXYEAR - date 和 datetime 对象所能⽀持的最⼤年份，object.MAXYEAR 的值为 9999
datetime 模块中定义的类（前四个下⽅有详解）：
datetime.date - 表⽰⽇期的类，常⽤属性：year, month, day
datetime.time - 表⽰时间的类，常⽤属性：hour, minute, second, microsecond, tzinfo
datetime.datetime - 表⽰⽇期和时间的类，常⽤属性： year, month, day, hour, minute, second, microsecond, tzinfodatetime.timedelta - 表⽰时间间隔，即两个时间点（date，time，datetime）之间的长度datetime.tzinfo - 表⽰时区的基类，为上⽅的 time 和 datetime 类提供调整的基准datetime.timezone - 表⽰ UTC 时区的固定偏移，是 tzinfo 基类的实现
注：上边这些类的对象是不可变的上边这些类的从属关系：1. object
2. timedelta3. tzinfo
4. timezone5. time6. date
7. datetime8.
复制代码timedelta 对象
timedelta 对象表⽰两个⽇期或时间之间的间隔
1. datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) 2.
复制代码以上所有的参数都是可选的（默认为 0），参数的可以是整数或浮点数，正数或负数。
内部的存储单位只有 days（天）、seconds（秒）、microseconds（毫秒），其他单位均先转换后再存储：
1 millisecond -> 1000 microseconds1 minutes -> 60 seconds1 hours -> 3600 seconds1 weeks -> 7 days
⽽ days、seconds 和 microseconds 为了不产⽣时间表⽰上的歧义，将根据以下范围⾃动“进位”：
0 <= microseconds < 1000000
0 <= seconds < 3600 * 24（1⼩时的秒数 * 24⼩时）-999999999 <= days <= 999999999
timedelta 类属性：
timedelta.min - timedelta 对象负值的极限，timedelta(-999999999)
timedelta.max - timedelta 对象正值的极限，timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)timedelta.resolution - 两个 timedelta 不相等的对象之间最⼩的差值，timedelta(microseconds=1)请注意，在正常情况下，timedelta.max > -timedelta.min，-timedelta.max ⽆意义。
timedelta 实例属性（只读）：
属性取值范围timedelta.days-999999999 ~ 999999999timedelta.seconds0 ~ 86399timedelta.microseconds0 ~ 999999
timedelta 对象⽀持的操作：
操作结果t1 = t2 + t3t2 和 t3 的和，随后：t1 - t2 == t3 and t1 - t3 == t2 为 True（注1）t1 = t2 - t3t2 和 t3 的差，随后：t1 == t2 - t3 and t2 == t1 + t3 为 True（注1）t1 = t2 * i 或 t1 = i * t2对象乘以⼀个整数，随后：t1 // i == t2 为 true；且 i != 0
t1 = t2 * f 或 t1 = f * t2对象乘以⼀个浮点数，结果四舍五⼊到精度 timedelta.resolution（注1）f = t2 / t3t2 和 t3 的商（注3），返回⼀个 float 对象
t1 = t2 / f 或 t1 = t2 / i对象除以⼀个整数或浮点数，结果四舍五⼊到精度 timedelta.resolutiont1 = t2 // i 或 t1 = t2 // t3对象地板除⼀个整数或浮点数，结果舍去⼩数，返回⼀个整数（注3）t1 = t2 % t3t2 和 t3 的余数，返回⼀个 timedelta 对象（注3）q, r = divmod(t1, t2)计算 t1 和 t2 的商和余数，q = t1 // t2（注3），r = t1 % t2，q 是⼀个整数，r 是⼀个 timedelta 对象+t1返回⼀个 timedelta 对象，且值相同（注2）-t1等同于 timedelta(-t1.days, -t1.seconds, -t1.microseconds)，并且相当于 t1 * -1（注1、4）abs(t)当 t.days >= 0 时，等同于 +t；当 t.days < = 时，等同于 -t（注2）str(t)返回⼀个字符串，按照此格式：[D day[ s ], ][H]H:MM:SS[.UUUUUU]repr(t)返回⼀个字符串，按照此格式：datetime.timedelta(D[, S[, U]])
注1：这是准确的，但可能会溢出注2：这是准确的，并且不会溢出注3：除数为 0 会引发 ZeroDivisionError 异常注4：-timedelta.max 是⽆意义的timedelta 实例⽅法：
timedelta.total_seconds()
- 返回 timedelta 对象所包含的总秒数，相当于 td / timedelta(seconds=1)
请注意，对于⾮常⼤的时间间隔（在⼤多数平台上是⼤于270年），这种⽅法将失去微秒（microsecond）精度
timedelta ⽤法⽰例：
1. # 爱学习，爱鱼C⼯作室
2. >>> from datetime import timedelta3. >>> year = timedelta(days=365)
4. >>> another_year = timedelta(weeks=40, days=84, hours=23,
5. ... minutes=50, seconds=600) # adds up to 365 days6. >>> year.total_seconds()7. 31536000.0
8. >>> year == another_year9. True
10. >>> ten_years = 10 * year
11. >>> ten_years, ten_years.days // 36512. (datetime.timedelta(3650), 10)13. >>> nine_years = ten_years - year
14. >>> nine_years, nine_years.days // 36515. (datetime.timedelta(3285), 9)
16. >>> three_years = nine_years // 3;
17. >>> three_years, three_years.days // 36518. (datetime.timedelta(1095), 3)
19. >>> abs(three_years - ten_years) == 2 * three_years + year20. True21.
复制代码date 对象
date 对象表⽰⼀个⽇期，在⼀个理想化的⽇历⾥，⽇期由 year（年）、month（⽉）、day（⽇）组成1. datetime.date(year, month, day)
复制代码所有的参数都是必需的，参数可以是整数，并且在以下范围内：
MINYEAR <= year <= MAXYEAR（也就是 1 ~ 9999）1 <= month <= 12
1 <= day <= 根据 year 和 month 来决定（例如 2015年2⽉ 只有 28 天）
date 类⽅法（classmethod）：
date.today() - 返回⼀个表⽰当前本地⽇期的 date 对象
date.fromtimestamp(timestamp) - 根据给定的时间戮，返回⼀个 date 对象
date.fromordinal(ordinal) - 将 Gregorian ⽇历时间转换为 date 对象（Gregorian Calendar：⼀种⽇历表⽰⽅法，类似于我国的农历，西⽅国家使⽤⽐较多）
date 类属性：
date.min - date 对象所能表⽰的最早⽇期，date(MINYEAR, 1, 1)date.max - date 对象所能表⽰的最晚⽇期，date(MAXYEAR, 12, 31)
date.resolution - date 对象表⽰⽇期的最⼩单位，在这⾥是 1 天，timedelta(days=1)
date 实例属性（只读）：
属性取值范围
date.yearMINYEAR ~ MAXYEAR（1 ~ 9999）date.month1 ~ 12
date.day1 ~ 根据 year 和 month 来决定（例如 2015年2⽉ 只有 28 天）
date 对象⽀持的操作：
操作结果
date2 = date1 + timedelta⽇期加上⼀个时间间隔，返回⼀个新的⽇期对象（注1）date2 = date1 - timedelta⽇期减去⼀个时间间隔，相当于 date2 + timedelta == date1（注2）timedelta = date1 - date2（注3）date1 < date2当 date1 的⽇期在 date2 之前时，我们认为 date1 < date2（注4）注1：timedelta.day > 0 或 timedelta.day < 0 决定 date2 ⽇期增长的⽅向；随后，date2 - date1 == timedelta.days；timedelta.seconds 和timedelta.microseconds 被忽略；如果 date2.year < MINYEAR 或 date2.year > MAXYEAR，引发 OverflowError 异常注2：这并不等同于 date1 + (-timedelta)，因为单独的 -timedelta 可能会溢出，⽽ date1 - timedelta 则不会溢出；timedelta.seconds 和timedelta.microseconds 被忽略注3：这是准确的，并且不会溢出；timedelta.seconds 和 timedelta.microseconds 都为 0，然后 date2 + timedelta == date1注4：换句话说，当且仅当 date1.toordinal() < date2.toordinal()，才有 date1 < date2
date 实例⽅法：
date.replace(year, month, day)
- ⽣成⼀个新的⽇期对象，⽤参数指定的年、⽉、⽇代替原有对象中的属性date.timetuple()
- 返回⽇期对应的 time.struct_time 对象（类似于 的 time.localtime()）date.toordinal()
- 返回⽇期对应的 Gregorian Calendar ⽇期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.ctime(time.mktime(d.timetuple()))date.strftime(format)
- 返回⾃定义格式化字符串表⽰⽇期，下⾯有详解
date.__format__(format)
- 跟 date.strftime(format) ⼀样，这使得调⽤ str.format() 时可以指定 data 对象的字符串
以下是计算天数的例⼦：
1. # You may say I'm the dreamer. But I'm not the only one!
2.
3. >>> import time
4. >>> from datetime import date5. >>> today = date.today()6. >>> today
7. datetime.date(2014, 8, 31)
8. >>> today == date.fromtimestamp(time.time())9. True
10. >>> my_birthday = date(today.year, 6, 24)11. >>> if my_birthday < today:
12. my_birthday = my_birthday.replace(year = today.year + 1)13.
14. >>> my_birthday
15. datetime.date(2015, 6, 24)
16. >>> time_to_birthday = abs(my_birthday - today)17. >>> time_to_birthday.days18. 297
复制代码关于 date 的综合应⽤：
1. # Follow FishC. Follow your dream!2.
3. >>> from datetime import date
4. >>> d = date.fromordinal(735678) # ⾃⽇期 1.1.0001 之后的第 735678 天5. >>> d
6. datetime.date(2015, 3, 21)7. >>> t = d.timetuple()8. >>> for i in t:9. print(i)10. 11. 201512. 313. 2114. 015. 016. 017. 518. 8019. -1
20. >>> ic = d.isocalendar()21. >>> for i in ic:22. print(i)23. 24. 201525. 1226. 6
27. >>> d.isoformat()28. '2015-03-21'
29. >>> d.strftime(\"%d/%m/%y\")30. '21/03/15'
31. >>> d.strftime(\"%A %d. %B %Y\")32. 'Saturday 21. March 2015'
33. >>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, \"day\34. 'The day is 21, the month is March.'
复制代码time 对象
time 对象表⽰⼀天中的⼀个时间，并且可以通过 tzinfo 对象进⾏调整
1. datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
复制代码所有的参数都是可选的；tzinfo 可以是 None 或者 tzinfo ⼦类的实例对象；其余的参数可以是整数，并且在以下范围内：
0 <= hour < 240 <= minute < 600 <= second < 60
0 <= microsecond < 1000000
注：如果参数超出范围，将引发 ValueError 异常
time 类属性
time.min - time 对象所能表⽰的最早时间，time(0, 0, 0, 0)
time.max - time 对象所能表⽰的最晚时间，time(23, 59, 59, 999999)
time.resolution - time 对象表⽰时间的最⼩单位，在这⾥是 1 毫秒，timedelta(microseconds=1)
time 实例属性（只读）：
属性
time.hour取值范围0 ~ 23
time.minute0 ~ 59time.second0 ~ 59
time.microsecond0 ~ 999999time.tzinfo通过构造函数的 tzinfo 参数赋值
time 实例⽅法：
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)
关于 time 的综合应⽤：
1. # 学编程，到鱼C
2. >>> from datetime import time, timedelta, tzinfo3. >>> class GMT1(tzinfo):4. def utcoffset(self, dt):
5. return timedelta(hours=1)6. def dst(self, dt):
7. return timedelta(0)8. def tzname(self, dt):
9. return \"欧洲/布拉格\"10.
11. >>> t = time(14, 10, 30, tzinfo=GMT1())12. >>> t
13. datetime.time(14, 10, 30, tzinfo=<__main__.GMT1 object at 0x02D7FE90>)14. >>> gmt = GMT1()15. >>> t.isoformat()16. '14:10:30+01:00'17. >>> t.dst()
18. datetime.timedelta(0)19. >>> t.tzname()20. '欧洲/布拉格'
21. >>> t.strftime(\"%H:%M:%S %Z\")22. '14:10:30 欧洲/布拉格'
23. >>> 'The {} is {:%H:%M}.'.format(\"time\24. 'The time is 14:10.'
复制代码datetime 对象
datetime 对象是 date 对象和 time 对象的结合体，并且包含他们的所有信息
1. datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
复制代码必须的参数是 year（年）、month（⽉）、day（⽇）；tzinfo 可以是 None 或者 tzinfo ⼦类的实例对象；其余的参数可以是整数，并且在以下范围内：
MINYEAR <= year <= MAXYEAR（也就是 1 ~ 9999）1 <= month <= 12
1 <= day <= 根据 year 和 month 来决定（例如 2015年2⽉ 只有 28 天）0 <= hour < 240 <= minute < 600 <= second < 60
0 <= microsecond < 1000000
注：如果参数超出范围，将引发 ValueError 异常
datetime 类⽅法（classmethod）：
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 类属性：
datetime.min - datetime 对象所能表⽰的最早⽇期，datetime(MINYEAR, 1, 1, tzinfo=None)
datetime.max - datetime 对象所能表⽰的最晚⽇期，datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)datetime.resolution - datetime 对象表⽰⽇期的最⼩单位，在这⾥是 1 毫秒，timedelta(microseconds=1)
datetime 实例属性（只读）：
属性取值范围datetime.yearMINYEAR ~ MAXYEAR（1 ~ 9999）datetime.month1 ~ 12datetime.day1 ~ 根据 year 和 month 来决定（例如 2015年2⽉ 只有 28 天）datetime.hour0 ~ 23datetime.minute0 ~ 59datetime.second0 ~ 59
datetime.microsecond0 ~ 999999datetime.tzinfo通过构造函数的 tzinfo 参数赋值
datetime 对象⽀持的操作：
操作结果
datetime2 = datetime1 + timedelta⽇期加上⼀个时间间隔，返回⼀个新的⽇期对象（注1）datetime2 = datetime1 - timedelta⽇期减去⼀个时间间隔，相当于 datetime2 + timedelta == datetime1（注2）timedelta = datetime1 - datetime2两个⽇期相减得到⼀个时间间隔（注3）datetime1 < datetime2当 datetime1 的⽇期在 datetime2 之前时，我们认为 datetime1 < datetime2
注1：timedelta.day > 0 或 timedelta.day < 0 决定 datetime2 ⽇期增长的⽅向；计算结果 datetime2 的 tzinfo 属性和 datetime1 相同；如果date2.year < MINYEAR 或 date2.year > MAXYEAR，引发 OverflowError 异常注2：计算结果 datetime2 的 tzinfo 属性和 datetime1 相同；这并不等同于 date1 + (-timedelta)，因为单独的 -timedelta 可能会溢出，⽽date1 - timedelta 则不会溢出注3：如果 datetime1 和 datetime2 的 tzinfo 属性⼀样（指向同⼀个时区），则 tzinfo 属性被忽略，计算结果为⼀个 timedelta 对象 t，则datetime2 + t == datetime1（不⽤进⾏时区调整）；如果 datetime1 和 datetime2 的 tzinfo 属性不⼀样（指向不同时区），则 datetime1 和datetime2 会先被转换为 UTC 时区时间，在进⾏计算，(datetime1.replace(tzinfo=None) - datetime1.utcoffset()) -(datetime2.replace(tzinfo=None) - datetime2.utcoffset())
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.localtime()）datetime.utctimetuple()
- 返回 UTC ⽇期对应的 time.struct_time 对象
datetime.toordinal()
- 返回⽇期对应的 Gregorian Calendar ⽇期（类似于 self.date().toordinal()）datetime.timestamp()
- 返回当前时间的时间戳（类似于 的 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.ctime(time.mktime(d.timetuple()))datetime.strftime(format)
- 返回⾃定义格式化字符串表⽰⽇期，下⾯有详解
datetime.__format__(format)
- 跟 datetime.strftime(format) ⼀样，这使得调⽤ str.format() 时可以指定 data 对象的字符串
关于 datetime 的综合应⽤：
1. # I love FishC.com!
2. >>> from datetime import datetime, date, time3.
4. # 使⽤ datetime.combine()5. >>> d = date(2015, 8, 1)6. >>> t = time(12, 30)
7. >>> datetime.combine(d, t)
8. datetime.datetime(2015, 8, 1, 12, 30)
9.
10. # 使⽤ datetime.now() 或 datetime.utcnow()11. >>> datetime.now()
12. datetime.datetime(2014, 8, 31, 18, 13, 40, 858954)13. >>> datetime.utcnow()
14. datetime.datetime(2014, 8, 31, 10, 13, 49, 347984)15.
16. # 使⽤ datetime.srptime()
17. >>> dt = datetime.strptime(\"21/11/14 16:30\18. >>> dt
19. datetime.datetime(2014, 11, 21, 16, 30)20.
21. # 使⽤ datetime.timetuple()22. >>> tt = dt.timetuple()23. >>> for it in tt:24. print(it)25.
26. 201427. 1128. 2129. 1630. 3031. 032. 433. 32534. -135.
36. # ISO 格式的⽇期
37. >>> ic = dt.isocalendar()38. >>> for it in ic:39. print(it)40.
41. 201442. 4743. 544.
45. # 格式化 datetime 对象
46. >>> dt.strftime(\"%A, %d. %B %Y %I:%M%p\")47. 'Friday, 21. November 2014 04:30PM'
48. >>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, \"day\49. 'The day is 21, the month is November, the time is 04:30PM.'
复制代码带有 tzinfo 的 datetime 综合演⽰：
1. # 嘿，都能看到这⾥来了，毅⼒不错哈^_^
2. >>> from datetime import timedelta, datetime, tzinfo3. >>> class GMT1(tzinfo):4. def utcoffset(self, dt):
5. return timedelta(hours=1) + self.dst(dt)6. def dst(self, dt):
7. # DST 开始于三⽉最后⼀个星期天8. # 结束于⼗⽉最后⼀个星期天9. d = datetime(dt.year, 4, 1)
10. self.dston = d - timedelta(days=d.weekday() + 1)11. d = datetime(dt.year, 11, 1)
12. self.dstoff = d - timedelta(days=d.weekday() + 1)13. if self.dston <= dt.replace(tzinfo=None) < self.dstoff:14. return timedelta(hours=1)15. else:
16. return timedelta(0)17. def tzname(self, dt):18. return \"GMT +1\"19.
20. >>> class GMT2(tzinfo):21. def utcoffset(self, dt):
22. return timedelta(hours=2) + self.dst(dt)23. def dst(self, dt):
24. d = datetime(dt.year, 4, 1)
25. self.dston = d - timedelta(days=d.weekday() + 1)26. d = datetime(dt.year, 11, 1)
27. self.dstoff = d - timedelta(days=d.weekday() + 1)28. if self.dston <= dt.replace(tzinfo=None) < self.dstoff:29. return timedelta(hours=1)30. else:
31. return timedelta(0)32. def tzname(self, dt):33. return \"GMT +2\"34.
35. >>> gmt1 = GMT1()36.
37. # 夏令时
38. >>> dt1 = datetime(2014, 11, 21, 16, 30, tzinfo=gmt1)39. >>> dt1.dst()
40. datetime.timedelta(0)41. >>> dt1.utcoffset()
42. datetime.timedelta(0, 3600)
43. >>> dt2 = datetime(2014, 6, 14, 13, 0, tzinfo=gmt1)44. >>> dt2.dst()
45. datetime.timedelta(0, 3600)46. >>> dt2.utcoffset()
47. datetime.timedelta(0, 7200)48.
49. # 将 datetime 转换到另⼀个时区50. >>> dt3 = dt2.astimezone(GMT2())51. >>> dt3
52. datetime.datetime(2014, 6, 14, 14, 0, tzinfo=<__main__.GMT2 object at 0x036C0F70>)53. >>> dt2
54. datetime.datetime(2014, 6, 14, 13, 0, tzinfo=<__main__.GMT1 object at 0x036C0B10>)55. >>> dt2.utctimetuple() == dt3.utctimetuple()56. True
复制代码格式化字符串：strftime() 和 strptime()
date, datetime, 和 time 对象均⽀持使⽤ strftime(format) ⽅法，将指定的⽇期或时间转换为⾃定义的格式化字符串相反的，datetime.strptime() 类⽅法却是把格式化字符串转换为 datetime 对象
格式化指令%a%A%w%d%b%B%m%y%Y%H%I
含义
星期的简写（星期⼀ ~ 天：Mon, Tue, Wed, Thu, Fri, Sat, Sun）
星期的全写（星期⼀ ~ 天：Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday）在⼀个星期中的第⼏天（ 0 表⽰星期天 ... 6 表⽰星期六）在⼀个⽉中的第⼏天（01, 02, ..., 31）
⽉份的简写（⼀⽉ ~ ⼗⼆⽉：Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec）
⽉份的全写（⼀⽉ ~ ⼗⼆⽉：January, February, March, April, May, June, July, August, September, October, November,December）
⽉份（01, 02, ..., 12）
⽤两个数字表⽰年份（例如 2014年 == 14）⽤四个数字表⽰年份
⼆⼗四⼩时制（00, 01, ..., 23）⼗⼆⼩时制（01, 02, ..., 11）
%p%M%S%f%z%Z%j%U%W%c%x%X%%AM 或者 PM分钟（00, 01, ..., 59）秒（00, 01, ..., 59）
微秒（000000, 000001, ..., 999999）
与 UTC 时间的间隔 ；如果是本地时间，返回空字符串（(empty), +0000, -0400, +1030）时区名称；如果是本地时间，返回空字符串（(empty), UTC, EST, CST）在⼀年中的第⼏天（001, 002, ..., 366）
在⼀年中的第⼏周，星期天作为第⼀天（00, 01, ..., 53）在⼀年中的第⼏周，星期⼀作为第⼀天（00, 01, ..., 53）⽤字符串表⽰⽇期和时间（Tue Aug 16 21:30:00 2014）⽤字符串表⽰⽇期（08/16/14）⽤字符串表⽰时间（21:30:00）表⽰百分号
格式化字符串综合演⽰：
1. >>> from datetime import datetime2. >>> dt = datetime.now()
3. >>> print('(%Y-%m-%d %H:%M:%S %f): ', dt.strftime('%Y-%m-%d %H:%M:%S %f'))4. (%Y-%m-%d %H:%M:%S %f): 2014-08-31 23:54:58 379804
5. >>> print('(%Y-%m-%d %H:%M:%S %p): ', dt.strftime('%y-%m-%d %I:%M:%S %p'))6. (%Y-%m-%d %H:%M:%S %p): 14-08-31 11:54:58 PM7. >>> print('%%a: %s ' % dt.strftime('%a'))8. %a: Sun
9. >>> print('%%A: %s ' % dt.strftime('%A'))10. %A: Sunday
11. >>> print('%%b: %s ' % dt.strftime('%b'))12. %b: Aug
13. >>> print('%%B: %s ' % dt.strftime('%B'))14. %B: August
15. >>> print('⽇期时间%%c: %s ' % dt.strftime('%c'))16. ⽇期时间%c: 08/31/14 23:54:58
17. >>> print('⽇期%%x：%s ' % dt.strftime('%x'))18. ⽇期%x：08/31/14
19. >>> print('时间%%X：%s ' % dt.strftime('%X'))20. 时间%X：23:54:58
21. >>> print('今天是这周的第%s天 ' % dt.strftime('%w'))22. 今天是这周的第0天
23. >>> print('今天是今年的第%s天 ' % dt.strftime('%j'))24. 今天是今年的第243天
25. >>> print('今周是今年的第%s周 ' % dt.strftime('%U'))26. 今周是今年的第35周
复制代码
因篇幅问题不能全部显示，请点此查看更多更全内容