Python，datetime笔记（啥时候用到，啥时候更新）。
time模块:https://www.cnblogs.com/sidianok/p/11831019.html
官方的资料链接: https://docs.python.org/zh-cn/3.7/library/datetime.html#timedelta-objects
更新与2020年8月15日
下面内容，全部参考，复制来至官方内容。
dateime与time又一个可喜欢的时区信息属性tzinfo，这个属性可u市值给tzinfo类的子类实例。这些tzinfo对象捕获关于相对与世界标准时间（UTC）偏移、时区名字和夏令时是否有效等信息。
有效的类型
- class
datetime.time -
一个理想化的时间，它独立于任何特定的日期，假设每天一共有 24*60*60 秒（这里没有"闰秒"的概念）。 属性：
hour,minute,second,microsecond, 和tzinfo。
- class
datetime.datetime -
日期和时间的结合。属性：
year,month,day,hour,minute,second,microsecond, andtzinfo.
- class
datetime.timezone -
一个实现了
tzinfo抽象基类的子类，用于表示相对于 世界标准时间（UTC）的偏移量。
子类关系
object
timedelta
tzinfo
timezone
time
date
datetime
timedelta类对象
timedelta对象表示两个date或者time的时间间隔。
class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)¶
所有的参数都是可选的并且默认为 0。这些参数可以是整数或者浮点数，也可以是正数或者负数。
只有 days,*seconds* 和 microseconds 会存储在内部，即python内部以 days,*seconds* 和 microseconds 三个单位作为存储的基本单位。参数单位转换规则如下：
-
1毫秒会转换成1000微秒。
-
1分钟会转换成60秒。
-
1小时会转换成3600秒。
-
1星期会转换成7天。
days, seconds, microseconds 本身也是标准化的，以保证表达方式的唯一性，例：
-
0 <= microseconds < 1000000 -
0 <= seconds < 3600*24(一天的秒数) -
-999999999 <= days <= 999999999
在有任何浮点型参数或者微秒为小数的情况下，所有小数均会按照前面的换算规则叠加到下一级，并使用round-half-to-even的方法对微秒进行取舍。没有浮点型参数情况下，转换的过程就是精确的（没有信息丢失）。
microseconds为微秒，milliseconds=0为毫秒,所以保存的实际信息为，天，秒，毫秒
类属性：
timedelta.min-
The most negative
timedeltaobject,timedelta(-999999999).
timedelta.max-
The most positive
timedeltaobject,timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999).
timedelta.resolution-
两个不相等的
timedelta类对象最小的间隔为timedelta(microseconds=1)
In [6]: timedelta.min Out[6]: datetime.timedelta(days=-999999999) In [7]: timedelta.max Out[7]: datetime.timedelta(days=999999999, seconds=86399, microseconds=999999) In [8]: timedelta.resolution Out[8]: datetime.timedelta(microseconds=1) In [9]:
In [10]: t1 = timedelta(days=1,seconds=999,microseconds=1000) In [11]: t2 = timedelta(days=2,seconds=99,microseconds=500) In [12]:
|
|
t2 和 t3 的和。 运算后 t1-t2 == t3 and t1-t3 == t2 必为真值。(1) In [12]: t1 + t2 Out[12]: datetime.timedelta(days=3, seconds=1098, microseconds=1500)
|
|
|
t2 减 t3 的差。 运算后 t1 == t2 - t3 and t2 == t1 + t3 必为真值。 (1)(6) In [13]: t1 - t2 Out[13]: datetime.timedelta(days=-1, seconds=900, microseconds=500)
|
|
|
乘以一个整数。运算后假如 In [28]: t1 * 3 Out[28]: datetime.timedelta(days=3, seconds=2997, microseconds=3000)
|
|
In general, t1 * i == t1 * (i-1) + t1 is true. (1) |
|
|
|
乘以一个浮点数，结果会被舍入到 timedelta 最接近的整数倍。 精度使用四舍五偶入奇不入规则。 In [29]: t1 Out[29]: datetime.timedelta(days=1, seconds=999, microseconds=1000) In [30]: t1 * 1.5 Out[30]: datetime.timedelta(days=1, seconds=44698, microseconds=501500) In [31]:
|
|
|
总时间 t2 除以间隔单位 t3 (3)。 返回一个 In [33]: t1 Out[33]: datetime.timedelta(days=1, seconds=999, microseconds=1000) In [34]: t2 Out[34]: datetime.timedelta(days=2, seconds=99, microseconds=500) In [35]: t1 / t2 Out[35]: 0.5054916497333944 In [36]:
|
|
|
除以一个浮点数或整数。 结果会被舍入到 timedelta 最接近的整数倍。 精度使用四舍五偶入奇不入规则。 In [36]: t1 /3 Out[36]: datetime.timedelta(seconds=29133, microseconds=333) In [37]:
|
|
|
取整除，余数部分(如果有的话)将被丢弃。在第二种情况下，返回一个整数。(3) In [37]: t1 // 3 Out[37]: datetime.timedelta(seconds=29133, microseconds=333) In [38]:
|
|
|
余数为一个 In [38]: t1 % t2 Out[38]: datetime.timedelta(days=1, seconds=999, microseconds=1000) In [39]: t1 Out[39]: datetime.timedelta(days=1, seconds=999, microseconds=1000) In [40]: t2 Out[40]: datetime.timedelta(days=2, seconds=99, microseconds=500) In [41]: t2 % t1 Out[41]: datetime.timedelta(seconds=85499, microseconds=999500) In [42]:
|
|
|
通过 : |
|
|
返回一个相同数值的 |
|
|
等价于 In [49]: t1 Out[49]: datetime.timedelta(days=1, seconds=999, microseconds=1000) In [50]: -t1 Out[50]: datetime.timedelta(days=-2, seconds=85400, microseconds=999000) In [51]:
|
|
|
当 In [44]: t1 -t2 Out[44]: datetime.timedelta(days=-1, seconds=900, microseconds=500) In [45]: abs(t1-t2) Out[45]: datetime.timedelta(seconds=85499, microseconds=999500) In [46]: t2 - t1 Out[46]: datetime.timedelta(seconds=85499, microseconds=999500) In [47]:
|
|
|
返回一个形如 |
|
|
返回一个 |
-
精确但可能会溢出。
-
精确且不会溢出。
-
除以0将会抛出异常
ZeroDivisionError。 -
-timedelta.max 不是一个
timedelta类对象。 -
String representations of
timedeltaobjects are normalized similarly to their internal representation. This leads to somewhat unusual results for negative timedeltas. For example:In [51]: timedelta(hours=-1) Out[51]: datetime.timedelta(days=-1, seconds=82800) In [52]: _ = timedelta(hours=-5) In [53]: print(_) -1 day, 19:00:00 In [54]: _ Out[54]: datetime.timedelta(days=-1, seconds=68400) In [55]:
-
表达式
t2 - t3通常与t2 + (-t3)是等价的，除非 t3 等于timedelta.max; 在这种情况下前者会返回结果，而后者则会溢出。
除了上面列举的操作以外 timedelta 对象还支持与 date 和 datetime 对象进行特定的相加和相减运算（见下文）。
在 3.2 版更改: 现在已支持 timedelta 对象与另一个 timedelta 对象相整除或相除，包括求余运算和 divmod() 函数。 现在也支持 timedelta 对象被 float 对象除或乘。
timedelta 对象与 timedelta 对象比较的支持是通过将表示较小时间差的 timedelta 对象视为较小值。 为了防止将混合类型比较回退为基于对象地址的默认比较，当 timedelta 对象与不同类型的对象比较时，将会引发 TypeError，除非比较运算符是 == 或 !=。 在后一种情况下将分别返回 False 或 True。
timedelta 对象是 hashable 类型的(可以作为字典关键字), 支持高效获取, 在布尔上下文中， timedelta 对象大多数情况下都被视为真，仅在不等于 timedelta(0) 时。
实例方法：
timedelta.total_seconds()-
返回时间间隔包含了多少秒。造价于
td / timedelta(seconds=1)。对于其它单位可以直接使用除法的形式 (例如td / timedelta(microseconds=1))。需要注意的是，时间间隔较大时，这个方法的结果中的微秒将会失真（大多数平台上大于270年视为一个较大的时间间隔）。
In [57]: t1 Out[57]: datetime.timedelta(days=1, seconds=999, microseconds=1000) In [58]: t1.total_seconds() Out[58]: 87399.001 In [59]:
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(days=3650), 10) nine_years = ten_years - year nine_years, nine_years.days // 365 (datetime.timedelta(days=3285), 9) three_years = nine_years // 3 three_years, three_years.days // 365 (datetime.timedelta(days=1095), 3) abs(three_years - ten_years) == 2 * three_years + year True
data对象
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 <= 日期 <= 给定年月对应的天数 - 如果参数不在这些范围内，则抛出
ValueError异常。
-
In [65]: date(2020,1,1) Out[65]: datetime.date(2020, 1, 1) In [66]: date(2020,13,1) --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-66-2b8ed3aca917> in <module> ----> 1 date(2020,13,1) ValueError: month must be in 1..12 In [67]:
其它构造器，所有的类方法：
- classmethod
date.today() -
返回当地的当前日期。与``date.fromtimestamp(time.time())``等价。
In [67]: date.today() Out[67]: datetime.date(2020, 8, 15) In [68]:
- classmethod
date.fromtimestamp(timestamp) -
返回对应于 POSIX 时间戳例如
time.time()返回值的本地日期。 这可能引发OverflowError，如果时间戳数值超出所在平台 Clocaltime()函数的支持范围的话，并会在localtime()出错时引发OSError。 通常该数值会被限制在 1970 年至 2038 年之间。 请注意在时间戳概念包含闰秒的非 POSIX 系统上，闰秒会被fromtimestamp()所忽略。在 3.3 版更改: 引发
OverflowError而不是ValueError，如果时间戳数值超出所在平台 Clocaltime()函数的支持范围的话，并会在localtime()出错时引发OSError而不是ValueError。In [72]: date.fromtimestamp(0) Out[72]: datetime.date(1970, 1, 1) In [73]: date.fromtimestamp(tm.time()) Out[73]: datetime.date(2020, 8, 15) In [74]:
- classmethod
date.fromordinal(ordinal) -
返回对应于预期格列高利历序号的日期，其中公元 1 年 1 月 1 日的序号为 1。 除非
1 <= 序号 <= date.max.toordinal()[3652059]否则会引发ValueError。对于任意日期 d，
date.fromordinal(d.toordinal()) == d。In [77]: date.today().toordinal() Out[77]: 737652 In [79]: date.fromordinal(737652) == date.today() Out[79]: True In [80]:
- classmethod
date.fromisoformat(date_string) -
返回对应于
date.isoformat()所提供的 date_string 格式的date。 特别地，此函数支持YYYY-MM-DD格式的字符串。In [83]: date.fromisoformat('2020-02-03') Out[83]: datetime.date(2020, 2, 3) In [84]: date.fromisoformat('2020-12-03') Out[84]: datetime.date(2020, 12, 3)警告
此函数不支持解析任意 ISO 8601 字符串 —— 它的目的只是作为
date.isoformat()的逆操作。
datetime.datetime也支持iso的字符串格式
3.7 新版功能.
类属性：
date.min-
最小的日期
date(MINYEAR, 1, 1)。In [11]: date.min Out[11]: datetime.date(1, 1, 1)
date.max-
最大的日期 ，
date(MAXYEAR, 12, 31)。In [12]: date.max Out[12]: datetime.date(9999, 12, 31)
date.resolution-
两个日期对象的最小间隔，
timedelta(days=1)。In [13]: date.resolution Out[13]: datetime.timedelta(days=1)
实例属性（只读）：
date.month-
1 至 12（含）
date.day-
返回1到指定年月的天数间的数字。
In [17]: x = date.today() In [18]: x.year Out[18]: 2020 In [19]: x.month Out[19]: 8 In [20]: x.day Out[20]: 24
支持的运算：
|
运算 |
结果： |
|---|---|
|
|
date2 等于从 date1 减去 |
|
|
计算 date2 的值使得 |
|
|
(3) |
|
|
如果 date1 的时间在 date2 之前则认为 date1 小于 date2 。 (4) |
In [23]: date(2020,1,1) Out[23]: datetime.date(2020, 1, 1) In [24]: d = date(2020,1,1) In [25]: from datetime import timedelta In [26]: timedelta? Init signature: timedelta(self, /, *args, **kwargs) Docstring: Difference between two datetime values. timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) All arguments are optional and default to 0. Arguments may be integers or floats, and may be positive or negative. File: /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.7/lib/python3.7/datetime.py Type: type Subclasses: In [27]: time_d = timedelta(days=5) In [28]: d + time_d Out[28]: datetime.date(2020, 1, 6) In [29]: d - time_d Out[29]: datetime.date(2019, 12, 27) In [30]: d2 = date.today() In [31]: d2 - d Out[31]: datetime.timedelta(days=236) In [32]: d < d2 Out[32]: True In [33]:
注释:
-
如果
timedelta.days > 0则 date2 在时间线上前进，如果timedelta.days < 0则后退。 操作完成后date2 - date1 == timedelta.days。timedelta.seconds和timedelta.microseconds会被忽略。如果date2.year将小于MINYEAR或大于MAXYEAR则会引发OverflowError。. -
timedelta.seconds和timedelta.microseconds会被忽略。 -
精确且不会溢出。 操作完成后 timedelta.seconds 和 timedelta.microseconds 均为0， 并且 date2 + timedelta == date1。
-
换句话说，当且仅当
date1.toordinal() < date2.toordinal()时date1 < date2。 日期比较会引发TypeError，如果比较目标不为date对象的话。 不过也可能会返回NotImplemented，如果比较目标具有timetuple()属性的话。 这个钩子给予其他日期对象类型实现混合类型比较的机会。 否则，当date对象与不同类型的对象比较时将会引发TypeError，除非==或!=比较。 后两种情况将分别返回False或True。
日期可以作为字典的关键字。在布尔上下文中，所有的 date 对象都视为真。
实例方法：
date.replace(year=self.year, month=self.month, day=self.day)-
返回一个具有同样值的日期，除非通过任何关键字参数给出了某些形参的新值。 例如，如果
d == date(2002, 12, 31)，则d.replace(day=26) == date(2002, 12, 26)。In [37]: d Out[37]: datetime.date(2020, 1, 1) In [38]: d.replace? Docstring: Return date with new specified fields. Type: builtin_function_or_method In [39]: d.replace(year=1999) Out[39]: datetime.date(1999, 1, 1) In [40]: d Out[40]: datetime.date(2020, 1, 1) In [41]: d.replace(month=6) Out[41]: datetime.date(2020, 6, 1) In [42]: d.replace(day=22) Out[42]: datetime.date(2020, 1, 22) In [43]:
date.timetuple()-
返回一个
time.struct_time，即与time.localtime()的返回类型相同。 hours, minutes 和 seconds 值为 0, 且 DST 标志值为 -1。d.timetuple()等价于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() + 1是日期在当前年份中的序号，起始序号1表示 1 月 1 日。In [44]: d.timetuple() Out[44]: time.struct_time(tm_year=2020, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=1, tm_isdst=-1) In [45]: time.localtime() Out[45]: time.struct_time(tm_year=2020, tm_mon=8, tm_mday=24, tm_hour=10, tm_min=34, tm_sec=41, tm_wday=0, tm_yday=237, tm_isdst=0) In [46]:
date.toordinal()-
返回日期的预期格列高利历序号，其中公元 1 年 1 月 1 日的序号为 1。 对于任意
date对象 d，date.fromordinal(d.toordinal()) == d。In [49]: d.toordinal() Out[49]: 737425 In [50]: d Out[50]: datetime.date(2020, 1, 1) In [51]:
date.weekday()-
返回一个整数代表星期几，星期一为0，星期天为6。例如，
date(2002, 12, 4).weekday() == 2，表示的是星期三。参阅isoweekday()。
date.isoweekday()-
返回一个整数代表星期几，星期一为1，星期天为7。例如：
date(2002, 12, 4).isoweekday() == 3,表示星期三。参见weekday(),isocalendar()。In [54]: d2.weekday() Out[54]: 0 In [55]: d2 Out[55]: datetime.date(2020, 8, 24) In [56]: d2.isoweekday() Out[56]: 1 In [57]:
date.isocalendar()-
返回一个三元元组，(ISO year, ISO week number, ISO weekday) 。
ISO日历是一个被广泛使用的公历。可以从 https://www.staff.science.uu.nl/~gent0113/calendar/isocalendar.htm 上查看更完整的说明。
ISO 年由 52 或 53 个完整星期构成，每个星期开始于星期一结束于星期日。 一个 ISO 年的第一个星期就是（格列高利）历法的的一年中第一个包含星期四的星期。 这被称为 1 号星期，其中星期四所在的 ISO 年与其所在的格列高利年相同。
例如，2004 年的第一天是一个星期四，因此 ISO 2004 年的第一个星期开始于 2003 年 12 月 29 日星期一，结束于 2004 年 1 月 4 日星期日，因此
date(2003, 12, 29).isocalendar() == (2004, 1, 1)anddate(2004, 1, 4).isocalendar() == (2004, 1, 7)。In [58]: d2.isocalendar() Out[58]: (2020, 35, 1) In [59]: d2 Out[59]: datetime.date(2020, 8, 24)
date.isoformat()-
返回一个 ISO 8601 格式的字符串， 'YYYY-MM-DD'。例如
date(2002, 12, 4).isoformat() == '2002-12-04'。
date.__str__()-
对于日期对象 d,
str(d)等价于d.isoformat()。In [60]: d2.isoformat() Out[60]: '2020-08-24' In [61]: d2.__str__() Out[61]: '2020-08-24' In [62]:
date.ctime()-
返回一个代表日期的字符串，例如
date(2002, 12, 4).ctime() == 'Wed Dec 4 00:00:00 2002'。 在原生 Cctime()函数 (time.ctime()会发起调用该函数，但date.ctime()则不会) 遵循 C 标准的平台上，d.ctime()等价于time.ctime(time.mktime(d.timetuple()))。In [68]: d2 Out[68]: datetime.date(2020, 8, 24) In [69]: d2.ctime() Out[69]: 'Mon Aug 24 00:00:00 2020' In [70]:
date.strftime(format)-
返回一个由显式格式字符串所指明的代表日期的字符串。 表示时、分或秒的格式代码值将为 0。 要获取格式指令的完整列表请参阅 strftime() 和 strptime() 的行为。
In [71]: d2.strftime? Docstring: format -> strftime() style string. Type: builtin_function_or_method In [72]: d2.strftime('%y%m%d') Out[72]: '200824' In [73]:
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)
# 日期相减，然后取days参数
>>> 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.'
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, -
fold in [0, 1].
如果参数不在这些范围内，则抛出
ValueError异常。 -
In [3]: from datetime import datetime In [4]: datetime(2020,3,3) Out[4]: datetime.datetime(2020, 3, 3, 0, 0) In [5]: datetime(2020,3,3,22) Out[5]: datetime.datetime(2020, 3, 3, 22, 0) In [6]: datetime(2020,3,3,25) --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-6-5699f2fed949> in <module> ----> 1 datetime(2020,3,3,25) ValueError: hour must be in 0..23 In [7]:
- classmethod
datetime.today() -
返回当前的本地 datetime，
tzinfo值为None。 这等价于datetime.fromtimestamp(time.time())。 另请参阅now(),fromtimestamp()。In [14]: datetime.today() Out[14]: datetime.datetime(2020, 8, 26, 21, 58, 20, 829778) In [15]: import time In [16]: datetime.fromtimestamp(time.time()) Out[16]: datetime.datetime(2020, 8, 26, 21, 59, 4, 18675) In [17]:
- classmethod
datetime.now(tz=None) -
返回当前的本地 date 和 time。 如果可选参数 tz 为
None或未指定，这就类似于today()，但该方法会在可能的情况下提供比通过time.time()时间戳所获时间值更高的精度（例如，在提供了 Cgettimeofday()函数的平台上就可能做到）。如果 tz 不为
None，它必须是tzinfo的子类的一个实例，并且当前日期和时间将转换为 tz 时区的日期和时间。 在这种情况下结果等价于tz.fromutc(datetime.utcnow().replace(tzinfo=tz))。 另请参阅today(),utcnow()。In [17]: datetime.now() Out[17]: datetime.datetime(2020, 8, 26, 21, 59, 48, 408120) In [18]:
- classmethod
datetime.utcnow() -
返回当前 UTC 日期和时间，其中
tzinfo为None。 这类似于now()，但返回的当前 UTC 日期和时间是一个本机datetime对象。 自动感知的当前 UTC 日期时间可通过调用datetime.now(timezone.utc)来获得。 另请参阅now()。In [18]: datetime.utcnow() Out[18]: datetime.datetime(2020, 8, 26, 14, 0, 37, 579810) In [19]:
- 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，如果时间戳数值超出所在平台 Clocaltime()或gmtime()函数的支持范围的话，并会在localtime()或gmtime()出错时引发OSError。 通常该数值会被限制在 1970 年至 2038 年之间。 请注意在时间戳概念包含闰秒的非 POSIX 系统上，闰秒会被fromtimestamp()所忽略，结果可能导致两个相差一秒的时间戳产生相同的datetime对象。 另请参阅utcfromtimestamp()。在 3.3 版更改: 引发
OverflowError而不是ValueError，如果时间戳数值超出所在平台 Clocaltime()或gmtime()函数的支持范围的话。 并会在localtime()或gmtime()出错时引发OSError而不是ValueError。在 3.6 版更改:
fromtimestamp()可能返回fold值设为 1 的实例。
- classmethod
datetime.utcfromtimestamp(timestamp) -
返回对应于 POSIX 时间戳的 UTC
datetime，其中tzinfo为None。 这可能引发OverflowError，如果时间戳数值超出所在平台 Cgmtime()函数的支持范围的话，并会在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。In [30]: datetime.fromordinal(5) Out[30]: datetime.datetime(1, 1, 5, 0, 0) In [31]:
- 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 参数。
In [35]: d = dt.date.today() In [36]: t = dt.time() In [37]: d Out[37]: datetime.date(2020, 8, 26) In [38]: t Out[38]: datetime.time(0, 0) In [39]: datetime.combine(d,t) Out[39]: datetime.datetime(2020, 8, 26, 0, 0) In [40]:
- 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。In [40]: d = datetime.now() In [41]: d Out[41]: datetime.datetime(2020, 8, 26, 22, 11, 37, 816059) In [42]: d_iso = d.isoformat() In [43]: d_iso Out[43]: '2020-08-26T22:11:37.816059' In [44]: datetime.fromisoformat(d_iso) Out[44]: datetime.datetime(2020, 8, 26, 22, 11, 37, 816059) In [45]:
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() 的行为。In [45]: datetime.strptime('2020-08-21 09:30:08.256000','%Y-%m-%d %H:%M:%S.%f') Out[45]: datetime.datetime(2020, 8, 21, 9, 30, 8, 256000)
类属性：
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)。In [51]: datetime.min Out[51]: datetime.datetime(1, 1, 1, 0, 0) In [52]: datetime.max Out[52]: datetime.datetime(9999, 12, 31, 23, 59, 59, 999999) In [53]: datetime.resolution Out[53]: datetime.timedelta(microseconds=1)
实例属性（只读）：
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 新版功能.
In [54]: d = datetime.today() In [55]: d.year Out[55]: 2020 In [56]: d.month Out[56]: 8 In [57]: d.day Out[57]: 26 In [58]: d.hour Out[58]: 22 In [59]: d.minute Out[59]: 15 In [60]: d.second Out[60]: 26 In [61]: d.microsecond Out[61]: 79193 In [62]: t.tzinfo In [63]: t.fold Out[63]: 0 In [64]:
支持的运算：
|
运算 |
结果： |
|---|---|
|
|
(1) |
|
|
(2) |
|
|
(3) |
|
|
-
datetime2 是从中去掉的一段 timedelta 的结果，如果
timedelta.days> 0 则是在时间线上前进，如果timedelta.days< 0 则后退。 结果具有与输入的 datetime 相同的tzinfo属性，并且操作完成后 datetime2 - datetime1 == timedelta。 如果 datetime2.year 将小于MINYEAR或大于MAXYEAR则会引发OverflowError。 请注意即使输入的是一个感知型对象，该方法也不会进行时区调整。 -
计算 datetime2 使得 datetime2 + timedelta == datetime1。 与相加操作一样，结果具有与输入的 datetime 相同的
tzinfo属性，即使输入的是一个感知型对象，该方法也不会进行时区调整。 -
从一个
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())除非具体实现绝对不溢出。 -
当 datetime1 的时间在 datetime2 之前则认为 datetime1 小于 datetime2。
如果比较的一方是简单型而另一方是感知型，则如果尝试进行顺序比较将引发
TypeError。 对于相等比较，简单型实例将永远不等于感知型实例。如果两个比较方都是感知型，且具有相同的
tzinfo属性，相同的tzinfo属性会被忽略并对基本日期时间值进行比较。 如果两个比较方都是感知型且具有不同的tzinfo属性，两个比较方将首先通过减去它们的 UTC 差值（使用self.utcoffset()获取）来进行调整。注解
为了防止比较操作回退为默认的对象地址比较方案，datetime 比较通常会引发
TypeError，如果比较目标不同样为datetime对象的话。 不过也可能会返回NotImplemented如果比较目标具有timetuple()属性的话。 这个钩子给予其他日期对象类型实现混合类型比较的机会。 否则，当datetime对象与不同类型的对象比较时将会引发TypeError，除非==或!=比较。 后两种情况将分别返回False或True。In [72]: d1 Out[72]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553) In [73]: d1 Out[73]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553) In [74]: d2 Out[74]: datetime.datetime(2020, 8, 26, 22, 33, 30, 687943) In [75]: timedelta Out[75]: datetime.timedelta(seconds=6, microseconds=125390) In [76]: d1 + timedelta == d2 Out[76]: True In [77]: d1 < d2 Out[77]: True In [78]:
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对象。In [78]: d1 Out[78]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553) In [79]: d1.date() Out[79]: datetime.date(2020, 8, 26) In [80]: d1.time() Out[80]: datetime.time(22, 33, 24, 562553) In [81]: d1.timetz() Out[81]: datetime.time(22, 33, 24, 562553) In [82]:
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 而不必转换日期和时间值。In [82]: d1 Out[82]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553) In [83]: d1.replace(year=1999) Out[83]: datetime.datetime(1999, 8, 26, 22, 33, 24, 562553) In [84]:
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()的行为就类似于:def astimezone(self, tz): if self.tzinfo is tz: return self # 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. return tz.fromutc(utc)在 3.3 版更改: tz 现在可以被省略。
在 3.6 版更改:
astimezone()方法可以由简单型实例调用，这将假定其表示本地时间。
datetime.utcoffset()-
如果
tzinfo为None，则返回None，否则返回self.tzinfo.utcoffset(self)，并且在后者不返回None或者一个幅度小于一天的timedelta对象时将引发异常。在 3.7 版更改: UTC 时差不再限制为一个整数分钟值。
In [127]: d1.utcoffset() Out[127]: datetime.timedelta(seconds=28800) In [128]: d1 Out[128]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800), 'CST')) In [129]:
datetime.dst()-
如果
tzinfo为None，则返回None，否则返回self.tzinfo.dst(self)，并且在后者不返回None或者一个幅度小于一天的timedelta对象时将引发异常。在 3.7 版更改: DST 差值不再限制为一个整数分钟值。
In [129]: d1.dst() In [130]: d1 Out[130]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800), 'CST')) In [131]: d1.tzinfo.dst='ok' --------------------------------------------------------------------------- AttributeError Traceback (most recent call last) <ipython-input-131-84b14f89650b> in <module> ----> 1 d1.tzinfo.dst='ok' AttributeError: 'datetime.timezone' object attribute 'dst' is read-only
datetime.tzname()-
如果
tzinfo为None，则返回None，否则返回self.tzinfo.tzname(self)，如果后者不返回None或者一个字符串对象则将引发异常。In [133]: d1.tzname() Out[133]: 'CST' In [134]: d1 Out[134]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800), 'CST')) In [135]:
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。In [136]: d Out[136]: datetime.datetime(2020, 8, 27, 10, 15, 16, 594837) In [137]: d.timestamp() Out[137]: 1598494516.594837 In [138]: d.timetuple() Out[138]: time.struct_time(tm_year=2020, tm_mon=8, tm_mday=27, tm_hour=10, tm_min=15, tm_sec=16, tm_wday=3, tm_yday=240, tm_isdst=-1)
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。In [139]: d.utctimetuple() Out[139]: time.struct_time(tm_year=2020, tm_mon=8, tm_mday=27, tm_hour=10, tm_min=15, tm_sec=16, tm_wday=3, tm_yday=240, tm_isdst=0) In [140]:
datetime.toordinal()-
返回日期的预期格列高利历序号。 与
self.date().toordinal()相同。In [140]: d.toordinal() Out[140]: 737664
datetime.timestamp()-
返回对应于
datetime实例的 POSIX 时间戳。 返回值是与time.time()类似的float。简单型
datetime实例会假定为代表本地时间，并且此方法依赖于平台的 Cmktime()函数来执行转换。 由于在许多平台上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)
In [143]: d Out[143]: datetime.datetime(2020, 8, 27, 10, 15, 16, 594837) In [144]: d = d.replace(tzinfo=timezone.utc) In [145]: bj = d.astimezone(timezone(timedelta(hours=8))) In [146]: bj Out[146]: datetime.datetime(2020, 8, 27, 18, 15, 16, 594837, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800))) In [147]: d Out[147]: datetime.datetime(2020, 8, 27, 10, 15, 16, 594837, tzinfo=datetime.timezone.utc) In [148]: bj.timestamp() Out[148]: 1598523316.594837 In [149]: d.timestamp() Out[149]: 1598523316.594837
datetime.weekday()-
返回一个整数代表星期几，星期一为 0，星期天为 6。 相当于
self.date().weekday()。 另请参阅isoweekday()。In [152]: d Out[152]: datetime.datetime(2020, 8, 27, 10, 15, 16, 594837, tzinfo=datetime.timezone.utc) In [153]: d.weekday Out[153]: <function datetime.weekday> In [154]: d.weekday() Out[154]: 3 In [155]:
datetime.isoweekday()-
返回一个整数代表星期几，星期一为 1，星期天为 7。 相当于
self.date().isoweekday()。 另请参阅weekday(),isocalendar()。In [155]: d.isoweekday() Out[155]: 4 In [156]:
datetime.isocalendar()-
返回一个 3 元组 (ISO 年份, ISO 周序号, ISO 周日期)。 相当于
self.date().isocalendar()。In [156]: d.isocalendar() Out[156]: (2020, 35, 4) In [157]:
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') 为单个分隔字符，会被放在结果的日期和时间两部分之间。例如
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'
可选参数 timespec 要包含的额外时间组件值 (默认为 'auto')。它可以是以下值之一：
-
'auto': 如果microsecond为 0 则与'seconds'相同，否则与'microseconds'相同。 -
'hours': 以两个数码的 HH 格式包含hour。 -
'milliseconds': 包含完整时间，但将秒值的小数部分截断至微秒。 格式为 HH:MM:SS.sss。 -
'microseconds': 以HH:MM:SS.ffffff 格式包含完整时间。
注解
排除掉的时间部分将被截断，而不是被舍入。
对于无效的 timespec 参数将引发 ValueError。
from datetime import datetime
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'
In [162]: d1.isoformat(sep='_') Out[162]: '2020-08-26_22:33:24.562553+08:00' In [163]: d1.isoformat(sep='=', timespec='hours') Out[163]: '2020-08-26=22+08:00' In [164]: d1 Out[164]: datetime.datetime(2020, 8, 26, 22, 33, 24, 562553, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800), 'CST')) In [165]:
-
3.6 新版功能: 增加了 timespec 参数。
datetime.__str__()-
对于
datetime实例 d，str(d)等价于d.isoformat(' ')。In [12]: d Out[12]: datetime.datetime(2020, 9, 1, 14, 7, 6, 950061) In [13]: d.__str__() Out[13]: '2020-09-01 14:07:06.950061' In [14]: str(d) Out[14]: '2020-09-01 14:07:06.950061' In [15]: d.isoformat(sep=' ') Out[15]: '2020-09-01 14:07:06.950061' In [16]:
datetime.ctime()-
返回一个代表日期和时间的字符串，例如
datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec 4 20:30:40 2002'。 在原生 Cctime()函数 (time.ctime()会发起调用该函数，但datetime.ctime()则不会) 遵循 C 标准的平台上，d.ctime()等价于time.ctime(time.mktime(d.timetuple()))。In [16]: d Out[16]: datetime.datetime(2020, 9, 1, 14, 7, 6, 950061) In [17]: d.ctime() Out[17]: 'Tue Sep 1 14:07:06 2020' In [18]: import time In [19]: time.ctime(time.mktime(d.timetuple())) Out[19]: 'Tue Sep 1 14:07:06 2020' In [20]: time.ctime() Out[20]: 'Tue Sep 1 14:10:08 2020' In [21]: time.ctime(98765432) Out[21]: 'Sat Feb 17 10:50:32 1973' In [22]: time.mktime() --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-22-d66cbbbd63d1> in <module> ----> 1 time.mktime() TypeError: mktime() takes exactly one argument (0 given) In [23]: time.mktime(time.localtime()) Out[23]: 1598940644.0 In [24]: d.timetuple() Out[24]: time.struct_time(tm_year=2020, tm_mon=9, tm_mday=1, tm_hour=14, tm_min=7, tm_sec=6, tm_wday=1, tm_yday=245, tm_isdst=-1) In [25]: time.localtime() Out[25]: time.struct_time(tm_year=2020, tm_mon=9, tm_mday=1, tm_hour=14, tm_min=11, tm_sec=10, tm_wday=1, tm_yday=245, tm_isdst=0) In [26]: time.gmtime() Out[26]: time.struct_time(tm_year=2020, tm_mon=9, tm_mday=1, tm_hour=6, tm_min=11, tm_sec=17, tm_wday=1, tm_yday=245, tm_isdst=0) In [27]:
datetime.strftime(format)-
返回一个由显式格式字符串所指明的代表日期和时间的字符串， 要获取格式指令的完整列表请参阅 strftime() 和 strptime() 的行为。
datetime.__format__(format)-
与
datetime.strftime()相同。 此方法使得为datetime对象指定以 格式化字符串字面值 表示的格式化字符串以及使用str.format()进行格式化成为可能。 要获取格式指令的完整列表，请参阅 strftime() 和 strptime() 的行为。
使用 datetime 对象的例子:
In [29]: from datetime import datetime, date, time
In [30]: d = date(2005,7,14)
In [31]: t = time(12,30)
In [32]: datetime.combine(d,t)
Out[32]: datetime.datetime(2005, 7, 14, 12, 30)
In [33]: datetime.now()
Out[33]: datetime.datetime(2020, 9, 1, 14, 14, 0, 301874)
In [34]: datetime.utcnow()
Out[34]: datetime.datetime(2020, 9, 1, 6, 14, 13, 544549)
In [35]: dt = datetime.strptime('21/11/06 16:30', "%d/%m/%y %H:%M")
In [36]: dt
Out[36]: datetime.datetime(2006, 11, 21, 16, 30)
In [37]: tt = dt.timetuple()
In [38]: tt
Out[38]: time.struct_time(tm_year=2006, tm_mon=11, tm_mday=21, tm_hour=16, tm_min=30, tm_sec=0, tm_wday=1, tm_yday=325, tm_isdst=-1)
In [39]: for it in tt:
...: print(it)
...:
2006
11
21
16
30
0
1
325
-1
In [40]: ic = dt.isocalendar()
In [41]: ic
Out[41]: (2006, 47, 2)
In [42]: for it in ic:
...: print(it)
...:
2006
47
2
In [43]: dt
Out[43]: datetime.datetime(2006, 11, 21, 16, 30)
In [44]: dt.strftime("%A, %d. %B %Y %I:%M%p")
Out[44]: 'Tuesday, 21. November 2006 04:30PM'
In [45]: 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
Out[45]: 'The day is 21, the month is November, the time is 04:30PM.'
使用 datetime 并附带 tzinfo:
from datetime import timedelta, datetime, tzinfo, timezone
class KabulTz(tzinfo):
# Kabul used +4 until 1945, when they moved to +4:30
UTC_MOVE_DATE = datetime(1944, 12, 31, 20, tzinfo=timezone.utc)
def utcoffset(self, dt):
if dt.year < 1945:
return timedelta(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
return timedelta(hours=4, minutes=(30 if dt.fold else 0))
else:
return timedelta(hours=4, minutes=30)
def fromutc(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
if not isinstance(dt, datetime):
raise TypeError("fromutc() requires a datetime argument")
if dt.tzinfo is not self:
raise ValueError("dt.tzinfo is not self")
if dt.replace(tzinfo=timezone.utc) >= self.UTC_MOVE_DATE:
return dt + timedelta(hours=4, minutes=30)
else:
return dt + timedelta(hours=4)
def dst(self, dt):
return timedelta(0)
def tzname(self, dt):
if dt >= self.UTC_MOVE_DATE:
return "+04:30"
else:
return "+04"
def __repr__(self):
return f"{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
time 对象
一个 time 对象代表某个日期内的（本地）时间，它独立于任何特定日期，并可通过 tzinfo 对象来调整。
- class
datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0) -
所有参数都是可选的。 tzinfo 可以是
None，或者是一个tzinfo子类的实例。 其余的参数必须是在下面范围内的整数：-
0 <= hour < 24, -
0 <= minute < 60, -
0 <= second < 60, -
0 <= microsecond < 1000000, -
fold in [0, 1].
如果给出一个此范围以外的参数，则会引发
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对象并不支持算术运算。In [48]: time Out[48]: datetime.time In [49]: time.min Out[49]: datetime.time(0, 0) In [50]: time.max Out[50]: datetime.time(23, 59, 59, 999999) In [51]: time.resolution Out[51]: datetime.timedelta(microseconds=1)
实例属性（只读）：
time.hour-
取值范围是
range(24)。
time.minute-
取值范围是
range(60)。
time.second-
取值范围是
range(60)。
time.microsecond-
取值范围是
range(1000000)。
time.tzinfo-
作为 tzinfo 参数被传给
time构造器的对象，如果没有传入值则为None。
time.fold-
取值范围是
[0, 1]。 用于在重复的时间段中消除边界时间歧义。 （当夏令时结束时回调时钟或由于政治原因导致当前时区的 UTC 时差减少就会出现重复的时间段。） 取值 0 (1) 表示两个时刻早于（晚于）所代表的同一边界时间。3.6 新版功能.
In [52]: t = time(12,12,12) In [53]: t.hour Out[53]: 12 In [54]: t.minute Out[54]: 12 In [55]: t.second Out[55]: 12 In [56]: t.microsecond Out[56]: 0 In [57]: t.tzinfo In [58]: t.fold Out[58]: 0
支持的运算：
-
比较
time和另一个time，当 a 的时间在 b 之前时，则认为 a 小于 b。 如果比较的一方是简单型而另一方是感知型，则如果尝试进行顺序比较将引发TypeError。 对于相等比较，简单型实例将永远不等于感知型实例。如果两个比较方都是感知型，且具有相同的
tzinfo属性，相同的tzinfo属性会被忽略并对基本时间值进行比较。 如果两个比较方都是感知型且具有不同的tzinfo属性，两个比较方将首先通过减去它们的 UTC 差值（使用self.utcoffset()获取）来进行调整。 为了防止将混合类型比较回退为基于对象地址的默认比较，当time对象与不同类型的对象比较时，将会引发TypeError，除非比较运算符是==或!=。 在后一种情况下将分别返回False或True。 -
哈希，以便用作字典的键
-
高效的封存
在布尔运算时，time 对象总是被视为真值。
在 3.5 版更改: 在 Python 3.5 之前，如果一个 time 对象代表 UTC 午夜零时则会被视为假值。 此行为被认为容易引发困惑和错误，因此从 Python 3.5 起已被去除。 详情参见 bpo-13936。
其他构造方法：
- classmethod
time.fromisoformat(time_string) -
返回对应于
time.isoformat()所提供的 time_string 格式的time。 特别地此函数支持HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]格式的字符串。警告
此方法不支持解析任意 ISO 8601 字符串 —— 它的目的只是作为
time.isoformat()的逆操作。3.7 新版功能.
实例方法：
time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)-
返回一个具有同样属性值的
time，除非通过任何关键字参数指定了某些属性值。 请注意可以通过指定tzinfo=None从一个感知型time创建一个简单型time而不必转换时间值。3.6 新版功能: 增加了
fold参数。
time.isoformat(timespec='auto')-
返回一个表示时间的字符串，使用 ISO 8601 格式 HH:MM:SS.ffffff，或者如果
microsecond为 0 则改用格式 HH:MM:SS， 如果utcoffset()不返回None，则会添加一个字符串来给出 UTC 时差: HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]，或者如果 self.microsecond 为 0 则改用格式 HH:MM:SS+HH:MM[:SS[.ffffff]]。可选参数 timespec 要包含的额外时间组件值 (默认为
'auto')。它可以是以下值之一：-
'auto': 如果microsecond为 0 则与'seconds'相同，否则与'microseconds'相同。 -
'hours': 以两个数码的 HH 格式包含hour。 -
'milliseconds': 包含完整时间，但将秒值的小数部分截断至微秒。 格式为 HH:MM:SS.sss。 -
'microseconds': 以HH:MM:SS.ffffff 格式包含完整时间。
注解
排除掉的时间部分将被截断，而不是被舍入。
对于无效的 timespec 参数将引发
ValueError。 -
参考一个tzinfo的的例子，廖大的：https://www.liaoxuefeng.com/wiki/1016959663602400/1017648783851616
# 拿到UTC时间，并强制设置时区为UTC+0:00: >>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc) >>> print(utc_dt) 2015-05-18 09:05:12.377316+00:00 # astimezone()将转换时区为北京时间: >>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8))) >>> print(bj_dt) 2015-05-18 17:05:12.377316+08:00 # astimezone()将转换时区为东京时间: >>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9))) >>> print(tokyo_dt) 2015-05-18 18:05:12.377316+09:00 # astimezone()将bj_dt转换时区为东京时间: >>> tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9))) >>> print(tokyo_dt2) 2015-05-18 18:05:12.377316+09:00
时区转换的关键在于，拿到一个datetime时，要获知其正确的时区，然后强制设置时区，作为基准时间。
利用带时区的datetime，通过astimezone()方法，可以转换到任意时区。
注：不是必须从UTC+0:00时区转换到其他时区，任何带时区的datetime都可以正确转换，例如上述bj_dt到tokyo_dt的转换。
小结
datetime表示的时间需要时区信息才能确定一个特定的时间，否则只能视为本地时间。
如果要存储datetime，最佳方法是将其转换为timestamp再存储，因为timestamp的值与时区完全无关。
下面这些老的资料就当留着给自己记录一下以前的心酸历史。
网上查了点资料，书上看了一些，准备挑一些自己认为的重点讲一下算了。
先说一下datetime.datetime好了，以前我就一直会用datetime.datetime.now()
当运行一个d1=datetime.datetime.now()或者d1=datetime.datetime.(2019,1,1)
其实本质是在完成实例化，所以，该对象d1会又很多定义的方法，属性。
由于是对实例的操作，不同的实例之间还能进行一些加减操作，返回datetime.timedelta对象。
In [244]: d1 = datetime.datetime(1985,11,5) In [245]: d2 = datetime.datetime.now() In [246]: isinstance(d1,datetime.datetime) Out[246]: True In [247]: d1-d2 Out[247]: datetime.timedelta(days=-12425, seconds=74030, microseconds=689037) In [248]: d1.isoweekday Out[248]: <function datetime.isoweekday> In [249]: d1.isoweekday() Out[249]: 2
In [251]: datetime.datetime.fromtimestamp(time.time())
Out[251]: datetime.datetime(2019, 11, 11, 3, 35, 10, 555170)
In [252]: datetime.datetime.now()
Out[252]: datetime.datetime(2019, 11, 11, 3, 35, 18, 959855)
datetime.datetime.fromtimestamp(time.time()) 还可以用时间戳来创建一个时间对象。
这里简单的做了一个代码说明，对象又很多属性。（我感觉可能比较使用的准备标注红色）
datetime 实例方法：
datetime.date()
- 返回一个 date 对象datetime.time() - 返回一个 time 对象（tzinfo 属性为 None）
datetime.timetz()
- 返回一个 time() 对象（带有 tzinfo 属性）
datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
- 生成一个新的日期对象，用参数指定日期和时间代替原有对象中的属性
datetime.astimezone(tz=None)
- 传入一个新的 tzinfo 属性，返回根据新时区调整好的 datetime 对象
datetime.utcoffset()
- 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.utcoffset(self)
datetime.dst()
- 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.dst(self)
datetime.tzname()
- 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.tzname(self)
datetime.timetuple()
- 返回日期对应的 time.struct_time 对象（类似于 time 模块的 time.localtime()）
datetime.utctimetuple()
- 返回 UTC 日期对应的 time.struct_time 对象
datetime.toordinal()
- 返回日期对应的 Gregorian Calendar 日期（类似于 self.date().toordinal()）
datetime.timestamp()
- 返回当前时间的时间戳（类似于 time 模块的 time.time()）
datetime.weekday()
- 返回 0 ~ 6 表示星期几（星期一是 0，依此类推）
datetime.isoweekday()
- 返回 1 ~ 7 表示星期几（星期一是1， 依此类推）
datetime.isocalendar()
返回一个三元组格式 (year, week, day) # 第二个元素是“year中的第几周”，第三个元素是“该周的第几天”
datetime.isoformat(sep='T')
- 返回一个 ISO 8601 格式的日期字符串，如 "YYYY-MM-DD" 的字符串
datetime.__str__()
- 对于 date 对象 d 来说，str(d) 相当于 d.isoformat()
datetime.ctime()
- 返回一个表示日期的字符串，相当于 time 模块的 time.ctime(time.mktime(d.timetuple()))
datetime.strftime(format)
- 返回自定义格式化字符串表示日期，下面有详解
datetime.__format__(format)
- 跟 datetime.strftime(format) 一样，这使得调用 str.format() 时可以指定 data 对象的字符串
其实看的过程中，我觉的最方便的还是datetime.timedelta,这个能非常方便的让你找到前一天或者后一天的日期。
In [254]: d2 Out[254]: datetime.datetime(2019, 11, 11, 3, 26, 9, 310963) In [255]: t_pass = datetime.timedelta(2) In [256]: d2+t_pass Out[256]: datetime.datetime(2019, 11, 13, 3, 26, 9, 310963) In [257]: d2 -t_pass Out[257]: datetime.datetime(2019, 11, 9, 3, 26, 9, 310963)
一个 datetime.timedelta 类，你需要将指定的时间段传递给类的构造函数。可选参数包含：weeks,days (默认), hours, minutes, seconds, microseconds
最后讲一下strftime方法，里面的参数跟time.strftime函数里面的差不多。
| 格式化指令 | 含义 |
| %a | 星期的简写（星期一 ~ 天：Mon, Tue, Wed, Thu, Fri, Sat, Sun） |
| %A | 星期的全写（星期一 ~ 天：Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday） |
| %w | 在一个星期中的第几天（ 0 表示星期天 ... 6 表示星期六） |
| %d | 在一个月中的第几天（01, 02, ..., 31） |
| %b | 月份的简写（一月 ~ 十二月：Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec） |
| %B | 月份的全写（一月 ~ 十二月：January, February, March, April, May, June, July, August, September, October, November, December） |
| %m | 月份（01, 02, ..., 12） |
| %y | 用两个数字表示年份（例如 2014年 == 14） |
| %Y | 用四个数字表示年份 |
| %H | 二十四小时制（00, 01, ..., 23） |
| %I | 十二小时制（01, 02, ..., 11） |
| %p | AM 或者 PM |
| %M | 分钟（00, 01, ..., 59） |
| %S | 秒（00, 01, ..., 59） |
| %f | 微秒（000000, 000001, ..., 999999） |
| %z | 与 UTC 时间的间隔 ；如果是本地时间，返回空字符串（(empty), +0000, -0400, +1030） |
| %Z | 时区名称；如果是本地时间，返回空字符串（(empty), UTC, EST, CST） |
| %j | 在一年中的第几天（001, 002, ..., 366） |
| %U | 在一年中的第几周，星期天作为第一天（00, 01, ..., 53） |
| %W | 在一年中的第几周，星期一作为第一天（00, 01, ..., 53） |
| %c | 用字符串表示日期和时间（Tue Aug 16 21:30:00 2014） |
| %x | 用字符串表示日期（08/16/14） |
| %X | 用字符串表示时间（21:30:00） |
| %% | 表示百分号 |
可以再对象后面根据需要填写参数。
In [258]: d2 Out[258]: datetime.datetime(2019, 11, 11, 3, 26, 9, 310963)
# 时间对象装换为字符串 In [259]: d2.strftime('%Y-%m-%d:%H.%M.%s') Out[259]: '2019-11-11:03.26.1573413969'
In [260]: d2.strftime('%Y-%m-%d:%H.%M.%S') Out[260]: '2019-11-11:03.26.09' In [261]: d2.strftime('%A %Y-%m-%d:%H.%M.%S') Out[261]: 'Monday 2019-11-11:03.26.09'
datetime的模块就重点这里讲一些，后面三个参考链接。有需要用的到，可以参考下。
今天需要将一个字符串转换为datetime对象，记录下。
2019-03-17 11：00：00格式转化
import datetime
# str转时间格式：
dd = '2019-03-17 11:00:00'
dd = datetime.datetime.strptime(dd, "%Y-%m-%d %H:%M:%S")
print(dd,type(dd))
# 时间格式转str:
dc = dd.strftime("%Y-%m-%d %H:%M:%S")
print(dc,type(dc))
输出：2019-03-17 11:00:00 <class 'datetime.datetime'>
2019-03-17 11:00:00 <class 'str'>
20190616格式转化
# str转时间格式：
dd = '20190317'
dd = datetime.datetime.strptime(dd, "%Y%m%d")
print(dd,type(dd))
# 时间格式转str:
dc = dd.strftime("%Y%m%d")
print(dc,type(dc))
Python中对两个datetime对象取时间差，一个可以取日期用days属性，还有一个就是用total_seconds
就是没有分与小时的属性，可以自己除以60或者3600计算。
在python中经常会用到计算两个时间差，两个日期类型进行相减可以获取到时间差。
经常会使用seconds来获取，其实seconds获取的是仅仅是时间差的秒数，忽略微秒数，忽略天数。
total_seconds()是获取两个时间之间的总差。
total_seconds() = (td.microseconds+ (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6 # td是timedelta对象
