缓冲协议

虽然这些类型中的每一种都有自己的语义，但它们具有由可能较大的内存缓冲区支持的共同特征。 在某些情况下，希望直接访问该缓冲区而无需中间复制。

Python 以 缓冲协议 的形式在 C 层级上提供这样的功能。 此协议包括两个方面:

• 在生产者这一方面，该类型的协议可以导出一个“缓冲区接口”，允许公开它的底层缓冲区信息。该接口的描述信息在 一节中；

一些简单的对象例如 bytes 和 会以面向字节的形式公开它们的底层缓冲区。 也可能会用其他形式；例如 array.array 所公开的元素可以是多字节值。

缓冲区接口的消费者的一个例子是文件对象的 方法：任何可以输出为一系列字节流的对象可以被写入文件。然而 方法只需要对于传入对象的只读权限，其他的方法，如 readinto() 需要参数内容的写入权限。缓冲区接口使得对象可以选择性地允许或拒绝读写或只读缓冲区的导出。

对于缓冲接口的消费者而言，有两种方式来获取一个目的对象的缓冲。

• 使用正确的参数来调用 函数

• 调用 PyArg_ParseTuple() (或其同级对象之一) 并传入 y*, w* or s* 中的一个。

在这两种情况下，当不再需要缓冲区时必须调用 PyBuffer_Release() 。如果此操作失败，可能会导致各种问题，例如资源泄漏。

缓冲区结构(或者简单地称为“buffers”)对于将二进制数据从另一个对象公开给Python程序员非常有用。它们还可以用作零拷贝切片机制。使用它们引用内存块的能力，可以很容易地将任何数据公开给Python程序员。内存可以是C扩展中的一个大的常量数组，也可以是在传递到操作系统库之前用于操作的原始内存块，或者可以用来传递本机内存格式的结构化数据。

与 Python 解释器公开的大多部数据类型不同，缓冲区不是 指针而是简单的 C 结构。 这使得它们可以非常简单地创建和复制。 当需要为缓冲区加上泛型包装器时，可以创建一个 内存视图 对象。

有关如何编写并导出对象的简短说明，请参阅 。 要获取缓冲区对象，请参阅 PyObject_GetBuffer()。

Py_buffer

• void *buf

  指向由缓冲区字段描述的逻辑结构开始的指针。 这可以是导出程序底层物理内存块中的任何位置。 例如，使用负的 值可能指向内存块的末尾。

  对于 contiguous ，‘邻接’数组，值指向内存块的开头。

• void *obj

  A new reference to the exporting object. The reference is owned by the consumer and automatically decremented and set to NULL by . The field is the equivalent of the return value of any standard C-API function.

  As a special case, for temporary buffers that are wrapped by PyMemoryView_FromBuffer() or this field is NULL. In general, exporting objects MUST NOT use this scheme.

• Py_ssize_t len

  product(shape) * itemsize。对于连续数组，这是基础内存块的长度。对于非连续数组，如果逻辑结构复制到连续表示形式，则该长度将具有该长度。

  仅当缓冲区是通过保证连续性的请求获取时，才访问 ((char *)buf)[0] up to ((char *)buf)[len-1] 时才有效。在大多数情况下，此类请求将为 PyBUF_SIMPLE 或 。

• int readonly

  缓冲区是否为只读的指示器。此字段由 PyBUF_WRITABLE 标志控制。

• Py_ssize_t itemsize

  Item size in bytes of a single element. Same as the value of called on non-NULL format values.

  Important exception: If a consumer requests a buffer without the flag, format will be set to NULL, but still has the value for the original format.

  如果 shape 存在，则相等的 product(shape) * itemsize == len 仍然存在，使用者可以使用 来导航缓冲区。

  If shape is NULL as a result of a or a PyBUF_WRITABLE request, the consumer must disregard and assume itemsize == 1.

• const char *format

  A NUL terminated string in struct module style syntax describing the contents of a single item. If this is NULL, "B" (unsigned bytes) is assumed.

  此字段由 标志控制。

• int ndim

  The number of dimensions the memory represents as an n-dimensional array. If it is 0, buf points to a single item representing a scalar. In this case, , strides and MUST be NULL.

  宏 PyBUF_MAX_NDIM 将最大维度数限制为 64。 导出程序必须遵守这个限制，多维缓冲区的使用者应该能够处理最多 PyBUF_MAX_NDIM 维度。

• Py_ssize_t *shape

  一个长度为 Py_ssize_t 的数组 ndim 表示作为 n 维数组的内存形状。 请注意，shape[0] * ... * shape[ndim-1] * itemsize 必须等于 。

  Shape 形状数组中的值被限定在 shape[n] >= 0 。 shape[n] == 0 这一情形需要特别注意。更多信息请参阅 complex arrays 。

  shape数组对于使用者来说是只读的。

• Py_ssize_t *strides

  一个长度为 Py_ssize_t 的数组 给出要跳过的字节数以获取每个尺寸中的新元素。

  Stride 步幅数组中的值可以为任何整数。对于常规数组，步幅通常为正数，但是使用者必须能够处理 strides[n] <= 0 的情况。更多信息请参阅 complex arrays 。

  strides数组对用户来说是只读的。

• Py_ssize_t *suboffsets

  一个长度为 类型为 Py_ssize_t 的数组 。如果 suboffsets[n] >= 0，则第 n 维存储的是指针，suboffset 值决定了解除引用时要给指针增加多少字节的偏移。suboffset 为负值，则表示不应解除引用（在连续内存块中移动）。

  If all suboffsets are negative (i.e. no de-referencing is needed), then this field must be NULL (the default value).

  Python Imaging Library (PIL) 中使用了这种数组的表达方式。请参阅 complex arrays 来了解如何从这样一个数组中访问元素。

  suboffsets 数组对于使用者来说是只读的。

