python file文件操作--内置对象open

说明：

　　1. 函数功能打开一个文件，返回一个文件读写对象，然后可以对文件进行相应读写操作。

　　2. file参数表示的需要打开文件的相对路径(当前工作目录)或者一个绝对路径，当传入路径不存在此文件会报错。或者传入文件的句柄。

>>> a = open('test.txt') # 相对路径
>>> a
<_io.TextIOWrapper name='test.txt' mode='r' encoding='cp936'>
>>> a.close()

>>> a = open(r'D:PythonPython35-32test.txt') # 绝对路径
>>> a
<_io.TextIOWrapper name='D:\Python\Python35-32\test.txt' mode='r' encoding='cp936'>

　　3. mode参数表示打开文件的模式，常见的打开模式有如下几种，实际调用的时候可以根据情况进行组合。

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

r ，只读模式【默认】
w，只写模式【不可读；不存在则创建；存在则清空内容；】
x，只写模式【不可读；不存在则创建，存在则报错】
a，追加模式【可读；不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

r+，读写【可读，可写】
w+，写读【可读，可写】
x+ ，写读【可读，可写】
a+，写读【可读，可写】

"b"表示以字节的方式操作

rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

t为文本读写，b为二进制读写

# t为文本读写，b为二进制读写
>>> a = open('test.txt','rt')
>>> a.read()
'some text'
>>> a = open('test.txt','rb')
>>> a.read()
b'some text'

# r为只读，不能写入；w为只写，不能读取
>>> a = open('test.txt','rt')
>>> a.write('more text')
Traceback (most recent call last):
  File "<pyshell#67>", line 1, in <module>
    a.write('more text')
io.UnsupportedOperation: write
>>> a = open('test.txt','wt')
>>> a.read()
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    a.read()
io.UnsupportedOperation: not readable

#其它不一一举例了

　　4. buffering表示文件在读取操作时使用的缓冲策略。

　　　　　　0：代表buffer关闭（只适用于二进制模式）　　　　　　1：代表line buffer（只适用于文本模式）　　　　　　>1：表示初始化的buffer大小

　　5. encoding参数表示读写文件时所使用的的文件编码格式。

　　假设现在test.txt文件以utf-8编码存储了一下文本：

>>> a = open('test.txt','rt') # 未正确指定编码，有可能报错
>>> a.read()
Traceback (most recent call last):
  File "<pyshell#87>", line 1, in <module>
    a.read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0xac in position 8: illegal multibyte sequence

>>> a = open('test.txt','rt',encoding = 'utf-8')
>>> a.read()
'我是第1行文本，我将被显示在屏幕n我是第2行文本，我将被显示在屏幕n我是第3行文本，我将被显示在屏幕'
>>>

　　6. errors参数表示读写文件时碰到错误的报错级别。

　　常见的报错基本有：

'strict' 严格级别，字符编码有报错即抛出异常，也是默认的级别，errors参数值传入None按此级别处理.
'ignore' 忽略级别，字符编码有错，忽略掉.
'replace' 替换级别，字符编码有错的，替换成？.

>>> a = open('test.txt','rt',encoding = 'utf-8')
>>> a.read()
'我是第1行文本，我将被显示在屏幕n我是第2行文本，我将被显示在屏幕n我是第3行文本，我将被显示在屏幕'
>>> a = open('test.txt','rt')
>>> a.read()
Traceback (most recent call last):
  File "<pyshell#91>", line 1, in <module>
    a.read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0xac in position 8: illegal multibyte sequence
>>> a = open('test.txt','rt',errors = 'ignore' )
>>> a.read()
>>> a = open('test.txt','rt',errors = 'replace' )
>>> a.read()

　　7. newline表示用于区分换行符(只对文本模式有效，可以取的值有None,'n','r','','rn')

>>> a = open('test.txt','rt',encoding = 'utf-8',newline = 'r')
>>> a.readline()
'我是第1行文本，我将被显示在屏幕r'
>>> a = open('test.txt','rt',encoding = 'utf-8',newline = 'n')
>>> a.readline()
'我是第1行文本，我将被显示在屏幕rn'

　　8. closefd表示传入的file参数类型（缺省为True），传入文件路径时一定为True，传入文件句柄则为False。

>>> a = open('test.txt','rt',encoding = 'utf-8',newline = 'n',closefd = False)
Traceback (most recent call last):
  File "<pyshell#115>", line 1, in <module>
    a = open('test.txt','rt',encoding = 'utf-8',newline = 'n',closefd = False)
