python基础之文件操作 内置模块(13)

本文详细介绍了Python中文件的基础操作,包括打开、写入、读取文件,如使用open()、write()、read()、close()函数。还讲解了高级操作模式,如with语句的使用,以及文件操作的相关函数,如shutil模块的复制、移动、解压功能。此外,还介绍了文件指针的移动、截取文件内容等操作。最后,文章提到了其他一些Python标准库的使用,如os、shutil、pickle、math、random等。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

文件操作:
打开文件,读写文件,操作文件内容
写入文件操作:(把大象装进冰箱)
1.打开文件 open() #1.打开冰箱门
2.向文件中添加内容 write() #2.把大象塞进去
3.关闭文件 close() #3.关闭冰箱

读取文件操作:(把大象从冰箱中取出来)
1.打开文件 open() #1.打开冰箱门
2.读取文件内容 read() #2.把大象拿出来
3.关闭文件 close() #3.关闭冰箱
with open(文件,打开方式) as 变量:
变量.操作()

#文件操作相关的函数

open() 打开或者建立文件
格式:open(‘文件路径’,‘打开方式’,encoding = ‘设置字符集’)

打开方式:
基础模式:
w w模式 write 写入模式
1.文件不存在则新建文件,文件存在则打开并且清空文件
2.指针在最前面
(指针对应的是字节)

io = open(“1.txt”,“w”)

塞大象进冰箱

io.write(“这是一个被扔进冰箱的大象”)

关闭冰箱门

io.close()

    r   r模式     read     读取模式
        1.文件不存在则报错,文件已存在则打开文件
        2.指针在最前面

io=open(“1.txt”,“r”)
print(io.read())
io.close()

    x   x模式     xor      异或模式
        1.文件不存在则新建文件,文件已存在则报错
        2.指针在最前面

打开冰箱门
io = open(“2.txt”,“x”)

    a   a模式     append    追加模式
        1.文件不存在则新建文件,文件已存在则打开文件
        2.指针是在最后面

io = open(“1.txt”,“a”)
io.write(“今天开始学习了文件操作”)
io.close()

扩展模式:
    b   b模式     bytes       bytes模式
    +   plus模式              增强模式

文件操作模式:
    w,r,a,x
    wb,rb,ab,xb
    w+,r+,a+,x+
    wb+,rb+,ab+,xb+

w+
io = open(“text.txt”,“w+”)
txt = io.read() # 把大象取出来
print(txt) # 看看大象
io.close() # 关闭冰箱们

r+
io = open(“text.txt”,“r+”)
txt = io.write(“你好啊兄弟”) # 把大象取出来
print(txt) # 看看大象
io.close() # 关闭冰箱们

使用r模式读取图片信息
io = open(“2.jpg”,“rb”)
print(io.read())
io.close()

close():关闭文件对象,方便回收资源
文件打开就要关闭!
输入流(InputStream)和输出流(OutputStream)
read() 读取文件内容
格式:文件io对象.read() *
读取所有内容

  • 格式:文件io对象.read(读取的字节个数)
  • 读取指定长度的字符

readline() 一次读取一行的内容
格式:文件io对象.readline() *
读取一行内容

io = open(“3.txt”,“r”,encoding=“utf-8”)
print(io.readline(1))
io.close()

格式:文件io对象.readline(字节数)
读取内容:如果字符串个数<当前行的字节数,只读取当前行,如果读取的字节数<=当前行字符串,按照指定的长度读取

readlines() 一次读去多行内容 *

io = open(“3.txt”,“r”,encoding=“utf-8”)
print(io.readlines())
io.close()

格式:文件io对象.readlines()
将所有数据按行读取到列表当中去

格式:文件io对象.readlines(字节数)
将所有数据按行读取到列表当中去

注意:如果字节数不满1行按照一行计算
首行如果出现”\ufeff“,叫做叫BOM(ByteOrder Mark)(字节标记)用来声明该文件的编码信息.
解决方案:读取文件时指定编码方式为 "utf-8-sig"即可

