datetime

2.3版本的新功能。

该datetime模块提供简单和复杂的操作日期和时间的类。在支持日期和时间算法的同时，实现的重点是对输出格式和操作进行有效的属性提取。有关相关功能，另请参阅time和calendar模块。

有两种日期和时间对象：“native”和“aware”。

知道的对象具有足够的适用算法和政治时间调整的知识，例如时区和夏令时信息，以相对于其他感知对象进行定位。意识对象用于表示一个不能解释的特定时刻[1]。

天真的对象不包含足够的信息来明确地定位其相对于其他日期/时间对象的本身。无论天真的对象代表协调世界时（UTC），当地时间还是某个其他时区的时间，都完全取决于该计划，就像计划是否代表米，英里或质量一样。天真的对象很容易理解和使用，代价是无视现实的某些方面。

对于需要了解对象的应用程序，datetime以及time对象有一个可选的时区信息属性tzinfo，可以被设置为抽象的子类的实例tzinfo类。这些tzinfo对象捕获有关UTC时间偏移的信息，时区名称以及夏令时是否生效。请注意，模块不提供具体的tzinfo类datetime。支持任何细节级别的时区都取决于应用程序。全球时间调整的规则比理性更具政治性，没有适合每种应用的标准。

该datetime模块导出以下常量：

datetime.MINYEAR

date或datetimeobject中允许的最小年份数。MINYEAR是1。

datetime.MAXYEAR

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

1.可用的类型

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课程用于提供时间调整的可定制概念（例如，考虑时区和/或夏令时）。

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

date类型的对象总是天真的。

类型的对象time或datetime可能天真或意识。一个datetime对象d意识到，如果d.tzinfo不None和d.tzinfo.utcoffset(d)不返回None。如果d.tzinfo是None，或者如果d.tzinfo不是，None但是d.tzinfo.utcoffset(d)回报None，d是天真的。一个time对象牛逼意识到，如果t.tzinfo不None和t.tzinfo.utcoffset(None)不返回None。否则，t是天真的。

native与aware之间的区别不适用于timedelta对象。

子类关系：

object
    timedelta
    tzinfo
    time
    date
        datetime

2.小​​时对象

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

class datetime.timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])

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

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

• 毫秒转换为1000微秒。

• 一分钟转换为60秒。

• 一小时转换为3600秒。

• 一周转换为7天。

然后对days，秒和微秒进行归一化，以便该表示是唯一的

• 0 <= microseconds < 1000000

• 0 <= seconds < 3600*24 （一天中的秒数）

• -999999999 <= days <= 999999999

如果任何参数是浮点数并且有分数微秒，则将所有参数剩下的小数微秒合并，并将其总和四舍五入为最接近的微秒。如果没有参数是浮点数，则转换和规范化过程是精确的（不会丢失任何信息）。

如果标准化天数在指定范围之外，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对象。

实例属性（只读）：

属性	值
天	介于-999999999和999999999之间
秒	介于0和86399之间
微秒	介于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）
t1 = t2 * i或t1 = i * t2	Delta乘以整数或长整数。之后t1 //我== t2是真的，只要我！= 0。
​	一般来说，t1 * i == t1 *（i-1）+ t1是真的。（1）
t1 = t2 // i	计算地板的余量（如果有的话）被扔掉。（3）
+ T1	返回具有相同值的timedelta对象。（2）
-T1	相当于timedelta（-t1.days，-t1.seconds，-t1.microseconds）和t1 * -1。（1）（4）
ABS（t）的	相当于当t.days> = 0时的+ t，当t.days <0时相当于-t。（2）
STR（t）的	以D day [s]，H：MM：SS.UUUUUU的形式返回一个字符串，其中D对于负t是负的。（5）
再版（t）的	以datetime.timedelta（D [，S，U]）形式返回一个字符串，其中D对于负值t为负数。（5）

注释：

• 这是确切的，但可能会溢出。

• 这是确切的，不能溢出。

• 由0加分ZeroDivisionError。

• - timedelta.max不能表示为一个timedelta对象。

• timedelta对象的字符串表示与其内部表示相似。这导致负面timedeltas有点不寻常的结果。例如：

小时（小时= -5）datetime.timedelta（-1，68400）>>> print（_）-1 day，19:00:00

除了上面列出的操作之外，timedelta对象还支持使用date和datetime对象进行某些增加和减少操作（请参见下文）。

表示更小时间间隔的timedelta对象支持比较对象timedelta。为了阻止混合类型的比较回落到按对象地址进行默认比较，当一个timedelta对象与不同类型的对象进行TypeError比较时，除非比较结果为==或，否则将引发该混合类型比较!=。后面的情况分别返回False或True。

