一.IO（input、output-输入、输出）

1.IO定义

• 在内存中存在数据交换的操作认为是IO操作,比如和终端交互 ,和磁盘交互，和网络交互等

2.程序分类

• IO密集型程序：在程序执行中有大量IO操作，而cpu运算较少。消耗cpu较少，耗时长。
• 计算密集型程序：程序运行中计算较多，IO操作相对较少。cpu消耗多，执行速度快，几乎没有阻塞。

3.文件定义

• 文件是保存在持久化存储设备(硬U盘、光盘…)上的一段数据。从功能角度分为 文本文件 （打开后会自动解码为字符）、二进制文件(视频、音频等)。在Python里把文件视作一种类型的对象，类似之前学习过的其它类型。

二.字节串（bytes）

• 在python3中引入了字节串的概念，与str不同，字节串以字节序列值表达数据，更方便用来处理二进程数据。因此在python3中字节串是常见的二进制数据展现方式。
• 普通的ascii编码字符串可以在前面加b转换为字节串，例如：b’hello world’
• **字符串 ** 转换为字节串方法 ：str.encode()
• **字节串 ** 转换为字符串方法 :bytes.decode()
• 注意：所有的字符串能转成字节串，但是字节串不一定能转成字符串
  （因为utf8所定义的字符串相对有限，而二进制的范围相对大很多）

三.读写文件操作

1.基本流程

• 对文件实现读写的基本操作步骤为：打开文件，读写文件，关闭文件

Demo【file_open.py】

1 """
 2 file_open.py
 3 文件打开方式训练
 4 """
 5 
 6 #　打开文件
 7 try:
 8     # fd = open('a.py','r') #　以只读打开
 9     # fd = open('a.py','w') # 以只写方式打开
10     # fd = open('a.py','a') #　追加方式
11 
12     """
13     普通的文本文件　
14     既可以使用文本方式打开也可以使用二进制方式打开
15     二进制文件则必须以二进制方式打开
16     """
17     fd = open('a.py','rb') #　二进制方式
18     print(fd)
19 except Exception as e:
20     print(e)
21 
22 # 读写文件
23 
24 # 关闭文件
25 fd.close()

Demo【file_read.py】

1 """
 2 file_read.py
 3 文件读取演示
 4 """
 5 
 6 # 打开文件
 7 f = open('test','r')
 8 
 9 #　ｒｅａｄ 循环读取
10 # while True:
11 #     #　读到文件结尾返回空字符串
12 #     data = f.read(1024) #每次最多读１００字符
13 #     # 　读到结尾跳出循环
14 #     if not data:
15 #         break
16 #     print(data)
17 
18 # 读取一行内容
19 # data = f.readline(10) #　读取前１０个字符
20 # print("一行内容：",data)
21 # data = f.readline() # 读完第一行剩余内容
22 # print("一行内容：",data)
23 
24 # 将内容读取为列表，每行为列表一个元素
25 # data = f.readlines(18) #前18个字符所在的行作为读取对象
26 # print(data)
27 
28 # f为可迭代对象
29 for i in f:
30     print(i)  #　每次迭代到一行内容
31 
32 #　关闭
33 f.close()

Demo【file_write.py】

 1 """
 2 file_write.py
 3 文件写操作演示
 4 """
 5 
 6 #　打开文件
 7 # f = open('test','w')
 8 # f = open('img.jpg','wb')
 9 f = open('test','a')  #　追加
10 
11 #　写操作
12 # f.write("hello 死鬼\n".encode())
13 # f.write("哎呀，干啥".encode())
14 
15 # 将列表写入 人为添加换行
16 l = ['hello world\n','哈哈哈']
17 f.writelines(l)
18 
19 f.close()

2.基础认知

file_object = open(file_name, access_mode='r', buffering=-1)
功能：打开一个文件，返回一个文件对象。
参数：file_name  文件名；
     access_mode  打开文件的方式,如果不写默认为‘r’ 
          文件模式               操作
              r            以读方式打开 文件必须存在
              w            以写方式打开
                           文件不存在则创建，存在清空原有内容 
              a            以追加模式打开 
              r+           以读+写模式打开 文件必须存在
              w+           以读+写模式打开文件
                           不存在则创建，存在清空原有内容
              a+           以读写模式打开 追加模式
              rb           以二进制读模式打开 同r
              wb           以二进制写模式打开 同w
              ab           以二进制追加模式打开 同a
              rb+          以二进制读写模式打开 同r+
              wb+          以二进制读写模式打开 同w+
              ab+          以二进制读写模式打开 同a+
     buffering  1表示有行缓冲，默认则表示使用系统默认提供的缓冲机制。
