Python文件读写教程及操作详解

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《Python文件读写详解及操作教程》，文章讲解的知识点主要包括，如果你对文章方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

Python文件读写核心是使用open()函数打开文件，通过read()、write()等方法操作内容，并用with语句确保文件安全关闭。

Python中文件读写，核心在于使用内置的open()函数来打开文件，然后根据你想要进行的操作（读取、写入或追加）选择合适的模式。之后，通过文件对象提供的各种方法（如read(), write(), readline()等）来处理数据。完成操作后，务必关闭文件以释放资源，最推荐的方式是使用with语句，它能自动处理文件的关闭，即使发生错误也不例外。

解决方案

在Python里处理文件，说白了就是和操作系统打交道，告诉它：“嘿，我想对这个文件做点什么。” 这其中涉及到几个关键点：打开文件、操作文件内容、最后关闭文件。我个人经验是，理解这三步，文件操作基本就稳了。

1. 打开文件：open()函数

这是所有文件操作的起点。open()函数需要至少两个参数：文件路径和打开模式。

# 示例：打开一个文件
file_object = open('my_document.txt', 'r', encoding='utf-8')

这里，'my_document.txt'是文件名，'r'是模式，表示只读。encoding='utf-8'这一点我必须强调，尤其是在处理中文或跨平台文件时，它能帮你省去无数编码错误带来的烦恼。我见过太多新手因为编码问题抓狂，所以养成指定编码的习惯非常重要。

常见的打开模式有：

• 'r' (read): 只读模式，文件必须存在。
• 'w' (write): 写入模式，如果文件不存在则创建，如果存在则清空内容再写入。注意：这会覆盖原有内容！
• 'a' (append): 追加模式，如果文件不存在则创建，如果存在则在文件末尾追加内容。
• 'x' (exclusive creation): 独占创建模式，如果文件已存在则会引发FileExistsError。
• 'b' (binary): 二进制模式，与'r', 'w', 'a'等结合使用，如'rb', 'wb'，用于处理非文本文件（图片、音频等）。
• '+' (update): 更新模式，与'r', 'w', 'a'等结合使用，如'r+'（读写，文件指针在开头），'w+'（写读，清空文件），'a+'（追加读写，文件指针在末尾）。

2. 操作文件内容

一旦文件被打开，你就可以通过返回的文件对象进行读写操作了。

读取文件：

• read(size=-1): 读取文件所有内容作为一个字符串。如果指定size，则读取指定字节数。

  with open('example.txt', 'r', encoding='utf-8') as f:
      content = f.read()
      print("所有内容：", content)

  这里我直接用了with语句，因为它太好用了，后面会详细说。

• readline(size=-1): 读取文件的一行内容。

  with open('example.txt', 'r', encoding='utf-8') as f:
      first_line = f.readline()
      print("第一行：", first_line.strip()) # strip() 去掉末尾的换行符

• readlines(): 读取所有行并返回一个字符串列表，每个元素就是一行内容（包含换行符）。

  with open('example.txt', 'r', encoding='utf-8') as f:
      lines = f.readlines()
      print("所有行列表：", lines)

• 迭代文件对象： 这是处理大文件时我最推荐的方式，因为它一行一行地读取，不会一次性加载所有内容到内存，非常高效。

  with open('example.txt', 'r', encoding='utf-8') as f:
      for line in f:
          print("逐行读取：", line.strip())

写入文件：

• write(string): 写入一个字符串到文件。注意：它不会自动添加换行符，你需要手动添加\n。

  with open('output.txt', 'w', encoding='utf-8') as f:
      f.write("这是第一行内容。\n")
      f.write("这是第二行内容。\n")

• writelines(list_of_strings): 写入一个字符串列表到文件。同样，它不会自动添加换行符，列表中的每个字符串需要自己包含换行符。

  lines_to_write = ["苹果\n", "香蕉\n", "橙子\n"]
  with open('fruits.txt', 'w', encoding='utf-8') as f:
      f.writelines(lines_to_write)

3. 关闭文件：close()方法与with语句

文件操作完成后，必须调用file_object.close()来关闭文件，释放系统资源。忘记关闭文件可能导致数据丢失、文件损坏或资源泄露。

然而，更优雅、更安全的方式是使用with语句（上下文管理器）：

with open('my_file.txt', 'r', encoding='utf-8') as f:
    # 在这里进行文件操作
    content = f.read()
    print(content)
# 文件在with代码块结束后会自动关闭，即使发生异常

with语句的魔力在于，无论代码块内部是否发生异常，它都能确保文件被正确关闭。这避免了手动try...finally的繁琐，大大简化了代码，也降低了出错的概率。我个人在所有文件操作中都坚持使用with，因为它简直是Python文件处理的“最佳实践”。

Python文件读写时，常见的编码问题及如何避免？

我敢说，任何一个稍微深入一点的Python开发者，都或多或少被编码问题“坑”过。这玩意儿就像个隐形的地雷，平时没事，一遇到特定场景（比如跨平台、处理老旧数据），“砰”的一声就炸了。所以，理解并解决编码问题，绝对是文件读写中的一个关键技能点。

编码问题的根源：

• 默认编码差异： 不同的操作系统（Windows、Linux、macOS）或Python版本可能使用不同的默认编码。比如，Windows系统默认编码可能是GBK（或CP936），而Linux和macOS通常是UTF-8。当你在一个系统上用默认编码写入文件，到另一个系统上用其默认编码读取时，就可能出现乱码。
• 文件本身的编码： 文件在创建时就有了特定的编码。如果用错误的编码去解读，那结果肯定是一堆“天书”。

如何避免和解决：

1. 始终明确指定编码： 这是最重要的原则，没有之一。在open()函数中，明确使用encoding参数。

   # 写入文件时，明确指定UTF-8
   with open('output_utf8.txt', 'w', encoding='utf-8') as f:
       f.write("你好，世界！")
   
   # 读取文件时，也明确指定UTF-8
   with open('output_utf8.txt', 'r', encoding='utf-8') as f:
       content = f.read()
       print(content)

   对于大多数现代应用，utf-8是最佳选择，因为它支持几乎所有语言字符，并且是互联网上的主流编码。

2. 处理未知编码或错误字符：errors参数 有时候你可能不知道文件的确切编码，或者文件中混入了无法解码的字符。这时，open()函数的errors参数就派上用场了。

   # 假设文件可能包含无法用UTF-8解码的字符
   try:
       with open('mystery_file.txt', 'r', encoding='utf-8') as f:
           content = f.read()
           print(content)
   except UnicodeDecodeError:
       print("尝试UTF-8解码失败，尝试其他编码或忽略错误。")
       # 尝试忽略错误字符
       with open('mystery_file.txt', 'r', encoding='utf-8', errors='ignore') as f:
           content_ignored = f.read()
           print("忽略错误后内容：", content_ignored)
       # 或者替换错误字符
       with open('mystery_file.txt', 'r', encoding='utf-8', errors='replace') as f:
           content_replaced = f.read()
           print("替换错误后内容：", content_replaced)
       # 甚至可以尝试其他可能的编码，比如GBK
       try:
           with open('mystery_file.txt', 'r', encoding='gbk') as f:
               content_gbk = f.read()
               print("尝试GBK解码后内容：", content_gbk)
       except UnicodeDecodeError:
           print("GBK解码也失败了...")

   errors参数的常用值：

   • 'strict' (默认): 遇到编码错误时抛出UnicodeDecodeError。
   • 'ignore': 忽略无法编码/解码的字符。
   • 'replace': 用一个特殊的替换字符（通常是U+FFFD，�）替换无法编码/解码的字符。
   • 'backslashreplace': 用Python的反斜杠转义序列替换无法编码/解码的字符。

