Question

好的，我们今天没有过好日子。

当您将正确的tzinfo对象附加到日期时间实例，然后strftime（）它时，它仍然以UTC格式出现，似乎忽略了我附加到它的漂亮的tzinfo对象。

    # python 2.5.4
    now = datetime.now()
    print now.strftime( "%a %b %d %X" ) # %X is "locale's appropriate time rep"

    pst = now.replace( tzinfo=Pacific )
    print pst.strftime( "%a %b %d %X" )

我们得到：

Mon Jan 18 17:30:16
Mon Jan 18 17:30:16

我发现如果我添加％z，我可以添加它应该计算的差异：

Mon Jan 18 17:32:38 
Mon Jan 18 17:32:38 -0800

它只是在那里加-8，好像在说，“你自己做，foo。”

但是我希望strftime（）只给我一个字符串，其中包含一个预先确定的本地时间。

当我strftime（）它时，如何让strftime（）为我做小时减法数学？

我正在使用的完整代码如下。

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

# In the US, DST starts at 2am (standard time) on the first Sunday in April.
DSTSTART = datetime(1, 4, 1, 2)
# and ends at 2am (DST time; 1am standard time) on the last Sunday of Oct.
# which is the first Sunday on or after Oct 25.
DSTEND = datetime(1, 10, 25, 1)

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 first Sunday in April & the last in October.
    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")

now = datetime.now()
print now.strftime( "%a %b %d %X %z" )

pst = now.replace( tzinfo=Pacific )
print pst.strftime( "%a %b %d %X %z" )

Answer 1

.replace没有计算：它只是替换新返回对象中的一个或多个字段，同时从调用它的对象复制所有其他字段。

如果我理解你的情况，你可以从一个日期时间对象开始，你知道（通过其他方式）是UTC，但不知道它自己（具有{{tzinfo属性） 1}}，意思是“我对于我所处的时区完全无能为力。”

所以，首先，你从输入的时区初始对象中获得时区感知，以便通知它它是在时区UTC（所有其他字段都被复制）：

None

然后，您可以请求有关时区的计算，然后打印：

aware = naive.replace(tzinfo=utc)

Answer 2

使用dt.replace(tzinfo=tz)你并没有真正转换时间值，你只是说'嘿不，等等，这次实际上是在PDT，而不是在UTC'。您可能希望改为使用datetime.astimezone(tz)。

Answer 3

我认为Wim had the right idea，只是倒退。如果您想知道UTC时间，请使用：

print pst.astimezone(UTC).strftime( "%a %b %d %X" )

您必须挖掘UTC时区类的定义。我理解为什么Python不想提供每个可能的tzinfo的默认实现，但UTC应该包含在基础包中。

使用时区打印正确的时间，Python

3 个答案: