time模块

time模块介绍

time模块是Python内置的处理日期和时间的模块，它提供了一些函数来处理时间和日期，包括获取当前时间、时间格式化、计算时间差等等。

要使用 time 模块必须先导入：

import time

查看 time模块中的内容:

>>> import time
>>> dir(time)
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']

time() -时间戳

Python time time() 返回当前时间的时间戳（1970纪元后经过的浮点秒数），即从 "1970 年 1 月 1 日 00:00:00" UTC 到当前时间的秒数。

语法：

time.time()

参数

• 无参数。

返回值

​ 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

实例

import time
print("time.time(): %f " %  time.time())

以上实例输出结果为：

time.time(): 1234892919.655932

时间戳转换为时间对象

localtime([sec]) -将当前时间转换为本地时间

Python time localtime() 函数类似gmtime()，作用是格式化时间戳为本地的时间。 如果sec参数未输入，则以当前时间为转换标准。

语法：

time.localtime([sec])

参数

• sec -- 表示从1970-1-1以来的秒数（时间戳），可选参数，默认为当前时间。

返回值

​ 返回一个包含当前日期和时间的 struct_time 对象，struct_time是在time模块中定义的表示时间的对象。

实例

import time

print("time.localtime() : " , time.localtime())
print("time.localtime(time.time()) : " , time.localtime(time.time()))

以上实例输出结果为：

time.localtime() :  time.struct_time(tm_year=2023, tm_mon=10, tm_mday=21, tm_hour=10, tm_min=15, tm_sec=51, tm_wday=5, tm_yday=294, tm_isdst=0)
time.localtime(time.time()) :  time.struct_time(tm_year=2023, tm_mon=10, tm_mday=21, tm_hour=10, tm_min=15, tm_sec=51, tm_wday=5, tm_yday=294, tm_isdst=0)

gmtime([sec])-将当前时间转换为 UTC 时间

Python time gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct_time，可选的参数sec表示从1970-1-1以来的秒数。其默认值为time.time()，函数返回time.struct_time类型的对象。

struct_time是在time模块中定义的表示时间的对象。

语法：

time.gmtime([sec])

参数

• sec -- 转换为time.struct_time类型的对象的秒数，可选参数，默认为当前时间。

返回值

​ 返回time.struct_time类型的对象。

实例

import time

print("time.gmtime() :" , time.gmtime())

以上实例输出结果为：

time.gmtime() : time.struct_time(tm_year=2023, tm_mon=10, tm_mday=21, tm_hour=2, tm_min=17, tm_sec=51, tm_wday=5, tm_yday=294, tm_isdst=0)

gmtime() 函数与 localtime() 函数的作用类似，但将当前时间转换为 UTC 时间。它同样返回一个包含当前日期和时间的 struct_time 对象。

mktime(t)-时间对象转换为时间戳

Python time mktime() 函数执行与gmtime(), localtime()相反的操作，它接收struct_time对象作为参数，返回用秒数来表示时间的浮点数。

如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError。

语法：

time.mktime(t)

参数

• t -- 结构化的时间或者完整的9位元组元素。

返回值

​ 返回用秒数来表示时间的浮点数。

实例

import time

t = (2009, 2, 17, 17, 3, 38, 1, 48, 0)
secs = time.mktime( t )
print("time.mktime(t) : %f" % secs)

以上实例输出结果为：

time.mktime(t) : 1234861418.000000

转换为时间字符串

asctime([t])-时间对象转换为时间字符串

Python time asctime() 函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串，功能与mktime()类似。

语法：

time.asctime([t]))

参数

• t -- 9个元素的元组或者通过函数 gmtime() 或 localtime() 返回的时间值，可选参数，默认为当前时间。

返回值

​ 返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。

实例

import time

t = time.localtime()
print("time.asctime(t): %s " % time.asctime(t))

以上实例输出结果为：

