python显示时间_datetime --- 基本的日期和时间类型 — Python 3.9.0 文档

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