Python的文本IO把我坑惨了，原来read和readlines的区别这么大

小郑那天写了一个日志分析工具，要统计应用日志里每种错误出现的次数。日志文件不大，几百兆，他想着一次性读进来处理最方便。代码大概长这样：

with open("app.log", "r", encoding="utf-8") as f:
    content = f.read()

for line in content:
    if "ERROR" in line:
        count += 1

跑完他傻眼了：统计结果大得离谱，几乎每一行都被算成了错误。他打印了一下line，发现每次循环拿到的都是一个字符，不是一行。

“我明明读的是日志，怎么变成逐个字符遍历了？”

他改成readlines()：

with open("app.log", "r", encoding="utf-8") as f:
    lines = f.readlines()

for line in lines:
    if "ERROR" in line:
        count += 1

这次对了。但他又写了一个场景：需要把整个日志当做一个字符串，用正则做跨行匹配。他用了readlines()拿到列表，然后"\n".join(lines)拼回去。同事路过看了一眼，说：“你直接用read()不就行了，干嘛绕这一圈？”

小郑愣了一下：read()读出来是字符串，readlines()读出来是列表，那到底什么时候用哪个？两者看起来都是“把文件读进来”，区别真的有那么大吗？

区别不但大，而且用错了不是报错，是静默地做出错误的结果。就像他第一次那样，程序不崩，只是统计数字全错。

先看一个最直观的对比

准备一个简单的文本文件demo.txt：

第一行
第二行
第三行

用两种方式读：

with open("demo.txt", "r", encoding="utf-8") as f:
    content = f.read()

print(type(content))   # <class 'str'>
print(repr(content))   # '第一行\n第二行\n第三行\n'
print(len(content))    # 12，字符数

