一:文件内容清空问题:
在工作中我们有时候还会清空文件中的内容 然后再重新写入新的内容,哪如何清空已存文件的内容呢?
解决方法:
def modify_text():
with open('test.txt', "r+") as f:
read_data = f.read()
f.truncate() #清空文件
f.write(read_data.replace('apple', 'android'))
执行上面这个函数,它会把内容追加进去,而不是替换。
f.truncate()没起作用,应该怎么写才可以呢?
需要加上f.seek(0),把文件定位到position 0,没有这句的话,文件是定位到数据最后,truncate也是从这里删除,所以感觉就是没起作用。
def modify_text():
with open('test.txt', "r+") as f:
read_data = f.read()
f.seek(0) #定位
f.truncate() #清空文件
f.write(read_data.replace('apple', 'android'))
f.seek(0):把文件定位到数据起始位置(index=0),若没有这句的话,文件则默认定位到数据结束位置,w.truncate()不起作用。
w.truncate():从**位置(index)**处清空文件内容。
二:文件读写的流程
2.1 类比windows中手动操作txt文档
说明python中如何操作txt文件?
1)windows中手动操作txt文件的步骤
找到word文档
打开word文档
查看(或操作)word文档中的内容
关闭word文档
2) python操作txt文件的步骤
获取被打开的文件的内存对象,该内存对象又叫做“文件句柄”。
通过这个内存对象(文件句柄),来对文件进行操作(读取,写入等操作)。
关闭文件
3)什么是文件的内存对象(文件句柄)? 使用python读取一个txt文件的时候,相当于把这个文件从硬盘上,读取到了内存中。我们如果想要操作这个文件,是不是先要获取这个文件对象?只有获取这个文件对象后,才能够真正的去操作这个文件,不管是读取文件中的内容,还是向文件中写入内容。 这个“文件句柄”包含了文件的文件名、文件的字符集、文件的大小、文件在硬盘上的起始位置。
2.2 文件的读取
① 演示如下
import os
def test_read_txt_01():
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
with open(file_path,'r+',encoding='utf-8') as f:
data = f.read()
data1 = f.read()
print(data[:100])
print('========='*20)
print(data1[:100])
if __name__ == '__main__':
test_read_txt_01()
执行结果;
#执行结果:
使用python读取一个txt文件的时候,
相当于把这个文件从硬盘上,读取到了内存中。我们如果想要操作这个文件,是不是先要获取这个文件对象?
只有获取这个文件对象后,才能够真正的去操作这个文件,不管是
=========================================================================
Process finished with exit code 0
问题:我们读取了2遍内容,为什么只显示了一次读取的结果呢?对于上述问题,我们用一张图回答上述问题。
通过上图我们可以发现,当我们操作这个“文件句柄”的read()方法去读取文件的时候,这个句柄会从文件的开头位置1,移动到文件的结束位置2。如果不做任何操作,读取完毕之后,句柄就会停止在2这个位置。因此当我们再次读取文件的时候,该句柄是从2这个位置,往后面读取内容。由于后面没有任何内容,因此第二次读取为空。 那么,如果我们想要第二次同样能够读取到文件中的内容,应该怎么办呢?那么接着往下看。
2.3写入文件
def test_write_text_01(data):
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
with open(file_path, 'w', encoding='utf-8') as f:
f.write(data)
f.close()
if __name__ == '__main__':
test_write_text_01('第一次往text文件写入数据')
执行结果:
假如我们在写一句“第二次写入数据”,会出现啥情况呢?
def test_write_text_01(data):
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
with open(file_path, 'w', encoding='utf-8') as f:
f.write(data)
f.close()
if __name__ == '__main__':
test_write_text_01('第二次写入数据')
执行结果;
意外发生。当我们再次写入新的内容的时候,发现之前写的内容不见了,这是为啥呢?这就是我们下面要讲述的“文件读写的几种常见模式”。
2.4 文件读写的几种常见模式
2.4.1)关于r+、w+、a+使用说明(易错点)
当我们读取某个文件,向文件中写入某些内容(覆盖写),向文件中追加写入某写内容时,最好的方式就是分别使用r、w、a这三种模式。对于这三种模式,要么读,要么写,读模式就不能写,写模式就不能读。 对于r+、w+、a+这三种模式,如果你不是特别清楚python文件读写的原理,就不要轻易使用,因为会出现很多问题,下面我们仅演示r+、w+、a+这三种模式。
2.4.2)r+模式:可读可写
对于这种模式,不管是读取文件中的内容,还是朝文件中写入内容。前提条件:文件存在,若文件不存在 则会报错。
def test_write_read_text_r_jia_01():
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
with open(file_path, 'r+',encoding='utf-8') as f:
f.write('使用r加写入数据')
print('=====# 朝文件中写入内容后,立即读取,会出现啥问题?===')
data = f.read()
print(f'读取是的数据为:{data}')
print('# 朝文件中写入内容后,调整句柄位置后,再读取,会出现啥问题?')
f.seek(0)
data1 = f.read()
print(f'读取是的数据为:{data1}')
if __name__ == '__main__':
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
f = open(file_path, 'r+',encoding='utf-8')
data = f.read()
print(f'读取文件原内容:{data}')
print('===================')
test_write_read_text_r_jia_01()
执行结果;
读取文件原内容:关于r+、w+、a+
===================
=====# 朝文件中写入内容后,立即读取,会出现啥问题?===
读取是的数据为:
# 朝文件中写入内容后,调整句柄位置后,再读取,会出现啥问题?
读取是的数据为:使用r加写入数据
Process finished with exit code 0
结果分析: 使用r+模式,当只读文件的时候,可以读取到其中的内容。 当写入内容后,立即读取文件内容,发现什么也读取不到。这是由于当你写入内容后,文件句柄会放在写入内容的最后面,因此当你立即读取的时候,句柄会从上次内容最后的位置,朝后面读,因此读取为空。 当往文件中写入内容后,调整句柄位置后,再读取文件中的内容,发现就有了内容。这是由于我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,因此就又有了内容
2.4.3)w+:可读可写
def test_write_read_texy_w_jia_01():
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
# 直接往文件中写入内容
f = open(file_path, "w+", encoding="utf-8")
f.write("bbbbbb")
f.close()
print('========直接读取上述文件,看看会发生啥问题?==========\n')
# 直接读取上述文件,看看会发生啥问题?(特别注意这一步)
f = open(file_path, "w+", encoding="utf-8")
data_1 = f.read()
print(f'读取数据data1:{data_1}\n')
f.close()
print('========朝文件中写入内容后,立即读取,又会发生什么?==========\n')
# 朝文件中写入内容后,立即读取,又会发生什么?
f = open(file_path, "w+", encoding="utf-8")
f.write("哈哈哈哈哈")
data_2 = f.read()
print(f'读取数据data_2:{data_2}\n')
f.close()
print('========朝文件中写入内容后,调整句柄位置后,再读取,会发生什么?==========\n')
# 朝文件中写入内容后,调整句柄位置后,再读取,会发生什么?
f = open(file_path, "w+", encoding="utf-8")
f.write("嘿嘿嘿嘿嘿")
f.seek(0)
data_3 = f.read()
print(f'读取数据data_2:{data_3}\n')
f.close()
if __name__ == '__main__':
test_write_read_texy_w_jia_01()
执行结果:
========直接读取上述文件,看看会发生啥问题?==========
读取数据data1:
========朝文件中写入内容后,立即读取,又会发生什么?==========
读取数据data_2:
========朝文件中写入内容后,调整句柄位置后,再读取,会发生什么?==========
读取数据data_2:嘿嘿嘿嘿嘿
Process finished with exit code 0
结果分析: 使用w+模式,当我们直接朝文件中写入bbbbbb,毋庸置疑,肯定是可以的。 接着,我们直接读取这个文件中的内容,奇怪的现象发生了,什么都读取不到。这是因为w+模式,在进行文件读取的时候,默认是先写再读。但是我们确实没有写入任何东西呀?这是由于系统默认帮我们写入了一个空值,因此把原有内容覆盖了。所以再当我们读取文件中的内容的时候,发现读取为空。 再接着,我们朝文件中,写入内容后再立即读取,这下仍然读取不到任何内容,这又是为什么呢?这是由于我们第一次写入“哈哈哈哈哈哈”的时候,句柄移动到了内容最后。当我们立即读取的时候,句柄从内容最后的位置,继续朝后面读,因此啥也没有。 最后,当朝文件中写入内容后,调整句柄位置后,再读取文件中的内容,发现就有了内容。这是由于我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,因此就又有了内容。
2.4.4)a+:可读可写
def text_wire_read_txt_a_jia_01():
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
# 直接朝文件中写入内容
f = open(file_path, "a+", encoding="utf-8")
f.write("哈哈")
f.close()
print('========直接读取文件中的内容==========\n')
# 直接读取文件中的内容
f = open(file_path, "a+", encoding="utf-8")
data_1 = f.read()
print(f'读取数据data_2:{data_1}\n')
f.close()
print('========调整句柄位置后,再读取文件中的内容==========\n')
# 调整句柄位置后,再读取文件中的内容
f = open(file_path, "a+", encoding="utf-8")
f.seek(0)
data_2 = f.read()
print(f'读取数据data_2:{data_2}\n')
f.close()
if __name__ == '__main__':
text_wire_read_txt_a_jia_01()
执行结果:
========直接读取文件中的内容==========
读取数据data_2:
========调整句柄位置后,再读取文件中的内容==========
读取数据data_2:嘿嘿嘿嘿嘿哈哈
Process finished with exit code 0
结果分析: 使用a+模式,朝文件中写入内容,会接着原有的内容继续追加内容,毋庸置疑,肯定是没问题的。 接着,当我们读取上述文件中的内容,会发现什么也读取不到。这是由于,使用a+模式打开文件,文件句柄默认放在内容的最后面,因此你直接读取其中的内容,什么也没有。 最后,在读取文件中内容之前,我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,再次读取文件中的内容,发现就有了内容。
2.5 read、readline、readlines的区别
2.5.1)read()方法的使用
def test_read():
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
f = open(file_path, "r", encoding="utf-8")
data = f.read()
print(type(data))
print(data)
f.close()
if __name__ == '__main__':
test_read()
执行结果:
君不见黄河之水天上来,奔流到海不复回
君不见高堂明镜悲白发,朝如青丝暮成雪
人生得意须尽欢,莫使金樽空对月
天生我材必有用,千金散尽还复来
Process finished with exit code 0
2.5.2)readline()方法的使用
def test_readline():
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
f = open(file_path, "r", encoding="utf-8")
data = f.readline()
print(type(data))
print(data)
f.close()
print('========================')
f = open(file_path, "r", encoding="utf-8")
for i in range(3):
data = f.readline()
print(data)
f.close()
print('==========去掉每一行末尾的换行符==============\n')
#去掉每一行末尾的换行符:
f = open(file_path, "r", encoding="utf-8")
for i in range(3):
data = f.readline().strip()
print(data)
f.close()
if __name__ == '__main__':
test_readline()
执行结果:
2.5.3)readlines()方法的使用
def test_readlines():
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
f = open(file_path, "r", encoding="utf-8")
data = f.readlines()
print(type(data))
print(data)
f.close()
if __name__ == '__main__':
test_readlines()
执行结果:
2.6 对于一个10G的大文件,怎么高效的查看文件中的内容呢?
2.6.1)相关说明
当我们读取文件中的内容,相当于是把写在硬盘上的东西,读取到内存中。不管你是使用read()或者readlines()一次性读取到到内存中,还是使用readline()一行行的将整个内容读取到内存中,如果文件很大,都将会耗用很大的内存。同时,从硬盘读取文件内容到内存中,也会很慢。 因此,有没有一种高效的方式?既让我们看到了文件中的内容,又不会占用内存呢?下面我们将进行说明。
2.6.2)操作说明
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test.txt'))
f = open(file_path ,"r",encoding="utf-8")
for line in f:
print(line.strip())
执行结果:
结果说明: 上述方式中,f相当于一个迭代器,我们使用for循环迭代f中元素。每循环一次,就相当于读取一行到内存中,并记住这一次读取到的位置。当进行下次迭代的时候,上一次读取到内存中的内容,就会被销毁了,当前内存中读取的就是第二行的内容。当进行第三次循环的时候,内存中第二行的内容也会被销毁,此时内存中只会保存第三行的内容,这样依次进行下去。直到最后一次循环,读取最后一行的内容,此时,内存中保留的也只是最后一行的内容。 迭代器有一个特性:每次进行迭代的时候,就会记住当前读取的位置。当进行下一次迭代的时候,前面的内容会被销毁掉,在内存中只会保留当前循环得到的内容。原文链接:https://blog.csdn.net/weixin_41261833/article/details/104462907