一、如何將列表數(shù)據(jù)寫入文件

 ⾸先，我們來看看下⾯這段代碼，并思考：這段代碼有沒有問題，如果有問題的話，要怎么改？

li = ['python',' is',' a',' cat']
with open('test.txt','w') as f:
    f.write(li)

現(xiàn)在公布答案，這段代碼會報錯：

TypeError Traceback (most recent call last)
ipython-input-6-57e0c2f5a453> in module>()
        1 with open('test.txt','w') as f:
----> 2  f.write(li)
TypeError: write() argument must be str, not list

以上代碼的想法是將list列表內(nèi)容寫⼊txt⽂件中，但是報錯 TypeError: write() argument must be str。  

就是說，write()⽅法必須接受字符串（str）類型的參數(shù)。 Python中內(nèi)置了str()⽅法，可以返回字符串版本的對象（Return a string version of object）。所以，上⾯的例⼦中，我們試試把 f.write(li) 改為 f.write(str(li)) ，先做⼀下字符串類型的轉(zhuǎn)化看看。代碼略。 這次沒有報錯了，但是打開⽂件就傻眼了吧，寫⼊的內(nèi)容是“['python',' is',' a',' cat']”。怎么才能寫 成“python is a cat”呢？ ⽂件寫操作還有⼀個writelines()⽅法，它接收的參數(shù)是由字符串組成的序列（sequence），實際寫⼊的效果是將全部字符串拼接在⼀起。字符串本身也是⼀種序列，所以當(dāng)參數(shù)是字符串的時候，writelines()⽅法等價于write()。

# 以下3種寫法等價，都是寫⼊字符串“python is a cat” 
In [20]: with open('test.txt','w') as f: 
    ...: f.writelines(['python',' is',' a',' cat']) 
    ...: f.writelines('python is a cat') 
    ...: f.write('python is a cat') 
# 以下2種寫法等價，都是寫⼊列表的字符串版本“['python',' is',' a',' cat']” 
In [21]: with open('test.txt','w') as f: 
    ...: f.write(str(['python',' is',' a',' cat'])) 
    ...: f.writelines(str(['python',' is',' a',' cat'])) 
# 作為反例，以下寫法都是錯誤的： 
In [22]: with open('test.txt','w') as f: 
    ...: f.writelines([2018,'is','a','cat']) # 含⾮字符串 
    ...: f.write(['python','is','a','cat']) # ⾮字符串

由上可知，當(dāng)多段分散的字符串存在于列表中的時候，要⽤writelines()⽅法，如果字符串是⼀整段，那直 接使⽤write()⽅法。如果要以整個列表的形式寫⼊⽂件，就使⽤str()⽅法做下轉(zhuǎn)化。 這個問題還沒結(jié)束，如果列表中就是有元素不是字符串，⽽且要把全部元素取出來，怎么辦呢？ 那就不能直接使⽤write()和writelines()了，需要先⽤for循環(huán)，把每個元素取出來，逐⼀str()處理。  

In [37]: content=[1,' is',' everything'] 
In [38]: with open('test.txt','w') as f: 
...: for i in content: 
...: f.write(str(i))

需要注意的是，writelines()不會⾃動換⾏。如果要實現(xiàn)列表元素間的換⾏，⼀個辦法是在每個元素后⾯加 上換⾏符“\n”，如果不想改變元素，最好是⽤for循環(huán)，在寫⼊的時候加在末尾：for i in content: f.writelines(str(i)+“\n”)   引申⼀下，經(jīng)過實驗，數(shù)字及元祖類型也可以作為write()的參數(shù)，不需轉(zhuǎn)化。但是dict字典類型不可以， 需要先⽤str()處理⼀下。字典類型⽐較特殊，最好是⽤json.dump()⽅法寫到⽂件。   總結(jié)⼀下，write()接收字符串參數(shù)，適⽤于⼀次性將全部內(nèi)容寫⼊⽂件；writelines()接收參數(shù)是由字符串 組成的序列，適⽤于將列表內(nèi)容逐⾏寫⼊⽂件。str()返回Python對象的字符串版本，使⽤需注意。

二、如何從文件中讀取內(nèi)容？

從⽂件中讀取內(nèi)容有如下⽅法：

file.read([size]) 
從⽂件讀取指定的字節(jié)數(shù)，如果未給定或為負(fù)則讀取所有。 
file.readline([size]) 
讀取整⾏，包括 "\n" 字符。 
file.readlines([sizeint]) 
讀取所有⾏并返回列表，若給定sizeint>0，則是設(shè)置⼀次讀多少字節(jié)，這是為了減輕讀取壓⼒。

簡⽽⾔之，在不傳參數(shù)的情況下，read()對應(yīng)write()，讀取全部內(nèi)容；readlines()對應(yīng)writelines()，讀取 全部內(nèi)容（含換⾏符）并以列表形式返回，每個換⾏的內(nèi)容作為列表的⼀個元素。

In [47]: with open('test.txt','r') as f: 
...: print(f.read()) 
1 is everything. 
python is a cat. 
this is the end. 
In [48]: with open('test.txt','r') as f: 
...: print(f.readlines()) 
['1 is everything.\n', 'python is a cat.\n', 'this is the end.']

但是，以上兩個⽅法有個缺點，當(dāng)⽂件過⼤的時候，⼀次性讀取太多內(nèi)容，會對內(nèi)存造成極⼤壓⼒。讀操作還有⼀個readline()⽅法，可以逐⾏讀取。

In [49]: with open('test.txt','r') as f: ...: print(f.readline()) 1 is everything.

readline()讀取第⼀⾏就返回，再次調(diào)⽤f.readline()，會讀取下⼀⾏。 這么看來，readline()太笨拙了。那么，有什么辦法可以優(yōu)雅地讀取⽂件內(nèi)容呢？ 回過頭來看readlines()⽅法，它返回的是⼀個列表。這不奇怪么，好端端的內(nèi)容為啥要返回成列表呢？ 再想想writelines()⽅法，把字符串列表寫⼊⽂件正是這家伙⼲的事，readlines()⽅法恰恰是它的逆操作！ ⽽writelines()⽅法要配合for循環(huán)，所以我們把readlines()與for循環(huán)結(jié)合，看看會怎樣。

In [61]: with open('test.txt','r') as f: 
    ...: for line in f.readlines(): 
    ...: print(line) 
1 is everything. 
python is a cat. 
this is the end. 
# 讀取內(nèi)容包含換⾏符，所以要strip()去掉換⾏符 
In [62]: with open('test.txt','r') as f: 
    ...: for line in f.readlines(): 
    ...: print(line.strip()) 
1 is everything. 
python is a cat. 
this is the end.

總結(jié)⼀下，readline()⽐較雞肋，不咋⽤；read()適合讀取內(nèi)容較少的情況，或者是需要⼀次性處理全部內(nèi)容的情況；⽽readlines()⽤的較多，⽐較靈活，因為for循環(huán)是⼀種迭代器，每次加載部分內(nèi)容，既減少內(nèi) 存壓⼒，⼜⽅便逐⾏對數(shù)據(jù)處理。

三、多樣需求的讀寫任務(wù)

前兩部分講了⽂件讀寫的⼏⼤核⼼⽅法，它們能夠起作⽤的前提就是，需要先打開⼀個⽂件對象，因為只有在⽂件操作符的基礎(chǔ)上才可以進(jìn)⾏讀或者寫的操作。   打開⽂件⽤的是open()⽅法，所以我們再繼續(xù)講講這個⽅法。open() ⽅法⽤于打開⼀個⽂件，并返回⽂件對象，在對⽂件進(jìn)⾏處理過程都需要使⽤到這個函數(shù)，如果該⽂件⽆法被打開，會拋出 OSError。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

open()⽅法的參數(shù)⾥file（⽂件）是必需的，其它參數(shù)最常⽤的是mode（模式）和encoding（編碼）。 先說說encoding，⼀般來說，打開⽂件的編碼⽅式以操作系統(tǒng)的默認(rèn)編碼為準(zhǔn)，中⽂可能會出現(xiàn)亂碼，需要加encoding='utf-8'。

In [63]: with open('test.txt','r') as f: 
    ...: for line in f.readlines(): 
    ...: print(line.strip()) 
----------------------- 
UnicodeDecodeError Traceback (most recent call last) 
ipython-input-63-731a4f9cf707> in module>() 
    1 with open('test.txt','r') as f: 
----> 2 for line in f.readlines(): 
    3 print(line.strip()) 
UnicodeDecodeError: 'gbk' codec can't decode byte 0xa4 in positio n 26: illegal multibyte sequence 
In [65]: with open('test.txt','r',encoding='utf-8') as f: 
    ...: for line in f.readlines(): 
    ...: print(line.strip()) 
python is a cat.

再說mode，它指定⽂件打開的模式。

r'： 以只讀模式打開（缺省模式）（必須保證⽂件存在） 
'w'：以只寫模式打開。若⽂件存在，則清空⽂件，然后重新創(chuàng)建；若不存在，則新建⽂件。 
'a'：以追加模式打開。若⽂件存在，則會追加到⽂件的末尾；若⽂件不存在，則新建⽂件。 
常⻅的mode組合 
'r'或'rt'： 默認(rèn)模式，⽂本讀模式 
'w'或'wt'： 以⽂本寫模式打開（打開前⽂件會被清空） 
'rb'： 以⼆進(jìn)制讀模式打開 'ab'： 以⼆進(jìn)制追加模式打開 
'wb'： 以⼆進(jìn)制寫模式打開（打開前⽂件會被清空） 
'r+'： 以⽂本讀寫模式打開，默認(rèn)寫的指針開始指在⽂件開頭, 因此會覆寫⽂件 
'w+'： 以⽂本讀寫模式打開（打開前⽂件會被清空） 
'a+'： 以⽂本讀寫模式打開（寫只能寫在⽂件末尾） 
'rb+'： 以⼆進(jìn)制讀寫模式打開 
'wb+'： 以⼆進(jìn)制讀寫模式打開（打開前⽂件會被清空） 
'ab+'： 以⼆進(jìn)制讀寫模式打開

初看起來，模式很多，但是，它們只是相互組合罷了。建議記住最基本的w、r、a，遇到特殊場景，再翻看⼀下就好了。

四、從with語句到上下文管理器

基礎(chǔ)部分講完了，下⾯是進(jìn)階部分。知其然，更要知其所以然。

1、with語句是初學(xué)者必會常識

⾸先，要解釋⼀下為啥前⽂直接就⽤了with語句。with語句是讀寫⽂件時的優(yōu)雅寫法，這已經(jīng)默認(rèn)是Python初學(xué)者必會的常識了。如果你還不會，先看看⽤和不⽤with語句的對⽐：

# 不⽤with語句的正確寫法 
try: 
    f = open('test.txt','w') 
    f.writelines(['python',' is',' a',' cat']) 
finally: 
    if f: 
        f.close()
# 使⽤with語句的正確寫法 
with open('test.txt','w') as f:
    f.writelines(['python',' is',' a',' cat'])

因為⽂件對象會占⽤操作系統(tǒng)的資源，并且操作系統(tǒng)同⼀時間能打開的⽂件數(shù)量是有限的，所以open()⽅法之后⼀定要調(diào)⽤close()⽅法。另外，讀寫操作可能出現(xiàn)IO異常的情況，所以要加try...finally，保證⽆論如何，都會調(diào)⽤到close()⽅法。   這樣寫萬⽆⼀失，但是實在繁瑣，⼀不⼩⼼還可能漏寫或者寫錯。⽽with語句會保證調(diào)⽤close()，只需⼀⾏代碼，簡直不要太優(yōu)雅！所以，with語句是Python初學(xué)者必會技能。

2、什么是上下⽂管理器？

下⾯，重頭戲來了，什么是上下⽂管理器（context manager）？

上下⽂管理器是這樣⼀個對象：它定義程序運⾏時需要建⽴的上下⽂，處理程序的進(jìn)⼊和退出，實現(xiàn)了上下⽂管理協(xié)議，即在對象中定義了 __enter__() 和 __exit__() ⽅法。 __enter__()：進(jìn)⼊運⾏時的上下⽂，返回運⾏時上下⽂相關(guān)的對象，with 語句中會將這個返回值綁定到⽬標(biāo)對象。 __exit__(exception_type, exception_value, traceback)：退出運⾏時的上下⽂，定義在塊執(zhí)⾏（或終⽌）之后上下⽂管理器應(yīng)該做什么。它可以處理異常、清理現(xiàn)場或者處理 with 塊中語句執(zhí)⾏完成之后需要處理的動作。

注意 enter 和 exit 的前后有兩個下劃線，Python 中⾃帶了很多類似的⽅法，它們是很神秘⼜很強(qiáng)⼤的存在，江湖⼈常常稱其為“⿊魔法”。例如，迭代器協(xié)議就實現(xiàn)了__iter__⽅法。   在Python的內(nèi)置類型中，很多類型都是⽀持上下⽂管理協(xié)議的，例如 file、thread.LockType、 threading.Lock 等等。上下⽂管理器⽆法獨⽴使⽤，它們要與 with 相結(jié)合，with 語句可以在代碼塊運⾏前進(jìn)⼊⼀個運⾏時上下⽂（執(zhí)⾏__enter__⽅法），并在代碼塊結(jié)束后退出該上下⽂（執(zhí)⾏__exit__⽅法）。   with 語句適⽤于對資源進(jìn)⾏訪問的場合，確保不管使⽤過程中是否發(fā)⽣異常都會執(zhí)⾏必要的“清理”操作，釋放資源，⽐如⽂件使⽤后⾃動關(guān)閉、線程中鎖的⾃動獲取和釋放等。  

3、⾃定義上下⽂管理器

除了Python的內(nèi)置類型，任何⼈都可以定義⾃⼰的上下⽂管理器。下⾯是⼀個示例：

class OpenFile(object):
    def __init__(self,filename,mode):
def open_file(name):
    ff = open(name, 'w')
    ff.write("enter now\n")
    try:
        yield ff
    except RuntimeError:
        pass
        ff.write("exit now")
        ff.close()
    with open_file('test.txt') as f:
        f.write('Hello World!\n')

最終寫⼊⽂件的結(jié)果是：

enter now Hello World! exit now

上下⽂管理器必須同時提供 enter() 和 exit() ⽅法的定義，缺少任何⼀個都會導(dǎo)致 AttributeError。   上下⽂管理器在執(zhí)⾏過程中可能會出現(xiàn)異常，exit() 的返回值會決定異常的處理⽅式：返回值等于 False，那么這個異常將被重新拋出到上層；返回值等于 True，那么這個異常就被忽略，繼續(xù)執(zhí)⾏后⾯的代碼。exit() 有三個參數(shù)(exception_type, exception_value, traceback)，即是異常的相關(guān)信息。

4、contextlib實現(xiàn)上下⽂管理器

上例中，⾃定義上下⽂管理器的寫法還是挺繁瑣的，⽽且只能⽤于類級別。為了更好地輔助上下⽂管理，Python 內(nèi)置提供了 contextlib 模塊，進(jìn)⽽可以很⽅便地實現(xiàn)函數(shù)級別的上下⽂管理器。   該模塊本質(zhì)上是通過裝飾器(decorators)和⽣成器(generators)來實現(xiàn)上下⽂管理器，可以直接作⽤于函數(shù)/對象，⽽不⽤去關(guān)⼼ enter() 和 exit() ⽅法的具體實現(xiàn)。   先把上⾯的例⼦改造⼀下，然后我們再對照著解釋：

from contextlib import contextmanager 
 
@contextmanager
def open_file(name): 
    ff = open(name, 'w') 
    ff.write("enter now\n") 
    try: 
        yield ff 
    except RuntimeError: 
        pass 
    ff.write("exit now") 
    ff.close() 
with open_file('test.txt') as f: 
    f.write('Hello World!\n')

contextmanager 是要使⽤的裝飾器，yield 關(guān)鍵字將普通的函數(shù)變成了⽣成器。yield 的返回值（ff）等于上例__enter__()的返回值，也就是 as 語句的值（f），⽽ yield 前后的內(nèi)容，分別是__enter__() 和__exit__() ⽅法⾥的內(nèi)容。   使⽤ contextlib，可以避免類定義、__enter__() 和 __exit__() ⽅法，但是需要我們捕捉可能的異常（例如，yield 只能返回⼀個值，否則會導(dǎo)致異常 RuntimeError），所以 try...except 語句不能忽略。  

到此這篇關(guān)于Python初學(xué)者必備的文件讀寫指南的文章就介紹到這了,更多相關(guān)Python文件讀寫內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！