datetime —- 基本日期和時間類型

源代碼： Lib/datetime.py

目前創(chuàng)新互聯(lián)公司已為超過千家的企業(yè)提供了網(wǎng)站建設(shè)、域名、虛擬空間、網(wǎng)站運營、企業(yè)網(wǎng)站設(shè)計、洪澤網(wǎng)站維護等服務(wù)，公司將堅持客戶導(dǎo)向、應(yīng)用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協(xié)力一起成長，共同發(fā)展。

datetime 模塊提供用于處理日期和時間的類。

在支持日期時間數(shù)學(xué)運算的同時，實現(xiàn)的關(guān)注點更著重于如何能夠更有效地解析其屬性用于格式化輸出和數(shù)據(jù)操作。

參見

模塊 calendar

通用日歷相關(guān)函數(shù)

模塊 time

時間的訪問和轉(zhuǎn)換

zoneinfo 模塊

代表 IANA 時區(qū)數(shù)據(jù)庫的具體時區(qū)。

dateutil 包

具有擴展時區(qū)和解析支持的第三方庫。

感知型對象和簡單型對象

日期和時間對象可以根據(jù)它們是否包含時區(qū)信息而分為“感知型”和“簡單型”兩類。

充分掌握應(yīng)用性算法和政治性時間調(diào)整信息例如時區(qū)和夏令時的情況下，一個 感知型 對象就能相對于其他感知型對象來精確定位自身時間點。 感知型對象是用來表示一個沒有解釋空間的固定時間點。 1

簡單型 對象沒有包含足夠多的信息來無歧義地相對于其他 date/time 對象來定位自身時間點。 不論一個簡單型對象所代表的是世界標準時間（UTC）、當?shù)貢r間還是某個其他時區(qū)的時間完全取決于具體程序，就像一個特定數(shù)字所代表的是米、英里還是質(zhì)量完全取決于具體程序一樣。 簡單型對象更易于理解和使用，代價則是忽略了某些現(xiàn)實性考量。

對于要求感知型對象的應(yīng)用，datetime 和 time 對象具有一個可選的時區(qū)信息屬性 tzinfo，它可被設(shè)為抽象類 tzinfo 的子類的一個實例。 這些 tzinfo 對象會捕獲與 UTC 時間的差值、時區(qū)名稱以及夏令時是否生效等信息。

datetime 模塊只提供了一個具體的 tzinfo 類，即 timezone 類。 timezone 類可以表示具有相對于 UTC 的固定時差的簡單時區(qū)，例如 UTC 本身或北美的 EST 和 EDT 時區(qū)等。 支持時間的詳細程度取決于具體的應(yīng)用。 世界各地的時間調(diào)整規(guī)則往往是政治性多于合理性，經(jīng)常會發(fā)生變化，除了 UTC 之外并沒有一個能適合所有應(yīng)用的標準。

常量

The datetime module exports the following constants:

datetime.MINYEAR

date 或者 datetime 對象允許的最小年份。 常量 MINYEAR 是 1 。

datetime.MAXYEAR

date 或 datetime 對象允許最大的年份。常量 MAXYEAR 是 9999 。

datetime.UTC

Alias for the UTC timezone singleton datetime.timezone.utc.

3.11 新版功能.

有效的類型

class datetime.date

一個理想化的簡單型日期，它假設(shè)當今的公歷在過去和未來永遠有效。 屬性: year, month, and day。

class datetime.time

一個獨立于任何特定日期的理想化時間，它假設(shè)每一天都恰好等于 24*60*60 秒。 （這里沒有“閏秒”的概念。） 包含屬性: hour, minute, second, microsecond 和 tzinfo。

class datetime.datetime

日期和時間的結(jié)合。屬性：year, month, day, hour, minute, second, microsecond, and tzinfo.

class datetime.timedelta

表示兩個 date 對象或 time 對象，或者 datetime 對象之間的時間間隔，精確到微秒。

class datetime.tzinfo

一個描述時區(qū)信息對象的抽象基類。 用來給 datetime 和 time 類提供自定義的時間調(diào)整概念（例如處理時區(qū)和/或夏令時）。

class datetime.timezone

一個實現(xiàn)了 tzinfo 抽象基類的子類，用于表示相對于 世界標準時間（UTC）的偏移量。

3.2 新版功能.

這些類型的對象都是不可變的。

子類關(guān)系

 
 
 
 

  
  
  
  
object
  
  
  
  
 timedelta
  
  
  
  
 tzinfo
  
  
  
  
 timezone
  
  
  
  
 time
  
  
  
  
 date
  
  
  
  
 datetime
 
 
 
 

通用的特征屬性

date, datetime, time 和 timezone 類型共享這些通用特性:

• 這些類型的對象都是不可變的。

• 這些類型的對象是可哈希的，這意味著它們可被作為字典的鍵。

• 這些類型的對象支持通過 pickle 模塊進行高效的封存。

確定一個對象是感知型還是簡單型

date 類型的對象都是簡單型的。