time.asctime(t): Sat Oct 21 09:58:21 2023

ctime([sec])-时间戳转换为时间字符串

Python time ctime() 函数把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。 如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于 asctime(localtime(secs))。

语法：

time.ctime([sec])

参数

• sec -- 要转换为字符串时间的秒数，可选参数，默认为当前时间。

返回值

​ 返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。

实例

import time

print("time.ctime() : %s" % time.ctime())

以上实例输出结果为：

time.ctime() : Sat Oct 21 10:05:34 2023

ctime() 函数用于将时间戳转换为可读性的时间字符串，格式与 asctime() 相同。如果不传参数，则默认输出当前时间字符串。

时间日期格式化

时间格式化是指将日期或时间按照指定的格式进行输出或显示。Python中时间模块提供了多个用于时间格式化的函数，下面介绍一些常用的函数及其使用方法

时间日期格式化符号

• %y 两位数的年份表示（00-99）
• %Y 四位数的年份表示（000-9999）
• %m 月份（01-12）
• %d 月内中的一天（0-31）
• %H 24小时制小时数（0-23）
• %I 12小时制小时数（01-12）
• %M 分钟数（00=59）
• %S 秒（00-59）
• %a 本地简化星期名称
• %A 本地完整星期名称
• %b 本地简化的月份名称
• %B 本地完整的月份名称
• %c 本地相应的日期表示和时间表示
• %j 年内的一天（001-366）
• %p 本地A.M.或P.M.的等价符
• %U 一年中的星期数（00-53）星期天为星期的开始
• %w 星期（0-6），星期天为星期的开始
• %W 一年中的星期数（00-53）星期一为星期的开始
• %x 本地相应的日期表示
• %X 本地相应的时间表示
• %Z 当前时区的名称
• %% %号本身

strftime 时间对象转为字符串

Python time strftime() 函数用于格式化时间，返回以可读字符串表示的当地时间，格式由参数 format 决定。

语法：

time.strftime(format[, t])

参数

• format -- 格式字符串。
• t -- 可选的参数 t 是一个 struct_time 对象，默认为当前时间。

返回值

​ 返回以可读字符串表示的当地时间。

实例

import time

local_time = time.localtime()
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print("当前时间格式化字符串是：",formatted_time)
formatted_time2 = time.strftime("%Y-%m-%d %H:%M:%S")
print("当前时间格式化字符串是：",formatted_time2)

以上实例输出结果为：

当前时间格式化字符串是： 2023-10-21 15:52:28
当前时间格式化字符串是： 2023-10-21 15:52:28

strptime 字符串转换为时间对象

Python time strptime() 函数根据指定的格式把一个时间字符串解析为时间元组。

语法：

time.strptime(string[, format])

参数

• string -- 时间字符串。
• format -- 格式化字符串。

返回值

​ 返回struct_time对象。

实例

import time

struct_time = time.strptime("2023-10-21 15:52:28", "%Y-%m-%d %H:%M:%S")
print ("转换后的时间对象为: ", struct_time)

以上实例输出结果为：

返回元组:  time.struct_time(tm_year=2023, tm_mon=10, tm_mday=21, tm_hour=15, tm_min=52, tm_sec=28, tm_wday=5, tm_yday=294, tm_isdst=-1)

python 关于睡眠的操作

Python中的time模块还提供了一些函数可以实现程序的等待或睡眠，以延迟指定的时间间隔来控制程序的执行速度或顺序。下面介绍一些比较常用的函数及其使用方法

5.1 sleep(t)-程序暂停指定的时间

Python time sleep() 函数推迟调用线程的运行，可通过参数secs指秒数，表示进程挂起的时间。

语法：

time.sleep(t)

参数

• t -- 推迟执行的秒数。

返回值

该函数没有返回值。

实例

import time

print ("Start : %s" % time.ctime())
time.sleep( 5 )
print ("End : %s" % time.ctime())

以上实例输出结果为：

