Pythondatetime基本的日期和时间类型

datetime 对象¶

datetime 对象是一个包含了来自 date 对象和 time 对象所有信息的单一对象。 与 date 对象一样，datetime 假定当今的格列高利历向前后两个方向无限延伸；与 time 对象一样，datetime 假定每一天恰好有 3600*24 秒。

构造器 ：

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

year, month 和 day 参数是必要的。 tzinfo 可以是 None 或者一个 tzinfo 子类的实例。 其余的参数必须是在下面范围内的整数：

• MINYEAR<=year<=MAXYEAR,

• 1<=month<=12,

• 1<=day<=指定年月的天数,

• 0<=hour<24,

• 0<=minute<60,

• 0<=second<60,

• 0<=microsecond<1000000,

• foldin[0,1].

如果参数不在这些范围内，则抛出 ValueError 异常。

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

其它构造器，所有的类方法：

classmethod datetime.today()¶

返回当前的本地 datetime，tzinfo 值为 None。 这等价于 datetime.fromtimestamp(time.time())。 另请参阅 now(), fromtimestamp()。

classmethod datetime.now(tz=None)¶

返回当前的本地 date 和 time。 如果可选参数 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 对象。 自动感知的当前 UTC 日期时间可通过调用 datetime.now(timezone.utc) 来获得。 另请参阅 now()。

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

返回对应于 POSIX 时间戳例如 time.time() 的返回值的本地日期和时间。 如果可选参数 tz 为 None 或未指定，时间戳会被转换为所在平台的本地日期和时间，返回的 datetime 对象将为天真型。

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

fromtimestamp() 可能引发 OverflowError，如果时间戳数值超出所在平台 C localtime() 或 gmtime() 函数的支持范围的话，并会在 localtime() 或 gmtime() 出错时引发 OSError。 通常该数值会被限制在 1970 年至 2038 年之间。 请注意在时间戳概念包含闰秒的非 POSIX 系统上，闰秒会被 fromtimestamp() 所忽略，结果可能导致两个相差一秒的时间戳产生相同的 datetime 对象。 另请参阅 utcfromtimestamp()。

在 3.3 版更改: 引发 OverflowError 而不是 ValueError，如果时间戳数值超出所在平台 C localtime() 或 gmtime() 函数的支持范围的话。 并会在 localtime() 或 gmtime() 出错时引发 OSError 而不是 ValueError。

在 3.6 版更改: fromtimestamp() 可能返回 fold 值设为 1 的实例。

classmethod datetime.utcfromtimestamp(timestamp)¶

返回对应于 POSIX 时间戳的 UTC datetime，其中 tzinfo 为 None。 这可能引发 OverflowError，如果时间戳数值超出所在平台 C gmtime() 函数的支持范围的话，并会在 gmtime() 出错时引发 OSError。 通常该数值并会限制在 1970 年至 2038 年之间。

要得到一个感知型 datetime 对象，应调用 fromtimestamp():

datetime.fromtimestamp(timestamp,timezone.utc)

在 POSIX 兼容的平台上，它等价于以下表达式:

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

不同之处在于后一种形式总是支持完整年份范围：从 MINYEAR 到 MAXYEAR 的开区间。

在 3.3 版更改: 引发 OverflowError 而不是 ValueError，如果时间戳数值超出所在平台 C gmtime() 函数的支持范围的话。 并会在 gmtime() 出错时引发 OSError 而不是 ValueError。

classmethod datetime.fromordinal(ordinal)¶

返回对应于预期格列高利历序号的 datetime，其中公元 1 年 1 月 1 日的序号为 1。 除非 1<=ordinal<=datetime.max.toordinal() 否则会引发 ValueError。 结果的hour, minute, second 和 microsecond 值均为 0，并且 tzinfo 值为 None。

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

返回一个新的 datetime 对象，对象的日期数值等于给定的 date 对象的数值，时间数值等于给定的 time 对象的数值。 如果提供 tzinfo 参数，其值会被用来设置结果的 tzinfo 属性，否则将会使用 time 参数的 tzinfo 属性。

