08-Python文件處理
一、打開關閉文件
可以用 file 對象做大部分的文件操作。 file()在python3中已經被廢除，使用open()打開文件
open 函數
先用open()打開一個文件，創建一個file
對象，再用相關方法才可以調用它進行讀寫。
語法
file object = open(file_name [, access_mode][, buffering])
參數說明
file_name：
file_name變量是一個包含了你要訪問的文件名稱的字符串值。
access_mode：
決定打開文件的模式：只讀’r’，寫入’w’，追加’a’等，所有可取值見后面的完全列表，這個參數是非強制的，默認文件訪問模式為只讀?。
buffering:
如果buffering值被設為0（python3已經不能使用0了），就不會有寄存，數據會立即寫入文件。
如果buffering值取1（默認值），訪問文件時會寄存行，直到文件關閉才會把數據同步到文件。一般緩沖使用系統默認值即可.
如果將buffering的值設為大于1的整數，表明這就是的寄存區的緩沖大小。緩沖內容超過這個大小之后就會同步硬盤
如果取負值，寄存區的緩沖大小則為系統默認。
例1.
>>> f = open(‘c.txt’,‘w’,0) #沒有緩沖
>>> f.write(‘hello world’) #close之前打開另一終端觀察文件發現已經寫入進去，說明關閉文件之前就已經寫到硬盤
>>> f.close()
例2.
? >>> f = open(‘d.txt’,‘w’,1) #有緩沖
? >>> f.write(‘hello world’) #close之前打開另一終端觀察文件發現沒有寫入進去，說明關閉文件之前沒有寫到硬盤
? >>> f.close()
?
不同模式打開文件的完全列表
| 模式 | 描述 |
|---|---|
| r | 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。以這種模式打開的文件必須是已經存在的(U模式也是) |
| rb | 以二進制格式打開一個文件用于只讀。文件指針將會放在文件的開頭。這是默認模式。 |
| r+ | 打開一個文件用于讀寫。文件指針將會放在文件的開頭。注意這個模式默認是帶緩沖的 |
| rb+ | 以二進制格式打開一個文件用于讀寫。文件指針將會放在文件的開頭。 |
| w | 打開一個文件只用于寫入。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| wb | 以二進制格式打開一個文件只用于寫入。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| w+ | 打開一個文件用于讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| wb+ | 以二進制格式打開一個文件用于讀寫。如果該文件已存在則將其覆蓋。如果該文件不存在，創建新文件。 |
| a | 打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后即使你 seek 到了其它的地方。如果該文件不存在，創建新文件進行寫入。 |
| ab | 以二進制格式打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之后。如果該文件不存在，創建新文件進行寫入。 |
| a+ | 打開一個文件用于讀寫。如果該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。如果該文件不存在，創建新文件用于讀寫。 |
| ab+ | 以二進制格式打開一個文件用于追加。如果該文件已存在，文件指針將會放在文件的結尾。如果該文件不存在，創建新文件用于讀寫。 |
通用換行符支持(UNS)：
還有一個特殊的模式U,不同平臺用來表示行結束的符號是不同的, 例如 \n, \r, 或者 \r\n.當你使用 ‘U’ 標志打開文件的時候, 所有的行分割符(或行結束符, 無論它原來是什么)通過 Python 的輸入方法(例如 read*() )返回時都會被替換為換行符 NEWLINE(\n).注意 UNS 只用于讀取文本文件. 沒有對應的處理文件輸出的方法.
可以使用U,rU或Ua模式打開文件
關于 ‘b’ 的說明
對于所有 POSIX 兼容的 Unix 系統(包括Linux)來說, 'b’是可有可無的, 因為它們把所有的文件當作二進制文件, 包括文本文件.
下面是從 Linux 手冊的 fopen() 函數使用中摘錄的一段, Python 語言中的 open() 函數就是從它衍生出的:
指示文件打開模式的字符串中也可以包含字符 “b” , 但它不能做為第一個字符出現.
這樣做的目的是為了嚴格地滿足 ANSI C3.159-1989 (即 ANSI C)中的規定。
事實上它沒有任何效果, 所有POSIX 兼容系統, 包括 Linux , 都會忽略 “b” ,其它系統可能會區分文本文件和二進制文件, 如果你要處理一個二進制文件, 并希望你的程序可以移植到其它非 Unix 的環境中, 加上"b" 會是不錯的主意
擴展閱讀：
計算機在物理內存上面存放的都是二進制，所以文本文件和二進制文件的主要區別是在邏輯上的而不是物理上的。而從文件的編碼方式來看，文件可以分為文本文件和二進制文件。文本文件是基于字符編碼的文件，常見的有ASCII、Unicode等，二進制文件是基于值編碼的文件，可以看成是變長編碼，你可以根據自己的需要，決定多少個比特代表一個值。從文件編碼的方式來看，文件可分為ASCII碼文件和二進制碼文件兩種。
(1)ASCII文件也稱為文本文件，這種文件在磁盤中存放時每個字符對應一個字節，用于存放對應的ASCII碼。例如，數5678的存儲形式為：ASC碼： 00110101 00110110 00110111 00111000↓ ↓ ↓ ↓ 十進制碼： 5 6 7 8 共占用4個字節。ASCII碼文件可在屏幕上按字符顯示， 例如源程序文件就是ASCII文件，用DOS命令TYPE可顯示文件的內容。 由于是按字符顯示，因此能讀懂文件內容。(2)二進制文件是按二進制的編碼方式來存放文件的。 例如， 數5678的存儲形式為： 00010110 00101110只占二個字節。二進制文件雖然也可在屏幕上顯示，但其內容無法讀懂。C系統在處理這些文件時，并不區分類型，都看成是字符流，按字節進行處理。 輸入輸出字符流的開始和結束只由程序控制而不受物理符號(如回車符)的控制。 因此也把這種文件稱作“流式文件”。存儲的方式不同二進制文件就是把內存中的數據按其在內存中存儲的形式原樣輸出到磁盤中存放，即存放的是數據的原形式。文本文件是把數據的終端形式的二進制數據輸出到磁盤上存放，即存放的是數據的終端形式在實際存儲中最好是將數據分成字符數據和非字符數據兩類:(1)如果存儲的是字符數據，無論采用文本文件還是二進制文件都是沒有任何區別的，所以討論使用文本文件還是二進制文件是沒有意義的。(2)如果存儲的是非字符數據，又要看我們使用的情況來決定:a:如果是需要頻繁的保存和訪問數據，那么應該采取二進制文件進行存放，這樣可以節省存儲空間和轉換時間。b:如果需要頻繁的向終端顯示數據或從終端讀入數據，那么應該采用文本文件進行存放，這樣可以節省轉換時間。文本文件的打開方式和二進制文件打開方式的區別
(1)文本模式中回車被當成一個字符'\n'，在文件中如果讀到0x1B,文本模式會認為這是文件結束符，會按照一定方式對數據做相應的轉換。
(2)二進制模式中'\n'會被認為是兩個字符0x0D，0x0A;在讀到0x1B時，二進制模式不會對文件進行處理。只讀/寫模式的r/w和rb/wb
(1)r:讀取到的是文本數據(字符的編碼),使用 open() 打開文件時，默認采用 GBK 編碼。但當要打開的文件不是 GBK 編碼格式時，可以在使用 open() 函數時，手動指定打開文件的編碼格式，例如：file = open("a.txt",encoding="utf-8")(2)rb: 讀取到的是二進制數據(字符在硬盤中存儲的二進制),不需要指定編碼.
file對象的屬性
一個文件被打開后，你就會擁有一個file對象，你可以得到有關該文件的各種信息。
file對象屬性列表：
| 屬性 | 描述 |
|---|---|
| file.closed | 如果文件已被關閉返回true，否則返回false。 |
| file.mode | 返回被打開文件的訪問模式。 |
| file.name | 返回文件的名稱。 |
例：
#!/usr/bin/python3.8
# 打開一個文件
fo = open("foo.txt", "w")
print("文件名: ", fo.name)
print("是否已關閉 : ", fo.closed)
print("訪問模式 : ", fo.mode)輸出結果：
文件名: foo.txt
是否已關閉 : False
訪問模式 : w
close()方法
File 對象的 close（）方法刷新緩沖區里任何還沒寫入的信息，并關閉該文件，這之后便不能再進行寫入。
語法：
fileObject.close()
例：
#!/usr/bin/python3.8
fo = open("foo.txt", "w")
print("文件名: ", fo.name)
fo.close() # 關閉打開的文件輸出結果：
文件名: foo.txt
with
用with可以不用關閉文件
with open(‘/proc/meminfo’) as fd: 和 fd=open(‘/proc/meminfo’) 執行的結果一樣，都是遍歷文件；
后者當打開的文件達到幾個G的時候，很消耗內存，而前者沒有這個問題
#!/usr/bin/env python3.8
with open('a.txt','w') as f:f.write('hello world')with open('a.txt','r') as f:print(f.read())
二、讀文件
使用方法：read() readline() readlines()
read()：返回字符串
從一個打開的文件中讀取一個字符串。
fileObject.read([count])
被傳遞的參數count是要從已打開文件中讀取的字節計數。
該方法從文件的開頭開始讀入，如果沒有傳入count參數(默認值為 -1)或者值為負, 文件將被讀取到末尾.
#!/usr/bin/python3.8
fo = open("foo.txt", "r+")
str = fo.read(10);
print("讀取的字符串是 : ", str)
fo.close() 輸出結果： 讀取的字符串是 : www.fklinu
Windows下字符編碼報錯
報錯如下：
Traceback (most recent call last):File "c:/Users/86186/Desktop/python-exc/hello.py", line 3, in <module>str = fo.read(10);
UnicodeDecodeError: 'gbk' codec can't decode byte 0xff in position 0: illegal multibyte sequence 解決方案：
#!/usr/bin/python3.8
fo = open("foo.txt", "r+",encoding="utf-8",errors="ignore") # 如果在windows下讀文件報錯就加上編碼和錯誤忽略,這里用的utf-8也不合適，最后的結果會有問題，每個字符之間都有個空格
str = fo.read(10);
print("讀取的字符串是 : ", str)
fo.close() #!/usr/bin/python3.8
fo = open("foo.txt", "r+",encoding="utf-16",errors="ignore") # 查看記事本用的字符編碼是utf-16,這樣才能可以讀到正確的內容
str = fo.read(10);
print("讀取的字符串是 : ", str)
fo.close()
readline()：返回字符串
讀取下個行結束符之前的所有字節. 作為字符串返回整行,包括行結束符。
和 read() 相同, 它也有一個可選的 size 參數, 默認為 -1, 代表讀至行結束符， 如果提供了該參數, 那么在超過 size 個字節后會返回不完整的行.
readlines()：返回字符串列表
讀取所有剩余的行，返回一個字符串列表。
三、寫文件
使用方法：write() writelines()
write()
可將任何字符串(包括二進制數據)寫入一個打開的文件，Linux下不會在字符串的結尾添加換行符(‘\n’)，windows是有換行符的，不支持數字
writelines()
是針對字符串序列的操作, 它接受一個字符串序列(字符串，字符串列表，字符串元組)作為參數, 將它們寫入文件. 行結束符并不會被自動加入, 所以如果需要的話, 你必須在調用writelines()前給每行結尾加上行結束符.
語法：
fileObject.write(string)
string參數是要寫入到已打開文件的內容。
#!/usr/bin/python3.8
fo = open("foo.txt", "w")
fo.write("www.fklinux.com!\nVery good site!\n");
fo.close() # 關閉打開的文件被創建的foo.txt文件內容:
# cat foo.txt
www.fklinux.com!
Very good site!
四、文件指針
tell()
這個方法告訴我們文件內的當前位置，換句話說，下一次的讀寫會發生在文件開頭這么多字節之后。
seek()
可以在文件中移動文件指針到不同的位置.
語法：
seek(offset [,from])
offset
? 表示要移動的字節數
from
? 指定開始移動字節的參考位置。
? 如果from被設為0，這意味著將文件的開頭作為移動字節的參考位置（0 – start of stream (the default); offset should be zero or positive）
? 如果設為1，則使用當前的位置作為參考位置（python2可以，python3必須帶b讀文件–rb）
? 如果設為2，那么該文件的末尾將作為參考位置 (其實唯一的作用是將指針移動到最后seek(0,2))
? seek配置r+模式可以實現從指定位置修改文件
例： 就用上面創建的文件foo.txt
#!/usr/bin/python3.8
# python2沒有任何問題，python3 在seek的時候如果相對位置是1，需要打開文件的是時候帶'b'
fo = open("foo.txt", "r+")
str = fo.read(10);
print ("讀取的字符串是 : ", str)# 查找當前位置
position = fo.tell();
print ("當前文件位置 : ", position)# 把指針再次重新定位到文件開頭
position = fo.seek(0, 0);
str = fo.read(10);
print ("重新讀取字符串 : ", str)
# 關閉打開的文件
fo.close()輸出結果： 讀取的字符串是 : www.fklinu當前文件位置 : 10重新讀取字符串 : www.fklinuIn [77]: with open('a.txt','rb') as f:...: print(f.read(2))...: f.seek(2,1) ...: print(f.read(2))...:
b'he'
b'o '
五、文件迭代
一行一行訪問文件很簡單:
for eachLine in f::
eachLine 代表文本文件的一行，包括末尾的行結束符
?Python 2.2 中, 引進了迭代器和文件迭代, 文件對象成為了它們自己的迭代器用戶不必調用 read() 方法就可以在 for 循環中迭代文件的每一行.
迭代器之前的老方法
for eachLine in f.readline()::
In [35]: for i in f:
...: print(i,end="") # end的作用是取消print默認的換行
...: 1111222233334444
print函數取消默認換行符
print 語句默認在輸出內容末尾后加一個換行符, 而在語句后加一個逗號就可以避免這個行為. readline() 和 readlines() 函數不對行里的空白字符做任何處理，所以你有必要加上逗號. 如果你省略逗號, 那么顯示出的文本每行后會有兩個換行符, 其中一個是輸入是附帶的, 另個是 print 語句自動添加的.
打印輸出的時候取消默認換行，python2只需要在后面加一個逗號’,’
#!/usr/bin/env python
print "hello", # 在這里加逗號可以取消換行
print "hi"#!/usr/bin/env python3.8
print("hello",end="") # 這是python3里的方法
print "hi"
另外也可使用迭代器的 next 方法, file.next() 可以用來讀取文件的下一行.
注意：python3已經不支持file.next()方法，python3使用系統內置函數next()
和其它迭代器一樣，Python 也會在所有行迭代完成后引發 StopIteration 異常.
In [269]: f=open("a.txt","r+")In [270]: next(f)
Out[270]: 'hello world\n'In [271]: next(f)
Out[271]: 'nice to meet you\n'In [272]: next(f)
Out[272]: 'I love you\n'
六、文件重命名和刪除
創建普通文件
>> os.mknod("/a.txt")
Python的os模塊提供了幫你執行文件處理操作的方法，比如重命名和刪除文件。
rename()方法
語法：
os.rename(current_file_name, new_file_name)
例子： 下例將重命名一個已經存在的文件test1.txt。
#!/usr/bin/env python3.8
import os
os.rename("foo.txt","foo1.txt") # 重命名文件foo.txt到foo1.txt
remove()方法
刪除文件
語法：
os.remove(file_name)
例子： 下例將刪除一個已經存在的文件test2.txt。
#!/usr/bin/python3.8
import os
os.remove("test2.txt") # 刪除一個已經存在的文件test2.txt
七、Python目錄操作
os模塊有許多方法能幫你創建，刪除和更改目錄。
mkdir()方法
語法：
os.mkdir(“newdir”)
例子：
#!/usr/bin/python3.8
import os
os.mkdir("test") # 創建目錄test
chdir()方法
改變當前工作目錄
語法：
os.chdir(“newdir”)
例子： 下例將進入"/home/newdir"目錄。
#!/usr/bin/python3.8
import os
os.chdir("/home/newdir") # 將當前目錄改為"/home/newdir"
getcwd()方法
顯示當前工作目錄
語法：
os.getcwd()
例子：
#!/usr/bin/python
import os
os.getcwd() # 給出當前的目錄
rmdir()方法
刪除目錄，只能刪除空目錄
語法：
os.rmdir(‘dirname’)
例子：
#!/usr/bin/python3.8
import os
os.rmdir( "/tmp/test" ) # 刪除”"tmp/test"目錄
八、Python File方法列表
file 對象使用 open 函數來創建，下表列出了 file 對象常用的方法
| 方法 | 描述 |
|---|---|
| file.close() | 關閉文件。關閉后文件不能再進行讀寫操作。 |
| file.flush() | 刷新文件內部緩沖，直接把內部緩沖區的數據立刻寫入文件, 而不是被動的等待輸出緩沖區寫入。 |
| file.fileno() | 返回一個整型的文件描述符(file descriptor FD 整型), 可以用在如os模塊的read方法等一些底層操作上。 |
| file.isatty() | 如果文件連接到一個終端設備返回 True，否則返回 False。 |
| file.read([size]) | 從文件讀取指定的字節數，如果未給定或為負則讀取所有。 |
| file.readline([size]) | 讀取整行，包括 “\n” 字符。 |
| file.readlines([sizehint]) | 讀取所有行并返回列表，若給定sizeint>0，返回總和大約為sizeint字節的行, 實際讀取值可能比sizhint較大, 因為需要填充緩沖區。 |
| file.seek(offset[,whence]) | 設置文件當前位置 |
| file.tell() | 返回文件當前位置。 |
| file.truncate([size]) | 截取文件，截取的字節通過size指定，默認為當前文件位置。 |
| file.write(str) | 將字符串寫入文件，沒有返回值。 |
| file.writelines(sequence) | 向文件寫入一個序列字符串列表，如果需要換行則要自己加入每行的換行符。 |
truncate() 方法
將文件截取到當前文件指針位置或者到給定 size , 以字節為單位.
它接受一個可選的 size 作為參數. 如果給定, 那么文件將被截取到最多 size 字節處. 如果沒有傳遞 size 參數, 那么默認將截取到文件的當前位置.例如, 你剛打開了一個文件, 然后立即調用 truncate() 方法, 那么你的文件(內容)實際上被刪除,這時候你是其實是從 0 字節開始截取的
In [19]: cat foo.txt
aaaaa
bbbbbIn [20]: f = open('foo.txt','r+') #注意權限必須帶+號In [21]: f.truncate(2)
Out[21]: 2In [22]: cat foo.txt
aa
八、Python序列化數據存儲
序列化 (Serialization)是指將對象、數據結構的狀態信息轉換為可以存儲或傳輸的形式的過程。在序列化期間，對象將其當前狀態寫入到臨時或持久性存儲區。以后，可以通過從存儲區中讀取或反序列化對象的狀態，重新創建該對象。
我們編寫的程序，會涉及到各種各樣的對象、數據結構，它們通常是以變量的形式在內存中存在著。當程序運行結束后，這些變量也就會被清理。但我們有時希望能夠在下一次編寫程序時恢復上一次的某個對象（如機器學習中的到結果，需要程序運行較長時間，多次運行時間成本太大），這就需要我們將變量進行持久化的存儲。
一種方式是利用文件讀寫的方式將變量轉化為某種形式的字符串寫入文件內，但需要自己控制存儲格式顯得十分笨拙。更好的方式是通過序列化的方式將變量持久化至本地。
json是一種所有的語言都可以識別的數據結構。
如果我們將一個字典或者序列化成了一個json存在文件里，那么java代碼或者js代碼也可以拿來用。
但是如果我們用pickle進行序列化，其他語言就不能讀懂這是什么了
所以，如果你序列化的內容是列表或者字典，非常推薦你使用json模塊
但如果出于某種原因你不得不序列化其他的數據類型，而未來你還會用python對這個數據進行反序列化的話，那么就可以使用pickle
json序列化
json模塊提供了四個功能：
dumps 序列化對象至字符串，存儲到內存
? loads 對應的反序列化方法
? dump 序列化對象至本地文件
? load 對應的反序列化方法
pickle序列化
pickle模塊提供了四個功能：
dumps 序列化對象至字符串，存儲到內存
? loads 對應的反序列化方法
? dump 序列化對象至本地文件
? load 對應的反序列化方法
pickle可以存儲什么類型的數據？
- 所有python支持的原生類型：布爾值，整數，浮點數，復數，字符串，字節，None。
- 由任何原生類型組成的列表，元組，字典和集合。
- 函數，類，類的實例
例子：
pickle模塊
>>> import pickle
>>> data = ['aa', 'bb', 'cc']
dumps 存儲數據，將數據通過特殊的形式轉換為只有python語言認識的字符串
>>> p_str = pickle.dumps(data)
>>> print(p_str) b'\x80\x03]q\x00(X\x02\x00\x00\x00aaq\x01X\x02\x00\x00\x00bbq\x02X\x02\x00\x00\x00ccq\x03e.
loads 讀取數據，將pickle數據轉換為python的數據結構
>>> mes = pickle.loads(p_str)
>>> print(mes)['aa', 'bb', 'cc']
dump 存儲數據，將數據通過特殊的形式轉換為只有python語言認識的字符串，并寫入文件
with open('/tmp/aa.txt', 'wb') as f:pickle.dump(data, f)
注意：以上代碼中的w必須帶b
load 讀取數據，從數據文件中讀取數據，并轉換為python的數據結構
with open('/tmp/aa.txt', 'rb') as f:data = pickle.load(f)
注意：以上代碼中的r必須帶b
寫入多個對象
In [25]: import pickle
In [26]: li = [1,2,3]
In [27]: di = {'a':'b'}In [28]: with open('pickles.db','wb') as f:...: pickle.dump(li,f)...: pickle.dump(di,f)...:
讀取多個對象
In [29]: with open('pickles.db','rb') as f:...: l2 = pickle.load(f)...: d2 = pickle.load(f)...: In [30]: l2
Out[30]: [1, 2, 3]In [31]: d2
Out[31]: {'a': 'b'}
在有序列化數據的基礎上追加數據
In [2]: import pickle
In [1]: d={"name":"fulei","age":28,"shengao":18} # 第一次存儲數據
In [3]: with open("a.txt","wb") as f: ...: pickle.dump(d,f) In [6]: e={"name":"fulei","age":28,"shengao":18} In [7]: with open("a.txt","ab") as f: # 第一次追加...: pickle.dump(e,f) In [9]: l={"xingming":"fulei","nianling":27,"gaodu":180} In [10]: with open("a.txt","ab") as f: # 第二次追加...: pickle.dump(l,f) In [13]: with open("a.txt","rb") as f: # 取數據時要按順序取3次...: e=pickle.load(f) ...: t=pickle.load(f) ...: v=pickle.load(f)
In [14]: e
Out[14]: {'name': 'fulei', 'age': 28, 'shengao': 18}In [15]: t
Out[15]: {'name': 'fulei', 'age': 28, 'shengao': 18}In [16]: v
Out[16]: {'xingming': 'fulei', 'nianling': 27, 'gaodu': 180}
json模塊
In [1]: import jsonIn [2]: s = json.dumps({"a": "b"})In [3]: s
Out[3]: '{"a": "b"}'In [4]: json.loads(s)
Out[4]: {'a': 'b'}
In [5]: import jsonIn [6]: li = [1,2,3]In [7]: di = {'a':'b'}In [8]: with open('json.db','w') as f:...: json.dump(li,f) #序列化存儲列表'li'到文件中...: In [9]: !cat json.db #json序列化的文件是直接可讀的
[1, 2, 3]In [15]: with open('json.db','r') as f:...: l2 = json.load(f) #反序列化...: In [16]: l2
Out[16]: [1, 2, 3]
序列化多個對象到文件中
In [20]: with open('json.db','w') as f:...: f.write(json.dumps(li)+'\n') # 需要換行符保證每個對象占一行...: f.write(json.dumps(di)+'\n')
從一個文件讀取多個序列化對象時需用 loads 配合readline，一次讀一行
In [21]: with open('json.db','r') as f:...: l2 = json.loads(f.readline())...: d2 = json.loads(f.readline())...: In [22]: l2
Out[22]: [1, 2, 3]In [23]: d2
Out[23]: {'a': 'b'}
擴展練習
----編寫程序，實現程序功能為修改指定文件內指定內容
[root@python python]# cat alterfile.py
#!/usr/bin/env python3
# 程序執行方式：python alterfile.py test.txt 舊關鍵字 新關鍵字
import sys
file_name = sys.argv[1]
old_str = sys.argv[2]
new_str = sys.argv[3]def alter(file,old_str,new_str):file_data = ""with open(file,"r") as f:for line in f:if old_str in line:line = line.replace(old_str,new_str)file_data += linewith open(file,"w") as f:f.write(file_data)alter(file_name,old_str,new_str)[root@python python]# cat test.txt
hello world
nice to meet you
nihao every body[root@python python]# python alterfile.py test.txt world 世界[root@python python]# cat test.txt
hello 世界
nice to meet you
nihao every body
[root@python python]# cat alterfile.py
#!/usr/bin/env python3
# 程序執行方式：python alterfile.py test.txt 舊關鍵字 新關鍵字
import sys
file_name = sys.argv[1]
old_str = sys.argv[2]
new_str = sys.argv[3]def alter(file,old_str,new_str):file_data = ""with open(file,"r") as f:for line in f:if old_str in line:line = line.replace(old_str,new_str)file_data += linewith open(file,"w") as f:f.write(file_data)alter(file_name,old_str,new_str)[root@python python]# cat test.txt
hello world
nice to meet you
nihao every body[root@python python]# python alterfile.py test.txt world 世界[root@python python]# cat test.txt
hello 世界
nice to meet you
nihao every body
