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

目录

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_打开文件

语法

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

• open的模式决定了后面函数的读写

 

1.2. read_读取文件

语法

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

 

1.3. readlines_读取文件

语法

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

 

1.4. csv.reader_读取csv文件

语法

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

 

1.5. write_写入内容

语法

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

 

 

2. 操作普通文件

2.1. 读取内容

手动关闭文件方法

# 打开一个名为file.txt的文件
f = open("file.txt", "r")
 
# 读取文件
print(f.read())
 
# 关闭文件
f.close()

with 自动关闭文件

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

 

① 按大小读取

读取10字节内容

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

 

② 按行数读取

读取前10行内容

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

读取文件11-20行内容

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

读取文件后10行内容 

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

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

import os,itertools
 
# 定义一个反向迭代器函数
def reverse_readline(filename, bufsize=8192):
    with open(filename) as f:
        # 将文件指针移到文件末尾
        f.seek(0, os.SEEK_END)
        # 获取文件大小
        remaining_bytes = f.tell()
        # 定位到文件末尾的最后一个完整行
        f.seek(-min(bufsize, remaining_bytes), os.SEEK_CUR)
        lines = []
        # 逆序读取行
        while remaining_bytes > 0:
            # 读取缓存数据
            read_size = min(bufsize, remaining_bytes)
            data = f.read(read_size)
            # 倒置数据并获取行
            lines = data[::-1].splitlines(True) + lines
            # 更新剩余字节数
            remaining_bytes -= read_size
            # 重新定位指针到当前位置的后面
            f.seek(-read_size, os.SEEK_CUR)
        # 迭代器
        for line in lines:
            yield line
 
# 调用逆向迭代器函数，获取文件的最后10行
with open('tmp.txt', 'w') as f:
    for i in range(100):
        f.write('Line {}\n'.format(i))
for line in itertools.islice(reverse_readline('tmp.txt'), 0, 10):
    print(line.strip())

 

③ 按列数读取

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

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

读取多列（索引读取）

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

   

④ 读取大文件

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

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

 

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

举个例子

l = []
with open('/home/tmp.txt', 'r') as f:
    for i in f.readlines():
        l.append(i)

• 这种方法去读取一个1GB的文件，会消耗7.4GB内存，且耗时19s。
• 上面的循环方法内存使用仅500MB，耗时1.3s。

 

⑤ 条件过滤

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

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

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

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

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

 

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

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

 

   

2.2. 写入内容

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

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

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

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

 

① 覆盖原有内容

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

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

 

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

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

 

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

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

 

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

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

 

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

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

 

② 追加到原有内容

追加自定义内容到文件

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

 

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

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

 

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

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

 

③ 修改内容

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

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

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

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

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

import os, shutil
 
# 操作的文件
path = '/home/yt/python/file.txt'
 
# 临时文件(将替换好的行先放入临时文件)
tmp = '/home/yt/python/tmp.txt'
# 创建这个临时文件
os.mknod(tmp)
 
# 打开需要操作的文件
with open(path, 'rb') as f1:
    # 打开临时文件，准备写入已替换的内容
    with open(tmp, 'wb') as f2:
        # 遍历文件内容
        while True:
            # 指定每次读取大小(单位：字节)
            chunk = f1.read(8192)
            # 如果内容已读完，那么退出循环
            if not chunk:
                break
            # 将读取的内容进行替换
            chunk = chunk.replace('aaa'.encode('UTF-8'), 'bbb'.encode('UTF-8'))
            # 写入临时文件
            f2.write(chunk)
 
# 将临时文件的内容覆盖到操作文件
shutil.copyfile(tmp, path)
 
# 删除临时文件
os.remove(tmp)