NumPy 记录数组

numpy 提供了一个 ndarray 子类， numpy.recarray它允许通过属性而不是仅通过索引访问结构化数组的字段。记录数组使用特殊的数据类型 ，numpy.record允许按属性访问从数组中获得的结构化标量。该numpy.rec模块提供了从各种对象创建重新数组的功能。用于创建和操作结构化数组的其他辅助函数可以在numpy.lib.recfunctions.

创建记录数组的最简单方法是numpy.rec.array：

>>> recordarr = np.rec.array([(1, 2., 'Hello'), (2, 3., "World")],
...                    dtype=[('foo', 'i4'),('bar', 'f4'), ('baz', 'S10')])
>>> recordarr.bar
array([ 2.,  3.], dtype=float32)
>>> recordarr[1:2]
rec.array([(2, 3., b'World')],
      dtype=[('foo', '<i4'), ('bar', '<f4'), ('baz', 'S10')])
>>> recordarr[1:2].foo
array([2], dtype=int32)
>>> recordarr.foo[1:2]
array([2], dtype=int32)
>>> recordarr[1].baz
b'World'

numpy.rec.array 可以将各种参数转换为记录数组，包括结构化数组：

>>> arr = np.array([(1, 2., 'Hello'), (2, 3., "World")],
...             dtype=[('foo', 'i4'), ('bar', 'f4'), ('baz', 'S10')])
>>> recordarr = np.rec.array(arr)

该numpy.rec模块提供了许多用于创建记录数组的其他便利函数，请参阅记录数组创建例程。

可以使用适当的视图获得结构化数组的记录数组表示：

>>> arr = np.array([(1, 2., 'Hello'), (2, 3., "World")],
...                dtype=[('foo', 'i4'),('bar', 'f4'), ('baz', 'a10')])
>>> recordarr = arr.view(dtype=np.dtype((np.record, arr.dtype)),
...                      type=np.recarray)

为方便起见，将 ndarray 视为类型numpy.recarray将自动转换为numpy.record数据类型，因此可以将dtype排除在视图之外：

>>> recordarr = arr.view(np.recarray)
>>> recordarr.dtype
dtype((numpy.record, [('foo', '<i4'), ('bar', '<f4'), ('baz', 'S10')]))

要回到普通的 ndarray 必须重置 dtype 和类型。以下视图这样做，考虑到 recordarr 不是结构化类型的异常情况：

>>> arr2 = recordarr.view(recordarr.dtype.fields or recordarr.dtype, np.ndarray)

如果字段具有结构化类型，则通过索引或属性访问的记录数组字段将作为记录数组返回，否则作为普通 ndarray 返回。

>>> recordarr = np.rec.array([('Hello', (1, 2)), ("World", (3, 4))],
...                 dtype=[('foo', 'S6'),('bar', [('A', int), ('B', int)])])
>>> type(recordarr.foo)
<class 'numpy.ndarray'>
>>> type(recordarr.bar)
<class 'numpy.recarray'>

请注意，如果字段与 ndarray 属性同名，则 ndarray 属性优先。这些字段将无法通过属性访问，但仍可通过索引访问。

重新排列辅助函数

用于操作结构化数组的实用程序集合。

大多数这些函数最初是由 John Hunter 为 matplotlib 实现的。为方便起见，它们已被重写和扩展。 numpy.lib.recfunctions。 append_fields ( base , names , data , dtypes = None , fill_value = - 1 , usemask = True , asrecarray = False )[来源]

向现有数组添加新字段。

字段的名称由名称参数给出，对应的值由数据参数给出。如果附加单个字段，则names、data和dtypes不必是列表而只是值。

&参数:
&&基本: 数组
&&&要扩展的输入数组。

&&名称: 字符串，序列
&&&与新字段名称对应的字符串或字符串序列。

&&数据：数组或数组序列
&&&数组或数组序列存储要添加到基的字段。

&&dtypes: 数据类型序列，可选
&&&数据类型或数据类型序列。如果为 None，则数据类型是从data估计的。

&&fill_value: {float}，可选
&&&填充值用于填充较短数组上的缺失数据。

&&usemask: {False, True}, 可选
&&&是否返回掩码数组。

&&asrecarray: {False, True}, 可选
&&&是否返回重新数组（MaskedRecords）。

numpy.lib.recfunctions。apply_along_fields ( func , arr )[来源]

应用函数 'func' 作为跨结构化数组字段的约简。

