devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python对普通文件的操作_with open('tmp', 'rb') as f1: with open('1.zip', '

作者：知新_RL | 2024-07-09 16:49:33

赞

踩

with open('tmp', 'rb') as f1: with open('1.zip', 'wb') as f2: tmp = (f1.read

目录

1. 常用函数语法

1.1. open_打开文件

1.2. read_读取文件

1.3. readlines_读取文件

1.4. csv.reader_读取csv文件

1.5. write_写入内容

2. 操作普通文件

2.1. 读取内容

① 按大小读取

② 按行数读取

③ 按列数读取

④ 读取大文件

⑤ 条件过滤

2.2. 写入内容

① 覆盖原有内容

② 追加到原有内容

③ 修改内容

1. 常用函数语法

1.1. open_打开文件

语法

  1. open(
  2.     '文件路径',                  #必选参数
  3.     mode='模式',                 #可选参数，模式包含：r(读)、w(写)、a(追加)、x(创建)、b(二进制)、t(文本)，组合'rb'读取二进制文件(任意组合)
  4.     buffering=[缓冲大小]         #可选参数，单位字节，0表示不适用缓冲。读写二进制文件默认0，读写文本文件默认-1(系统自动决定)
  5.     encoding=[编码方式]          #可选参数，默认为系统默认编码。常用utf-8、gbk、gb2312
  6.     errors=[处理编码错误的方式]  #可选参数，默认为'strict'，即出现错误时抛出UnicodeError异常。常见的方式有'ignore'忽略错误，'replace' 用?来替换错误，'backslashreplace' 用反斜杠替换错误。
  7.     newline=控制文件中换行顺序   #可选参数，None、''、'\n'、'\r'、'\r\n'等
  8.     )
  • open的模式决定了后面函数的读写

 

1.2. read_读取文件

语法

  1.  [文件].read(
  2.     size       #可选参数，指定读取的字节数
  3.     encoding   #可选参数，指定文本编码(常见的 UTF-8、GBK)
  4.     errors     #可选参数，指定解码错误的处理方式(默认：strict)，ignore：忽略错误，replace：替换错误，或者其他自定义的错误方法。
  5.     newline    #可选参数，用于区分并读取带有不同换行符号的文件。Linux：\n，Windows：\r\n
  6. )

 

1.3. readlines_读取文件

语法

  1.  [文件].readlines(
  2.     size       #可选参数，指定读取的字节数
  3.     hint       #可选参数，指定读取的最大行数。当文件规模较大时，建议设置该参数，以减轻内存压力。
  4.     encoding   #可选参数，指定文本编码(常见的 UTF-8、GBK)
  5.     errors     #可选参数，指定解码错误的处理方式(默认：strict)，ignore：忽略错误，replace：替换错误，或者其他自定义的错误方法。
  6.     newline    #可选参数，用于区分并读取带有不同换行符号的文件。Linux：\n，Windows：\r\n
  7. )

 

1.4. csv.reader_读取csv文件

语法

  1. csv.reader(
  2.     '文件'                     #必选参数，指定open打开的文件
  3.     delimiter='[分隔符]'       #可选参数，默认逗号
  4.     skipinitialspace=[布尔值]  #可选参数，表示是否忽略分隔符后的空白，默认值为 False。
  5.     dialect='[CSV文件的方言]'  #可选参数，默认值为 excel。例如 csv.excel_tab。可以使用 csv.list_dialects() 获取全部方言信息。
  6.     quotechar='[字符串]'       #可选参数，当需要引用字段时使用的字符。默认值为 "
  7.     escapechar='\'             #可选参数，指定在字符串中非字面量字符前面的转义字符，默认值为没有指定。
  8.     doublequote=[布尔值]       #可选参数，表示是否将引用字符写为两个引用字符。默认值为 True。
  9.     strict=[布尔值]            #可选参数，默认False，当设置为 True 时，当读取的行中包含与方言不兼容的数据时，抛出 csv.Error 异常。
  10. )

 

1.5. write_写入内容

语法

  1.  [文件].write(
  2.     size       #可选参数，指定读取的字节数
  3.     encoding   #可选参数，指定文本编码(常见的 UTF-8、GBK)
  4.     errors     #可选参数，指定解码错误的处理方式(默认：strict)，ignore：忽略错误，replace：替换错误，或者其他自定义的错误方法。
  5.     newline    #可选参数，用于区分并读取带有不同换行符号的文件。Linux：\n，Windows：\r\n
  6. )

 

 

2. 操作普通文件

2.1. 读取内容

手动关闭文件方法

  1. # 打开一个名为file.txt的文件
  2. f = open("file.txt", "r")
  3.  
  4. # 读取文件
  5. print(f.read())
  6.  
  7. # 关闭文件
  8. f.close()

with 自动关闭文件

  1. # 打开一个名为file.txt的文件
  2. with open("file.txt", "r") as f:
  3.  
  4.     # 读取文件
  5.     print(f.read())
'
运行

 

① 按大小读取

读取10字节内容

  1. with open('/home/tmp.txt', mode='r', buffering=2048) as f:
  2.     # 指定读取10字节
  3.     print(f.read(10))

 

② 按行数读取

读取前10行内容

  1. with open('/home/tmp.txt', 'r') as f:
  2.     # 使用readlines切片读取前10行，赋值给某个变量
  3.     chunk = f.readlines()[:10]
  4.     # 遍历这个遍历
  5.     for i in chunk:
  6.         # 使用strip处理遍历的内容
  7.         print(i.strip())

读取文件11-20行内容

  1. with open('/home/tmp.txt', 'r') as f:
  2.     # 使用readlines切片读取后10行，赋值给某个变量
  3.     chunk = f.readlines()[10:20]
  4.     # 遍历这个遍历
  5.     for i in chunk:
  6.         # 使用strip处理遍历的内容
  7.         print(i.strip())

读取文件后10行内容 

  1. with open('/home/tmp.txt', 'r') as f:
  2.     # 使用readlines切片读取前10行，赋值给某个变量
  3.     chunk = f.readlines()[-10:]
  4.     # 遍历这个遍历
  5.     for i in chunk:
  6.         # 使用strip处理遍历的内容
  7.         print(i.strip())

切片会创建一个新列表，因此在处理非常大的文件时可能会导致内存问题。为了避免这种情况，可以使用逆向迭代器，以生成器的方式读取文件行。即使文件太大，也不会读取完整文件

  1. import os,itertools
  2.  
  3. # 定义一个反向迭代器函数
  4. def reverse_readline(filename, bufsize=8192):
  5.     with open(filename) as f:
  6.         # 将文件指针移到文件末尾
  7.         f.seek(0, os.SEEK_END)
  8.         # 获取文件大小
  9.         remaining_bytes = f.tell()
  10.         # 定位到文件末尾的最后一个完整行
  11.         f.seek(-min(bufsize, remaining_bytes), os.SEEK_CUR)
  12.         lines = []
  13.         # 逆序读取行
  14.         while remaining_bytes > 0:
  15.             # 读取缓存数据
  16.             read_size = min(bufsize, remaining_bytes)
  17.             data = f.read(read_size)
  18.             # 倒置数据并获取行
  19.             lines = data[::-1].splitlines(True) + lines
  20.             # 更新剩余字节数
  21.             remaining_bytes -= read_size
  22.             # 重新定位指针到当前位置的后面
  23.             f.seek(-read_size, os.SEEK_CUR)
  24.         # 迭代器
  25.         for line in lines:
  26.             yield line
  27.  
  28. # 调用逆向迭代器函数，获取文件的最后10行
  29. with open('tmp.txt', 'w') as f:
  30.     for i in range(100):
  31.         f.write('Line {}\n'.format(i))
  32. for line in itertools.islice(reverse_readline('tmp.txt'), 0, 10):
  33.     print(line.strip())

 

③ 按列数读取

指定分隔符读取某列（索引读取）

  1. import csv
  2.  
  3. path = '/home/yt/python/file.txt'
  4.  
  5. # 打开文件
  6. with open(path, newline='') as f:
  7.     # 使用csv模块读取文件，指定分隔符为 | (默认逗号)
  8.     readr = csv.reader(f, delimiter='|')
  9.     # 遍历文件内容
  10.     for i in readr:
  11.         #按索引取列(第2列)
  12.         print(i[1])

读取多列（索引读取）

  1. import csv
  2.  
  3. path = '/home/yt/python/file.txt'
  4.  
  5. with open(path, newline='') as f:
  6.     #默认分隔符为逗号
  7.     readr = csv.reader(f)
  8.     for i in readr:
  9.         # 按索引读取第2列和第3列
  10.         print(i[1:3])

   

④ 读取大文件

读取大文件（按指定大小循环读取，保证文件过大时不会大量使用内存） 

  1. with open('/home/tmp.txt', 'r') as f:
  2.     # 循环读取文件中的行
  3.     while True:
  4.         # 每行读取1024字节，赋值给一个变量(如果单行大小超过1024，那么只会截取1024部分)
  5.         chunk = f.read(1024)
  6.         # 如果读取为空，那么退出循环(空行不算)
  7.         if not chunk:
  8.             break
  9.         # 持续打印读取的行
  10.         print(chunk)

 

注意：不要用readlines！不要用readlines！不要用readlines！

举个例子

  1. l = []
  2. with open('/home/tmp.txt', 'r') as f:
  3.     for i in f.readlines():
  4.         l.append(i)
  • 这种方法去读取一个1GB的文件，会消耗7.4GB内存，且耗时19s。
  • 上面的循环方法内存使用仅500MB，耗时1.3s。

 

⑤ 条件过滤

使用readlines方法（只适用于读取小文件）

过滤条件（仅读取含 "abc" 的行）

  1. with open('/home/tmp.txt', 'r', buffering=8192) as f:
  2.     # 按行遍历内容
  3.     for i in f.readlines():
  4.         # 判断该行包含字符串 'abc'
  5.         if 'abc' in i:
  6.             print(i.strip())

过滤条件（读取不包含 "abc" 的行）

  1. with open('/home/tmp.txt', 'r', buffering=8192) as f:
  2.     # 按行遍历内容
  3.     for i in f.readlines():
  4.         # 判断该行不包含字符串 'abc'
  5.         if 'abc' not in i:
  6.             print(i.strip())

 

循环方法（适用于读取大文件）

  1. with open('/home/tmp.txt', 'r') as f:
  2.     # 按行遍历内容
  3.     while True:
  4.         # 每行最大输出1024字节
  5.         chunk = f.read(1024)
  6.         if not chunk:
  7.             break
  8.         if 'abc' in chunk:
  9.             print(chunk)

 

   

2.2. 写入内容

手动关闭文件的方法（覆盖原有文件内容）

  1. # 打开一个名为file.txt的文件，如果该文件不存在，则自动新建一个文件
  2. f = open("file.txt", "w")
  3.  
  4. # 写入内容到文件
  5. f.write("ha ha ha")
  6.  
  7. # 关闭文件
  8. f.close()
'
运行

自动关闭文件的方法（覆盖原有文件内容）

  1. # 打开一个名为file.txt的文件，如果该文件不存在，则自动新建一个文件
  2. with open("file.txt", "w") as f:
  3.  
  4.     # 写入内容到文件
  5.     f.write("ha ha ha")
'
运行

 

① 覆盖原有内容

将手动编写的字符串覆盖到文件

  1. # 打开一个名为file.txt的文件，如果该文件不存在，则自动新建一个文件
  2. with open("file.txt", "w") as f:
  3.  
  4.     # 写入内容到文件
  5.     f.write("ha ha ha")
'
运行

 

将文件1的内容拷贝到文件2（覆盖）

  1. import shutil
  2. # 使用shutil模块，将文件1拷贝到文件2
  3. shutil.copyfile('file1.txt', 'file2.txt')

 

将文件1的前10行写入文件2

  1. read_file = '/home/file1.txt'
  2. write_file = '/home/file2.txt'
  3.  
  4.      #读取文件(指定路径，使用r)         写入文件(指定路径，使用w)
  5. with open(read_file, 'r') as f_read, open(write_file, 'w') as f_write:
  6.     # 遍历前10行
  7.     for i in f_read.readlines()[:10]:
  8.         #将每行的内容写入指定的文件
  9.         f_write.write(i.strip())

 

将文件1包含字符串 "abc" 的行写入文件2

  1. read_file = '/home/file1.txt'
  2. write_file = '/home/file2.txt'
  3.  
  4.      #读取文件(指定路径，使用r)         写入文件(指定路径，使用w)
  5. with open(read_file, 'r') as f_read, open(write_file, 'w') as f_write:
  6.     #循环读取文件
  7.     while True:
  8.         #每次读取1024字节，减少内存使用
  9.         chunk = f_read.read(1024)
  10.         #如果读完内容，则退出循环
  11.         if not chunk:
  12.             break
  13.         #将内容包含 'abc' 的行写入另一个文件
  14.         if 'abc' in chunk:
  15.             f_write.write(i)

 

将文件中包含 "abc" 的行读取出来，重新覆盖给文件本身

  1. file_path = '/home/tmp.txt'
  2.  
  3. # 打开文件，并读取所有行
  4. with open(file_path, 'r') as f:
  5.     lines = f.readlines()
  6.  
  7. # 遍历符合条件的行
  8. filtered_lines = [i for i in lines if 'abc' in i]
  9.  
  10. # 将过滤后的行覆盖到原始文件
  11. with open(file_path, 'w') as f:
  12.     f.writelines(filtered_lines)

 

② 追加到原有内容

追加自定义内容到文件

  1. # 文件路径
  2. path = '/home/yt/python/file.txt'
  3. # 输入的内容
  4. desc = 'abc\nedf\n123'
  5.  
  6. # 打开文件，a表示追加
  7. with open(path, 'a') as f:
  8.     # 将内容追加到文件
  9.     f.write(desc)

 

将文件1的内容追加到文件2

  1. # 打开需要读取的文件
  2. with open('/home/tmp2.txt', 'r') as f1:
  3.     # 打开需要追加的文件
  4.     with open('/home/tmp2.txt', 'a') as f2:
  5.         # 将f1的内容追加到f2(如果f2不存在，则自动创建并追加)
  6.         f2.write(f1.read())

 

将文件1包含 "abc" 的部分内容追加到文件2

  1. # 打开需要读取的文件
  2. with open('/home/tmp1.txt', 'r') as f1:
  3.     # 打开需要追加的文件
  4.     with open('/home/tmp2.txt', 'a') as f2:
  5.         # 遍历读取的文件内容
  6.         for i in f1:
  7.             # 将符合条件的行追加到另一个文件
  8.             if 'abc' in i:
  9.                 f2.write(i)

 

③ 修改内容

将文件内容读取出来再替换字符，最后重新覆盖到文件本身

  1. # 打开文件
  2. with open(path, 'r') as f:
  3.     # 将读取的内容赋值给变量
  4.     file_content = f.read()
  5.  
  6. # 使用replace将变量中 AAA 替换为 BBB
  7. file_content = file_content.replace('AAA', 'BBB')
  8.  
  9. # 再将已替换的变量覆盖给文件
  10. with open(path, 'w') as f:
  11.     f.write(file_content)

如果让被替换的内容不区分大小写，使用re正则

  1. import re
  2.  
  3. # 打开文件
  4. with open(path, 'r') as f:
  5.     # 将读取的内容赋值给变量
  6.     file_content = f.read()
  7.  
  8. # 使用正则将变量中 AAA(不区分大小写) 替换为 BBB
  9. file_content = re.sub(r'AAA', 'BBB', file_content, flags=re.IGNORECASE)
  10.  
  11. # 再将已替换的变量覆盖给文件
  12. with open(path, 'w') as f:
  13.     f.write(file_content)

替换大文件使用逐块读取和写入的方式可以避免使用过多内存

  1. import os, shutil
  2.  
  3. # 操作的文件
  4. path = '/home/yt/python/file.txt'
  5.  
  6. # 临时文件(将替换好的行先放入临时文件)
  7. tmp = '/home/yt/python/tmp.txt'
  8. # 创建这个临时文件
  9. os.mknod(tmp)
  10.  
  11. # 打开需要操作的文件
  12. with open(path, 'rb') as f1:
  13.     # 打开临时文件，准备写入已替换的内容
  14.     with open(tmp, 'wb') as f2:
  15.         # 遍历文件内容
  16.         while True:
  17.             # 指定每次读取大小(单位：字节)
  18.             chunk = f1.read(8192)
  19.             # 如果内容已读完，那么退出循环
  20.             if not chunk:
  21.                 break
  22.             # 将读取的内容进行替换
  23.             chunk = chunk.replace('aaa'.encode('UTF-8'), 'bbb'.encode('UTF-8'))
  24.             # 写入临时文件
  25.             f2.write(chunk)
  26.  
  27. # 将临时文件的内容覆盖到操作文件
  28. shutil.copyfile(tmp, path)
  29.  
  30. # 删除临时文件
  31. os.remove(tmp)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/803045
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号