datetime 模塊詳解 -- 基本的日期和時間類型

轉自：https://www.cnblogs.com/fclbky/articles/4098204.html

datetime 模塊提供了各種類用於操作日期和時間，該模塊側重於高效率的格式化輸出

在 Python 中，與時間處理有關的模塊包括：time，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, tzinfo
• datetime.timedelta - 表示時間間隔，即兩個時間點（date，time，datetime）之間的長度
• datetime.tzinfo - 表示時區的基類，為上方的 time 和 datetime 類提供調整的基准
• datetime.timezone - 表示 UTC 時區的固定偏移，是 tzinfo 基類的實現

注：上邊這些類的對象是不可變的

上邊這些類的從屬關系：

1. object
2.     timedelta
3.     tzinfo
4.         timezone
5.     time
6.     date
7.         datetime

復制代碼

timedelta 對象

timedelta 對象表示兩個日期或時間之間的間隔

1. 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 minutes -> 60 seconds
• 1 hours -> 3600 seconds
• 1 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 ~ 999999999
timedelta.seconds	0 ~ 86399
timedelta.microseconds	0 ~ 999999

timedelta 對象支持的操作：

操作	結果
t1 = t2 + t3	t2 和 t3 的和，隨后：t1 - t2 == t3 and t1 - t3 == t2 為 True（注1）
t1 = t2 - t3	t2 和 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 / t3	t2 和 t3 的商（注3），返回一個 float 對象
t1 = t2 / f 或 t1 = t2 / i	對象除以一個整數或浮點數，結果四舍五入到精度 timedelta.resolution
t1 = t2 // i 或 t1 = t2 // t3	對象地板除一個整數或浮點數，結果舍去小數，返回一個整數（注3）
t1 = t2 % t3	t2 和 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 timedelta
3. >>> year = timedelta(days=365)
4. >>> another_year = timedelta(weeks=40, days=84, hours=23,
5. ...                          minutes=50, seconds=600)  # adds up to 365 days
6. >>> year.total_seconds()
7. 31536000.0
8. >>> year == another_year
9. True
10. >>> ten_years = 10 * year
11. >>> ten_years, ten_years.days // 365
12. (datetime.timedelta(3650), 10)
13. >>> nine_years = ten_years - year
14. >>> nine_years, nine_years.days // 365
15. (datetime.timedelta(3285), 9)
16. >>> three_years = nine_years // 3;
17. >>> three_years, three_years.days // 365
18. (datetime.timedelta(1095), 3)
19. >>> abs(three_years - ten_years) == 2 * three_years + year
20. True

復制代碼

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.year	MINYEAR ~ MAXYEAR（1 ~ 9999）
date.month	1 ~ 12
date.day	1 ~ 根據 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 模塊的 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 模塊的 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! 
3. >>> import time
4. >>> from datetime import date
5. >>> 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)
14. >>> my_birthday
15. datetime.date(2015, 6, 24)
16. >>> time_to_birthday = abs(my_birthday - today)
17. >>> time_to_birthday.days
18. 297

復制代碼

關於 date 的綜合應用：

1. # Follow FishC. Follow your dream!
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. 2015
12. 3
13. 21
14. 0
15. 0
16. 0
17. 5
18. 80
19. -1
20. >>> ic = d.isocalendar()
21. >>> for i in ic:
22.         print(i)
23.         
24. 2015
25. 12
26. 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", "month")
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 < 24
• 0 <= minute < 60
• 0 <= 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.minute	0 ~ 59
time.second	0 ~ 59
time.microsecond	0 ~ 999999
time.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, tzinfo
3. >>> 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 "歐洲/布拉格"
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", t)
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 < 24
• 0 <= minute < 60
• 0 <= 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.year	MINYEAR ~ MAXYEAR（1 ~ 9999）
datetime.month	1 ~ 12
datetime.day	1 ~ 根據 year 和 month 來決定（例如 2015年2月 只有 28 天）
datetime.hour	0 ~ 23
datetime.minute	0 ~ 59
datetime.second	0 ~ 59
datetime.microsecond	0 ~ 999999
datetime.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 模塊的 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 的綜合應用：

1. # I love FishC.com!
2. >>> from datetime import datetime, date, time
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)
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)
16. # 使用 datetime.srptime()
17. >>> dt = datetime.strptime("21/11/14 16:30", "%d/%m/%y %H:%M")
18. >>> dt
19. datetime.datetime(2014, 11, 21, 16, 30)
21. # 使用 datetime.timetuple()
22. >>> tt = dt.timetuple()
23. >>> for it in tt:
24.         print(it)
26. 2014
27. 11
28. 21
29. 16
30. 30
31. 0
32. 4
33. 325
34. -1
36. # ISO 格式的日期
37. >>> ic = dt.isocalendar()
38. >>> for it in ic:
39.         print(it)
41. 2014
42. 47
43. 5
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", "month", "time")
49. 'The day is 21, the month is November, the time is 04:30PM.'

復制代碼

帶有 tzinfo 的 datetime 綜合演示：

1. # 嘿，都能看到這里來了，毅力不錯哈^_^
2. >>> from datetime import timedelta, datetime, tzinfo
3. >>> 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()
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)
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	星期的簡寫（星期一 ~ 天：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）
%%	表示百分號

格式化字符串綜合演示：

1. >>> from datetime import datetime
2. >>> 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 PM
7. >>> 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周

復制代碼