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

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 #Author:sking
  4 #Python3文件操作详解  Python3文件操作大全
  5 
  6 """
  7 test_file.txt
  8 文件内容如下：
  9 打印字符串第一个字符
 10 
 11 打印字符串第二个字符
 12 """
 13 #打开文件test_file.txt
 14 f = open(‘test_file.txt‘, ‘r+‘) #f是文件的文件句柄，它是在内存中的，是内存中的一个对象
 15 data = f.read()
 16 print(data)
 17 """
 18 data结果：
 19 打印字符串第一个字符
 20 
 21 打印字符串第二个字符
 22 """
 23 data2 = f.read() #再读一次文件
 24 print("data2=", data2) #data2=
 25 # 此时的结果是data2= ，也就是此时读取的data2为空，为什么？
 26 # 因为第一次data读的时候文件光标是从头开始一直读到最后的，再次读的时候，
 27 # 是从此时光标所在的位置（此时光标在最后面）开始读取，因为光标已经在最后了，
 28 # 后面已经没有任何内容了，当然data2就读不出来数据了
 29 # 可以用seek重新定位光标的位置
 30 f.seek(0) #将光标定位到文件的开始位置
 31 data3 = f.read()
 32 print(data3)
 33 """
 34 data3结果：
 35 打印字符串第一个字符
 36 
 37 打印字符串第二个字符
 38 """
 39 #写文件write
 40 #f = open(‘test_file.txt‘, ‘w‘)  #如果是‘w‘写的模式的时候，系统会自动创建一个这个名字的文件，
 41 # 如果该目录下有这个名字的文件，系统会直接覆盖掉原来的文件，原来的文件及内容就不存在了，所以这点一定要注意。
 42 #f.write(‘\n\n写入字符串第三个字符‘)
 43 f.seek(0) #seekable()判断文件内容是否可以进行seek操作，因为有些文件是不可以进行seek的
 44 data4 = f.read()
 45 print(data4)
 46 f.close()
 47 """
 48 打印字符串第一个字符
 49 
 50 打印字符串第二个字符
 51 
 52 写入字符串第三个字符
 53 """
 54 #向文件追加内容
 55 f = open(‘test_file.txt‘, ‘a‘) #‘a‘是append  追加，但是不能读取文件
 56 f.write(‘\n\nhaha‘)
 57 print(f.readable()) #False  判断文件是否可读
 58 f.close()
 59 #读取一行内容
 60 f = open(‘test_file.txt‘, ‘r‘)
 61 data = f.readline()
 62 print(data) # 打印字符串第一个字符
 63 #读取多行
 64 data2 = f.readlines()
 65 print(data2)
 66 
 67 
 68 #读取到第3行
 69 for index, line in enumerate(f.readlines()):  #仅适合读取小文件
 70     print(line.strip())
 71     if index == 2:
 72         break;
 73 f.close()
 74 #读取大文件（推荐使用）
 75 f = open(‘test_file.txt‘, ‘r‘)
 76 for line in f:  #这样写的效果就是逐行读取文件中的内容，并且内存中始终仅保存读取的这一行内容 此时的f是一个迭代器
 77     print(line)
 78 f.close()
 79 #查看文件游标所在的位置
 80 f = open(‘test_file.txt‘, ‘r‘)
 81 print(f.tell()) #0
 82 print(f.read(5))
 83 print(f.tell()) #10 因为一个汉字占2个字节，所以这里显示的是10
 84 f.close()
 85 f2 = open(‘test_file2.txt‘, ‘r‘)
 86 print(f2.tell()) #0
 87 print(f2.read(5))
 88 print(f2.tell()) #5 因为一个英文占1个字节，所以这里显示的是5
 89 f2.close()
 90 
 91 
 92 f = open(‘test_file.txt‘, ‘r‘)
 93 print(f.encoding)  #cp936 #查看文件编码
 94 print(f.name) # test_file.txt 查看文件名
 95 
 96 f.close()
 97 #实时存储数据
 98 f.write("sdfadf")  #因为代码执行的过程中并不是出现依据写到硬盘的代码就立马开始向硬盘存储。
 99 #系统有一个阀门限制，系统会在内存中开辟一块用来临时存储的区域，当临时存储区域的数据达到一定值时，才会从内存存到硬盘上。