time 或 datetime 類型的對象可以是感知型或者簡單型。

一個 datetime 對象 d 在以下條件同時成立時將是感知型的：

1. d.tzinfo 不為 None

2. d.tzinfo.utcoffset(d) 不返回 None

在其他情況下，d 將是簡單型的。

一個 time 對象 t 在以下條件同時成立時將是感知型的：

1. t.tzinfo 不為 None

2. t.tzinfo.utcoffset(None) 不返回 None。

在其他情況下，t 將是簡單型的。

感知型和簡單型之間的區(qū)別不適用于 timedelta 對象。

timedelta 類對象

timedelta 對象表示兩個 date 或者 time 的時間間隔。

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

所有參數(shù)都是可選的并且默認為 0。 這些參數(shù)可以是整數(shù)或者浮點數(shù)，也可以是正數(shù)或者負數(shù)。

只有 days, seconds 和 microseconds 會存儲在內(nèi)部。 參數(shù)單位的換算規(guī)則如下：

• 1毫秒會轉(zhuǎn)換成1000微秒。

• 1分鐘會轉(zhuǎn)換成60秒。

• 1小時會轉(zhuǎn)換成3600秒。

• 1星期會轉(zhuǎn)換成7天。

日期、秒、微秒都是標準化的，所以它們的表達方式也是唯一的，例：

• 0 <= microseconds < 1000000

• 0 <= seconds < 3600*24 (一天的秒數(shù))

• -999999999 <= days <= 999999999

下面的例子演示了如何對 days, seconds 和 microseconds 以外的任意參數(shù)執(zhí)行“合并”操作并標準化為以上三個結(jié)果屬性:

 
 
 
 

  
  
  
  
>>> from datetime import timedelta
  
  
  
  
>>> delta = timedelta(
  
  
  
  
... days=50,
  
  
  
  
... seconds=27,
  
  
  
  
... microseconds=10,
  
  
  
  
... milliseconds=29000,
  
  
  
  
... minutes=5,
  
  
  
  
... hours=8,
  
  
  
  
... weeks=2
  
  
  
  
... )
  
  
  
  
>>> # Only days, seconds, and microseconds remain
  
  
  
  
>>> delta
  
  
  
  
datetime.timedelta(days=64, seconds=29156, microseconds=10)
 
 
 
 

在有任何參數(shù)為浮點型并且 microseconds 值為小數(shù)的情況下，從所有參數(shù)中余下的微秒數(shù)將被合并，并使用四舍五入偶不入奇的規(guī)則將總計值舍入到最接近的整數(shù)微秒值。 如果沒有任何參數(shù)為浮點型的情況下，則轉(zhuǎn)換和標準化過程將是完全精確的（不會丟失信息）。

如果標準化后的 days 數(shù)值超過了指定范圍，將會拋出 OverflowError 異常。

請注意對負數(shù)值進行標準化的結(jié)果可能會令人感到驚訝。 例如:

 
 
 
 

  
  
  
  
>>> from datetime import timedelta
  
  
  
  
>>> d = timedelta(microseconds=-1)
  
  
  
  
>>> (d.days, d.seconds, d.microseconds)
  
  
  
  
(-1, 86399, 999999)
 
 
 
 

類屬性：

timedelta.min

The most negative timedelta object, timedelta(-999999999).

timedelta.max

The most positive timedelta object, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999).

timedelta.resolution

兩個不相等的 timedelta 類對象最小的間隔為 timedelta(microseconds=1)。

需要注意的是，因為標準化的緣故，timedelta.max > -timedelta.min，-timedelta.max 不可以表示一個 timedelta 類對象。

實例屬性（只讀）：

支持的運算：

注釋：

1. 結(jié)果正確，但可能會溢出。

2. 結(jié)果正確，不會溢出。

3. 除以0將會拋出異常 ZeroDivisionError 。

4. -timedelta.max 不是一個 timedelta 類對象。

5. timedelta 對象的字符串表示形式類似于其內(nèi)部表示形式被規(guī)范化。對于負時間增量，這會導(dǎo)致一些不尋常的結(jié)果。例如:

      
      
      
      
   
       
       
       
       
   >>> timedelta(hours=-5)
       
       
       
       
   datetime.timedelta(days=-1, seconds=68400)
       
       
       
       
   >>> print(_)
       
       
       
       
   -1 day, 19:00:00
      
      
      
      

6. 表達式 t2 - t3 通常與 t2 + (-t3) 是等價的，除非 t3 等于 timedelta.max; 在這種情況下前者會返回結(jié)果，而后者則會溢出。

除了上面列舉的操作以外，timedelta 對象還支持與 date 和 datetime 對象進行特定的相加和相減運算（見下文）。

在 3.2 版更改: 現(xiàn)在已支持 timedelta 對象與另一個 timedelta 對象相整除或相除，包括求余運算和 divmod() 函數(shù)。 現(xiàn)在也支持 timedelta 對象加上或乘以一個 float 對象。

支持 timedelta 對象之間進行比較，但其中有一些注意事項。