对于任意 datetime 对象 d，d==datetime.combine(d.date(),d.time(),d.tzinfo)。 如果 date 是一个 datetime 对象，它的时间数值和 tzinfo 属性会被忽略。

在 3.6 版更改: 增加了 tzinfo 参数。

classmethod datetime.fromisoformat(date_string)¶

返回对应于 date.isoformat() 和 datetime.isoformat() 所提供的格式字符串中 date_string 的 datetime。 特别地，此函数支持 YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]] 格式的字符串，其中 * 可匹配任意单个字符。

警告

此函数并不支持解析任意 ISO 8601 字符串 —— 它的目的只是作为 datetime.isoformat() 的逆操作。 在第三方包 dateutil 中提供了一个更完善的 ISO 8601 解析器 dateutil.parser.isoparse。

3.7 新版功能.

classmethod datetime.strptime(date_string, format)¶

返回根据 format 解析与 date_string 相对应的 datetime，这等价于 datetime(*(time.strptime(date_string,format)[0:6]))，如果 date_string 和 format 无法被 time.strptime() 解析或它返回一个不是时间元组的值，则将引发 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到指定年月的天数间的数字。

datetime.hour¶

取值范围是 range(24)。

datetime.minute¶

取值范围是 range(60)。

datetime.second¶

取值范围是 range(60)。

datetime.microsecond¶

取值范围是 range(1000000)。

datetime.tzinfo¶

作为 tzinfo 参数被传给 datetime 构造器的对象，如果没有传入值则为 None。

datetime.fold¶

取值范围是 [0,1]。 用于在重复的时间段中消除边界时间歧义。 （当夏令时结束时回调时钟或由于政治原因导致当前时区的 UTC 时差减少就会出现重复的时间段。） 取值 0 (1) 表示两个时刻早于（晚于）所代表的同一边界时间。

3.6 新版功能.

支持的运算：

1. datetime2 是从中去掉的一段 timedelta 的结果，如果 timedelta.days > 0 则是在时间线上前进，如果 timedelta.days < 0 则后退。 结果具有与输入的 datetime 相同的 tzinfo 属性，并且操作完成后 datetime2 - datetime1 == timedelta。 如果 datetime2.year 将小于 MINYEAR 或大于 MAXYEAR 则会引发 OverflowError。 请注意即使输入的是一个感知型对象，该方法也不会进行时区调整。

2. 计算 datetime2 使得 datetime2 + timedelta == datetime1。 与相加操作一样，结果具有与输入的 datetime 相同的 tzinfo 属性，即使输入的是一个感知型对象，该方法也不会进行时区调整。

3. 从一个 datetime 减去一个 datetime 仅对两个操作数均为简单型或均为感知型时有定义。 如果一个是感知型而另一个是简单型，则会引发 TypeError。

   如果两个操作数都是简单型，或都是感知型且具有相同的 tzinfo 属性，tzinfo 属性会被忽略，结果是一个使得 datetime2+t==datetime1 的 timedelta 对象 t。 在此情况下不会进行时区调整。

   如果两个操作数都是感知型且具有不同的 tzinfo 属性，a-b 操作的行为就如同 a 和 b 被首先转换为简单型 UTC 日期时间。 结果将是 (a.replace(tzinfo=None)-a.utcoffset())-(b.replace(tzinfo=None)-b.utcoffset()) 除非具体实现绝对不溢出。

4. 当 datetime1 的时间在 datetime2 之前则认为 datetime1 小于 datetime2。

   如果比较的一方是简单型而另一方是感知型，则如果尝试进行顺序比较将引发 TypeError。 对于相等比较，简单型实例将永远不等于感知型实例。

   如果两个比较方都是感知型，且具有相同的 tzinfo 属性，相同的 tzinfo 属性会被忽略并对基本日期时间值进行比较。 如果两个比较方都是感知型且具有不同的 tzinfo 属性，两个比较方将首先通过减去它们的 UTC 差值（使用 self.utcoffset() 获取）来进行调整。

   在 3.3 版更改: 简单型和感知型 datetime 实例之间的相等比较不会引发 TypeError。

   注解

   为了防止比较操作回退为默认的对象地址比较方案，datetime 比较通常会引发 TypeError，如果比较目标不同样为 datetime 对象的话。 不过也可能会返回 NotImplemented 如果比较目标具有 timetuple() 属性的话。 这个钩子给予其他日期对象类型实现混合类型比较的机会。 否则，当 datetime 对象与不同类型的对象比较时将会引发 TypeError，除非 == 或 != 比较。 后两种情况将分别返回 False 或 True。

