【Python全棧筆記】05 [模塊二] 19 Oct 文件的操做

 文件操做

 

通常步驟1. 文件打開 2. 文件操做 3. 文件關閉

1. 打開文件 

使用open(文件名(絕對路徑), 打開模式, 編碼) 

文件打開的模式有：

r:  只讀模式（默認）

w: 只寫模式 （不可讀，文件不存在就建立，存在則清空）

x:  只寫模式 （不可讀，文件不存在就建立，存在則報錯）

a:  追加模式 （不可讀，若是文件不存在就建立，若是存在則在原文件後面追加）

以上都是以字符串方式打開

'+' 表示能夠同時讀寫某個文件

'b' 表示以字節的方式操做 -> 後續socket部分會用到 

文件的打開方式有 普通打開方式 和 二進制打開方式

普通打開：python內部將0101自動轉換成字符串

二進制打開：'b'模式加str - bytes 轉換 + 手動encoding='utf-8'

 1 # 打開一個文件使用open(文件名（絕對路徑），打開模式，編碼)
 2 # 文件打開默認只讀模式（'r'）
 3 #
 4 f = open('test.log', 'r')
 5 data = f.read()
 6 f.close()
 7 print(data)
 8 
 9 f = open('test.log', 'r')
10 data = f.write('ehhh')
11 f.close()
12 print(data)
13 # 在只讀狀態下寫入，報錯 Traceback (most recent call last):
14 # File "D:/NaomiPyer/naomi_01/mod8/file_stuff.py", line 21, in <module>
15 #  data = f.write('ehhh')
16 # io.UnsupportedOperation: not writable
17 
18 # 只寫 - 文件不可讀，只寫狀況下，文件不存在則建立，存在則清空內容寫入
19 f = open('test1.log', 'w')
20 f.write('ruby')
21 f.close()
22 # 執行後自動建立了有'ruby'內容的文件
23 f = open('test1.log', 'w')
24 f.write('python')
25 f.close()
26 # 修改寫入內容再次執行，文件內容更新爲新輸入的內容
27 f = open('test1.log', 'w')
28 f.read()
29 # 報錯， 不可讀 => io.UnsupportedOperation: not readable
30 
31 # x 只寫 - 不可讀，不存在則建立，存在則報錯
32 f = open('test1.log', 'x')
33 f.write(' ')
34 f.close()
35 # 文件已存在，報錯 => FileExistsError: [Errno 17] File exists: 'test1.log'
36 
37 # a 追加 - 不可讀，不存在則建立，存在則只追加內容
38 f = open('test.log', 'a')
39 f.write('java')
40 f.close()
41 # 'test.log'文件裏面追加了java 內容
42 
43 # 以上爲文件的基本打開方式
44 # 一般讀取到的文件數據，類型是str, 若是要轉換爲字節，能夠用types()
45 f = open('test.log', 'r')
46 data = f.read()
47 a = bytes(data, encoding='utf-8')
48 print(a)
49 # 這樣文件裏的數據就以bytes輸出了 => b'zen of pythonjava'
50 
51 # 以字節方式打開
52 # 1. 只讀
53 f = open('test.log', 'rb')
54 data = f.read()
55 print(data)
56 str_data = str(data, encoding='utf-8')
57 print(str_data)
58 # 不須要編碼
59 
60 # 2. 只寫
61 f = open('test.log', 'wb')
62 f.write(bytes('牛奶', encoding='utf-8'))
63 f.close()
64 # 寫入的字符串"牛奶"須要用編碼變爲bytes寫入
65 f = open('test1.log', 'wb')
66 str_data = '牛奶'
67 bytes_data = bytes(str_data, encoding='utf-8')
68 f.write(bytes_data)
69 f.close()
70 # 以字節的方式寫入

 '+' 

r+ 讀寫 

 1 # r+
 2 # w, 末尾追加，指針最後
 3 f = open('test1.log', 'r+', encoding='utf-8')
 4 
 5 # 指針爲0， 起始位置
 6 print(f.tell())
 7 
 8 data = f.read(3)  # read(3) 讀取3個字符（中文9個字節）
 9 print(type(data), data)