== 或 != 比較 總是 返回一個 bool 對象，無論被比較的對象是什么類型:

 
 
 
 

  
  
  
  
>>> from datetime import timedelta
  
  
  
  
>>> delta1 = timedelta(seconds=57)
  
  
  
  
>>> delta2 = timedelta(hours=25, seconds=2)
  
  
  
  
>>> delta2 != delta1
  
  
  
  
True
  
  
  
  
>>> delta2 == 5
  
  
  
  
False
 
 
 
 

對于所有其他比較 (例如 < 和 >)，當一個 timedelta 對象與其他類型的對象比較時，將引發(fā) TypeError:

 
 
 
 

  
  
  
  
>>> delta2 > delta1
  
  
  
  
True
  
  
  
  
>>> delta2 > 5
  
  
  
  
Traceback (most recent call last):
  
  
  
  
 File "", line 1, in 
  
  
  
  
TypeError: '>' not supported between instances of 'datetime.timedelta' and 'int'
 
 
 
 

在布爾運算中，timedelta 對象當且僅當其不等于 timedelta(0) 時則會被視為真值。

實例方法：

timedelta.total_seconds()

返回期間占用了多少秒。等價于 td / timedelta(seconds=1)。對于秒以外的間隔單位，直接使用除法形式 (例如 td / timedelta(microseconds=1))。

需要注意的是，時間間隔較大時，這個方法的結(jié)果中的微秒將會失真（大多數(shù)平臺上大于270年視為一個較大的時間間隔）。

3.2 新版功能.

class:timedelta 用法示例

一個標準化的附加示例:

 
 
 
 

  
  
  
  
>>> # Components of another_year add up to exactly 365 days
  
  
  
  
>>> from datetime import timedelta
  
  
  
  
>>> year = timedelta(days=365)
  
  
  
  
>>> another_year = timedelta(weeks=40, days=84, hours=23,
  
  
  
  
... minutes=50, seconds=600)
  
  
  
  
>>> year == another_year
  
  
  
  
True
  
  
  
  
>>> year.total_seconds()
  
  
  
  
31536000.0
 
 
 
 

timedelta 算術(shù)運算的示例:

 
 
 
 

  
  
  
  
>>> from datetime import timedelta
  
  
  
  
>>> year = timedelta(days=365)
  
  
  
  
>>> ten_years = 10 * year
  
  
  
  
>>> ten_years
  
  
  
  
datetime.timedelta(days=3650)
  
  
  
  
>>> ten_years.days // 365
  
  
  
  
10
  
  
  
  
>>> nine_years = ten_years - year
  
  
  
  
>>> nine_years
  
  
  
  
datetime.timedelta(days=3285)
  
  
  
  
>>> three_years = nine_years // 3
  
  
  
  
>>> three_years, three_years.days // 365
  
  
  
  
(datetime.timedelta(days=1095), 3)
 
 
 
 

date 對象

date 對象代表一個理想化歷法中的日期（年、月和日），即當今的格列高利歷向前后兩個方向無限延伸。

公元 1 年 1 月 1日是第 1 日，公元 1 年 1 月 2 日是第 2 日，依此類推。 2

class datetime.date(year, month, day)

所有參數(shù)都是必要的。 參數(shù)必須是在下面范圍內(nèi)的整數(shù)：

• MINYEAR <= year <= MAXYEAR

• 1 <= month <= 12

• 1 <= 日期 <= 給定年月對應(yīng)的天數(shù)

如果參數(shù)不在這些范圍內(nèi)，則拋出 ValueError 異常。

其它構(gòu)造器，所有的類方法：

classmethod date.today()

返回當前的本地日期。

這等價于 date.fromtimestamp(time.time())。

classmethod date.fromtimestamp(timestamp)

返回對應(yīng)于 POSIX 時間戳的當?shù)貢r間，例如 time.time() 返回的就是時間戳。

這可能引發(fā) OverflowError，如果時間戳數(shù)值超出所在平臺 C localtime() 函數(shù)的支持范圍的話，并且會在 localtime() 出錯時引發(fā) OSError。 通常該數(shù)值會被限制在 1970 年至 2038 年之間。 請注意在時間戳概念包含閏秒的非 POSIX 系統(tǒng)上，閏秒會被 fromtimestamp() 所忽略。

在 3.3 版更改: 引發(fā) OverflowError 而不是 ValueError，如果時間戳數(shù)值超出所在平臺 C localtime() 函數(shù)的支持范圍的話，并會在 localtime() 出錯時引發(fā) OSError 而不是 ValueError。

classmethod date.fromordinal(ordinal)

返回對應(yīng)于預(yù)期格列高利歷序號的日期，其中公元 1 年 1 月 1 日的序號為 1。

除非 1 <= ordinal <= date.max.toordinal() 否則會引發(fā) ValueError。對于任意日期 d，date.fromordinal(d.toordinal()) == d。

classmethod date.fromisoformat(date_string)

Return a date corresponding to a date_string given in any valid ISO 8601 format, except ordinal dates (e.g. YYYY-DDD):

 
 
 
 

  
  
  
  
