Python 基础笔记 day-10 文件io

文件

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

文本文件

文本文件存储的是普通“字符”文本，python 默认为 unicode 字符集（两个字节表示一个字符，最多可以表示：2**16 = 65536 个），可以使用记事本程序打开。但是，像 word 软件编辑的文档不是文本文件。

二进制文件

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

文件操作和相关模块概述

文件操作相关的模块

创建文件对象 open()

open()函数用于创建文件对象

1. 如果只是文件名，代表在当前目录下的文件。
2. 文件名可以录入全路径，比如：D:\a\b.txt。
3. 可以使用原始字符串：r“d:\b.txt”。示例如下：f = open(r"d:\b.txt",“w”)

打开方式

f = open(‘a123.txt’,‘w’) # 当前目录，写模式，不存在则创建
f = open(‘a123.txt’,‘bw’) # 默认为二进制文件，以字节操作

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

基本操作流程

文本文件的写入一般就是三个步骤：

1. 创建文件对象
2. 写入数据
3. 关闭文件对象
   ！！ 注意一定要关闭

常用编码介绍

ASCII

ASCII 码用 7 位表示，只能表示 128 个字符。

ISO8859-1

GB2312,GBK,GB18030 汉字相关

·GB18030
现在最新的内码字集于 2000 年发布，并于 2001 年强制执行，包含了中国大部分少数
民族的语言字符，收录汉字数超过 70000 余个。

Unicode

Unicode 编码设计成了固定两个字节，所有的字符都用 16 位(2^16=65536)表示

UTF-8 （一般采用）

对于英文字母，unicode 也需要两个字节来表示。所以 unicode 不便于传输和存储。因此而产生了 UTF 编码
UTF 编码是不定长编码，每一个字符的长度从 1-4 个字节不等。其中，英文字母都是用一个字节表示，而汉字使用三个字节
一般项目都会使用 UTF-8。unicode 中虽然汉字是两个字节，UTF-8 中汉字是 3 个字节。但是互联网中一个网页也包含了大量的英文字母，这些英文字母只占用 1 个字节，整体占用空间，UTF-8 仍然优于Unicode

中文乱码问题

windows 操作系统默认的编码是 GBK，Linux 操作系统默认的编码是 UTF-8。当我们用 open()时，调用的是操作系统打开的文件，默认的编码是 GBK。

write()/writelines()写入数据

write(a)：把字符串 a 写入到文件中
writelines(b)：把字符串列表写入文件中，不添加换行符

#测试写入中文
f = open(r"b.txt","w",encoding="utf-8")
f.write("尚学堂\n百战程序员\n")
f.close()

close()关闭文件流

由于文件底层是由操作系统控制，所以我们打开的文件对象必须显式调用 close()方法关闭文件对象。当调用 close()方法时，首先会把缓冲区数据写入文件(也可以直接调用 flush()方法)，再关闭文件，释放文件对象。
为了确保打开的文件对象正常关闭，一般结合异常机制的 finally 或者 with 关键字实现无论何种情况都能关闭打开的文件对象。

#文件关闭操作
try:
    f = open('a123.txt','w')
    str = 'Fredy\n'
    str2= ['11',' 22',' 33']
    f.write(str)
    f.writelines(str2)
except BaseException as e :
    print(e)
finally:
    f.close()
    print('无论是否有异常，都会关闭')

a123.txt:
Fredy
11 22 33

with 语句(上下文管理器)

with 关键字（上下文管理器）可以自动管理上下文资源，不论什么原因跳出 with 块，都能确保文件正确的关闭，并且可以在代码块执行完毕后自动还原进入该代码块时的现场。

s = ["高淇\n","高老三\n","高老五\n"]
with open(r"d:\bb.txt","w") as f:
	f.writelines(s) #自动管理，自动关闭，很好用

with open('a123.txt','w') as f:
    f.write('a123456789')

