1. Python技术站首页
  2. Python开发

python常用标准库（时间模块time和datetime）

• Python开发

常用的标准库

time时间模块

import time

time -- 获取本地时间戳

时间戳又被称之为是Unix时间戳，原本是在Unix系统中的计时工具。

它的含义是从1970年1月1日（UTC/GMT的午夜）开始所经过的秒数，不考虑闰秒。UNIX时间戳的 0 按照ISO 8601规范为 ：1970-01-01T00:00:00Z。

比如：

  • 时间戳 60 表示 1970-01-01T00:01:00Z
  • 时间戳 120 表示 1970-01-01T00:02:00Z
  • 时间戳 3600 表示 1970-01-01T01:00:00Z

小知识：最开始的时候，时间戳的开始年份是1971年，那个时候Unix系统和C语言刚刚诞生，所以时间戳0也就是Unix系统和C语言的生日。那时候的时间位数只有32位，而且每秒中有60个数字，发现只要两年多的时间时间戳就能完成一个轮回，十分的不方便！所以后来的一系列改革，将时间戳的数值改为每秒1个数字，还有一些新的系统可以将时间戳的位数增大，可以让时间戳的轮回扩展到一百多年，再后来为了方便人们记忆，将时间戳的起始年份定位1970年整。

import time

stamp_time = time.time()
print(stamp_time)  # 1635768368.2838552
localtime -- 获取本地时间元组（UTC）

参数为时间戳，默认为本地时间戳，获取时间元组。

时间元组是python中的一个特殊的数据类型type: time.struct_time，但是它和tuple的特性是相同的。

import time

# 时间元组中的值分别表示：
	# tm_year: 年
	# tm_mon: 月
	# tm_mday: 日
	# tm_hour: 时
	# tm_min: 分
	# tm_sec: 秒
	# tm_wday: 周几（0表示星期一）
	# tm_yday: 一年中的第几天（从1开始）
	# tm_isdst: 夏令标识（1夏令时、0非夏令时、-1未知）

# 默认当前时间
time_tuple = time.localtime()
print(time_tuple)
# time.struct_time(tm_year=2021, tm_mon=11, tm_mday=1, tm_hour=20, tm_min=7, tm_sec=50, tm_wday=0, tm_yday=305, tm_isdst=0)

# 指定时间戳
time_tuple = time.localtime(3600)
print(time_tuple)
# time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=9, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

有大问题啦！！！

时间戳的起始时间是1970-1-1 0:0:0， 这个时候的时间戳是0，那么时间戳3600就是整整一个小时之后，那么时间就应该是1970-1-1 0:1:0 才对的呀！怎么上面的3600确实9点钟了呢？怎么起始时间变成了8点了呢？

然后你发现你在中国，时间是北京时间，北京在东八区时区，嘶，怎么正好也是个八？

是这样的，按照道理来说的话全世界任何一个地方的时间戳所代表的时间都应该是一样的，而且时间戳的起始时间确实是 1970-1-1 0:0:0 ，但是这个时间是位于英国的一个叫做格林威治的小镇的，格林威治有一个天文台叫做皇家格林尼治天文台，后来国际上将这个地方的经线作为本初子午线，作为时间计算时间和地理精度的起点。那么，有时区的存在打破了这个可能，我们在中国，所有的设备都是按照中国的时区编码的，中国位于东八区，在时间上比英国快八个小时，所以我们中国的本地时间戳就是 1970-1-1 8:00:00。

gmtime -- 获取时间元组（GMT）

在不知道这个函数的时候，我就很好奇为什么localtime的初始时间比格林威治时间要快8小时，现在就明白了：

函数 描述
gmtime 获取时间元组（GMT格林威治时间）
localtime 获取时间元组（UTC协调世界时）
mktime -- 时间元组获取时间戳

注意：

  1. 参数必须是时间元组time.struct_time 或者元组 tuple 类型；
  2. 元组中的元素一个也不能少，必须九个元素都存在；
  3. 得到的时间戳只收到前六个值的影响，即：年月日时分秒；
  4. 时间元组中的时间表示，最小时间不能低于当地的最小时间戳；
  5. 时间元组中的时间表示，单位可以超出原本的范围，比如秒满60进1，我们将秒写成100，系统也不会报错，但是时间上会自动的将多出的时间进位。但是数字也不能过大，因为数据类型的大小是有极限的。
  6. mktime返回的数值是浮点型的，但是精度只能到1；
import time

# 在中国的最小时间单位
tst = (1970, 1, 1, 8, 0, 0, 0, 0, 0)
time_stamp = time.mktime(tst)
print(time_stamp)  # 0.0
ctime -- 获取时间字符串

参数默认为本地时间戳，获取的数据类型是 str，这个时间字符串不像时间元组是一个单独的数据类型。

import time

# 时间字符串中的含义是：
	# Mon Nov  1 21:34:39 2021
    # 星期 月   日 时 分 秒  年

# 默认为本地时间戳
time_char = time.ctime()
print(time_char)  # Mon Nov  1 21:34:39 2021

# 指定时间戳
time_char = time.ctime(0)
print(time_char)  # Thu Jan  1 08:00:00 1970
asctime -- 时间元组获取时间字符串

注意，asctime有弊端，看下例：

import time

tst = (1970, 1, 1, 8, 24, 61, 1, 0, 0)
time_char = time.asctime(tst)
print(time_char)  # Tue Jan  1 08:24:61 1970

tst = (1970, 1, 1, 8, 24, 61, 2, 0, 0)
time_char = time.asctime(tst)
print(time_char)  # Tue Jan  1 08:24:61 1970

看上面的例子，时间元组变成时间字符串的时候，会将星期的数据也读取到，但是却不会分辨数据是否正确，所以asctime并不常用。

如果要将一个不确定正确性的时间元组变成时间字符串的话，先通过 mktime 获取时间戳（mktime可以分辨出正确的时间信息），然后在将时间戳通过 ctime 变成时间字符串。

strftime -- 格式化时间

格式化时间，按照指定的格式（一段格式化字符串，就像字符串的格式化一样）将时间元组变成时间字符串。

我们先来学习一下时间占位符的含义是什么：

注意！！！这些占位符的大小写的含义是不同的：

占位符 含义
%Y 以十进制数字表示以世纪为单位的年份（四位数）
%y 以十进制数字表示年份（两位数）
%m 以十进制数字表示月份
%D 以月/日/年(两位数)的格式表示年月日
%d 以十进制数字表示日期
%H 以十进制数字表示二十四小时制的时
%M 以十进制数字表示分钟
%S 以十进制数字表示秒
%z 与UTC的时区偏移
%a 区域设置的缩写工作日名称
%A 区域设置的完整工作日名称
%b 区域设置的缩写月份名称
%B 区域设置的完整月份名称
%c 语言环境的适当日期和时间表示
%I 以十进制数表示十二小时制的时（大写 ‘爱’）
%p 语言环境的等效值：AM 或者 PM

现在根据使用时间占位符用字符串格式化将时间元组变成字符串。

import time

# 注意，如果格式化字符串中出现中文字符，只能在linux系统下运行，windows下不能解析，直接报错。

tst = (1970, 1, 1, 8, 0, 0, 0, 0, 0)
time_tuple = time.strftime('%Y-%m-%d-%H-%m-%S',tst)
print(time_tuple)  # 1970-01-01-08-01-00

# 有中文在windows下报错
tst = (1970, 1, 1, 8, 0, 0, 0, 0, 0)
time_tuple = time.strftime('%Y-%m哈哈-%d-%H-%m-%S',tst)
print(time_tuple)  # 1970-01-01-08-01-00
strptime -- 格式化时间

格式化时间，通过格式化字符串将一个字符串中的时间变成时间元组。

import time

# 格式化字符串要和原字符串一模一样，只是将需要提出的部分使用占位符替换
char = '2000年10月30日一个伟大的中国少年在三晋大地诞生了'
format_char = '%Y年%m月%d日一个伟大的中国少年在三晋大地诞生了'

tst = time.strptime(char, format_char)
print(tst)
sleep -- 时间睡眠

等待指定秒数的时间：

import time

print('开始睡觉')
time.sleep(2)
print('睡了两秒钟，神清气爽')
perf_counter -- 时间计时

用于计算程序运行的时间

import time

# perf_counter 用于计算程序运行的时间

# 记录开始时间
start_time = time.perf_counter()

# 程序运行
for i in range(10000):
    pass

# 记录时间
end_time = time.perf_counter()

# windows系统直接拿到第二次的值就可以了，不用减去第一次的值也行
print(end_time, '秒')  # 0.0003918 秒
print(end_time - start_time, '秒')  # 0.0003916 秒

如果使用多次perf_counter()函数，直接输出其的值是距第一次使用的时间长度：

import time

time1 = time.perf_counter()
time.sleep(1)
time2 = time.perf_counter()
print(time2)

time.sleep(2)
time3 = time.perf_counter()
print(time3)

time.sleep(3)
time4 = time.perf_counter()
print(time4)

"""
结果：
1.0002558
3.0048941
6.019172
"""

注意：windows系统下使用perf_counter()函数可以直接输出耗时长度，每次的耗时默认都是距离第一次使用perf_counter()函数的时间长度；如果在linux系统下使用perf_counter()函数则必须要使用第二次的结果减去之前的结果，因为在linux系统中perf_counter()函数的值和time()函数的值都是一样的，那就是返回一个时间戳。

使用time.time()计算时间

import time

# perf_counter 用于计算程序运行的时间

# 记录开始时间
start_time = time.time()

# 程序运行
for i in range(10000):
    pass

# 记录时间
end_time = time.time()

print(end_time - start_time, '秒')  # 0.001001119613647461 秒

耗时短的计时推荐使用pref_counter，耗时长的推荐使用time。

模拟进度条
# 1、定义进度条样式
print('[%-50s]' % ('###########'))
print('[%-50s]' % ('###################'))
print('[%-50s]' % ('###########################'))
print('[%-50s]' % ('####################################'))
print('[%-50s]' % ('########################################'))

# 2、让进度条动起来
import time

progress_char = ''
for i in range(50):
    progress_char += '#'
    time.sleep(0.05)  # 延时看起来不是很快
    # end使不能换行，\r使进度条不断刷新，保持在同一行显示；
    print('\r[%-50s]' % (progress_char), end='')
print('\n')

# 3、根据文件的大小调整进度条的进度
import time

def progress(percent):
    """控制进度条的显示
    参数是下载的百分比，用来控制进度条的进展
    """
    # 如果百分比超过了1，说明数据已经接受完毕
    if percent > 1:
        percent = 1

    # 打印对应的进度条效果
    char = '#' * int(percent * 50)
    print('\r[%-50s]%d%%' % (char, int(percent * 100)), end='')


# 已下的大小
rec_size = 0

# 下载文件的大小
total_size = 102400

# 模拟下载过程
while rec_size < total_size:
    rec_size += 10240  # 下载速度
    time.sleep(0.05)  # 模拟网络延迟
    percent = rec_size / total_size  # 计算下载的进度（百分比）
    # 调用进度条
    progress(percent)
程序计时

在学习了perf_counter计时后，我们知道有很多种方法可以用于计时：

  1. time函数：返回当前时间戳，使用time函数计时是获取两个节点各自的时间戳，然后计算其之间的差值，即为耗时时长。
    • 优点：计算的是真实世界中的时间长度，而且计时本身不消耗计算机资源，计算长时间的程序优势较大；
    • 缺点：time函数的时间获取来源于计算机本身的时间，如果在计时途中计算机的时间发生变化，比如人为的调快一小时，那么计时就会比正确的时间慢一个小时的时间。
  2. perf_counter函数：是time模块中专门用于性能计时的函数，具有高分辨率的时钟，已测量短持续的时间。
    • 优点：是专门用于性能计时的函数，精确度高，适合计算耗时短的程序；
    • 缺点：专门用于计时的函数，计时本身就会消耗计算机资源，所以计时过长难免会有一定的影响；
  3. process_time函数：用于评测处理时间，计算内核和用户空间CPU时间之和，这个时间不包含程序阻塞的时间，比如time.sleep()、input()等。
    • 优点：专门用于计算程序本身内在的时间消耗，排除外来因素、提升系统本身效率、优化程序使用；
