PEP 209 – 多维阵列 - 腾龙猫勺儿

重要
此 PEP 已被撤回。
×

抽象

该 PEP 建议重新设计和重新实施多维数组模块，Numeric，使其更容易添加模块的新特性和功能。数字 2 的各个方面将受到特别关注的是对阵列的有效访问大小超过 1 GB，由不均匀的数据组成结构或记录。所提出的设计使用了四个 Python 类：ArrayType、UFunc、Array 和 ArrayView;和低级 C-extension 模块，_ufunc，用于处理阵列操作有效。此外，每种数组类型都有自己的 C 扩展名定义强制规则、操作和方法的模块对于该类型。此设计支持新的类型、功能和以模块化方式添加的功能。新版本将引入一些与当前 Numeric 的不兼容之处。

赋予动机

多维数组通常用于存储和操作科学、工程和计算中的数据。Python 目前有一个名为 Numeric（以下称为 Numeric 1）的扩展模块，它为用户提供了一组令人满意的功能操作中等大小（有序）的同构数据数组 10 MB）。对于访问更大的阵列（100 MB 或更多），请可能是不均匀的数据，数字 1 的实现是效率低下且繁琐。将来，由用于附加功能的数字 Python 社区也是可能是 PEP 211：向 Python 添加新的线性运算符，以及 225：Elementwise/Objectwise 运算符说明。

建议

该提案建议重新设计和重新实施数字 1，以下称为数字 2，这将使新的类型、特性和功能要添加到一个简单和模块化方式。数字 2 的初始设计应侧重于提供用于操作各种数组的通用框架类型，并应启用添加新数组类型和 UFuncs。更具体的功能方法然后可以将各种学科分层到该核心之上。这个新模块仍将称为 Numeric，并且大多数在数字 1 中找到的行为将被保留。

建议的设计使用四个 Python 类：ArrayType、UFunc、 Array 和 ArrayView;以及一个低级 C 扩展模块来处理数组高效操作。此外，每个数组类型有自己的 C 扩展模块，用于定义强制规则，操作，以及该类型的方法。在以后的日期，当核心功能稳定，一些 Python 类可以转换为 C 扩展类型。

一些计划的功能包括：

改进了内存使用率
此功能在处理大型数组时尤为重要并且可以显着提高性能以及内存使用情况。我们确定了内存使用情况的几个区域可以改进：

使用局部强制模型
而不是使用 Python 的全局强制模型，该模型创建临时数组，数字 2 和数字 1 一样，将实现 PEP 208 中描述的局部胁迫模型推迟了对经营者的胁迫责任。通过使用内部缓冲区，可以对每个阵列进行强制操作（包括输出数组），如有必要，在操作。基准测试 [1] 表明，性能大多数仅略有退化，并在内部缓冲区小于 L2 缓存大小，并且处理器负载过载。为了完全避免阵列强制，允许在数字 2.
避免创建临时数组
在复杂的数组表达式中（即具有多个数组表达式）操作），每个操作将创建一个临时数组，该数组将被使用，然后由后续操作删除。一个更好的方法是识别这些临时数组并在可能的情况下重用其数据缓冲区，即当数组的形状和类型与临时数组相同创建。这可以通过检查临时数组的引用计数。如果它是 1，那么它将被删除一次操作已完成，并且是重用的候选项。
可选使用内存映射文件
数字用户有时需要从非常大的数据访问数据文件或处理大于可用数据的数据记忆。内存映射数组提供了一种执行此操作的机制通过将数据存储在磁盘上，同时使其看起来位于记忆。内存映射阵列应改善对所有文件，通过消除文件过程中的两个复制步骤之一访问。Numeric 应该能够访问内存中和内存映射数组透明。
记录访问
在某些科学领域，数据以二进制形式存储在文件中记录。例如，在天文学中，光子数据存储为按到达时间顺序排列的光子的 1 维列表。这些记录或类似 C 的结构包含有关检测到的光子，例如它的到达时间、它在探测器及其能量。每个字段可能属于不同的字段类型，例如 char、int 或 float。这样的阵列引入了新的必须处理的问题，特别是字节对齐或者可能需要对数值执行字节交换要正确访问的值（尽管字节交换也是内存映射数据的问题）。数字 2 旨在自动处理对齐和表示问题当数据被访问或操作时。有两个实施记录的方法;作为派生数组类或特殊数组类型，具体取决于您的观点。我们将此讨论推迟到“未解决的问题”部分。