>>> from datetime import date
  
  
  
  
>>> date.fromisoformat('2019-12-04')
  
  
  
  
datetime.date(2019, 12, 4)
  
  
  
  
>>> date.fromisoformat('20191204')
  
  
  
  
datetime.date(2019, 12, 4)
  
  
  
  
>>> date.fromisoformat('2021-W01-1')
  
  
  
  
datetime.date(2021, 1, 4)
 
 
 
 

3.7 新版功能.

在 3.11 版更改: Previously, this method only supported the format YYYY-MM-DD.

classmethod date.fromisocalendar(year, week, day)

返回指定 year, week 和 day 所對應(yīng) ISO 歷法日期的 date。 這是函數(shù) date.isocalendar() 的逆操作。

3.8 新版功能.

類屬性：

date.min

最小的日期 date(MINYEAR, 1, 1) 。

date.max

最大的日期 ，date(MAXYEAR, 12, 31)。

date.resolution

兩個日期對象的最小間隔，timedelta(days=1)。

實例屬性（只讀）：

date.year

在 MINYEAR 和 MAXYEAR 之間，包含邊界。

date.month

1 至 12（含）

date.day

返回1到指定年月的天數(shù)間的數(shù)字。

支持的運算：

注釋：

1. 如果 timedelta.days > 0 則 date2 將在時間線上前進，如果 timedelta.days < 0 則將后退。 操作完成后 date2 - date1 == timedelta.days。 timedelta.seconds 和 timedelta.microseconds 會被忽略。 如果 date2.year 將小于 MINYEAR 或大于 MAXYEAR 則會引發(fā) OverflowError。

2. timedelta.seconds 和 timedelta.microseconds 會被忽略。

3. 此值完全精確且不會溢出。 操作完成后 timedelta.seconds 和 timedelta.microseconds 均為 0，并且 date2 + timedelta == date1。

4. 換句話說，當且僅當 date1.toordinal() < date2.toordinal() 時 date1 < date2。 日期比較會引發(fā) TypeError，如果比較目標不為 date 對象的話。 不過也可能會返回 NotImplemented，如果比較目標具有 timetuple() 屬性的話。 這個鉤子給予其他日期對象類型實現(xiàn)混合類型比較的機會。 否則，當 date 對象與不同類型的對象比較時將會引發(fā) TypeError，除非是 == 或 != 比較。 后兩種情況將分別返回 False 或 True。

在布爾運算中，所有 date 對象都會被視為真值。

實例方法：

date.replace(year=self.year, month=self.month, day=self.day)

返回一個具有同樣值的日期，除非通過任何關(guān)鍵字參數(shù)給出了某些形參的新值。

示例:

 
 
 
 

  
  
  
  
>>> from datetime import date
  
  
  
  
>>> d = date(2002, 12, 31)
  
  
  
  
>>> d.replace(day=26)
  
  
  
  
datetime.date(2002, 12, 26)
 
 
 
 

date.timetuple()

返回一個 time.struct_time，即 time.localtime() 所返回的類型。

hours, minutes 和 seconds 值均為 0，且 DST 旗標值為 -1。

d.timetuple() 等價于:

 
 
 
 

  
  
  
  
time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))
 
 
 
 

其中 yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 是當前年份中的日期序號，1 月 1 日的序號為 1。

date.toordinal()

返回日期的預(yù)期格列高利歷序號，其中公元 1 年 1 月 1 日的序號為 1。 對于任意 date 對象 d，date.fromordinal(d.toordinal()) == d。

date.weekday()

返回一個整數(shù)代表星期幾，星期一為0，星期天為6。例如， date(2002, 12, 4).weekday() == 2，表示的是星期三。參閱 isoweekday()。

date.isoweekday()

返回一個整數(shù)代表星期幾，星期一為1，星期天為7。例如：date(2002, 12, 4).isoweekday() == 3,表示星期三。參見 weekday(), isocalendar()。

date.isocalendar()

返回一個由三部分組成的 named tuple 對象: year, week 和 weekday。

ISO 歷法是一種被廣泛使用的格列高利歷。 3

ISO 年由 52 或 53 個完整星期構(gòu)成，每個星期開始于星期一結(jié)束于星期日。 一個 ISO 年的第一個星期就是（格列高利）歷法的一年中第一個包含星期四的星期。 這被稱為 1 號星期，這個星期四所在的 ISO 年與其所在的格列高利年相同。

例如，2004 年的第一天是星期四，因此 ISO 2004 年的第一個星期開始于 2003 年 12 月 29 日星期一，結(jié)束于 2004 年 1 月 4 日星期日:

 
 
 
 

  
  
  
  
>>> from datetime import date
  
  
  
  
>>> date(2003, 12, 29).isocalendar()
  
  
  
  
datetime.IsoCalendarDate(year=2004, week=1, weekday=1)
  
  
  
  
>>> date(2004, 1, 4).isocalendar()
  
  
  
  
datetime.IsoCalendarDate(year=2004, week=1, weekday=7)
 
 
 
 

在 3.9 版更改: 結(jié)果由元組改為 named tuple。

date.isoformat()

返回一個以 ISO 8601 格式 YYYY-MM-DD 來表示日期的字符串:

 
 
 
 

  
  
  
  
>>> from datetime import date
  
  
  
  
>>> date(2002, 12, 4).isoformat()
  
  
  
  
'2002-12-04'
 
 
 
 

date.__str__()

對于日期對象 d, str(d) 等價于 d.isoformat() 。

date.ctime()

返回一個表示日期的字符串:

 
 
 
 

  
  
  
  
>>> from datetime import date
  
  
  
  
>>> date(2002, 12, 4).ctime()
  
  
  
  
'Wed Dec 4 00:00:00 2002'
 
 
 
 

d.ctime() 等效于:

 
 
 
 

  
  
  
  
time.ctime(time.mktime(d.timetuple()))
 
 
 
 

在原生 C ctime() 函數(shù) (time.ctime() 會發(fā)起調(diào)用該函數(shù)，但 date.ctime() 則不會) 遵循 C 標準的平臺上。

date.strftime(format)

返回一個由顯式格式字符串所指明的代表日期的字符串。 表示時、分或秒的格式代碼值將為 0。 要獲取格式指令的完整列表請參閱 strftime() 和 strptime() 的行為。

date.__format__(format)

與 date.strftime() 相同。 此方法使得為 date 對象指定以 格式化字符串字面值 表示的格式化字符串以及使用 str.format() 進行格式化成為可能。 要獲取格式指令的完整列表，請參閱 strftime() 和 strptime() 的行為。

class:date 用法示例

計算距離特定事件天數(shù)的例子:

 
 
 
 

  
  
  
  
>>> import time
  
  
  
  
>>> from datetime import date
  
  
  
  
>>> today = date.today()
  
  
  
  
>>> today
  
  
  
  
datetime.date(2007, 12, 5)
  
  
  
  
>>> 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(2008, 6, 24)
  
  
  
  
>>> time_to_birthday = abs(my_birthday - today)
  
  
  
  
>>> time_to_birthday.days
  
  
  
  
202
 
 
 
 

使用 date 的更多例子：

 
 
 
 

  
  
  
  
>>> from datetime import date
  
  
  
  
>>> d = date.fromordinal(730920) # 730920th day after 1. 1. 0001
  
  
  
  
>>> d
  
  
  
  
datetime.date(2002, 3, 11)
  
  
  
  

  
  
  
  
>>> # Methods related to formatting string output
  
  
  
  
>>> d.isoformat()
  
  
  
  
'2002-03-11'
  
  
  
  
>>> d.strftime("%d/%m/%y")
  
  
  
  
'11/03/02'
  
  
  
  
>>> d.strftime("%A %d. %B %Y")
  
  
  
  
'Monday 11. March 2002'
  
  
  
  
>>> d.ctime()
  
  
  
  
'Mon Mar 11 00:00:00 2002'
  
  
  
  
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
  
  
  
  
'The day is 11, the month is March.'
  
  
  
  

  
  
  
  
>>> # Methods for to extracting 'components' under different calendars
  
  
  
  
>>> t = d.timetuple()
  
  
  
  
>>> for i in t: 
  
  
  
  
... print(i)
  
  
  
  
2002 # year
  
  
  
  
3 # month
  
  
  
  
11 # day
  
  
  
  
0
  
  
  
  
0
  
  
  
  
0
  
  
  
  
0 # weekday (0 = Monday)
  
  
  
  
70 # 70th day in the year
  
  
  
  
-1
  
  
  
  
>>> ic = d.isocalendar()
  
  
  
  
>>> for i in ic: 
  
  
  
  
... print(i)
  
  
  
  
2002 # ISO year
  
  
  
  
11 # ISO week number
  
  
  
  
1 # ISO day number ( 1 = Monday )
  
  
  
  

  
  
  
  
>>> # A date object is immutable; all operations produce a new object
  
  
  
  
>>> d.replace(year=2005)
  
  
  
  
datetime.date(2005, 3, 11)
 
 
 
 

datetime 對象

datetime 對象是包含來自 date 對象和 time 對象的所有信息的單一對象。

與 date 對象一樣，datetime 假定當前的格列高利歷向前后兩個方向無限延伸；與 time 對象一樣，datetime 假定每一天恰好有 3600*24 秒。

構(gòu)造器 ：

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, **, fold=0*)

year, month 和 day 參數(shù)是必須的。 tzinfo 可以是 None 或者是一個 tzinfo 子類的實例。 其余的參數(shù)必須是在下面范圍內(nèi)的整數(shù)：

• MINYEAR <= year <= MAXYEAR,

• 1 <= month <= 12,

• 1 <= day <= 指定年月的天數(shù),

• 0 <= hour < 24,

• 0 <= minute < 60,

• 0 <= second < 60,

• 0 <= microsecond < 1000000,

• fold in [0, 1].

