NumPy 記錄數(shù)組

numpy 提供了一個 ndarray 子類，?numpy.recarray它允許通過屬性而不是僅通過索引訪問結(jié)構(gòu)化數(shù)組的字段。記錄數(shù)組使用特殊的數(shù)據(jù)類型 ，numpy.record允許按屬性訪問從數(shù)組中獲得的結(jié)構(gòu)化標(biāo)量。該numpy.rec模塊提供了從各種對象創(chuàng)建重新數(shù)組的功能。用于創(chuàng)建和操作結(jié)構(gòu)化數(shù)組的其他輔助函數(shù)可以在numpy.lib.recfunctions.

創(chuàng)建記錄數(shù)組的最簡單方法是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?可以將各種參數(shù)轉(zhuǎn)換為記錄數(shù)組，包括結(jié)構(gòu)化數(shù)組：

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

該numpy.rec模塊提供了許多用于創(chuàng)建記錄數(shù)組的其他便利函數(shù)，請參閱記錄數(shù)組創(chuàng)建例程。

可以使用適當(dāng)?shù)囊晥D獲得結(jié)構(gòu)化數(shù)組的記錄數(shù)組表示：

>>> 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將自動轉(zhuǎn)換為numpy.record數(shù)據(jù)類型，因此可以將dtype排除在視圖之外：

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

要回到普通的 ndarray 必須重置 dtype 和類型。以下視圖這樣做，考慮到 recordarr 不是結(jié)構(gòu)化類型的異常情況：

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

如果字段具有結(jié)構(gòu)化類型，則通過索引或?qū)傩栽L問的記錄數(shù)組字段將作為記錄數(shù)組返回，否則作為普通 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 屬性優(yōu)先。這些字段將無法通過屬性訪問，但仍可通過索引訪問。

重新排列輔助函數(shù)

用于操作結(jié)構(gòu)化數(shù)組的實用程序集合。

大多數(shù)這些函數(shù)最初是由 John Hunter 為 matplotlib 實現(xiàn)的。為方便起見，它們已被重寫和擴(kuò)展。 numpy.lib.recfunctions。 append_fields?(?base?,?names?,?data?,?dtypes?=?None?,?fill_value?=?-?1?,?usemask?=?True?,?asrecarray?=?False?)[來源]

向現(xiàn)有數(shù)組添加新字段。

字段的名稱由名稱參數(shù)給出，對應(yīng)的值由數(shù)據(jù)參數(shù)給出。如果附加單個字段，則names、data和dtypes不必是列表而只是值。

&參數(shù):
&&基本: 數(shù)組
&&&要擴(kuò)展的輸入數(shù)組。

&&名稱: 字符串，序列
&&&與新字段名稱對應(yīng)的字符串或字符串序列。

&&數(shù)據(jù)：數(shù)組或數(shù)組序列
&&&數(shù)組或數(shù)組序列存儲要添加到基的字段。

&&dtypes: 數(shù)據(jù)類型序列，可選
&&&數(shù)據(jù)類型或數(shù)據(jù)類型序列。如果為 None，則數(shù)據(jù)類型是從data估計的。

&&fill_value: {float}，可選
&&&填充值用于填充較短數(shù)組上的缺失數(shù)據(jù)。

&&usemask:?{False, True}, 可選
&&&是否返回掩碼數(shù)組。

&&asrecarray:?{False, True}, 可選
&&&是否返回重新數(shù)組（MaskedRecords）。

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

應(yīng)用函數(shù) 'func' 作為跨結(jié)構(gòu)化數(shù)組字段的約簡。

這類似于apply_along_axis，但將結(jié)構(gòu)化數(shù)組的字段視為額外的軸。根據(jù)numpy.result_type?應(yīng)用于字段的 dtypes的類型提升規(guī)則，這些字段首先全部轉(zhuǎn)換為通用類型。

&參數(shù):
&&func: 函數(shù)
&&&應(yīng)用于“字段”維度的函數(shù)。此函數(shù)必須支持軸參數(shù)，例如 np.mean、np.sum 等。

&&ARR:?ndarray
&&&;對其應(yīng)用 func 的結(jié)構(gòu)化數(shù)組。

&退貨:出:數(shù)組
&&&切割操作的結(jié)果

例子

>>> 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?)[來源]

按字段名稱將值從一個結(jié)構(gòu)化數(shù)組分配給另一個。

通常在 numpy &= 1.14 中，將一個結(jié)構(gòu)化數(shù)組分配給另一個“按位置”復(fù)制字段，這意味著 src 中的第一個字段被復(fù)制到 dst 的第一個字段，依此類推，無論字段名稱如何。

該函數(shù)改為“按字段名稱”復(fù)制，這樣 dst 中的字段是從 src 中的同名字段分配的。這遞歸地適用于嵌套結(jié)構(gòu)。這就是結(jié)構(gòu)賦值在 numpy &= 1.6 到 <= 1.13 中的工作方式。

&參數(shù):
&&dst: 數(shù)組
&&SRC:?ndarray
&&&分配期間的源數(shù)組和目標(biāo)數(shù)組。

&&zero_unassigned?:bool，可選
&&&如果為 True，則 dst 中在 src 中沒有匹配字段的字段將填充值 0（零）。這是 numpy <= 1.13 的行為。如果為 False，則不會修改這些字段。

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

返回一個新數(shù)組，其中drop_names 中的字段已刪除。

支持嵌套字段。

在 1.18.0 版更改：drop_fields如果刪除所有字段，則返回一個包含 0 個字段的數(shù)組，而不是None像以前那樣返回。

&參數(shù):
&&基本:數(shù)組
&&&輸入數(shù)組

&&drop_names:字符串或序列
&&&與要刪除的字段名稱相對應(yīng)的字符串或字符串序列。

&&usemask?: {False, True}, 可選
&&&是否返回掩碼數(shù)組。

&&asrecarray :字符串或序列，可選
&&&是否返回 recarray 或 mrecarray (?asrecarray=True?) 或普通 ndarray 或具有靈活 dtype 的掩碼數(shù)組。默認(rèn)值為假。

例子

>>> 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?)[來源]

沿著給定的鍵在結(jié)構(gòu)化數(shù)組中查找重復(fù)項

&參數(shù):
&&類似: 數(shù)組
&&&輸入數(shù)組

&& 鍵: {字符串，無}，可選
&&&沿其檢查重復(fù)項的字段的名稱。如果沒有，則按記錄執(zhí)行搜索

&&忽略掩碼: {True, False}，可選
&&&是否應(yīng)丟棄屏蔽數(shù)據(jù)或?qū)⑵湟暈橹貜?fù)數(shù)據(jù)。

&&return_index:?{False, True}，可選
&&&是否返回重復(fù)值的索引。

例子

>>> 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?)[來源]

扁平化結(jié)構(gòu)化數(shù)據(jù)類型描述。

例子

>>> 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?)[來源]

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

此函數(shù)用于簡化對嵌套在其他字段中的字段的訪問。

&參數(shù):
&&adtype:?np.dtype
&&&輸入數(shù)據(jù)類型

&&姓氏: 可選
&&&最后處理的字段名稱（在遞歸期間內(nèi)部使用）。

&&父母: 字典
&&&父字段字典（在遞歸期間相互使用）。

例子

>>> 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，詳情）[來源]

以元組形式返回輸入數(shù)據(jù)類型的字段名稱。

&參數(shù):
&&adtype，詳情: D型
&&&輸入數(shù)據(jù)類型

例子

>>> 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?)[來源]

以元組形式返回輸入數(shù)據(jù)類型的字段名稱。嵌套結(jié)構(gòu)預(yù)先展平。
&參數(shù):
&&adtype，詳情: D型
&&&輸入數(shù)據(jù)類型

例子

>>> 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上連接數(shù)組r1和r2。

鍵應(yīng)該是與用于連接數(shù)組的字段相對應(yīng)的字符串或字符串序列。如果在兩個輸入數(shù)組中找不到鍵字段，則會引發(fā)異常?。r1和?r2都不應(yīng)該在key 上有任何重復(fù)項：重復(fù)項的存在會使輸出非常不可靠。請注意，算法不會查找重復(fù)項。
&參數(shù):
&&鍵: {字符串，序列}
&&&與用于比較的字段對應(yīng)的字符串或字符串序列。

&&r1, r2: 數(shù)組
&&&結(jié)構(gòu)化數(shù)組。

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

&&r1postfix： 字符串，可選**
&&&附加到 r1 中存在于 r2 中但沒有鍵的字段名稱的字符串。

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

&&默認(rèn)值: {dictionary}，可選
&&&字典將字段名稱映射到相應(yīng)的默認(rèn)值。

&&使用掩碼: {True, False}，可選
&&&是返回 MaskedArray （或 MaskedRecords 是?asrecarray==True）還是 ndarray。

&&asrecarray?: {False, True}, 可選
&&&是否返回 recarray （或 MaskedRecords 如果usemask==True）或只是一個靈活類型的 ndarray。

筆記