timedelta对象是可散列的（可用作字典键），支持高效的酸洗，并且在布尔上下文中，timedelta当且仅当它不等于时，才认为对象为真timedelta(0)。

实例方法：

timedelta.total_seconds()

返回持续时间中包含的总秒数。相当于(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6启用真分区时计算的值。

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

2.7版本的新功能。

用法示例：

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

3.日期对象

一个date对象代表一个理想化的日历日期（年，月，日），当前的公历无限期延长两个方向。第1年的1月1日被称为第1日，第1年的1月2日被称为第2日，依此类推。这与Dershowitz和Reingold的书Calendrical Calculations中的“预测格里历”日历的定义相匹配，它是所有计算的基本日历。请参阅本书，了解在格雷戈里公会和许多其他日历系统之间进行转换的算法。

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()。ValueError如果时间戳超出平台C localtime()函数支持的值范围，则可能会引发此问题。从1970年到2038年这种情况通常会受到限制。请注意，在非POSIX系统中，在其时间戳概念中包含闰秒时，闰秒会被忽略fromtimestamp()。

classmethod date.fromordinal(ordinal)

返回对应于格雷高尔顺序的日期，第一年的1月1日有顺序1. ValueError除非是1 <= ordinal <= date.max.toordinal()。对于任何日期d，date.fromordinal(d.toordinal()) == d。

类属性：

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和给定年的给定月份中的天数之间。

支持的操作：

Operation	结果
date2 = date1 +小时	date2是从date1中删除的timedelta.days天。（1）
date2 = date1 - 每小时	计算date2，使date2 + timedelta == date1。（2）
timedelta = date1 - date2	(3)
date1 <date2	当date1在date2之前及时时，date1被认为小于date2。（4）

注释：

• date2在时间上向前移动if timedelta.days > 0或向后移动if timedelta.days < 0。之后date2 - date1 == timedelta.days。timedelta.seconds并被timedelta.microseconds忽略。OverflowError如果date2.year小于MINYEAR或大于，则提高MAXYEAR。

• 这与date1 +（-timedelta）不完全等价，因为在date1 - timedelta没有的情况下，-timedelta在隔离时可能会溢出。timedelta.seconds并被timedelta.microseconds忽略。

• 这是确切的，不能溢出。timedelta.seconds和timedelta.microseconds是0，而date2 + timedelta == date1之后。

• 换句话说，date1 < date2当且仅当date1.toordinal() < date2.toordinal()。为了阻止比较从回落到比较对象地址的默认方案，TypeError如果另一个比较不是对象，日期比较通常会引发date。但是，NotImplemented如果其他比较具有timetuple()属性，则返回。这个钩子为其他类型的日期对象提供了一个实现混合类型比较的机会。如果没有，则将date对象与不同类型的对象进行TypeError比较时，除非比较为==或，否则将引发该对象!=。后面的情况分别返回False或True。

日期可以用作字典键。在布尔上下文中，所有date对象都被认为是真的。

实例方法：

date.replace(year, month, day)

使用相同的值返回一个日期，除了那些由指定的关键字参数给定新值的参数。例如，如果d == date(2002, 12, 31)，那么d.replace(day=26) == date(2002, 12, 26)。

date.timetuple()

返回一个time.struct_time如返回的time.localtime()。小时，分钟和秒为0，DST标志为-1。d.timetuple()相当于今年1月1 日开始的当天数字在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() + 11

date.toordinal()

返回日期，其中1月1日1年的有序1.对于任何的proleptic阳历序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()

返回3元组（ISO年，ISO周编号，ISO工作日）。

ISO日历是格里高利日历的一个广泛使用的变体。请参阅https://www.staff.science.uu.nl/~gent0113/calendar/isocalendar.htm以获取更好的解释。

ISO年度包括52周或53周，以及周一开始于周一至周日结束。ISO年的第一周是包含一个星期四的第一个（格里高利）历年。这称为第1周，该星期四的ISO年与公历年相同。

例如，2004年开始在星期四，因此2004年ISO年份的第一周开始于星期一，2003 12月29日，周日结束，2004年1月4日，让date(2003, 12, 29).isocalendar() == (2004, 1, 1)和date(2004, 1, 4).isocalendar() == (2004, 1, 7)。

date.isoformat()

以ISO 8601格式返回表示日期的字符串'YYYY-MM-DD'。例如，date(2002, 12, 4).isoformat() == '2002-12-04'。

date.__str__()

对于日期d而言，str(d)相当于d.isoformat()。

date.ctime()

例如，返回表示日期的字符串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在使用时为对象指定格式字符串成为可能str.format()。请参见strftime（）和strptime（）行为一节。

计算事件日期的示例：

>>> 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)
>>> 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 )
>>> d.isoformat()
'2002-03-11'
>>> d.strftime("%d/%m/%y")
'11/03/02'
>>> d.strftime("%A %d. %B %Y")
'Monday 11. March 2002'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 11, the month is March.'