import time


def loop():
    time.sleep(1)
    input('请输入：')  # 这个位置人为数三秒回车执行
    num = 10 ** 8
    for _ in range(num):
        pass
    time.sleep(1)


# time.time
start_time = time.time()
loop()
end_time = time.time()
print(start_time)  # 1640270620.4077902
print(end_time)  # 1640270628.1165576
print(end_time - start_time)  # 7.708767414093018

# time.perf_counter
start_time = time.perf_counter()
loop()
end_time = time.perf_counter()
print(start_time)  # 3e-07
print(end_time)  # 7.823952
print(end_time - start_time)  # 7.8239517

# time.process_time
start_time = time.process_time()
loop()
end_time = time.process_time()
print(start_time)  # 3.234375
print(end_time)  # 4.8125
print(end_time - start_time)  # 1.578125

除此之外，python3.7之后，新增了精确到纳秒的函数:

  1. time.time_ns()
  2. time.perf_counter_ns()
  3. time.process_time_ns()

还有标准库timeit用于程序的性能计时。

时间转换示意图

在上述的几种类型中存在时间转换的问题，详情和之间的关系可以参考下图：

在这里插入图片描述

datetime时间模块

import datatime

datatime模块重新封装了time模块，提供更多的接口。

date类

date类专门用于描述日期，实例化对象时必须填入参数，分别表示：年、月、日，返回datetime.date对象。

datetime.date(year, month, day)

from datetime import date

date_o = date(2022, 3, 1)

print(date_o)
print(type(date_o))

"""
结果：
2022-03-01
<class 'datetime.date'>
"""

常用属性

属性 作用
year date对象表示的具体年份（实例化对象调用达到效果）；
month date对象表示的具体月份（实例化对象调用达到效果）；
day date对象表示的具体日（实例化对象调用达到效果）；
max date类能够表示的最大日期；
min date类能够表示的最小日期；
resolution date类能够表示的最小单位；

常用方法

注意，以下方法如果可以返回新的对象，使用对象调用时，返回新的对象，原对象不变；如果根据对象值返回对应的值，则使用类调用达不到目标效果；

方法 作用
today() 返回本地日期对象；
fromtimestamp(time_stamp) 给定时间戳返回日期对象；
replace(y, m, d) 给定年月日返回日期对象；
timetuple() 返回本地当前时间元组time.struct_time对象;
weekday() 返回星期序号，星期一返回0；
isoweekday() 返回星期序号，星期一返回1；
isocalendar() 返回元组，表示日期的年份、第几周、第几周之后的第几天；
isoformat() 返回时间字符串；
strftime() 格式化日期，参考time.strftime()；

time类

time类是datetime模块中专门用于描述时间的类，四个参数：hour、minute、second、microsecond默认都为0。

datetime.time(hour=0, minute=0, second=0, microsecond=0)

from datetime import time

time_0 = time()

print(time_0)
print(type(time_0))

"""
结果：
00:00:00
<class 'datetime.time'>
"""

time的属性和date类的属性方法基本相同，可以参考使用；

datetime类

相同于date和time两个类的结合，使用基本相同；

timedelta类

timedelta类用于时间运算，类的参数有datetime模块支持的所有时间单位，使用其它的时间和日期对象可以和timedelta对象进行时间加减运算，注意在实例化时使用关键字传参；

from datetime import datetime
from datetime import timedelta

# 日期对象
datetime_o = datetime(2000, 10, 30, 14, 40, 6)
print(datetime_o)

# ## 假设我们要计算这个时间5天4小时23分6秒之后的时间

# 实例化 5天4小时23分6秒 的timedelta对象
timedelta_o = timedelta(days=5, hours=4, minutes=23, seconds=6)

# 将时间对象和timedelta对象相加
datetime_o += timedelta_o
print(datetime_o)

"""
结果：
2000-10-30 14:40:06
2000-11-04 19:03:12
"""

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：python常用标准库（时间模块time和datetime） - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年4月2日
下一篇 2023年4月2日

相关文章

  • python 函数进阶-闭包函数

    闭包函数 什么是闭包函数 如果内函数使用了外函数的局部变量，并且外函数把内函数返回出来的过程叫做闭包，里面的内函数是闭包函数。 # 外函数 outer def outer(): # 外函数变量 num var = ‘外函数局部变量’ # 内函数 inner def inner(): # 内函数使用了外函数的变量 num print(‘内函数使用了：’ + v…

    Python开发 2023年4月2日
    00

  • python常用标准库（压缩包模块zipfile和tarfile）

    常用的标准库 在我们常用的系统windows和Linux系统中有很多支持的压缩包格式，包括但不限于以下种类：rar、zip、tar，以下的标准库的作用就是用于压缩解压缩其中一些格式的压缩包。 zip格式 import zipfile zipfile模块操作压缩包使用ZipFile类进行操作，使用方法和open的使用方法很相似，也是使用r、w、x、a四种操作模…

    Python开发 2023年4月2日
    00

  • Python 函数进阶-迭代器

    迭代器 什么是迭代器 能被 next 指针调用，并不断返回下一个值的对象，叫做迭代器。表示为Iterator，迭代器是一个对象类型数据。 概念 迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一次的结果而继续的，单纯的重复并不是迭代。 特征 迭代器并不依赖索引，而通过 next 指针迭代所有数据，一次只取一个值，大大节省空间。 惰性序列 …

    Python开发 2023年4月2日
    00

  • python生成器

    生成器 我们学习完推导式之后发现，推导式就是在容器中使用一个for循环而已，为什么没有元组推导式？ 原因就是“元组推导式”的名字不是这样的，而是叫做生成器表达式。 什么是生成器 生成器表达式本质上就是一个迭代器，是定义迭代器的一种方式，是允许自定义逻辑的迭代器。生成器使用generator表示。 迭代器和生成器的区别 迭代器本身是系统内置的， 无法重写内置的…

    Python开发 2023年4月2日
    00

  • Python推导式

    推导式 什么是推导式 推导式是 for 循环的简化使用方法，使用推导式，将一个可迭代对象中的数据遍历到某一个容器当中。简单的来说就是用一行for循环语句，遍历一个可迭代对象中的所有数据，然后将遍历出来的数据进行处理放入对应的容器中的一个过程和方式。 和推导类似作用的还有三元运算符，三元运算符是条件判断语句的简化使用方法。 语法 val for val in …

    Python开发 2023年4月2日
    00

  • Python常用标准库（pickle序列化和JSON序列化）

    常用的标准库 序列化模块 import pickle 序列化和反序列化 把不能直接存储的数据变得可存储，这个过程叫做序列化。把文件中的数据拿出来，回复称原来的数据类型，这个过程叫做反序列化。 在文件中存储的数据只能是字符串，或者是字节流，不能是其它的数据类型，但是如果想要将其存储就需要序列化。 Python中的序列化模块叫做 pickle，PHP等其它的一些…

    Python开发 2023年4月2日
    00

  • python常用标准库（os系统模块、shutil文件操作模块）

    常用的标准库 系统模块 import os 系统模块用于对系统进行操作。 常用方法 os模块的常用方法有数十种之多，本文中只选出最常用的几种，其余的还有权限操作、文件的删除创建等详细资料可以参考官方文档。 system — 执行系统命令 参数的数据类型是字符串格式，内容是系统指令。执行时，直接返回系统输出。 import os os.system(‘ifc…

    Python开发 2023年4月2日
    00

  • python常用内置函数和关键字

    常用内置方法 在Python中有许许多多的内置方法，就是一些Python内置的函数，它们是我们日常中经常可以使用的到的一些基础的工具，可以方便我们的工作。 查看所有的内置类和内置方法 # 方法一 built_list = dir(__builtins__) # 方法二 import builtins built_list = dir(builtins) 其中…

    Python开发 2023年4月2日
    00
合作推广
合作推广
分享本页
返回顶部