with open("demo.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()

print(type(lines))     # <class 'list'>
print(lines)           # ['第一行\n', '第二行\n', '第三行\n']
print(len(lines))      # 3，行数

区别非常清楚：

read()把整个文件读成一个字符串，换行符\n保留在字符串里。你拿到的是连续的一大段文本。

readlines()把整个文件读成一个列表，列表的每个元素是一行，行尾的换行符\n也保留着。你拿到的是按行切好的若干段文本。

用一个生活场景来理解。你有一本记事本，上面记着三行字。

read()的做法是：把整本记事本的内容复印到一张长纸上，三行字连在一起，中间用换行隔开。你拿到的是“一整张纸”。

readlines()的做法是：把记事本拆成一页一页，每页一行，装进一个文件夹。你拿到的是“一叠纸”。

区别一目了然：一个是一整块文本，一个是按行切好的列表。

read()：整个文件读成一个字符串

read()的签名是file.read(size=-1)。不传参数时，读取从当前位置到文件末尾的所有内容，返回一个字符串。

with open("demo.txt", "r", encoding="utf-8") as f:
    content = f.read()

print(content)
# 第一行
# 第二行
# 第三行

read()适合“需要把整个文件当做一个整体来处理”的场景。比如：

• 用正则做跨行匹配
• 把整个文件内容传给某个只接受字符串的解析器
• 统计整个文件的字符数、单词数
• 文件很小，一次性读完最省事

read()也可以传一个size参数，读取指定数量的字符：

with open("demo.txt", "r", encoding="utf-8") as f:
    first_5 = f.read(5)
    print(repr(first_5))  # '第一行\n第'

注意：在文本模式下，size是字符数，不是字节数。一个中文字符算一个字符。

readlines()：整个文件读成一个字符串列表

readlines()的签名是file.readlines(hint=-1)。不传参数时，读取所有行，返回一个字符串列表。每个元素是一行，包含行尾的换行符。

with open("demo.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()

print(lines)  # ['第一行\n', '第二行\n', '第三行\n']

readlines()适合“需要按行逐个处理，而且文件不大”的场景。比如：

• 逐行解析配置
• 逐行过滤日志
• 对每一行做独立处理

readlines()的hint参数是一个“提示”，告诉Python大概读多少字节。但Python不保证精确按这个数量读，只是用它来优化内存分配。实际中很少用到这个参数。

坑一：对 read() 的结果用 for 循环，拿到的是字符

这就是小郑踩的第一个坑。

content = f.read()
for line in content:
    print(line)  # 每次输出一个字符

read()返回的是字符串。对字符串用for循环，迭代的是字符，不是行。

如果想按行遍历，要么用content.splitlines()先切成列表：

for line in content.splitlines():
    print(line)

要么一开始就用readlines()：

for line in f.readlines():
    print(line)

要么更直接：文件对象本身就是可迭代的，直接for line in f就是逐行读取。

坑二：readlines() 返回的行带换行符

readlines()保留行尾的\n。如果你直接拿去比较或者拼接，很容易出问题。

lines = f.readlines()
if lines[0] == "第一行":  # False，实际是 "第一行\n"
    ...

需要手动去掉换行符：

lines = [line.rstrip("\n") for line in f.readlines()]

或者用splitlines()：

lines = f.read().splitlines()

splitlines()会去掉行尾的换行符，而且能处理\r\n、\r、\n等多种换行符。这通常比readlines()更符合直觉。

坑三：大文件用 readlines() 会撑爆内存

readlines()会把整个文件读进内存，变成一个列表。文件几百兆、几个G的时候，内存直接爆掉。

# 文件 5GB，这行会直接 OOM
lines = f.readlines()

而且列表里每个元素都是一个独立的字符串对象，额外还有列表本身的开销。一个5GB的文件，读成列表后占用的内存可能超过6GB。

大文件应该逐行迭代，而不是一次性读进列表：

with open("big.log", "r", encoding="utf-8") as f:
    for line in f:
        process(line)

文件对象本身就是可迭代的，每次只读一行，内存占用恒定。这是处理大文件的标准做法。

坑四：以为 read() 和 readlines() 可以混用

文件对象内部维护一个“当前位置”指针。read()读完之后，指针到了文件末尾。再调readlines()，读到的是空列表。

with open("demo.txt", "r", encoding="utf-8") as f:
    content = f.read()       # 指针到末尾
    lines = f.readlines()    # []
    print(lines)             # []

反过来也一样：

with open("demo.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()    # 指针到末尾
    content = f.read()       # ''
    print(repr(content))     # ''

如果需要重新读，必须f.seek(0)把指针移回开头：

f.seek(0)
content = f.read()

坑五：readline() 和 read() 搞混

还有一个readline()，每次读一行，返回字符串。它和read()名字很像，但行为完全不同。

with open("demo.txt", "r", encoding="utf-8") as f:
    line1 = f.readline()  # '第一行\n'
    line2 = f.readline()  # '第二行\n'
    line3 = f.readline()  # '第三行\n'
    line4 = f.readline()  # ''，到末尾了

readline()适合“一次处理一行，但需要手动控制读取节奏”的场景。大多数时候，直接for line in f更简洁，效果也一样。

readline()在文件末尾返回空字符串''，可以用它来判断是否读完：

while True:
    line = f.readline()
    if not line:
        break
    process(line)

但这段代码完全可以用for line in f替代：

for line in f:
    process(line)

后者更简洁，也更 Pythonic。

四种读取方式的对比

Python 读文本文件主要有四种方式：

内存占用上，read()和readlines()都是O(文件大小)，readline()和for line in f都是O(一行大小)。

什么时候用 read()，什么时候用 readlines()？

判断标准很清晰：

需要把整个文件当做一个字符串处理：用read()。比如正则跨行匹配、整体哈希、传给只接受字符串的解析器。

需要按行处理，而且文件不大：用readlines()，或者f.read().splitlines()。

需要按行处理，而且文件很大：用for line in f，逐行迭代，不要一次性读进内存。

需要手动控制读取节奏：用readline()。

需要读取固定大小的块：用read(size)，配合循环，适合二进制或超大文本的分块处理。

一个容易忽略的细节：splitlines() 比 readlines() 更干净

readlines()保留行尾换行符，splitlines()不保留。大多数按行处理的场景，你其实不想要换行符。

# readlines()：行尾带 \n
lines = f.readlines()
print(lines)  # ['第一行\n', '第二行\n']

# splitlines()：行尾不带 \n
lines = f.read().splitlines()
print(lines)  # ['第一行', '第二行']

splitlines()还能正确处理\r\n（Windows换行）、\r（老Mac换行）、\n（Unix换行）以及一些特殊换行符（如\v、\f）。跨平台处理文本时，splitlines()比readlines()更可靠。

但splitlines()需要先read()整个文件，所以只适合小文件。大文件还是用for line in f，需要去换行符就line.rstrip("\n")。

性能差异

对于小文件，read()、readlines()、for line in f的差别不大。对于大文件，差别就出来了。

import time

# 假设有一个 100MB 的文本文件

# read()
start = time.time()
with open("big.txt", "r", encoding="utf-8") as f:
    content = f.read()
print(f"read(): {time.time() - start:.2f}s")

# readlines()
start = time.time()
with open("big.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
print(f"readlines(): {time.time() - start:.2f}s")

# for line in f
start = time.time()
with open("big.txt", "r", encoding="utf-8") as f:
    for line in f:
        pass
print(f"for line in f: {time.time() - start:.2f}s")

时间上，三者可能差不多，因为瓶颈在磁盘I/O。但内存占用完全不同：read()和readlines()要一次性加载整个文件，for line in f只加载一行。文件越大，内存差距越明显。

回到小郑的故事

小郑最终的代码是这样的。

统计错误次数，用逐行迭代：

count = 0
with open("app.log", "r", encoding="utf-8") as f:
    for line in f:
        if "ERROR" in line:
            count += 1

跨行正则匹配，用read()：

with open("app.log", "r", encoding="utf-8") as f:
    content = f.read()
matches = re.findall(r"ERROR.*?\n.*?stack", content, re.DOTALL)

需要按行列表处理的小文件，用splitlines()：

with open("config.txt", "r", encoding="utf-8") as f:
    lines = f.read().splitlines()

他后来在团队文档里写了一条：“read()读成字符串，readlines()读成列表。字符串用for循环拿到的是字符，列表用for循环拿到的是行。大文件用for line in f，别一次性读进内存。需要去换行符用splitlines()，别用readlines()再手动处理。”

这个区分看起来简单，但真到写代码的时候，很多人会随手写f.read()然后for循环，发现拿到的是字符，还以为是编码问题。或者用readlines()读一个大日志，把内存撑爆。

记住那个复印记事本的比喻：read()是把整本记事本复印到一张长纸上，readlines()是拆成一页一页装进文件夹。你要整体处理，就用长纸；你要逐页处理，就用文件夹；文件太大，就一页一页翻，别一次性全拆开。

文本IO本身不难，难的是想清楚“我要的是整块文本还是按行列表，文件有多大，内存够不够”。想清楚了，read和readlines就不再是坑，而是两个各司其职的工具。