write() 向文件中写入内容 *
格式:文件io对象.write(内容)

writelines() 将容器数据写入到文件当中 #

io = open(“2.txt”,“w”)
io.writelines(“你好四届”)
io.close()

格式:文件io对象.writelines(容器类数据)

truncate() 截取文件内容 #

格式:文件io对象.truncate(字节个数)
从文件的首行首字符开始截断,截断文件为 size 个字节,无 size 表示从当前位置(指针)截断;截断之后后面的所有字符被删除

io = open(“3.txt”,“r+”)
io.write(“你好兄弟连在等你来”)
io.close()

io = open(“3.txt”,“r+”)
io.truncate(2)
io.close()

seek() 设置指针的偏移

io = open(“1.txt”,“r”)
print(io.read())
io.seek(0)
print(io.read())
io.close()
#读一遍指针到了末尾,重新定义指针到句首,再读一遍
格式:文件io对象.seek(偏移位置)

高级操作模式

with 方法

with open(参数。。。) as 文件io对象:
具体的操作代码…
具体的操作代码…

with open(“C:\Users\xdl\Desktop\1.txt”,“w”) as io:
io.write(“这是桌面的文件”)

作业3
写一个用户注册的功能.
打开叫 user.txt 的文件,对文件内容进行读取.
User.txt里面的数据内容见附件. 输入用户名,如果用户名存在则提示:抱歉 , 用户名已存在!
,不会确认密码,如果用户名不存在,则输入密码,检测密码是否为空,如果是空则提示,如果不是的话再次输入密码,两次密码一致则提示注册成功 ,
不一致则提示 密码不一致,重新确认密码.