• 輸出按鍵排序。
• 通過刪除不在兩個數(shù)組的鍵中的字段并將結(jié)果連接起來，形成一個臨時數(shù)組。然后對該數(shù)組進(jìn)行排序，并選擇公共條目。通過使用所選條目填充字段來構(gòu)建輸出。如果有一些重復(fù)項，則不會保留匹配...

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

按字段合并數(shù)組。

&參數(shù):
&&seqarrays ndarrays: 序列
&&&數(shù)組序列

&&fill_value:?{float}，可選
&&&填充值用于填充較短數(shù)組上的缺失數(shù)據(jù)。

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

&&usemask:?{False, True}, 可選
&&&是否返回掩碼數(shù)組。

&&asrecarray:?{False, True}, 可選
&&&是否返回重新數(shù)組（MaskedRecords）。

筆記

如果沒有掩碼，缺失值將被填充，具體取決于其對應(yīng)的類型：

• -1?對于整數(shù)
• -1.0?對于浮點數(shù)
• '-'?對于字符
• '-1'?對于字符串
• True?對于布爾值

XXX：我只是憑經(jīng)驗獲得這些值

例子

>>> 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?)[來源]

向現(xiàn)有數(shù)組添加新字段。

字段的名稱由名稱參數(shù)給出，對應(yīng)的值由數(shù)據(jù)參數(shù)給出。如果附加單個字段，則names、data和dtypes不必是列表而只是值。

&參數(shù):
&&基本: 數(shù)組
&&&要擴(kuò)展的輸入數(shù)組。

&&名稱: 字符串，序列
&&&與新字段名稱對應(yīng)的字符串或字符串序列。

&&數(shù)據(jù): 數(shù)組或數(shù)組序列
&&&數(shù)組或數(shù)組序列存儲要添加到基的字段。

&&dtypes: 數(shù)據(jù)類型序列，可選
&&&數(shù)據(jù)類型或數(shù)據(jù)類型序列。如果為 None，則數(shù)據(jù)類型是從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?)[來源]

在鍵上連接數(shù)組r1和r2。join_by 的替代方法，它總是返回一個 np.recarray。

numpy.lib.recfunctions。recursive_fill_fields（輸入，輸出）[來源]

使用輸入字段填充輸出字段，支持嵌套結(jié)構(gòu)。

&參數(shù):
&&輸入: 數(shù)組
&&&輸入數(shù)組。

&&輸出:數(shù)組
&&&輸出數(shù)組。

筆記

輸出應(yīng)至少與輸入大小相同

例子

>>> 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?)[來源]從靈活數(shù)據(jù)類型 ndarray 或 recarray 重命名字段。 支持嵌套字段。 參數(shù)基礎(chǔ)數(shù)組必須修改其字段的輸入數(shù)組。 名稱映射字典將舊字段名稱映射到新版本的字典。 例子

>>> 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?)[來源]

在內(nèi)存中重新打包結(jié)構(gòu)化數(shù)組或 dtype 的字段。

結(jié)構(gòu)化數(shù)據(jù)類型的內(nèi)存布局允許任意字節(jié)偏移的字段。這意味著字段可以由填充字節(jié)分隔，它們的偏移量可以非單調(diào)增加，并且它們可以重疊。

此方法刪除任何重疊并重新排序內(nèi)存中的字段，使它們具有增加的字節(jié)偏移量，并根據(jù)align選項添加或刪除填充字節(jié)，其行為類似于align選項np.dtype。

如果align=False，則此方法會生成“打包”內(nèi)存布局，其中每個字段從前一個字段結(jié)束的字節(jié)開始，并刪除任何填充字節(jié)。

如果align=True，則此方法通過根據(jù)需要添加填充字節(jié)來生成“對齊”內(nèi)存布局，其中每個字段的偏移量是其對齊方式的倍數(shù)，并且總項目大小是最大對齊方式的倍數(shù)。

&參數(shù)
&&一個: ndarray 或 dtype
&&&要為其重新打包字段的數(shù)組或數(shù)據(jù)類型。

&&對齊: 布爾值
&&&如果為 true，則使用“對齊”內(nèi)存布局，否則使用“打包”布局。

&&遞歸: 布爾值
&&&如果為 True，還重新打包嵌套結(jié)構(gòu)。

&退貨:
&&重新: 打包的 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（數(shù)組，?required_dtype）[來源]

使用按字段名稱賦值將結(jié)構(gòu)化數(shù)組轉(zhuǎn)換為新的數(shù)據(jù)類型。

此函數(shù)按名稱從舊數(shù)組分配給新數(shù)組，因此輸出數(shù)組中字段的值是源數(shù)組中同名字段的值。這具有創(chuàng)建僅包含 required_dtype 的“必需”字段的新 ndarray 的效果。

