Python 在numpy数组中沿轴求和

我想了解这个ndarray.sum（axis=）是如何工作的。我知道axis=0表示列，axis=1表示行。 但在3维（3轴）的情况下，很难解释以下结果

arr = np.arange(0,30).reshape(2,3,5)

arr
Out[1]: 
array([[[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]],

       [[15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24],
        [25, 26, 27, 28, 29]]])

arr.sum(axis=0)
Out[2]: 
array([[15, 17, 19, 21, 23],
       [25, 27, 29, 31, 33],
       [35, 37, 39, 41, 43]])


arr.sum(axis=1)
Out[8]: 
array([[15, 18, 21, 24, 27],
       [60, 63, 66, 69, 72]])

arr.sum(axis=2)
Out[3]: 
array([[ 10,  35,  60],
       [ 85, 110, 135]])

在这个形状为（2,3,5）的3轴数组的示例中，有3行5列。但如果我把这个数组作为一个整体来看，似乎只有两行（都有3个数组元素）

---

任何人都可以解释这个总和是如何在3个或更多轴（维度）的阵列上工作的。

您指定的轴是有效删除的轴。因此，给定一个

（2,3,5）

的形状，轴0给出

（3,5）

，轴1给出

（2,5）

，等等。这可以扩展到任意数量的维度。

如果要保留维度，可以指定

保留维度：

>>> arr = np.arange(0,30).reshape(2,3,5)
>>> arr.sum(axis=0, keepdims=True)
array([[[15, 17, 19, 21, 23],
        [25, 27, 29, 31, 33],
        [35, 37, 39, 41, 43]]])

否则，将从图形中删除沿其求和的轴。跟踪此情况的一个简单方法是使用属性：

>>> arr.shape
(2, 3, 5)

>>> arr.sum(axis=0).shape
(3, 5)  # the first entry (index = axis = 0) dimension was removed 

>>> arr.sum(axis=1).shape
(2, 5)  # the second entry (index = axis = 1) was removed

如果需要，还可以沿多个轴求和（按指定轴的数量减少维度）：

这是另一种解释。可以考虑多维数组作为张量，<代码> t[i] [j] [k] < /代码>，而i，j，k分别表示轴<代码> 0. 1,2。p>
T.sum（轴=0）
在数学上等于：


类似地，
T.sum（轴=1）
：


和，
T.sum（轴=2）
：


换句话说，轴将被求和，例如，
axis=0
，第一个索引将被求和。如果写入for循环中：

result[j][k] = sum(T[i][j][k] for i in range(T.shape[0])) for all j,k

对于
轴=1
：

result[i][k] = sum(T[i][j][k] for j in range(T.shape[1])) for all i,k

等等。
numpy
将（2,3,5）数组显示为2块3x5数组（3行5列）。或者称之为“平面”（MATLAB将其显示为2x3的5个块）

numpy
显示也匹配一个嵌套列表-一个包含两个子列表的列表；每个都有3个子列表。每个元素都有5个元素长

在3x5 2d情况下，轴0沿尺寸
3
维度求和，形成一个5元素数组。“行上求和”或“沿列求和”的描述在英语中有点模糊。关注结果、形状的变化以及要求和的值，而不是描述

回到3d案例：

当轴=0时，它沿第一维求和，有效地去除了它，给我们留下了一个3x5数组<代码>0+15=16，1+16=17等

轴1，压缩尺寸

3

尺寸，结果为2x5<代码>0+5+10=15等

轴2，压缩大小

5

dimenson，结果为2x3，

sum（（0,1,2,3,4））

你的例子很好，因为这3个维度是不同的，而且在求和过程中更容易看出哪一个被消除了

---

2d有一些模糊性；'行上求和”-这是否意味着删除或保留行？有了3d，就没有了歧义；当axis=0时，您只能删除它，剩下2个。

您似乎被numpy数组的输出样式弄糊涂了。输出的“行”几乎总是最后一个索引，而不是第一个。例如：

x=np.arange(1,4)
y=np.arange(10,31,10)
z=np.arange(100,301,100)
xy=x[:,None]+y[None,:]

xy
Out[100]: 
array([[11, 21, 31],
       [12, 22, 32],
       [13, 23, 33]])

请注意，行（而不是列）上的十位增量，即使y是第二个索引

xyz=x[:,None,None]+y[None,:,None]+z[None,None,:]
xyz
Out[102]: 
array([[[111, 211, 311],
        [121, 221, 321],
        [131, 231, 331]],

       [[112, 212, 312],
        [122, 222, 322],
        [132, 232, 332]],

       [[113, 213, 313],
        [123, 223, 323],
        [133, 233, 333]]])