name = input(“请输出您的用户名”)
io = open(“user.txt”, “r”)
for i in io.readlines():
txt1=i.split("?
txt=txt1[0]
io.close()
if name == txt:
print(“用户名已经存在”)
exit()
while True:
mima=input(“请输入您的密码”)
if mima in “”:
print(“密码为空”)
else:
while True:
mima2=input(“再次输入您的密码”)
if mima==mima2:
print(“注册成功”)
io = open(“user.txt”, “a”)
io.write("\n{}".format(name))
io.write(":{}".format(mima))
io.close()
exit()
if mima !=mima2:
print(“两次输入密码不一样”)

作业4
4.尝试利用字典的特性编写一个通讯录程序吧!能够满足查询联系人资料、插入新的联系人、删除已有联系人、退出通讯录程序
其中联系人是人名 , 联系人资料是电话号. 查询和删除的资料就是 插入的 联系人资料.

dict1={}
print(“添加联系人”)
name=input(“输入姓名”)
num=input(‘输入电话号码’)
dict2=dict1.fromkeys(name,num)
print(“添加联系人的信息”,dict2)
print(‘查询联系人’)
name1=input(“输入姓名”)
if name1 in dict2.keys():
print(“这个人的电话号码是”,dict2.get(name1))
print(“删除联系人的信息”)
name2=input(“输入姓名”)
if name2 in dict2.keys():
del dict2[name2]
print(“检验”)
name3=input(“输入姓名”)
if name3 not in dict2.keys():
print(“不在里面”)
exit()

5.写一个抽奖系统。 奖品共有6个。抽完相应的奖品即从奖池删除。直到所有奖品都抽完,提示:奖品已抽取完毕!

import random
print(“欢迎来到兄弟连抽奖******”)
print(“祝您喜提大奖!****”)
list1 = [“青菜”,“肉”,“鸡”,“电脑”,“笔记本”,“1个亿”]
while True:
choice = input("\n开始请按enter键!")
res = random.choice(list1)
print(“本次抽到的奖品为{}”.format(res))
list1.remove(res)
if list1 == []:
print(“奖品已经全部抽取完毕!”)
break

4.写一个文件夹/文件 的增删改功能
输入想要进入的目录,打印出目录下的所有文件和文件夹
请输入你要的操作:1.增加文件/增加文件夹,2.修改文件/文件夹名字,3.删除文件/文件夹的名字,4.退出程序
说明:第四题 功能如有扩展2个及以上的,第3个作业可以减免1遍
import os
while True:
handle_file = input(‘请输入接下来的操作:1:创建文件;2:删除文件;3:修改文件名;4:退出\n’)
if handle_file == ‘1’:
mk_filename = input(‘请输入需要创建的文件名:\n’)
# 创建文件夹
os.mkdir(mk_filename)
# 再次获取列表内容
lists = os.listdir(os.getcwd())
#利用成员检测判断是否创建成功
if mk_filename in lists:
print(‘创建成功!恭喜您!’)

elif handle_file == '2':
    # 再次获取列表内容
    lists = os.listdir(os.getcwd())
    rm_filename = input('请输入需要删除的文件名:\n')
    # 判断删除的文件是否在列表里
    if rm_filename in lists:
        os.rmdir(rm_filename)       
        print('删除成功!')
    else:
        print("文件夹不存在,请重新选择操作方法!!")
    
elif handle_file == '3':
    lists = os.listdir(os.getcwd())
    #使用while循环判断输入的名称是否存在
    while True:
        res = input('请输入需要修改的文件或文件夹名称:\n')
        if res not in lists:
            print('对不起,您输入的文件或文件夹名不存在,请确认后重新输入!')
        else:
            break
    n_filename = input('请输入修改后的名称:\n')
    # 修改名字
    os.rename(res,n_filename)
    print('修改成功!')
    
elif handle_file == '4':
    exit()
    
else:
    print('输入有误,请输入提示的内容,谢谢!')

序列化模块-pickle
#dumps 把任意对象序列化成一个bytes
序列化:把不能够存储的数据变得可存储(例如列表,元祖,字典等)
pickle.dumps(数据)

list1 = {“鲁智深”:“爽”,“宋江”:“虚弱”}
res = pickle.dumps(list1)
print(res)

#loads 把任意bytes反序列化成原来数据
反序列化:把存储的内容拿出来,转换成原来的数据类型。

by = b’\x80\x03}q\x00(X\t\x00\x00\x00\xe9\xb2\x81\xe6\x99\xba\xe6\xb7\xb1q\x01X\x03\x00\x00\x00\xe7\x88\xbdq\x02X\x06\x00\x00\x00\xe5\xae\x8b\xe6\xb1\x9fq\x03X\x06\x00\x00\x00\xe8\x99\x9a\xe5\xbc\xb1q\x04u.’
res = pickle.loads(by)
print(res,type(res))

#dump 把对象序列化后写入到file-like Object(即文件对象)
with open(文件名,“wb”) as 变量1:
pickle.dump(内容,变量1)

dict1 = {“鲁智深”:“爽”,“宋江”:“虚弱”}
io = open(“1.txt”,“wb”)
pickle.dump(dict1,io)
io.close()

#load 把file-like Object(即文件对象)中的内容拿出来,反序列化成原来数据
with open(文件名,“wb”) as 变量:
pickle.load(变量)

io = open(“1.txt”,“rb”)
res = pickle.load(io)
print(res)
io.close()

数学模块-math
必须先调用模块 import math

ceil() 向上取整操作 (对比内置round)
格式: math.ceil(数值)
返回值:整型

num = 3.1
res = math.ceil(num)
print(res)

floor() 向下取整操作 (对比内置round)
格式: math.floor(数值)
返回值:整型

num = 3.1
res = math.floor(num)
print(res)

pow() 计算一个数值的N次方(结果为浮点数)
格式:math.pow(底数,指数)
返回值:浮点型

print(pow(2,3))
print(math.pow(2,3))

sqrt() 开平方运算(结果浮点数)
格式:math.sqrt(数值)
返回值:数值

num = 8
print(math.sqrt(num))

fabs() 计算一个数值的绝对值 (结果浮点数) (对比内置abs)
格式: math.fabs(数值)
返回值:一定是非负浮点数
注意:在操作时如果操作的数值本身是整数,返回的数值依旧是绝对值计算之后的浮点数

num = -8
print(math.fabs(num))

modf() 将一个数值拆分为整数和小数两部分组成元组
格式:math.modf(数值)
返回值:(小数部分,整数部分)

num = 3
print(math.modf(num))

copysign() 将参数第二个数值的正负号拷贝给第一个
格式:math.copysign(数值1,数值2)
返回值:新的数值

print(math.copysign(1,-2))

fsum() 将一个容器数据中的数据进行求和运算 (结果浮点数)(sum)
格式: math.fsum(容器)
返回值:求和后的结果

print(math.fsum([1,2,3,4,5]))

#圆周率常数 pi 注意:不是函数。 math.pi
随机模块-random
random() 获取随机0-1之间的小数(左闭右开)
格式:random.random()
返回值:随机0-1之间的小数

res = random.random()
print(res)

randrange() 随机获取指定范围内的整数(包含开始值,不包含结束值,间隔值)
格式:random.randrange([开始值,]结束值[,间隔值])
返回值: 随机返回指定范围内的指定间隔的数值
注意:默认开始值为0,默认间隔值为1

res = random.randrange(1,10,2)
print(res)

randint() 随机产生指定范围内的随机整数(闭区间)
格式:randint(low,high)
#在numpy里面的randint:
格式:randint(low[, high, size])
参数:low为最小值,high为最大值,size为数组维度大小
high没有填写时,默认生成随机数的范围是[0,low)
返回值:返回指定范围内的随机整数

res = random.randint(10,15)
print(res)

uniform() 获取指定范围内的随机小数(左闭右开)
格式:random.uniform(开始值,结束值)
返回值:随机返回开始和结束之间的小数。

res = random.uniform(10,15)
print(res)

choice() 随机获取序列中的值(字符串,列表,元组)
格式:random.choice(序列)
返回值:序列中的某个值

list=[“你没”,“你哥”,3,4,5]
res=random.choice(list)
print(res)

shuffle() 随机打乱列表中的值(直接打乱原序列)
格式:random.shuffle(列表)
返回值:None

list=[“你没”,“你哥”,3,4,5]
random.shuffle(list)
print(list)

os模块-对系统进行操作
模块调用必须要 import os
getcwd() 获取当前的工作目录 get current work directory
格式:os.getcwd()
返回值:当前工作目录的地址字符串
注意:当前工作目录:操作文件或者文件夹等信息的默认查找使用的文件夹

print(os.getcwd())

chdir() 修改当前的工作目录
格式:os.chdir(要设置的工作目录)
返回值:无

os.chdir("…/第10天")

listdir() 获取指定文件夹中的所有内容的信息组成的列表
格式:os.listdir(路径)
返回值:存放所有内容名称的列表

res=os.listdir("./")
print(res)

mkdir() 创建文件夹

    格式:os.mkdir(文件夹路径,权限设置)
    返回值:无
    以下内容对linux有效,window无所谓
        0o           7          7           7
       八进制       所有者      所属组    	其他人
       所有者:文件夹或者文件归谁所有    admin 用户
       所属组:所有者所在的组别          group用户
       其他人: 不是所有者或者所属组的其他用户 other用户
       权限划分:
            可读,可写,可执行
             4      2     1

os.mkdir(“lin”)

makedirs() 递归创建文件夹
格式:os.makedirs(路径,权限)
返回值:无

os.makedirs(“D:/py.练习/每日作业/第九天/day9/day9-1”)

rmdir() 删除空文件夹
格式:os.rmdir(路径)
返回值:无

os.rmdir("…/第九天")

removedirs() 递归删除空文件夹
格式:os.removedirs(路径)
返回值:无

os.removedirs("…/第九天/day9/day9-1")

rename() 修改文件或者文件夹的名称
格式:os.rename(‘来源路径’,‘目标路径’)
返回值:无

os.rename(“day11-2.py”,“day11-4.py”)

stat() 获取文件或者文件夹的状态信息(很少用)
格式:os.stat(路径)
返回值:容器数据 保存着很多的文件夹和文件的信息

os.stat(“day11-4.py”)

system() 执行操作系统的命令(少用)
格式:os.system(‘系统命令’)
返回值:无
注意:linux,和window,unix的命令是不同的

os.system(‘calc’)

#调用计算机
os路径模块 -os.path
abspath() 将相对路径转化为绝对路径 *
格式:os.path.abspath(路径)
返回值:绝对路径

print(os.path.abspath(“day10.py”))

basename() 获取路径的主体部分
格式:os.path.basename(路径)
返回值:主体部分

res=os.path.basename(“D:\py.练习\每日作业\第10天”)
print(res)

dirname() 获取路径中路径部分
格式:os.path.dirname(路径)
返回值:路径部分

res=os.path.dirname(“D:\py.练习\每日作业\第10天”)
print(res)

join() 将两个路径合并到一起
格式:os.path.join(路径1,路径2)
返回值:组合之后的路径信息

res=os.path.join(“D:\py.练习\每日作业\第10天”,“D:\py.练习\每日作业”)
print(res)

split() 直接将路径拆分成路径部分和主体部分组成的元组
格式:os.path.split(路径)
返回值:主体和路径组成的元组

res=os.path.split(“D:\py.练习\每日作业\第10天”)
print(res)

splitext() 将路径拆分为文件后缀和其他部分
格式:os.path.splitext(路径)
返回值:后缀信息和其他信息组成的元组

res=os.path.splitext(“D:/py.练习/每日作业/第10天/day10.py”)
print(res)

getsize() 获取文件的大小 *
格式:os.path.getsize(文件路径)

res=os.path.getsize(‘D:/py.练习/每日作业/第10天/day10.py’)
print(res)

isdir() 检测是否是一个文件夹 *
格式:os.path.isdir(路径)
返回值:布尔值

res=os.path.isdir(“D:/py.练习/每日作业/第10天”)
print(res)

isfile() 检测是否是一个文件 *
格式:os.path.isfile(路径)
返回值:布尔值

res=os.path.isfile(‘D:/py.练习/每日作业/第10天/day10.py’)
print(res)

islink() 检测是否是一个连接(linux)
Windows“链接”是一种特殊的Windows功能(快捷方式),
必须通过Win32 api 调用或搜索快捷方式的内容特征来检测。

getctime() 获取文件的创建时间 get create time
格式:os.path.getctime()
返回值:创建文件的时间戳

getmtime() 获取文件的修改时间 get modify time
格式:os.path.getmtime()
返回值:修改文件的时间戳

getatime() 获取文件的访问时间 get active time
格式:os.path.getatime()
返回值:最后一次访问文件的时间戳

exists() 检测指定路径是否真的存在
格式:os.path.exists(路径)
返回值:布尔值

result = os.path.exists(“F:/project/text.py”)
print(result)

isabs() 检测路径是否是一个绝对路径
格式:os.path.isabs(路径)
返回值:布尔值

result = os.path.isabs(“F:/project/text.py”)
print(result)

samefile() 检测两个路径是否指向同一个文件或者文件夹 *
格式:os.path.samefile(路径1,路径2)
返回值:布尔值

res = os.path.samefile(“F:/project/day1/day1_2.py”,"…/day1/day1_3.py")
print(res)

shutil模块

– shutil模块 复制/移动/

copy() 复制文件 *
格式:copy(src, dst)
参数:src 文件来源路径
dst 文件目标路径
返回值:目标文件地址

shutil.copy(“day11.py”,"…/第10天")

copy2() 复制文件,保留原有文件的信息(操作时间和权限等) *
格式:copy2(src, dst)
参数:src 文件来源路径
dst 文件目标路径
返回值:目标文件地址

shutil.copy2(“day11.py”,"…/第10天")

copyfile() 复制文件内容(打开文件之后读取内容 ,在新建文件复制进去) *
格式:copyfile(src,dst)
参数:src 文件来源路径
dst 文件目标路径
返回值:目标文件地址

shutil.copyfile(“day11.py”,“1.txt”)

copystat() 拷贝文件状态信息
格式:copystat(src,dst)
参数:src 文件来源路径
dst 文件目标路径
返回值:None

shutil.copystat(“day11.py”,“1.txt”)

copymode() 拷贝文件权限(linux下操作)
格式:copymode(src,dst)
参数:src 文件来源路径
dst 文件目标路径
返回值:None

copytree() 拷贝整个文件夹 *
格式:copytree(src,dst)
参数:src 来源文件夹
dst 目标文件夹
返回值:目标地址路径

shutil.copytree(“D:/py.练习/每日作业/第10天”,“D:/py.练习/每日作业/第九天”)

rmtree() 删除整个文件夹 *
格式:rmtree(path)
参数:path 要删除的文件夹路径
返回值:None

shutil.rmtree(“D:/py.练习/每日作业/第九天”)

move() 移动文件或者文件夹/剪切操作(修改文件和文件夹名称也可以使用该函数!) *
格式:move(src,dst)
参数:src 来源路径
dst 目标路径
返回值:目标路径

shutil.move(“D:/py.练习/每日作业/第10天/day11.py”,“D:/py.练习/每日作业/第11天/day11-1.py”)
shutil.move(“1.txt”,"…/第10天/2.txt")

disk_usage() 查看磁盘使用量
格式:disk_usage(‘盘符’)
返回值:盘符使用情况

res=shutil.disk_usage(“D:”)
print(res)

压缩模块-zipfile (后缀为zip)
#zipfile.ZipFile(file[, mode[, compression[, allowZip64]]])
#ZipFile(路径包名,模式,压缩or打包,可选allowZip64)
#功能:创建一个ZipFile对象,表示一个zip文件.
#参数:
-参数file表示文件的路径或类文件对象(file-like object)
-参数mode指示打开zip文件的模式,默认值为r
r 表示读取已经存在的zip文件
w 表示新建一个zip文档或覆盖一个已经存在的zip文档
a 表示将数据追加到一个现存的zip文档中。
-参数compression表示在写zip文档时使用的压缩方法
zipfile.ZIP_STORED 只是存储模式,不会对文件进行压缩,这个是默认值
zipfile.ZIP_DEFLATED 对文件进行压缩
-如果要操作的zip文件大小超过2G,应该将allowZip64设置为True。

压缩文件
1.ZipFile() 写模式w打开或者新建压缩文件
2.write(路径,别名) 向压缩文件中添加文件内容
3.close() 关闭压缩文件

import zipfile
with zipfile.ZipFile("…/第11天/day12.zip",“w”,compression=zipfile.ZIP_DEFLATED)as res:
res.write("…/第11天/day11.py",“day11.py”)#通过取别名可以防止压缩文件中有嵌套文件存在

#解压文件
#1.ZipFile() 读模式r打开压缩文件
#2.extractall(路径) 解压所有文件到某个路径下

extract(文件,路径) 解压指定的某个文件到某个路径下

#3.close() 关闭压缩文件

import zipfile
with zipfile.ZipFile("…/第11天/day12.zip",“r”,compression=zipfile.ZIP_DEFLATED)as res:
res.extract(“day11.py”,"./")

压缩模块-tarfile(后缀为.tar | .tar.gz | .tar.bz2)
#bz2模式的压缩文件较小 gz相对bz2大

w 单纯的套一个后缀 打包
w:bz2 采用bz2算法 压缩
w:gz 采用gz算法 压缩
with tarfile.open(路径,“w:bz2”) as tf:
tf.add()

import tarfile
with tarfile.open(“tar_try.tar”,“w”)as tr:
tr.add(“day12.py”)

import tarfile
with tarfile.open(“tar_try.tar”,“w:bz2”)as tr:
tr.add(“day12.py”)
tr.add("…/第11天/day11.py",“day11.py”)

with tarfile.open(“tar_try.tar”,“w:gz”)as tr:
tr.add(“day12.py”)
tr.add("…/第11天/day11.py",“day11.py”)

#压缩文件
#1.open(‘路径包名’,‘模式’,‘字符编码’) 创建或者打开文件
#2.add(路径文件,arcname=“别名”) 向压缩文件中添加文件
#3,close() 关闭文件

#解压文件
#1.open(‘路径包名’,‘模式’,‘字符编码’) 读模式打开文件
#2.extractall(路径) 解压所有文件到某个路径下

extract(文件,路径) 解压指定的某个文件到某个路径下

#3.close() 关闭压缩文件
with tarfile.open(路径1,“r”) as tf:
tf.extractall(路径2)

with tarfile.open("…/第11天/tar_try.tar.bz2",“r”)as tr:
tr.extract(“day10.py”,"…/第10天/day10-1.py")#extract(要解压的指定文件,将解压的文件放置的位子-同时可以给他起别名)

with tarfile.open("…/第11天/tar_try.tar.gz",“r”)as tr:
tr.extract(“day10.py”,"…/第10天/day10-1.py")#extract(要解压的指定文件,将解压的文件放置的位子-同时可以给他起别名)

#追加文件
open() 追加模式 a: 打开压缩文件 正常添加即可
with tarfile.open(文件,“a”) as tf:
tf.add(“路径”,“别名”)

#查看压缩包中的内容
getnames()
时间模块
time() 获取本地时间戳 *
格式:time.time()
参数:无
返回值:时间戳

import time
print(time.time())

ctime() 获取本地时间字符串(参数是时间戳,默认当前)
格式:time.ctime(时间戳)
参数:时间戳
返回值:字符串

print(time.ctime(1559563834.457381))

#结果为Mon Jun 3 20:10:34 2019

localtime() 获取本地时间元组 (参数是时间戳,默认当前) *
格式:time.localtime(时间戳)
参数:时间戳
返回值:时间元组

print(time.localtime(1559563834.457381))

#结果为:time.struct_time(tm_year=2019, tm_mon=6, tm_mday=3, tm_hour=20, tm_min=10, tm_sec=34, tm_wday=0, tm_yday=154, tm_isdst=0)

mktime() 通过时间元组获取时间戳 (参数是时间元组)
格式:time.mktime(时间元组)
参数:时间元组
返回值:时间戳

res=time.mktime((2019,10,1,1,5,45,0,0,0))
print(res)

#后三位不输可以0代替

asctime() 通过时间元组获取时间字符串(参数是时间元组)
格式:time.asctime(时间元组)
参数:时间元组
返回值:字符串

res=time.asctime((2019,10,1,1,5,45,0,0,0))
print(res)

#Mon Oct 1 01:05:45 2019

sleep() 程序睡眠等待 *
格式:time.sleep(秒数)
参数:数值
返回值:无

print(“hello”)
sleep(5)
print(“hello”)

strftime() 格式化时间字符串(格式化字符串,时间元祖) *
格式:time.strftime(格式化字符串,时间元组)
参数:格式化字符串,时间元组(可选)
返回值:字符串
注意:第二个参数如果不选,则默认为当前时间

res=time.strftime("%Y{}-%m{}-%d{} %H{}-%M{}-%S{} %A{} %p{}",(2019,6,3,4,5,6,0,0,0))
print(res.format(“年”,‘月’,‘日’,‘时’,‘分’,‘秒’,‘星期’,‘上下午’))

#结果为
2019年-06月-03日 04时-05分-06秒 Monday星期 AM上下午

#strptime() 将时间字符串通过指定格式提取到时间元组中(时间字符串,格式化字符串) *
格式:time.strptime(时间字符串,格式化字符串)
参数:时间字符串,格式化字符串
返回值:时间元组

res=time.strptime(“2019,6,3,2,12,5”,"%Y,%m,%d,%H,%M,%S")
print(res)
#结果为time.struct_time(tm_year=2019, tm_mon=6, tm_mday=3, tm_hour=2, tm_min=12, tm_sec=5, tm_wday=0, tm_yday=154, tm_isdst=-1)

res=input(“请输入 年-月-日”)
print(“当前年已经过去了{}天”.format(time.strptime(res,"%Y-%m-%d")[7]))

#perf_counter() 用于计算程序运行的时间 *
格式:time.perfcounter()
参数:无
返回值:计数器的值(以分秒为单位)

start=time.perf_counter()
for i in range(10000):
pass
time.sleep(4)
end=time.perf_counter()
print(“该操作总过花了{}秒的时间”.format(end-start))

时间模块相关知识
#时间戳指从1970年1月1日0时0分0秒到指定时间之间的秒数,时间戳是秒,可以使用到2038年的某一天
#UTC时间: 世界约定的时间表示方式,世界统一时间格式,世界协调时间!,特指格林尼治天文台所在位置的时间也叫做格林尼治时间。中国的时区是东八区,和世界协调时间差了8个小时,多个八个小时
#夏令时: 在夏令时时间状态下,时间会调块1个小时

#时间元组是使用元祖格式表示时间的一种方式,他是time模块操作时间的主要方式。
格式1(自定义):
(年,月,日,时,分,秒,周几,一年中的第几天,是否是夏令时时间)
格式2(系统提供):
(tm_year = 年,tm_month = 月,tm_day = 日,tm _hour = 时, tm_min = 分, tm _sec = 秒, tm _wday = 周几, tm _yday = 一年中的第几天,tm_isdst = 是否是夏令时时间)

    0   年   4位数完整年份    四位数1997
    1   月   1-12月           1 - 12
    2   日   1-31天           1 - 31
    3   时   0-23时           0 - 23
    4   分   0-59分           0 - 59
    5   秒   0-61秒           0 - 61 #闰秒
    6   周几 周一-周天         0 - 6
    7   年中第几天    共366天  1 - 366
    8   夏令时  两种           0,1  0是  其他都不是  

#strftime()格式化时间字符串:
格式 含义
%a 本地(locale)简化星期名称
%A 本地完整星期名称
%b 本地简化月份名称
%B 本地完整月份名称
%c 本地相应的日期和时间表示
%d 一个月中的第几天(01 - 31)
%H 一天中的第几个小时(24 小时制,00 - 23)
%I 一天中的第几个小时(12 小时制,01 - 12)
%j 一年中的第几天(001 - 366)
%m 月份(01 - 12)
%M 分钟数(00 - 59)
%p 本地 am 或者 pm 的相应符
%S 秒(01 - 61)
%U 一年中的星期数(00 - 53 星期天是一个星期的开始)第一个星期天之前的所有天数都放在第 0 周
%w 一个星期中的第几天(0 - 6,0 是星期天)
%W 和 %U 基本相同,不同的是 %W 以星期一为一个星期的开始
%X 本地相应时间
%y 去掉世纪的年份(00 - 99)
%Y 完整的年份
%z 用 +HHMM 或 -HHMM 表示距离格林威治的时区偏移(H 代表十进制的小时数,M 代表十进制的分钟数)
例:
日历模块-calendar(了解内容)
#–calendar 日历模块 import calendar
#calendar() 获取指定年份的日历字符串 (年份,w日期间的宽度,l日期间的高度,c月份间的间距,m一行显示几个月)

calendar.calendar(2018,w=2,l=2,c=20,m=1)

#month() 获取指定年月的日历字符串 (年份,月份,w日期之间的宽度,l日期之间的高度)

calendar.month(2018,9,w = 2,l = 2)

#monthcalendar() 获取指定年月的信息列表 (年份,月份) 0从周一开始排

calendar.monthcalendar(2018,9)

#isleap() 检测是否是润年(能被4整除不能被100整除或能被400整除)

calendar.isleap(2004)

#leapdays() 指定从某年到某年范围内的润年个数
calendar.leapdays(1970,2038)

#monthrange() 获取某年某月的信息 周一是0

calendar.monthrange(2018,8)

#weekday() 指定某年某月某日是星期几

calendar.weekday(2018,8,18)

#timegm() 将时间元组转化为时间戳

ttp = (2018,10,1,13,23,34,0,0,0)

calendar.timegm(ttp)

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值