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

好的，我们今天过得不好

当您将正确的tzinfo对象附加到datetime实例，然后将其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" ) #python 2.5.4 now=datetime.now（） 立即打印。strftime（“%a%b%d%X”）#是“区域设置的适当时间代表” pst=now.replace（tzinfo=Pacific） 打印pst.strftime（“%a%b%d%X”） 我们得到：

Mon Jan 18 17:30:16 Mon Jan 18 17:30:16 1月18日星期一17:30:16 1月18日星期一17:30:16 我发现如果我加上%z，我可以加上它应该计算的差值：

Mon Jan 18 17:32:38 Mon Jan 18 17:32:38 -0800 1月18日星期一17:32:38 周一1月18日17:32:38-0800 它只是钉在-8上，好像在说，“你自己做，福。”

但我希望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" )

从datetime导入tzinfo、timedelta、datetime
零=时间增量（0）
小时=时间增量（小时=1）
#UTC类。
UTC等级（tzinfo）：
“UTC”
def utcoffset（自身，dt）：
归零
def tzname（自身，dt）：
返回“UTC”
def dst（自身，dt）：
归零
utc=utc（）
#为固定偏移时区构建tzinfo对象的类。
#请注意，FixedOffset（0，“UTC”）是构建
#UTC tzinfo对象。
类固定偏移（tzinfo）：
“”“以分钟为单位的固定偏移距UTC。”“”
定义初始化（自身、偏移量、名称）：
自偏移量=时间增量（分钟=偏移量）
self.\uu name=名称
def utcoffset（自身，dt）：
返回自偏移量
def tzname（自身，dt）：
返回self.\u名称
def dst（自身，dt）：
归零
#一个捕获平台本地时间概念的类。
将时间导入为\u时间
STDOFFSET=timedelta（秒=-\u time.timezone）
如果_time.daylight：
DSTOFFSET=timedelta（秒=-\u time.altzone）
其他：
DSTOFFSET=STDOFFSET
DSTDIFF=DSTOFFSET-STDOFFSET
类本地时区（tzinfo）：
def utcoffset（自身，dt）：
如果是自整定isdst（dt）：
返回偏移量
其他：
返回标准偏差
def dst（自身，dt）：
如果是自整定isdst（dt）：
返回差分
其他：
归零
def tzname（自身，dt）：
return _time.tzname[self._isdst（dt）]
def_isdst（自身，dt）：
tt=（年、月、日、，
时，分，秒，
dt.weekday（），0，-1）
stamp=\u time.mktime（tt）
tt=\u time.localtime（戳记）
返回tt.tm_isdst>0
Local=LocalTimezone（）
#全面实施美国主要时区的现行DST规则。
def第一个星期日在星期日或星期日之后（dt）：
天数=6-dt.weekday（）
如果还有几天：
dt+=时间增量（天数）
返回dt
#在美国，DST在4月的第一个星期日凌晨2点（标准时间）开始。
DSTSTART=datetime（1,4,1,2）
#在10月最后一个星期日凌晨2点（DST时间；标准时间凌晨1点）结束。
#10月25日当天或之后的第一个星期日。
DSTEND=日期时间（1,10,25,1）
乌司米酮类（tzinfo）：
定义初始化（self、hours、reprname、stdname、dstname）：
self.stdoffset=timedelta（小时=hours）
self.reprname=reprname
self.stdname=stdname
self.dstname=dstname
定义报告（自我）：
return self.reprname
def tzname（自身，dt）：
如果自测试（dt）：
返回self.dstname
其他：
return self.stdname
def utcoffset（自身，dt）：
返回self.stdoffset+self.dst（dt）
def dst（自身，dt）：
如果dt为无或dt.tzinfo为无：
#在一种或两种情况下，例外情况可能是合理的。
#这取决于你想如何对待他们。默认值
#fromutc（）实现（默认情况下使用astimezone（）调用）
#实现）通过dt.tzinfo is self传递日期时间。
归零
断言dt.tzinfo是self
#找到四月的第一个星期日&十月的最后一个星期日。
开始=第一个星期日或之后（DSTSTART.replace（year=dt.year））
结束=第一个星期日或之后（DSTEND.replace（year=dt.year））
#无法将原始对象与感知对象进行比较，因此请从
#首先。
如果开始时使用
dt.replace（tzinfo=tz）
您并没有真正转换时间值，您只是说“嘿，不，等等，这次实际上是在PDT中，不是在UTC中”。您可能会想使用
datetime.astimezone（tz）
。
我认为，只是向后看。如果您想知道UTC的时间，请使用：

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

您必须为UTC时区类找到一个定义。我理解为什么Python不想提供每个可能的tzinfo的默认实现，但UTC应该包含在基本包中。
.replace
不进行计算：它只是替换新返回对象中的一个或多个字段，同时从调用它的对象复制所有其他字段

如果我正确地理解了您的情况，您可以从一个datetime对象开始，您知道（通过其他方式）它是UTC，但不知道它本身（is的tzinfo属性为
None
，意思是“我完全不知道我在哪个时区）

因此，首先，您可以从输入的时区原始对象中识别时区，以便通知它位于时区UTC（所有其他字段都会被复制）：

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

print aware.astimezone(Pacific).strftime('%a %b %d %X %z')

要获取给定时区中的当前时间：
now=datetime.now（Pacific）
dt.replace（tzinfo=tz）
可以为您提供一个aware
datetime
对象，而
datetime.astimezone（tz）
将为您提供以前拥有的任何类型的对象（无论是感知的还是幼稚的）。
print aware.astimezone(Pacific).strftime('%a %b %d %X %z')