如果參數(shù)不在這些范圍內(nèi)，則拋出 ValueError 異常。

3.6 新版功能: 增加了 fold 參數(shù)。

其它構(gòu)造器，所有的類方法：

classmethod datetime.today()

返回表示當前地方時的 datetime 對象，其中 tzinfo 為 None。

等價于:

 
 
 
 

  
  
  
  
datetime.fromtimestamp(time.time())
 
 
 
 

另請參閱 now(), fromtimestamp()。

此方法的功能等價于 now()，但是不帶 tz 形參。

classmethod datetime.now(tz=None)

返回表示當前地方時的 date 和 time 對象。

如果可選參數(shù) tz 為 None 或未指定，這就類似于 today()，但該方法會在可能的情況下提供比通過 time.time() 時間戳所獲時間值更高的精度（例如，在提供了 C gettimeofday() 函數(shù)的平臺上就可以做到這一點）。

如果 tz 不為 None，它必須是 tzinfo 子類的一個實例，并且當前日期和時間將被轉(zhuǎn)換到 tz 時區(qū)。

此函數(shù)可以替代 today() 和 utcnow()。

classmethod datetime.utcnow()

返回表示當前 UTC 時間的 date 和 time，其中 tzinfo 為 None。

這類似于 now()，但返回的是當前 UTC 日期和時間，類型為簡單型 datetime 對象。 感知型的當前 UTC 日期時間可通過調(diào)用 datetime.now(timezone.utc) 來獲得。 另請參閱 now()。

警告

由于簡單型 datetime 對象會被許多 datetime 方法當作本地時間來處理，最好是使用感知型日期時間對象來表示 UTC 時間。 因此，創(chuàng)建表示當前 UTC 時間的對象的推薦方式是通過調(diào)用 datetime.now(timezone.utc)。

classmethod datetime.fromtimestamp(timestamp, tz=None)

返回 POSIX 時間戳對應(yīng)的本地日期和時間，如 time.time() 返回的。 如果可選參數(shù) tz 指定為 None 或未指定，時間戳將轉(zhuǎn)換為平臺的本地日期和時間，并且返回的 datetime 對象將為簡單型。

如果 tz 不為 None，它必須是 tzinfo 子類的一個實例，并且時間戳將被轉(zhuǎn)換到 tz 指定的時區(qū)。

fromtimestamp() 可能會引發(fā) OverflowError，如果時間戳數(shù)值超出所在平臺 C localtime() 或 gmtime() 函數(shù)的支持范圍的話，并會在 localtime() 或 gmtime() 報錯時引發(fā) OSError。 通常該數(shù)值會被限制在 1970 年至 2038 年之間。 請注意在時間戳概念包含閏秒的非 POSIX 系統(tǒng)上，閏秒會被 fromtimestamp() 所忽略，結(jié)果可能導(dǎo)致兩個相差一秒的時間戳產(chǎn)生相同的 datetime 對象。 相比 utcfromtimestamp() 更推薦使用此方法。

在 3.3 版更改: 引發(fā) OverflowError 而不是 ValueError，如果時間戳數(shù)值超出所在平臺 C localtime() 或 gmtime() 函數(shù)的支持范圍的話。 并會在 localtime() 或 gmtime() 出錯時引發(fā) OSError 而不是 ValueError。

在 3.6 版更改: fromtimestamp() 可能返回 fold 值設(shè)為 1 的實例。

classmethod datetime.utcfromtimestamp(timestamp)

返回對應(yīng)于 POSIX 時間戳的 UTC datetime，其中 tzinfo 值為 None。 （結(jié)果為簡單型對象。）

這可能引發(fā) OverflowError，如果時間戳數(shù)值超出所在平臺 C gmtime() 函數(shù)的支持范圍的話，并會在 gmtime() 報錯時引發(fā) OSError。 通常該數(shù)值會被限制在 1970 至 2038 年之間。

要得到一個感知型 datetime 對象，應(yīng)調(diào)用 fromtimestamp():

 
 
 
 

  
  
  
  
datetime.fromtimestamp(timestamp, timezone.utc)
 
 
 
 

在 POSIX 兼容的平臺上，它等價于以下表達式:

 
 
 
 

  
  
  
  
datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)
 
 
 
 

不同之處在于后一種形式總是支持完整年份范圍：從 MINYEAR 到 MAXYEAR 的開區(qū)間。

警告

由于簡單型 datetime 對象會被許多 datetime 方法當作本地時間來處理，最好是使用感知型日期時間對象來表示 UTC 時間。 因此，創(chuàng)建表示特定 UTC 時間戳的日期時間對象的推薦方式是通過調(diào)用 datetime.fromtimestamp(timestamp, tz=timezone.utc)。

在 3.3 版更改: 引發(fā) OverflowError 而不是 ValueError，如果時間戳數(shù)值超出所在平臺 C gmtime() 函數(shù)的支持范圍的話。 并會在 gmtime() 出錯時引發(fā) OSError 而不是 ValueError。

classmethod datetime.fromordinal(ordinal)

