Column_stacking中任意数量的数据

Question

我有一个具有" ydata“属性的”谱“对象列表，我需要将所有ydata列在一起。

我可以遍历所有的对象，但我必须以某种方式创建一个长度相同的数组，以便可以进行堆栈。

下面是我所拥有的最基本的版本：

import numpy as np

class Spectrum(object):

  def __init__(self, ydata):
    self.ydata = ydata

spec = {}

spec[1] = Spectrum([1,2,3])
spec[2] = Spectrum([4,5,6])

array = np.empty(len(spec[1].ydata))

for i in range(1,len(spec)+1):
    array = np.column_stack((array,spec[i].ydata))

print(array)

所以上面的方法是可行的，但是数组的第一列总是空(随机)值。

我知道必须有一个简单的方法来做到这一点，但我只是错过了它。

我想到的一个选择是首先：

array = spec[1].ydata

然后进入for-循环，但这似乎不对，因为这假设存在一个spec1。

预期的产出将是：

>>>array
>>>[[1 4]
    [2 5]
    [3 6]]

Answer 1

假设您的所有Spectrum实例都有相同的ydata长度，我将使用一个简单的列表理解：

array = np.array([spec[i+1].ydata for i in range(len(spec))])
print(array)

产出：

[[1 2 3]
 [4 5 6]]

编辑

我再看一看所需的输出，在这种情况下，它将是

array = np.array([spec[i+1].ydata for i in range(len(spec))]).T

和

[[1 4]
 [2 5]
 [3 6]]

编辑

我编写了一个小测试程序来比较np.array().T和np.column_stack()的性能：

import numpy as np
from timeit import Timer

class Spectrum(object):

  def __init__(self, ydata):
    self.ydata = ydata

def create_by_array():
  return np.array([spec[i+1].ydata for i in range(len(spec))]).T

def create_by_column_stack():
  return np.column_stack([spec[i+1].ydata for i in range(len(spec))])


I = 1000
spec = {i: Spectrum([j for j in range(3*i,3*(i+1))]) for i in range(1,I+1)}

t1 = Timer(
  """create_by_array()""",
  setup="""from __main__ import create_by_array"""
  )
res1 = t1.repeat(10,1000)

t2 = Timer(
  """create_by_column_stack()""",
  setup="""from __main__ import create_by_column_stack"""
  )
res2 = t2.repeat(10,1000)

print(
  'Results of the two tests:   ',
  '{:5}, {:5}, {:5}'.format('min','mean','max')
  )
print(
  'With np.array and transpose:',
  '{:5.3}, {:5.3}, {:5.3}'.format(np.min(res1), np.mean(res1),np.max(res1))
)
print(
  'With np.column_stack():     ',
  '{:5.4}, {:5.4}, {:5.4}'.format(np.min(res2), np.mean(res2),np.max(res2))
)

该程序首先生成一个1,000个Spectrum实例的dict，然后将这两种方法重复10×1000次。以下是研究结果：

('Results of the two tests:   ', 'min  , mean , max  ')
('With np.array and transpose:', '0.687, 0.709, 0.742')
('With np.column_stack():     ', '3.982, 4.367, 5.263')

如您所见，np.array().T方法比np.column_stack()快5倍。我不太清楚这是为什么，但根据堆栈文档页的说法，

取一系列一维数组，并将它们作为列堆叠成一个单独的二维数组。二维数组按-is方式堆叠，就像使用h堆栈一样。首先将一维数组转换为二维列.

这听起来很像每个单独的子列表首先被转换成一个ndarray，而np.array()只创建最终的数组。矩阵的转换非常快，因为它不会在内存中进行任何重新排列。例如，参见这里。我希望这能把它弄清楚。