这类似于apply_along_axis，但将结构化数组的字段视为额外的轴。根据numpy.result_type 应用于字段的 dtypes的类型提升规则，这些字段首先全部转换为通用类型。

&参数:
&&func: 函数
&&&应用于“字段”维度的函数。此函数必须支持轴参数，例如 np.mean、np.sum 等。

&&ARR: ndarray
&&&;对其应用 func 的结构化数组。

&退货:出:数组
&&&切割操作的结果

例子

>>> from numpy.lib import recfunctions as rfn
>>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
...              dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
>>> rfn.apply_along_fields(np.mean, b)
array([ 2.66666667,  5.33333333,  8.66666667, 11.        ])
>>> rfn.apply_along_fields(np.mean, b[['x', 'z']])
array([ 3. ,  5.5,  9. , 11. ])

numpy.lib.recfunctions。assign_fields_by_name ( dst , src , zero_unassigned = True )[来源]

按字段名称将值从一个结构化数组分配给另一个。

通常在 numpy &= 1.14 中，将一个结构化数组分配给另一个“按位置”复制字段，这意味着 src 中的第一个字段被复制到 dst 的第一个字段，依此类推，无论字段名称如何。

该函数改为“按字段名称”复制，这样 dst 中的字段是从 src 中的同名字段分配的。这递归地适用于嵌套结构。这就是结构赋值在 numpy &= 1.6 到 <= 1.13 中的工作方式。

&参数:
&&dst: 数组
&&SRC: ndarray
&&&分配期间的源数组和目标数组。

&&zero_unassigned :bool，可选
&&&如果为 True，则 dst 中在 src 中没有匹配字段的字段将填充值 0（零）。这是 numpy <= 1.13 的行为。如果为 False，则不会修改这些字段。

numpy.lib.recfunctions。drop_fields ( base , drop_names , usemask = True , asrecarray = False )[来源]

返回一个新数组，其中drop_names 中的字段已删除。

支持嵌套字段。

在 1.18.0 版更改：drop_fields如果删除所有字段，则返回一个包含 0 个字段的数组，而不是None像以前那样返回。

&参数:
&&基本:数组
&&&输入数组

&&drop_names:字符串或序列
&&&与要删除的字段名称相对应的字符串或字符串序列。

&&usemask : {False, True}, 可选
&&&是否返回掩码数组。

&&asrecarray :字符串或序列，可选
&&&是否返回 recarray 或 mrecarray ( asrecarray=True ) 或普通 ndarray 或具有灵活 dtype 的掩码数组。默认值为假。

例子

>>> from numpy.lib import recfunctions as rfn
>>> a = np.array([(1, (2, 3.0)), (4, (5, 6.0))],
...   dtype=[('a', np.int64), ('b', [('ba', np.double), ('bb', np.int64)])])
>>> rfn.drop_fields(a, 'a')
array([((2., 3),), ((5., 6),)],
      dtype=[('b', [('ba', '<f8'), ('bb', '<i8')])])
>>> rfn.drop_fields(a, 'ba')
array([(1, (3,)), (4, (6,))], dtype=[('a', '<i8'), ('b', [('bb', '<i8')])])
>>> rfn.drop_fields(a, ['ba', 'bb'])
array([(1,), (4,)], dtype=[('a', '<i8')])

numpy.lib.recfunctions。find_duplicates ( a , key = None , ignoremask = True , return_index = False )[来源]

沿着给定的键在结构化数组中查找重复项

&参数:
&&类似: 数组
&&&输入数组

&& 键: {字符串，无}，可选
&&&沿其检查重复项的字段的名称。如果没有，则按记录执行搜索

&&忽略掩码: {True, False}，可选
&&&是否应丢弃屏蔽数据或将其视为重复数据。

&&return_index: {False, True}，可选
&&&是否返回重复值的索引。

例子

>>> from numpy.lib import recfunctions as rfn
>>> ndtype = [('a', int)]
>>> a = np.ma.array([1, 1, 1, 2, 2, 3, 3],
...         mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype)
>>> rfn.find_duplicates(a, ignoremask=True, return_index=True)
(masked_array(data=[(1,), (1,), (2,), (2,)],
             mask=[(False,), (False,), (False,), (False,)],
       fill_value=(999999,),
            dtype=[('a', '<i8')]), array([0, 1, 3, 4]))

numpy.lib.recfunctions。flatten_descr ( ndtype )[来源]

扁平化结构化数据类型描述。

