2020-12-01 DAY10 文件操作

1313-徐同学

发表文章数:29

热门标签

首页 » Python » 正文

一、文件操作

1.文本文件和二进制文件

按文件中数据组织形式,我们把文件分为文本文件二进制文件两大类

1文本文件

文本文件存储的是普通“字符”文本,python 默认为 unicode 字符集(两个字节表示 一个字符,最多可以表示:65536 个),可以使用记事本程序打开。

2.二进制文件

二进制文件把数据内容用“字节”进行存储,无法用记事本打开。必须使用专用的软件 解码。常见的有:MP4 视频文件、MP3 音频文件、JPG 图片、doc 文档等等

2. 文件操作的相关模块

  1. io模块:   文件流的输入input 和 输出操作output
  2. os模块:基本操作系统功能,包括文件操作
  3. glob模块:查找符合特定规则的文件路径名
  4. fnmatch模块:使用模式来匹配文件路径名
  5. fileinput模块:处理多个输入文件
  6. filecmp模块:文件比较
  7. csv模块:用于csv文件处理
  8. pickle和cPickle模块:用于序列化和反序列化
  9. xml包:用于XML数据处理
  10. bz2,gzip,zipfile,zlib,tarfile:用于处理压缩和解压缩

3.创建文件对象 open()

基本语法:open(文件名[,打开方式])

如果只有文件名,代表在当前目录下的文件。否则就要录入全路径,比如:D:/a/b.txt。

例如:f = open(r"d:/b.txt","w")                            r的作用:申明路径中的"/"不用转义,这样可以减少"/"的输入

2020-12-01    DAY10     文件操作

文本文件对象和二进制文件对象的创建区别在于模式里面有没有加“b”。没有b默认创建的是文本文件,处理的基本单元是“字符”。

如果是二进制模式“b”创建的是二进制文件对象,处理的基本单元是“字节”。

4.文本文件的写入和读取

写入操作:

  1. 创建文件对象
  2. 写入数据
  3. 关闭文件对象(关闭解释器及操作系统打开的相关资源,可以借用with自动完成)
#测试文本写入操作
f=open(r"a.txt","a")
s= "itbaizhan/nsxt/n"    #/n   换行符
f.write(s)
f.close()

 写入数据:write()/writelines()

  1. write(a):把字符串a写入文件中
  2. writelines(b):把字符串列表写入文件,不添加换行符
#测试writelines()写入数据
f = open(r"d:/bb.txt","w",encoding="utf-8")
s = ["高淇/n","高老三/n","高老四/n"]
f.writelines(s)
f.close()

close()关闭文件流

1.由于文件底层是由操作系统控制,所以我们打开的文件对象必须显式调用 close()方法 关闭文件对象。当调用 close()方法时,首先会把缓冲区数据写入文件(也可以直接调用 flush() 方法),再关闭文件,释放文件对象。

2.为了确保打开的文件对象正常关闭,一般结合异常机制的 finally 或者 with 关键字实现 无论何种情况都能关闭打开的文件对象

#使用异常机制管理文件对象的关闭操作
try:
    f=open(r"b.txt","w")
    strs= ["bb/n","cc/n",'ss']
    f.writelines(strs)
except BaseException as e:
    print(e)
finally:
    f.close()

######################################################

#用with关键字实现对象的关闭操作
with open(r"c.txt","a")as f:
    s="i love u"
    f.write(s)

文本文件的读取(有如下3中方式)

  1. read([size]):读取size个字符作为结果返回,若没有size,读取整个文件,末尾返回空字符串
  2. readline():读取一行内容作为结果返回,读取到文件末尾,返回空字符串
  3. readlines():每一行作为一个字符串存入列表中,返回该列表
#测试文本文件的读取
with open(r"a.txt","r")as f:
    # print(f.read(5))       #从文本的第一行开头开始读取5个字符
    # print(f.readline())    #读取文本一行的内容
    # print(f.readline())    #读取下一行内容
    print(f.readlines())     #把读取到的每一行内容作为字符串存入列表中,并返回该列表

练习:

#1.为文本文件每一行的末尾增加行号
with open(r"e.txt","r",encoding="utf-8")as f:
    lines = f.readlines()
    lines = [line.rstrip() + " #" + str(index + 1) + "/n" for index, line in
             enumerate(lines)]  # 推导式生成列表

with open("e.txt","w",encoding="utf-8") as f:
    f.writelines(lines)


#2.使用迭代器(每次返回一行)读取文本文件
with open(r"a.txt", "r")as f:
    for a in f:
        print(a, end="")

5.二进制文件的写入和读取

二进制文件的处理流程和文本文件流程一致。首先还是要创建文件对象,不过,我们需要指 定二进制模式,从而创建出二进制文件对象。例如:

f = open(r"d:/a.txt", 'wb') #可写的、重写模式的二进制文件对象

f = open(r"d:/a.txt", 'ab') #可写的、追加模式的二进制文件对象

f = open(r"d:/a.txt", 'rb') #可读的二进制文件对象

创建好二进制文件对象后,仍然可以使用 write()、read()实现文件的读写操作。

#读取图片文件,实现文件的拷贝
with open('aa.jpg', 'rb') as f:
    with open('aa_copy.jpg', 'wb') as w:
        for line in f.readlines():
            w.write(line)
print('图片拷贝完成!')

6.文件对象的属和性常用方法

属性:

  1. name:返回文件的名字
  2. mode:返回文件的打开模式
  3. closed:若文件被关闭则返回True

常用方法

  1. read([size]):从文件中读取size个字节或字符的内容返回若省略[size],则读取所有内容
  2. readline() :从文本文件中读取一行内容
  3. readlines() :把文本文件中每一行都作为独立的字符串对象,并将这些对象放入 列表返回
  4. write(str):将字符串str的内容写入文件
  5. writelines(s):将字符串列表s写入文件,不添加换行符
  6. seek(offset,[whence]):将文件指针移动到新的位置,offset表示相对于whence的多少个字节偏移量(汉字在utf-8中占3个字节);whence=0:从文件头;whence=1:从当前位置;whence=2:从文件尾;
  7. tell():返回文件指针的当前位置
  8. truncate([size]):不论指针在什么位置,只留下指针前size个字节内容,其余全部删除;若没有size,则删除文档全部内容
  9. flush():缓冲区内容写入文件,但不关闭文件
  10. close():缓冲区内容写入文件,同时关闭文件,释放文件对象相关资源

7.文件任意位置操作

#测试seek()移动文件指针
with open("e.txt","r",encoding="utf-8") as f:
    print("文件名是:{0}".format(f.name))
    print(f.tell())     #获得当前指针位置
    print("读取的内容:{0}".format(str(f.readline())))
    print(f.tell())
    f.seek(5,0)     #whence=0从文件头开始计算 ,5个字节的偏移量,1个汉字=3个字节
    print("读取的内容:{0}".format(str(f.readline())))
    print(f.tell())  #返回文件指针的当前位置(换行符也占用一个字节)

二、重点模块介绍

1.shutil模块(拷贝和压缩)

#coding=utf-8
import shutil
import zipfile
####################### 拷贝  ##################################
# shutil.copyfile("1.txt","1_copy.txt")   #拷贝文件
# shutil.copytree("movie/港台","电影")  #拷贝movie/港台下的子目录内容,只能拷贝一次,目录“电影”下以存在拷贝的内容后,会报错
# shutil.copytree("movie/港台","电影",ignore=shutil.ignore_patterns('*.txt','*.html')) #拷贝是忽略txt和html格式的文件

######################## 压缩  #################################################
# shutil.make_archive("电影/gg","zip","movie/港台") #将movie/港台目录下的内容压缩成zip格式,添加到电影/gg里

#使用zipfile模块压缩文件
z1=zipfile.ZipFile("a.zip","w")  #创建a.zip的压缩包
z1.write("1.txt")   #往创建好的压缩包中添加文件
z1.write("1_copy.txt")
z1.close()   #关闭文件操作

#解压缩
z2=zipfile.ZipFile("a.zip","r")
z2.extractall("电影")    
z2.close()

2.os 和 os.path 模块

os 模块可以帮助我们直接对操作系统进行操作。我们可以直接调用操作系统的可执行 文件、命令,直接操作文件、目录等等。在系统运维的核心基础。

1.os模块—调用操作系统命令

  1. os.system 可以帮助我们直接调用系统的命令
  2. os.startfile:直接调用可执行文件
import os
# os.system('cmd')
# os.system('regedit')
#os.system("notepad.exe")      #调用windows系统记事本程序
# os.system('ping www.baidu.com')  #调用windows系统中的ping命令
# os.startfile(r"C:/Program Files (x86)/Tencent/QQ/Bin/QQScLauncher.exe")  #调用可执行的文件

