Python常用模块4-Python的datetime及time模块简介_mdd.get_min_data_n(tdate=today-datetime.timedelta(

一.Python datetime模块介绍

datetime 模块提供了可以通过多种方式操作日期和时间的类。在支持日期时间数学运算的同时，实现的关注点更着重于如何能够更有效地解析其属性用于格式化输出和数据操作。

1.1 有效的类型

子类关系:

object
    timedelta
    tzinfo
        timezone
    time
    date
        datetime
1
2
3
4
5
6
7

1.2 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天。
1
2
3
4

days, seconds, microseconds 本身也是标准化的，以保证表达方式的唯一性，例：

0 <= microseconds < 1000000
0 <= seconds < 3600*24 (一天的秒数)
-999999999 <= days <= 999999999
1
2
3

在有任何浮点型参数或者微秒为小数的情况下，所有小数均会按照前面的换算规则叠加到下一级，并使用round-half-to-even的方法对微秒进行取舍。没有浮点型参数情况下，转换的过程就是精确的（没有信息丢失）。

如果标准化后的 days 数值超过了指定范围，将会抛出 OverflowError异常。

需要注意的是，负数被标准化后的结果会让你大吃一惊。例如:

E:\>python
Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> from datetime import timedelta
>>> d = timedelta(microseconds=-1)
>>> (d.days, d.seconds, d.microseconds)
(-1, 86399, 999999)
>>>
1
2
3
4
5
6
7
8

类属性
timedelta.min
最大的负数 ,timedelta(-999999999)

timedelta.max
最大的整数, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)

timedelta.resolution
两个相等的timedelta类对象最小的间隔为 timedelta(microseconds=1)

需要注意的是，因为标准化的缘故，timedelta.max > -timedelta.min，-timedelta.max 不可以表示一个 timedelta 类对象。

支持的运算：

1.2.1 timedelta.total_seconds()方法

需要注意的是，时间间隔较大时，这个方法的结果中的微秒将会失真（大多数平台上大于270年视为一个较大的时间间隔）。

>>> from datetime import timedelta
>>>
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23, minutes=50, seconds=600);
>>>
>>>
>>> year.total_seconds()
31536000.0
>>>
>>> year == another_year
True
>>>
>>> ten_years = 10 * year
>>> ten_years, ten_years.days
(datetime.timedelta(3650), 3650)
>>> nini_years = ten_years - year
>>>
>>> nine_years, nine_years.days
(datetime.timedelta(3285), 3285)
>>>
>>> three_years = nine_years // 3
>>> three_years, three_years.days
(datetime.timedelta(1095), 1095)
>>>
>>> abs(three_years - ten_years) == 2 * three_years + year
True
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1.3 date对象

date 对象代表一个理想化历法中的日期（年、月和日），即当今的格列高利历向前后两个方向无限延伸。公元 1 年 1 月 1 日是第 1 日，公元 1 年 1 月 2 日是第 2 日， 依此类推。 这与 Dershowitz 与 Reingold 所著 Calendrical Calculations 中“预期格列高利”历法的定义一致，它是适用于该书中所有运算的基础历法。 请参阅该书了解在预期格列高利历序列与许多其他历法系统之间进行转换的算法。

class datetime.date(year, month, day)
All arguments are required. Arguments may be integers, in the following ranges:

MINYEAR <= year <= MAXYEAR
1 <= month <= 12
1 <= 日期 <= 给定年月对应的天数
如果参数不在这些范围内，则抛出 ValueError 异常。

支持的运算:

实例方法:

计算距离特定事件天数的例子:

>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2021, 3, 10)
>>>
>>> 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(2021, 6, 24)
>>>
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
106
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

使用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      -- 年
3         -- 月
11        -- 日
0
0
0
0         -- weekday (0 = Monday)
70        -- 70th dya 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("%y%m%d")
'020311'
>>>
>>> d.strftime("%y-%m-%d")
'02-03-11'
>>> d.strftime("%Y-%m-%d")
'2002-03-11'
>>>
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

1.4 datetime对象

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

构造器:

实例属性（只读）：
如果参数不在这些范围内，则抛出 ValueError 异常。

支持的运算：

实例方法

使用 datetime 对象的例子:

