Python Numpy重新排列列和堆栈的排序

对于python来说比较新，所以如果这有一个我还没有找到的明显的答案，请原谅

我将一些临时连续的二进制文件读入numpy记录数组，最终目标是将它们存储在pytable中。我预期的问题是，这些文件可能并不都具有相同的字段，或者具有相同的字段顺序。我一直在寻找一个numpy函数，它将使用字段标签或索引对重新排列的列（而不是行）进行排序。更好的是，当您将一个重新排列附加到另一个重新排列时，可以使用一个函数来为您执行此操作，并解释缺少的列。以下是我的想法示例：

#-------script------------
Myarray1 = np.array([(1,2,3),(1,2,3),(1,2,3)], {'names': ('a','b','c'), 'formats': ('f4', 'f4', 'f4')})
Myarray2 = np.array([(2,1,4,3),(2,1,4,3),(2,1,4,3)], {'names': ('b','a','d','c'), 'formats': ('f4', 'f4', 'f4', 'f4')})
Myarray3 = SomeColumnSortFunction(Myarray2, sortorder=[2,1,4,3])
Myarray4 = SomeBetterVerticalStackFunction(Myarray1,Myarray2)
#
print(Myarray1)
print()
print(Myarray2)
print()
print(Myarray3)
print()
print(Myarray4)

#---------- Wished for Output -------------
[(1.0, 2.0, 3.0) (1.0, 2.0, 3.0) (1.0, 2.0, 3.0)],
 dtype=[('a', 'i4'), ('b', 'i4'), ('c', 'i4')]

[(2.0, 1.0, 4.0, 3.0) (2.0, 1.0, 4.0, 3.0) (2.0, 1.0, 4.0, 3.0)],
dtype=[('b', 'i4'), ('a', 'i4'), ('d', 'i4'), ('c', 'i4')]


[(1.0, 2.0, 3.0, 4.0) (1.0, 2.0, 3.0, 4.0) (1.0, 2.0, 3.0, 4.0)] 
dtype=[('a', 'i4'), ('b', 'i4'), ('c', 'i4'), ('d', 'i4')]

[(1.0, 2.0, 3.0, NaN) (1.0, 2.0, 3.0, NaN) (1.0, 2.0, 3.0, NaN),
 (1.0, 2.0, 3.0, 4.0) (1.0, 2.0, 3.0, 4.0) (1.0, 2.0, 3.0, 4.0)] 
dtype=[('a', 'i4'), ('b', 'i4'), ('c', 'i4'), ('d', 'i4')]

• 如果要对结构化数组的字段重新排序，只需使用奇特的索引：

  MyArray3 = MyArray2[['a','b','c','d']]
  

  如果要使用整数对字段进行排序，可以使用以下方法：

  order = [1,0,3,2]
  names = MyArray2.dtype.names
  MyArray3 = MyArray2[[names[i] for i in order]]
  

  （在您的

  sortorder=[2,1,4,3]

  中，您可能忘记了iterable的第一个索引是0…）

• 对于堆叠结构化数组，请查看

  numpy.lib.recfunctions

  子模块，尤其是

  stack\u数组

  函数。请注意，您必须显式地使用

  导入numpy.lib.recfunctions

这是文件串

stack_arrays(arrays, defaults=None, usemask=True, asrecarray=False, autoconvert=False)

Superposes arrays fields by fields

Parameters
----------
seqarrays : array or sequence
    Sequence of input arrays.
defaults : dictionary, optional
    Dictionary mapping field names to the corresponding default values.
usemask : {True, False}, optional
    Whether to return a MaskedArray (or MaskedRecords is `asrecarray==True`)
    or a ndarray.
asrecarray : {False, True}, optional
    Whether to return a recarray (or MaskedRecords if `usemask==True`) or
    just a flexible-type ndarray.
autoconvert : {False, True}, optional
    Whether automatically cast the type of the field to the maximum.

Examples
--------
>>> 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', float), ('C', float)])
>>> test = rfn.stack_arrays((z,zz))
>>> test
masked_array(data = [('A', 1.0, --) ('B', 2.0, --) ('a', 10.0, 100.0) ('b', 20.0, 200.0)
 ('c', 30.0, 300.0)],
             mask = [(False, False, True) (False, False, True) (False, False, False)
 (False, False, False) (False, False, False)],
       fill_value = ('N/A', 1e+20, 1e+20),
            dtype = [('A', '|S3'), ('B', '<f8'), ('C', '<f8')])