返回對應(yīng)于預(yù)期格列高利歷序號的 datetime，其中公元 1 年 1 月 1 日的序號為 1。 除非 1 <= ordinal <= datetime.max.toordinal() 否則會引發(fā) ValueError。 結(jié)果的 hour, minute, second 和 microsecond 值均為 0，并且 tzinfo 值為 None。

classmethod datetime.combine(date, time, tzinfo=self.tzinfo)

返回一個新的 datetime 對象，對象的日期部分等于給定的 date 對象的值，而其時間部分等于給定的 time 對象的值。 如果提供了 tzinfo 參數(shù)，其值會被用來設(shè)置結(jié)果的 tzinfo 屬性，否則將使用 time 參數(shù)的 tzinfo 屬性。

對于任意 datetime 對象 d，d == datetime.combine(d.date(), d.time(), d.tzinfo)。 如果 date 是一個 datetime 對象，它的時間部分和 tzinfo 屬性會被忽略。

在 3.6 版更改: 增加了 tzinfo 參數(shù)。

classmethod datetime.fromisoformat(date_string)

Return a datetime corresponding to a date_string in any valid ISO 8601 format, with the following exceptions:

1. Time zone offsets may have fractional seconds.

2. The T separator may be replaced by any single unicode character.

3. Ordinal dates are not currently supported.

4. Fractional hours and minutes are not supported.

示例:

 
 
 
 

  
  
  
  
>>> from datetime import datetime
  
  
  
  
>>> datetime.fromisoformat('2011-11-04')
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 0)
  
  
  
  
>>> datetime.fromisoformat('20111104')
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 0)
  
  
  
  
>>> datetime.fromisoformat('2011-11-04T00:05:23')
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 5, 23)
  
  
  
  
>>> datetime.fromisoformat('2011-11-04T00:05:23Z')
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)
  
  
  
  
>>> datetime.fromisoformat('20111104T000523')
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 5, 23)
  
  
  
  
>>> datetime.fromisoformat('2011-W01-2T00:05:23.283')
  
  
  
  
datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)
  
  
  
  
>>> datetime.fromisoformat('2011-11-04 00:05:23.283')
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)
  
  
  
  
>>> datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone.utc)
  
  
  
  
>>> datetime.fromisoformat('2011-11-04T00:05:23+04:00') 
  
  
  
  
datetime.datetime(2011, 11, 4, 0, 5, 23,
  
  
  
  
 tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))
 
 
 
 

3.7 新版功能.

在 3.11 版更改: Previously, this method only supported formats that could be emitted by date.isoformat() or datetime.isoformat().

classmethod datetime.fromisocalendar(year, week, day)

返回以 year, week 和 day 值指明的 ISO 歷法日期所對應(yīng)的 datetime。 該datetime 對象的非日期部分將使用其標準默認值來填充。 這是函數(shù) datetime.isocalendar() 的逆操作。

3.8 新版功能.

classmethod datetime.strptime(date_string, format)

返回一個對應(yīng)于 date_string，根據(jù) format 進行解析得到的 datetime 對象。

這相當于：

 
 
 
 

  
  
  
  
datetime(*(time.strptime(date_string, format)[0:6]))
 
 
 
 

如果 date_string 和 format 無法被 time.strptime() 解析或它返回一個不是時間元組的值，則將引發(fā) ValueError。 要獲取格式化指令的完整列表，請參閱 strftime() 和 strptime() 的行為。

類屬性：

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 對象之間可能的最小間隔，timedelta(microseconds=1)。

實例屬性（只讀）：

datetime.year

在 MINYEAR 和 MAXYEAR 之間，包含邊界。

datetime.month

1 至 12（含）

datetime.day

返回1到指定年月的天數(shù)間的數(shù)字。

datetime.hour

取值范圍是 range(24)。

datetime.minute

取值范圍是 range(60)。

datetime.second

取值范圍是 range(60)。

datetime.microsecond

取值范圍是 range(1000000)。

datetime.tzinfo

作為 tzinfo 參數(shù)被傳給 datetime 構(gòu)造器的對象，如果沒有傳入值則為 None。

datetime.fold

取值范圍是 [0, 1]。 用于在重復(fù)的時間段中消除邊界時間歧義。 （當夏令時結(jié)束時回撥時鐘或由于政治原因?qū)е庐斆鲿r區(qū)的 UTC 時差減少就會出現(xiàn)重復(fù)的時間段。） 取值 0 (1) 表示兩個時刻早于（晚于）所代表的同一邊界時間。

3.6 新版功能.

支持的運算：

1. datetime2 是從 datetime1 去掉了一段 timedelta 的結(jié)果，如果 timedelta.days > 0 則是在時間線上前進，如果 timedelta.days < 0 則是在時間線上后退。 該結(jié)果具有與輸入的 datetime 相同的 tzinfo 屬性，并且操作完成后 datetime2 - datetime1 == timedelta。 如果 datetime2.year 將要小于 MINYEAR 或大于 MAXYEAR 則會引發(fā) OverflowError。 請注意即使輸入的是一個感知型對象，該方法也不會進行時區(qū)調(diào)整。

