【Python基础知识-pycharm版】文件操作(IO技术)

文件操作(IO技术)

实际开发中，我们经常需要从外部存
储介质（硬盘、光盘、U盘等）读取数据，或者将程序产生的数据存储到文件中，实现“持久化”保存。
很多软件系统是将数据存储的数据库中；数据库实际也是基于文件
形式存储的

文本文件和二进制文件

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

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. 关闭文件对象

常用编码介绍

在操作文本文件时，经常会操作中文，这时候就经常会碰到乱码问题。为了让大家有能力解决中文乱码问题，这里简单介绍一下各种编码之间的关系。
常用编码之间的关系如下：

ASCII

全称为 American Standard Code for Information Interchange，美国信
息交换标准代码，这是世界上最早最通用的单字节编码系统，主要用来显示现代
英语及其他西欧语言。
ASCII码用7位表示，只能表示128个字符。只定义了27=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
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。
在文件编辑区单击右键，选择FileEncoding，选择 GBK即可，再选择Reload，文件即显示正常。

write()/writelines()写入数据

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

close()关闭文件流

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

with语句(上下文管理器)

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

文本文件的读取

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

1. read([size])
   从文件中读取 size 个字符，并作为结果返回。如果没有 size 参数，则读取整个文件。
   读取到文件末尾，会返回空字符串。
2. readline()
   读取一行内容作为结果返回。读取到文件末尾，会返回空字符串。
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)]
#推导式生成列表
with open("e.txt","w",encoding="utf-8") as f:
	f.writelines(lines)

二进制文件的读取和写入

二进制文件的处理流程和文本文件流程一致。首先还是要创建文件对象，不过，需要指定二进制模式，从而创建出二进制文件对象。
f = open(r"d:\a.txt", ‘wb’) #可写的、重写模式的二进制文件对象
f = open(r"d:\a.txt", ‘ab’) #可写的、追加模式的二进制文件对象
f = open(r"d:\a.txt", ‘rb’) #可读的二进制文件对象
创建好二进制文件对象后，仍然可以使用 write()、read()实现文件的读写操作。

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

文件对象封装了文件相关的操作。
文件对象的属性

文件对象的打开模式

文件对象的常用方法

文件任意位置操作

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

使用pickle序列化

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

CSV文件的操作

csv(Comma Separated Values)是逗号分隔符文本格式，常用于数据交换、Excel
文件和数据库数据的导入和导出。与Excel 文件不同，CSV 文件中：
值没有类型，所有值都是字符串
不能指定字体颜色等样式
不能指定单元格的宽高，不能合并单元格
没有多个工作表
不能嵌入图像图表

Python标准库的模块 csv提供了读取和写入 csv格式文件的对象。

csv.reader对象和csv文件读取

import csv 
with open(r"d:\a.csv") as a: 
	a_csv = csv.reader(a)	#创建csv对象,它是一个包含所有数据的列表，每一行为一个元素
	headers = next(a_csv)	#获得列表对象，包含标题行的信息
	print(headers) 
	for row in a_csv:	# 循 环 打 印 各 行 内 容
		print(row)

csv.writer对象和csv文件写入

import csv
headers = ["工号","姓名","年龄","地址","月薪"]
rows = [("1001","王小一",18,"西三旗1号院","50000"),("1002","王小二",19,"西三旗1号院","30000")]
with open(r"d:\b.csv","w") as b: 
	b_csv = csv.writer(b) #创建csv对象 
	b_csv.writerow(headers) #写入一行（标题） 
	b_csv.writerows(rows) #写入多行（数据）

os和os.path模块

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

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

os.system可以直接调用系统的命令

#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.startfile：直接调用可执行文件

#运行安装好的微信
import os
os.startfile(r"C:\Program Files (x86)\Tencent\WeChat\WeChat.exe")

os模块-文件和目录操作

os 模块下常用操作文件的方法

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