10 print(f.tell())
11 # f.write('草莓')
12 # f.seek(0)
13 # data = f.read()
14 f.read(2)
15 print(f.tell())
16 print(type(data), data)
17 f.close()
18 # 指針 讀取完數據，繼續讀取的時候從上次停下的位置開始繼續讀取
19 # 經過tell() 來獲取指針
20 # 經過seek() 來調整指針 [seek以字節來講]
21 # 寫入的時候，指針會調到最後

 

w+ 寫讀

 1 # w+，先清空，寫完內容以後才能夠讀
 2 # 寫入完畢，指針到最後 
 3 f = open('test1.log', 'w+', encoding='utf-8')
 4 data = f.read()
 5 f.close()
 6 print(data)
 7 # 沒有數據，由於寫讀是先寫入再讀取，沒有寫入的內容
 8 f = open('test1.log', 'w+', encoding='utf-8')
 9 f.write('雞蛋')
10 data = f.read()
11 f.close()
12 print(data)
13 # 仍是沒有內容，由於寫完以後指針已經到文件末尾
14 f = open('test1.log', 'w+', encoding='utf-8')
15 f.write('雞蛋')
16 f.seek(0)
17 data = f.read()
18 f.close()
19 print(data)
20 # 寫入數據後，調整指針到起始位置，讀到文件內容

 

x+ 寫讀

基本和 w+ 同樣，不一樣的是，若是文件已經存在，會報錯。 

a+ 寫讀 

 1 # a+
 2 # 寫時追加，放到最後
 3 f = open('test.log', 'a+', encoding='utf-8')
 4 print(f.tell())
 5 data = f.read()
 6 print(data)
 7 f.seek(0)
 8 data = f.read()
 9 print(data)
10 f.close()
11 # 由於a是追加，其實在打開文件的同時，指針已經到了文件末尾
12 # => 6 空 牛奶

 

幾種讀寫方式共有的特色

1 # 從開始向後讀
2 # 寫，追加，指針調到最後   
3 f.tell()  # 獲取指針的位置
4 f.seek(num)  # 調整指針的位置
5 data = f.read(1)  # 讀取一個字符（中文3個字節）
6 print(data)
7 print(f.tell())  # 向後移了三個字節
8 f.write('content')  # 在尾部追加，而且指針移動到最後
9 f.close()

在不肯定每一個讀寫方式特色的時候，能夠經過tell(), seek(), read(), write() 方法來判斷 

 

'b' 表示以字節的方式操做

wb w+b 

rb r+b

xb x+b

ab a+b

上述是和在底層數據交流的時候，以字節的方式讀寫，默認以字節方式打開，拿到字節數據後轉化爲字符串進行操做，寫入的時候一樣轉換爲字節寫入。

文件的操做：

 1 # close() 關閉一個文件
 2 
 3 # fileno() 文件描述符（後續講）
 4 
 5 # flush() 文件內部緩衝區
 6 # 寫入內容以後，f.flush()能夠將內存裏寫入的東西刷入到硬盤裏
 7 
 8 # read(1) 讀取內容
 9 
10 # readable() 判斷是否可讀
11 
12 # readline(1) 僅讀取一行內容，再次執行會從第一次指針停下來的位置繼續往下讀取
13 
14 # seek() 調整指針
15 
16 # truncate() 截取， 依賴於指針
17 
18 f = open("test.log", 'r', encoding='utf-8')
19 # f.read()
20 for line in f:
21     print(line)
22 # 效果同readline()，且比readline()更好用
23 
24 # 關閉文件 close()
25 # 每次文件讀寫都要close()，比較麻煩，能夠經過with語句來自動關閉
26 with open('test.log', 'r') as f:
27     f.read()
28 # 讀取數據時，上面代碼自動幫助close()文件
29 # python 2.7 及之後版本，能夠同時還打開兩個文件
30 with open('log1', 'r') as obj1, open('log2', 'r') as obj2:
31     pass
32 # 以讀方式打開源文件，同時打開新文件w，能夠一行一行讀取而後一行一行寫入新文件。大大節省了內存。
33 with open('源文件', 'r') as obj1, open('新文件', 'w') as obj2:
34     for line in obj1:
35         obj2.write(line)

文件關閉後不會保存指針，可是關閉前，文件讀到哪兒，指針就指到哪兒。 

若是須要記錄文件讀取的位置，咱們能夠將tell()指針位置先保存起來，下一次打開的時候seek()一下從新讀取