4. datetime对象

datetime对象是包含来自所有信息的单个对象date的对象和time对象。就像一个date物体一样，datetime假定当前的格里历日历在两个方向上延伸; 像时间对象一样，datetime假设每天都有3600 * 24秒。

构造函数：

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

年，月和日的参数是必需的。tzinfo可能是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

如果超出这些范围的论点ValueError被提出。

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

classmethod datetime.today()

返回当前本地日期时间tzinfo None。这相当于datetime.fromtimestamp(time.time())。另见now()，fromtimestamp()。

classmethod datetime.now([tz])

返回当前的本地日期和时间。如果可选参数tz是None或未指定，则类似于此today()，但如果可能，提供的精度比通过time.time()时间戳记所获得的精度要高（例如，在提供C gettimeofday()函数的平台上可能会这样做）。

如果tz不是None，它必须是一个tzinfo子类的实例，并且当前的日期和时间被转换为tz的时区。在这种情况下，结果等同于tz.fromutc(datetime.utcnow().replace(tzinfo=tz))。另见today()，utcnow()。

classmethod datetime.utcnow()

返回当前的UTC日期和时间tzinfo None。这就像是now()，但返回当前的UTC日期和时间，作为一个天真的datetime对象。另见now()。

classmethod datetime.fromtimestamp(timestamp[, tz])

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

如果tz不是None，它必须是一个tzinfo子类的实例，并且时间戳被转换为tz的时区。在这种情况下，结果等同于tz.fromutc(datetime.utcfromtimestamp(timestamp).replace(tzinfo=tz))。

fromtimestamp()ValueError如果时间戳超出平台C localtime()或gmtime()函数所支持的值范围，则可能会引发。在1970年到2038年这种情况通常会受到限制。请注意，在非POSIX系统中，在其时间戳概念中包含闰秒时，闰秒会被忽略fromtimestamp()，然后可能会有两个时间戳相差一秒产生相同的datetime物体。另见utcfromtimestamp()。

classmethod datetime.utcfromtimestamp(timestamp)

返回与datetimePOSIX时间戳相对应的UTC tzinfo None。ValueError如果时间戳超出平台C gmtime()函数支持的值范围，则可能会引发此问题。1970年到2038年这种情况通常会受到限制。另请参见fromtimestamp()。

classmethod datetime.fromordinal(ordinal)

返回datetime相应的格雷戈里顺序，第一年的1月1日有顺序1. ValueError除非1 <= ordinal <= datetime.max.toordinal()。结果的小时，分​​钟，秒和微秒全部为0，并且tzinfo是None。

classmethod datetime.combine(date, time)

返回一个新的datetime对象，其日期分量等于给定的date对象，并且其时间分量和tzinfo属性等于给定的time对象。对于任何datetime对象d，d == datetime.combine(d.date(), d.timetz())。如果date是一个datetime对象，它的时间组件和tzinfo属性将被忽略。

classmethod datetime.strptime(date_string, format)

返回一个datetime对应的date_string，根据格式进行解析。这相当于datetime(*(time.strptime(date_string, format)[0:6]))。ValueError如果date_string和format不能被解析，time.strptime()或者它返回的值不是时间元组，则会引发该错误。有关格式化指令的完整列表，请参见strftime（）和strptime（）行为一节。

2.5版本中的新功能。

类属性：

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和给定年的给定月份中的天数之间。

datetime.hour

In range(24).

datetime.minute

In range(60).

datetime.second

In range(60).

datetime.microsecond

In range(1000000).

datetime.tzinfo

该对象作为tzinfo参数传递给datetime构造函数，或者None如果没有传递。

支持的操作：

Operation	结果
datetime2 = datetime1 + timedelta	(1)
datetime2 = datetime1 - timedelta	(2)
timedelta = datetime1 - datetime2	(3)
datetime1 <datetime2	将日期时间与日期时间进行比较。（4）

• datetime2是从datetime1中删除的timedelta的持续时间，如果timedelta.days> 0 则向前移动，如果timedelta.days<0则向后移动。结果tzinfo与输入日期时间具有相同的属性，而datetime2 - datetime1 == timedelta之后。OverflowError如果datetime2.year将小于MINYEAR或大于，则会提高MAXYEAR。请注意，即使输入是感知对象，也不会进行时区调整。

• 计算datetime2，使datetime2 + timedelta == datetime1。至于添加，结果具有与tzinfo输入日期时间相同的属性，并且即使输入已知，也不会执行时区调整。这与datetime1 +（-timedelta）并不完全等价，因为在datetime1 - timedelta没有的情况下，单独的-timedelta可能会溢出。