ValueError: Cannot use closefd=False with file name
>>> a = open('test.txt','rt',encoding = 'utf-8',newline = 'n',closefd = True)

笔记总结:

　a) 以二进制方式读写文件

python3 提供了一种机制, 以字节(二进制)的方式打开

 1 #二进制方式写入文件
 2 f = open("d:/data.txt", "wb")
 3 str = "卧室丽1"
 4 #需要将字符串转换为二进制以后才能添加
 5 f.write(bytes(str,encoding="utf-8"))
 6 f.close()
 7 
 8 
 9 #二进制方式读取文件
10 f = open("d:/data.txt", "rb")
11 str = f.read()
12 f.close()
13 print(str)

输出结果：

卧室丽1
b'xe5x8dxa7xe5xaexa4xe7xbdx97xe6x99x93xe4xb8xbd1'

　b) r+, w+, x+, a+ 四种模式都是可读可写, 那么他们的区别是什么?

　　　　想了解区别, 首先知道file的四个方法: 1. read(): 读数据, 2.write(): 写数据, 3.tell(): 获取当前指针的位置, 4.seek(): 重置指针的位置.

r+ 读写文件

- - 　　从开始像后读
  - 　　写, 以追加的方式写, 指针指向最后

 1 print("--------  r+: 从头读取, 写入后指针指向最后   -------------")
 2 #r+: 读的时候从开始向后读数据,
 3 # 写的时候是在末尾追加, 指针指向末尾
 4 f = open("d:/data.txt", "r+",encoding="utf-8")
 5 #tell 获取指针位置,位置是0
 6 print(f.tell())
 7 #指定读取3个字符, 一个汉字三个字节
 8 str = f.read(3)
 9 #此时指针已经在第9个字节的位置了
10 print(f.tell())
11 print(str)
12 #再次读取6个字符, 那么指针应该指向9+18=27的位置了
13 str = f.read(6)
14 # 指针指向第27个字符
15 print(f.tell())
16 print(str)
17 
18 #此时, 在写, 写完之后看看指针在哪里?
19 f.write("SSSBBB")
20 # 指针指向最后了
21 print(f.tell())
22 # 由此可见, 读的时候可以调整指针, 但是写的时候指针都是调整到最后去写.
23 
24 f.close()

　　执行结果:　　

1 --------  r+: 从头读取, 写入后指针指向最后   -------------
2 0
3 9
4 美丽丽
5 20
6 卧室丽1
7 
8 26

　　注意: 如果在文件打开后就写入, 则会写在开始,并覆盖指定字符数. 因为以r+方式打开, 指针指向文件最开始. 注意分析一下代码:

 1 print("======= 测试r+模式write数据指针的位置变化  =====")
 2 
 3 #先清空再写入数据
 4 f = open("data.txt","r+",encoding="utf-8")
 5 content = "你是谁,我也不知道,啊啊啊啊啊"
 6 print("文件内容: ", content)
 7 
 8 str = f.write(content)
 9 f.close()
10 
11 print("--------------")
12 
13 
14 
15 #以r+的方式open数据, open后指针在文件的最开始, 这个时候write数据,
16 # 会从最开始插入数据,并替换原来的字节数
17 f = open("data.txt", "r+", encoding="utf-8")
18 print("文件打开后, 指针位置: ", f.tell())
19 f.write("aaaaaa")
20 print("写入aaaaaa后, 指针位置: ",f.tell())
21 
22 str = f.read(3)
23 print("读取三个字符后, 指针位置: ",f.tell())
24 print("读取三个字符内容: ",str)
25 #在中间的位置write数据, 则追加到最后.
26 f.write("bbbb")
27 print("再次写入bbbb内容后, 指针位置: ",f.tell())
28 f.close()

　　　　执行结果:

1 ======= 测试r+模式write数据指针的位置变化  =====
2 文件内容:  你是谁,我也不知道,啊啊啊啊啊
3 --------------
4 文件打开后, 指针位置:  0
5 写入aaaaaa后, 指针位置:  6
6 读取三个字符后, 指针位置:  13
7 读取三个字符内容:  谁,我
8 再次写入bbbb内容后, 指针位置:  65

w+ 读写文件

- - 最重要的特征, 先清空, 然后读写. 也就是先把文件内容清空, 然后读写.
  - 读的时候, 从前往后读,
  - 写完以后, 指针指向末尾

 1 print("==========  #w+  ===========")
 2 #w+ :
 3 # 先清空, 在写读.
 4 # 先写, 后读.
 5 # 写后指针指向末尾
 6 f = open("d:/data.txt", "w+",encoding="utf-8")
 7 data = f.read()
 8 print("data:"+data)
 9 f.write("美丽丽")