3. 统一编码标准： 如果你的项目涉及到多个文件或多个系统，最好内部约定一个统一的编码标准（强烈推荐UTF-8），并确保所有文件操作都遵循这个标准。这能从根本上减少编码问题的发生。

处理大文件时，Python文件读写有哪些高效策略？

处理大文件，比如几个GB甚至几十GB的日志文件、数据集，如果还像读小文件那样一股脑儿read()或readlines()，那内存肯定扛不住，程序分分钟崩溃。我的经验是，面对大文件，核心思想就是“化整为零，分而治之”，避免一次性将所有内容加载到内存。

1. 逐行迭代（最常用且高效）：

这是我处理文本大文件时的首选方法。Python的文件对象本身就是迭代器，这意味着你可以直接在for循环中使用它，它会一行一行地读取文件，每次只加载一行到内存。

def process_large_text_file_line_by_line(filepath):
    line_count = 0
    with open(filepath, 'r', encoding='utf-8') as f:
        for line in f:
            # 在这里处理每一行数据
            # 比如，解析CSV行、筛选特定内容等
            if "error" in line.lower():
                print(f"发现错误日志：{line.strip()}")
            line_count += 1
            # 为了演示，我们只处理前100行
            if line_count > 10000: # 假设文件很大，我们只看前10000行
                break
    print(f"总共处理了 {line_count} 行。")

# 假设有一个名为 'large_log.txt' 的大文件
# process_large_text_file_line_by_line('large_log.txt')

这种方法内存占用极低，非常适合处理日志文件、大型文本数据集等。

2. 分块读取（read(size)）：

当文件不是纯文本，或者你需要按固定大小的块来处理数据时（例如，处理二进制文件、自定义协议的数据包），read(size)方法就非常有用。它会读取指定字节数的数据。

def process_large_binary_file_in_chunks(filepath, chunk_size=4096): # 默认4KB一块
    total_bytes_processed = 0
    with open(filepath, 'rb') as f: # 注意是二进制模式 'rb'
        while True:
            chunk = f.read(chunk_size)
            if not chunk: # 读取到文件末尾
                break
            # 在这里处理读取到的数据块
            # 比如，计算哈希值、查找特定字节序列、传输数据等
            # print(f"读取到 {len(chunk)} 字节的数据块。")
            total_bytes_processed += len(chunk)
            # 假设我们只处理前1MB
            if total_bytes_processed > 1024 * 1024:
                print("已处理超过1MB数据，停止。")
                break
    print(f"总共处理了 {total_bytes_processed} 字节。")

# 假设有一个名为 'large_image.bin' 的大二进制文件
# process_large_binary_file_in_chunks('large_image.bin')

这种方式同样可以有效控制内存使用，因为它每次只加载一小部分数据。

3. 内存映射文件（mmap模块）：

对于某些高级场景，特别是你需要对大文件进行随机访问或者需要像操作内存一样操作文件时，Python的mmap模块提供了一个非常强大的解决方案。它允许你将文件的一部分或全部映射到进程的虚拟内存空间，这样你就可以像访问普通内存数组一样访问文件内容，而操作系统会负责按需加载文件数据。

import mmap
import os

def search_in_large_file_with_mmap(filepath, search_term_bytes):
    if not os.path.exists(filepath):
        print(f"文件不存在: {filepath}")
        return False

    with open(filepath, 'r+b') as f: # 注意 'r+b' 模式
        # 使用mmap创建内存映射
        # mmap.ACCESS_READ 表示只读访问
        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
            # 现在可以像操作字节串一样操作mm对象
            # 比如，查找一个字节序列
            index = mm.find(search_term_bytes)
            if index != -1:
                print(f"找到 '{search_term_bytes.decode()}' 在文件中的偏移量: {index}")
                # 还可以读取特定位置的数据
                # print(mm[index:index + len(search_term_bytes) + 20].decode())
                return True
            else:
                print(f"未找到 '{search_term_bytes.decode()}'")
                return False

