파이톤화분(10g/50g/1t)遇到的性能问题(面试向)

最近 最近 是 是 还是 笔试 笔试 笔试 笔试 笔试 个 个 高频 高频 始终 始终 阴魂 阴魂 不散 不散 不散 不散 不散 不散 不散 不散 不散 不散 不散 是 是 一 一 个 大 文件 文件 文件 文件 文件 超过 超过 10g, 在内存 有限 的 的 情况 下 下 下 低于)))) 该 以 什么 什么 姿势 读 它????

所有人都知道,用python读文件有一套”标准流程”:

def retrun\_count(fname):
    """计算文件有多少行
    """
    count = 0
    with open(fname) as file:
        for line in file:
            count += 1
    return count

为什么这种文件读取方式会成为标准? 这是因为它有两个好处:

with 上下文管理器会自动关闭打开的文件描述符
在迭代文件对象时,内容是一行一行返回的,不会展用太多内存

但这套标准做法并非没有缺点.如果被读取的文件里,根本就没有任何换行符,那么上面的第二个好处就不成立了.当代码执行到 for line in file 时,line 将会变成一个非常巨大的字符串对象,消耗掉非常可观的内存.

如果有一个 5GB 大的文件 big_file.txt,它里面装满了随机字符串.只不过它存储内容的方式稍有不同,所有的文本都被放在了同一行里

如果我们继续使用前面的 return_count 函数去统计这个大文件行数.那么在一台pc上,这个过程会足足花掉 65 秒,并在执中行过程吃吃掉掉 2GB

为了 为了 这个 解决 解决, 我们 需要 暂时 暂时 把 这个“标准 做法”放到 放到 一边 一边 一边 一边 一边 一边 一边 一边 一边 一边 一边 一边 一边 底层 的 的 的 的 的 的 的 的 的 的 方法.. 与 直接 直接 直接 循环 迭代 文件 对象 不同 不同 不同 不同 调用 调用 调用 调用 调用 调用 调用 调用 调用 从 从 从 从 从当前位置往后读取 chunk_size 大小的文件内容,不必等待任何换行符出现.

file.read()를 사용하는 방법은 다음과 같습니다.

def return\_count\_v2(fname):

    count = 0
    block\_size = 1024 \* 8
    with open(fname) as fp:
        while True:
            chunk = fp.read(block\_size)
            # 当文件没有更多内容时，read 调用将会返回空字符串 ''
            if not chunk:
                break
            count += 1
    return count

在 在 中 中 中 中 读取 文件 文件 个 个 个 读取 读取 读取 文件 内容 内容 内容 内容 内容 内容 内容 多 多 多 读取 读取 8kb 大小 大小 大小 这样 可以 可以 避免 避免 之前 需要 拼接 一 个 巨大 字 符串 过程 过程 过程 把 内存 占用 占用 降低 非常 多..

利用生成器解耦代码

假如 假如 在 我们 我们 的 不 是 是 是 是 是 是 是 而 而 其他 其他 其他 编程 编程 语言 语言. 那么 那么 可以 说 上面 的 代码 已经 很 很 好 了 了.. 但是 如果 如果 你 认真 认真 一下 一下 一下 一下 你 发现 发现 在 在 循环体 内部 内部 内部 内部 内部 内部 存在 着 两 独立 : : 효과가 있습니다.数据生成(调用与 chunk 判断 읽기) 与 数据消费.而这两个独立逻辑被耦合在了一起.

为了 为了 复用 提升 提升, 我们 可以 定义 定义 一 个 新 新 新 的 的 的 的 的 的 的 的 的 来 来 来 负责 负责 所有 所有 与 与“数据 生成 相关”相关 的 的 逻辑. 这样 这样 这样 这样 的 主循环 就 就 只 只 需要 负责 计数 计数 可 可 可.... 这样 这样

def chunked\_file\_reader(fp, block\_size=1024 \* 8):
    """生成器函数：分块读取文件内容
    """
    while True:
        chunk = fp.read(block\_size)
        # 当文件没有更多内容时，read 调用将会返回空字符串 ''
        if not chunk:
            break
        yield chunk


def return\_count\_v3(fname):
    count = 0
    with open(fname) as fp:
        for chunk in chunked\_file\_reader(fp):
            count += 1
    return count

进行到这一步,代码似乎已经没有优化的内建函数,但其实不然.iter(iterable) 是一个用来构造迭代器的内建函数,但它还有个个使用的内建函数,但它还有个个使用我一人的个(callable, sentinel) 的方式调用它时,会返回一个特殊的对象,迭代它将不断产生可调用对象 callable 的调用结果,直到结果为 setinel 时,濭代绢.

def chunked\_file\_reader(file, block\_size=1024 \* 8):
    """生成器函数：分块读取文件内容，使用 iter 函数
    """
    # 首先使用 partial(fp.read, block\_size) 构造一个新的无需参数的函数
    # 循环将不断返回 fp.read(block\_size) 调用结果，直到其为 '' 时终止
    for chunk in iter(partial(file.read, block\_size), ''):
        yield chunk

最后只需要两行代码,就构造出了一个可复用的分块读取方法,和一开始的”标准流程“按行读取 2GB 内存/耗时 65秒生相比稪的需要 7MB 内存/12 秒就能完成计算.效率提升了接近 4 倍,内存・用更是不到原来的 1%,简直完美.