Python3文件操作详解 Python3文件操作大全

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:sking
"""
test_file.txt
文件内容如下：
打印字符串第一个字符

打印字符串第二个字符
"""
#打开文件test_file.txt
f = open('test_file.txt', 'r+') #f是文件的文件句柄，它是在内存中的，是内存中的一个对象
data = f.read()
print(data)
"""
data结果：
打印字符串第一个字符

打印字符串第二个字符
"""
data2 = f.read() #再读一次文件
print("data2=", data2) #data2=
# 此时的结果是data2= ，也就是此时读取的data2为空，为什么？
# 因为第一次data读的时候文件光标是从头开始一直读到最后的，再次读的时候，
# 是从此时光标所在的位置（此时光标在最后面）开始读取，因为光标已经在最后了，
# 后面已经没有任何内容了，当然data2就读不出来数据了
# 可以用seek重新定位光标的位置
f.seek(0) #将光标定位到文件的开始位置
data3 = f.read()
print(data3)
"""
data3结果：
打印字符串第一个字符

打印字符串第二个字符
"""
#写文件write
#f = open('test_file.txt', 'w')  #如果是'w'写的模式的时候，系统会自动创建一个这个名字的文件，
# 如果该目录下有这个名字的文件，系统会直接覆盖掉原来的文件，原来的文件及内容就不存在了，所以这点一定要注意。
#f.write('\n\n写入字符串第三个字符')
f.seek(0) #seekable()判断文件内容是否可以进行seek操作，因为有些文件是不可以进行seek的
data4 = f.read()
print(data4)
f.close()
"""
打印字符串第一个字符

打印字符串第二个字符

写入字符串第三个字符
"""
#向文件追加内容
f = open('test_file.txt', 'a') #'a'是append  追加，但是不能读取文件
f.write('\n\nhaha')
print(f.readable()) #False  判断文件是否可读
f.close()
#读取一行内容
f = open('test_file.txt', 'r')
data = f.readline()
print(data) # 打印字符串第一个字符
#读取多行
data2 = f.readlines()
print(data2)


#读取到第3行
for index, line in enumerate(f.readlines()):  #仅适合读取小文件
    print(line.strip())
    if index == 2:
        break;
f.close()
#读取大文件（推荐使用）
f = open('test_file.txt', 'r')
for line in f:  #这样写的效果就是逐行读取文件中的内容，并且内存中始终仅保存读取的这一行内容 此时的f是一个迭代器
    print(line)
f.close()
#查看文件游标所在的位置
f = open('test_file.txt', 'r')
print(f.tell()) #0
print(f.read(5))
print(f.tell()) #10 因为一个汉字占2个字节，所以这里显示的是10
f.close()
f2 = open('test_file2.txt', 'r')
print(f2.tell()) #0
print(f2.read(5))
print(f2.tell()) #5 因为一个英文占1个字节，所以这里显示的是5
f2.close()


f = open('test_file.txt', 'r+')
print(f.encoding)  #cp936 #查看文件编码
print(f.name) # test_file.txt 查看文件名

#实时存储数据
#f.write("sdfadf")  #因为代码执行的过程中并不是出现依据写到硬盘的代码就立马开始向硬盘存储。
#系统有一个阀门限制，系统会在内存中开辟一块用来临时存储的区域，当临时存储区域的数据达到一定值时，才会从内存存到硬盘上。
#所以并不是执行一行写的代码后，硬盘就一定已经保存了该结果，很可能该结果还没有被保存。
f.flush()
print(f.flush()) #None

f.close()

#截断字符truncate
f = open('test_file.txt', 'r+')
f.truncate(10)  #打印字符串  从文件头开始截取10个字节(一个汉字是2个字节)
f.truncate() #如果什么都不写，就是截取0个字节也就相当于清空文件内容
f.close()

#写二进制文件内容
f = open('test_file.txt', 'wb')
f.write('hello'.encode(encoding='utf-8'))
f.close()

#演示进度条
import sys
import time
for i in range(31):
    sys.stdout.write('#')
    sys.stdout.flush()
    time.sleep(0.3)


