Python文件处理详解

什么是文件：

　　文件是操作系统提供给用户/应用程序操作硬盘的一种虚拟的概念/接口

为什么要用文件

　　所写的程序可以通过文件将数据永久保留到硬盘上

打开文件路径问题：

# windows路径分隔符问题
# 路径：C:
bcd.txt
# 解决方案一：推荐
# open(r'C:
bcd.txt')
# 解决方案二：
# open('C:/nb/c/d.txt')

绝对路径和相对路径

相对路径：

1、xxx.py想要打开a.txt，使用相对路径，有如下两种方式：

• with open(r"b_filea.txt","r") as file:

• with open(r"._filea.txtx", "r") as file:

特别提示：.. 是错误的，打开的是上级目录

2、ab.py尝试打开b_file下的a.txt，应该怎么写：

　　with open(r".._fileaa.txt", "r") as f:

绝对路径：

　　with open(r'C: bcd.txt',"r") as f:

操作文件：open() 方法

open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

#open（）方法打开文件例子：

f=open(r'C:
bcd.txt',mode='r') # f的值是一种变量/文件句柄，占用的是应用程序的内存空间

语法格式：

# 简洁语法： 
open(file, mode='r', encoding=None)

# 完整语法：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明:
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 编码格式，一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型

encoding(编码参数)：

　　如果没有指定encoding参数，会使用系统默认的编码格式，例如windows操作系统中，如果代码没有指定encoding参数，会默认使用windows的GBK编码格式

# 没有指定encoding参数操作系统会使用自己默认的编码
# linux系统默认utf-8
# windows系统默认gbk
with open('c.txt',mode='rt',encoding='utf-8') as f:
    res=f.read() # t模式会将f.read()读出的结果解码成unicode
    print(res,type(res))
# 报错UnicodeDecodeError: 'gbk' codec can't decode byte 0x80 in position 16: illegal multibyte sequence

mode详解

控制文件读写内容的格式：（t模式和b模式）

1、t模式（默认的内容格式）只能打开文本文件

• 读写都是以str（Unicode）为单位的
• 文本文件
• 必须为open()指定encoding='utf-8'

2、b模式（bytes）

　　二进制方式，读写文件都是以bytes/二进制为单位的

　　可以针对所有文件（文本文件，图片，视频。。。）

　　不能指定encodingcabs

　　注意：b模式打开没有encoding编码这一说

总结：b模式和t模式对比

　　1、在操作纯文本文件方面t模式帮我们省去了解码环节，b模式则需要我们手动编码与解码，所以在操作纯文本文件方面t模式更加方便

　　2、针对非文本文件（图片、视频，音频。。）只能使用b模式

文件操作模式

模式	描述
+	打开一个文件进行更新(可读可写)。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。如果原先有内容，执行写会把原先内容覆盖
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

+不能单独使用，必须配合r、w、a使用

t模式下读写实例：

user_db.txt内容如下

zhangsan:123:0
lisi:123:0
egon:123:0
alex:123:0

 r（默认的操作模式）：只读模式，当文件不存在时报错，当文件存在时文件指针跳到开始位置

 with open('user_db.txt',mode='rt',encoding='utf-8') as f:
     print('第一次读'.center(50,'*'))
     res=f.read() # 把所有内容从硬盘读入内存
     print(res)

 with open('user_db.txt', mode='rt', encoding='utf-8') as f:
     print('第二次读'.center(50,'*'))
     res1=f.read()
     print(res1)

//执行结果
***********************第一次读***********************
zhangsan:123:0
lisi:123:0
egon:123:0
alex:123:0
***********************第二次读***********************

w：只写模式，当文件不存在时会创建空文件，当文件存在会清空文件，指针位于开始位置

with open('user_db.txt',mode='wt',encoding='utf-8') as f:
    # f.read() # 报错，不可读
    f.write('擦勒
')
# 执行后user_db.txt内容
'擦勒

强调：

# 1、在以w模式打开文件没有关闭的情况下，连续写入，新的内容总是跟在旧的之后
# 2、如果以w模式打开一个原先有内容文件，则会清空文件内容

a：只追加写，在文件不存在时会创建空文档，在文件存在时文件指针会直接调到末尾

with open('e.txt',mode='at',encoding='utf-8') as f:
     # f.read() # 报错，不能读
     f.write('擦嘞1
')
     f.write('擦嘞2
')
     f.write('擦嘞3
')

//执行结果
在e.txt文件末尾追加擦嘞

强调 w 模式与 a 模式的异同：

相同点：在打开的文件不关闭的情况下，连续的写入，新写的内容总会跟在前写的内容之后
不同点：以 a 模式重新打开文件，不会清空原文件内容，会将文件指针直接移动到文件末尾，新写的内容永远写在最后

# 案例：a模式用来在原有的文件内存的基础之上写入新的内容，比如记录日志、注册
# 注册功能
name=input('your name>>: ')
pwd=input('your name>>: ')
with open('db.txt',mode='at',encoding='utf-8') as f:
     f.write('{}:{}
'.format(name,pwd))

b模式读写文件实例

b模式打开文件

fo.txt文件内容

zhangsan:123
lisi:123
egon:123
alex:123

代码

#b 模式打开文本文件（输出显示为bytes）
with open("fo.txt","rb") as f:
    for line in f:
        print(line)
//执行结果
b'zhangsan:123
'
b'lisi:123
'
b'egon:123
'
b'alex:123'
#怎么将文件内容通过b模式打开显示正常呢？
#因为二进制打开时bytes类型，我们要将输出内容解码，并且按照当初文件存时候的编码
#去解码
#因为fo.txt文件存的时候时utf-8编码，所以我们用utf-8去解码

#手动解码显示为字符
with open("fo.txt","rb") as f:
    for line in f:
        print(line.decode("utf-8"),end="")
//执行结果
zhangsan:123
lisi:123
egon:123
alex:123

b模式写入内容到文本文件

解释：因为时b模式，所以只能写bytes数据到文件，因此，我们只能手动的将我们要写到文件的内容进行编码再写入，t模式时自动帮我们转了（encoding指定的）

写入前fo.txt文件内容

zhangsan:123
lisi:123
egon:123
alex:123

#代码
with open("fo.txt","ab") as f:
f.write("
王二:123".encode("utf-8"))

执行后fo.txt文件内容

zhangsan:123
lisi:123
egon:123
alex:123
王二:123

 一个特殊的文件操作模式x模式（了解知识）

x模式
x，只写模式[不可读；不存在则创建，存在则报错]
# 实例
#a.txt文件存在（执行时提示报错）
#with open('a.txt',mode='x',encoding='utf-8') as f:
#     pass

# c.txt文件不存在（创建c.txt文件）
# with open('c.txt',mode='x',encoding='utf-8') as f:
#     f.read()

#打开文件时，文件指针在开头
with open('d.txt',mode='x',encoding='utf-8') as f:
    f.write('哈哈哈
')

with语句

使用with…as 关键字
上下文管理的语句块并不会开启新的作用域
with语句块执行完的时候，会自动关闭文件对象

为了避免打开文件后忘记关闭，可以通过管理上下文，即：
with open('log','r') as f:
    ...
如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
打开多个文件：

with open('yesterday','r',encoding='utf-8') as f,
        open('yesterday2','r',encoding='utf-8') as f2:
　　...

# 例子：打开单个文件
yesterday2文件内容：
1:www.runoob.com
2:www.runoob.com
3:www.runoob.com
4:www.runoob.com
7:www.runoob.com
# 代码
with open('yesterday2','r',encoding='utf-8') as f:
    for line in f:
        print(line.strip())
# 执行结果
1:www.runoob.com
2:www.runoob.com
3:www.runoob.com
4:www.runoob.com
7:www.runoob.com


# 注解：
with open('yesterday2','r',encoding='utf-8') as f:   
# 等同于
f=open('yesterday2','r',encoding='utf-8')
f.close()

# 例子：打开多个文件
yesterday文件内容：
f1:www.runoob.com
f1:www.runoob.com
f1:www.runoob.com
f1:www.runoob.com
f1:www.runoob.com
yesterday2文件内容：
f2:www.runoob.com
f2:www.runoob.com
f2:www.runoob.com
f2:www.runoob.com
f2:www.runoob.com

# 代码
with open('yesterday','r',encoding='utf-8') as f,
        open('yesterday2','r',encoding='utf-8') as f2:
    for line in f:
        print(line.strip())
    for line2 in f2:
        print(line2.strip())
# 执行结果
f1:www.runoob.com
f1:www.runoob.com
f1:www.runoob.com
f1:www.runoob.com
f1:www.runoob.com
f2:www.runoob.com
f2:www.runoob.com
f2:www.runoob.com
f2:www.runoob.com
f2:www.runoob.com

 file对象读写文件的方法

file.read()

file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。（仅限于文件比较小的时候使用）
//概述
read() 方法用于从文件读取指定的字节数，如果未给定或为负则读取所有。
//语法
read() 方法语法如下：
fileObject.read(); 
//参数
size -- 从文件中读取的字节数。
//返回值
返回从字符串中读取的字节。
//实例
以下实例演示了 read() 方法的使用：
文件 runoob.txt 的内容如下：
这是第一行
这是第二行
这是第三行
这是第四行
这是第五行
循环读取文件的内容：
#!/usr/bin/python3
# 打开文件
fo = open("runoob.txt", "r+")
print ("文件名为: ", fo.name)
line = fo.read(10)    #从头开始读取，一共读取10个字节
print ("读取的字符串: %s" % (line))
# 关闭文件
fo.close()
以上实例输出结果为：
文件名为:  runoob.txt
读取的字符串: 这是第一行
这是第二

file.readline()

file.readline([size]) 读取整行，包括 "
" 字符。
//概述
readline() 方法用于从文件读取整行，包括 "
" 字符。如果指定了一个非负数的参数，则返回指定大小的字节数，包括 "
" 字符。

//语法
readline() 方法语法如下：
fileObject.readline(); 
//参数
size -- 从文件中读取的字节数。
//返回值
返回从字符串中读取的字节。
//实例
以下实例演示了 readline() 方法的使用：
文件 runoob.txt 的内容如下：
1:www.runoob.com
2:www.runoob.com
3:www.runoob.com
4:www.runoob.com
5:www.runoob.com
循环读取文件的内容：
# 打开文件
fo = open("runoob.txt", "r+")
print ("文件名为: ", fo.name)
line = fo.readline()
print ("读取第一行 %s" % (line))
line = fo.readline(5)
print ("读取的字符串为: %s" % (line))

# 关闭文件
fo.close()
以上实例输出结果为：
文件名为:  runoob.txt
读取第一行 1:www.runoob.com
读取的字符串为: 2:www

file.readlines()

file.readlines([sizeint]) 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。（仅限于文件比较小的时候使用）
//概述
readlines() 方法用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由 Python 的 for... in ... 结构进行处理。 如果碰到结束符 EOF 则返回空字符串。
如果碰到结束符 EOF 则返回空字符串。
语法
readlines() 方法语法如下：
fileObject.readlines( );
//参数
无。
//返回值
返回列表，包含所有的行。
//实例
以下实例演示了 readlines() 方法的使用：
文件 runoob.txt 的内容如下：
1:www.runoob.com
2:www.runoob.com
3:www.runoob.com
4:www.runoob.com
5:www.runoob.com
循环读取文件的内容：
实例(Python 3.0+)
#!/usr/bin/python3
# 打开文件
fo = open("runoob.txt", "r")
print ("文件名为: ", fo.name)
for line in fo.readlines():                          #依次读取每行  
    line = line.strip()                             #去掉每行头尾空白  
    print ("读取的数据为: %s" % (line))
# 关闭文件
fo.close()
以上实例输出结果为：
文件名为:  runoob.txt
读取的数据为: 1:www.runoob.com
读取的数据为: 2:www.runoob.com
读取的数据为: 3:www.runoob.com
读取的数据为: 4:www.runoob.com
读取的数据为: 5:www.runoob.com

file.readable()

readable   判断文件是否可读
//代码
f=open("yesterday",'r+')  #文件句柄
print(f.readable())
f.close()
//执行结果
True

file.write()

file.write(str) 将字符串写入文件，返回的是写入的字符长度。
//概述
write() 方法用于向文件中写入指定字符串。
在文件关闭前或缓冲区刷新前，字符串内容存储在缓冲区中，这时你在文件中是看不到写入的内容的。
如果文件打开模式带 b，那写入文件内容时，str (参数)要用 encode 方法转为 bytes 形式，否则报错：TypeError: a bytes-like object is required, not 'str'。
//语法
write() 方法语法如下：
fileObject.write( [ str ])
//参数
str -- 要写入文件的字符串。
//返回值
返回的是写入的字符长度。
//实例
文件 runoob.txt 的内容如下：
1:www.runoob.com
2:www.runoob.com
3:www.runoob.com
4:www.runoob.com
5:www.runoob.com
以下实例演示了 write() 方法的使用：
#!/usr/bin/python3
# 打开文件
fo = open("runoob.txt", "r+")
print ("文件名: ", fo.name)
str = "6:www.runoob.com"
# 在文件末尾写入一行
fo.seek(0, 2)
line = fo.write( str )
# 读取文件所有内容
fo.seek(0,0)
for index in range(6):
    line = next(fo)
    print ("文件行号 %d - %s" % (index, line))
# 关闭文件
fo.close()
以上实例输出结果为：
文件行号 0 - 1:www.runoob.com
文件行号 1 - 2:www.runoob.com
文件行号 2 - 3:www.runoob.com
文件行号 3 - 4:www.runoob.com
文件行号 4 - 5:www.runoob.com
文件行号 5 - 6:www.runoob.com
查看文件内容：
$ cat runoob.txt 
1:www.runoob.com
2:www.runoob.com
3:www.runoob.com
4:www.runoob.com
5:www.runoob.com
6:www.runoob.com

file.writelines()

file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
//概述
writelines() 方法用于向文件中写入一序列的字符串。
这一序列字符串可以是由迭代对象产生的，如一个字符串列表。
换行需要制定换行符 
。
//语法
writelines() 方法语法如下：
fileObject.writelines( [ str ])
//参数
str -- 要写入文件的字符串序列。
//返回值
该方法没有返回值。
//实例
以下实例演示了 writelines() 方法的使用：
#!/usr/bin/python3
# 打开文件
fo = open("test.txt", "w")
print ("文件名为: ", fo.name)
seq = ["菜鸟教程 1
", "菜鸟教程 2"]
fo.writelines( seq )
# 关闭文件
fo.close()
以上实例输出结果为：
文件名为:  test.txt
查看文件内容：
菜鸟教程 1
菜鸟教程 2

file.writeable()

writable   判断文件是否可写
//代码
f=open("yesterday",'r+')  #文件句柄
print(f.writable())
f.close()
//执行结果
True

file.close()关闭文件

file.close() 关闭文件。关闭后文件不能再进行读写操作。
//概述
close() 方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作， 否则会触发 ValueError 错误。 close() 方法允许调用多次。
当 file 对象，被引用到操作另外一个文件时，Python 会自动关闭之前的 file 对象。 使用 close() 方法关闭文件是一个好的习惯。
//语法
close() 方法语法如下：
fileObject.close();
//参数
无
//返回值
该方法没有返回值。
//实例
以下实例演示了 close() 方法的使用：
#!/usr/bin/python3
# 打开文件
fo = open("runoob.txt", "wb")
print("文件名为: ", fo.name)
# 关闭文件
fo.close()
以上实例输出结果为：
文件名为:  runoob.txt

file.closed()

file.closed   判断文件是否关闭
//代码
f=open("yesterday",'r+')  #文件句柄
f.close()
print(f.closed)
//执行结果
True

file.flush()  了解知识，不常用

file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
//概述
flush() 方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。
一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。
//语法
flush() 方法语法如下：
fileObject.flush();
//参数
无
//返回值
该方法没有返回值。
//实例
以下实例演示了 flush() 方法的使用：
#!/usr/bin/python3
# 打开文件
fo = open("runoob.txt", "wb")
print ("文件名为: ", fo.name)
# 刷新缓冲区
fo.flush()
# 关闭文件
fo.close()
以上实例输出结果为：
文件名为:  runoob.txt

总结：

f.read()与f.readlines()都是将内容一次性读入内存，如果内容过大会导致内存溢出，若还想将内容全部读入内存，则必须分多次读入，有两种方式：

# 方式一
with open('a.txt',mode='rt',encoding='utf-8') as f:
    for line in f:
        print(line) # 同一时刻只读入一行内容到内存中

# 方式二
with open('1.mp4',mode='rb') as f:
    while True:
        data=f.read(1024) # 同一时刻只读入1024个Bytes到内存中
        if len(data) == 0:
            break
        print(data)

了解操作

f.readable()  # 文件是否可读
f.writable()  # 文件是否可读
f.closed  # 文件是否关闭
f.encoding  # 如果文件打开模式为b,则没有该属性
f.flush()  # 立刻将文件内容从内存刷到硬盘
f.name    #打印文件名

文件高级操作：控制文件指针的移动

指针移动的单位都是以bytes/字节为单位，只有一种情况特殊：t模式下的read(n),n代表的是字符个数

# f.seek(n,模式):n指的是移动的字节个数
# 模式：
# 模式0：参照物是文件开头位置（默认的模式）
# f.seek(9,0)
# f.seek(3,0) # 3

# 模式1：参照物是当前指针所在位置
# f.seek(9,1)
# f.seek(3,1) # 12

# 模式2：参照物是文件末尾位置，应该倒着移动
# f.seek(-9,2) # 3
# f.seek(-3,2) # 9

# 强调：只有0模式可以在t下使用，1、2必须在b模式下用
# f.tell() # 获取文件指针当前位置

案例1：0模式

# a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）
abc你好

# 0模式的使用
with open('a.txt',mode='rt',encoding='utf-8') as f:
    f.seek(3,0)     # 参照文件开头移动了3个字节
    print(f.tell()) # 查看当前文件指针距离文件开头的位置，输出结果为3
    print(f.read()) # 从第3个字节的位置读到文件末尾，输出结果为：你好
    # 注意：由于在t模式下，会将读取的内容自动解码，所以必须保证读取的内容是一个完整中文数据，否则解码失败

with open('a.txt',mode='rb') as f:
    f.seek(6,0)
    print(f.read().decode('utf-8')) #输出结果为: 好

案例2：1模式

# 1模式的使用
with open('a.txt',mode='rb') as f:
    f.seek(3,1) # 从当前位置往后移动3个字节，而此时的当前位置就是文件开头
    print(f.tell()) # 输出结果为：3
    f.seek(4,1)     # 从当前位置往后移动4个字节，而此时的当前位置为3
    print(f.tell()) # 输出结果为：7

案例3：2模式

# a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）
abc你好

# 2模式的使用
with open('a.txt',mode='rb') as f:
    f.seek(0,2)     # 参照文件末尾移动0个字节， 即直接跳到文件末尾
    print(f.tell()) # 输出结果为：9
    f.seek(-3,2)     # 参照文件末尾往前移动了3个字节
    print(f.read().decode('utf-8')) # 输出结果为：好

# 小练习：实现动态查看最新一条日志的效果
import time
with open('access.log',mode='rb') as f:
    f.seek(0,2)
    while True:
        line=f.readline()
        if len(line) == 0:
            # 没有内容
            time.sleep(0.5)
        else:
            print(line.decode('utf-8'),end='')

文件修改操作

# 文件a.txt内容如下
张一蛋     山东    179    49    12344234523
李二蛋     河北    163    57    13913453521
王全蛋     山西    153    62    18651433422

# 执行操作
with open('a.txt',mode='r+t',encoding='utf-8') as f:
    f.seek(9)
    f.write('<妇女主任>')

# 文件修改后的内容如下
张一蛋<妇女主任> 179    49    12344234523
李二蛋     河北    163    57    13913453521
王全蛋     山西    153    62    18651433422

# 强调：
# 1、硬盘空间是无法修改的,硬盘中数据的更新都是用新内容覆盖旧内容
# 2、内存中的数据是可以修改的

文件的内容修改是如何实现的， 大致的思路是将硬盘中文件内容读入内存,然后在内存中修改完毕后再覆盖回硬盘 具体的实现方式分为两种:

文件修改方式一：

# 实现思路：将文件内容发一次性全部读入内存,然后在内存中修改完毕后再覆盖写回原文件
# 优点: 在文件修改过程中同一份数据只有一份
# 缺点: 会过多地占用内存
with open('db.txt',mode='rt',encoding='utf-8') as f:
    data=f.read()

with open('db.txt',mode='wt',encoding='utf-8') as f:
    f.write(data.replace('kevin','SB'))

文件修改方式二：

# 实现思路：以读的方式打开原文件,以写的方式打开一个临时文件,一行行读取原文件内容,修改完后写入临时文件...,删掉原文件,将临时文件重命名原文件名
# 优点: 不会占用过多的内存
# 缺点: 在文件修改过程中同一份数据存了两份
import os

with open('db.txt',mode='rt',encoding='utf-8') as read_f,
        open('.db.txt.swap',mode='wt',encoding='utf-8') as wrife_f:
    for line in read_f:
        wrife_f.write(line.replace('SB','kevin'))

os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')