datetime 对象可以用作字典的键。 在布尔运算时，所有 datetime 对象都被视为真值。

实例方法：

datetime.date()¶

返回具有同样 year, month 和 day 值的 date 对象。

datetime.time()¶

返回具有同样 hour, minute, second, microsecond 和 fold 值的 time 对象。 tzinfo 为 None。 另请参见方法 timetz()。

在 3.6 版更改: fold 值会被复制给返回的 time 对象。

datetime.timetz()¶

返回具有同样 hour, minute, second, microsecond, fold 和 tzinfo 属性值的 time 对象。 另请参见方法 time()。

在 3.6 版更改: fold 值会被复制给返回的 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 从一个感知型 datetime 创建一个简单型 datetime 而不必转换日期和时间值。

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

datetime.astimezone(tz=None)¶

返回一个具有新的 tzinfo 属性 tz 的 datetime 对象，并会调整日期和时间数据使得结果对应的 UTC 时间与 self 相同，但为 tz 时区的本地时间。

tz 如果给出则必须是一个 tzinfo 子类的实例，并且其 utcoffset() 和 dst() 方法不可返回 None。 如果 self 为简单型，它会被假定为基于系统时区表示的时间。

如果调用时不传入参数（或传入 tz=None) 则将假定目标时区为系统的本地时区。 转换后 datetime 实例的 .tzinfo 属性将被设为一个 timezone 实例，时区名称和时差值将从系统获取。

如果 self.tzinfo 为 tz，self.astimezone(tz) 等于 self: 不会对日期或时间数据进行调整。 否则结果为 tz 时区的本地时间，代表的 UTC 时间与 self 相同：在 astz=dt.astimezone(tz) 之后，astz-astz.utcoffset() 将具有与 dt-dt.utcoffset() 相同的日期和时间数据。

如果你只想附加一个时区对象 tz 给一个 datetime 对象 dt 而不调整日期和时间数据，请使用 dt.replace(tzinfo=tz)。 如果你只想从一个感知型 datetime 对象 dt 移除时区对象则不转换日期和时间数据，请使用 dt.replace(tzinfo=None)。

请注意默认的 tzinfo.fromutc() 方法在 tzinfo 的子类中可以被重载，从而影响 astimezone() 的返回结果。 如果忽略出错的情况，astimezone() 的行为就类似于:

defastimezone(self,tz):
ifself.tzinfoistz:
returnself
# 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.
returntz.fromutc(utc)

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

在 3.6 版更改: astimezone() 方法可以由简单型实例调用，这将假定其表示本地时间。

datetime.utcoffset()¶

如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.utcoffset(self)，并且在后者不返回 None 或者一个幅度小于一天的 timedelta 对象时将引发异常。

在 3.7 版更改: UTC 时差不再限制为一个整数分钟值。

datetime.dst()¶

如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.dst(self)，并且在后者不返回 None 或者一个幅度小于一天的 timedelta 对象时将引发异常。

在 3.7 版更改: DST 差值不再限制为一个整数分钟值。

datetime.tzname()¶

如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.tzname(self)，如果后者不返回 None 或者一个字符串对象则将引发异常。

datetime.timetuple()¶

返回一个 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 会通过减去 d.utcoffset() 被标准化为 UTC 时间，并返回标准化时间对应的 time.struct_time。 tm_isdst 会强设为 0。 请注意如果 d.year 为 MINYEAR 或 MAXYEAR 并且 UTC 调整超出一年的边界则可能引发 OverflowError。

datetime.toordinal()¶

返回日期的预期格列高利历序号。 与 self.date().toordinal() 相同。

datetime.timestamp()¶

返回对应于 datetime 实例的 POSIX 时间戳。 返回值是与 time.time() 类似的 float。