>>> from datetime import datetime, date, time
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> datetime.now()
datetime.datetime(2021, 3, 10, 16, 10, 53, 787000)
>>>
>>> datetime.utcnow()
datetime.datetime(2021, 3, 10, 8, 11, 6, 212000)
>>>
>>> dt = datetime.strptime("2021-03-10 16:13:00", "%Y-%m-%d %H:%M:%S")
>>> dt
datetime.datetime(2021, 3, 10, 16, 13)
>>>
>>> dt = datetime.strptime("2021-03-10 16:13:10", "%Y-%m-%d %H:%M:%S")
>>> dt
datetime.datetime(2021, 3, 10, 16, 13, 10)
>>>
>>> tt = dt.timetuple()
>>> for it in tt:
...     print(it)
...
2021     -- 年
3        -- 月
10       -- 日
16       -- 小时
13       -- 分
10       -- 秒
2        -- weekday (2 = 周三)
69       -- 今年的第多少天
-1       -- 时区相关
>>>
>>> ic = dt.isocalendar()
>>> for it in ic:
...     print(it)
...
2021
10
3
>>>
>>> dt.strftime("%Y-%m-%d %H:%M:%S")
'2021-03-10 16:13:10'
>>>
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

1.5 time 对象

一个 time 对象代表某个日期内的（本地）时间，它独立于任何特定日期，并可通过 tzinfo 对象来调整。

类属性

实例属性（只读）

支持的运算：

1. 比较 time 和另一个 time，当 a 的时间在 b 之前时，则认为 a 小于 b。 如果比较的一方是简单型而另一方是感知型，则如果尝试进行顺序比较将引发 TypeError。 对于相等比较，简单型实例将永远不等于感知型实例。

2. 如果两个比较方都是感知型，且具有相同的 tzinfo 属性，相同的 tzinfo 属性会被忽略并对基本时间值进行比较。 如果两个比较方都是感知型且具有不同的 tzinfo 属性，两个比较方将首先通过减去它们的 UTC 差值（使用 self.utcoffset() 获取）来进行调整。 为了防止将混合类型比较回退为基于对象地址的默认比较，当 time 对象与不同类型的对象比较时，将会引发 TypeError，除非比较运算符是 == 或 !=。 在后一种情况下将分别返回 False 或 True。

3. 哈希，以便用作字典的键

4. 高效的封存

在布尔运算时，time 对象总是被视为真值。

实例方法

>>> from datetime import time, tzinfo, timedelta
>>> class GMT1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1)
...     def dst(self, dt):
...         return timedelta(0)
...     def tzname(self, dt):
...         return "Europe/Prague"
...
>>>
>>> t = time(12, 10, 30, tzinfo=GMT1())
>>> t
datetime.time(12, 10, 30, tzinfo=<__main__.GMT1 object at 0x0000000002882978>)
>>> gmt = gmt1()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'gmt1' is not defined
>>> gmt = GMT1()
>>>
>>> t.isoformat()
'12:10:30+01:00'
>>>
>>> t.dst()
datetime.timedelta(0)
>>>
>>> t.tzname()
'Europe/Prague'
>>>
>>> t.strftime("%H:%M:%S %Z")
'12:10:30 Europe/Prague'
>>>
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

1.6 tzinfo 对象

一个描述时区信息的抽象基类。用于给 datetime 类和 time 类提供自定义的时间调整概念（例如，负责时区或者夏令时）。

与时区相关，此处省略。

1.7 timezone 对象

一个实现了 tzinfo 抽象基类的子类，用于表示相对于 世界标准时间（UTC）的偏移量。

与时区相关，此处省略。

二.datetime模块实操

2.1 datetime模块常用方法案例

代码:

from datetime import datetime, date, time, timedelta

# 获取当前日期及时间
datetime_object = datetime.now()
print(datetime_object)

# 获取当前日期
datetime_object = date.today()
print(datetime_object)

# 打印今天的年，月和日
today = date.today()

print("当前年:",today.year)
print("当前月:",today.month)
print("当前日:",today.day)

# 打印 时分秒及微妙
t = time(17, 8, 21,1)

print("小时=", t.hour)
print("分钟=", t.minute)
print("秒=", t.second)
print("微秒=", t.microsecond)

# datetime类使用实例,并打印 年，月，时，分，秒及时间戳
a = datetime(2021, 3, 10)
print(a)

b = datetime(2021, 3, 10, 17, 12, 23, 22222)
print(b)

print("年 =", b.year)
print("月 =", b.month)
print("日 =", b.day)
print("时 =", b.hour)
print("分 =", b.minute)
print("秒 =", b.second)
print("微妙 =", b.microsecond)
print("时间戳 =", a.timestamp())

