Python mmap：使用内存映射改进文件 I/O

深入了解文件 I/O

既然您对不同类型的内存有了一个高层次的了解，是时候了解什么是内存映射以及它解决了什么问题。内存映射是另一种执行文件 I/O 的方法，可以提高性能和内存效率。

为了充分理解内存映射的作用，从较低级别的角度考虑常规文件 I/O 很有用。读取文件时在幕后发生了很多事情：

1. 通过系统调用将控制权转移到内核或核心操作系统代码

2. 与文件所在的物理磁盘交互

3. 将数据复制到用户空间和内核空间之间的不同缓冲区中

考虑以下代码，它执行常规 Python 文件 I/O：

def regular_io(filename):
    with open(filename, mode="r", encoding="utf8") as file_obj:
        text = file_obj.read()
        print(text)

如果在运行时有足够的可用空间，此代码会将整个文件读入物理内存，并将其打印到屏幕上。

这种类型的文件 I/O 可能是您在 Python 之旅的早期学习过的。代码不是很密集或复杂。然而，在函数调用的掩护下发生的事情read()非常复杂。请记住，Python 是一种高级编程语言，因此可以对程序员隐藏很多复杂性。

使用 Python 读取内存映射文件 mmap

现在，抛开所有这些理论，您可能会问自己：“我如何使用 Pythonmmap创建内存映射文件？”

这是您之前看到的文件 I/O 代码的内存映射等效项：

import mmap

def mmap_io(filename):
    with open(filename, mode="r", encoding="utf8") as file_obj:
        with mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_READ) as mmap_obj:
            text = mmap_obj.read()
            print(text)

这段代码将整个文件作为字符串读入内存并将其打印到屏幕上，就像早期的常规文件 I/O 方法所做的那样。

简而言之， usingmmap与传统的读取文件的方式非常相似，只是有一些小的变化：

1. 打开文件open()是不够的。您还需要使用mmap.mmap()向操作系统发出信号，表明您希望将文件映射到 RAM 中。

2. 您需要确保您使用的模式open()与mmap.mmap(). 的默认模式open()是读取，但默认模式mmap.mmap()是读取和写入。因此，您在打开文件时必须明确。

3. 您需要使用mmap对象而不是由返回的标准文件对象来执行所有读取和写入操作open()。

>>> import timeit
>>> timeit.repeat(
...     "regular_io(filename)",
...     repeat=3,
...     number=1,
...     setup="from __main__ import regular_io, filename")
[0.02022400000000002, 0.01988580000000001, 0.020257300000000006]
>>> timeit.repeat(
...     "mmap_io(filename)",
...     repeat=3,
...     number=1,
...     setup="from __main__ import mmap_io, filename")
[0.006156499999999981, 0.004843099999999989, 0.004868600000000001]

mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_READ)

mmap 作为字符串的对象

如前所述，内存映射透明地将文件内容作为字符串加载到内存中。因此，一旦打开文件，您就可以执行许多与字符串相同的操作，例如切片：

import mmap

def mmap_io(filename):
    with open(filename, mode="r", encoding="utf8") as file_obj:
        with mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_READ) as mmap_obj:
            print(mmap_obj[10:20])

此代码将十个字符打印mmap_obj到屏幕上，并将这十个字符读入物理内存。同样，数据是惰性读取的。

切片不会推进内部文件位置。因此，如果您要read()在切片之后调用，那么您仍然会从文件的开头读取。

搜索内存映射文件

除了切片之外，该mmap模块还允许其他类似字符串的行为，例如使用find()和rfind()搜索特定文本的文件。例如，这里有两种方法可以找到" the "文件中第一次出现的：

import mmap

def regular_io_find(filename):
    with open(filename, mode="r", encoding="utf-8") as file_obj:
        text = file_obj.read()
        print(text.find(" the "))