Start : Sat Oct 21 16:10:09 2023
End : Sat Oct 21 16:10:14 2023

perf_counter()

perf_counter() 函数可以返回当前系统的CPU时间，可以被用作基准时间。我们可以在某个程序处理完成之后重新计算一次CPU时间，来获得程序处理的实际时间。

返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。

import time

start_time = time.perf_counter()

# 执行某个操作，比如循环1亿次
for i in range(100000000):
    pass

end_time = time.perf_counter()

print(f"处理1亿次操作，用时{end_time - start_time}秒")

以上实例输出结果为：

处理1亿次操作，用时5.3497827秒

process_time()

process_time() 函数返回当前进程执行 CPU 的时间总量，不包含睡眠时间，单位为秒。与 perf_counter() 不同的是，process_time() 不包括睡眠时间。

由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。

import time

start_time = time.process_time()

# 执行某个操作，比如循环1亿次
for i in range(100000000):
    pass

end_time = time.process_time()

print(f"处理1亿次操作，用时{end_time - start_time}秒")

以上实例输出结果为：

处理1亿次操作，用时6.71875秒

模拟考题

考题1 单选题

以下有关常用标准库的表述中，正确的是？（ ）

A. jieba.cut(s)函数分词功能是自由模式分词

B. wordcloud库生成词云有两种方法：文本生成和图片生成

C. time的strftime()函数用于格式化时间，返回以可读字符串表示的当前时间

D. "%y-%m-%d, %H:%M:%S"和"%Y-%m-%d, %H:%M:%S"输出格式一样

答案：C

解析： jieba.cut(s)函数分词功能是精确模式分词。

wordcloud库生成词云有两种方法：文本生成和频率生成。

%y 两位数的年份表示（00-99），%Y 四位数的年份表示（0000-9999）。

考题2 单选题

time模块中，time.time()所得的结果的数据类型是？（ ）

A. 整形

B. 实型

C. 字符串类型

D. 列表类型

答案：B

解析： time.time() 返回当前时间的时间戳（1970纪元后经过的浮点秒数），即从 "1970 年 1 月 1 日 00:00:00" UTC 到当前时间的秒数

考题3 单选题

下列代码运行后的正确选项是？（ ）

import time
a=time.gmtime()
print(time.strftime('%Y-%m-%d %a %h:%M:%S %p',a))

A. 2023-02-01 Wed Feb:08:04 PM

B. Wed Feb: 2023-02-01 08:04 PM

C. Wed Feb:08:04 PM 2023-02-01

D. 2023-02-01 Wed Feb:08:04

答案：A

解析：Python中的time库应用。

考题4 单选题

利用time模块，下列可以输出当前日期的正确的语句是？（　）

A. print(time.ctime('%y%m%d'))

B. print(time.strftime('%y%m%d'))

C. print(time.nowdate('%y%m%d'))

D. print(time.local('%y%m%d'))

答案：B

解析：Python time strftime() 函数用于格式化时间，返回以可读字符串表示的当地时间，%y 两位数的年份表示（00-99）%m 月份（01-12）%d 月内中的一天（0-31）

考题5 判断题

time库是Python中处理时间的标准库, time库中时间获取函数time()和ctime()，返回的都是字符串。（ ）

答案：错误

解析：函数time()返回当前时间的时间戳（1970纪元后经过的浮点秒数，函数ctime()返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串

datetime模块

datetime模块介绍

Python有一个名为datetime的模块，用于处理日期和时间。在深入学习之前，让我们创建一些与日期和时间相关的简单程序。

获取当前日期和时间

import datetime

datetime_object = datetime.datetime.now()
print(datetime_object)

当您运行程序时，输出将类似于：

2020-04-13 17:09:49.015911

这里，我们使用import datetime语句导入了datetime模块。

datetime模块中定义的一个类是datetime类。然后，我们使用now()方法创建一个包含当前本地日期和时间的datetime对象。