# 创建一个示例大文件（如果不存在）
# with open('test_mmap_large_file.txt', 'w', encoding='utf-8') as f:
#     for i in range(100000):
#         f.write(f"Line {i}: This is some content for line {i}.\n")
#     f.write("Here is the secret phrase I am looking for.\n")
#     for i in range(100000, 200000):
#         f.write(f"Line {i}: More content.\n")

# search_in_large_file_with_mmap('test_mmap_large_file.txt', b'secret phrase')

mmap在处理非常大的文件，并且需要高效随机访问时表现出色，但它更底层，使用起来也相对复杂一些，需要对内存管理有一定的理解。通常情况下，逐行迭代或分块读取已经能满足绝大多数需求了。

Python中如何安全地处理文件路径，避免跨平台兼容性问题？

文件路径，这个看似简单的小东西，在不同操作系统上却能带来不少麻烦。Windows习惯用反斜杠\，而Linux和macOS则用正斜杠/。如果你硬编码路径，比如'C:\Users\Documents\file.txt'，那这段代码在Linux上跑起来肯定会报错。为了避免这种恼人的跨平台路径问题，Python提供了两个非常实用的模块：os.path和pathlib。我个人觉得，pathlib是更现代、更优雅的选择，但os.path在很多老项目中依然常见。

1. 使用 os.path 模块（传统方式）：

os.path模块提供了一系列函数来处理文件路径，它们会自动根据当前操作系统调整路径分隔符。

• *`os.path.join(paths)`：** 这是最常用的函数，用于将多个路径组件智能地连接起来。它会自动使用正确的路径分隔符。

  import os
  
  # 硬编码路径分隔符的错误示范
  # windows_path = 'C:\\Users\\user\\Documents\\report.txt'
  # linux_path = '/home/user/documents/report.txt'
  
  # 使用 os.path.join
  base_dir = 'my_project'
  sub_dir = 'data'
  file_name = 'config.json'
  
  full_path = os.path.join(base_dir, sub_dir, file_name)
  print(f"拼接后的路径: {full_path}")
  # 在Windows上可能输出: my_project\data\config.json
  # 在Linux上可能输出: my_project/data/config.json

  无论在哪个系统上运行，os.path.join()都能生成符合该系统规范的路径。

• os.path.abspath(path)： 获取路径的绝对路径。

  relative_path = 'temp/my_file.txt'
  abs_path = os.path.abspath(relative_path)
  print(f"绝对路径: {abs_path}")

• os.path.dirname(path)： 获取路径的目录部分。

  path_with_file = '/home/user/documents/report.txt'
  directory = os.path.dirname(path_with_file)
  print(f"目录部分: {directory}") # 输出: /home/user/documents

• os.path.basename(path)： 获取路径的文件名部分。

  path_with_file = '/home/user/documents/report.txt'
  filename = os.path.basename(path_with_file)
  print(f"文件名部分: {filename}") # 输出: report.txt

2. 使用 pathlib 模块（Python 3.4+ 推荐）：

pathlib模块提供了一种面向对象的方式来处理文件系统路径，它让路径操作更加直观和优雅。我个人觉得，一旦你习惯了pathlib，就很难再回到os.path了。

• 创建 Path 对象：

  from pathlib import Path
  
  # 创建一个Path对象
  p = Path('my_project') / 'data' / 'config.json'
  print(f"Path对象: {p}")
  # Path对象会自动处理路径分隔符

  这里最酷的是，你可以直接使用/运算符来连接路径组件，这比os.path.join()更符合直觉。

• 路径属性和方法： Path对象有很多实用的属性和方法。

  from pathlib import Path
  
  p = Path('/home/user/documents/report.txt')
  
  print(f"文件名: {p.name

以上就是《Python文件读写教程及操作详解》的详细内容，更多关于文件路径,编码问题,with语句,Python文件读写,open()函数的资料请关注golang学习网公众号！