stack_数组（数组，默认值=None，usemack=True，asrecarray=False，autoconvert=False）
按字段叠加数组
参数
----------
seqarray：数组还是序列
输入数组的序列。
默认值：字典，可选
字典将字段名称映射到相应的默认值。
usemask:{True，False}，可选
是否返回MaskedArray（或MaskedRecords为'asrecarray==True`）
或者说是一条长途跋涉。
asrecarray:{False，True}，可选
是否返回重新排列（如果'usemask==True'，则返回掩码记录）或
只是一个灵活的类型。
自动转换：{False，True}，可选
是否自动将字段类型强制转换为最大值。
例子
--------
>>>从numpy.lib导入函数作为rfn
>>>x=np.array（[1，2，]）
>>>堆栈数组（x）是x
真的
>>>z=np.array（[（'A'，1），（'B'，2）]，dtype=[（'A'，'S3'），（'B'，float）]）
>>>zz=np.数组（[（'a'，10,100.），（'b'，20,200.），（'c'，30,300.），
…数据类型=[（'A'，'S3'），（'B'，float），（'C'，float）]）
>>>test=rfn.stack_数组（（z，zz））
>>>试验
掩蔽数组（数据=[（'A'，1.0，--）（'B'，2.0，--）（'A'，10.0，100.0）（'B'，20.0，200.0）
（'c'，30.0，300.0）]，
面具=[（假，假，真）（假，假，真）（假，假，假）
（假，假，假）（假，假，假）]，
填充值=（'N/A'，1e+20，1e+20），
dtype=[（'A'，'S3'），（'B'，'请注意，by的答案似乎在较旧版本的
numpy
中不起作用，例如以下代码段：

  python -c 'import numpy as np
from pprint import pformat
print np.__version__
a = np.array([ (1, 4.0, "Hello"), 
               (-1, -1.0, "World")],
       dtype=[("f0", ">i4"), ("f1", ">f4"), ("S2", "|S10")])
print("a : "+ pformat( a ) )
print("a1: "+ pformat( a[["f0", "S2"]] ) )
print("a2: "+ pformat( a[["S2", "f0"]] ) )
'

…为我生成以下内容（python 2.7）：

1.5.1
答：数组（[（1,4.0，'Hello'），（-1，-1.0，'World'），
数据类型=[（'f0'，'>i4'），（'f1'，'>f4'），（'S2'，'S10'））
a1:数组（[（1，'Hello'），（-1，'World'），
数据类型=[（'f0'，'>i4'），（'S2'，'S10'））
a2：数组（[（1，'Hello'），（-1，'World'）]，
数据类型=[（'f0'，'>i4'），（'S2'，'S10'））

…也就是说，列根本没有重新排列


编辑：找到替代方案，使用；以及。基本上：


创建一个新列表，其中包含按所需顺序重新排列的列数据类型
通过
.view
（以便为每个列保留名称和数据类型）创建一个新的
np.array
s列表，这些列表表示每个列，并根据重新排列的列数据类型列表重新排序
使用
np.array
s列表作为
numpy.lib.recfunctions.merge_array

因此，可以将此内容添加到本文前面的片段中：

从numpy.lib导入函数作为rfn
rdtype=[（“S2”、“S10”）、（“f1”、“f4”）、（“f0”、“i4”）]
#ra=np.array（[np.array（对于rdtype中的rdt，为[rdt[0]]，rdt）]）
#为rdtype中的rdt打印[np.array（a[rdt[0]]，dtype=rdt）]#否
#在rdtype中为rdt打印[np.array（一个[rdt[0]]）#过程，无字段名
打印[np.数组（一个[rdt[0]]）。在rdtype中为rdt打印视图（[rdt]）。#确定
ra=rfn.merge_数组（[np.array（a[rdt[0]]）。rdtype中rdt的视图（[rdt]））
打印（“a4:+P格式（ra））

…它还输出：

[array（[（'Hello'，），（'World'，）]，
数据类型=[（'S2'，'S10'）]、数组（[（4.0，）、（-1.0，）]，
数据类型=[（'f1'，'>f4'）]），数组（[（1，），（-1，）]，
数据类型=[（'f0'，'>i4'）]]
a4:array（[（'Hello'，4.0，1），（'World'，-1.0，-1）]，
数据类型=[（'S2'，'S10'），（'f1'，'>f4'），（'f0'，'>i4'））

…这最终表明列是按要求重新排列的

好吧，希望这对某人有所帮助-希望这里没有其他问题，

干杯