返回值：成功返回文件操作对象。    

3.读取文件

• read([size])
• 功能： 用来直接读取文件中字符。
• 参数： 如果没有给定size参数（默认值为-1）或者size值为负，文件将被读取直至末尾，给定size最多读取给定数目个字符（字节）。
• 返回值： 返回读取到的内容
  ·注意：文件过大时候不建议直接读取到文件结尾，读到文件结尾会返回空字符串。

Demo【读文件】

 1 # 打开文件
 2 f = open('test','r')
 3 
 4 #　read循环读取文件
 5 while True:
 6   #　一次最多读取1024字节
 7   data = f.read(1024)
 8   #　读到文件结尾得到空字符串，此时跳出循环
 9   if not data:
10     break
11   print("读取的内容:",data)

• readline([size])
• 功能： 用来读取文件中一行
• 参数： 如果没有给定size参数（默认值为-1）或者size值为负，表示读取一行，给定size表示最多读取制定的字符（字节）。
• 返回值： 返回读取到的内容

1 # 打开文件
2 f = open('test','r')
3 
4 #　读取一行内容
5 data = f.readline()
6 print("读取的内容:",data)
7 data = f.readline()
8 print("读取的内容:",data)

• readlines([sizeint])
• 功能： 读取文件中的每一行作为列表中的一项
• 参数： 如果没有给定size参数（默认值为-1）或者size值为负，文件将被读取直至末尾，给定size表示读取到size字符所在行为止。
• 返回值： 返回读取到的内容列表

1 # 打开文件
2 f = open('test','r')
3 
4 #　读取所有内容，每行作为列表中一个元素
5 data = f.readlines()
6 print("读取的内容:",data)

文件对象本身也是一个可迭代对象，在for循环中可以迭代文件的每一行。

1 # 打开文件
2 f = open('test','r')
3 #    每次获取文件一行
4 for line in f:
5      print(line)

3.写入文件

• write(string)
• 功能: 把文本数据或二进制数据块的字符串写入到文件中去
• 参数：要写入的内容
  • 如果需要换行要自己在写入内容中添加\n

1 # w原有内容被清除,a则追加
2 #f = open('test','a')
3 f = open('test','wb')
4 #　如果是wb打开要转换为字节串写入
5 f.write("hello word\n".encode())
6 f.write("python".encode())
7 
8 f.close()

• writelines(str_list)
• 功能：接受一个字符串列表作为参数，将它们写入文件。
• 参数: 要写入的内容列表

1 # w原有内容被清除,a则追加
2 f = open('test','a')
3 
4 f.writelines(['abc\n','def\n'])
5 
6 f.close()

4.关闭文件

• 打开一个文件后我们就可以通过文件对象对文件进行操作了，当操作结束后使用close（）关闭这个对象可以防止一些误操作，也可以节省资源。
• file_object.close()

5.with操作

• python中的with语句使用于对资源进行访问的场合，保证不管处理过程中是否发生错误或者异常都会执行规定的“清理”操作，释放被访问的资源，比如有文件读写后自动关闭、线程中锁的自动获取和释放等。

with语句的语法格式如下：

with context_expression [as target(s)]:

with-body

通过with方法可以不用close(),因为with生成的对象在语句块结束后会自动处理，所以也就不需要close了，但是这个文件对象只能在with语句块内使用。

1 with open('file','r+') as f:
2     f.read()
3 等同于----------------------
4 f=open(‘file’，‘r+’)
5 f.read()
6 f.close()

注意:

加b的打开方式读写要求必须都是字节串 无论什么缓冲，当程序结束或者文件被关闭时都会将缓冲区内容写入磁盘 with 语句块结束　ｆ自动销毁

四.缓冲

