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, 

對於大文件效率還可以。
"""