10 # 写完之后直接读, 读不到内容, 因为写完以后指针已经知道最后了
11 data = f.read()
12 print("after write:"+data)
13 # 使用seek重新让指针指向0
14 f.seek(0)
15 data = f.read()
16 print(data)
17 f.close()

　　　　执行结果:

1 ==========  #w+  ===========
2 data:
3 after write:
4 美丽丽

　　　　x+ 与 w+ 的区别:

#x+: x+和w+一样, 只是额外的存在一个功能, 那就是文件存在则报错.

a+ 读写文件

- - 最重要的特征,读取文件以后, 指针指向最后, .
  - 读的时候, 从前往后读,
  - 写完以后, 指针指向末尾

print("-------------a+: 打开文件,执行指向最后, 调整指针位置读取--------------")
#a+: 可以读可以写
f = open("d:/data.txt", "a+", encoding="utf-8")
#当前指针指向位置, 使用a+的方式, 打开的同时指针已经在最后的位置
print(f.tell())
#读取三个字节, 读取内容为空, 因为指针指向最后
str = f.read(1)
#读取3个字符后指针的位置
print(f.tell())

#重新将指针指向开始
f.seek(0)
#读取指针的位置
print(f.tell())
# 读取一个字符
str= f.read(1)
# 一个字符后,指针的位置
print(f.tell())
print(str)
f.close()

文件操作常用方法

1. close 关闭文件.
     python2.6 以后有一个with语句. 可以自动关闭文件.不用手动关闭

 1 #with自动关闭打开的file.无需手动调用close()方法
 2 with open("data.txt","r",encoding="utf-8") as f:
 3     str = f.readline()
 4     print(str)
 5 
 6 # with 还可以同时打开两个文件. 可以用于文件拷贝. 例如:将文件1的内容拷贝到文件2
 7 with open("data.txt" ,"r", encoding="utf-8") as f1, open("data1.txt", "w", encoding="utf-8") as f2:
 8     #读取文件1的每一行数据, 写入到文件2
 9     for line in f1:
10         f2.write(line)

　2. flush 将文件从缓冲区刷新到硬盘

       write到file的内部,在进程没有结束之前, 都是保存在内存中, 通过flush方法可以将文件刷到硬盘上

1 f = open("data.txt","r+",encoding="utf-8")
2 f.write("再次添加内容2")
3 # 手动调用flush方法,将write的内容刷入硬盘
4 #f.flush()
5 str = input("请输入:")
6 
7 #在执行到input时, 进程没有结束, 文件write的内容保存在内存中, 并没有保存在硬盘上.
8 # 放开 f.flush(),手动刷新内存中的文件到硬盘上

将文件输入到硬盘有三种方法

1. 手动调用close()方法
2. 进程结束, 自动刷新内存中内容到硬盘
3. 手动调用flush()方法, 手动刷新内存中内容到硬盘

 1 print("=====   flush 刷新文件内部缓冲区   =======")
 2 
 3 #1. 手动调用close()方法
 4 f = open("data.txt","w",encoding="utf-8")
 5 f.write("新添加的内容")
 6 # 执行f.close()后,会自动调用flush将write的内容写进硬盘.
 7 f.close()
 8 
 9 
10 
11 # 2. 进程结束, 自动刷新内存中内容到硬盘
12 f = open("data.txt","r+",encoding="utf-8")
13 f.write("再次添加内容1")
14 # 进程结束, 也会自动将write的内容刷如硬盘
15 
16 
17 
18 # 3. 手动调用flush()方法, 手动刷新内存中内容到硬盘
19 f = open("data.txt","r+",encoding="utf-8")
20 f.write("再次添加内容2")
21 # 手动调用flush方法,将write的内容刷入硬盘
22 f.flush()
23 str = input("请输入:")

truncate: 截断数据，仅保留指定之前数据

 1 # truncate: 截断数据，仅保留指定之前数据
 2 f = open("data1.txt", "r+", encoding="utf-8")
 3 #f.seek(5)
 4 # 一个参数, 指定保留字符个数
 5 f.truncate(20)
 6 # f.flush()
 7 f.seek(0)
 8 str = f.read()
 9 print(str)
10 f.close()

　　运行前文件内容:

　　运行后文件内容: