`datetime` ---基本日期和时间类型¶

这个 datetime 模块提供用于处理日期和时间的类。

虽然支持日期和时间算法，但实现的重点是有效的属性提取，以进行输出格式和操作。

参见

模块 calendar: 常规日历相关功能。
模块 time: 时间访问和转换。
包裹 dateutil: 具有扩展时区和解析支持的第三方库。

有意识和天真的物体¶

根据日期和时间对象是否包含时区信息，可以将其分类为“感知”或“幼稚”。

在充分了解适用的算法和政治时间调整（如时区和夏令时信息）的情况下 意识到的 对象可以相对于其他感知对象定位自身。一个意识到的物体代表一个特定的时间时刻，而这个时刻是不可解释的。 1

A 天真的 对象不包含足够的信息，无法相对于其他日期/时间对象明确定位其自身。一个简单的对象是否表示协调世界时（UTC）、当地时间，或者某个其他时区的时间，完全取决于程序，就像一个特定的数字是否表示米、英里或质量一样。天真的对象很容易理解和使用，但代价是忽略了现实的某些方面。

对于需要感知对象的应用程序， datetime 和 time 对象具有可选的时区信息属性， tzinfo ，可以设置为抽象子类的实例 tzinfo 班级。这些 tzinfo 对象捕获有关与UTC时间的偏移量、时区名称以及夏令时是否有效的信息。

只有一种混凝土 tzinfo 类 timezone 类，由 datetime 模块。这个 timezone 类可以表示与UTC有固定偏移量的简单时区，例如UTC本身或北美EST和EDT时区。在更深层次上支持时区取决于应用程序。世界各地的时间调整规则都是政治性的，而不是理性的，变化频繁，除了UTC之外，没有一个标准适用于所有应用程序。

常量¶

这个 datetime 模块导出以下常量：

datetime.MINYEAR¶: a中允许的最小年份数 date 或 datetime 对象。 MINYEAR 是 1 .

datetime.MAXYEAR¶: a中允许的最大年份数 date 或 datetime 对象。 MAXYEAR 是 9999 .

可用类型¶

class datetime.date: 一个理想化的天真的日期，假设当前的公历一直有效，并且将永远有效。属性： year ， month 和 day .

class datetime.time: 一个理想化的时间，独立于任何特定的一天，假设每天正好有24天 * 60 * 60秒。（这里没有“闰秒”的概念）属性： hour ， minute ， second ， microsecond 和 tzinfo .

class datetime.datetime: 日期和时间的组合。属性： year ， month ， day ， hour ， minute ， second ， microsecond 和 tzinfo .

class datetime.timedelta: 表示两者之间差异的持续时间 date ， time 或 datetime 实例到微秒分辨率。

class datetime.tzinfo: 时区信息对象的抽象基类。它们被 datetime 和 time 类提供可自定义的时间调整概念（例如，考虑时区和/或夏令时）。

class datetime.timezone: 实现 tzinfo 将基类抽象为与UTC的固定偏移量。

3.2 新版功能.

这些类型的对象是不可变的。

子类关系：

object
    timedelta
    tzinfo
        timezone
    time
    date
        datetime

共同财产¶

这个 date ， datetime ， time 和 timezone 类型具有以下共同特征：

这些类型的对象是不可变的。
这些类型的对象是散列的，这意味着它们可以用作字典键。
这些类型的对象通过 pickle 模块。

确定一个对象是感知的还是天真的¶

对象 date 类型总是幼稚的。

类型的对象 time 或 datetime 可能意识到或天真。

A datetime 对象 d 如果以下两项都成立：

d.tzinfo is not None
d.tzinfo.utcoffset(d) does not return None

否则， d 幼稚。

A time 对象 t 如果以下两项都成立：

t.tzinfo is not None
t.tzinfo.utcoffset(None) 不返 None .

否则， t 幼稚。

觉知和天真的区别不适用于 timedelta 物体。

`timedelta` 物体¶

A timedelta 对象表示持续时间，即两个日期或时间之间的差。

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

所有参数都是可选的，默认为 0 . 参数可以是整数或浮点数，也可以是正数或负数。

只有 days ，秒和微秒存储在内部。参数转换为这些单位：

毫秒转换为1000微秒。
一分钟转换为60秒。
一小时转换为3600秒。
一周改为7天。

然后对天、秒和微秒进行标准化，使表示是唯一的，使用

0 <= microseconds < 1000000
0 <= seconds < 3600*24 （一天中的秒数）
-999999999 <= days <= 999999999

下面的例子说明了除了 days ，秒和微秒被“合并”并规范化为这三个结果属性：

>>> 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)

如果任何参数是浮点，并且存在小数微秒，则合并所有参数剩余的小数微秒，并使用舍入一半到偶数tiebraker将其和舍入到最接近的微秒。如果没有参数是浮点数，则转换和规范化过程是精确的（不会丢失任何信息）。

如果天数的标准化值超出指示范围， OverflowError 提高了。

注意，负值的标准化一开始可能会令人惊讶。例如：：

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

类属性：

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 对象。

实例属性（只读）：

属性	价值
`days`	介于-99999999和99999999之间（含99999999）
`seconds`	介于0和86399之间（含0和86399）
`microseconds`	介于0和999999之间（含0和999999）

支持的操作：

操作	结果
`t1 = t2 + t3`	总和 t2 和 t3 . 之后 t1 - t2 = t3 和 t1 - t3 = t2 是真的。（1）
`t1 = t2 - t3`	差异性 t2 和 t3 . 之后 t1 = t2 - t3 和 t2 = t1 + t3 是真的。（1）（6）
`t1 = t2 * i or t1 = i * t2`	增量乘以整数。之后 t1 /i= t2 是真的，前提是 `i != 0` .
	一般来说， t1 * I= t1 * （I-1）+ t1 是真的。（1）
`t1 = t2 * f or t1 = f * t2`	delta乘以float。使用舍入半到偶数将结果四舍五入为TimeDelta.Resolution的最接近倍数。
`f = t2 / t3`	总工期划分（3） t2 按间隔单位 t3 . 返回A `float` 对象。
`t1 = t2 / f or t1 = t2 / i`	delta除以float或int。使用round half to even将结果四舍五入为timedelta.resolution的最接近倍数。
`t1 = t2 // i` or `t1 = t2 // t3`	计算楼层，剩余部分（如果有的话）扔掉。在第二种情况下，返回一个整数。（三）
`t1 = t2 % t3`	余数计算为 `timedelta` 对象。（3）
`q, r = divmod(t1, t2)`	计算商和余数： `q = t1 // t2` （3）和 `r = t1 % t2` . q是一个整数，r是一个 `timedelta` 对象。
`+t1`	返回A `timedelta` 具有相同值的对象。（二）
`-t1`	相当于 `timedelta` （-） t1.days - t1.seconds - t1.microseconds ） t1 * - 1。（1）（4）
`abs(t)`	相当于+t 什么时候？ `t.days >= 0` 和- t 什么时候？ `t.days < 0` .（二）
`str(t)`	返回窗体中的字符串 `[D day[s], ][H]H:MM:SS[.UUUUUU]` ，其中d为负表示负 `t` . （5）
`repr(t)`	返回的字符串表示形式 `timedelta` 对象作为具有规范属性值的构造函数调用。

笔记：

这是准确的，但可能会溢出。
这是准确的，不能溢出。
以0分引发 ZeroDivisionError .
-timedelta.max is not representable as a timedelta object.
字符串表示 timedelta 对象的规格化与它们的内部表示类似。这会导致负时间增量出现一些不寻常的结果。例如：：
```
>>> timedelta(hours=-5)
datetime.timedelta(days=-1, seconds=68400)
>>> print(_)
-1 day, 19:00:00
```
表达式 t2 - t3 将始终等于表达式 t2 + (-t3) 除非t3等于 timedelta.max ；在这种情况下，前者将产生结果，而后者将溢出。

除了上面列出的操作之外， timedelta 对象支持某些加法和减法 date 和 datetime 对象（见下文）。

在 3.2 版更改: A的楼层划分和真实划分 timedelta 另一个对象 timedelta 现在支持对象，其余操作和 divmod() 功能。真除乘 timedelta 由A对象 float 现在支持对象。

比较 timedelta 对象是受支持的，但有一些注意事项。

The comparisons == or != always return a bool, no matter the type of the compared object:

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

用于所有其他比较（例如 < 和 > )，当 timedelta 对象与不同类型的对象进行比较， TypeError 提出：

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

在布尔上下文中，a timedelta 当且仅当对象不等于 timedelta(0) .

实例方法：

timedelta.total_seconds()¶

返回持续时间中包含的总秒数。相当于 td / timedelta(seconds=1) . 对于除秒以外的间隔单位，直接使用除法形式（例如 td / timedelta(microseconds=1) ）

请注意，对于非常大的时间间隔（大多数平台上超过270年），此方法将失去微秒精度。

3.2 新版功能.

用法示例： `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 算术：

>>> 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` 物体¶

A date 对象表示理想化日历中的日期（年、月和日），当前的公历在两个方向上无限期延长。

