Python读取txt文件的几种方法

积累知识，胜过积蓄金银！毕竟在文章开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《Python读取txt文件方法详解》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

Python读取txt文件需用open()函数配合with语句确保资源释放，推荐逐行迭代或分块读取大文件，并明确指定encoding解决编码问题。

Python读取txt文件主要依赖内置的open()函数，它能打开文件并返回一个文件对象，接着可以使用文件对象的方法如read()、readline()或readlines()来获取内容。文件写入则通常使用write()方法，同时，为了确保文件资源被正确释放，无论读写，都强烈推荐使用with语句。

解决方案

在Python中进行文件读写，核心在于open()函数和文件对象的操作。以下是具体的步骤和常用方法：

1. 打开文件： 使用open()函数来打开一个文件。它至少需要一个参数：文件路径（包含文件名）。通常还会指定第二个参数：文件模式（'r'表示读，'w'表示写，'a'表示追加）。更重要的是，要考虑编码，尤其是处理包含非ASCII字符的文本文件时，指定encoding='utf-8'是一个非常好的习惯，能避免很多乱码问题。

# 读取模式
# 'r' - 只读（默认模式），文件不存在会报错
# 'w' - 只写，如果文件存在会清空内容，不存在则创建新文件
# 'a' - 追加模式，如果文件存在，新内容会添加到文件末尾，不存在则创建新文件
# 'r+' - 读写模式，文件指针在开头
# 'w+' - 读写模式，清空文件内容或创建新文件
# 'a+' - 读写模式，文件指针在末尾（写入时），读取时在开头

2. 读取文件内容： 一旦文件被打开，你就可以使用文件对象提供的方法来读取数据。

• read(): 读取整个文件内容，并将其作为单个字符串返回。

  with open('example.txt', 'r', encoding='utf-8') as f:
      content = f.read()
      print(content)

• readline(): 读取文件中的一行内容，包括行尾的换行符。每次调用都会读取下一行。

  with open('example.txt', 'r', encoding='utf-8') as f:
      first_line = f.readline()
      second_line = f.readline()
      print(f"第一行: {first_line.strip()}") # .strip()去除换行符
      print(f"第二行: {second_line.strip()}")

• readlines(): 读取所有行，并将它们作为一个字符串列表返回，列表中的每个元素都是文件中的一行（包含换行符）。

  with open('example.txt', 'r', encoding='utf-8') as f:
      lines = f.readlines()
      for line in lines:
          print(line.strip())

• 按行迭代（推荐）: 对于大文件，直接迭代文件对象是最高效的方式，因为它不会一次性将所有内容加载到内存中。

  with open('example.txt', 'r', encoding='utf-8') as f:
      for line in f:
          print(line.strip())

3. 写入文件内容： 使用write()方法将字符串写入文件。

• write(string): 将指定的字符串写入文件。请注意，write()不会自动添加换行符，你需要手动添加\n。

  # 写入新内容（会覆盖旧内容）
  with open('output.txt', 'w', encoding='utf-8') as f:
      f.write("这是第一行内容。\n")
      f.write("这是第二行内容。\n")
  
  # 追加内容
  with open('output.txt', 'a', encoding='utf-8') as f:
      f.write("这是追加的第三行。\n")

4. 错误处理： 文件操作时可能会遇到FileNotFoundError或PermissionError等异常。使用try...except块可以更好地处理这些情况。

try:
    with open('non_existent_file.txt', 'r', encoding='utf-8') as f:
        content = f.read()
        print(content)
except FileNotFoundError:
    print("错误：文件不存在，请检查路径。")
except Exception as e:
    print(f"发生了一个未知错误: {e}")

Python文件读取时，编码问题怎么解决？

编码问题，说实话，是我在Python文件操作中遇到最多的“拦路虎”之一。你兴冲冲地写好代码，运行，结果屏幕上跳出一堆乱码，或者更糟，直接一个UnicodeDecodeError，那一瞬间的挫败感，我相信很多开发者都深有体会。