文本文件的读取

文件的读取一般使用如下三个方法：

1. read([size])
   从文件中读取 size 个字符，并作为结果返回。如果没有 size 参数，则读取整个文件。读取到文件末尾，会返回空字符串。

#测试文件读取
with open(r"e.txt","r",encoding="utf-8") as f:
    str = f.read(3)
    print(str)

全部读取

with open(r"d:\bb.txt","r") as f:
	print(f.read())

2. readline()
   读取一行内容作为结果返回。读取到文件末尾，会返回空字符串。
   按行读取一个文件

with open(r"bb.txt","r") as f:
	while True:
		fragment = f.readline()
		if not fragment:
			break
		else:
			print(fragment,end="")
with open(r"d:\bb.txt","r") as f:
	for a in f:
		print(a,end="")			

3. readlines()
   文本文件中，每一行作为一个字符串存入列表中，返回该列表

with open("e.txt","r",encoding="utf-8") as f:
    lines = f.readlines()
    lines = [ line.rstrip()+" #"+str(index+1)+"\n" for index,line in enumerate(lines)]  #推导式生成列表

二进制文件的写入和读取

我们需要指定二进制模式，从而创建出二进制文件对象

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

with open("aa.gif","rb") as f:
    with open("aa_copy.gif","wb") as w:
        for line in f.readlines():
            w.write(line)

print("图片拷贝完成.........")

文件对象常用属性和方法

文件对象的属性

文件对象的打开模式

文件对象的常用方法

文件任意位置操作

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(0,0)
    print("读取的内容：{0}".format(str(f.readline())))

使用 pickle 序列化

1. 序列化指的是：将对象转化成“串行化”数据形式，这样才能传输
2. 反序列化是指相反的过程，将读取到的“串行化数据”转化成对象。
   我们可以使用 pickle 模块中的函数，实现序列化和反序列操作。

pickle.dump(obj, file) obj 就是要被序列化的对象，file 指的是存储的文件
pickle.load(file) 从 file 读取数据，反序列化成对象

import pickle

a1 = "高淇"
a2 = 234
a3 = [10,20,30,40]

with open("data.dat","wb") as f:
    pickle.dump(a1,f)
    pickle.dump(a2,f)
    pickle.dump(a3,f)

with open("data.dat","rb") as f:
    b1 = pickle.load(f);b2 = pickle.load(f);b3 = pickle.load(f)
    print(b1);print(b2);print(b3)

    print(id(a1));print(id(b1))

在这里插入代码片

输出：
>>>>
高淇
234
[10, 20, 30, 40]
2121240377456
2121493959760

import pickle

a1 = 'Fr'
a2 = 123
a3 = [10,20,30,40]

with open('a123.dat','wb') as f:
    pickle.dump(a1,f)
    pickle.dump(a2,f)
    pickle.dump(a3,f)

with open('a123.dat','rb') as f:
    b1 = pickle.load(f)
    b2 = pickle.load(f)
    b3 = pickle.load(f)

print(f'b1:{b1}\nb2:{b2}\nb3:{b3}\n')

CSV 文件的操作

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

csv.reader 对象和 csv 文件读取

import csv



with open('aa123.csv','r') as f:
    a_csv = csv.reader(f)
    for row in a_csv:
        print(row)

csv.writer 对象和 csv 文件写入

with open('aa123.csv','w') as f:
    b_csv = csv.writer(f)
    b_csv.writerow(['ID','Name','Age'])
    b_csv.writerow(['01','Fr','21'])

    c = [['02','13','54'],['54','45','45']]
    b_csv.writerows(c)

os 和 os.path 模块

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

os 模块-调用操作系统命令

import os

# os.system('notepad.exe') #打开笔记本
# os.system("ping www.baidu.com")
# os.system('ping www.google.com')
# os.startfile(r"C:\Program Files (x86)\Tencent\WeChat\WeChat.exe")