• 仅当两个操作数都是天真的，或者如果两者都知道的话，才datetime从a中减去a datetime。如果一个人意识到而另一个天真，TypeError则会被提出。

如果两者都native，或两者都知道并具有相同的tzinfo属性，则tzinfo属性将被忽略，其结果是一个timedelta对象吨使得datetime2 + t == datetime1。在这种情况下，不会进行时区调整。

如果两者都知道并且具有不同的tzinfo属性，a-b就好像a和b首先被转换为朴素的UTC日期时间。结果是(a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())除了实现不会溢出。

• 当datetime1在datetime2之前及时时，datetime1被认为小于datetime2。如果一个比较是天真的，另一个是知道的，则会提出。如果两个比较数据都知道并且具有相同的属性，则忽略通用属性并比较基准日期时间。如果两个比较值都知道并具有不同的属性，则首先通过减去它们的UTC偏移量（从中获得）来调整比较值。注意为了停止比较以回落到比较对象地址的默认方案，如果另一个比较值不是对象，则日期时间比较通常会上升。然而，TypeErrortzinfotzinfotzinfoself.utcoffset()TypeErrordatetimeNotImplemented如果另一个比较具有timetuple()属性，则返回。这个钩子为其他类型的日期对象提供了一个实现混合类型比较的机会。如果没有，则将datetime对象与不同类型的对象进行TypeError比较时，除非比较为==或，否则将引发该对象!=。后面的情况分别返回False或True。datetime对象可以用作字典键。在布尔上下文中，所有datetime对象都被认为是true.Instance方法：datetime.date()返回date年份，月份和日期相同的对象。以相同的小时，分​​钟，秒和微秒datetime.time()返回time对象。tzinfo是None。另见方法timetz()。datetime.timetz()返回time具有相同小时，分钟，秒，微秒和tzinfo属性的对象。另见方法time()。datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])使用相同的属性返回一个日期时间，除了那些通过指定任何关键字参数给出新值的属性。请注意，tzinfo=None可以指定从可识别的日期时间创建天真的日期时间，而不会转换日期和时间数据。datetime.astimezone(tz)返回datetime带有新tzinfo属性tz的对象，调整日期和时间数据，以便UTC与自身的时间相同，但在tz的当地时间。tz必须是tzinfo子类的一个实例，其方法utcoffset()和dst()方法不能返回None。自我必须意识到（self.tzinfo一定不能None，也self.utcoffset()不能返回None）。如果self.tzinfo是tz，self.astimezone(tz)就等于self：不调整日期或时间数据。否则，结果是时区tz中的本地时间，表示与自身时间相同的UTC时间：之后astz = dt.astimezone(tz)，astz - astz.utcoffset()通常会有相同的日期和时间数据dt - dt.utcoffset()。对班级的讨论tzinfo解释了在夏令时转换边界不能实现的情况（只有在tz模拟标准时间和夏令时的情况下才会出现问题）。如果您只想将时区对象tz附加到日期时间dt无需调整日期和时间数据，即可使用dt.replace(tzinfo=tz)。如果您只是想在不转换日期和时间数据的情况下从感知日期时间dt中删除时区对象，请使用dt.replace(tzinfo=None).Note tzinfo.fromutc()可以在tzinfo子类中重写默认方法以影响返回的结果astimezone()。忽略错误情况，astimezone()如下所示：def astimezone（self，tz）：if self.tzinfo is tz：return self＃将self转换为UTC，并附加新的时区对象。utc =（self - self.utcoffset（））。replace（tzinfo = tz）＃从UTC转换到tz的本地时间。返回tz.fromutc（utc）datetime.utcoffset()如果tzinfo是None，返回None，否则返回self.tzinfo.utcoffset(self)，如果后者不返回None，则引发异常，或者返回timedelta对象表示整数分钟，幅度小于一天。datetime.dst()如果tzinfo是None，则返回None，否则返回self.tzinfo.dst(self)，如果后者不返回None，则引发异常，或者timedelta表示整数分钟的对象，其大小小于一天。datetime.tzname()如果tzinfo是None，退货None，否则退货self.tzinfo.tzname(self)，引发异常，如果后者不返回None或字符串对象，datetime.timetuple()返回一个time.struct_time例如通过返回的time.localtime()。d.timetuple()相当于今年1月1 日开始的当天数字在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() + 11tm_isdstdst()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()返回的是什么。对于UTC时间，DST永远不起作用。如果d知道，则将d标准化为UTC时间，通过减去d.utcoffset()并time.struct_time返回标准化时间。tm_isdst被强制为0.注意，如果d。年是或，结果的tm_year成员可能是MINYEAR-1或MAXYEAR+1MINYEARMAXYEAR并且UTC调整溢出了一年的边界。datetime.toordinal()返回日期的格雷戈里序数。和self.date().toordinal()。一样。datetime.weekday()将星期几作为整数返回，其中星期一为0，星期日为6.与self.date().weekday()。相同。另见isoweekday()。datetime.isoweekday()将星期几作为整数返回，其中星期一为1，星期日为7.与self.date().isoweekday()。相同。另见weekday()，isocalendar()。datetime.isocalendar()返回3元组（ISO年，ISO周编号，ISO工作日）。和self.date().isocalendar()。一样。datetime.isoformat([sep])以ISO 8601格式YYYY-MM-DDTHH：MM：SS.mmmmmm返回代表日期和时间的字符串，如果microsecond为0，则返回YYYY-MM-DDTHH：MM：SSIf utcoffset()不返回None，会附加一个6个字符的字符串，给出（带符号）小时和分钟的UTC偏移：YYYY-MM-DDTHH：MM：SS.mmmmmm + HH：MM或者如果microsecond为0 YYYY-MM-DDTHH：MM：SS + HH：MM可选参数sep（默认'T'）是一个单字符分隔符，位于结果的日期和时间部分之间。例如，>>> from datetime import tzinfo，timedelta，datetime >>> class TZ（tzinfo）：... def utcoffset（self，dt）：return timedelta（minutes = -399）... >>> datetime（ 2002年12月25日，tzinfo = TZ（））。isoformat（''）'2002-12-25 00：00：00-06：39' datetime.__str__()对于datetime实例d而言，str(d)等同于d.isoformat(' ')。datetime.ctime()例如，返回表示日期和时间的字符串datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec 4 20:30:40 2002'。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在使用时为对象指定格式字符串成为可能str.format()。请参阅使用datetime对象的strftime（）和strptime（）部分的行为：>>> from datetime导入日期时间，日期，时间>>>＃使用datetime.combine（）>>> d = date（2005， 14）>>> t = time（12,30）>>> datetime.combine（d，t）datetime.datetime（2005,7,14,12,30）>>>＃使用datetime.now（）或datetime 。datetime.datetime（2007，12，6，16，29，43， 6，15，29，43，79060）>>>＃使用datetime.strptime（）>>> dt = datetime.strptime（“21/11/06 16:30”，“％d /％m /％y％ H：％M“）>>> dt datetime.datetime（2006,11,21,16,30）>>>＃使用datetime.timetuple（）获取所有属性的元组>>> >>> tt = dt.timetuple（） > 7200）>>>＃将datetime转换为另一个时区>>> dt3 = dt2.astimezone（GMT2（））>>> dt3 datetime.datetime（2006，6，14，14，0，tzinfo = <GMT2对象在0x ...>）>>> dt2 datetime.datetime（2006，6，14，13，0，tzinfo = <0x1>处的GMT1对象）>>> dt2.utctimetuple（）== dt3.utctimetuple（） True5。时间对象时间对象表示一天中的（当地）时间，与任何特定日子无关，并且可以通过a。进行调整tzinfo目的。class datetime.time([hour[, minute[, second[, microsecond[, tzinfo]]]]])所有参数都是可选的。tzinfo可能是None一个tzinfo子类的实例。其余参数可以是整数或长整数，范围如下：