简单型 datetime 实例会假定为代表本地时间，并且此方法依赖于平台的 C mktime() 函数来执行转换。 由于在许多平台上 datetime 支持的值范围比 mktime() 更广，对于极其遥远的过去或末来时间此方法可能引发 OverflowError。

对于感知型 datetime 实例，返回值的计算方式为:

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

3.3 新版功能.

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

注解

没有一个方法能直接从简单型 datetime 实例获取 POSIX 时间戳来代表 UTC 时间。 如果你的应用使用此惯例方式并且你的系统时区不是设为 UTC，你可以通过提供 tzinfo=timezone.utc 来获取 POSIX 时间戳:

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

返回一个 3 元组 (ISO 年份, ISO 周序号, ISO 周日期)。 相当于 self.date().isocalendar()。

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

返回一个以 ISO 8601 格式表示日期和时间的字符串 YYYY-MM-DDTHH:MM:SS.ffffff，如果 microsecond 为 0 则改用格式 YYYY-MM-DDTHH:MM:SS

如果 utcoffset() 不返回 None，则会添加一个字符串来给出 UTC 时差: YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]，如果 microsecond 为 0 则改用格式 YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]。

可选参数 sep (默认为 'T') 为单个分隔字符，会被放在结果的日期和时间两部分之间。例如

>>> fromdatetimeimporttzinfo,timedelta,datetime
>>> classTZ(tzinfo):
... defutcoffset(self,dt):returntimedelta(minutes=-399)
...
>>> datetime(2002,12,25,tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'

可选参数 timespec 要包含的额外时间组件值 (默认为 'auto')。它可以是以下值之一：

• 'auto': 如果 microsecond 为 0 则与 'seconds' 相同，否则与 'microseconds' 相同。

• 'hours': 以两个数码的 HH 格式包含 hour。

• 'minutes': 以 HH:MM 格式包含 hour 和 minute。

• 'seconds': 以 HH:MM:SS 格式包含 hour, minute 和 second。

• 'milliseconds': 包含完整时间，但将秒值的小数部分截断至微秒。 格式为 HH:MM:SS.sss。

• 'microseconds': 以HH:MM:SS.ffffff 格式包含完整时间。

注解

排除掉的时间部分将被截断，而不是被舍入。

对于无效的 timespec 参数将引发 ValueError。

>>> fromdatetimeimportdatetime
>>> 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()¶

返回一个代表日期和时间的字符串，例如 datetime(2002,12,4,20,30,40).ctime()=='WedDec  420:30:402002'。 在原生 C ctime() 函数 (time.ctime() 会发起调用该函数，但 datetime.ctime() 则不会) 遵循 C 标准的平台上，d.ctime() 等价于 time.ctime(time.mktime(d.timetuple()))。

datetime.strftime(format)¶

返回一个由显式格式字符串所指明的代表日期和时间的字符串， 要获取格式指令的完整列表请参阅 strftime() 和 strptime() 的行为。

datetime.__format__(format)¶

与 datetime.strftime() 相同。 此方法使得为 datetime 对象指定以 格式化字符串字面值 表示的格式化字符串以及使用 str.format() 进行格式化成为可能。 要获取格式指令的完整列表，请参阅 strftime() 和 strptime() 的行为。

使用 datetime 对象的例子:

>>> fromdatetimeimportdatetime,date,time
>>> # 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() or datetime.utcnow()
>>> datetime.now()
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.utcnow()
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060)
>>> # 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()
>>> foritintt:
... 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()
>>> foritinic:
... print(it)
...
2006    # ISO year
47      # ISO week
2       # ISO weekday
>>> # Formatting 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.'

使用 datetime 并附带 tzinfo:

