Python基础（八）- 文件操作（IO技术）

一个完整的程序一般都包括数据的存储和读取。很多软件系统是将数据存储的数据库中； 数据库实际也是基于文件形式存储的。

文本文件和二进制文件

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

1. 文本文件
   文本文件存储的是普通“字符”文本，python 默认为 unicode 字符集（两个字节表示 一个字符，最多可以表示：65536 个），可以使用记事本程序打开。但是，像 word 软件 编辑的文档不是文本文件。
2. 二进制文件
   二进制文件把数据内容用“字节”进行存储，无法用记事本打开。必须使用专用的软件 解码。常见的有：MP4 视频文件、MP3 音频文件、JPG 图片、doc 文档等等。

文件操作相关模块概述

Python 标准库中，如下是文件操作相关的模块：

创建文件对象 open()

open()函数用于创建文件对象，基本语法格式如下：

open(文件名[,打开方式])

如果只是文件名，代表在当前目录下的文件。文件名可以录入全路径，比如：D:\a\b.txt。
为了减少转义字符“\”的输入，可以使用原始字符串：r“d:\b.txt”。
示例如下：

f = open(r"d:\b.txt","w")

打开方式有如下几种：

文本文件对象和二进制文件对象的创建：
如果我们没有增加模式“b”，则默认创建的是文本文件对象，处理的基本单元是“字 符”。
如果是二进制模式“b”，则创建的是二进制文件对象，处理的基本单元是“字节”。

文本文件的写入

基本的文件写入操作

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

1. 创建文件对象
2. 写入数据
3. 关闭文件对象

# 测试文件写入操作
f = open('a.txt','w')
f.write('i love python!')  # 调用操作系统的资源对文件进行写入
f.close()

结果：

常用编码介绍

在操作文本文件时，经常会操作中文，这时候就经常会碰到乱码问题。这里简单介绍一下各种编码之间的关系。

ASCII

 全称为 American Standard Code for Information Interchange，美国信 息交换标准代码，这是世界上最早最通用的单字节编码系统，主要用来显示现代英语及其他西欧语言。
 ASCII 码用 7 位表示，只能表示 128 个字符。只定义了 2^7=128 个字符，用 7bit 即可完全编码，而一字节 8bit 的容量是 256，所以一字节 ASCII 的编码最 高位总是 0。
 0～31 表示控制字符如回车、退格、删除等；32～126 表示打印字符即可以 通过键盘输入并且能显示出来的字符；其中 48～57 为 0 到 9 十个阿拉伯数字， 65～90 为 26 个大写英文字母，97～122 号为 26 个小写英文字母，其余为一 些标点符号、运算符号等，具体可以参考 ASCII 标准表（大家自行百度，不在此 赘述）。

ISO8859-1

 ISO-8859-1 又称 Latin-1，是一个 8 位单字节字符集，它把 ASCII 的最高 位也利用起来，并兼容了 ASCII，新增的空间是 128，但它并没有完全用完。
 在 ASCII 编码之上又增加了西欧语言、希腊语、泰语、阿拉伯语、希伯来语 对应的文字符号，它是向下兼容 ASCII 编码。

GB2312,GBK,GB18030

目前市场上GB2312,GBK使用的最多。

• GB2312
  GB2312 全称为信息交换用汉字编码字符集，是中国于 1980 年发布，主要用于计算机系统中的汉字处理。GB2312 主要收录了 6763 个汉字、682 个符号。
   GB2312覆盖了汉字的大部分使用率，但不能处理像古汉语等特殊的罕用字， 所以后来出现了像 GBK、GB18030 这种编码。
  GB2312 完全兼容 ISO8859-1。
• GBK
  全称为 Chinese Internal Code Specification，即汉字内码扩展规范，于 1995 年制定。 它主要是扩展了 GB2312，在它的基础上又加了更多的汉字，它一共收录了 21003 个汉字。
• GB18030
  现在最新的内码字集于 2000 年发布，并于 2001 年强制执行，包含了中国大部分少数 民族的语言字符，收录汉字数超过 70000 余个。
   它主要采用单字节、双字节、四字节对字符编码，它是向下兼容 GB2312 和 GBK 的， 虽然是我国的强制使用标准，但在实际生产中很少用到，用得最多的反而是 GBK 和 GB2312。

Unicode

 Unicode 编码设计成了固定两个字节，所有的字符都用 16 位(2^16=65536) 表示，包括之前只占 8 位的英文字符等，所以会造成空间的浪费，UNICODE 在 很长的一段时间内都没有得到推广应用。
 Unicode 完全重新设计，不兼容 iso8859-1，也不兼容任何其他编码。

UTF-8

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

中文乱码问题

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

# 指定操作系统创建文件时的文件编码，不写，则如果使用的windows系统则会以GBK编码写入文件
f = open('a.txt','w',encoding = 'utf-8')

write()/writelines()写入数据

write(a)：把字符串 a 写入到文件中
writelines(b)：把字符串列表写入文件中，不添加换行符，仅仅只是写入列表内容，并不会自动添加换行符。

close()关闭文件流

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

try:
    f = open(r"my01.txt","a")
    str = "python"
    f.write(str)
except BaseException as e:
    print(e)
finally:
    f.close()

with 语句(上下文管理器)

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

s = ['我','爱','python']
with open('a.txt','w') as f:
    f.writelines(s)

文件a.txt:

文本文件的读取

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

1. read([size])
   从文件中读取 size 个字符，并作为结果返回。如果没有 size 参数，则读取整个文件。 读取到文件末尾，会返回空字符串。
2. readline()
   读取一行内容作为结果返回。读取到文件末尾，会返回空字符串。
3. readlines()
   文本文件中，每一行作为一个字符串存入列表中，返回该列表。

测试read()

with open('a.txt','r') as f:
    print(f.read())
    
输出：
我爱python
oh

测试read(size)

with open('a.txt','r') as f:
    print(f.read(3))
    
输出：
我爱p

测试readline按行读取一个文件

with open('a.txt','r') as f:
    r = f.readline()
    while(r):
        print(r)
        r = f.readline()
        
输出：
我爱python

oh

测试realines()读取多行存入列表

with open('a.txt','r') as f:
    l = f.readlines()
    print(l)
    
输出：
['我爱python\n', 'oh']

函数推导式生成，为每行增加行号

'''
我
爱
python
'''
with open('a.txt','r',encoding='utf-8') as f:
    l = f.readlines()
    print(l)
    nl = [str(index) +'.\t' + s.lstrip() for index,s in enumerate(l)]

with open('a.txt','w') as f:
    f.writelines(nl)

输出：
['我\n', '爱\n', 'python']

结果：

二进制文件的读取和写入

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

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('pic.png','rb') as f:
    r = f.readlines()
    with open('pic_copy.png','wb') as wf:
        for line in r:
            wf.write(line)

原始图像pic.png：

拷贝后的图像pic_copy.png：

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

文件对象封装了文件相关的操作。我们详细列出文件对象的常用属性和方法，并进行说明。
文件对象的属性：

文件对象的打开模式：

文件对象的常用方法

文件任意位置操作

seek()移动文件指针示例
文件内容：

我爱
python，
今天
天气不错。

with open('a.txt','r') as f:
    print('文件名是:{0}'.format(f.name))
    print(f.tell())
    print(f.readline(),end='')
    print(f.tell())
    f.seek(0)
    print(f.readline(),end='')
    print(f.tell())
    print(f.readline(),end='')
    print(f.tell())

输出：
文件名是:a.txt
0
我爱
6
我爱
6
python，
17

使用 pickle 序列化

Python 中，一切皆对象，对象本质上就是一个“存储数据的内存块”。有时候，我们 需要将“内存块的数据”保存到硬盘上，或者通过网络传输到其他的计算机上。这时候，就 需要“对象的序列化和反序列化”。对象的序列化机制广泛的应用在分布式、并行系统上。
 序列化指的是：将对象转化成“串行化”数据形式，存储到硬盘或通过网络传输到其他 地方。反序列化是指相反的过程，将读取到的“串行化数据”转化成对象。
 我们可以使用 pickle 模块中的函数，实现序列化和反序列操作。
序列化我们使用：

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

将对象序列化到文件中

import pickle
with open('data.txt','wb') as f:
    a1 = 'sherry'
    a2 = 100
    a3 = {'name':'sherry','age':24}
    a4 = [1,2,3,4,5]
    pickle.dump(a1,f)
    pickle.dump(a2,f)
    pickle.dump(a3,f)
    pickle.dump(a4,f)

将获得的数据反序列化为对象

import pickle
with open('data.txt','rb') as f:
    a1 = pickle.load(f)
    a2 = pickle.load(f)
    a3 = pickle.load(f)
    a4 = pickle.load(f)
    print(a1)
    print(a2)
    print(a3)
    print(a4)

输出：
sherry
100
{'name': 'sherry', 'age': 24}
[1, 2, 3, 4, 5]

CSV 文件的操作

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

• 值没有类型，所有值都是字符串
• 不能指定字体颜色等样式
• 不能指定单元格的宽高，不能合并单元格
• 没有多个工作表
• 不能嵌入图像图表
  Python 标准库的模块 csv 提供了读取和写入 csv 格式文件的对象。

创建一个csv文件，内容如下：

csv.reader 对象和 csv 文件读取

csv.writer 对象写一个 csv 文件

import csv
with open('a.csv','r') as f:
    csv_reader = csv.reader(f)
    header = next(csv_reader)
    print(header)
    for row in csv_reader:
        print(row)

输出：
['名字', '年龄', '成绩']
['sherry', '24', '100']
['lily', '24', '90']

csv.writer 对象和 csv 文件写入