os 模块-文件和目录操作

常用文件操作方法：

常见目录操作方法

#测试 os.path 常用方法
import os
import os.path
#################获得目录、文件基本信息
######################
print(os.path.isabs("d:/a.txt")) #是否绝对路径
print(os.path.isdir("d:/a.txt")) #是否目录
print(os.path.isfile("d:/a.txt")) #是否文件
print(os.path.exists("a.txt")) #文件是否存在
print(os.path.getsize("a.txt")) #文件大小
print(os.path.abspath("a.txt")) #输出绝对路径
print(os.path.dirname("d:/a.txt")) #输出所在目录
########获得创建时间、访问时间、最后修改时间##########
print(os.path.getctime("a.txt")) #返回创建时间
print(os.path.getatime("a.txt")) #返回最后访问时间
print(os.path.getmtime("a.txt")) #返回最后修改时间
################对路径进行分割、连接操作####################
path = os.path.abspath("a.txt") #返回绝对路径
print(os.path.split(path)) #返回元组：目录、文件('C:\\Users\\Administrator\\PycharmProjects\\mypro_io\\test_os', 'a.txt')
print(os.path.splitext(path)) #返回元组：路径、扩展名('C:\\Users\\Administrator\\PycharmProjects\\mypro_io\\test_os\\a','.txt')
print(os.path.join("aa","bb","cc")) #返回路径：aa/bb/cc

os.walk()递归遍历所有文件和目录

返回一个 3 个元素的元组，(dirpath, dirnames, filenames),
dirpath：要列出指定目录的路径
dirnames：目录下的所有文件夹
filenames：目录下的所有文件

shutil 模块(拷贝和压缩)

shutil 模块是 python 标准库中提供的，主要用来做文件和文件夹的拷贝、移动、删除等；还可以做文件和文件夹的压缩、解压缩操作。
os 模块提供了对目录或文件的一般操作。shutil 模块作为补充，提供了移动、复制、压缩、解压等操作，这些 os 模块都没有提供

shutil拷贝

import shutil
#copy 文件内容
shutil.copyfile("1.txt","1_copy.txt")

import shutil
#"音乐"文件夹不存在才能用。
shutil.copytree("电影/学习","音乐",ignore=shutil.ignore_patterns("*.html","*.htm")) #把这个文件夹的内容（电影/学习）拷贝到新建文件夹、（音乐）
# ignore=shutil.ignore_patterns("*.html","*.htm") 即这种类型的文件不拷贝

shutil 压缩

import shutil
#将"电影/学习"文件夹下所有内容压缩到"音乐 2"文件夹下生成 movie.zip
shutil.make_archive("音乐 2/movie","zip","电影/学习")

zipfile 模块

zipfile压缩

import zipfile

#压缩:将指定的多个文件压缩到一个 zip 文件

with open('1.txt','w') as f:
    f.writelines(['123','456','789'])


with open('2.txt','w') as f:
    f.writelines(['123','456','789'])

z = zipfile.ZipFile("a.zip","w")
z.write("1.txt")
z.write("2.txt")
z.close()

zipfile解压

import zipfile
#解压缩：
z2 = zipfile.ZipFile("a.zip","r")
z2.extractall("d:/") #设置解压的地址
z2.close()

递归算法

递归的基本思想就是**“自己调用自己”** 一个使用递归技术的方法将会直接或者间接的调用自己。

递归结构包括两个部分：
定义递归头 ：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
递归体 ：什么时候需要调用自身方法。

举例：算阶乘

def factorial(n):
    if n == 1:
        return 1
    else:
        return n*factorial(n-1)


print(factorial(4))

使用递归算法遍历目录下所有文件

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):
            getFiles(filepath,level+1)
        allfile.append('\t'*level + filepath) #加入缩进，提高层次结构

getFiles(os.getcwd(),0)
for f in reversed(allfile):
    print(f)