其他阵列类型
数值 1 有 11 种定义的类型：char、ubyte、sbyte、short、int、 long、float、double、cfloat、cdouble 和 object。没有 ushort、uint 或 ulong 类型，也没有更复杂的类型例如对某些科学领域有用的位类型和可能用于实现掩码数组。数字 1 的设计使得添加这些和其他类型变得困难且容易出错的过程。启用轻松添加（和删除）的步骤新的数组类型，例如下面描述的位类型，重新设计的 Numeric 是必要的。
钻头类型
数组之间丰富比较的结果是一个数组布尔值。结果可以存储在以下类型的数组中 char，但这是不必要的内存浪费。一个更好的实现将使用 bit 或 boolean 类型，压缩数组大小是 8 倍。目前，这正在为数字 1（由 Travis Oliphant 实现），并且应该是包含在数字 2 中。
增强的数组索引语法
扩展切片语法已添加到 Python 中，以提供更大的通过允许操作数值数组时的灵活性步长大于 1。这种语法可以很好地用作速记获取规则间隔的索引列表。对于这些情况如果需要不规则间隔的索引列表，则增强数组索引语法将允许一维数组作为参数。
丰富的比较
PEP 207 的实现：Python 2.1 中的丰富比较在操作阵列时提供额外的灵活性。我们打算在数字 2 中实现此功能。
阵列广播规则
当标量和数组之间的操作完成时，隐含的行为是创建一个具有相同形状的新数组包含标量值的数组操作数。这叫做阵列广播。它也适用于较低等级的数组，例如向量。此隐式行为是在 Numeric 中实现的 1，也将在 Numeric 2 中实现。

设计与实施

数值 2 的设计有四个主要类：

数组类型：
这是一个描述基本属性的简单类数组类型，例如它的名称、它的大小（以字节为单位）、它的强制与其他类型的关系等，例如

Int32 = ArrayType('Int32', 4, 'doc-string')

它与其他类型的关系是在 C 扩展时定义的导入该类型的模块。对应的 Python 代码是：

Int32.astype[Real64] = Real64

这表示 Real64 数组类型的优先级高于 Int32 数组类型。

针对核心提出了以下属性和方法实现。可以在单个基础，例如位类型的 .bitsize 或 .bitstrides。

属性：

.name:                  e.g. "Int32", "Float64", etc.
.typecode:              e.g. 'i', 'f', etc.
                        (for backward compatibility)
.size (in bytes):       e.g. 4, 8, etc.
.array_rules (mapping): rules between array types
.pyobj_rules (mapping): rules between array and python types
.doc:                   documentation string

方法：

__init__():             initialization
__del__():              destruction
__repr__():             representation

C-API：这仍然需要充实。

UFunc：

这个类是数字 2 的核心。它的设计类似于 ArrayType 的 UFunc 创建一个单一实例可调用对象，其属性为 name、total 和 input number 参数、文档字符串和空 CFunc 字典;例如：

add = UFunc('add', 3, 2, 'doc-string')

定义后，add 实例没有与因此，它不能做任何工作。CFunc 字典是稍后填充或注册 C 扩展模块时 array-type 被导入。register 方法的参数为：函数名称、函数描述符和 CUFunc 对象。这对应的 Python 代码是

add.register('add', (Int32, Int32, Int32), cfunc-add)

在数组类型模块的初始化函数中，例如 Int32，有两个 C API 函数：一个用于初始化强制规则，另一个用于注册 CFunc 对象。

当操作应用于某些数组时，该方法被调用。它获取每个数组的类型（如果输出数组不是给出的，它是根据强制规则创建的）和检查与参数类型匹配的键的 CFunc 字典。如果存在，则立即执行操作，否则强制规则用于搜索相关操作并设置的转换函数。然后，该方法调用用 C 编写的计算方法，用于遍历每个数组的切片，即：__call____call__