#coding=utf-8
#测试os模块中，关于文件和目录的操作
import os
# # # # # # # # # # # # # 获 取 文 件 和 文 件 夹 相 关 的 信 息 # # # # # # # # # # # # # # # #
print(os.name)
# w i n d o w s - > n t li n u x 和 u n i x - > p o s i x
print(os.sep)
# w i n d o w s - > \ li n u x 和 u n i x - > /
print(repr(os.linesep))
# w i n d o w s - > \ r \ n li n u x - - > \ n \
print(os.stat("my02.py"))
# # # # # # # # # # # # # # 关 于 工 作 目 录 的 操 作 # # # # # # # # # # # # # # #
# print(os.getcwd())
# os.chdir("d:") # 改 变 当 前 的 工 作 目 录 为 ： d:盘 根 目 录
# os.mkdir("书籍")
# # # # # # # # # # # # # # # # 创 建 目 录 、 创 建 多 级 目 录 、 删 除 # # # # # # # # # # # # #
# os.mkdir("书籍")
# os.rmdir("书籍") # 相 对 路 径 都 是 相 对 于 当 前 的 工 作 目 录
# os.makedirs("电影 / 港 台 / 周 星 驰 " )
# os.removedirs("电影 / 港 台 / 周 星 驰 " ) # 只 能 删 除 空 目 录
# os.makedirs("../ 音 乐 / 香 港 / 刘 德 华 " ) #../ 指 的 是 上 一 级 目 录
# os.rename("电 影 "," m o v i e " )
dirs = os.listdir("movie")
print(dirs)

os.path模块

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

# 测 试 o s.p a t h 常 用 方 法
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:\ \ U s e r s \ \ A d m i n i s t r a t o r \ \ P y c h a r m P r o j e c t s \ \ m y p r o _ i o \ \ t e s t _ o s', ' a.t x t')
print(os.path.splitext(path))# 返 回 元 组 ： 路 径 、 扩 展 名(' C:\ \ U s e r s \ \ A d m i n i s t r a t o r \ \ P y c h a r m P r o j e c t s \ \ m y p r o _ i o \ \ t e s t _ o s \ \ a','.t x t')
print(os.path.join("aa","bb","cc"))# 返 回 路 径 ： a a / b b / c c

# c o d i n g = u t f - 8
# 列 出 指 定 目 录 下 所 有 的.p y 文 件 ， 并 输 出 文 件 名
import os
import os.path
path = os.getcwd()
file_list = os.listdir(path)
# 列 出 子 目 录 和 子 文 件
for filename in file_list:
	pos = filename.rfind(".")
	if filename[pos+1:]=="py":
		print(filename,end="\t")

print("##################")
file_list2 = [filename for filename in os.listdir(path) if
filename.endswith(".py") ]
for filename in file_list2:
	print(filename,end="\t")

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

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

# c o d i n g = u t f - 8
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 name in filenames:
		all_files.append(os.path.join(dirpath,name))

# 打 印 子 目 录 和 子 文 件
for file in all_files:
	print(file)

shutil模块(拷贝和压缩)

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

#实现文件的拷贝
import shutil
# c o p y 文 件 内 容
shutil.copyfile("1.txt","1_copy.txt")

#实现递归的拷贝文件夹内容(使用shutil模块)
import shutil
# " 音 乐 " 文 件 夹 不 存 在 才 能 用 。
shutil.copytree("电影/学习","音乐",ignore=shutil.ignore_patterns("*.html","*.htm"))

#实现将文件夹所有内容压缩(使用shutil模块) 
import shutil
import zipfile
# 将 " 电 影 / 学 习 " 文 件 夹 下 所 有 内 容 压 缩 到 " 音 乐 2 " 文 件 夹 下 生 成 m o v i e.z i p
# s h u til.m a k e _ a r c h i v e ( " 音 乐 2 / m o v i e "," z i p "," 电 影 / 学 习 " )
# 压 缩:将 指 定 的 多 个 文 件 压 缩 到 一 个 z i p 文 件
# z = zipfile.ZipFile("a.z i p "," w " )
# z.write("1.t x t " )
# z.write("2.t x t " )
# z.close()

#实现将压缩包解压缩到指定文件夹(使用shutil模块) 
import shutil
import zipfile
# 解 压 缩 ：
z2 = zipfile.ZipFile("a.zip","r")
z2.extractall("d:/")
# 设 置 解 压 的 地 址
z2.close()

递归算法

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。
递归结构包括两个部分：
定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
递归体。解答：什么时候需要调用自身方法。

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

#使用递归算法遍历目录下所有文件
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)