解决这个问题，核心思想就是明确地告诉Python你正在处理的文件是什么编码格式。默认情况下，Python 3在打开文件时会尝试使用系统的默认编码（比如在Windows上可能是GBK，在Linux上通常是UTF-8），但如果文件实际编码与系统默认不符，问题就来了。

最直接、最推荐的做法是：在open()函数中明确指定encoding参数。

# 假设你的文件是UTF-8编码
with open('my_document.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

# 如果你知道文件是GBK编码（中文Windows系统常见）
with open('legacy_file.txt', 'r', encoding='gbk') as f:
    content = f.read()
    print(content)

# 甚至是一些比较少见的，比如Latin-1
with open('iso_file.txt', 'r', encoding='latin-1') as f:
    content = f.read()
    print(content)

当你遇到UnicodeDecodeError时，错误信息通常会提示在哪一行、哪个字节发生了问题。这给了我们排查的方向。通常，你需要：

1. 确认文件实际编码：这可能是最难的一步。你可以尝试用文本编辑器（如Notepad++、VS Code）打开文件，这些编辑器通常能自动检测或允许你手动查看/更改文件的编码。
2. 尝试常见的编码：如果无法确定，可以先尝试utf-8，然后是gbk（针对中文环境），或者latin-1（针对一些西欧语言）。
3. 万不得已的“暴力”方法（不推荐，但有时有用）： errors参数。在open()函数中，除了encoding，还有一个errors参数。它可以指定当编码解码失败时如何处理。
   • errors='ignore'：忽略无法解码的字符。这会导致数据丢失，但至少程序不会崩溃。
   • errors='replace'：用一个特殊的替换字符（通常是?或�）代替无法解码的字符。

     # 慎用！这会丢失信息
     with open('problem_file.txt', 'r', encoding='utf-8', errors='ignore') as f:
     content = f.read()
     print(content)

     这种方法虽然能让程序跑起来，但你得到的数据可能是不完整的或有偏差的，所以只应作为最后的手段，并且要清楚其副作用。我的建议是，从源头解决编码问题，确保文件以正确的编码保存，或者在读取时使用正确的编码参数。

Python文件读写操作中，with语句为什么如此重要？

with语句在Python的文件操作中，几乎可以说是“标配”了。如果你看到一个Python文件操作的代码没有用with，那多半是初学者，或者在一些非常特殊的场景下。它的重要性，主要体现在资源管理和代码健壮性上。

想象一下，你打开了一扇门（文件），进去拿东西。拿完东西后，你是不是应该把门关上？如果忘了关，这扇门就一直开着，别人可能进不来，或者风雨会进来。文件也是一样，当你用open()函数打开一个文件后，操作系统会为这个文件分配一些资源（比如文件句柄）。如果程序在完成操作后没有显式地调用f.close()来关闭文件，这些资源就可能一直被占用着，直到程序结束，甚至更久。

这就可能导致一系列问题：

• 资源泄露：打开的文件句柄过多，可能耗尽操作系统资源，导致后续文件操作失败。
• 数据损坏或丢失：如果文件没有被正确关闭，写入的数据可能没有完全刷新到磁盘，导致数据不完整。
• 文件锁定：在某些操作系统上，未关闭的文件可能会被锁定，阻止其他程序或用户访问或修改。

而with语句，正是为了解决这些问题而生的。它背后利用了Python的上下文管理器协议（context manager protocol）。当with语句块开始执行时，它会自动调用文件对象的__enter__方法；当with语句块执行结束（无论是正常结束，还是因为异常退出），它都会自动调用文件对象的__exit__方法。而__exit__方法的核心工作，就是确保文件被安全地关闭。

这意味着，无论你的代码在with块内部是顺利执行完毕，还是在某个地方抛出了异常，Python都会保证文件句柄会被释放，文件会被关闭。你不再需要手动地在try...finally块中去调用f.close()，代码会变得更简洁、更安全。

# 没有使用with语句的写法（不推荐）
f = open('data.txt', 'r', encoding='utf-8')
try:
    content = f.read()
    print(content)
except Exception as e:
    print(f"处理文件时出错: {e}")
finally:
    f.close() # 必须手动关闭

# 使用with语句的写法（推荐）
with open('data.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)
# 文件在with块结束时自动关闭，即使有异常

很明显，with语句让代码更清晰，减少了出错的可能性，也让开发者能更专注于业务逻辑，而不是繁琐的资源管理。这正是它如此重要的原因。

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

处理大文件，比如几个GB甚至几十GB的日志文件或数据集，如果直接用f.read()或f.readlines()一次性把所有内容加载到内存，那几乎肯定会遇到MemoryError，或者导致系统卡顿。这时候，我们需要更“聪明”的策略，也就是那些按需读取、分块处理的方法。

1. 逐行迭代（Line-by-Line Iteration）

这是处理文本大文件最常用、最有效的方式之一。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:
            # 在这里处理每一行数据
            # 比如：解析JSON、过滤特定内容、统计词频等
            # print(line.strip()) # 打印时去除换行符
            line_count += 1
            if line_count % 100000 == 0:
                print(f"已处理 {line_count} 行...")
    print(f"文件处理完毕，总行数: {line_count}")

# 示例调用
# process_large_text_file_line_by_line('large_log.txt')

这种方法内存占用极低，因为它一次只处理一行，非常适合日志文件分析、数据清洗等场景。

2. 分块读取（Reading in Chunks）

对于二进制文件或者那些不以行划分的文本文件（比如巨大的XML、CSV文件，你可能想一次读取固定大小的数据块），f.read(size)方法就派上用场了。你可以指定每次读取的字节数（size），然后在一个循环中不断读取，直到文件末尾。

def process_large_binary_file_in_chunks(filepath, chunk_size=4096): # 默认4KB
    total_bytes_read = 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_read += len(chunk)
            if total_bytes_read % (1024 * 1024 * 100) == 0: # 每100MB打印一次
                print(f"已处理 {total_bytes_read / (1024 * 1024):.2f} MB...")
    print(f"文件处理完毕，总字节数: {total_bytes_read}")

# 示例调用
# process_large_binary_file_in_chunks('large_data.bin')

这种方式对于处理图像、视频、归档文件等二进制数据非常有效。chunk_size的选择取决于你的内存和处理需求，通常选择几KB到几MB。

3. 使用mmap模块（Memory-Mapped Files）

对于非常非常大的文件，如果你的操作系统支持内存映射文件（大多数现代操作系统都支持），Python的mmap模块可以提供一种更高级的解决方案。它将文件的一部分或全部内容映射到进程的虚拟内存空间中，这样你就可以像访问内存数组一样访问文件内容，而不需要实际将整个文件加载到物理内存。操作系统会负责按需从磁盘加载数据。

import mmap
import os

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

    with open(filepath, 'r+b') as f: # 'r+b' 读写二进制模式
        # 使用mmap.mmap创建内存映射
        # length=0表示映射整个文件
        mm = mmap.mmap(f.fileno(), 0)
        try:
            # 在映射的内存中查找字节序列
            # 注意：search_term也需要是字节串
            if mm.find(search_term.encode('utf-8')) != -1:
                print(f"找到了 '{search_term}'。")
                return True
            else:
                print(f"未找到 '{search_term}'。")
                return False
        finally:
            mm.close() # 务必关闭mmap对象

# 示例调用
# with open('large_text_for_mmap.txt', 'w', encoding='utf-8') as f:
#     f.write("This is a very long file with some important text inside it." * 100000)
# search_in_large_file_with_mmap('large_text_for_mmap.txt', 'important text')

mmap特别适合需要随机访问文件内容或者在文件中进行复杂搜索的场景，因为它避免了频繁的磁盘I/O操作，直接通过内存地址访问数据。然而，它的使用相对复杂一些，且主要用于二进制模式。

选择哪种策略，取决于你的文件类型、文件大小以及你想要对数据进行的操作。对于大多数文本大文件，逐行迭代通常是最佳选择，兼顾了简单性和效率。

理论要掌握，实操不能落！以上关于《Python读取txt文件的几种方法》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！