• 0 <= hour < 24

• 0 <= minute < 60

• 0 <= second < 60

• 0 <= microsecond < 1000000.

如果超出这些范围的论点ValueError被提出。0除tzinfo之外，所有的默认值都是默认的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

In range(24).

time.minute

In range(60).

time.second

In range(60).

time.microsecond

In range(1000000).

time.tzinfo

该对象作为tzinfo参数传递给time构造函数，或者None如果没有传递。

支持的操作：

• 比较time来time，其中一个被认为是小于b当一先b中的时间。如果一个比较是天真的，另一个是知道的，TypeError则会提出。如果两个比较都知道，并且具有相同的tzinfo属性，tzinfo则忽略通用属性并比较基准时间。如果两个比较值都知道并具有不同的tzinfo属性，则首先通过减去它们的UTC偏移量（从中获得self.utcoffset()）来调整比较值。为了阻止混合类型比较回落到按对象地址进行的默认比较，当time对象与不同类型的对象进行TypeError比较时，除非比较是==或者!=。后面的情况分别返回False或True。

• 散列，用作字典键

• 高效的pickling

• 在布尔上下文中，time当且仅当在将其转换为分钟并减去utcoffset()（或者0如果是None）之后，结果不为零时，才认为该对象为真。

实例方法：

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

使用相同的值返回time ，除了通过指定任何关键字参数给出新值的那些属性。请注意，tzinfo=None可以指定time从知道创建一个天真的time，而不需要转换时间数据。

time.isoformat()