第1年的1月1日称为第1天，第1年的1月2日称为第2天，以此类推。 2

class datetime.date(year, month, day)¶

所有参数都是必需的。参数必须是整数，范围如下：

MINYEAR <= year <= MAXYEAR
1 <= month <= 12
1 <= day <= number of days in the given month and year

如果给出了超出这些范围的参数， ValueError 提高了。

其他构造函数，所有类方法：

classmethod date.today()¶

返回当前本地日期。

这相当于 date.fromtimestamp(time.time()) .

classmethod date.fromtimestamp(timestamp)¶

返回与posix时间戳相对应的本地日期，例如 time.time() .

这可能会提高 OverflowError ，如果时间戳超出平台C支持的值范围 localtime() 函数，以及 OSError 在 localtime() 失败。这是很常见的限制，从1970年到2038年。注意，在非POSIX系统中，在其时间戳概念中包含闰秒的情况下，闰秒被忽略 fromtimestamp() .

在 3.3 版更改: 提高 OverflowError 而不是 ValueError 如果时间戳超出平台C支持的值范围 localtime() 功能。提高 OSError 而不是 ValueError 在 localtime() 失败。

classmethod date.fromordinal(ordinal)¶

返回对应于无神论公历序数的日期，其中第一年的1月1日有序数1。

ValueError 除非 1 <= ordinal <= date.max.toordinal() . 任何日期 d ， date.fromordinal(d.toordinal()) == d .

classmethod date.fromisoformat(date_string)¶

返回A date 对应于 date_string 以格式给出 YYYY-MM-DD ：：

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

这与 date.isoformat() . 它只支持格式 YYYY-MM-DD .

3.7 新版功能.

classmethod date.fromisocalendar(year, week, day)¶: 返回A date 对应于由年、周和日指定的ISO日历日期。这是函数的倒数 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之间（含1和12）。

date.day¶: 一年内某月份的天数。

支持的操作：

操作	结果
`date2 = date1 + timedelta`	DATE2 是 `timedelta.days` 从中删除的天数日期1 . （一）
`date2 = date1 - timedelta`	计算 DATE2 这样的话 `date2 + timedelta == date1` .（二）
`timedelta = date1 - date2`	(3)
`date1 < date2`	日期1 被认为小于 DATE2 什么时候？日期1 先于 DATE2 及时。（4）

笔记：

DATE2 如果 timedelta.days > 0 ，或者如果 timedelta.days < 0 . 之后 date2 - date1 == timedelta.days . timedelta.seconds 和 timedelta.microseconds 被忽略。 OverflowError 如果 date2.year 会小于 MINYEAR 大于或大于 MAXYEAR .
timedelta.seconds 和 timedelta.microseconds 被忽略。
这是准确的，不能溢出。timedelta.seconds和timedelta.microseconds为0，date2+timedelta==date1之后。
换言之， date1 < date2 当且仅当 date1.toordinal() < date2.toordinal() . 日期比较加薪 TypeError 如果另一个比较也不是 date 对象。然而， NotImplemented 如果另一个comparand具有 timetuple() 属性。这个钩子为其他类型的数据对象提供了实现混合类型比较的机会。如果不是，当 date 对象与不同类型的对象进行比较， TypeError 除非比较结果 == 或 != . 后一种情况又出现了 False 或 True ，分别。

在布尔上下文中，所有 date 对象被认为是真的。

实例方法：

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

返回具有相同值的日期，但由指定的关键字参数赋予新值的参数除外。

例子：：

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

date.timetuple()¶

返回A time.struct_time 如返回者 time.localtime() .

小时、分钟和秒为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()¶: 返回日期的序数，其中年份1的1月1日具有序数1。任何人 date 对象 d ， date.fromordinal(d.toordinal()) == d .

date.weekday()¶: 以整数形式返回星期几，其中星期一为0，星期日为6。例如， date(2002, 12, 4).weekday() == 2 一个星期三。也见 isoweekday() .

date.isoweekday()¶: 以整数形式返回星期几，其中星期一为1，星期日为7。例如， date(2002, 12, 4).isoweekday() == 3 一个星期三。也见 weekday() ， isocalendar() .

date.isocalendar()¶

返回A named tuple 包含三个组件的对象： year ， week 和 weekday .

ISO日历是公历的一个广泛使用的变体。 3

ISO年由52或53个整周组成，一周从周一开始，到周日结束。ISO年的第一周是一年中包含星期四的第一个（公历）日历周。这被称为第1周，该星期四的ISO年与其公历年相同。

例如，2004年开始于一个星期四，所以2004年的第一个星期从2003年12月29日星期一开始，到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 版更改: 结果从元组更改为 named tuple .

date.isoformat()¶

返回以ISO 8601格式表示日期的字符串， YYYY-MM-DD ：：

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

这与 date.fromisoformat() .

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() 功能（哪些） time.ctime() 调用，但是 date.ctime() 不调用）符合C标准。

date.strftime(format)¶: 返回表示日期的字符串，由显式格式字符串控制。引用小时、分钟或秒的格式代码将显示0值。有关格式化指令的完整列表，请参见 strftime() 和 strptime() 行为 .

date.__format__(format)¶: 等同于 date.strftime() . 这使得可以为 date 中的对象 formatted string literals 当使用时 str.format() . 有关格式化指令的完整列表，请参见 strftime() 和 strptime() 行为 .

用法示例： `date`¶

事件的计数天数示例：