通常，通过 向输出对象发送缓冲区请求，即可获得缓冲区。由于内存的逻辑结构复杂，可能会有很大差异，缓冲区使用者可用 flags 参数指定其能够处理的缓冲区具体类型。

所有 Py_buffer 字段均由请求类型明确定义。

以下字段不会被 flags 影响，并且必须总是用正确的值填充：, buf，，itemsize，。

只读，格式

可以和下一节的所有标志联用。由于 PyBUF_SIMPLE 定义为 0，所以 可以作为一个独立的标志，用于请求一个简单的可写缓冲区。

PyBUF_FORMAT 可以被设为除了 之外的任何标志。 后者已经按暗示了``B``(无符号字节串)格式。

控制内存逻辑结构的标志按照复杂度的递减顺序列出。注意，每个标志包含它下面的所有标志。

连续性的请求

可以显式地请求C 或 Fortran ，不管有没有步幅信息。若没有步幅信息，则缓冲区必须是 C-连续的。

所有可能的请求都由上一节中某些标志的组合完全定义。为方便起见，缓冲区协议提供常用的组合作为单个标志。

在下表中，U 代表连续性未定义。消费者程序必须调用 PyBuffer_IsContiguous() 以确定连续性。

NumPy-风格：形状和步幅

NumPy 风格数组的逻辑结构由 itemsize 、 、 shape 和 定义。

If ndim == 0, the memory location pointed to by buf is interpreted as a scalar of size . In that case, both shape and are NULL.

If strides is NULL, the array is interpreted as a standard n-dimensional C-array. Otherwise, the consumer must access an n-dimensional array as follows:

ptr = (char *)buf + indices[0] * strides[0] + ... + indices[n-1] * strides[n-1] item = *((typeof(item) *)ptr);

如上所述， 可以指向实际内存块中的任意位置。输出者程序可以用该函数检查缓冲区的有效性。

除了常规项之外， PIL 风格的数组还可以包含指针，必须跟随这些指针才能到达维度的下一个元素。例如，常规的三维 C 语言数组 char v[2][2][3] 可以看作是一个指向 2 个二维数组的 2 个指针：char (*v[2])[2][3]。在子偏移表示中，这两个指针可以嵌入在 buf 的开头，指向两个可以位于内存任何位置的 char x[2][3] 数组。

Here is a function that returns a pointer to the element in an N-D array pointed to by an N-dimensional index when there are both non-NULL strides and suboffsets:

void *get_item_pointer(int ndim, void *buf, Py_ssize_t *strides,
                       Py_ssize_t *suboffsets, Py_ssize_t *indices) {
    char *pointer = (char*)buf;
    int i;
    for (i = 0; i < ndim; i++) {
        pointer += strides[i] * indices[i];
        if (suboffsets[i] >=0 ) {
            pointer = *((char**)pointer) + suboffsets[i];
        }
    }
    return (void*)pointer;
}

int ( *obj)

如果 obj 支持缓冲区接口，则返回 1，否则返回 0。 返回 1 时不保证 PyObject_GetBuffer() 一定成功。本函数一定调用成功。

int PyObject_GetBuffer( exporter*, Py_buffer view, int flags*)

Send a request to exporter to fill in view as specified by flags. If the exporter cannot provide a buffer of the exact type, it MUST raise PyExc_BufferError, set view->obj to NULL and return -1.

成功时，填充 view，将 view->obj 设为对 exporter 的新引用并返回 0。 在使用将请求重定向到单一对象的链式缓冲区提供器的情况下，view->obj 可以引用该对象而不是 exporter (参见 )。

PyObject_GetBuffer() 必须与 同时调用成功，类似于 malloc() 和 free()。因此，消费者程序用完缓冲区后， PyBuffer_Release() 必须保证被调用一次。

void PyBuffer_Release( *view)

Release the buffer view and decrement the reference count for view->obj. This function MUST be called when the buffer is no longer being used, otherwise reference leaks may occur.

若该函数针对的缓冲区不是通过 PyObject_GetBuffer() 获得的，将会出错。

Py_ssize_t PyBuffer_SizeFromFormat(const char *)

Return the implied from format. This function is not yet implemented.

int PyBuffer_IsContiguous( *view, char order)

如果 view 定义的内存是 C 风格（order 为 'C'）或 Fortran 风格（order 为 'F'） contiguous 或其中之一（order 是 'A'），则返回 1。否则返回 0。该函数总会成功。

int PyBuffer_ToContiguous(void buf*, src, Py_ssize_t len, char order*)

Copy len bytes from src to its contiguous representation in buf. order can be 'C' or 'F' (for C-style or Fortran-style ordering). 0 is returned on success, -1 on error.

如果 len != src->len 则此函数将报错。

void PyBuffer_FillContiguousStrides(int ndims, Py_ssize_t shape*, Py_ssize_t strides, int itemsize, char order*)

用给定形状的 contiguous 字节串数组 (如果 order 为 'C' 则为 C 风格，如果 order 为 'F' 则为 Fortran 风格) 来填充 strides 数组，每个元素具有给定的字节数。

int PyBuffer_FillInfo( view*, PyObject exporter, void **buf, Py_ssize_t len, int readonly, int flags)

处理导出程序的缓冲区请求，该导出程序要暴露大小为 len 的 buf ，并根据 readonly 设置可写性。bug 被解释为一个无符号字节序列。

参数 flags 表示请求的类型。该函数总是按照 flag 指定的内容填入 view，除非 buf 设为只读，并且 flag 中设置了 标志。

On success, set view->obj to a new reference to exporter and return 0. Otherwise, raise PyExc_BufferError, set view->obj to NULL and return -1;