以ISO 8601格式返回表示时间的字符串，HH：MM：SS.mmmmmm，或者，如果self.microsecond为0，则HH：MM：SS如果utcoffset()不返回None，则会追加6个字符的字符串，从而给出UTC偏移量（带符号）小时和分钟：HH：MM：SS.mmmmmm + HH：MM或者，如果self.microsecond为0，则HH：MM：SS + HH：MM

time.__str__()

在时间t，str(t)相当于t.isoformat()。

time.strftime(format)

返回一个表示时间的字符串，由一个明确的格式字符串控制。有关格式化指令的完整列表，请参见strftime（）和strptime（）行为一节。

time.__format__(format)

和...一样time.strftime()。这使得time在使用时为对象指定格式字符串成为可能str.format()。请参见strftime（）和strptime（）行为一节。

time.utcoffset()

如果tzinfo是None，返回None，否则返回self.tzinfo.utcoffset(None)，并且如果后者不返回，则引发异常，None或者timedelta表示整数分钟的对象，其大小小于一天。

time.dst()

如果tzinfo是None，则返回None，否则返回self.tzinfo.dst(None)，如果后者不返回None，则引发异常，或者timedelta表示整数分钟的对象，其大小小于一天。

time.tzname()

如果tzinfo是None，返回None，否则返回self.tzinfo.tzname(None)，或者如果后者没有返回None或字符串对象则引发异常。

例：

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

6. tzinfo对象

class datetime.tzinfo

这是一个抽象基类，意味着这个类不应该直接实例化。您需要派生一个具体的子类，并且（至少）提供您使用的tzinfo方法所需的标准方法的实现datetime。该datetime模块不提供任何具体的子类tzinfo。

（具体子类）的实例tzinfo可以传递给构造函数datetime和time对象。后者对象将它们的属性视为在本地时间，并且该tzinfo对象支持揭示UTC的本地时间偏移量，时区名称和DST偏移量的方法，所有这些方法都相对于传递给它们的日期或时间对象。

pickling的特殊要求：一个tzinfo子类必须有一个__init__()可以不带参数调用的方法，否则它可能会被腌渍，但可能不会再次取消。这是未来可能会放松的技术要求。

具体的子类tzinfo可能需要实现以下方法。究竟需要哪些方法取决于由感知datetime对象组成的用途。如果有疑问，只需实施所有这些。

tzinfo.utcoffset(self, dt)

在UTC以东的分钟内，从UTC返回当地时间的偏移量。如果当地时间在UTC以西，则应该是负值。请注意，这应该是UTC的总偏移量; 例如，如果某个tzinfo对象同时代表时区和DST调整，utcoffset()则应返回它们的总和。如果UTC偏移量未知，则返回None。否则，返回的值必须是一个timedelta对象，指定在-1439至1439（含1440 = 24 * 60;偏移的幅度必须小于一天）范围内的整数分钟。大多数的实现utcoffset()可能看起来像这两个之一：

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

如果utcoffset()不返回None，dst()也不应该返回None。

utcoffset()引发的默认实现NotImplementedError。

tzinfo.dst(self, dt)

返回UTC以东分钟的夏令时（DST）调整，或者None如果DST信息未知。timedelta(0)如果DST没有生效，则返回。如果DST生效，请将偏移量作为timedelta对象返回（utcoffset()详情请参阅）。请注意，如果适用，DST偏移量已被添加到返回的UTC偏移量utcoffset()，因此dst()除非您有兴趣单独获取DST信息，否则无需咨询。例如，datetime.timetuple()调用其tzinfo属性的dst()方法来确定如何设置tm_isdst标志，并tzinfo.fromutc()调用dst()跨越时区时考虑DST更改。

在这个意义上，模拟标准时间和日光时间的子类的实例tztzinfo必须一致：

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

必须为每个datetime dt返回与dt.tzinfo == tzFor sane tzinfo子类相同的结果，这个表达式产生时区的“标准偏移量”，它不应该取决于日期或时间，而只取决于地理位置。datetime.astimezone()依赖于此的实施，却无法检测到违规行为; 程序员有责任确保它。如果一个tzinfo子类不能保证这一点，它可能能够重写默认实现，tzinfo.fromutc()以便与astimezone()不管。

大多数的实现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.  Then

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

dst()引发的默认实现NotImplementedError。

tzinfo.tzname(self, dt)

以字符串形式返回与datetime对象dt相对应的时区名称。关于字符串名称的任何内容都不是由datetime模块定义的，并且没有要求它具体说明任何内容。例如，“GMT”，“UTC”，“-500”，“-5：00”，“EDT”，“US / Eastern”，“America / New York”都是有效的答复。None如果字符串名称未知，则返回。请注意，这是一种方法，而不是固定字符串，主要是因为某些tzinfo子类会根据传递的dt的具体值返回不同的名称，特别是如果tzinfo类占了白天时间。

