如何在不改变维度的情况下向 numpy 数组添加名称？

Question

我有一个现有的两列 numpy 数组，我需要向其中添加列名。通过dtype 传递它们在下面Block 1 中显示的玩具示例中起作用。但是，对于我的实际数组，如 Block 2 所示，同样的方法会产生意想不到的（对我而言！）改变数组维度的副作用。

如何将我的实际数组（下面第二个块中名为 Y 的数组）转换为具有命名列的数组，就像我在第一个块中为数组 A 所做的那样？

第 1 块：（A 的列命名没有重塑维度）

import numpy as np
A = np.array(((1,2),(3,4),(50,100)))
A
# array([[  1,   2],
#        [  3,   4],
#        [ 50, 100]])
dt = {'names':['ID', 'Ring'], 'formats':[np.int32, np.int32]}
A.dtype=dt
A
# array([[(1, 2)],
#        [(3, 4)],
#        [(50, 100)]], 
#       dtype=[('ID', '<i4'), ('Ring', '<i4')])

块 2：（命名我的实际数组的列，Y，重塑其维度）

import numpy as np
## Code to reproduce Y, the array I'm actually dealing with
nRings = 3
nn = [[nRings+1-n] * n for n in range(nRings+1)]
RING = reduce(lambda x, y: x+y, nn)
ID = range(1,len(RING)+1)
X = numpy.array([ID, RING])
Y = X.T
Y
# array([[1, 3],
#        [2, 2],
#        [3, 2],
#        [4, 1],
#        [5, 1],
#        [6, 1]])

## My unsuccessful attempt to add names to the array's columns    
dt = {'names':['ID', 'Ring'], 'formats':[np.int32, np.int32]}
Y.dtype=dt
Y
# array([[(1, 2), (3, 2)],
#        [(3, 4), (2, 1)],
#        [(5, 6), (1, 1)]], 
#       dtype=[('ID', '<i4'), ('Ring', '<i4')])

## What I'd like instead of the results shown just above
# array([[(1, 3)],
#        [(2, 2)],
#        [(3, 2)],
#        [(4, 1)],
#        [(5, 1)],
#        [(6, 1)]],
#       dtype=[('ID', '<i4'), ('Ring', '<i4')])

Answer 1

尝试重写X的定义：

X = np.array(zip(ID, RING))

然后你就不需要定义 Y = X.T

Answer 2

您完全确定A 和Y 的输出吗？我使用 Python 2.7.6 和 numpy 1.8.1 得到了一些不同的东西。

A 的初始输出与您的相同，应该如此。为第一个示例运行以下代码后

dt = {'names':['ID', 'Ring'], 'formats':[np.int32, np.int32]}
A.dtype=dt

数组A的内容其实是

array([[(1, 0), (3, 0)],
   [(2, 0), (2, 0)],
   [(3, 0), (2, 0)],
   [(4, 0), (1, 0)],
   [(5, 0), (1, 0)],
   [(6, 0), (1, 0)]], 
  dtype=[('ID', '<i4'), ('Ring', '<i4')])

这对我来说比您添加的输出更有意义，因为dtype 确定数组中每个元素的数据类型，并且新定义指出每个元素都应该包含两个字段，所以确实如此，但是值第二个字段的值设置为 0，因为第二个字段没有预先存在的值。

但是，如果您想对现有数组的列进行 numpy 分组，以便每一行仅包含一个元素，但每个元素都有两个字段，您可以引入一个小的代码更改。

由于需要一个元组来将 numpy 组元素转换为更复杂的数据类型，因此您可以通过创建一个新数组并将现有数组的每一行转换为一个元组来实现这一点。这是一个简单的工作示例

import numpy as np
A = np.array(((1,2),(3,4),(50,100)))
dt = np.dtype([('ID', np.int32), ('Ring', np.int32)])
B = np.array(list(map(tuple, A)), dtype=dt)

使用这段简短的代码，数组B 变为

array([(1, 2), (3, 4), (50, 100)], 
  dtype=[('ID', '<i4'), ('Ring', '<i4')])

要把B做成一个二维数组，写就够了

B.reshape(len(B), 1) # in this case, even B.size would work instead of len(B)

对于第二个示例，需要做类似的事情来使 Y 成为结构化数组：

Y = np.array(list(map(tuple, X.T)), dtype=dt)

为您的第二个示例执行此操作后，数组 Y 看起来像这样

array([(1, 3), (2, 2), (3, 2), (4, 1), (5, 1), (6, 1)], 
  dtype=[('ID', '<i4'), ('Ring', '<i4')])

您会注意到输出与您期望的不一样，但是这个更简单，因为您可以只写Y[0] 而不是写Y[0,0] 来获取第一个元素。要同时将此数组设为 2D，您还可以使用 reshape，就像使用 B 一样。

Answer 3

首先，因为您的问题是关于为数组命名，我觉得有义务指出使用“结构化数组”来命名可能不是最好的方法。当我们使用表格时，我们经常喜欢给行/列命名，如果是这种情况，我建议你尝试像pandas 这样的东西，这太棒了。如果你只是想在代码中组织一些数据，数组字典通常比结构化数组好得多，例如你可以这样做：

Y = {'ID':X[0], 'Ring':X[1]}

除此之外，如果您想使用结构化数组，我认为这是最清晰的方法：

import numpy as np

nRings = 3
nn = [[nRings+1-n] * n for n in range(nRings+1)]
RING = reduce(lambda x, y: x+y, nn)
ID = range(1,len(RING)+1)
X = np.array([ID, RING])

dt = {'names':['ID', 'Ring'], 'formats':[np.int, np.int]}
Y = np.zeros(len(RING), dtype=dt)
Y['ID'] = X[0]
Y['Ring'] = X[1]

Answer 4

这是因为Y不是C_CONTIGUOUS，可以通过Y.flags查看：

  C_CONTIGUOUS : False
  F_CONTIGUOUS : True
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

您可以先致电Y.copy() 或Y.ravel()：

dt = {'names':['ID', 'Ring'], 'formats':[np.int32, np.int32]}
print Y.ravel().view(dt) # the result shape is (6, )
print Y.copy().view(dt)  # the result shape is (6, 1)

Answer 5

store-different-datatypes-in-one-numpy-array 另一个页面，包括一个很好的解决方案，可以将名称添加到可以用作列的数组中 示例：

r = np.core.records.fromarrays([x1,x2,x3],names='a,b,c')
# x1, x2, x3 are flatten array
# a,b,c are field name