_ufunc.compute(slice, data, func, swap, conv)

'func' 参数是 CFuncObject，而 'swap' 和 'conv' 参数是那些需要 pre- 或后处理，否则使用“无”。data 参数为缓冲区对象的列表，Slice 参数给出数字每个维度的迭代次数以及缓冲区偏移量和每个数组和每个维度的步长。

我们预定义了几个 UFunc，供该方法使用： cast、swap、getobj 和 setobj。强制转换和交换功能可以胁迫和字节交换，分别是 getobj 和 setobj 函数在数值数组和 Python 序列之间执行强制。__call__

针对核心提出了以下属性和方法实现。

属性：

.name:                  e.g. "add", "subtract", etc.
.nargs:                 number of total arguments
.iargs:                 number of input arguments
.cfuncs (mapping):      the set C functions
.doc:                   documentation string

方法：

__init__():             initialization
__del__():              destruction
__repr__():             representation
__call__():             look-up and dispatch method
initrule():             initialize coercion rule
uninitrule():           uninitialize coercion rule
register():             register a CUFunc
unregister():           unregister a CUFunc

C-API：这仍然需要充实。

数组：

此类包含有关数组的信息，例如 shape、类型、数据的字节序等。它的运算符 '+'， '-'，等等，只需调用相应的 UFunc 函数，例如

def __add__(self, other):
    return ufunc.add(self, other)

提出了以下属性、方法和功能核心实现。

属性：

.shape:                 shape of the array
.format:                type of the array
.real (only complex):   real part of a complex array
.imag (only complex):   imaginary part of a complex array

方法：

__init__():             initialization
__del__():              destruction
__repr_():              representation
__str__():              pretty representation
__cmp__():              rich comparison
__len__():
__getitem__():
__setitem__():
__getslice__():
__setslice__():
numeric methods:
copy():                 copy of array
aslist():               create list from array
asstring():             create string from array

功能：

fromlist():             create array from sequence
fromstring():           create array from string
array():                create array with shape and value
concat():               concatenate two arrays
resize():               resize array

C-API：这仍然需要充实。
数组视图
此类类似于 Array 类，只是 reshape 而扁平方法将引发异常，因为非连续数组不能仅使用指针和步长信息。
C-API：这仍然需要充实。
C-扩展模块：
Numeric2 将有几个 C 扩展模块。

_ufunc：
此集合的主要模块是 _ufuncmodule.c。这本模块的目的是做最低限度的工作，即使用指定的 C 函数遍历数组。这这些函数的接口与数字 1 相同，即
```
int (*CFunc)(char *data, int *steps, int repeat, void *func);
```
并且它们的功能应该是相同的，即它们遍历最内层的维度。
针对核心提出了以下属性和方法实现。
属性：
方法：
```
compute():
```
C-API：这仍然需要充实。
_int32、_real64等：
每种阵列类型还将有 C 扩展模块，例如 _int32module.c、_real64module.c 等。如前所述以前，当这些模块由 UFunc 导入时模块，它们将自动注册其功能和胁迫规则。这些模块的新版本或改进版本可以易于实现和使用，而不会影响其余部分数字 2.

未解决的问题