• 系统自动的在内存中为每一个正在使用的文件开辟一个缓冲区，从内存向磁盘输出数据必须先送到内存缓冲区，再由缓冲区送到磁盘中去。从磁盘中读数据，则一次从磁盘文件将一批数据读入到内存缓冲区中，然后再从缓冲区将数据送到程序的数据区。

Demo【缓冲】

 1 # 打开文件
 2 try:
 3   fd = open('img.jpg','ab+')
 4 except FileNotFoundError as e:
 5   print(e)
 6 
 7 # 开始你的读写
 8 
 9 # 关闭文件
10 fd.close()

- flush()

• 该函数调用后会进行一次磁盘交互，将缓冲区中的内容写入到磁盘。

 1 """
 2 缓冲区
 3 """
 4 
 5 #　１表示行缓冲
 6 f = open('test','w',1)
 7 
 8 while True:
 9   s = input(">>")
10   f.write("nihao\n")
11   # f.flush() # 将缓冲内容写入磁盘
12 
13 f.close()

五.文件偏移量

1.定义

• 打开一个文件进行操作时系统会自动生成一个记录，记录中描述了我们对文件的一系列操作。其中包括每次操作到的文件位置。文件的读写操作都是从这个位置开始进行的。

2.基本操作

• tell()
• 功能：获取文件偏移量大小
• seek(offset[,whence])
• 功能:移动文件偏移量位置
• 参数：offset 代表相对于某个位置移动的字节数。负数表示向前移动，正数表示向后移动。
• whence是基准位置的默认值为 0，代表从文件开头算起，1代表从当前位置算起，2 代表从文件末尾算起。

必须以二进制方式打开文件时基准位置才能是1或者2

Demo【文件偏移】

1 # r,w打开文件偏移量在开头
 2 # a打开文件偏移量在结尾
 3 f = open('test','wb+')
 4 
 5 f.write(b"hello\n")
 6 f.flush()
 7 
 8 print(f.tell())  #打印当前文件偏移量
 9 f.seek(-3,2)  #　以开头为基准向后移动０字节
10 
11 data = f.read()
12 print(data)

Demo【空洞文件】

1 f = open('test','wb')
2 
3 f.write(b'start')
4 f.seek(1000,2) # 结尾位置向后移动１０００字节
5 f.write(b'end')
6 
7 f.close()

六.文件描述符

1.定义

• 系统中每一个IO操作都会分配一个整数作为编号，该整数即这个IO操作的文件描述符。

2.获取文件描述符

• fileno()
• 通过IO对象获取对应的文件描述符

七.文件管理函数

• 1.获取文件大小：os.path.getsize(file)
• 2.查看文件列表：os.listdir(dir)
• 3.查看文件是否存在：os.path.exists(file)
• 4.判断文件类型：os.path.isfile(file)
• 5.删除文件：os.remove(file)

练习1

• 向一个文件写入日志, 写入格式:

1. 2019-1-1 12:12:12
2. 2019-1-1 12:12:13
3. 2019-1-1 12:12:24
   要求每隔1秒写入一次,每条时间占一行.程序死循环,crtl-c退出. 如果程序退出重新启动时内容能跟上次内容衔接(序列号)

 1 import time
 2 
 3 f = open('log.txt','a+')
 4 
 5 n = 0
 6 f.seek(0,0) # 将偏移量移动待开始然后计数
 7 for line in f:
 8   n += 1
 9 
10 while True:
11   n += 1
12   time.sleep(1)
13   s = "%d.  %s\n"%(n,time.ctime())
14   f.write(s)
15   f.flush()  #　随时看到文件变化

练习2

• 从终端输入一个文件名称(包含路径),如果该文件存在则将该文件复制到当前目录下,命名为1904(要求文件可以是任意类型),如果文件不存在则打印该文件不存在

 1 #　输入文件名
 2 filename = input("File:")
 3 
 4 try:
 5   fr = open(filename,'rb')
 6 except FileNotFoundError as e:
 7   print(e)
 8 else:
 9   fw = open('file.jpg','wb')
10 
11   #　循环复制
12   while True:
13     data = fr.read(1024)
14     if not data:
15       break
16     fw.write(data)
17 
18   fr.close()
19   fw.close()