例子

>>> from numpy.lib import recfunctions as rfn
>>> ndtype = np.dtype([('a', '<i4'), ('b', [('ba', '<f8'), ('bb', '<i4')])])
>>> rfn.flatten_descr(ndtype)
(('a', dtype('int32')), ('ba', dtype('float64')), ('bb', dtype('int32')))

numpy.lib.recfunctions。get_fieldstructure ( adtype , lastname = None , parents = None )[来源]

返回一个字典，其中包含其父字段的字段索引列表。

此函数用于简化对嵌套在其他字段中的字段的访问。

&参数:
&&adtype: np.dtype
&&&输入数据类型

&&姓氏: 可选
&&&最后处理的字段名称（在递归期间内部使用）。

&&父母: 字典
&&&父字段字典（在递归期间相互使用）。

例子

>>> from numpy.lib import recfunctions as rfn
>>> ndtype =  np.dtype([('A', int),
...                     ('B', [('BA', int),
...                            ('BB', [('BBA', int), ('BBB', int)])])])
>>> rfn.get_fieldstructure(ndtype)
... # XXX: possible regression, order of BBA and BBB is swapped
{'A': [], 'B': [], 'BA': ['B'], 'BB': ['B'], 'BBA': ['B', 'BB'], 'BBB': ['B', 'BB']}

numpy.lib.recfunctions。get_names（adtype，详情）[来源]

以元组形式返回输入数据类型的字段名称。

&参数:
&&adtype，详情: D型
&&&输入数据类型

例子

>>> from numpy.lib import recfunctions as rfn
>>> rfn.get_names(np.empty((1,), dtype=int))
Traceback (most recent call last):
    ...
AttributeError: 'numpy.ndarray' object has no attribute 'names'

>>> rfn.get_names(np.empty((1,), dtype=[('A',int), ('B', float)]))
Traceback (most recent call last):
    ...
AttributeError: 'numpy.ndarray' object has no attribute 'names'
>>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
>>> rfn.get_names(adtype)
('a', ('b', ('ba', 'bb')))

numpy.lib.recfunctions。get_names_flat ( adtype )[来源]

以元组形式返回输入数据类型的字段名称。嵌套结构预先展平。
&参数:
&&adtype，详情: D型
&&&输入数据类型

例子

>>> from numpy.lib import recfunctions as rfn
>>> rfn.get_names_flat(np.empty((1,), dtype=int)) is None
Traceback (most recent call last):
    ...
AttributeError: 'numpy.ndarray' object has no attribute 'names'
>>> rfn.get_names_flat(np.empty((1,), dtype=[('A',int), ('B', float)]))
Traceback (most recent call last):
    ...
AttributeError: 'numpy.ndarray' object has no attribute 'names'
>>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
>>> rfn.get_names_flat(adtype)
('a', 'b', 'ba', 'bb')

numpy.lib.recfunctions。join_by ( key , r1 , r2 , jointype = 'inner' , r1postfix = '1' , r2postfix = '2' , defaults = None , usemask = True , asrecarray = False )[来源]

在键key上连接数组r1和r2。

键应该是与用于连接数组的字段相对应的字符串或字符串序列。如果在两个输入数组中找不到键字段，则会引发异常 。r1和 r2都不应该在key 上有任何重复项：重复项的存在会使输出非常不可靠。请注意，算法不会查找重复项。
&参数:
&&键: {字符串，序列}
&&&与用于比较的字段对应的字符串或字符串序列。

&&r1, r2: 数组
&&&结构化数组。

&&jointype: {'inner', 'outer', 'leftouter'}，可选
&&&如果为 'inner'，则返回 r1 和 r2 共有的元素。如果为 'outer'，则返回公共元素以及不在 r2 中的 r1 元素和不在 r2 中的元素。如果为 'leftouter'，则返回公共元素和 r1 中不在 r2 中的元素。

&&r1postfix： 字符串，可选**
&&&附加到 r1 中存在于 r2 中但没有键的字段名称的字符串。

&&r2postfix: 字符串，可选
&&&附加到 r2 中存在于 r1 中但缺少键的字段名称的字符串。

&&默认值: {dictionary}，可选
&&&字典将字段名称映射到相应的默认值。

&&使用掩码: {True, False}，可选
&&&是返回 MaskedArray （或 MaskedRecords 是 asrecarray==True）还是 ndarray。