>>> fromdatetimeimporttimedelta,datetime,tzinfo,timezone
>>> classKabulTz(tzinfo):
... # Kabul used +4 until 1945, when they moved to +4:30
... UTC_MOVE_DATE=datetime(1944,12,31,20,tzinfo=timezone.utc)
... defutcoffset(self,dt):
... ifdt.year<1945:
... returntimedelta(hours=4)
... elif(1945,1,1,0,0)<=dt.timetuple()[:5]<(1945,1,1,0,30):
... # If dt falls in the imaginary range, use fold to decide how
... # to resolve. See PEP495
... returntimedelta(hours=4,minutes=(30ifdt.foldelse0))
... else:
... returntimedelta(hours=4,minutes=30)
...
... deffromutc(self,dt):
... # 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
...
... # Follow same validations as in datetime.tzinfo
... ifnotisinstance(dt,datetime):
... raiseTypeError("fromutc() requires a datetime argument")
... ifdt.tzinfoisnotself:
... raiseValueError("dt.tzinfo is not self")
...
... ifdt.replace(tzinfo=timezone.utc)>=self.UTC_MOVE_DATE:
... returndt+timedelta(hours=4,minutes=30)
... else:
... returndt+timedelta(hours=4)
...
... defdst(self,dt):
... returntimedelta(0)
...
... deftzname(self,dt):
... ifdt>=self.UTC_MOVE_DATE:
... return"+04:30"
... else:
... return"+04"
...
... def__repr__(self):
... returnf"{self.__class__.__name__}()"
...
>>> 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.utctimetuple()==dt3.utctimetuple()
True

>>> fromdatetimeimporttime,tzinfo,timedelta
>>> classTZ1(tzinfo):
... defutcoffset(self,dt):
... returntimedelta(hours=1)
... defdst(self,dt):
... returntimedelta(0)
... deftzname(self,dt):
... return"+01:00"
... def__repr__(self):
... returnf"{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.'

fromdatetimeimporttzinfo,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.)
importtimeas_time
STDOFFSET=timedelta(seconds=-_time.timezone)
if_time.daylight:
DSTOFFSET=timedelta(seconds=-_time.altzone)
else:
DSTOFFSET=STDOFFSET
DSTDIFF=DSTOFFSET-STDOFFSET
classLocalTimezone(tzinfo):
deffromutc(self,dt):
assertdt.tzinfoisself
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))
returndatetime(*args,microsecond=dt.microsecond,
tzinfo=self,fold=fold)
defutcoffset(self,dt):
ifself._isdst(dt):
returnDSTOFFSET
else:
returnSTDOFFSET
defdst(self,dt):
ifself._isdst(dt):
returnDSTDIFF
else:
returnZERO
deftzname(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)
returntt.tm_isdst>0
Local=LocalTimezone()
# A complete implementation of current DST rules for major US time zones.
deffirst_sunday_on_or_after(dt):
days_to_go=6-dt.weekday()
ifdays_to_go:
dt+=timedelta(days_to_go)
returndt
# 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
defus_dst_range(year):
# Find start and end times for US DST. For years before 1967, return
# start = end for no DST.
if2006<year:
dststart,dstend=DSTSTART_2007,DSTEND_2007
elif1986<year<2007:
dststart,dstend=DSTSTART_1987_2006,DSTEND_1987_2006
elif1966<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))
returnstart,end
classUSTimeZone(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):
returnself.reprname
deftzname(self,dt):
ifself.dst(dt):
returnself.dstname
else:
returnself.stdname
defutcoffset(self,dt):
returnself.stdoffset+self.dst(dt)
defdst(self,dt):
ifdtisNoneordt.tzinfoisNone:
# 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.
returnZERO
assertdt.tzinfoisself
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)
ifstart+HOUR<=dt<end-HOUR:
# DST is in effect.
returnHOUR
ifend-HOUR<=dt<end:
# Fold (an ambiguous hour): use dt.fold to disambiguate.
returnZEROifdt.foldelseHOUR
ifstart<=dt<start+HOUR:
# Gap (a non-existent hour): reverse the fold rule.
returnHOURifdt.foldelseZERO
# DST is off.
returnZERO
deffromutc(self,dt):
assertdt.tzinfoisself
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
ifend<=dst_time<end+HOUR:
# Repeated hour
returnstd_time.replace(fold=1)
ifstd_time<startordst_time>=end:
# Standard time
returnstd_time
ifstart<=std_time<end-HOUR:
# Daylight saving time
returndst_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")