如果 required_dtype 中的字段名稱在輸入數(shù)組中不存在，則會在輸出數(shù)組中創(chuàng)建該字段并將其設(shè)置為 0。
&參數(shù)
&&一個: 數(shù)組
&&&要投射的數(shù)組

&&required_dtype:?D型
&&&輸出數(shù)組的數(shù)據(jù)類型

&退貨
&&出: 數(shù)組
&&&具有新 dtype 的數(shù)組，字段值從輸入數(shù)組中的同名字段復(fù)制

例子

>>> 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（陣列，默認(rèn)=無，?usemask?=真，?asrecarray?=假，自動轉(zhuǎn)換=假）[來源]按字段疊加數(shù)組字段 參數(shù)數(shù)組數(shù)組或序列輸入數(shù)組的序列。 默認(rèn)字典，可選字典將字段名稱映射到相應(yīng)的默認(rèn)值。 使用掩碼{True, False}，可選是返回 MaskedArray （或 MaskedRecords 是?asrecarray==True）還是 ndarray。 asrecarray?{False, True}, 可選是否返回 recarray （或 MaskedRecords 如果usemask==True）或只是一個靈活類型的 ndarray。 自動轉(zhuǎn)換{假，真}，可選是否自動將字段的類型轉(zhuǎn)換為最大值。 例子

>>> 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 結(jié)構(gòu)化數(shù)組轉(zhuǎn)換為 (n+1)-D 非結(jié)構(gòu)化數(shù)組。

新數(shù)組將有一個新的最后一個維度，其大小等于輸入數(shù)組的字段元素數(shù)。如果未提供，則輸出數(shù)據(jù)類型由應(yīng)用于所有字段數(shù)據(jù)類型的 numpy 類型提升規(guī)則確定。

嵌套字段以及任何子數(shù)組字段的每個元素都算作單個字段元素。

&參數(shù):
&&ARR:?ndarray
&&&要轉(zhuǎn)換的結(jié)構(gòu)化數(shù)組或數(shù)據(jù)類型。不能包含對象數(shù)據(jù)類型。

&&dtype:?dtype，可選
&&&輸出非結(jié)構(gòu)化數(shù)組的 dtype。

&&復(fù)制: 布爾值，可選
&&&請參閱將參數(shù)復(fù)制到ndarray.astype.?如果為 true，則始終返回副本。如果為 false，并且滿足dtype要求，則返回視圖。

&&鑄造: {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}，可選
&&&參見 的鑄造參數(shù)ndarray.astype?？刂瓶赡馨l(fā)生的數(shù)據(jù)類型轉(zhuǎn)換。

&退貨:
&&非結(jié)構(gòu)化:數(shù)組
&&&多一維的非結(jié)構(gòu)化數(shù)組。

例子

>>> 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 非結(jié)構(gòu)化數(shù)組轉(zhuǎn)換為 (n-1)-D 結(jié)構(gòu)化數(shù)組。

輸入數(shù)組的最后一維被轉(zhuǎn)換為一個結(jié)構(gòu)體，其字段元素的數(shù)量等于輸入數(shù)組最后一維的大小。默認(rèn)情況下，所有輸出字段都具有輸入數(shù)組的 dtype，但可以提供具有相同字段元素數(shù)量的輸出結(jié)構(gòu)化 dtype。

嵌套字段以及任何子數(shù)組字段的每個元素都計入字段元素的數(shù)量。

&參數(shù):
&&ARR:?ndarray
&&&要轉(zhuǎn)換的非結(jié)構(gòu)化數(shù)組或數(shù)據(jù)類型。

&&dtype: dtype，可選
&&&輸出數(shù)組的結(jié)構(gòu)化數(shù)據(jù)類型

&&名稱: 字符串列表，可選
&&&如果未提供 dtype，則按順序指定輸出 dtype 的字段名稱。字段 dtypes 將與輸入數(shù)組相同。

&&對齊: 布爾值，可選
&&&是否創(chuàng)建對齊的內(nèi)存布局。

&&復(fù)制: 布爾值，可選
&&&請參閱將參數(shù)復(fù)制到ndarray.astype.?如果為 true，則始終返回副本。如果為 false，并且滿足dtype要求，則返回視圖。

&&**鑄造: {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}，可選***
&&&參見 的鑄造參數(shù)ndarray.astype?？刂瓶赡馨l(fā)生的數(shù)據(jù)類型轉(zhuǎn)換。

&退貨:
&&結(jié)構(gòu)化: 數(shù)組
&&&維數(shù)較少的結(jié)構(gòu)化數(shù)組。

例子

>>> 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,))])