&&asrecarray : {False, True}, 可选
&&&是否返回 recarray （或 MaskedRecords 如果usemask==True）或只是一个灵活类型的 ndarray。

笔记

• 输出按键排序。
• 通过删除不在两个数组的键中的字段并将结果连接起来，形成一个临时数组。然后对该数组进行排序，并选择公共条目。通过使用所选条目填充字段来构建输出。如果有一些重复项，则不会保留匹配...

numpy.lib.recfunctions。merge_arrays ( seqarrays , fill_value = - 1 , flatten = False , usemask = False , asrecarray = False )[来源]

按字段合并数组。

&参数:
&&seqarrays ndarrays: 序列
&&&数组序列

&&fill_value: {float}，可选
&&&填充值用于填充较短数组上的缺失数据。

&&展平: {假，真}，可选
&&&是否折叠嵌套字段。

&&usemask: {False, True}, 可选
&&&是否返回掩码数组。

&&asrecarray: {False, True}, 可选
&&&是否返回重新数组（MaskedRecords）。

笔记

如果没有掩码，缺失值将被填充，具体取决于其对应的类型：

• -1 对于整数
• -1.0 对于浮点数
• '-' 对于字符
• '-1' 对于字符串
• True 对于布尔值

XXX：我只是凭经验获得这些值

例子

>>> from numpy.lib import recfunctions as rfn
>>> rfn.merge_arrays((np.array([1, 2]), np.array([10., 20., 30.])))
array([( 1, 10.), ( 2, 20.), (-1, 30.)],
      dtype=[('f0', '<i8'), ('f1', '<f8')])






>>> rfn.merge_arrays((np.array([1, 2], dtype=np.int64),
...         np.array([10., 20., 30.])), usemask=False)
 array([(1, 10.0), (2, 20.0), (-1, 30.0)],
         dtype=[('f0', '<i8'), ('f1', '<f8')])
>>> rfn.merge_arrays((np.array([1, 2]).view([('a', np.int64)]),
...               np.array([10., 20., 30.])),
...              usemask=False, asrecarray=True)
rec.array([( 1, 10.), ( 2, 20.), (-1, 30.)],
          dtype=[('a', '<i8'), ('f1', '<f8')])

numpy.lib.recfunctions。rec_append_fields ( base , names , data , dtypes = None )[来源]

向现有数组添加新字段。

字段的名称由名称参数给出，对应的值由数据参数给出。如果附加单个字段，则names、data和dtypes不必是列表而只是值。

&参数:
&&基本: 数组
&&&要扩展的输入数组。

&&名称: 字符串，序列
&&&与新字段名称对应的字符串或字符串序列。

&&数据: 数组或数组序列
&&&数组或数组序列存储要添加到基的字段。

&&dtypes: 数据类型序列，可选
&&&数据类型或数据类型序列。如果为 None，则数据类型是从data估计的。

&退货: appended_array : np.recarray

numpy.lib.recfunctions。rec_drop_fields ( base , drop_names )[来源]

返回一个新的 numpy.recarray，其中 drop_names 中的字段已删除。

numpy.lib.recfunctions。rec_join ( key , r1 , r2 , jointype = 'inner' , r1postfix = '1' , r2postfix = '2' , defaults = None )[来源]

在键上连接数组r1和r2。join_by 的替代方法，它总是返回一个 np.recarray。

numpy.lib.recfunctions。recursive_fill_fields（输入，输出）[来源]

使用输入字段填充输出字段，支持嵌套结构。

&参数:
&&输入: 数组
&&&输入数组。

&&输出:数组
&&&输出数组。

笔记

输出应至少与输入大小相同

例子

>>> from numpy.lib import recfunctions as rfn
>>> a = np.array([(1, 10.), (2, 20.)], dtype=[('A', np.int64), ('B', np.float64)])
>>> b = np.zeros((3,), dtype=a.dtype)
>>> rfn.recursive_fill_fields(a, b)
array([(1, 10.), (2, 20.), (0,  0.)], dtype=[('A', '<i8'), ('B', '<f8')])

numpy.lib.recfunctions。rename_fields ( base , namemapper )[来源]从灵活数据类型 ndarray 或 recarray 重命名字段。 支持嵌套字段。 参数基础数组必须修改其字段的输入数组。 名称映射字典将旧字段名称映射到新版本的字典。 例子