>>> 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` 物体¶

A datetime 对象是包含来自 date 对象与A time 对象。

像一个 date 对象， datetime 假设当前的公历向两个方向扩展；如 time 对象， datetime 假设有3600个 * 每天24秒。

Constructor：

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

这个 year ，月和 day 参数是必需的。 茨芬格 可能是 None 或 tzinfo 子类。其余参数必须是以下范围内的整数：

MINYEAR <= year <= MAXYEAR ，
1 <= month <= 12 ，
1 <= day <= number of days in the given month and year ，
0 <= hour < 24 ，
0 <= minute < 60 ，
0 <= second < 60 ，
0 <= microsecond < 1000000 ，
fold in [0, 1] .

如果给出了超出这些范围的参数， ValueError 提高了。

3.6 新版功能: 增加了 fold 参数。

其他构造函数，所有类方法：

classmethod datetime.today()¶

返回当前本地日期时间，使用 tzinfo None .

等同于：

datetime.fromtimestamp(time.time())

也见 now() ， fromtimestamp() .

这种方法在功能上等价于 now() ，但没有 tz 参数。

classmethod datetime.now(tz=None)¶

返回当前本地日期和时间。

if可选参数 tz 是 None 或者没有指定，这就像 today() 但是，如果可能的话，提供的精度比通过 time.time() 时间戳（例如，这可能在提供C的平台上实现 gettimeofday() 函数）。

如果 tz 不是 None ，它必须是 tzinfo 子类，当前日期和时间转换为 tz 的时区。

此功能优先于 today() 和 utcnow() .

classmethod datetime.utcnow()¶

返回当前的UTC日期和时间，使用 tzinfo None .

这就像 now() ，但返回当前的UTC日期和时间 datetime 反对。可以通过调用 datetime.now(timezone.utc) . 也见 now() .

警告

因为天真 datetime 物体被许多人处理 datetime 方法作为本地时间，最好使用aware datetimes以UTC表示时间。因此，建议通过调用 datetime.now(timezone.utc) .

classmethod datetime.fromtimestamp(timestamp, tz=None)¶

返回与posix时间戳相对应的本地日期和时间，例如 time.time() . if可选参数 tz 是 None 或者未指定，时间戳将转换为平台的本地日期和时间，并返回 datetime 对象是幼稚的。

如果 tz 不是 None ，它必须是 tzinfo 子类，时间戳转换为 tz 的时区。

fromtimestamp() 可以提高 OverflowError ，如果时间戳超出平台C支持的值范围 localtime() 或 gmtime() 功能，以及 OSError 在 localtime() 或 gmtime() 失败。在1970年到2038年，这是很常见的。注意，在非POSIX系统中，在时间戳概念中包含闰秒，闰秒被忽略。 fromtimestamp() ，然后可能有两个时间戳相差一秒，产生相同的结果。 datetime 物体。这种方法比 utcfromtimestamp() .

在 3.3 版更改: 提高 OverflowError 而不是 ValueError 如果时间戳超出平台C支持的值范围 localtime() 或 gmtime() 功能。提高 OSError 而不是 ValueError 在 localtime() 或 gmtime() 失败。

在 3.6 版更改: fromtimestamp() 可以返回实例 fold 设置为1。

classmethod datetime.utcfromtimestamp(timestamp)¶

返回UTC datetime 对应于posix时间戳，使用 tzinfo None . （生成的对象是天真的。）

这可能会提高 OverflowError ，如果时间戳超出平台C支持的值范围 gmtime() 函数，以及 OSError 在 gmtime() 失败。在1970年到2038年，这是很常见的。

了解 datetime 调用对象 fromtimestamp() ：：

datetime.fromtimestamp(timestamp, timezone.utc)

在符合POSIX的平台上，它相当于以下表达式：

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

除了后一个公式始终支持完整的年份范围：介于 MINYEAR 和 MAXYEAR 包容的。

警告

因为天真 datetime 物体被许多人处理 datetime 方法作为本地时间，最好使用aware datetimes以UTC表示时间。因此，建议通过调用 datetime.fromtimestamp(timestamp, tz=timezone.utc) .

在 3.3 版更改: 提高 OverflowError 而不是 ValueError 如果时间戳超出平台C支持的值范围 gmtime() 功能。提高 OSError 而不是 ValueError 在 gmtime() 失败。

classmethod datetime.fromordinal(ordinal)¶: 返回 datetime 对应于无神论的公历序数，其中第一年的1月1日有序数1。 ValueError 除非 1 <= ordinal <= datetime.max.toordinal() . 结果的小时、分钟、秒和微秒都是0，并且 tzinfo 是 None .

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

返回一个新的 datetime 其日期组件等于给定的 date 对象，其时间分量等于给定的 time 对象的。如果 茨芬格 提供了参数，其值用于设置 tzinfo 结果的属性，否则 tzinfo 的属性 time 使用了参数。

对于任何 datetime 对象 d ， d == datetime.combine(d.date(), d.time(), d.tzinfo) . 如果日期是 datetime 对象及其时间组件和 tzinfo 属性被忽略。

在 3.6 版更改: 增加了 茨芬格 参数。

classmethod datetime.fromisoformat(date_string)¶

返回A datetime 对应于 date_string 以 date.isoformat() 和 datetime.isoformat() .

具体来说，此函数支持以下格式的字符串：

YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]]

在哪里？ * 可以匹配任何单个字符。

警告

这确实 not 支持解析任意ISO 8601字符串-它仅用于 datetime.isoformat() . 一个功能更全面的ISO8601解析器， dateutil.parser.isoparse is available in the third-party package dateutil .

实例：

>>> from datetime import datetime
>>> datetime.fromisoformat('2011-11-04')
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-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 新版功能.

classmethod datetime.fromisocalendar(year, week, day)¶: 返回A datetime 对应于由年、周和日指定的ISO日历日期。日期时间的非日期组件用其正常默认值填充。这是函数的倒数 datetime.isocalendar() .

3.8 新版功能.

classmethod datetime.strptime(date_string, format)¶

返回A datetime 对应于 date_string ，根据格式 .

这相当于：

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

ValueError 如果无法分析日期字符串和格式，则引发 time.strptime() 或者返回一个不是时间元组的值。有关格式化指令的完整列表，请参见 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之间（含1和12）。

datetime.day¶: 一年内某月份的天数。

datetime.hour¶: 在 range(24) .

datetime.minute¶: 在 range(60) .

datetime.second¶: 在 range(60) .

datetime.microsecond¶: 在 range(1000000) .

datetime.tzinfo¶: 对象作为 茨芬格 参数 datetime 构造器，或 None 如果没有通过。

datetime.fold¶: 在 [0, 1] . 用于消除重复间隔期间墙时间的歧义。（当夏令时结束时时钟回滚，或由于政治原因降低当前区域的UTC偏移量时，会出现重复间隔。）值0（1）表示两个具有相同墙时表示的时间中较早（较晚）的时间。

3.6 新版功能.

支持的操作：

操作	结果
`datetime2 = datetime1 + timedelta`	(1)
`datetime2 = datetime1 - timedelta`	(2)
`timedelta = datetime1 - datetime2`	(3)
`datetime1 < datetime2`	比较 `datetime` 到 `datetime` .（4）

datetime2是从datetime1中删除的timedelta的持续时间，如果 timedelta.days >0，如果 timedelta.days <0。结果是一样的 tzinfo 属性作为输入日期时间，datetime2-datetime1==timedelta-after。 OverflowError 如果datetime2.year小于 MINYEAR 大于或大于 MAXYEAR . 请注意，即使输入是一个感知对象，也不会进行时区调整。
计算datetime2，使datetime2+timedelta==datetime1。另外，结果是一样的 tzinfo 属性作为输入日期时间，即使输入已知，也不会进行时区调整。
A的减法 datetime 从A datetime 仅当两个操作数都是纯操作或都知道时才定义。如果一个知道另一个天真， TypeError 提高了。

如果两个都是幼稚的，或者都是有意识的并且拥有相同的 tzinfo 属性 tzinfo 属性被忽略，结果是 timedelta 对象 t 这样的话 datetime2 + t == datetime1 . 在这种情况下不进行时区调整。

如果两者都意识到并有不同 tzinfo 属性， a-b 表现得像 a 和 b 首先转换为原始UTC日期时间。结果是 (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset()) 但实现永远不会溢出。
DATETME1 被认为小于 DATETME2 什么时候？ DATETME1 先于 DATETME2 及时。

如果一个比较器是幼稚的，而另一个却意识到， TypeError 在尝试进行订单比较时引发。对于平等比较，天真的实例永远不等于有意识的实例。

如果两个比较方都知道，并且具有相同的 tzinfo 属性，公共 tzinfo 属性被忽略，并比较基准日期时间。如果两个比较对象都知道并且有不同的 tzinfo 属性，首先通过减去其UTC偏移量（从 self.utcoffset() ）

在 3.3 版更改: 觉知与天真的平等比较 datetime 实例不会引发 TypeError .

注解

为了防止比较返回到对象地址比较的默认方案，datetime比较通常会引发 TypeError 如果另一个比较也不是 datetime 对象。然而， NotImplemented 如果另一个comparand具有 timetuple() 属性。这个钩子为其他类型的数据对象提供了实现混合类型比较的机会。如果不是，当 datetime 对象与不同类型的对象进行比较， TypeError 除非比较结果 == 或 != . 后一种情况又出现了 False 或 True ，分别。

实例方法：

datetime.date()¶: 返回 date 对象具有相同的年、月和日。

datetime.time()¶: 返回 time 对象具有相同的小时、分钟、秒、微秒和折叠。 tzinfo 是 None . 另见方法 timetz() .

在 3.6 版更改: 折叠值复制到返回的 time 对象。

datetime.timetz()¶: 返回 time 具有相同的小时、分钟、秒、微秒、折叠和tzinfo属性的对象。另见方法 time() .

在 3.6 版更改: 折叠值复制到返回的 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，除了那些通过指定关键字参数而赋予新值的属性。请注意 tzinfo=None 可以指定为从不转换日期和时间数据的已知日期时间创建原始日期时间。

3.6 新版功能: 增加了 fold 参数。

datetime.astimezone(tz=None)¶

返回A datetime 新对象 tzinfo 属性 tz ，调整日期和时间数据，使结果与 self ，但在 tz 当地时间。

如果提供， tz 必须是 tzinfo 子类及其 utcoffset() 和 dst() 方法不能返回 None .如果 self 是幼稚的，它被假定代表系统时区中的时间。

如果调用时没有参数（或 tz=None )目标时区假定为系统本地时区。这个 .tzinfo 已转换的日期时间实例的属性将设置为 timezone 从操作系统获取区域名称和偏移量。

如果 self.tzinfo 是 tz ， self.astimezone(tz) 等于 self ：不执行日期或时间数据的调整。否则，结果是时区中的本地时间 tz ，表示与 self 之后 astz = dt.astimezone(tz) ， astz - astz.utcoffset() 将具有与相同的日期和时间数据 dt - dt.utcoffset() .

如果只想附加时区对象 tz 到日期时间 dt 不调整日期和时间数据，使用 dt.replace(tzinfo=tz) . 如果您只想从已知日期时间中删除时区对象 dt 如果不转换日期和时间数据，请使用 dt.replace(tzinfo=None) .

注意，默认 tzinfo.fromutc() 方法可以在 tzinfo 影响返回结果的子类 astimezone() . 忽略错误案例， astimezone() 行为像：

def astimezone(self, tz):
    if self.tzinfo is tz:
        return self
    # Convert self to UTC, and attach the new time zone object.
    utc = (self - self.utcoffset()).replace(tzinfo=tz)
    # Convert from UTC to tz's local time.
    return tz.fromutc(utc)

在 3.3 版更改: tz 现在可以省略。

在 3.6 版更改: 这个 astimezone() 现在可以对假定表示系统本地时间的原始实例调用方法。

datetime.utcoffset()¶: 如果 tzinfo 是 None 回报 None 否则返回 self.tzinfo.utcoffset(self) ，如果后者不返回则引发异常 None 或A timedelta 小于一天的物体。

在 3.7 版更改: UTC偏移量不限于整数分钟。

datetime.dst()¶: 如果 tzinfo 是 None 回报 None 否则返回 self.tzinfo.dst(self) ，如果后者不返回则引发异常 None 或A timedelta 小于一天的物体。

在 3.7 版更改: DST偏移不限于整数分钟。

datetime.tzname()¶: 如果 tzinfo 是 None 回报 None 否则返回 self.tzinfo.tzname(self) ，如果后者不返回，则引发异常 None 或者字符串对象，

datetime.timetuple()¶

返回A time.struct_time 如返回者 time.localtime() .

d.timetuple() 等于：

time.struct_time((d.year, d.month, d.day,
                  d.hour, d.minute, d.second,
                  d.weekday(), yday, dst))

在哪里？ yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 是当前年份中从以下日期开始的日期 1 1月1日 tm_isdst 结果的标志根据 dst() 方法： tzinfo 是 None 或 dst() 收益率 None ， tm_isdst 设置为 -1 否则 dst() 返回一个非零值， tm_isdst 设置为 1 否则 tm_isdst 设置为 0 .

datetime.utctimetuple()¶

如果 datetime 实例 d 太天真了，这和 d.timetuple() 除了那个 tm_isdst 被强制为0，无论 d.dst() 返回。DST在UTC时间内从未生效。

如果 d 意识到， d 通过减去，标准化为UTC时间 d.utcoffset() 和A time.struct_time 返回标准化时间。 tm_isdst 强制为0。注意，一个 OverflowError 如果 d 年是 MINYEAR 或 MAXYEAR 联合技术公司的调整超出了一年的界限。

警告

因为天真 datetime 物体被许多人处理 datetime 方法作为本地时间，最好使用aware datetimes以UTC表示时间；因此，使用 utcfromtimetuple 可能会产生误导性的结果。如果你有一个天真的 datetime 表示UTC，使用 datetime.replace(tzinfo=timezone.utc) 为了让它知道，在这一点上你可以使用 datetime.timetuple() .

datetime.toordinal()¶: 返回日期的序数。一样 self.date().toordinal() .

datetime.timestamp()¶

返回与 datetime 实例。返回值是 float 类似于 time.time() .

天真 datetime 假设实例代表本地时间，该方法依赖于平台C mktime() 执行转换的函数。自从 datetime 支持比 mktime() 在许多平台上，这种方法可以提高 OverflowError 无论是过去还是将来。

为察觉 datetime 实例，返回值计算为：

(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()

3.3 新版功能.

在 3.6 版更改: 这个 timestamp() 方法使用 fold 属性在重复间隔期间消除时间的歧义。

注解

没有直接从naive获取posix时间戳的方法 datetime 表示UTC时间的实例。如果应用程序使用此约定，并且系统时区未设置为UTC，则可以通过提供 tzinfo=timezone.utc ：：

timestamp = dt.replace(tzinfo=timezone.utc).timestamp()

或者直接计算时间戳：

timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)

datetime.weekday()¶: 以整数形式返回星期几，其中星期一为0，星期日为6。一样 self.date().weekday() . 也见 isoweekday() .

datetime.isoweekday()¶: 以整数形式返回星期几，其中星期一为1，星期日为7。一样 self.date().isoweekday() . 也见 weekday() ， isocalendar() .

datetime.isocalendar()¶: 返回A named tuple 由三部分组成： year ， week 和 weekday . 一样 self.date().isocalendar() .

datetime.isoformat(sep='T', timespec='auto')¶

以ISO 8601格式返回表示日期和时间的字符串：

YYYY-MM-DDTHH:MM:SS.ffffff 如果 microsecond 不是0
YYYY-MM-DDTHH:MM:SS 如果 microsecond 是0

如果 utcoffset() 不返 None ，追加一个字符串，给出UTC偏移量：

YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]] 如果 microsecond 不是0
YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]] ，如果 microsecond 是0

实例：

>>> from datetime import datetime, timezone
>>> datetime(2019, 5, 18, 15, 17, 8, 132263).isoformat()
'2019-05-18T15:17:08.132263'
>>> datetime(2019, 5, 18, 15, 17, tzinfo=timezone.utc).isoformat()
'2019-05-18T15:17:00+00:00'

可选参数 sep （默认） 'T' )是一个单字符分隔符，位于结果的日期和时间部分之间。例如：：

>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
...     """A time zone with an arbitrary, constant -06:39 offset."""
...     def utcoffset(self, dt):
...         return timedelta(hours=-6, minutes=-39)
...
>>> datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'
>>> datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()
'2009-11-27T00:00:00.000100-06:39'

可选参数 TimeSime 指定要包括的时间的附加组件数（默认值为 'auto' ）它可以是以下之一：

'auto' 一样 'seconds' 如果 microsecond 为0，与 'microseconds' 否则。
'hours' 包括： hour 两位数 HH 格式。
'minutes' 包括 hour 和 minute 在里面 HH:MM 格式。
'seconds' 包括 hour ， minute 和 second 在里面 HH:MM:SS 格式。
'milliseconds' ：包括全时，但将小数第二部分截断为毫秒。 HH:MM:SS.sss 格式。
'microseconds' ：包括全日制 HH:MM:SS.ffffff 格式。

注解

排除的时间组件被截断，而不是四舍五入。

ValueError 将在无效的 TimeSime 论点：

>>> from datetime import datetime
>>> datetime.now().isoformat(timespec='minutes')   
'2002-12-25T00:00'
>>> dt = datetime(2015, 1, 1, 12, 30, 59, 0)
>>> dt.isoformat(timespec='microseconds')
'2015-01-01T12:30:59.000000'

3.6 新版功能: 增加了 timespec 参数。

datetime.__str__()¶: 对于一个 datetime 实例 d ， str(d) 等于 d.isoformat(' ') .

datetime.ctime()¶

返回表示日期和时间的字符串：

>>> from datetime import datetime
>>> datetime(2002, 12, 4, 20, 30, 40).ctime()
'Wed Dec  4 20:30:40 2002'

输出字符串将 not 包括时区信息，无论输入是感知的还是天真的。

d.ctime() 等于：

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

在本机C的平台上 ctime() 功能（哪些） time.ctime() 调用，但是 datetime.ctime() 不调用）符合C标准。

datetime.strftime(format)¶: 返回一个表示日期和时间的字符串，由显式格式字符串控制。有关格式化指令的完整列表，请参见 strftime() 和 strptime() 行为 .

datetime.__format__(format)¶: 等同于 datetime.strftime() . 这使得可以为 datetime 中的对象 formatted string literals 当使用时 str.format() . 有关格式化指令的完整列表，请参见 strftime() 和 strptime() 行为 .

用法示例： `datetime`¶

使用示例 datetime 物体：

>>> from datetime import datetime, date, time, timezone

>>> # Using datetime.combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)

>>> # Using datetime.now()
>>> datetime.now()   
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.now(timezone.utc)   
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060, tzinfo=datetime.timezone.utc)

>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)

>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:   
...     print(it)
...
2006    # year
11      # month
21      # day
16      # hour
30      # minute
0       # second
1       # weekday (0 = Monday)
325     # number of days since 1st January
-1      # dst - method tzinfo.dst() returned None

>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:   
...     print(it)
...
2006    # ISO year
47      # ISO week
2       # ISO weekday

>>> # Formatting a datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 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.'

下面的示例定义了 tzinfo 为阿富汗喀布尔捕获时区信息的子类，在1945年之前使用+4 UTC，之后使用+4:30 UTC:：

from datetime import timedelta, datetime, tzinfo, timezone

class KabulTz(tzinfo):
    # Kabul used +4 until 1945, when they moved to +4:30
    UTC_MOVE_DATE = datetime(1944, 12, 31, 20, tzinfo=timezone.utc)

    def utcoffset(self, dt):
        if dt.year < 1945:
            return timedelta(hours=4)
        elif (1945, 1, 1, 0, 0) <= dt.timetuple()[:5] < (1945, 1, 1, 0, 30):
            # An ambiguous ("imaginary") half-hour range representing
            # a 'fold' in time due to the shift from +4 to +4:30.
            # If dt falls in the imaginary range, use fold to decide how
            # to resolve. See PEP495.
            return timedelta(hours=4, minutes=(30 if dt.fold else 0))
        else:
            return timedelta(hours=4, minutes=30)

    def fromutc(self, dt):
        # Follow same validations as in datetime.tzinfo
        if not isinstance(dt, datetime):
            raise TypeError("fromutc() requires a datetime argument")
        if dt.tzinfo is not self:
            raise ValueError("dt.tzinfo is not self")

        # A custom implementation is required for fromutc as
        # the input to this function is a datetime with utc values
        # but with a tzinfo set to self.
        # See datetime.astimezone or fromtimestamp.
        if dt.replace(tzinfo=timezone.utc) >= self.UTC_MOVE_DATE:
            return dt + timedelta(hours=4, minutes=30)
        else:
            return dt + timedelta(hours=4)

    def dst(self, dt):
        # Kabul does not observe daylight saving time.
        return timedelta(0)

    def tzname(self, dt):
        if dt >= self.UTC_MOVE_DATE:
            return "+04:30"
        return "+04"

用法 KabulTz 从上面：

>>> tz1 = KabulTz()

>>> # Datetime before the change
>>> dt1 = datetime(1900, 11, 21, 16, 30, tzinfo=tz1)
>>> print(dt1.utcoffset())
4:00:00

>>> # Datetime after the change
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=tz1)
>>> print(dt2.utcoffset())
4:30:00

>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(timezone.utc)
>>> dt3
datetime.datetime(2006, 6, 14, 8, 30, tzinfo=datetime.timezone.utc)
>>> dt2
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=KabulTz())
>>> dt2 == dt3
True

`time` 物体¶

A time 对象表示一天中独立于任何特定日期的（本地）时间，并可通过 tzinfo 对象。

class datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)¶

所有参数都是可选的。 茨芬格 可能是 None 或 tzinfo 子类。其余参数必须是以下范围内的整数：

0 <= hour < 24 ，
0 <= minute < 60 ，
0 <= second < 60 ，
0 <= microsecond < 1000000 ，
fold in [0, 1] .

如果给出了超出这些范围的参数， ValueError 是升起的。全部默认为 0 除了 茨芬格 ，默认为 None .

类属性：

time.min¶: 最早的代表 time ， time(0, 0, 0, 0) .

time.max¶: 最新代表 time ， time(23, 59, 59, 999999) .

time.resolution¶: 非相等的最小可能差 time 物体， timedelta(microseconds=1) 尽管请注意 time 不支持对象。

实例属性（只读）：

time.hour¶: 在 range(24) .

time.minute¶: 在 range(60) .

time.second¶: 在 range(60) .

time.microsecond¶: 在 range(1000000) .

time.tzinfo¶: 作为tzinfo参数传递给 time 构造器，或 None 如果没有通过。

time.fold¶: 在 [0, 1] . 用于消除重复间隔期间墙时间的歧义。（当夏令时结束时时钟回滚，或由于政治原因降低当前区域的UTC偏移量时，会出现重复间隔。）值0（1）表示两个具有相同墙时表示的时间中较早（较晚）的时间。

3.6 新版功能.

time 对象支持比较 time 到 time 在哪里 a 被认为小于 b 什么时候？ a 先于 b 及时。如果一个比较者天真，另一个知道， TypeError 在尝试进行订单比较时引发。对于平等比较，天真的实例永远不等于有意识的实例。

如果两个比较方都知道，并且具有相同的 tzinfo 属性，公共 tzinfo 属性被忽略，并且比较基准时间。如果两个比较对象都知道并且有不同的 tzinfo 属性，首先通过减去其UTC偏移量（从 self.utcoffset() ）为了防止混合类型比较返回到按对象地址的默认比较，当 time 对象与不同类型的对象进行比较， TypeError 除非比较结果 == 或 != . 后一种情况又出现了 False 或 True ，分别。

在 3.3 版更改: 觉知与天真的平等比较 time 实例不会引发 TypeError .

在布尔上下文中，a time 对象总是被认为是真的。

在 3.5 版更改: 在python 3.5之前，a time 如果对象以UTC表示午夜，则将其视为false。这种行为被认为晦涩难懂且容易出错，并已在Python3.5中删除。见 bpo-13936 详细信息。

其他构造器：

classmethod time.fromisoformat(time_string)¶

返回A time 对应于 time_string 以 time.isoformat() . 具体来说，此函数支持以下格式的字符串：

HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]

警告

这确实 not 支持解析任意ISO 8601字符串。它只用于 time.isoformat() .

实例：

>>> from datetime import time
>>> time.fromisoformat('04:23:01')
datetime.time(4, 23, 1)
>>> time.fromisoformat('04:23:01.000384')
datetime.time(4, 23, 1, 384)
>>> time.fromisoformat('04:23:01+04:00')
datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

3.7 新版功能.

实例方法：

time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)¶: 返回A time 具有相同的值，但由指定的关键字参数赋予新值的属性除外。请注意 tzinfo=None 可以指定为创建一个 time 从意识到 time ，而不转换时间数据。

3.6 新版功能: 增加了 fold 参数。

time.isoformat(timespec='auto')¶

返回以ISO 8601格式表示时间的字符串，其格式为：

HH:MM:SS.ffffff 如果 microsecond 不是0
HH:MM:SS 如果 microsecond 是0
HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], if utcoffset() does not return None
HH:MM:SS+HH:MM[:SS[.ffffff]], if microsecond is 0 and utcoffset() does not return None

可选参数 TimeSime 指定要包括的时间的附加组件数（默认值为 'auto' ）它可以是以下之一：

'auto' 一样 'seconds' 如果 microsecond 为0，与 'microseconds' 否则。
'hours' 包括： hour 两位数 HH 格式。
'minutes' 包括 hour 和 minute 在里面 HH:MM 格式。
'seconds' 包括 hour ， minute 和 second 在里面 HH:MM:SS 格式。
'milliseconds' ：包括全时，但将小数第二部分截断为毫秒。 HH:MM:SS.sss 格式。
'microseconds' ：包括全日制 HH:MM:SS.ffffff 格式。

注解

排除的时间组件被截断，而不是四舍五入。

ValueError 将在无效的 TimeSime 参数。

例子：：

>>> from datetime import time
>>> time(hour=12, minute=34, second=56, microsecond=123456).isoformat(timespec='minutes')
'12:34'
>>> dt = time(hour=12, minute=34, second=56, microsecond=0)
>>> dt.isoformat(timespec='microseconds')
'12:34:56.000000'
>>> dt.isoformat(timespec='auto')
'12:34:56'

3.6 新版功能: 增加了 timespec 参数。

time.__str__()¶: 一段时间 t ， str(t) 等于 t.isoformat() .

time.strftime(format)¶: 返回一个表示时间的字符串，由显式格式字符串控制。有关格式化指令的完整列表，请参见 strftime() 和 strptime() 行为 .

time.__format__(format)¶: 等同于 time.strftime() . 这使得可以为 time 中的对象 formatted string literals 当使用时 str.format() . 有关格式化指令的完整列表，请参见 strftime() 和 strptime() 行为 .

time.utcoffset()¶: 如果 tzinfo 是 None 回报 None 否则返回 self.tzinfo.utcoffset(None) ，如果后者不返回则引发异常 None 或A timedelta 小于一天的物体。

在 3.7 版更改: UTC偏移量不限于整数分钟。

time.dst()¶: 如果 tzinfo 是 None 回报 None 否则返回 self.tzinfo.dst(None) ，如果后者不返回则引发异常 None ，或者 timedelta 小于一天的物体。

在 3.7 版更改: DST偏移不限于整数分钟。

time.tzname()¶: 如果 tzinfo 是 None 回报 None 否则返回 self.tzinfo.tzname(None) 或者如果后者不返回则引发异常 None 或字符串对象。

用法示例： `time`¶

使用 time 对象：

>>> from datetime import time, tzinfo, timedelta
>>> class TZ1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1)
...     def dst(self, dt):
...         return timedelta(0)
...     def tzname(self,dt):
...         return "+01:00"
...     def  __repr__(self):
...         return f"{self.__class__.__name__}()"
...
>>> t = time(12, 10, 30, tzinfo=TZ1())
>>> t
datetime.time(12, 10, 30, tzinfo=TZ1())
>>> t.isoformat()
'12:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'+01:00'
>>> t.strftime("%H:%M:%S %Z")
'12:10:30 +01:00'
>>> 'The {} is {:%H:%M}.'.format("time", t)
'The time is 12:10.'

`tzinfo` 物体¶

class datetime.tzinfo¶

这是一个抽象基类，意味着不应该直接实例化该类。定义的子类 tzinfo 捕获有关特定时区的信息。

（的具体子类）的实例 tzinfo 无法传递给的构造函数 datetime 和 time 物体。后一个对象将其属性视为本地时间，并且 tzinfo 对象支持显示本地时间与UTC的偏移量、时区名称和DST偏移量的方法，所有这些方法都与传递给它们的日期或时间对象相关。

您需要派生一个具体的子类，并且（至少）提供标准的实现 tzinfo 所需的方法 datetime 你使用的方法。这个 datetime 模块提供 timezone ，一个简单的具体子类 tzinfo 它可以表示与UTC有固定偏移量的时区，例如UTC本身或北美EST和EDT。

酸洗特殊要求：a tzinfo 子类必须具有 __init__() 方法，该方法可以在没有参数的情况下调用，否则可以对其进行pickle操作，但可能不会再次取消对其的pickle操作。这是未来可能放宽的技术要求。

一个具体的子类 tzinfo 可能需要实现以下方法。具体需要哪些方法取决于aware的用途 datetime 物体。如果有疑问，只需全部实施即可。

tzinfo.utcoffset(dt)¶

从UTC返回本地时间的偏移量，作为 timedelta 对象，该对象在UTC以东为正。如果当地时间在UTC以西，则应为负。

这代表 全部的 从UTC偏移；例如，如果 tzinfo 对象表示时区和DST调整， utcoffset() 应该还他们的钱。如果不知道UTC偏移量，则返回 None . 否则返回的值必须是 timedelta 对象严格介于 -timedelta(hours=24) 和 timedelta(hours=24) （偏移量的大小必须小于一天）。大多数实现 utcoffset() 可能看起来像这两个中的一个：

return CONSTANT                 # fixed-offset class
return CONSTANT + self.dst(dt)  # daylight-aware class

如果 utcoffset() 不返 None ， dst() 不应返回 None 要么。

默认实现 utcoffset() 引发 NotImplementedError .

在 3.7 版更改: UTC偏移量不限于整数分钟。

tzinfo.dst(dt)¶

返回夏令时（DST）调整，作为 timedelta 对象或 None 如果不知道DST信息。

返回 timedelta(0) 如果DST无效。如果DST有效，返回偏移量作为 timedelta 对象（参见 utcoffset() 详情请参阅。请注意，DST偏移量（如果适用）已添加到由返回的UTC偏移量中。 utcoffset() 所以不需要咨询 dst() 除非你有兴趣单独获取DST信息。例如， datetime.timetuple() 调用它的 tzinfo 属性的 dst() 方法来确定 tm_isdst 应设置标志，并且 tzinfo.fromutc() 电话 dst() 考虑穿越时区时的DST变化。

一个实例 tz A的 tzinfo 标准和夏令时模型的子类在此意义上必须一致：

tz.utcoffset(dt) - tz.dst(dt)

must return the same result for every datetime dt with dt.tzinfo == tz For sane tzinfo subclasses, this expression yields the time zone's "standard offset", which should not depend on the date or the time, but only on geographic location. The implementation of datetime.astimezone() relies on this, but cannot detect violations; it's the programmer's responsibility to ensure it. If a tzinfo subclass cannot guarantee this, it may be able to override the default implementation of tzinfo.fromutc() to work correctly with astimezone() regardless.

大多数实现 dst() 可能看起来像这两个中的一个：

def dst(self, dt):
    # a fixed-offset class:  doesn't account for DST
    return timedelta(0)

或：

def dst(self, dt):
    # Code to set dston and dstoff to the time zone's DST
    # transition times based on the input dt.year, and expressed
    # in standard local time.

    if dston <= dt.replace(tzinfo=None) < dstoff:
        return timedelta(hours=1)
    else:
        return timedelta(0)

默认实现 dst() 引发 NotImplementedError .

在 3.7 版更改: DST偏移不限于整数分钟。

tzinfo.tzname(dt)¶

返回与 datetime 对象 dt ，作为字符串。字符串名称的定义 datetime 模块，不要求它有任何特别的含义。例如，“GMT”、“UTC”、“500”、“5:00”、“EDT”、“美国/东方”、“美国/纽约”都是有效的答复。返回 None 如果字符串名未知。注意，这是一个方法，而不是一个固定字符串，主要是因为 tzinfo 子类希望返回不同的名称，具体取决于 dt 通过，特别是如果 tzinfo 上课是计算夏令时的。

默认实现 tzname() 引发 NotImplementedError .

这些方法由 datetime 或 time 对象，以响应其同名方法。一个 datetime 对象将自身作为参数传递，并且 time 物体通过 None 作为论据。一个 tzinfo 因此，子类的方法应该准备接受 dt 的参数 None 或类 datetime .

什么时候？ None 如果通过，则由类设计器决定最佳响应。例如，返回 None 如果类希望说时间对象不参与 tzinfo 协议。它可能对 utcoffset(None) 返回标准的UTC偏移量，因为没有发现标准偏移量的其他约定。

当A datetime 对象作为响应传递给 datetime 方法， dt.tzinfo 与相同的对象 self . tzinfo 方法可以依赖于此，除非用户代码调用 tzinfo 方法直接。其目的是 tzinfo 方法解释 dt 因为是在当地时间，不需要担心其他时区的对象。

还有一个 tzinfo 子类可能希望重写的方法：

tzinfo.fromutc(dt)¶

这是从默认值调用的 datetime.astimezone() 实施。从那打来的时候， dt.tzinfo 是 self 和 dt 的日期和时间数据将被视为表示UTC时间。目的 fromutc() 是调整日期和时间数据，返回 self 当地时间。

大多数 tzinfo 子类应该能够继承默认值 fromutc() 执行无问题。它足够强大，可以处理固定偏移时区，时区同时包含标准时间和夏令时，后者即使DST转换时间在不同年份有所不同。时区的示例默认值 fromutc() 在所有情况下，执行可能无法正确处理，因为标准偏差（从UTC）取决于经过的特定日期和时间，这可能是出于政治原因。的默认实现 astimezone() 和 fromutc() 如果结果是跨越标准偏移量更改时刻的某个小时，则可能不会生成所需的结果。

跳过错误情况的代码，默认 fromutc() 实施方式如下：

def fromutc(self, dt):
    # raise ValueError error if dt.tzinfo is not self
    dtoff = dt.utcoffset()
    dtdst = dt.dst()
    # raise ValueError if dtoff is None or dtdst is None
    delta = dtoff - dtdst  # this is self's standard offset
    if delta:
        dt += delta   # convert to standard local time
        dtdst = dt.dst()
        # raise ValueError if dtdst is None
    if dtdst:
        return dt + dtdst
    else:
        return dt

在下面 tzinfo_examples.py 文件有一些例子 tzinfo 类别：

from datetime import tzinfo, timedelta, datetime

ZERO = timedelta(0)
HOUR = timedelta(hours=1)
SECOND = timedelta(seconds=1)

# A class capturing the platform's idea of local time.
# (May result in wrong values on historical times in
#  timezones where UTC offset and/or the DST rules had
#  changed in the past.)
import time as _time

STDOFFSET = timedelta(seconds = -_time.timezone)
if _time.daylight:
    DSTOFFSET = timedelta(seconds = -_time.altzone)
else:
    DSTOFFSET = STDOFFSET

DSTDIFF = DSTOFFSET - STDOFFSET

class LocalTimezone(tzinfo):

    def fromutc(self, dt):
        assert dt.tzinfo is self
        stamp = (dt - datetime(1970, 1, 1, tzinfo=self)) // SECOND
        args = _time.localtime(stamp)[:6]
        dst_diff = DSTDIFF // SECOND
        # Detect fold
        fold = (args == _time.localtime(stamp - dst_diff))
        return datetime(*args, microsecond=dt.microsecond,
                        tzinfo=self, fold=fold)

    def utcoffset(self, dt):
        if self._isdst(dt):
            return DSTOFFSET
        else:
            return STDOFFSET

    def dst(self, dt):
        if self._isdst(dt):
            return DSTDIFF
        else:
            return ZERO

    def tzname(self, dt):
        return _time.tzname[self._isdst(dt)]

    def _isdst(self, dt):
        tt = (dt.year, dt.month, dt.day,
              dt.hour, dt.minute, dt.second,
              dt.weekday(), 0, 0)
        stamp = _time.mktime(tt)
        tt = _time.localtime(stamp)
        return tt.tm_isdst > 0

Local = LocalTimezone()


# A complete implementation of current DST rules for major US time zones.

def first_sunday_on_or_after(dt):
    days_to_go = 6 - dt.weekday()
    if days_to_go:
        dt += timedelta(days_to_go)
    return dt


# US DST Rules
#
# This is a simplified (i.e., wrong for a few cases) set of rules for US
# DST start and end times. For a complete and up-to-date set of DST rules
# and timezone definitions, visit the Olson Database (or try pytz):
# http://www.twinsun.com/tz/tz-link.htm
# http://sourceforge.net/projects/pytz/ (might not be up-to-date)
#
# In the US, since 2007, DST starts at 2am (standard time) on the second
# Sunday in March, which is the first Sunday on or after Mar 8.
DSTSTART_2007 = datetime(1, 3, 8, 2)
# and ends at 2am (DST time) on the first Sunday of Nov.
DSTEND_2007 = datetime(1, 11, 1, 2)
# From 1987 to 2006, DST used to start at 2am (standard time) on the first
# Sunday in April and to end at 2am (DST time) on the last
# Sunday of October, which is the first Sunday on or after Oct 25.
DSTSTART_1987_2006 = datetime(1, 4, 1, 2)
DSTEND_1987_2006 = datetime(1, 10, 25, 2)
# From 1967 to 1986, DST used to start at 2am (standard time) on the last
# Sunday in April (the one on or after April 24) and to end at 2am (DST time)
# on the last Sunday of October, which is the first Sunday
# on or after Oct 25.
DSTSTART_1967_1986 = datetime(1, 4, 24, 2)
DSTEND_1967_1986 = DSTEND_1987_2006

def us_dst_range(year):
    # Find start and end times for US DST. For years before 1967, return
    # start = end for no DST.
    if 2006 < year:
        dststart, dstend = DSTSTART_2007, DSTEND_2007
    elif 1986 < year < 2007:
        dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
    elif 1966 < year < 1987:
        dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
    else:
        return (datetime(year, 1, 1), ) * 2

    start = first_sunday_on_or_after(dststart.replace(year=year))
    end = first_sunday_on_or_after(dstend.replace(year=year))
    return start, end


class USTimeZone(tzinfo):

    def __init__(self, hours, reprname, stdname, dstname):
        self.stdoffset = timedelta(hours=hours)
        self.reprname = reprname
        self.stdname = stdname
        self.dstname = dstname

    def __repr__(self):
        return self.reprname

    def tzname(self, dt):
        if self.dst(dt):
            return self.dstname
        else:
            return self.stdname

    def utcoffset(self, dt):
        return self.stdoffset + self.dst(dt)

    def dst(self, dt):
        if dt is None or dt.tzinfo is None:
            # An exception may be sensible here, in one or both cases.
            # It depends on how you want to treat them.  The default
            # fromutc() implementation (called by the default astimezone()
            # implementation) passes a datetime with dt.tzinfo is self.
            return ZERO
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        # Can't compare naive to aware objects, so strip the timezone from
        # dt first.
        dt = dt.replace(tzinfo=None)
        if start + HOUR <= dt < end - HOUR:
            # DST is in effect.
            return HOUR
        if end - HOUR <= dt < end:
            # Fold (an ambiguous hour): use dt.fold to disambiguate.
            return ZERO if dt.fold else HOUR
        if start <= dt < start + HOUR:
            # Gap (a non-existent hour): reverse the fold rule.
            return HOUR if dt.fold else ZERO
        # DST is off.
        return ZERO

    def fromutc(self, dt):
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        start = start.replace(tzinfo=self)
        end = end.replace(tzinfo=self)
        std_time = dt + self.stdoffset
        dst_time = std_time + HOUR
        if end <= dst_time < end + HOUR:
            # Repeated hour
            return std_time.replace(fold=1)
        if std_time < start or dst_time >= end:
            # Standard time
            return std_time
        if start <= std_time < end - HOUR:
            # Daylight saving time
            return dst_time


Eastern  = USTimeZone(-5, "Eastern",  "EST", "EDT")
Central  = USTimeZone(-6, "Central",  "CST", "CDT")
Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")
Pacific  = USTimeZone(-8, "Pacific",  "PST", "PDT")

请注意，在 tzinfo 在DST转换点同时考虑标准时间和夏令时的子类。具体来说，考虑美国东部时间（UTC-0500），东部时间从3月第二个星期天的1:59（东部标准时间）后开始，到11月第一个星期天的1:59（东部标准时间）后结束：

  UTC   3:MM  4:MM  5:MM  6:MM  7:MM  8:MM
  EST  22:MM 23:MM  0:MM  1:MM  2:MM  3:MM
  EDT  23:MM  0:MM  1:MM  2:MM  3:MM  4:MM

start  22:MM 23:MM  0:MM  1:MM  3:MM  4:MM

  end  23:MM  0:MM  1:MM  1:MM  2:MM  3:MM

当DST开始时（即“开始”线），本地挂钟从1:59跳到3:00。2:MM的墙时间在那一天没有意义，所以 astimezone(Eastern) 无法提供结果 hour == 2 在夏令时开始的那天。例如，在2016年的春季过渡期，我们得到：

>>> from datetime import datetime, timezone
>>> from tzinfo_examples import HOUR, Eastern
>>> u0 = datetime(2016, 3, 13, 5, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname())
...
05:00:00 UTC = 00:00:00 EST
06:00:00 UTC = 01:00:00 EST
07:00:00 UTC = 03:00:00 EDT
08:00:00 UTC = 04:00:00 EDT

当DST结束时（即“结束”线），有一个潜在的更糟的问题：有一个小时不能在本地墙时间中明确拼写：夏时制的最后一个小时。在东部，这是夏令时结束当天5:MM UTC的时间。当地的挂钟又从1:59（夏令时）跳回1:00（标准时间）。1:MM格式的本地时间不明确。 astimezone() 通过将两个相邻的UTC小时映射到同一个本地小时来模拟本地时钟的行为。在东部示例中，格式为5:MM和6:MM的UTC时间在转换为东部时都映射为1:MM，但早期的时间具有 fold 属性设置为0，以后的时间将其设置为1。例如，在2016年的倒退过渡期，我们得到：

>>> u0 = datetime(2016, 11, 6, 4, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)
...
04:00:00 UTC = 00:00:00 EDT 0
05:00:00 UTC = 01:00:00 EDT 0
06:00:00 UTC = 01:00:00 EST 1
07:00:00 UTC = 02:00:00 EST 0

请注意 datetime 只因 fold 在比较中，属性被认为是相等的。

不能承受墙时间模糊的应用程序应该显式检查 fold 属性或避免使用混合 tzinfo 子类；使用时没有歧义 timezone 或任何其他固定偏移 tzinfo 子类（例如仅表示EST（固定偏移-5小时）的类，或仅表示EDT（固定偏移-4小时））。

参见

dateutil.tz

这个 datetime 模块有一个基本的 timezone 类（用于处理来自UTC的任意固定偏移量）及其 timezone.utc 属性（UTC时区实例）。

dateutil.tz 类库带来了 IANA时区数据库 （也称为Olson数据库）到Python，并推荐使用它。

IANA timezone database

时区数据库（通常称为TZ、TZDATA或ZoneInfo）包含代码和数据，这些代码和数据表示全球许多具有代表性的位置的本地时间历史。它会定期更新，以反映政治机构对时区边界、UTC偏移量和夏令时规则所做的更改。

`timezone` 物体¶

这个 timezone 类是的子类 tzinfo ，每个实例表示由与UTC的固定偏移量定义的时区。

此类的对象不能用于表示一年中不同日期使用不同偏移量的位置或对民用时间进行历史更改的位置的时区信息。

class datetime.timezone(offset, name=None)¶

这个抵消参数必须指定为 timedelta 对象，表示本地时间和UTC之间的差异。必须严格地介于 -timedelta(hours=24) 和 timedelta(hours=24) ，否则 ValueError 提高了。

这个 name 参数是可选的。如果指定，则必须是一个字符串，该字符串将用作 datetime.tzname() 方法。

3.2 新版功能.

在 3.7 版更改: UTC偏移量不限于整数分钟。

timezone.utcoffset(dt)¶

返回指定的固定值 timezone 实例已构造。

这个 dt 参数被忽略。返回值是 timedelta 实例等于本地时间和UTC之间的差异。

在 3.7 版更改: UTC偏移量不限于整数分钟。

timezone.tzname(dt)¶

返回指定的固定值 timezone 实例已构造。

如果 name 未在构造函数中提供，返回的名称 tzname(dt) 是从 offset 如下所示。如果抵消是 timedelta(0) ，名称是“UTC”，否则是格式为 UTC±HH:MM ，其中±是 offset ，hh和mm是 offset.hours 和 offset.minutes 分别。

在 3.6 版更改: 从生成的名称 offset=timedelta(0) 现在很清楚了 'UTC' 不是 'UTC+00:00' .

timezone.dst(dt)¶: 总是回报 None .

timezone.fromutc(dt)¶: 返回 dt + offset . 这个 dt 参数必须是已知的 datetime 实例，使用 tzinfo 设置为 self .

类属性：

timezone.utc¶: UTC时区， timezone(timedelta(0)) .

`strftime()` 和 `strptime()` 行为¶

date ， datetime 和 time 对象都支持 strftime(format) 方法，以创建表示在显式格式字符串控制下的时间的字符串。

相反， datetime.strptime() 类方法创建 datetime 对象，该对象来自表示日期和时间以及相应格式字符串的字符串。

下表提供了 strftime() 对战 strptime() ：

	`strftime`	`strptime`
使用	根据给定格式将对象转换为字符串	将字符串解析为 `datetime` 对象给定相应的格式
方法类型	实例方法	类方法
方法	`date`; `datetime`; `time`	`datetime`
签名	`strftime(format)`	`strptime(date_string, format)`

`strftime()` 和 `strptime()` 格式代码¶

下面是1989 C标准所需的所有格式代码的列表，这些代码适用于具有标准C实现的所有平台。

指令	意义	例子	笔记
`%a`	工作日作为区域设置的缩写名称。	太阳，周一，…，周六（美国）所以，莫，…，萨（德）	(1)
`%A`	工作日作为区域设置的全名。	星期日，星期一，…，星期六（美国） Sonntag，Montag，…，Samstag（de_de）	(1)
`%w`	工作日为十进制数，其中0表示星期日，6表示星期六。	0，1，…，6
`%d`	以零填充的十进制数字表示的月份日期。	01, 02，…，31	(9)
`%b`	月份作为区域设置的缩写名称。	一月、二月、十二月（美国）一月，二月，…，德州	(1)
`%B`	月份作为区域设置的全名。	一月，二月，…，十二月（美国） Januar，Februar，…，Dezember（de_de）	(1)
`%m`	以零填充的十进制数表示的月份。	01, 02，…，12	(9)
`%y`	没有世纪的年份作为零填充十进制数。	00, 01，…，99	(9)
`%Y`	以世纪为十进制数的年份。	0001，0002，…，2013，2014，…，9998，9999	(2)
`%H`	小时（24小时制）为零填充十进制数。	00, 01，…，23	(9)
`%I`	小时（12小时时钟）作为零填充的十进制数。	01, 02，…，12	(9)
`%p`	区域设置相当于AM或PM。	AM，PM（EnthUS）； AM，PM（DEEDE）	(1), (3)
`%M`	分钟作为零填充的十进制数。	00, 01，…，59	(9)
`%S`	第二个是零填充的十进制数。	00, 01，…，59	（4），（9）
`%f`	微秒为十进制数，左边加零。	000000，000001，…，999999	(5)
`%z`	表格中的UTC偏移量 `±HHMM[SS[.ffffff]]` （如果对象是纯对象，则为空字符串）。	(empty), +0000, -0400, +1030, +063415, -030712.345216	(6)
`%Z`	时区名称（如果对象是幼稚的，则为空字符串）。	（空），UTC，GMT	(6)
`%j`	以零填充的十进制数字表示的一年中的某一天。	001，002，…，366年	(9)
`%U`	一年中的周数（星期日为一周的第一天）作为零填充的十进制数。新的一年中第一个星期日之前的所有天都被认为是在第0周。	00, 01，…，53	（7），（9）
`%W`	一年中的第几周（星期一为一周的第一天）作为十进制数。新年第一个星期一之前的所有日子都被认为是在第0周。	00, 01，…，53	（7），（9）
`%c`	区域设置的适当日期和时间表示。	1988年8月16日星期二21:30:00（美国） DI 1988年8月16日21:30:00（de_de）	(1)
`%x`	区域设置的适当日期表示。	08/16/88 (None); 08/16/1988 (en_US); 1988年8月16日	(1)
`%X`	区域设置的适当时间表示。	21:30:00（美国） 21:30:00（德鲁）	(1)
`%%`	文字的 `'%'` 性格。	%

为了方便起见，还包括了一些C89标准不要求的附加指令。这些参数都对应于ISO 8601日期值。

指令	意义	例子	笔记
`%G`	ISO 8601年，其中“世纪”表示包含ISO周大部分内容的年份。 (`%V` ）	0001，0002，…，2013，2014，…，9998，9999	(8)
`%u`	ISO 8601工作日为十进制数字，其中1表示星期一。	1, 2，…，7
`%V`	ISO 8601周为十进制数，星期一为一周的第一天。第一周是包含1月4日的一周。	01，02，…，53岁	（8），（9）

当与 strftime() 方法。ISO 8601年和ISO 8601周指令不能与上述年和周数指令互换。打电话 strptime() 如果ISO 8601指令不完整或不明确，将引发 ValueError .

由于python调用平台c库的 strftime() 功能和平台的变化是常见的。要查看平台上支持的全套格式代码，请参阅 strftime(3) 文档。

3.6 新版功能: %G ， %u 和 %V 加入。

技术细节¶

广义上讲， d.strftime(fmt) 行为像 time 模块的 time.strftime(fmt, d.timetuple()) 虽然并非所有对象都支持 timetuple() 方法。

对于 datetime.strptime() 类方法，默认值为 1900-01-01T00:00:00.000 ：格式字符串中未指定的任何组件都将从默认值中提取。 4

使用 datetime.strptime(date_string, format) 等于：

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

除非格式包含子秒组件或时区偏移信息，这些信息在 datetime.strptime 但是被抛弃了 time.strptime .

为了 time 对象，不应使用年、月和日的格式代码，因为 time 对象没有这样的值。如果它们被使用， 1900 替换为年份，以及 1 一个月一天。

为了 date 对象，格式代码（小时、分钟、秒和微秒）不应用作 date 对象没有这样的值。如果它们被使用， 0 代替它们。

出于同样的原因，处理包含当前区域设置的字符集中无法表示的Unicode代码点的格式字符串也依赖于平台。在某些平台上，这些代码点在输出中保持不变，而在其他平台上则保持不变。 strftime 可以提高 UnicodeError 或者返回空字符串。

笔记：

因为格式取决于当前的区域设置，所以在对输出值进行假设时应该小心。字段顺序将有所不同（例如，“月/日/年”与“日/月/年”），并且输出可能包含使用区域设置的默认编码编码的Unicode字符（例如，如果当前区域设置为 ja_JP ，默认编码可以是 eucJP ， SJIS 或 utf-8 使用 locale.getlocale() 以确定当前区域设置的编码）。
这个 strptime() 方法可以完整分析年份 [1, 9999] 范围，但小于1000年的年份必须为零，填充宽度为4位数。

在 3.2 版更改: 在以前的版本中， strftime() 方法仅限于1900年以上的年份。

在 3.3 版更改: 在版本3.2中， strftime() 方法仅限于大于等于1000年。
当与 strptime() 方法 %p 指令只影响输出小时字段，如果 %I 指令用于分析小时。
不像 time 模块 datetime 模块不支持闰秒。
当与 strptime() 方法 %f 指令接受从1到6位数字和右边的零填充。 %f 是C标准中格式字符集的扩展（但在datetime对象中单独实现，因此始终可用）。
对于一个天真的对象， %z 和 %Z 格式代码由空字符串替换。

对于感知对象：

%z
utcoffset() 被转换成字符串的形式 ±HHMM[SS[.ffffff]] 在哪里 HH 是一个2位数的字符串，表示UTC偏移小时数， MM 是一个2位数的字符串，表示UTC偏移分钟数， SS 是一个2位字符串，给出UTC偏移秒数和 ffffff 是一个6位字符串，给出UTC偏移微秒数。这个 ffffff 当偏移量为整数秒且 ffffff 以及 SS 当偏移量为整数分钟时，忽略部分。例如，如果 utcoffset() 收益率 timedelta(hours=-3, minutes=-30) ， %z 替换为字符串 '-0330' .

在 3.7 版更改: UTC偏移量不限于整数分钟。

在 3.7 版更改: 当 %z 指令提供给 strptime() 方法，UTC偏移量可以使用冒号作为小时、分钟和秒之间的分隔符。例如， '+01:00:00' 将被解析为一小时的偏移量。此外，提供 'Z' 相同 '+00:00' .
%Z
在 strftime() ， %Z 替换为空字符串，如果 tzname() 收益率 None 否则 %Z 替换为返回值，该值必须是字符串。

strptime() 只接受某些值 %Z ：
1. 任何价值 time.tzname 对于您机器的区域设置
2. 硬编码值 UTC 和 GMT
所以住在日本的人可能 JST ， UTC 和 GMT 作为有效值，但可能不是 EST . 它会提高 ValueError 对于无效值。
在 3.2 版更改: 当 %z 指令提供给 strptime() 方法，一种意识 datetime 将生成对象。这个 tzinfo 结果将设置为 timezone 实例。
当与 strptime() 方法， %U 和 %W 仅用于计算星期几和日历年 (%Y ）已指定。
类似 %U 和 %W ， %V 仅在星期几和ISO年时用于计算 (%G ）在a中指定 strptime() 格式化字符串。还要注意 %G 和 %Y 不能互换。
当与 strptime() 方法，前导零对于格式是可选的 %d ， %m ， %H ， %I ， %M ， %S ， %J ， %U ， %W 和 %V . 格式 %y 需要前导零。

脚注

1: 如果，也就是说，我们忽略了相对论的影响
2: 这与德肖维茨和雷戈尔德的书中对“先兆公历”的定义相吻合 历法计算 ，它是所有计算的基准日历。请参阅这本书，了解用于在不可接受的格里高利序数和许多其他日历系统之间转换的算法。
3: 见R.H.van Gent's guide to the mathematics of the ISO 8601 calendar 为了一个好的解释。
4: 经过 datetime.strptime('Feb 29', '%b %d') 将失败，因为 1900 不是闰年。

`datetime` ---基本日期和时间类型¶

有意识和天真的物体¶

常量¶

可用类型¶

共同财产¶

确定一个对象是感知的还是天真的¶

`timedelta` 物体¶

用法示例： `timedelta`¶

`date` 物体¶

用法示例： `date`¶

`datetime` 物体¶

用法示例： `datetime`¶

`time` 物体¶

用法示例： `time`¶

`tzinfo` 物体¶

`timezone` 物体¶

`strftime()` 和 `strptime()` 行为¶

`strftime()` 和 `strptime()` 格式代码¶

技术细节¶

Table of Contents

上一个主题

下一个主题

datetime ---基本日期和时间类型¶

有意识和天真的物体¶

常量¶

可用类型¶

共同财产¶

确定一个对象是感知的还是天真的¶

timedelta 物体¶

用法示例： timedelta¶

date 物体¶

用法示例： date¶

datetime 物体¶

用法示例： datetime¶

time 物体¶

用法示例： time¶

tzinfo 物体¶

timezone 物体¶

strftime() 和 strptime() 行为¶

strftime() 和 strptime() 格式代码¶

技术细节¶

`datetime` ---基本日期和时间类型¶

`timedelta` 物体¶

用法示例： `timedelta`¶

`date` 物体¶

用法示例： `date`¶

`datetime` 物体¶

用法示例： `datetime`¶

`time` 物体¶

用法示例： `time`¶

`tzinfo` 物体¶

`timezone` 物体¶

`strftime()` 和 `strptime()` 行为¶

`strftime()` 和 `strptime()` 格式代码¶