2.os模块和os.path—文件和目录操作

os模块常用操作:

  1. remove(path):删除指定文件
  2. rename(src,dest):重命名文件或目录
  3. stat(path):返回文件所有属性
  4. listdir(path):返回path目录下的文件和目录列表
  5. mkdir(path):创建目录
  6. makedirs(path1/path2/path3/…):创建多级目录
  7. rmdir(path):删除目录,必须为空
  8. removedirs(path1/path2/…):删除多级目录,目录下必须为空
  9. getcwd():返回当前工作目录
  10. chdir(path):把path设为当前工作目录
  11. walk():遍历目录树
  12. sep:当前操作系统使用的路径分隔符
#coding=utf-8
#测试Os模块中关于文件和目录的操作
import os

##########获取文件和文件夹相关信息###########
# print(os.name)   #windows->nt     linix->posix
# print(os.sep)    #windows->/ linux 和 unix->/   #sep 分隔符

# print(repr(os.linesep))    #windows->/r/n linux-->/n/     #linesep换行符
#repr(obj) 函数将obj对象转化为供解释器读取的形式   返回对象的 string 格式。
# print(os.stat("my02.py"))  #获取文件的所有属性

###############关于工作目录的操作##################################
# print(os.getcwd())   #获取当前的工作目录
# os.chdir("e:")    #改变当前的工作目录为d:根目录
# os.mkdir("书籍")   #在当前工作目录下创建新目录

###########创建目录、创建多级目录、删除##############################
# os.mkdir("书籍")      #创建目录
# os.rmdir("书籍")      #删除目录
# os.makedirs("电影/港台/周星驰")     #创建多级目录
# os.removedirs("电影/港台/周星驰")   #删除多级目录,提前条件目录必须为空
# os.makedirs("../音乐/香港/刘德华")    #../指的是上一级目录
# os.rename("电影","movie")   #重命名文件或目录
dirs=os.listdir("movie")   #以列表的形式显示movie下的子目录,下下级目录不显示
print(dirs)

os.path模块常用操作:

  1. os.path模块提供了目录相关(路径切分,路径判断,路径连接,文件夹遍历)的操作
  2. isabs(path):判断是否为绝对路径
  3. isdir(path):判断是否为目录
  4. isfile(path):判断是否为文件
  5. exists(path):判断指定路径的文件是否存在
  6. getsize(filename):返回文件大小
  7. abspath(path):返回绝对路径
  8. dirname§:返回目录的路径
  9. getatime(filename):返回文件最后访问时间
  10. getmtime(filename):返回文件最后修改时间
  11. walk(top,func,arg):递归方式遍历目录
  12. join(path,*paths):连接多个path
  13. split(path):对路径进行分割,以列表形式返回
  14. splitext(path):从路径中分割文件的扩展名
#encoding=utf-8
#测试os.path中关于目录,路径的操作

import os
import os.path
##############判断绝对路径,文件目录是否存在,是否是文件目录############
# print(os.path.isabs("d:/a.txt"))  #判断d:/a.txt是否为绝对路径,结果True
# print(os.path.isfile("d:/a.txt"))  #d:/a.txt文件不存在, Flase
# print(os.path.isdir("d:/a.txt"))   #d:/a.txt目录不存在, Flase
# print(os.path.exists("d:/a.txt")) #该路径下的文件不存在,Flase
# print(os.path.exists("b.txt"))    #当前目录下写相对路径
# print(os.path.isfile("b.txt"))

#############获得文件基本信息#####################
# print(os.path.getsize("b.txt"))  #获取当前目录下b文件的大小
# print(os.path.abspath("b.txt"))   #返回b文件的绝对路径
# print(os.path.dirname("b.txt"))  #返回b文件的目录路径
#
# print(os.path.getctime("b.txt"))  #返回b文件创建时间,以1970年1月1号0点0分0秒作为原点,到目前为止计算出的毫秒数
# print(os.path.getatime("b.txt"))   #返回文件最后的访问时间
# print(os.path.getmtime("b.txt"))   #返回文件最后的修改时间

################对路径的操作#################################
path=os.path.abspath("b.txt")   #返回b文件的绝对路径
# print(os.path.split(path))   #返回元组,将目录和文件名进行分割  ('D://PycharmProjects//MyTest//Day_10//os_test', 'b.txt')
# print(os.path.splitext(path))   #分割 文件的扩展名  ('D://PycharmProjects//MyTest//Day_10//os_test//b', '.txt')