>>> from numpy.lib import recfunctions as rfn
>>> a = np.array([(1, (2, [3.0, 30.])), (4, (5, [6.0, 60.]))],
...   dtype=[('a', int),('b', [('ba', float), ('bb', (float, 2))])])
>>> rfn.rename_fields(a, {'a':'A', 'bb':'BB'})
array([(1, (2., [ 3., 30.])), (4, (5., [ 6., 60.]))],
      dtype=[('A', '<i8'), ('b', [('ba', '<f8'), ('BB', '<f8', (2,))])])

numpy.lib.recfunctions。repack_fields ( a , align = False , recurse = False )[来源]

在内存中重新打包结构化数组或 dtype 的字段。

结构化数据类型的内存布局允许任意字节偏移的字段。这意味着字段可以由填充字节分隔，它们的偏移量可以非单调增加，并且它们可以重叠。

此方法删除任何重叠并重新排序内存中的字段，使它们具有增加的字节偏移量，并根据align选项添加或删除填充字节，其行为类似于align选项np.dtype。

如果align=False，则此方法会生成“打包”内存布局，其中每个字段从前一个字段结束的字节开始，并删除任何填充字节。

如果align=True，则此方法通过根据需要添加填充字节来生成“对齐”内存布局，其中每个字段的偏移量是其对齐方式的倍数，并且总项目大小是最大对齐方式的倍数。

&参数
&&一个: ndarray 或 dtype
&&&要为其重新打包字段的数组或数据类型。

&&对齐: 布尔值
&&&如果为 true，则使用“对齐”内存布局，否则使用“打包”布局。

&&递归: 布尔值
&&&如果为 True，还重新打包嵌套结构。

&退货:
&&重新: 打包的 ndarray 或 dtype
&&&拷贝一个带有字段重新包装，或者一个本身，如果需要重新包装没有。

例子

>>> from numpy.lib import recfunctions as rfn
>>> def print_offsets(d):
...     print("offsets:", [d.fields[name][1] for name in d.names])
...     print("itemsize:", d.itemsize)
...
>>> dt = np.dtype('u1, <i8, <f8', align=True)
>>> dt
dtype({'names':['f0','f1','f2'], 'formats':['u1','<i8','<f8'], 'offsets':[0,8,16], 'itemsize':24}, align=True)
>>> print_offsets(dt)
offsets: [0, 8, 16]
itemsize: 24
>>> packed_dt = rfn.repack_fields(dt)
>>> packed_dt
dtype([('f0', 'u1'), ('f1', '<i8'), ('f2', '<f8')])
>>> print_offsets(packed_dt)
offsets: [0, 1, 9]
itemsize: 17

numpy.lib.recfunctions。require_fields（数组， required_dtype）[来源]

使用按字段名称赋值将结构化数组转换为新的数据类型。

此函数按名称从旧数组分配给新数组，因此输出数组中字段的值是源数组中同名字段的值。这具有创建仅包含 required_dtype 的“必需”字段的新 ndarray 的效果。

如果 required_dtype 中的字段名称在输入数组中不存在，则会在输出数组中创建该字段并将其设置为 0。
&参数
&&一个: 数组
&&&要投射的数组

&&required_dtype: D型
&&&输出数组的数据类型

&退货
&&出: 数组
&&&具有新 dtype 的数组，字段值从输入数组中的同名字段复制

例子

>>> from numpy.lib import recfunctions as rfn
>>> a = np.ones(4, dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'u1')])
>>> rfn.require_fields(a, [('b', 'f4'), ('c', 'u1')])
array([(1., 1), (1., 1), (1., 1), (1., 1)],
  dtype=[('b', '<f4'), ('c', 'u1')])
>>> rfn.require_fields(a, [('b', 'f4'), ('newf', 'u1')])
array([(1., 0), (1., 0), (1., 0), (1., 0)],
  dtype=[('b', '<f4'), ('newf', 'u1')])

numpy.lib.recfunctions。stack_arrays（阵列，默认=无， usemask =真， asrecarray =假，自动转换=假）[来源]按字段叠加数组字段 参数数组数组或序列输入数组的序列。 默认字典，可选字典将字段名称映射到相应的默认值。 使用掩码{True, False}，可选是返回 MaskedArray （或 MaskedRecords 是 asrecarray==True）还是 ndarray。 asrecarray {False, True}, 可选是否返回 recarray （或 MaskedRecords 如果usemask==True）或只是一个灵活类型的 ndarray。 自动转换{假，真}，可选是否自动将字段的类型转换为最大值。 例子