tzname()引发的默认实现NotImplementedError。

这些方法由一个datetime或一个time对象调用，以响应它们的相同名称的方法。一个datetime对象将自身作为参数传递，并且一个time对象None作为参数传递。一个tzinfo因此子类的方法应该准备接受DT的说法None，或一类datetime。

什么时候None通过，是由班级设计师来决定最佳答案。例如，None如果班级希望说时间对象不参与tzinfo协议，则返回是合适的。utcoffset(None)返回标准UTC偏移量可能更有用，因为没有其他约定用于发现标准偏移量。

当datetime响应某个datetime方法传递一个对象时，dt.tzinfo它与自己是同一个对象。tzinfo方法可以依赖于此，除非用户代码tzinfo直接调用方法。意图是这些tzinfo方法将dt解释为在当地时间，而不需要担心其他时区中的对象。

还有tzinfo一个子类可能希望覆盖的方法：

tzinfo.fromutc(self, dt)

这是从默认datetime.astimezone()实现中调用的。当从那里调用时，dt.tzinfo是自己的，dt的日期和时间数据被视为表示UTC时间。的目的fromutc()是调整日期和时间数据，在返回等效的datetime 自本地时间。

大多数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类：

from datetime import tzinfo, timedelta, datetime

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

# A UTC class.

class UTC(tzinfo):
    """UTC"""

    def utcoffset(self, dt):
        return ZERO

    def tzname(self, dt):
        return "UTC"

    def dst(self, dt):
        return ZERO

utc = UTC()

# A class building tzinfo objects for fixed-offset time zones.
# Note that FixedOffset(0, "UTC") is a different way to build a
# UTC tzinfo object.

class FixedOffset(tzinfo):
    """Fixed offset in minutes east from UTC."""

    def __init__(self, offset, name):
        self.__offset = timedelta(minutes = offset)
        self.__name = name

    def utcoffset(self, dt):
        return self.__offset

    def tzname(self, dt):
        return self.__name

    def dst(self, dt):
        return ZERO

# A class capturing the platform's idea of local time.

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 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; 1am standard time) on the first Sunday of Nov.
DSTEND_2007 = datetime(1, 11, 1, 1)
# 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; 1am standard 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, 1)
# 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;
# 1am standard 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

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

        # Find start and end times for US DST. For years before 1967, return
        # ZERO for no DST.
        if 2006 < dt.year:
            dststart, dstend = DSTSTART_2007, DSTEND_2007
        elif 1986 < dt.year < 2007:
            dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
        elif 1966 < dt.year < 1987:
            dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
        else:
            return ZERO

        start = first_sunday_on_or_after(dststart.replace(year=dt.year))
        end = first_sunday_on_or_after(dstend.replace(year=dt.year))

        # Can't compare naive to aware objects, so strip the timezone from
        # dt first.
        if start <= dt.replace(tzinfo=None) < end:
            return HOUR
        else:
            return ZERO

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在DST开始的那天提供结果。为了astimezone()做出这种保证，该rzinfo.dst()方法必须考虑在“错过时间”（东部2：MM）的时间处于白天时间。

当DST结束时（“结束”），有一个潜在的更糟糕的问题：有一个小时不能在本地时间内明确拼写：夏时制的最后一个小时。在东部，这是当天白天时间形式为5：MM UTC的时间结束。当地的挂钟从1:59（白天时间）再次跳回到1:00（标准时间）。表格1：MM的当地时间不明确。astimezone()通过将两个相邻的UTC小时映射到当时相同的小时来模​​拟本地时钟的行为。在东部示例中，格式5：MM和6：MM的UTC时间在转换为东部时都映射到1：MM。为了astimezone()做出这个保证，tzinfo.dst()方法必须将“重复时间”中的时间考虑在标准时间内。例如，通过在时区的标准本地时间中表示DST切换时间，可以很容易地进行安排。

不能承受这种歧义的应用程序应避免使用混合tzinfo子类; 使用UTC或任何其他固定偏移tzinfo子类（例如仅代表EST（固定偏移-5小时）的类或仅EDT（固定偏移-4小时））时不存在歧义。

IANA时区数据库时区数据库（通常称为tz或zoneinfo）包含代表全球许多代表性地点的当地时间历史记录的代码和数据。它会定期更新以反映政治团体对时区边界，UTC偏移和夏时制规则所做的更改。

7. strftime()和strptime()行为

date，datetime和time所有对象都支持一个strftime(format)方法，在显式格式字符串的控制下创建一个表示时间的字符串。一般来说，d.strftime(fmt)就像time模块一样，time.strftime(fmt, d.timetuple())尽管不是所有的对象都支持一种timetuple()方法。