切片语法是否默认为复制或查看行为？
Python 的默认行为是返回子列表的副本或元组（当使用切片语法时），而数字 1 返回查看数组。为数字 1 所做的选择显然是出于性能原因：开发人员希望避免在每次分配和复制数据缓冲区的惩罚数组操作，并觉得需要对数组进行深层拷贝很少见。然而，一些人认为 Numeric 的切片符号还应该具有与 Python 列表一致的复制行为。在这种情况下，与复制行为相关的性能损失可以通过实现写入时复制来最小化。该计划具有两个数组共享一个数据缓冲区（如视图行为），直到为任一数组分配新数据，此时建立数据缓冲区。然后，视图行为将通过以下方式实现一个 ArrayView 类，其行为类似于 Numeric 1 数组，即 .shape 不能为非连续数组设置。使用 ArrayView 类还明确了数组的数据类型包含。
项语法是否默认为复制或查看行为？
项目语法也出现了类似的问题。例如，如果和，则更改也会更改，因为是 a 的第一行的引用或视图。因此，如果 c 是一个二维数组，那么它似乎应该返回一个一维数组，该数组是视图，而不是副本的，c 表示一致性。然而，可以认为只是一个简写意味着复制行为假设切片语法返回一个副本。数字 2 的行为是否相同方式作为列表并返回视图，或者它应该返回副本。a = [[0,1,2], [3,4,5]]b = a[0]b[0]a[0][0]a[0]c[i]c[i]c[i,:]
如何实现标量强制？
Python 的数值类型比 Numeric 少，这可能会导致胁迫问题。例如，在乘以 Python 标量时类型 float 和 float 类型的数值数组，即 Numeric 数组转换为 double，因为 Python float 类型实际上是一个双倍。这通常不是所需的行为，因为数值数组的大小将增加一倍，很可能是烦人，特别是对于非常大的数组。我们更希望数组类型胜过相同类型类的 Python 类型，即整数、浮点数和复数。因此，在 Python 整数和 Int16（短）数组将返回 Int16 数组。而 Python 浮点数和 Int16 之间的操作 array 将返回一个 Float64（双精度）数组。之间的操作两个数组使用正常的强制规则。
如何处理整数除法？
在 Python 的未来版本中，整数除法的行为会改变。操作数将转换为浮点数，因此结果将是一个浮点数。如果我们实现建议的标量数组优先于 Python 标量的强制规则，然后将数组除以整数将返回一个整数数组并且不会与 Python 的未来版本不一致将返回 double 类型的数组。科学程序员是熟悉整数和浮点数之间的区别除法，那么数字 2 是否应该继续这种行为？
记录应该如何实施？
有两种方法可以实现记录，具体取决于您的观点。第一种是将两个除法阵列分成单独的数组类取决于其类型的行为。例如数值数组是一个类，字符串是第二个类，记录一个第三，因为每个类的操作范围和类型不同。因此，记录数组不是一种新类型，而是更灵活的数组形式的机制。为了方便访问和处理如此复杂的数据，该类由数值组成在数据缓冲区中具有不同字节偏移量的数组。为例如，可能有一个由 Int16 数组组成的表， Real32 值。两个数值数组，一个偏移量为 0 字节一个 6 个字节的步幅被解释为 Int16，一个字节的步幅是偏移量为 2 个字节，步幅为 6 个字节，解释为 Real32 将表示记录数组。两个数值数组将引用相同的数据缓冲区，但具有不同的偏移量和步幅属性和不同的数值类型。
第二种方法是将记录视为多个数组之一类型，尽管数组操作较少，而且可能不同比数值数组。此方法将数组类型视为是固定长度字符串的映射。映射可以是简单，如整数和浮点数，或复杂，如复数、字节字符串和 C 结构。记录 type 有效地将 struct 和 Numeric 模块合并到多维结构数组。这种方法意味着某些对数组接口的更改。例如，“typecode” 关键字参数可能应该更改为更多描述性“format”关键字。

如何定义和实现记录语义？
无论采用哪种实施方法进行记录，都如何访问它们的语法和语义，以及如果一个人希望获得记录的子字段。在这种情况下，记录类型可以本质上被认为是一个不齐质的列表，就像一个元组由 struct 模块的 unpack 方法返回;和 1-D 记录数组可以解释为具有第二个维度是字段列表的索引。这种增强的数组语义使得访问一个数组或更多的字段简单明了。它还允许用户在自然的字段上执行数组操作和直观的方式。如果我们假设记录是实现的作为数组类型，则 last dimension 默认为 0 并且可以因此，对于由简单类型组成的数组，可以忽略不计，就像数字一样。