def mmap_io_find(filename):
    with open(filename, mode="r", encoding="utf-8") as file_obj:
        with mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_READ) as mmap_obj:
            print(mmap_obj.find(b" the "))

这两个函数都在文件中搜索第一次出现的" the "。它们之间的主要区别在于，第一个用于find()字符串对象，而第二个用于find()内存映射文件对象。

注意： mmap操作字节，而不是字符串。

这是性能差异：

>>>

>>> import timeit
>>> timeit.repeat(
...     "regular_io_find(filename)",
...     repeat=3,
...     number=1,
...     setup="from __main__ import regular_io_find, filename")
[0.01919180000000001, 0.01940510000000001, 0.019157700000000027]
>>> timeit.repeat(
...     "mmap_io_find(filename)",
...     repeat=3,
...     number=1,
...     setup="from __main__ import mmap_io_find, filename")
[0.0009397999999999906, 0.0018005999999999855, 0.000826699999999958]

这是几个数量级的差异！同样，您的结果可能会因您的操作系统而异。

内存映射文件也可以直接与正则表达式一起使用。考虑以下示例，该示例查找并打印出所有五个字母的单词：

import re
import mmap

def mmap_io_re(filename):
    five_letter_word = re.compile(rb"\b[a-zA-Z]{5}\b")

    with open(filename, mode="r", encoding="utf-8") as file_obj:
        with mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_READ) as mmap_obj:
            for word in five_letter_word.findall(mmap_obj):
                print(word)

此代码读取整个文件并打印出其中恰好包含五个字母的每个单词。请记住，内存映射文件使用字节字符串，因此正则表达式也必须使用字节字符串。

这是使用常规文件 I/O 的等效代码：

import re

def regular_io_re(filename):
    five_letter_word = re.compile(r"\b[a-zA-Z]{5}\b")

    with open(filename, mode="r", encoding="utf-8") as file_obj:
        for word in five_letter_word.findall(file_obj.read()):
            print(word)

这段代码也打印出文件中所有五个字符的单词，但它使用传统的文件 I/O 机制而不是内存映射文件。和以前一样，两种方法的性能不同：

>>>

>>> import timeit
>>> timeit.repeat(
...     "regular_io_re(filename)",
...     repeat=3,
...     number=1,
...     setup="from __main__ import regular_io_re, filename")
[0.10474110000000003, 0.10358619999999996, 0.10347820000000002]
>>> timeit.repeat(
...     "mmap_io_re(filename)",
...     repeat=3,
...     number=1,
...     setup="from __main__ import mmap_io_re, filename")
[0.0740976000000001, 0.07362639999999998, 0.07380980000000004]

内存映射方法仍然快一个数量级。

用 Python 编写内存映射文件 mmap

内存映射对于读取文件最有用，但您也可以使用它来写入文件。mmap除了一些不同之外，用于写入文件的API 与常规文件 I/O 非常相似。

这是将文本写入内存映射文件的示例：

import mmap

def mmap_io_write(filename, text):
    with open(filename, mode="w", encoding="utf-8") as file_obj:
        with mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_WRITE) as mmap_obj:
            mmap_obj.write(text)

此代码将文本写入内存映射文件。但是，ValueError如果创建mmap对象时文件为空，则会引发异常。

Python 的mmap模块不允许空文件的内存映射。这是合理的，因为从概念上讲，一个空的内存映射文件只是一个内存缓冲区，因此不需要内存映射对象。

通常，内存映射用于读或读/写模式。例如，以下代码演示了如何快速读取文件并仅修改其中的一部分：

import mmap

def mmap_io_write(filename):
    with open(filename, mode="r+") as file_obj:
        with mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_WRITE) as mmap_obj:
            mmap_obj[10:16] = b"python"
            mmap_obj.flush()

此函数将打开一个已包含至少 16 个字符的文件，并将字符 10 到 15 更改为"python".