获取当前日期

import datetime

date_object = datetime.date.today()
print(date_object)

当您运行程序时，输出将类似于：

2023-10-21

在这个程序中，我们使用了date类中定义的today()方法来获取一个包含当前本地日期的date对象。

datetime里面有什么？

我们可以使用dir()函数来获取包含模块所有属性的列表。

import datetime

print(dir(datetime))

运行该程序时，输出为：

['MAXYEAR', 'MINYEAR', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_divide_and_round', 'date', 'datetime', 'datetime_CAPI', 'time', 'timedelta', 'timezone', 'tzinfo']

datetime模块中常用的类是：

• date类
• time类
• datetime类
• timedelta类

datetime.date类

您可以从date类示例化date对象。date对象表示日期(年、月和日)。

表示日期的Date对象

import datetime

d = datetime.date(2019, 4, 13)
print(d)

运行该程序时，输出为：

2019-04-13

如果您想知道，上面示例中的date()是date类的构造函数。构造函数有三个参数:年、月和日。

变量a是一个date对象。

我们只能从datetime模块中导入date类。就是这样：

from datetime import date

a = date(2019, 4, 13)
print(a)

获取当前日期

您可以使用一个名为today()的类方法来创建一个包含当前日期的date对象。方法如下:

from datetime import date

today = date.today()

print("当前日期 =", today)

从时间戳获取日期

我们还可以从时间戳创建日期对象。Unix时间戳是特定日期到UTC的1970年1月1日之间的秒数。可以使用fromtimestamp()方法将时间戳转换为日期。

from datetime import date

timestamp = date.fromtimestamp(1576244364)
print("日期 =", timestamp)

运行该程序时，输出为：

日期 = 2019-12-13

打印今天的年，月和日

我们可以轻松地从日期对象获取年，月，日，星期几等。就是这样：

from datetime import date

# 今天的日期对象
today = date.today() 

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

输出如下：

当前年: 2023
当前月: 10
当前日: 21

datetime.time

从time类示例化的时间对象表示本地时间。

表示时间的时间对象

from datetime import time

# time(hour = 0, minute = 0, second = 0)
a = time()
print("a =", a)

# time(hour, minute and second)
b = time(11, 34, 56)
print("b =", b)

# time(hour, minute and second)
c = time(hour = 11, minute = 34, second = 56)
print("c =", c)

# time(hour, minute, second, microsecond)
d = time(11, 34, 56, 234566)
print("d =", d)

运行该程序时，输出为：

a = 00:00:00
b = 11:34:56
c = 11:34:56
d = 11:34:56.234566

打印时，分，秒和微秒

创建time对象后，您可以轻松打印其属性，例如小时，分钟等。

from datetime import time

a = time(11, 34, 56)

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

运行示例时，输出将是：

小时= 11
分钟= 34
秒= 56
微秒= 0

注意，我们还没有传递微秒参数。因此，将打印其默认值0。

datetime.datetime

datetime模块有一个名为的dateclass类，可以包含来自date和time对象的信息。

datetime对象

from datetime import datetime

#datetime(year, month, day)
a = datetime(2023, 11, 28)
print(a)

# datetime(year, month, day, hour, minute, second, microsecond)
b = datetime(2023, 11, 28, 23, 55, 59, 342380)
print(b)

运行该程序时，输出为：

2023-11-28 00:00:00
2023-11-28 23:55:59.342380

datetime()构造函数中的前三个参数year、month和day是必需的。

打印年，月，时，分和时间戳

from datetime import datetime

a = datetime(2019, 12, 28, 23, 55, 59, 342380)
print("年 =", a.year)
print("月 =", a.month)
print("日 =", a.day)
print("时 =", a.hour)
print("份 =", a.minute)
print("时间戳 =", a.timestamp())

运行该程序时，输出为：

年 = 2019
月 = 12
日 = 28
时 = 23
份 = 55
时间戳 = 1577548559.34238

datetime.timedelta

timedelta对象表示两个日期或时间之间的时差。

两个日期和时间之间的时差

from datetime import datetime, date

t1 = date(year = 2018, month = 7, day = 12)
t2 = date(year = 2017, month = 12, day = 23)
t3 = t1 - t2
print("t3 =", t3)

t4 = datetime(year = 2018, month = 7, day = 12, hour = 7, minute = 9, second = 33)
t5 = datetime(year = 2019, month = 6, day = 10, hour = 5, minute = 55, second = 13)
t6 = t4 - t5
print("t6 =", t6)

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

运行该程序时，输出为：

t3 = 201 days, 0:00:00
t6 = -333 days, 1:14:20
type of t3 = <class 'datetime.timedelta'>
type of t6 = <class 'datetime.timedelta'>

注意，t3和t6都是类型。

两个timedelta对象之间的时间差

from datetime import 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)