>>> from numpy.lib import recfunctions as rfn
>>> x = np.array([1, 2,])
>>> rfn.stack_arrays(x) is x
True
>>> z = np.array([('A', 1), ('B', 2)], dtype=[('A', '|S3'), ('B', float)])
>>> zz = np.array([('a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)],
...   dtype=[('A', '|S3'), ('B', np.double), ('C', np.double)])
>>> test = rfn.stack_arrays((z,zz))
>>> test
masked_array(data=[(b'A', 1.0, --), (b'B', 2.0, --), (b'a', 10.0, 100.0),
                   (b'b', 20.0, 200.0), (b'c', 30.0, 300.0)],
             mask=[(False, False,  True), (False, False,  True),
                   (False, False, False), (False, False, False),
                   (False, False, False)],
       fill_value=(b'N/A', 1.e+20, 1.e+20),
            dtype=[('A', 'S3'), ('B', '<f8'), ('C', '<f8')])

numpy.lib.recfunctions。Structured_to_unstructured ( arr , dtype = None , copy = False , cast = 'unsafe' )[来源]

将 nD 结构化数组转换为 (n+1)-D 非结构化数组。

新数组将有一个新的最后一个维度，其大小等于输入数组的字段元素数。如果未提供，则输出数据类型由应用于所有字段数据类型的 numpy 类型提升规则确定。

嵌套字段以及任何子数组字段的每个元素都算作单个字段元素。

&参数:
&&ARR: ndarray
&&&要转换的结构化数组或数据类型。不能包含对象数据类型。

&&dtype: dtype，可选
&&&输出非结构化数组的 dtype。

&&复制: 布尔值，可选
&&&请参阅将参数复制到ndarray.astype. 如果为 true，则始终返回副本。如果为 false，并且满足dtype要求，则返回视图。

&&铸造: {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}，可选
&&&参见 的铸造参数ndarray.astype。控制可能发生的数据类型转换。

&退货:
&&非结构化:数组
&&&多一维的非结构化数组。

例子

>>> from numpy.lib import recfunctions as rfn
>>> a = np.zeros(4, dtype=[('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)])
>>> a
array([(0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.]),
       (0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.])],
      dtype=[('a', '<i4'), ('b', [('f0', '<f4'), ('f1', '<u2')]), ('c', '<f4', (2,))])
>>> rfn.structured_to_unstructured(a)
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])






>>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
...              dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
>>> np.mean(rfn.structured_to_unstructured(b[['x', 'z']]), axis=-1)
array([ 3. ,  5.5,  9. , 11. ])

numpy.lib.recfunctions。unstructured_to_structured ( arr , dtype = None , names = None , align = False , copy = False , cast = 'unsafe' )[来源]

将 nD 非结构化数组转换为 (n-1)-D 结构化数组。

输入数组的最后一维被转换为一个结构体，其字段元素的数量等于输入数组最后一维的大小。默认情况下，所有输出字段都具有输入数组的 dtype，但可以提供具有相同字段元素数量的输出结构化 dtype。

嵌套字段以及任何子数组字段的每个元素都计入字段元素的数量。

&参数:
&&ARR: ndarray
&&&要转换的非结构化数组或数据类型。

&&dtype: dtype，可选
&&&输出数组的结构化数据类型

&&名称: 字符串列表，可选
&&&如果未提供 dtype，则按顺序指定输出 dtype 的字段名称。字段 dtypes 将与输入数组相同。

&&对齐: 布尔值，可选
&&&是否创建对齐的内存布局。

&&复制: 布尔值，可选
&&&请参阅将参数复制到ndarray.astype. 如果为 true，则始终返回副本。如果为 false，并且满足dtype要求，则返回视图。

&&**铸造: {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}，可选***
&&&参见 的铸造参数ndarray.astype。控制可能发生的数据类型转换。

&退货:
&&结构化: 数组
&&&维数较少的结构化数组。

例子

>>> from numpy.lib import recfunctions as rfn
>>> dt = np.dtype([('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)])
>>> a = np.arange(20).reshape((4,5))
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])
>>> rfn.unstructured_to_structured(a, dt)
array([( 0, ( 1.,  2), [ 3.,  4.]), ( 5, ( 6.,  7), [ 8.,  9.]),
       (10, (11., 12), [13., 14.]), (15, (16., 17), [18., 19.])],
      dtype=[('a', '<i4'), ('b', [('f0', '<f4'), ('f1', '<u2')]), ('c', '<f4', (2,))])