Python 如何将numpy子阵列相互添加？

我使用了

numpy.array\u split（）

函数将天文数据数组拆分为一系列长度已知的子数组（子数组的数量完全未知且任意）。我想按顺序将这些阵列相互添加，以便一个阵列具有多个子阵列：

A = [[1,  2,   3,  4]
     [5,  6,   7,  8]
     [9, 10,  11]]

可能会变成这样：

B = [15, 18, 21, NaN]

我在想，也许可以做一些类似于

B=numpy.sum（A[1]，A[2]，A[3]，axis=0）

，然后对B执行我喜欢的任何操作。但是，由于子数组的数量是任意的，除非我知道子数组的数量，否则这种方法将无法工作

---

如果您能帮我解决这个问题，我们将不胜感激。

我可能只需要填写

A

的最后一位成员：

>>> a = np.arange(1,12)
>>> A = np.array_split(a,3)
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([ 9, 10, 11])]
>>> A[-1] = np.append(A[-1], [np.nan]*(len(A[-2])-len(A[-1])))
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([  9.,  10.,  11.,  nan])]
>>> np.sum(A,axis=0)
array([ 15.,  18.,  21.,  nan])

---

但老实说，我认为最好先填充，然后再重塑，这样您仍然可以使用

numpy

数组，而不是数组列表

numpy实际上并不是为处理一系列不同长度的数据而设计的，它也不像pandas

那样方便地处理丢失的数据。我可能只需要填充

A

的最后一个成员：

>>> a = np.arange(1,12)
>>> A = np.array_split(a,3)
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([ 9, 10, 11])]
>>> A[-1] = np.append(A[-1], [np.nan]*(len(A[-2])-len(A[-1])))
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([  9.,  10.,  11.,  nan])]
>>> np.sum(A,axis=0)
array([ 15.,  18.,  21.,  nan])

---

但老实说，我认为最好先填充，然后再重塑，这样您仍然可以使用

numpy

数组，而不是数组列表

numpy实际上并不是为处理一系列不同长度的数据而设计的，它也不像pandas

那样方便地处理丢失的数据。我可能只需要填充

A

的最后一个成员：

>>> a = np.arange(1,12)
>>> A = np.array_split(a,3)
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([ 9, 10, 11])]
>>> A[-1] = np.append(A[-1], [np.nan]*(len(A[-2])-len(A[-1])))
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([  9.,  10.,  11.,  nan])]
>>> np.sum(A,axis=0)
array([ 15.,  18.,  21.,  nan])

---

但老实说，我认为最好先填充，然后再重塑，这样您仍然可以使用

numpy

数组，而不是数组列表

numpy实际上并不是为处理一系列不同长度的数据而设计的，它也不像pandas

那样方便地处理丢失的数据。我可能只需要填充

A

的最后一个成员：

>>> a = np.arange(1,12)
>>> A = np.array_split(a,3)
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([ 9, 10, 11])]
>>> A[-1] = np.append(A[-1], [np.nan]*(len(A[-2])-len(A[-1])))
>>> A
[array([1, 2, 3, 4]), array([5, 6, 7, 8]), array([  9.,  10.,  11.,  nan])]
>>> np.sum(A,axis=0)
array([ 15.,  18.,  21.,  nan])

---

但老实说，我认为最好先填充，然后再重塑，这样您仍然可以使用

numpy

数组，而不是数组列表

numpy实际上并不是为处理一系列不同长度的数据而设计的，它也不像pandas

那样方便地处理丢失的数据。我认为解决这个问题的最好方法是先填充，然后分割。如果先拆分，则必须根据拆分的方式重新填充多个元素。例如，将

np.arange（1，11）

拆分为3会导致两行长度不足

如果你在做算术，也许用零填充比用NaN填充更自然，但我不知道你的应用程序，所以我们可以用任何一种方法。用零填充：

a = np.arange(1, 11)
b = 3
pad_length = (b - len(a) % b) % b
a0 = np.pad(a, (0, pad_length), mode='constant')
A0 = np.array_split(a0)
np.sum(A0, axis=0) # array([15, 18, 10, 12])

用NaN填充：

aN = np.append(a, [np.nan] * pad_length)
AN = np.array_split(aN)

---

我认为解决这个问题的最好办法是先垫，然后分开。如果先拆分，则必须根据拆分的方式重新填充多个元素。例如，将

np.arange（1，11）

拆分为3会导致两行长度不足

如果你在做算术，也许用零填充比用NaN填充更自然，但我不知道你的应用程序，所以我们可以用任何一种方法。用零填充：

a = np.arange(1, 11)
b = 3
pad_length = (b - len(a) % b) % b
a0 = np.pad(a, (0, pad_length), mode='constant')
A0 = np.array_split(a0)
np.sum(A0, axis=0) # array([15, 18, 10, 12])

用NaN填充：

aN = np.append(a, [np.nan] * pad_length)
AN = np.array_split(aN)

---

我认为解决这个问题的最好办法是先垫，然后分开。如果先拆分，则必须根据拆分的方式重新填充多个元素。例如，将

np.arange（1，11）

拆分为3会导致两行长度不足

如果你在做算术，也许用零填充比用NaN填充更自然，但我不知道你的应用程序，所以我们可以用任何一种方法。用零填充：

a = np.arange(1, 11)
b = 3
pad_length = (b - len(a) % b) % b
a0 = np.pad(a, (0, pad_length), mode='constant')
A0 = np.array_split(a0)
np.sum(A0, axis=0) # array([15, 18, 10, 12])

用NaN填充：

aN = np.append(a, [np.nan] * pad_length)
AN = np.array_split(aN)

---

我认为解决这个问题的最好办法是先垫，然后分开。如果先拆分，则必须根据拆分的方式重新填充多个元素。例如，将

np.arange（1，11）

拆分为3会导致两行长度不足

如果你在做算术，也许用零填充比用NaN填充更自然，但我不知道你的应用程序，所以我们可以用任何一种方法。用零填充：

a = np.arange(1, 11)
b = 3
pad_length = (b - len(a) % b) % b
a0 = np.pad(a, (0, pad_length), mode='constant')
A0 = np.array_split(a0)
np.sum(A0, axis=0) # array([15, 18, 10, 12])

用NaN填充：

aN = np.append(a, [np.nan] * pad_length)
AN = np.array_split(aN)

那

A

不能是“一个数组有几个子数组”。这是怎么一回事？名单？数组列表？由于某种原因，您将多个数组表示为一个数组？即

A

不能是“具有多个子数组的一个数组”。这是怎么一回事？名单？数组列表？由于某种原因，您将多个数组表示为一个数组？即

A

不能是“具有多个子数组的一个数组”。这是怎么一回事？名单？数组列表？由于某种原因，您将多个数组表示为一个数组？即

A

不能是“具有多个子数组的一个数组”。这是怎么一回事？名单？数组列表？由于某种原因，您将多个阵列显示为一个？