2. 計算 datetime2 使得 datetime2 + timedelta == datetime1。 與相加操作一樣，結(jié)果具有與輸入的 datetime 相同的 tzinfo 屬性，即使輸入的是一個感知型對象，該方法也不會進行時區(qū)調(diào)整。

3. 從一個 datetime 減去一個 datetime 僅對兩個操作數(shù)均為簡單型或均為感知型時有定義。 如果一個是感知型而另一個是簡單型，則會引發(fā) TypeError。

   如果兩個操作數(shù)都是簡單型，或都是感知型并且具有相同的 tzinfo 屬性，則 tzinfo 屬性會被忽略，并且結(jié)果會是一個使得 datetime2 + t == datetime1 的 timedelta 對象 t。 在此情況下不會進行時區(qū)調(diào)整。

   如果兩個操作數(shù)都是感知型且具有不同的 tzinfo 屬性，a-b 操作的效果就如同 a 和 b 首先被轉(zhuǎn)換為簡單型 UTC 日期時間。 結(jié)果將是 (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())，除非具體實現(xiàn)絕對不溢出。

4. 當 datetime1 的時間在 datetime2 之前則認為 datetime1 小于 datetime2。

   如果比較的一方是簡單型而另一方是感知型，則如果嘗試進行順序比較將引發(fā) TypeError。 對于相等比較，簡單型實例將永遠不等于感知型實例。

   如果兩個比較方都是感知型，且具有相同的 tzinfo 屬性，則相同的 tzinfo 屬性會被忽略并對基本日期時間值進行比較。 如果兩個比較方都是感知型且具有不同的 tzinfo 屬性，則兩個比較方將首先通過減去它們的 UTC 差值（使用 self.utcoffset() 獲取）來進行調(diào)整。

   在 3.3 版更改: 感知型和簡單型 datetime 實例之間的相等比較不會引發(fā) TypeError。

   備注

   為了防止比較操作回退為默認的對象地址比較方式，datetime 比較通常會引發(fā) TypeError，如果比較目標不同樣為 datetime 對象的話。 不過也可能會返回 NotImplemented，如果比較目標具有 timetuple() 屬性的話。 這個鉤子給予其他種類的日期對象實現(xiàn)混合類型比較的機會。 如果未實現(xiàn)，則當 datetime 對象與不同類型比較時將會引發(fā) TypeError，除非是 == 或 != 比較。 后兩種情況將分別返回 False 或 True。

實例方法：

datetime.date()

返回具有同樣 year, month 和 day 值的 date 對象。

datetime.time()

返回具有同樣 hour, minute, second, microsecond 和 fold 值的 time 對象。 tzinfo 值為 None。 另請參見 timetz() 方法。

在 3.6 版更改: fold 值會被復(fù)制給返回的 time 對象。

datetime.timetz()

返回具有同樣 hour, minute, second, microsecond, fold 和 tzinfo 屬性性的 time 對象。 另請參見 time() 方法。

在 3.6 版更改: fold 值會被復(fù)制給返回的 time 對象。

datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, **, fold=0*)

返回一個具有同樣屬性值的 datetime，除非通過任何關(guān)鍵字參數(shù)為某些屬性指定了新值。 請注意可以通過指定 tzinfo=None 來從一個感知型 datetime 創(chuàng)建一個簡單型 datetime 而不必轉(zhuǎn)換日期和時間數(shù)據(jù)。

3.6 新版功能: 增加了 fold 參數(shù)。

datetime.astimezone(tz=None)

返回一個具有新的 tzinfo 屬性 tz 的 datetime 對象，并會調(diào)整日期和時間數(shù)據(jù)使得結(jié)果對應(yīng)的 UTC 時間與 self 相同，但為 tz 時區(qū)的本地時間。

如果給出了 tz，則它必須是一個 tzinfo 子類的實例，并且其 utcoffset() 和 dst() 方法不可返回 None。 如果 self 為簡單型，它會被假定為基于系統(tǒng)時區(qū)表示的時間。

如果調(diào)用時不傳入?yún)?shù) (或傳入 tz=None) 則將假定目標時區(qū)為系統(tǒng)的本地時區(qū)。 轉(zhuǎn)換后 datetime 實例的 .tzinfo 屬性將被設(shè)為一個 timezone 實例，時區(qū)名稱和時差值將從 OS 獲取。

如果 self.tzinfo 為 tz，self.astimezone(tz) 等于 self: 不會對日期或時間數(shù)據(jù)進行調(diào)整。 否則結(jié)果為 tz 時區(qū)的本地時間，代表的 UTC 時間與 self 相同：在 astz = dt.astimezone(tz) 之后，astz - astz.utcoffset() 將具有與 dt - dt.utcof
本文題目：創(chuàng)新互聯(lián)Python教程：datetime—-基本日期和時間類型
新聞來源：http://www.dlmjj.cn/article/dhpcodo.html