相反，datetime.strptime()类方法通过datetime表示日期和时间的字符串以及相应的格式字符串创建一个对象。datetime.strptime(date_string, format)相当于datetime(*(time.strptime(date_string, format)[0:6]))。

对于time对象，不应使用年，月和日的格式代码，因为时间对象不具有此类值。如果无论如何都使用它们，1900则替换年份以及1月份和日期。

对于date对象，不应使用小时，分钟，秒和微秒的格式代码，因为date对象不具有此类值。如果他们无论如何0都被使用，将被替代。

支持的全套格式代码在不同的平台上有所不同，因为Python将平台C库的strftime()功能称为平台，并且平台变体是常见的。要查看平台上支持的全套格式代码，请参阅strftime（3）文档。

以下是C标准（1989版本）要求的所有格式代码的列表，并且这些代码可以在所有平台上使用标准的C实现。请注意，1999版本的C标准添加了额外的格式代码。

作品的确切范围strftime()也因平台而异。无论何种平台，1900年前都不能使用。

指示	含义	例	笔记
％一个	星期几作为区域设置的缩写名称。	​	(1)
％一个	星期几作为区域的全名。	​	(1)
在％	星期几为十进制数字，其中0表示星期日，6表示星期六。	0, 1, ..., 6	​
％d	一个月中的一天作为零填充的十进制数字。	01, 02, ..., 31	​
％b	月为区域设置的缩写名称。	​	(1)
％B	月作为区域的全名。	​	(1)
％M	月份作为零填充十进制数字。	01, 02, ..., 12	​
％和	没有世纪的一年是一个零填充的十进制数。	00, 01, ..., 99	​
％Y	世纪作为十进制数字。	1970, 1988, 2001, 2013	​
％H	小时（24小时制）作为零填充十进制数字。	00, 01, ..., 23	​
％一世	小时（12小时制）作为零填充的十进制数字。	01, 02, ..., 12	​
％p	区域设置相当于AM或PM。	​	(1), (2)
％M	分钟作为零填充的十进制数字。	00, 01, ..., 59	​
％S	其次作为零填充的十进制数字。	00, 01, ..., 59	(3)
％F	微秒为十进制数字，左侧为零填充。	000000, 000001, ..., 999999	(4)
的％	以+ HHMM或-HHMM形式的UTC偏移量（如果对象天真，则为空字符串）。	（空），+0000，-0400，+1030	(5)
从％	时区名称（如果对象天真，则为空字符串）。	（空），UTC，EST，CST	​
引用％j	一年中的一天为零填充的十进制数字。	001, 002, ..., 366	​
％U	一年中的星期数（星期日为一周的第一天）作为零填充十进制数。第一个星期日前一年的所有日子都被认为是在第0周。	00, 01, ..., 53	(6)
在％	一年中的星期数（星期一作为一周中的第一天）作为十进制数。第一个星期一之前的新年的所有日子都被认为是在第0周。	00, 01, ..., 53	(6)
％C	区域设置的适当日期和时间表示。	​	(1)
％X	区域设置的适当日期表示。	​	(1)
％X	区域设置适当的时间表示。	​	(1)
%%	字面'％'字符。	%	​

注释：

• 由于格式取决于当前的语言环境，因此在对输出值进行假设时应该小心。字段排序会有所不同（例如，“月/日/年”相对于“日/月/年”）使用区域设置的默认编码进行编码，并输出可能包含Unicode字符（例如，如果当前区域是ja_JP，默认编码可以是中的任一项eucJP，SJIS或utf-8;使用locale.getlocale()以确定当前区域的编码）。

• 与strptime()方法一起使用时，%p如果%I指令用于解析小时，则指令仅影响输出小时字段。

• 与time模块不同，该datetime模块不支持闰秒。

• %f是C标准中格式字符集的扩展（但是在datetime对象中单独实现，因此始终可用）。当与该strptime()方法一起使用时，该%f指令在右侧接受一到六位数字和零填充。

2.6版本中的新功能。

• 对于一个天真的对象，%z和%Z格式代码被替换为空字符串。对于感知对象： %z utcoffset()被转换为格式为+ HHMM或-HHMM的5个字符的字符串，其中HH是一个2位数的字符串，给出UTC偏移小时数，MM是一个2位数字符串， UTC抵消分钟。例如，如果utcoffset()返回timedelta(hours=-3, minutes=-30)，%z则替换为字符串'-0330'。 %Z 如果tzname()返回None，%Z则由空字符串替换。否则%Z被返回的值替换，该值必须是一个字符串。

• 当与使用strptime()方法，%U并%W指定了一周，一年中的一天，在计算仅使用。

注

1	如果，那就是我们忽略相对论的影响