# timedelta 对象表示两个日期或时间之间的时差
t1 = date(2021, 3, 10)
t2 = date(2001, 1, 1)
t3 = t1 - t2
print("t3 = ", t3)

t4 = datetime(2021, 3, 10, 17, 12, 23, 22222)
t5 = datetime(2000, 1, 1, 0, 0, 0, 0)
t6 = t4 - t5
print("t6 = ",t6)

print("type of t3 =",type(t3))
print("type of t6 =",type(t6))

# 两个timedelta对象之间的时间差
t1 = timedelta(weeks = 2, days = 5, hours = 1, seconds = 33)
t2 = timedelta(days = 4, hours = 11, minutes = 4, seconds = 54)
t3 = t1 - t2

print("t3 =", t3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/datetime_test1.py
2021-03-10 17:23:49.158000
2021-03-10
当前年: 2021
当前月: 3
当前日: 10
小时= 17
分钟= 8
秒= 21
微秒= 1
2021-03-10 00:00:00
2021-03-10 17:12:23.022222
年 = 2021
月 = 3
日 = 10
时 = 17
分 = 12
秒 = 23
微妙 = 22222
时间戳 = 1615305600.0
t3 =  7373 days, 0:00:00
t6 =  7739 days, 17:12:23.022222
type of t3 = <class 'datetime.timedelta'>
type of t6 = <class 'datetime.timedelta'>
t3 = 14 days, 13:55:39

Process finished with exit code 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.2 格式日期时间

日期和时间的表示方式在不同的地方，组织等中可能有所不同。在美国，使用mm / dd / yyyy更为常见，而在英国使用dd / mm / yyyy更为常见。

Python有strftime()和strptime()方法来处理这个问题。

Python strftime()-字符串的日期时间对象
strftime()方法是在date、datetime和time类下面定义的。该方法根据给定的日期、日期时间或时间对象创建格式化的字符串。
本文以datetime举例说明，time里也是一样的

2.2.1 使用strftime()格式化日期

代码:

from datetime import datetime

now = datetime.now()

t = now.strftime("%Y-%m-%d %H:%M:%S")

print(t)

1
2
3
4
5
6
7
8

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/dattime_test2.py
2021-03-10 17:28:15

Process finished with exit code 0

1
2
3
4
5

2.2.2 Python strptime()-日期时间的字符串

代码:

from datetime import datetime

date_string = "1 October, 2020"
print("date_string =", date_string)

date_object = datetime.strptime(date_string, "%d %B, %Y")
print("date_object =", date_object)
1
2
3
4
5
6
7

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/datetime_test3.py
date_string = 1 October, 2020
date_object = 2020-10-01 00:00:00

Process finished with exit code 0
1
2
3
4
5

2.3 python 时间戳

代码:

from datetime import datetime

# 时间戳转为时间
timestamp = 1545730073
dt_object = datetime.fromtimestamp(timestamp)

print("dt_object =", dt_object)
print("type(dt_object) =", type(dt_object))

# 时间转为时间戳
dt = '2018-12-25 17:27:53'
dt2 = datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
dt_timestamp =  datetime.timestamp(dt2)

print("dt_timestamp =", dt_timestamp)
print("type(dt_timestamp) =", type(dt_timestamp))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/datetime_test4.py
dt_object = 2018-12-25 17:27:53
type(dt_object) = <class 'datetime.datetime'>
dt_timestamp = 1545730073.0
type(dt_timestamp) = <class 'float'>

Process finished with exit code 0

1
2
3
4
5
6
7
8

三.time模块简介

Python time.time()
time()函数返回自纪元以来经过的秒数。

这个地方用得比较多的是Python time.sleep()
sleep()函数在给定的秒数内暂停（延迟）当前线程的执行。

代码:

import time
import datetime
print("这是立即打印输出。",datetime.datetime.now())
time.sleep(4)
print("这是4秒后打印的。",datetime.datetime.now())

1
2
3
4
5
6

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/time_test1.py
这是立即打印输出。 2021-03-10 18:16:38.225000
这是4秒后打印的。 2021-03-10 18:16:42.225000

Process finished with exit code 0

1
2
3
4
5
6

参考:

1.https://docs.python.org/zh-cn/3.6/library/datetime.html
2.https://blog.csdn.net/kobeyu652453/article/details/108894807