前言时刻

今天学习了 Python 中比较重要的模块：time、sys等，都是很重要的。

总结一波：

time：sleep、gmtime、localtime、mktime、strftime、strptime

datetime：date、time、datetime、timedelta

os，sys

1、time模块

time模块中主要分为三种状态，一种是时间戳，一种是结构时间（stuct_time），另外一种是字符串时间，所以学习 time 模块就是玩这三种状态之间的转化。

1.1 时间戳

什么是时间戳呢？时间戳是从1970年1月1号0点0分0秒到现在所经历的秒数，一般单位是秒，但是也有以毫秒位单位的。

  1. import time
  3. # 1、时间戳
  4. # 输出从1970年1月1号0点0分0秒到现在所经历的秒数
  5. time.time()   # 1621734149.9351869

1.2 结构化时间

什么是结构化时间？这个是Python 内部的一种表示时间的类，直观且利于与其他状态互转。

返回结构化时间的函数有time.gmtime(), time.localtime(), time.strptime()

例如：

  1. time.struct_time(tm_year=2021, tm_mon=5, tm_mday=23, tm_hour=2, tm_min=19, tm_sec=56, tm_wday=6, tm_yday=143, tm_isdst=0)

1. 时间戳转结构化时间

time.gmtime()：默认是将时间戳转成格林尼治时间结构。参数传入秒数，默认是time.time()

由于我们中国是东八区时区，时间是不一样的，需要用 localtime 函数 。

time.localtime()：将时间戳转成当地时间结构。参数传入秒数，默认是time.time()

  1. # 2.1、时间戳转结构化时间
  2. strcut_t = time.gmtime(time.time())  # 传入秒数，默认是time.time()
  3. # time.struct_time(tm_year=2021, tm_mon=5, tm_mday=23, tm_hour=1, tm_min=48, tm_sec=26, tm_wday=6, tm_yday=143, tm_isdst=0)
  5. time.localtime(0)
  6. # time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

2. 结构化时间转时间戳

time.mktime(struct_time)：是 localtime 的反函数，将结构化时间转时间戳。

  1. # 2.2 结构时间转时间戳
  2. time.mktime(strcut_t)   # 1621706152.0

1.3 字符串时间

字符串时间是什么？其实本质上就是字符串，但是内容是时间例如："2021-05-23"。如果此时老板给你一个任务就是将这个字符串时间转为时间戳，你会咋办？是用正则还是 split 还是看下面👇。
指令 含义 注释
%a 本地化的缩写星期中每日的名称。
%A 本地化的星期中每日的完整名称。
%b 本地化的月缩写名称。
%B 本地化的月完整名称。
%c 本地化的适当日期和时间表示。
%d 十进制数 [01,31] 表示的月中日。 常用
%H 十进制数 [00,23] 表示的小时（24小时制）。 常用
%I 十进制数 [01,12] 表示的小时（12小时制）。
%j 十进制数 [001,366] 表示的年中日。
%m 十进制数 [01,12] 表示的月。 常用
%M 十进制数 [00,59] 表示的分钟。 常用
%p 本地化的 AM 或 PM 。 (1)
%S 十进制数 [00,61] 表示的秒。 (2)
%U 十进制数 [00,53] 表示的一年中的周数（星期日作为一周的第一天）。 在第一个星期日之前的新年中的所有日子都被认为是在第 0 周。 (3)
%w 十进制数 [0(星期日),6] 表示的周中日。
%W 十进制数 [00,53] 表示的一年中的周数（星期一作为一周的第一天）。 在第一个星期一之前的新年中的所有日子被认为是在第 0 周。 (3)
%x 本地化的适当日期表示。
%X 本地化的适当时间表示。
%y 十进制数 [00,99] 表示的没有世纪的年份。 常用
%Y 十进制数表示的带世纪的年份。
%z 时区偏移以格式 +HHMM 或 -HHMM 形式的 UTC/GMT 的正或负时差指示，其中H表示十进制小时数字，M表示小数分钟数字 [-23:59, +23:59] 。
%Z 时区名称（如果不存在时区，则不包含字符）。
%% 字面的 '%' 字符。

1.3.1. 字符串时间转格式化时间

time.strptime(string, format)：将字符串转格式化的时间，具体 format 的格式看上方👆。

  1. # 3.1 字符串转结构时间 
  2. time.strptime("2021-5-23", "%Y-%m-%d")
  3. # time.struct_time(tm_year=2021, tm_mon=5, tm_mday=23, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=143, tm_isdst=-1)

学完这个 strptime 函数，就可以解决上面”老版留的任务了”。

1）字符串时间转时间戳：

思路就是：以结构时间作为媒介，使用 strptime 将字符串时间->结构时间，然后使用mktime，将结构时间->时间戳。

  1. # 字符串时间转时间戳
  2. time_str = "2021-5-23"
  3. time_struct = time.strptime(time_str, "%Y-%m-%d")
  4. time_stamp = time.mktime(time_struct)
  5. print(f"time_str:{time_str}, timestamp:{time_stamp}")
  6. # time_str:2021-5-23, timestamp:1621699200.0

2. 格式化时间转字符串时间

time.strftime(format, struct_time)：将格式化时间转为字符串时间，具体 format 的格式看上方👆。

  1. # 格式化时间转字符串时间
  2. time_str2 = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
  3. print(time_str2)   # 2021-05-23 11:56:54

time模块总结：可能你觉得 strftime 和 strptime 区分不开，我是这样记得，strftime = str + f + time，f是 format （格式化）的缩写，所以 strftime 是将结构化时间转成格式化的字符串时间的。而 strptime 与 strftime 是相对的，则是字符串时间转格式化时间。

1.4 获取指定时间戳的年月日

  1. # 获取当前的day和month以及year
  3. # 首先获取当前时间的结构化时间，是很重要的。
  5. now_time = time.localtime(time.time())
  6. now_time.tm_year   # 2021
  7. now_time.tm_mon    # 7
  8. now_time.tm_mday   # 6

2、datetime模块

如果说 time 模块是关于时间的标准库，那么可以说 datetime 模块是关于时间的升级版，主要用于处理日期和时间的类。

datetime 模块中有三个重要的类：time 、 date 和 datetime 类，第一个是处理时间的，而第二个是处理日期的，最后一个就是综合前面两个的可处理时间和日期。

2.1 time类

  1. import datetime
  3. # 1、time类
  4. s = datetime.time(17, 3, 22)   # 传入参数：时 分 秒 微秒
  5. print(s)   # 17:03:22

2.2 date类

datetime.date()：参数year、month、 day。

  1. # 2、date类
  2. s2 = datetime.date(2021, 5, 23)   # 传入参数是年月日
  3. print(s2)   # 2021-05-23

2.3 datetime类

datetime.date()：参数属性：year, month, day, hour, minute, second, microsecond, and tzinfo。需重点掌握。

  1. # 3、datetime类
  3. s3 = datetime.datetime(2021, 5, 23, 17, 3, 22)
  4. print(s3)   # 2021-05-23 17:03:22

其实上面都是铺垫，真正重要的是下面的timedelta类，为啥重要的，因为他是关于日期的算术运算方法。时间中用的最多的就是日期的加减，所以很重要。

2.4 timedelta类

datetime.timedelta()：参数属性：days, hours, weeks, minutes, seconds, microseconds。需重点掌握。注意这里面并没有

  1. # 4、datedelta
  2. t1 = datetime.timedelta(days=2,hours=6, minutes=30)
  3. # 2 days, 6:30:00

（1）datetime类型 + timedelta，返回的是 datetime 类

  1. # 4.1 datetime+timedelta
  2. s3 = datetime.datetime(2021, 5, 23, 17, 3, 22)
  3. print(s3)   # 2021-05-23 17:03:22
  5. s4 = s3 + t1
  6. print(f"s4:{s4}, type:{type(s4)}")
  7. # s4:2021-05-25 23:33:22, type:<class 'datetime.datetime'>

（2）date 类型+ timedelta ，返回的是 date 类

  1. # 4.2 date+timedelta
  2. s5 = datetime.date(2021, 5, 24)
  3. s6 = s5 + t1
  4. print(f"s6:{s6}, type:{type(s6)}")
  5. # s6:2021-05-26, type:<class 'datetime.date'>
  6. # 可以看出date类型与timedelta相加时，只加的是date中的year、month、day

（3）timedelta 类型+ timedelta ，返回的是 timedelta 类

  1. # 4.3 timedelta+timedelta类型
  2. t2 = datetime.timedelta(days=6, hours=8)
  3. t3 = t1 + t2
  4. print(f"t3:{t3}, type:{type(t3)}")
  5. # t3:8 days, 14:30:00, type:<class 'datetime.timedelta'>

好了，datetime的常用用法就写到这，以后更高级的用法再更新。

3、os模块

首先os模块是干什么的？os（operation system） 模块是于操作系统息息相关的模块，其调用的是系统底层的用法。

os模块真的很实用很强大，重点掌握，一定要手敲一遍，加深印象。这里进介绍常用的 os 模块，如和文件操作有关以及和路径有关的模块。

（1）与文件操作有关的模块：

  1. import os
  2. # 1、和文件操作有关的模块
  4. file_path = "/test/666.txt"
  5. folder_path = "/test/te"
  7. # 1.1 删除文件或者空文件夹
  8. os.remove(file_path)
  10. # 1.2 重命名文件或文件夹
  11. os.rename(old_p, new_p)
  13. # 1.3 删除文件夹，但文件夹需为空，否则报错
  14. os.remove(folder_path)
  15. # 若需删除非空文件夹，可用用shutil中retree函数
  16. import shutil
  17. shutil.rmtree(folder_path)

（2）与文件路径有关的模块：

  • os.path.split(file_path)：将 file_path 按按最后一个斜杠 / 拆分为两个 head 和 tail ，如果file_path是以斜杠结尾，则 tail 为空。
  • os.path.basename(folder_path)：返回上述 split 中的第二个元素 tail 值。
  • os.path.dirname()：返回上述 split 中的第一个元素 head 值。
  • os.path.join(folder_path, file_name)：拼接路径
  • os.path.abspath(folder_path)：返回路径的绝对路径。
  • os.sep()：返回当前系统的文件分割符号，其中Mac下是/，Windows下是\，Linux下是/。
  1. # os.path
  2. # 2、与文件操作有关的模块
  4. folder_path = "test02"
  5. file_path = 'test2.txt'
  7. # 2.1 取路径的名称和父目录路径
  8. base_name = os.path.basename(folder_path)
  9. dir_name = os.path.dirname(os.path.abspath(folder_path))
  10. print(dir_name, base_name, sep='|')   # ...|test02
  11. # 其实也可以使用split方法，等同于上面两个函数
  12. dir_name, base_name = os.path.split(folder_path)
  14. # 2.2 拼接路径
  15. os.path.join(folder_path, '666.txt')   # test02/666.txt
  17. # 2.3 取路径的绝对路径
  18. os.path.abspath(folder_path)   # .../test02
  19. # 上面的 folder_path 就是一个相对路径

判断文件的属性：

  • os.path..isdir(path)：判断是否是文件夹，是则返回True，反之False。
  • os.path.isabs(path)：判断路径是否是绝对路径，是则返回True，反之False
  • os.path.isfile(path)：判断是否是文件，是则返回True，反之False
  • os.path.exists(path)：判断文件是否存在，是则返回True，反之False
  1. # 2.4 判断文件的属性
  3. # 判断是否是文件夹，是则返回True，反之False
  4. os.path.isdir(folder_path)   # True
  6. # 判断路径是否是绝对路径，是则返回True，反之False
  7. os.path.isabs(folder_path)   # False
  9. # 判断是否是文件，是则返回True，反之False
  10. os.path.isfile(file_path)   # True
  12. # 判断文件是否存在，是则返回True，反之False
  13. os.path.exists(file_path)   # True

新增：

  • os.walk(path, topdown=True)方法：迭代生成目录树的名称
  1. # os.walk 
  2. import os
  3. res = os.walk('../test06')
  4. for each in res:
  5.     print(each)
  6.     # ('../test06', ['test03'], ['untitled.txt'])
  7.     # ……

os.walk方法，返回该文件夹下的文件夹和文件名，元组格式，第一个是文件夹路径，后面的都是该文件夹中的文件。

4、sys模块

sys（system）模块是与 Python 系统的相关的模块，常用的用法如下：

  1. sys.path()：指定搜索模块的路径
  2. sys.modules：返回系统已经加载的模块。
  3. sys.argv：获取给脚本传递的参数，返回列表。
  1. import sys
  2. # 1、指定搜索模块的路径
  3. sys.path
  4. sys.path.append("your_module_dir_path")
  6. # 2、返回系统已经加载的模块
  7. sys.modules
  1. # 3、获取给脚本传递的参数，返回list
  3. # import sys
  4. # print(sys.argv)
  6. jiaozhuzhang@MacBook-Pro test02 % python3 argv_test.py -name "test" -p "./test02"
  7. ['argv_test.py', '-name', 'test', '-p', './test02']

总结：

今天的内容挺多的，写博客也花了半天时间，不过还是值得的，多看多练多总结。

参考文章：

Python官方文档：https://docs.python.org/zh-cn/3.8/library/time.html#time.mktime

https://docs.python.org/zh-cn/3.8/library/datetime.html