print(os.path.join("aa","bb","cc"))   #路径连接  aa/bb/cc

练习:列出指定目录下所有的.py 文件,并输出文件名

#coding=utf-8
#列出指定目录下所有的.py 文件,并输出文件名
import os

path = os.getcwd()
file_list = os.listdir(path) #列出子目录和子文件
for filename in file_list:
    if filename.endswith("py"):
        print(filename,end="/t")

#####################通过列表推导式生成子目录################################
file_list2=[filename for filename in os.listdir(path) if filename.endswith("py")]
for f in file_list2:
    print(f)

3.os.walk()方法

返回一个 3 个元素的元组,(dirpath, dirnames, filenames),

  • dirpath:要列出指定目录的路径
  • dirnames:目录下的所有文件夹
  • filenames:目录下的所有文件
#coding=utf-8
#测试os.walk()递归遍历所有的子目录和子文件
import os
all_files=[]
path = os.getcwd()
list_files = os.walk(path)
for dirpath,dirnames,filenames in list_files:
    for dir in dirnames:
        all_files.append(os.path.join(dirpath,dir))
    for file in filenames:
        all_files.append(os.path.join(dirpath,file))
#打印所有的子目录和子文件
for file in all_files:
    print(file)

3.cvs模块

csv文件的操作

csv(Comma Separated Values)是逗号分隔符文本格式,常用于数据交换、Excel 文件和数据库数据的导入和导出。

import csv
#################csv文件的读取#####################
with open("temp.csv","r") as f:     
    a_csv=csv.reader(f)      #创建 csv 对象,它是一个包含所有数据的列表,每一行为一个元素
    # print(list(a_csv))
    for row in a_csv:   #遍历csv文件的内容
        print(row)
        
#############cvs文件的写入############################
with open("ee.csv","w")as f:       
    b_csv=csv.writer(f)     #创建 csv 对象
    b_csv.writerow(["ID","姓名","年龄"])   #单行写入
    b_csv.writerow(["1000", "高奇", "20"])

    c=[["1001","喜喜","8"],["1002","乐乐","15"]] 
    b_csv.writerows(c)      #多行写入

4.pickle和cpickle

序列化将对象转化成串行化的数据,存储到硬盘或通过网络传输到其他位置

pickle.dump(obj, file)        #obj 就是要被序列化的对象,file 指的是存储的文件

反序列化读取到的串行化数据转化成对象

pickle.load(file)        #从 file 读取数据,反序列化成对象

#序列化过程
import pickle
a1="高琪"
a2=234
a3=[20,30,40]
with open(r"data.dat","wb") as f:
    pickle.dump(a1,f)
    pickle.dump(a2,f)
    pickle.dump(a3,f)

 ############# 反序列化###############
with open(r"data.dat","rb") as f:
    b1 = pickle.load(f)
    b2 = pickle.load(f)
    b3 = pickle.load(f)
    print(b1);print(b2);print(b3)  #b1,b2,b3读取出来的值与序列化的a1,a2,a3顺序一致!
print(id(a1));print(id(b1))    #a1和b1不是同一个对象

三、递归算法

递归是一种常见的解决问题的方法,即把问题逐渐简单化。递归的基本思想就是“自己 调用自己”,一个使用递归技术的方法将会直接或者间接的调用自己。

结构包括两部分

  1. 定义递归头:必须要有递归的结束条件
  2. 递归体:自己调用自己的循环体

缺陷:占用大量系统堆栈,内存耗过多,递归调用层次多时速度比循环慢得多

#coding=utf-8
#递归打印所有的目录和文件
import os
allfile = []

def getFiles(path,level):
    childFiles = os.listdir(path)
    for file in childFiles:
        filepath = os.path.join(path,file) #将目录和文件名连接
        if os.path.isdir(filepath):#判断filepath是否是目录,是的话打印下一级目录
            getFiles(filepath,level+1)
        allfile.append("/t"*level+filepath)  #/t缩进的制表符,缩进的空格数等于目录的等级
getFiles(os.getcwd(),0)
for f in reversed(allfile):  
    print(f)

 

标签:

未经允许不得转载:作者:1313-徐同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《2020-12-01 DAY10 文件操作》 发布于2020-12-07

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录