100 #所以并不是执行一行写的代码后，硬盘就一定已经保存了该结果，很可能该结果还没有被保存。
101 f.flush()
102 print(f.flush()) #None
103 
104 
105 
106 
107 """
108 一、文件操作
109 1.文件处理的流程
110  
111 
112 1）打开文件，得到文件句柄并赋值给一个变量
113 
114 2）通过句柄对文件进行操作
115 
116 3）关闭文件
117 
118 例如：
119 
120 f = open(‘chenli.txt‘) #打开文件
121 first_line = f.readline()
122 print(‘first line:‘,first_line) #读一行
123 data = f.read()# 读取剩下的所有内容,文件大时不要用
124 print(data) #打印读取内容
125 f.close() #关闭文件
126  
127 
128 2.文件操作基本用法
129 1）基本用法：
130 
131 file_object = open(file_name, access_mode = ‘r’, buffering = -1)
132 
133 open函数有很多的参数，常用的是file_name，mode和encoding
134 
135 file_name:打开的文件名,若非当前路径，需指出具体路径
136 access_mode文件打开模式
137 buffering的可取值有0，1，>1三个，0代表buffer关闭（只适用于二进制模式），1代表line buffer（只适用于文本模式），>1表示初始化的buffer大小； 
138 encoding表示的是返回的数据采用何种编码，一般采用utf8或者gbk；
139  
140 
141  
142 
143 2)文件打开模式
144 
145 r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
146 w，只写模式【不可读；不存在则创建；存在则清空内容】
147 x， 只写模式【不可读；不存在则创建，存在则报错】
148 a， 追加模式【不可读文件，不存在则创建；存在则只追加内容】，文件指针自动移到文件尾。
149 "+" 表示可以同时读写某个文件
150 
151 r+， 读写【可读，可写】
152 w+，写读【可读，可写】，消除文件内容，然后以读写方式打开文件。
153 x+ ，写读【可读，可写】
154 a+， 写读【可读，可写】，以读写方式打开文件，并把文件指针移到文件尾。
155  "b"表示以字节的方式操作，以二进制模式打开文件，而不是以文本模式。
156 
157  
158 
159 rb  或 r+b
160 wb 或 w+b
161 xb 或 w+b
162 ab 或 a+b
163  注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码
164 
165  
166 
167 3）以读r的方式打开文件
168 
169  
170 
171 #!/usr/bin/env python
172 # -*- coding:utf-8 -*-
173 f=open(‘1.txt‘,encoding=‘utf-8‘,mode=‘r‘)
174 print(f)
175 data1=f.read()
176 print(data1)
177  
178 
179 1.txt
180 
181 55542342
182 123
183 输出：
184 
185 <_io.TextIOWrapper name=‘1.txt‘ mode=‘r‘ encoding=‘utf-8‘>
186 55542342
187 123
188  
189 
190 补充：
191 
192 复制代码
193 1）python中有三个方法来处理文件内容的读取：
194 read() #一次读取全部的文件内容。返回字符串
195 
196 readline() #每次读取文件的一行。
197 
198 readlines() #读取文件的所有行，返回一个字符串列表。
199 
200 2）print(f.readable())    #判断文件是否是r模式打开的
201 
202 3）print(f.closed) 　　　#判断文件是否是关闭状态
203 
204 4）python中在文本文件内容移动的操作
205 file.seek(offset,whence=0)     #从文件中给移动指针，从whence(0起始，1当前，2末尾)偏移offset个字节，正往结束方向移动，负往开始方向移动
206 file.tell() 　　　　　　　　　#返回当前文件中的位置。获得文件指针位置
207 
208 5） file.truncate(size=file.tell())    #截取文件到最大size个字节，默认为当前文件位置
209 复制代码
210 4）以w方式写入文件
211 
212 复制代码
213 f=open(‘a.txt‘,‘w‘,encoding=‘utf-8‘)
214 # f=open(‘b.txt‘,‘r‘,encoding=‘utf-8‘) #以读的方式打开文件，文件不存在则报错
215 f=open(‘b.txt‘,‘w‘,encoding=‘utf-8‘)
216 # print(f.writable())
217 
218 f.write(‘111111\n22222222‘)
219 f.seek(0)
220 f.write(‘\n333333\n444444‘)
221 
222 f.writelines([‘\n55555\n‘,‘6666\n‘,‘77777\n‘])
223 f.close()
224 复制代码
225 a.txt 为空
226 
227 b.txt
228 
229 333333
230 444444
231 55555
232 6666
233 77777
234  
235 
236 补充：
237 
238 file.write(str)     #向文件中写入字符串(文本或二进制)
239 file.writelines(seq)    #写入多行，向文件中写入一个字符串列表，注意，要自己加入每行的换行符
240 file.flush()    #刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入.
241  
242 
243 5）文件修改
244 
245 复制代码
246 #!/usr/bin/env python
247 # -*- coding:utf-8 -*-
248 import os
249 read_f=open(‘b.txt‘,‘r‘)
250 write_f=open(‘.b.txt.swap‘,‘w‘)
251 for line in read_f.readlines():
252     if line.startswith(‘1111‘):
253         line=‘2222222222\n‘
254     write_f.write(line)
255 read_f.close()
256 write_f.close()
257 os.remove(‘b.txt‘)
258 os.rename(‘.b.txt.swap‘,‘b.txt‘)
259 复制代码
260  
261 
262 3.上下文管理with语句
263 当你做文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。
264 
265 正常情况下，代码如下：
266 
267 file = open("/tmp/foo.txt")
268 data = file.read()
269 file.close()
270 这里有两个问题。一是可能忘记关闭文件句柄；二是文件读取数据发生异常，没有进行任何处理。
271 
272 然而with可以很好的处理上下文环境产生的异常。下面是with版本的代码：
273 
274 with open("/tmp /foo.txt") as file:
275     data = file.read()
276 with的基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。
277 
278  
279 
280 补充：
281 
282 模拟   tail -f access.log
283 
284 复制代码
285 #!/usr/bin/env python
286 # -*- coding:utf-8 -*-
287 
288 # tail -f access.log
289 import time
290 with open(‘access.log‘,‘r‘,encoding=‘utf-8‘) as f:
291     f.seek(0,2)
292     while True:
293         line=f.readline().strip()
294         if line:
295             print(‘新增一行日志‘,line)
296         time.sleep(0.5)
297 复制代码
298 
299 
300 """
301 """
302 read(),readline(),readlines()的区别
303 
304 假设a.txt的内容如下所示：
305 123 
306 Hello
307 Welcome
308 What is the fuck... 
309 
310 一、read([size])方法
311  
312 read([size])方法从文件当前位置起读取size个字节，若无参数size，
313 则表示读取至文件结束为止，它范围为字符串对象
314 f = open("a.txt")
315 lines = f.read()
316 print(lines)
317 print(type(lines))
318 f.close() 
319 
320 输出结果：
321 Hello
322 Welcome
323 What is the fuck...
324 <type ‘str‘> #字符串类型 
325 
326 二、readline()方法
327  
328 从字面意思可以看出，该方法每次读出一行内容，所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。
329  
330 f = open("a.txt")
331 line = f.readline()
332 print(type(line))
333 while line: 
334     print line, 
335     line = f.readline()
336 f.close() 
337 
338 输出结果：
339 
340 <type ‘str‘>
341 Hello
342 Welcome
343 What is the fuck... 
344 
345 三、readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。
346  
347 f = open("a.txt")
348 lines = f.readlines()
349 print(type(lines))
350 for line in lines: 
351     print (line)
352     f.close() 
353 
354 输出结果：
355 <type ‘list‘>
356 Hello
357 Welcome
358 What is the fuck... 
359 
360 四、linecache模块
361  
362 当然，有特殊需求还可以用linecache模块，比如你要输出某个文件的第n行：
363  
364 # 输出第2行
365 text = linecache.getline(‘a.txt‘,2)
366 print text, 
367 
368 对于大文件效率还可以。
369 """