csv.writer 对象写一个 csv 文件

import csv
headers = ['name','sex']
rows = [('sherry','female'),('lily','female'),('logan','male')]
with open('a.csv','w') as f:
    csv_writer = csv.writer(f)
    csv_writer.writerow(headers) #写入一行数据
    csv_writer.writerows(rows)  #写入多行数据

a.csv内容：

os 和 os.path 模块

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

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

os.system 调用 windows 系统的记事本程序

import os
os.system('notepad.exe')

os.system 调用 windows的ping命令

import os
os.system('ping www.baidu.com')

【注】Linux 是命令行操作更容易，我们可以通过 os.system 可以更加容易的调用相关的命 令；
【注】控制台输出中文可能会有乱码问题，可以在 file–>setting 中设置

os.system调用注册表

import os
os.system('regedit')

·os.startfile：直接调用可执行文件

import os
os.startfile('D:\Software\Tencent\WeChat\WeChat.exe')

os 模块-文件和目录操作

我们可以通过前面讲的文件对象实现对于文件内容的读写操作。如果，还需要对文件和目录做其他操作，可以使用 os 和 os.path 模块。
os 模块下常用操作文件的方法：

os 模块下关于目录操作的相关方法，汇总如下：

os 模块：创建、删除目录、获取文件信息等示例。

#测试os模块中，关于文件和目录的操作
import os
###### 获取文件和文件夹相关信息#######
print(os.name) # windows->nt linux和unix->posix
print(os.sep) # windows->\ linux和unix->/
print(repr(os.linesep))
print(os.stat('a.txt'))

########关于工作目录的操作##########
print(os.getcwd()) #获得当前工作目录
os.mkdir('book') #创建目录
########创建目录、创建多级目录、删除#######、
os.rmdir('book') #相对路径都是相对于当前的工作目录
os.makedirs('movies/1/2/3')
os.rename('movies','电影')
os.removedirs('电影/1/2/3')
#print(os.listdir())

输出：
nt
\
'\r\n'
os.stat_result(st_mode=33206, st_ino=3096224743922409, st_dev=2317855786, st_nlink=1, st_uid=0, st_gid=0, st_size=32, st_atime=1644835294, st_mtime=1644835292, st_ctime=1644827162)
C:\Users\test\Desktop

os.path模块

os.path 模块提供了目录相关（路径判断、路径切分、路径连接、文件夹遍历）的操作：


测试 os.path 中常用方法

import os
import os.path

######判断绝对路径、是否目录、是否文件、是否存在########
print(os.path.isdir('a.txt'))
print(os.path.isfile('a.txt'))
print(os.path.isabs('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:')) #返回目录路径
print(os.path.getmtime('a.txt')) #获得创建时间

###########对路径的操作##########
path = os.path.abspath('a.txt')
print(os.path.split(path))  #返回目录和文件
print(os.path.splitext(path)) #按点切割
print(os.path.join('aa','bb','cc','dd'))

输出：
False
True
False
True
32
C:\Users\test\Desktop\a.txt
d:
1644835292.6216383
('C:\\Users\\test\\Desktop', 'a.txt')
('C:\\Users\\test\\Desktop\\a', '.txt')
aa\bb\cc\dd

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

os.walk()方法：
返回一个 3 个元素的元组，(dirpath, dirnames, filenames),

• dirpath：要列出指定目录的路径
• dirnames：目录下的所有文件夹
• filenames：目录下的所有文件

#测试os.walk()方法
import os
path = os.getcwd()
list_file = os.walk(path)
for dir_path, dir_name, file_name in list_file: 
    '''for dir in dir_name:
        print(dir)
    for file in file_name:
        print(file)'''
    print(dir_path)

shutil 模块(拷贝和压缩)

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

#测试shutil和zipfile

import shutil
import zipfile
######复制#######
# shutil.copy('a.txt','a_copy.txt')
# shutil.copytree('movie','movie_copy',ignore=shutil.ignore_patterns("*.html","*.htm"))
#######压缩和解压缩#######
z = zipfile.ZipFile('a.zip','w') #压缩包存在位置，和压缩的模式
z.write('a.txt')
z.close()
z2 = zipfile.ZipFile('a.zip','r')
z2.extractall('d:')  #设置解压缩地址
z2.close()

递归算法

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己 调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺 塔、快排等问题。
递归结构包括两个部分：

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

#递归求n的阶乘
def factorial(n):
    if n == 1:
        return n
    else:
        return n*factorial(n-1)
print(factorial(10))

输出:
3628800

递归原理分析：

递归的缺陷;
简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递 归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

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

import os
allfile = []

def getFiles(path,level):
    files = os.listdir(path)
    for file in files:
        filepath = os.path.join(path,file)
        if os.path.isdir(filepath):
            getFiles(filepath,level+1)
        allfile.append('\t'*level + filepath)

getFiles(r'D:\dsc',0)