掩码数组是如何实现的？
数值 1 中的掩码数组作为单独的数组实现类。由于能够向数值 2 添加新的数组类型，它可以实现数值 2 中的掩码数组作为新的数组类型，而不是数组类。
如何处理数值错误（IEEE 浮点错误特别）？
提议者（保罗·巴雷特和特拉维斯）不清楚 Oliphant）处理错误的最佳或首选方法是什么。由于大多数执行操作的 C 函数都进行了迭代数组的最内层（最后）维度。这个维度可能包含一千个或更多具有一个或多个错误的项目不同类型的，例如除以零、下溢和溢出。此外，跟踪这些错误可能会出现在性能的代价。因此，我们建议几个选项：

打印最严重错误的消息，将其留给用户来查找错误。
打印一条包含发生的所有错误和数字的消息的发生次数，让用户来定位错误。
打印发生的所有错误的消息以及它们发生的地方。
或者使用混合方法，只打印最严重的错误，但要跟踪错误的内容和位置发生。这将允许用户找到错误同时保持错误消息简短。

需要哪些功能来简化 FORTRAN 的集成库和代码？

在这个阶段，考虑如何缓解在 Numeric 2 中集成 FORTRAN 库和用户代码。

实施步骤

实现基本的 UFunc 功能

Minimal Array 类：
必要的类属性和方法，例如 .shape、.data、 .type 等。
Minimal ArrayType 类：
Int32、Real64、Complex64、Char、Object
最小 UFunc 类：
UFunc 实例化、CFunction 注册、UFunc 调用一维数组，包括用于对齐的规则，字节交换和胁迫。
最小的 C 扩展模块：
_UFunc，它在 C 中执行最内层的数组循环。
此步骤实现需要执行的任何操作：'c = add（a， b）' 其中 a、b 和 c 是一维数组。它教我们如何添加新的 UFuncs，以强制数组，传递必要的信息到 C 迭代器方法并实际执行计算。

继续增强 UFunc 迭代器和 Array 类

实现 Array 类的一些访问方法： print、repr、getitem、setitem 等。
实现多维数组
使用 UFuncs 实现一些基本的 Array 方法： +、-、*、/等
使 UFuncs 能够使用 Python 序列。

完成标准的 UFunc 和 Array 类行为

实现 getslice 和 setslice 行为
处理阵列广播规则
实现记录类型

添加其他功能

添加更多 UFuncs
实现缓冲区或 mmap 访问

不兼容

以下是行为不兼容的列表数字 1 和数字 2。

标量强制规则
数值 1 具有一组用于数组和 Python 的强制规则数值类型。这可能会导致意外和烦人的问题在数组表达式的计算过程中。数字 2 打算通过制定两套强制规则来克服这些问题：一个用于数组和 Python 数值类型，另一个仅用于阵列。
无 savespace 属性
数值 1 中的 savespace 属性使用以下数组创建数组属性集优先于未设置属性集的属性集。数字 2 不会有这样的属性，因此是正常的阵列强制规则将生效。
切片语法返回副本
数值 1 中的切片语法返回原始视图数组。数字 2 的切片行为将是副本。你应使用 ArrayView 类将视图获取到数组中。
布尔比较返回布尔数组
数值 1 中数组之间的比较得到一个布尔值标量，因为 Python 中的当前限制。的出现 Python 2.1 中的丰富比较将允许布尔数组被退回。
不推荐使用类型字符
数值 2 将具有一个由 Type 实例组成的 ArrayType 类，例如，有符号整数的 Int8、Int16、Int32 和 Int。这数字 1 中的类型代码方案将可用于向后兼容性，但将被弃用。

附录

隐式子数组迭代
计算机动画由许多二维图像或相同形状的框架。通过将这些图像堆叠成一个内存块，则创建一个 3-D 数组。然而，操作是执行的不是针对整个 3-D 阵列，而是在现场执行的二维子阵列。在大多数数组语言中，每个帧都必须是提取、操作，然后重新插入到输出数组中使用 for 类循环。J 语言允许程序员通过为帧设置等级来隐式执行此类操作和数组。默认情况下，这些排名在创建数组。这是数字 1 的意图开发人员来实现此功能，因为它基于语言 J.数字 1 代码具有所需的变量实现此行为，但从未实现。我们打算在数值 2 中实现隐式子数组迭代，如果数值 1 中的数组广播规则不完全支持此行为。