运行该程序时，输出为：

t3 = 14 days, 13:55:39

在这里，我们创建了两个timedelta对象t1和t2，它们直接相差的天数被打印在屏幕上。

打印负timedelta对象

from datetime import timedelta

t1 = timedelta(seconds = 33)
t2 = timedelta(seconds = 54)
t3 = t1 - t2

print("t3 =", t3)
print("t3 =", abs(t3))

运行该程序时，输出为：

t3 = -1 day, 23:59:39
t3 = 0:00:21

持续时间（以秒为单位）

您可以使用total_seconds()方法获得timedelta对象中的总秒数。

from datetime import timedelta

t = timedelta(days = 5, hours = 1, seconds = 33, microseconds = 233423)
print("total seconds =", t.total_seconds())

运行该程序时，输出为：

total seconds = 435633.233423

您还可以使用+运算符找到两个日期和时间的总和。同样，您可以将timedelta对象乘以整数和浮点数。

格式日期时间

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

Python有strftime()和strptime()方法来处理这个问题，与前面time模块的strftime()和strptime()方法类似。

strftime()-格式化日期

strftime()方法是在date、datetime和time类下面定义的。该方法根据给定的日期、日期时间或时间对象创建格式化的字符串。

实例

from datetime import datetime

# current date and time
now = datetime.now()

t = now.strftime("%H:%M:%S")
print("time:", t)

s1 = now.strftime("%m/%d/%Y, %H:%M:%S")
# mm/dd/YY H:M:S format
print("s1:", s1)

s2 = now.strftime("%d/%m/%Y, %H:%M:%S")
# dd/mm/YY H:M:S format
print("s2:", s2)

当您运行程序时，输出将类似于：

time: 04:34:52
s1: 12/26/2018, 04:34:52
s2: 26/12/2018, 04:34:52

这里%Y，%m，%d，%H等都是格式代码。strftime()方法采用一个或多个格式代码，并根据该代码返回格式化的字符串。

在上面的程序中，t，s1和s2是字符串。

• %Y -年[0001，...，2018，2019，...，9999]
• %m -月[01，02，...，11，12]
• %d -天[01，02，...，30，31]
• %H -小时[00，01，...，22，23
• %M -分钟[00，01，...，58，59]
• %S -秒[00，01，...，58，59]

更多说明，参考time模块【时间日期格式化符号】。

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

strptime()方法从一个给定的字符串(表示日期和时间)创建一个datetime对象。

实例

from datetime import datetime

date_string = "21 June, 2018"
print("date_string =", date_string)

date_object = datetime.strptime(date_string, "%d %B, %Y")
print("date_object =", date_object)

运行该程序时，输出为：

date_string = 21 June, 2018
date_object = 2018-06-21 00:00:00

strptime()方法有两个参数：

1. 表示日期和时间的字符串
2. 等同于第一个参数的格式代码

顺便说一下，%d、%B和%Y格式代码分别用于日、月(全称)和年。