写入的更改mmap_obj在磁盘和内存中的文件中都是可见的。Python 官方文档建议始终调用flush()以确保将数据写回磁盘。

使用 Python 在进程之间共享数据 mmap

到目前为止，您只将内存映射文件用于磁盘上的数据。但是，您也可以创建没有物理存储的匿名内存映射。这可以通过-1作为文件描述符传递来完成：

import mmap

with mmap.mmap(-1, length=100, access=mmap.ACCESS_WRITE) as mmap_obj:
    mmap_obj[0:100] = b"a" * 100
    print(mmap_obj[0:100])

这会在 RAM 中创建一个匿名内存映射对象，其中包含100字母 的副本"a"。

匿名内存映射对象本质上是length内存中由参数指定的特定大小的缓冲区。缓冲区类似于io.StringIO或io.BytesIO来自标准库。但是，匿名内存映射对象支持跨多个进程共享，这既io.StringIO不允许也io.BytesIO不允许。

这意味着您可以使用匿名内存映射对象在进程之间交换数据，即使这些进程具有完全独立的内存和堆栈。这是创建匿名内存映射对象以共享可以从两个进程写入和读取的数据的示例：

import mmap

def sharing_with_mmap():
    BUF = mmap.mmap(-1, length=100, access=mmap.ACCESS_WRITE)

    pid = os.fork()
    if pid == 0:
        # Child process
        BUF[0:100] = b"a" * 100
    else:
        time.sleep(2)
        print(BUF[0:100])

使用此代码，您可以创建一个内存映射100字节缓冲区，并允许从两个进程读取和写入该缓冲区。如果您想节省内存并仍然跨多个进程共享大量数据，则此方法很有用。

使用内存映射共享内存有几个优点：

• 不必在进程之间复制数据。

• 操作系统透明地处理内存。

• 数据不必在进程之间进行腌制，从而节省了 CPU 时间。

说到pickling，值得指出的mmap是，它与内置multiprocessing模块等更高级别、功能更全的 API 不兼容。该multiprocessing模块需要在进程之间传递的数据来支持pickle 协议，但mmap它不支持。

您可能想使用multiprocessing代替os.fork()，如下所示：

from multiprocessing import Process

def modify(buf):
    buf[0:100] = b"xy" * 50

if __name__ == "__main__":
    BUF = mmap.mmap(-1, length=100, access=mmap.ACCESS_WRITE)
    BUF[0:100] = b"a" * 100
    p = Process(target=modify, args=(BUF,))
    p.start()
    p.join()
    print(BUF[0:100])

在这里，您尝试创建一个新进程并将其传递给内存映射缓冲区。这段代码会立即引发a，TypeError因为mmap对象不能被pickle，这是将数据传递给第二个进程所必需的。因此，要与内存映射共享数据，您需要坚持使用较低级别的os.fork().

如果您使用的是 Python 3.8 或更新版本，那么您可以使用新shared_memory模块更有效地跨 Python 进程共享数据：

from multiprocessing import Process
from multiprocessing import shared_memory

def modify(buf_name):
    shm = shared_memory.SharedMemory(buf_name)
    shm.buf[0:50] = b"b" * 50
    shm.close()

if __name__ == "__main__":
    shm = shared_memory.SharedMemory(create=True, size=100)

    try:
        shm.buf[0:100] = b"a" * 100
        proc = Process(target=modify, args=(shm.name,))
        proc.start()
        proc.join()
        print(bytes(shm.buf[:100]))
    finally:
        shm.close()
        shm.unlink()

这个小程序创建一个100字符列表并修改另一个进程的前 50 个字符。

请注意，只有缓冲区的名称会传递给第二个进程。然后第二个进程可以使用唯一名称检索相同的内存块。这是shared_memory由mmap. 在幕后，该shared_memory模块使用每个操作系统的独特 API 为您创建命名内存映射。

现在你知道了Python 3.8新特性的一些底层实现细节以及如何mmap直接使用！