"""
一、文件操作
1.文件处理的流程
 

1）打开文件，得到文件句柄并赋值给一个变量

2）通过句柄对文件进行操作

3）关闭文件

例如：

f = open('chenli.txt') #打开文件
first_line = f.readline()
print('first line:',first_line) #读一行
data = f.read()# 读取剩下的所有内容,文件大时不要用
print(data) #打印读取内容
f.close() #关闭文件
 

2.文件操作基本用法
1）基本用法：

file_object = open(file_name, access_mode = ‘r’, buffering = -1)

open函数有很多的参数，常用的是file_name，mode和encoding

file_name:打开的文件名,若非当前路径，需指出具体路径
access_mode文件打开模式
buffering的可取值有0，1，>1三个，0代表buffer关闭（只适用于二进制模式），1代表line buffer（只适用于文本模式），>1表示初始化的buffer大小； 
encoding表示的是返回的数据采用何种编码，一般采用utf8或者gbk；
 

 

2)文件打开模式

r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
x， 只写模式【不可读；不存在则创建，存在则报错】
a， 追加模式【不可读文件，不存在则创建；存在则只追加内容】，文件指针自动移到文件尾。
"+" 表示可以同时读写某个文件

r+， 读写【可读，可写】
w+，写读【可读，可写】，消除文件内容，然后以读写方式打开文件。
x+ ，写读【可读，可写】
a+， 写读【可读，可写】，以读写方式打开文件，并把文件指针移到文件尾。
 "b"表示以字节的方式操作，以二进制模式打开文件，而不是以文本模式。

 

rb  或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b
 注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

 

3）以读r的方式打开文件

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
f=open('1.txt',encoding='utf-8',mode='r')
print(f)
data1=f.read()
print(data1)
 

1.txt

55542342
123
输出：

<_io.TextIOWrapper name='1.txt' mode='r' encoding='utf-8'>
55542342
123
 

补充：

复制代码
1）python中有三个方法来处理文件内容的读取：
read() #一次读取全部的文件内容。返回字符串

readline() #每次读取文件的一行。

readlines() #读取文件的所有行，返回一个字符串列表。

2）print(f.readable())    #判断文件是否是r模式打开的

3）print(f.closed) 　　　#判断文件是否是关闭状态

4）python中在文本文件内容移动的操作
file.seek(offset,whence=0)     #从文件中给移动指针，从whence(0起始，1当前，2末尾)偏移offset个字节，正往结束方向移动，负往开始方向移动
file.tell() 　　　　　　　　　#返回当前文件中的位置。获得文件指针位置

5） file.truncate(size=file.tell())    #截取文件到最大size个字节，默认为当前文件位置
复制代码
4）以w方式写入文件

复制代码
f=open('a.txt','w',encoding='utf-8')
# f=open('b.txt','r',encoding='utf-8') #以读的方式打开文件，文件不存在则报错
f=open('b.txt','w',encoding='utf-8')
# print(f.writable())

f.write('111111\n22222222')
f.seek(0)
f.write('\n333333\n444444')

f.writelines(['\n55555\n','6666\n','77777\n'])
f.close()
复制代码
a.txt 为空

b.txt

333333
444444
55555
6666
77777
 

补充：

file.write(str)     #向文件中写入字符串(文本或二进制)
file.writelines(seq)    #写入多行，向文件中写入一个字符串列表，注意，要自己加入每行的换行符
file.flush()    #刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入.
 

5）文件修改

复制代码
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
read_f=open('b.txt','r')
write_f=open('.b.txt.swap','w')
for line in read_f.readlines():
    if line.startswith('1111'):
        line='2222222222\n'
    write_f.write(line)
read_f.close()
write_f.close()
os.remove('b.txt')
os.rename('.b.txt.swap','b.txt')
复制代码
 

3.上下文管理with语句
当你做文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。

正常情况下，代码如下：

file = open("/tmp/foo.txt")
data = file.read()
file.close()
这里有两个问题。一是可能忘记关闭文件句柄；二是文件读取数据发生异常，没有进行任何处理。

然而with可以很好的处理上下文环境产生的异常。下面是with版本的代码：

with open("/tmp /foo.txt") as file:
    data = file.read()
with的基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。

 

补充：

模拟   tail -f access.log

复制代码
#!/usr/bin/env python
# -*- coding:utf-8 -*-

# tail -f access.log
import time
with open('access.log','r',encoding='utf-8') as f:
    f.seek(0,2)
    while True:
        line=f.readline().strip()
        if line:
            print('新增一行日志',line)
        time.sleep(0.5)
复制代码


"""
"""
read(),readline(),readlines()的区别

假设a.txt的内容如下所示：
123 
Hello
Welcome
What is the fuck... 

一、read([size])方法
 
read([size])方法从文件当前位置起读取size个字节，若无参数size，
则表示读取至文件结束为止，它范围为字符串对象
f = open("a.txt")
lines = f.read()
print(lines)
print(type(lines))
f.close() 

输出结果：
Hello
Welcome
What is the fuck...
<type 'str'> #字符串类型 

二、readline()方法
 
从字面意思可以看出，该方法每次读出一行内容，所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。
 
f = open("a.txt")
line = f.readline()
print(type(line))
while line: 
    print line, 
    line = f.readline()
f.close() 

输出结果：

<type 'str'>
Hello
Welcome
What is the fuck... 

三、readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。
 
f = open("a.txt")
lines = f.readlines()
print(type(lines))
for line in lines: 
    print (line)
    f.close() 

输出结果：
<type 'list'>
Hello
Welcome
What is the fuck... 

四、linecache模块
 
当然，有特殊需求还可以用linecache模块，比如你要输出某个文件的第n行：
 
# 输出第2行
text = linecache.getline(‘a.txt',2)
print text, 

对于大文件效率还可以。
"""