time模块、datetime模块、random模块、sys模块、os模块、序列化模块

time模块

在python中，通常有三种方式来表示时间：

　　1.时间戳：秒数，浮点型

　　2.结构化时间（struct_time）

　　3.格式化的时间字符串（Format String）

时间戳是计算机能识别的时间，我们看不懂

python中时间日期格式化符号

%Y：表示四位数的年份（000-9999）

%y：表示两位数的年份（00-99）

%m：表示月份（1-12）

%M：表示分钟（0==59）

%d：表示一个月中的一天（0-31）

%H：表示二十四制小时（00-23）

%I：表示十二制小时（01-12）

%S：表示秒数

%a：本地简化星期名称

%A：本地完整星期名称

%b：本地简化月份名称

%B：本地完整月份名称

%c：本地相应的日期、时间

%j：一年里的一天

%p：本地A.M.或P.M.的等价符

%U：一年中的星期数（00-53）星期天为一周的开始

%w：星期几（0-6），星期天为开始

%W：一年中的星期数（00-53）星期一为星期的开始

%x：本地相应的日期表示

%X：本地相应的时间表示

%Z：当前时区的名称

%%：%号本身

 

复制代码
 1 # 使用时间模块，需要导入time模块
 2 import time 
 3 time.time()   # 时间戳
 4 time.sleep(3)   # 休眠多少秒
 5 res = time.strftime('%Y-%m-%d %H:%M:%S')  # 2023-06-09 15:18:45 
 6 res = time.strftime('%Y-%m-%d %X')  # 2023-06-09 15:20:13
 7 res = time.strftime('%Y-%m-%d %H:%M')  # 2023-06-09 15:21
 8 res = time.strftime('%Y-%m-%d %H')  # 2023-06-09 15  %H：24小时制小时数（0-23）
 9 res = time.strftime('%Y-%m-%d %I')  # 2023-06-09 03  %I：12小时制小时数（01-12）
10 res = time.strftime('%y-%m')  # 23-06
11 res = time.strftime('%y-%m %a')  # 23-06 Fri
12 res = time.strftime('%y-%m %b')  # 23-06 Jun
13 res = time.strftime('%y-%m %B')  # 23-06 June
14 res = time.strftime('%y-%m %c')  # 23-06 Fri Jun  9 15:31:02 2023
15 res = time.strftime('%y-%m %j')  # 23-06 160
16 res = time.strftime('%y-%m %p')  # 23-06 PM
17 res = time.strftime('%y-%m %U')  # 23-06 23
18 res = time.strftime('%y-%m %w')  # 23-06 5
19 res = time.strftime('%y-%m %%a')  # 23-06 %a
20 print(res)
复制代码

三种格式时间之间的转换

                                              

时间戳和结构化时间之间的转换

复制代码
# 将时间戳转换为结构化时间（struct_time）
res = time.time()  # 1686298502.428151
res1 = time.gmtime(1686298502.428151)
# time.struct_time(tm_year=2023, tm_mon=6, tm_mday=9, tm_hour=8, tm_min=15, tm_sec=2, tm_wday=4, tm_yday=160, tm_isdst=0)
res2 = time.localtime(1686298502.428151)
# time.struct_time(tm_year=2023, tm_mon=6, tm_mday=9, tm_hour=16, tm_min=15, tm_sec=2, tm_wday=4, tm_yday=160, tm_isdst=0)
print(res2)


# 将结构化时间转换为时间戳
time_tuple = time.localtime(1686298502.428151)
print(time.mktime(time_tuple))  # 1686298502.0
复制代码

结构化时间（struct_time）与 格式化的时间字符串（Format String）的转化

复制代码
#结构化时间转换为格式化时间字符串
res = time.strftime("%Y-%m-%d %X")
print(res)  #  2023-06-09 16:53:20
res1 = time.strftime("%Y-%m-%d",time.localtime(1686298502.428151))
print(res1)  # 2023-06-09

#字符串时间-->结构化时间
res2 = time.strptime("2023-06-09","%Y-%m-%d")
print(res2)
# time.struct_time(tm_year=2023, tm_mon=6, tm_mday=9, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=160, tm_isdst=-1)
res3 = time.strptime("06/09/2023","%m/%d/%Y")
print(res3)
# time.struct_time(tm_year=2023, tm_mon=6, tm_mday=9, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=160, tm_isdst=-1)
复制代码

 

datetime模块

日期对象 = 日期对象 +/- timedelta对象
timedelta对象 = 日期对象 +/- 日期对象

自定义操作时间，可以对时间进行运算操作

复制代码
import datetime 
#timedelta 可以对时间进行运算
tdelta = datetime.timedelta(days=7)
print(tdelta)   #7 days, 0:00:00
tday = datetime.datetime.today()
print("7天之后的日期是：%s" % (tday + tdelta))
print("7天之前的日期是：%s" % (tday - tdelta))
# 7天之后的日期是：2023-06-16 16:49:29.762151
# 7天之后的日期是：2023-06-02 16:49:29.762151
复制代码

 

random模块

随机生成小数：

random.random()  生成大于0小于1之间的小数

 random.uniform(1,3)  生成大于1小于3的小数

随机生成整数：

 random.randint(1,5)  生成大于等于1且小于等于5的整数

random.randrange(1,10,2)  生成大于1且小于10的奇数

随机选择一个返回：

 random.choice([1,'23',[4,5]])  括号里的值随机进行一个返回

随机选择多个返回：

 random.sample([1,'23',[4,5]],2)   列表元素任意两个组合（任意几个数字为后面写的参数）

打乱列表顺序：

random.shuffle(i)

sys模块

sys.argv 命令行参数List，第一个元素是程序本身路径

import sys

print(sys.argv)  # ['D:\\python_study\\正则表达式.py']
print(sys.argv[0])   #D:\python_study\正则表达式.py

sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version 获取Python解释程序的版本信息
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称

异常处理

try:
    res=sys.argv[2]
except Exception:
    pass

os模块

 os模块是与操作系统交互的一个接口

os.mkdir('name')  只能创建一个目录

os.makedirs('name1/name2')  可生成多层递归目录

os.rmdir('name')  删除单层目录(文件夹），目录不为空则报错

os.removedirs('nam1/name2/nam3')  删除多层目录

os.listdir('name')  列出指定路径下所有的文件名和子目录，并以列表的形式返回

os.remove('name.后缀名')  删除一个文件

os.rename("oldname","newname")  将文件/目录a重新命名为aa

os.stat('path/filename')  获取文件/目录信息

os.system("bash command")  运行shell命令，并直接显示

os.getcwd()  获取当前工作目录，即当前python脚本工作的路径

os.chdir(r"D:\Typora\python代码\day23\bbb\ccc")  改变当前脚本工作目录，相当于shell下的cd

复制代码
import os

os.mkdir('aaa') # 只能创建出来一层目录
os.makedirs('bbb/ccc')    # 可生成多层递归目录
os.makedirs('bbb/ccc/ddd/eee/fff')    # 可生成多层递归目录
os.rmdir('aaa')
os.removedirs('bbb/ccc')

"""列出指定路径下的文件名和文件件名"""
res=os.listdir('a') # ['a1.txt', 'a2.txt', 'a3.txt', 'aaa']

# 删除一个文件
os.remove('a.txt')

os.rename("a","aa")  # 重命名文件/目录
os.rename("aa.txt","aa.txt.swap")  # 重命名文件/目录

os.stat(r'D:\Typora\python代码\day23')  # 获取文件/目录信息

os.system("tasklist")

os.getcwd()  # D:\python26\day23  os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir(r"D:\Typora\python代码\day23\bbb\ccc")  # 改变当前脚本工作目录；相当于shell下cd
复制代码

os.path

__file__：当前文件所在的绝对路径

os.path.abs(__file__)  返回path规范化的绝对路径

os.path.split(path)  将path分割成目录和文件名 以元组形式返回

os.path.dirname(path)  返回到path的上一级目录

os.path.basename(path)  返回path最后的文件名，如果path以\或者/结果，则返回空值

os.path.exists(path)  判断文件和文件夹的路径是否存在，若存在则返回True ，不存在则返回False

os.path.isabs(path)  如果path是绝对路径，返回True

os.path.isfile(path)  只判断文件，如果path是一个存在的文件，则返回True ,若不存在则返回False

os.path.isdir(path)  判断的是文件夹，若path是一个存在的目录，则返回True，否则返回False

os.path.join（path1） 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间

os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

 

复制代码
# print(__file__)  # D:/Typora/python代码/day23/01 os模块.py
# os.path.abspath(path) 返回path规范化的绝对路径os.path.split(path) 将path分割成目录和文件名二元组返回
res=os.path.abspath(__file__)  # D:/Typora/python代码/day23/01 os模块.py absolute  relative
print(res)
res1=os.path.split(__file__)
print(res1)  #('D:/Typora/python代码/day23', '01 os模块.py')

# os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
print(os.path.dirname("D:/Typora/python代码/day23/01 os模块.py")) # D:/Typora/python代码/day23
print(os.path.dirname(__file__)) # D:/Typora/python代码/day23
print(os.path.dirname(os.path.dirname(__file__))) # D:/Typora/python代码/day23
print(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) # D:/Typora/python代码/day23

# os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
print(os.path.basename(os.path.abspath(__file__)))  # 01 os模块.py
print(os.path.basename(os.path.dirname(__file__)))# D:/Typora/python代码/day23
print(os.path.basename("D:/python26/day23/01 os模块.py")) # 01 os模块.py
print(os.path.basename(os.path.abspath(__file__))) # 01 os模块.py

# os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

"""可以判断文件和文件夹的路径是否存在，如果存在则返回True，否则返回False"""
print(os.path.exists("D:/Typora/python代码/day23/01 os模块.py"))  # True
print(os.path.exists("D:/Typora/python代码/day23"))  # True

# os.path.isabs(path)  如果path是绝对路径，返回True
print(os.path.isabs("D:/Typora/python代码/day23/01 os模块.py"))  # True
print(os.path.isabs("aa"))  # False

# os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
print(os.path.isfile("D:/Typora/python代码/day23/01 os模块.py"))  # True
"""只能判断文件"""
print(os.path.isfile("D:/Typora/python代码/day23")) # False

"""判断的是文件夹"""
# os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
print(os.path.isdir("D:/Typora/python代码/day23"))  # True
print(os.path.isdir("D:/Typora/python代码/day23/01 os模块.py"))  # False

"""拼接路径的，太重要了"""
# os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
# join:它会根据操作系统自定识别路径分隔符
os.path.join("D:/Typora/python代码/day23", "abc")  # D:/Typora/python代码/day23\abc
os.path.join(os.path.dirname(os.path.abspath(__file__)), "abc", 'x', 'y', 'z')  # D:\Typora\python代码\day23\abc\x\y\z

# os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
print(os.path.getatime(os.path.abspath(__file__)))  # 1686557019.7229555
# os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
print(os.path.getmtime(os.path.abspath(__file__)))  # 1686557041.3546944

# os.path.getsize(path) 返回path的大小
print(os.path.getsize(os.path.abspath(__file__))) # 5565  bytes
复制代码

小练习

复制代码
import os
# # 1. 先拼接路径：D:\python26\day23\老师教学视频，把这个文件夹里面的文件名都读取出来
BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # D:\python26\day23
file_path = os.path.join(BASE_DIR, '老师教学视频')  # D:\Typora\python代码\day23\老师教学视频
res = os.listdir(file_path)  # ['jerry.txt', 'kevin.txt', 'qq.txt', 'rose.txt', 'tank.txt']

while True:
    # 1.1 先输出视频列表
    for i,j  in enumerate(res):
        print(i+1, j)

    # 2. 让用户输入视频编号
    cmd = input('请输入你想看的小视频编号:').strip()

    # 3. 判断输入的序号是否合法
    if cmd.isdigit():
        cmd = int(cmd)
        if cmd in range(1, len(res)+1): # 0-4
            # 3.1 开始拼接路径
            file_name_path = os.path.join(file_path, res[cmd-1])

            # 3.2 开始读取文件
            with open(file_name_path, 'r', encoding='utf8') as f:
                print(f.read())
        else:
            print('输入的序号不存在，请重新输入')
    else:
        print('输入的编号不合法')

    print(i+1 ,j)
复制代码

序列化模块（json格式）

json格式实现了跨语言传输

1.序列：就是字符串

2.序列化：就是将其他数据类型转为字符串的过程

3.反序列化：就是把字符串转为其他数据类型的过程

　　"""
　　　　能够直接写入文件的类型有哪些：
　　　　　　1. 字符串
　　　　　　2. 二进制
　　"""

json.dumps  序列化

json.loads  反序列化

json.dump 先序列化再写入文件
json.load 从文件里读出来然后反序列化
" json格式的字符串都是双引号 "

复制代码
# json格式的数据
d = {"username":"kevin"}
import json
"""
    json.dumps : 序列化
    json.loads： 反序列化
"""
res = json.dumps(d)
print(res, type(res)) # {"username": "kevin"} # json格式的字符串:里面必须是双引号

# 反序列化
res1=json.loads(res)
print(res1, type(res1))  # {'username': 'kevin'} <class 'dict'>

# 写入文件
with open('userinfo.txt', 'w' ,encoding='utf8') as f:
    f.write(json.dumps(d))

# 读取文件
with open('userinfo.txt', 'r' ,encoding='utf8') as f:
    data = f.read()
    print(json.loads(data), type(json.loads(data)))  # {'username': 'kevin'} <class 'dict'>
复制代码
复制代码
import json
"""
json.dump
    1. 先序列化
    2. 写入文件
json.load
"""
# 写入文件
with open('userinfo.txt', 'w', encoding='utf8') as f:
    json.dump(d, f)  # f.write(json.dumps(d)) = json.dump(d,f)

# 读取
with open('userinfo.txt', 'r', encoding='utf8') as f:
    # f.write(json.dumps(d))
    res=json.load(f)
    print(res, type(res))

# 补充
d1 = {"username":'hello世界', 'age':18}
print(json.dumps(d1, ensure_ascii=False))  # 以后我们可以阅读源码学习新知识
复制代码

pickle和json的区别

json不是所以的数据类型都可以序列化
pickle能够序列化所有的数据类型，比如：视频、音频、对象等
'pickle序列化之后的数据都只能在python中使用，不能跨语言'
pickle也有四种方法：dumps,loads，dump，load
用法和json一样
pickle序列化之后数据类型为二进制区别是：pickle序列化出来的结果都是二进制类型，字节类型

复制代码
import json
ss = b'{"username":"kevin","age":"18"}'  # bytes
# 1. 先转为字符串
s = ss.decode('utf8')  # {"username":"kevin","age":"18"}
print(s)
print(json.loads(s))  # {'username': 'kevin', 'age': '18'}

# 列表也可以序列化
l = [1, 2, 3]
print(json.dumps(l), type(json.dumps(l)))  # [1, 2, 3]
复制代码
复制代码
import pickle

d2 = {'a':1}
print(json.dumps(d2))
res1 = pickle.dumps(d2)
print(pickle.dumps(d2)) # b'\x80\x04\x95\n\x00\x00\x00\x00\x00\x00\x00}\x94\x8c\x01a\x94K\x01s.'

# 反序列化
res2=pickle.loads(res1)
print(res2)

with open('userinfo.txt', 'wb') as f:
    pickle.dump(d2, f)

with open('userinfo.txt', 'rb') as f:
    res=pickle.load(f)
    print(res)
复制代码

 

posted @   Maverick-Lucky  阅读(51)  评论(0)  编辑  收藏  举报
相关博文：
· 数据类型内置方法的补充
· Python语法入门
· Python常用模块
· day09
· 常用的内置模块
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！
点击右上角即可分享
微信分享提示