现在，尽管z是最后一个索引，但行中的百位将递增。对于初学者来说，这可能有点违反直觉

---

因此，当您执行

np.sum（x，index=-1）

时，您将始终在“行”上求和，如

np.array（[]）

格式所示。查看

arr.sum（axis=2）[0,0]

即

0+1+2+3+4=10

将多维数组视为一棵树。每个维度都是树中的一个级别。该级别上的每个分组都是一个节点。沿着特定轴的和（假设轴=4）意味着将该级别的所有节点合并（叠加）为单个节点（在其各自的父节点下）。在该层级的重叠节点上扎根的子树彼此堆叠。将所有重叠节点的值相加。

---

图片：

使用更简单的3D阵列可能更容易看到。在用1填充数组后，求和中的数字就是特定维度的大小，求和超过！在每种情况下，其他两个尺寸保持不变

arr = np.arange(0,60).reshape(4,3,5)
arr
Out[10]: 
array([[[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]],

       [[15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24],
        [25, 26, 27, 28, 29]],

       [[30, 31, 32, 33, 34],
        [35, 36, 37, 38, 39],
        [40, 41, 42, 43, 44]],

       [[45, 46, 47, 48, 49],
        [50, 51, 52, 53, 54],
        [55, 56, 57, 58, 59]]])

arr=arr*0+1

arr
Out[12]: 
array([[[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]],

       [[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]],

       [[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]],

       [[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]]])

arr0=arr.sum(axis=0,keepdims=True)
arr2=arr.sum(axis=2,keepdims=True)
arr1=arr.sum(axis=1,keepdims=True)

arr0
Out[20]: 
array([[[4, 4, 4, 4, 4],
        [4, 4, 4, 4, 4],
        [4, 4, 4, 4, 4]]])

arr1
Out[21]: 
array([[[3, 3, 3, 3, 3]],

       [[3, 3, 3, 3, 3]],

       [[3, 3, 3, 3, 3]],

       [[3, 3, 3, 3, 3]]])

arr2
Out[22]: 
array([[[5],
        [5],
        [5]],

       [[5],
        [5],
        [5]],

       [[5],
        [5],
        [5]],

       [[5],
        [5],
        [5]]])

---

虽然我理解这些解释（非常好），但框架/语言对维度的处理似乎有问题（2块3x5与5块2x3）。我习惯于用x，y，z来思考，x从左到右屏幕底部，y从底部到顶部屏幕，z从屏幕向我增加。在这种可视化中，根据使用的软件包，我可能会得到不同于预期的结果。@phil，3d，甚至2d，可以以不同的方式显示。三维图形通常是从右到右，

z

向上，

y

斜到左（“页面外”），图像通常是从x到宽，

y

到高，向下。颜色可以被认为是3个颜色平面，或每个像素的属性。表是行（向下）和列（跨）

numpy

数组维度是抽象的，能够存储和处理其中任何一个维度的值。别忘了它们也可以是0d或6d。

arr = np.arange(0,60).reshape(4,3,5)
arr
Out[10]: 
array([[[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]],

       [[15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24],
        [25, 26, 27, 28, 29]],

       [[30, 31, 32, 33, 34],
        [35, 36, 37, 38, 39],
        [40, 41, 42, 43, 44]],

       [[45, 46, 47, 48, 49],
        [50, 51, 52, 53, 54],
        [55, 56, 57, 58, 59]]])

arr=arr*0+1

arr
Out[12]: 
array([[[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]],

       [[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]],

       [[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]],

       [[1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1]]])

arr0=arr.sum(axis=0,keepdims=True)
arr2=arr.sum(axis=2,keepdims=True)
arr1=arr.sum(axis=1,keepdims=True)

arr0
Out[20]: 
array([[[4, 4, 4, 4, 4],
        [4, 4, 4, 4, 4],
        [4, 4, 4, 4, 4]]])

arr1
Out[21]: 
array([[[3, 3, 3, 3, 3]],

       [[3, 3, 3, 3, 3]],

       [[3, 3, 3, 3, 3]],

       [[3, 3, 3, 3, 3]]])

arr2
Out[22]: 
array([[[5],
        [5],
        [5]],

       [[5],
        [5],
        [5]],

       [[5],
        [5],
        [5]],

       [[5],
        [5],
        [5]]])