Question

我对Python的高级切片感到困惑。我基本上有一本字典，在SO的帮助下，我把它变成了一个数组。

   array1 = 
   ([[[36, 16],
    [48, 24],
    [12,  4],
    [12,  4]],

   [[48, 24],
    [64, 36],
    [16,  6],
    [16,  6]],

   [[12,  4],
    [16,  6],
    [ 4,  1],
    [ 4,  1]],

   [[12,  4],
    [16,  6],
    [ 4,  1],
    [ 4,  1]]])

为了练习使用矩阵求解器，使用：

将阵列转换为方阵（4 x 4）

 array_matrix_sized = array[:, :, 0]

我读到这意味着[索引，行数，列数]。关于为什么[：，：，0]返回一个4 x 4矩阵，我有点无能为力。为了尝试提供帮助，我制作了一个长度为100的数组，并且我一直试图以类似的方式将其转换为10 x 10矩阵，但没有成功。什么让我失望的是行数是＆＃34;：＆＃34;如果我正确地阅读了这个概念，那么列数是＆＃34; 0＆＃34;对于4 x 4矩阵，为什么不是数组[：，4,4]？我也假设：因为我对所有价值感兴趣。

提前感谢您提供任何帮助/建议。如果这是一个简单的问题，我会道歉，但我真的可以澄清它的工作原理。

仍然不太了解。如果我有

 array2 = 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,  60,  61,  62,  63,  64,
    65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
    78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
    91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103,
   104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
   117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
   130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
   143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
   156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
   169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
   182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
   195, 196, 197, 198, 199])

为了将它变成10×10矩阵，我尝试使用array2 [：，：，0]并获得错误IndexError：数组的索引太多了。这不是我的第一个例子吗？

Answer 1

我读到这意味着[索引，行数，列数]。 [...]如果我正确地阅读了这个概念，那么抛出我的是行数是“：”而列数是“0”。

没有。它意味着[尺寸1上我需要哪些部件，尺寸2上我想要哪些部件，尺寸3上我想要哪些部件]。索引不是您想要的行/列数，它们是您想要的。并且，正如您所说:在这种情况下意味着“所有”。

对于4 x 4矩阵，为什么不是数组[：，4,4]？

您没有指定结果的形状。结果的形状取决于原始数组的形状。由于您的数组是4x4x2，因此在最后一个维度上获取一个元素可以获得4x4。如果数组为8x7x2，那么[:, :, 0]将为您提供8x7的结果。

所以[:, :, 0]表示“给我前两个维度上的所有内容，但只提供最后一个维度上的第一个项目。这相当于获取每个”行“的第一个元素（或第一个”列“为它出现在显示屏上）这就是你得到结果的原因：

>>> array1[:, :, 0]
array([[36, 48, 12, 12],
       [48, 64, 16, 16],
       [12, 16,  4,  4],
       [12, 16,  4,  4]])

同样，做[0, :, :]会给你第一个“块”：

>>> array1[0, :, :]
array([[36, 16],
       [48, 24],
       [12,  4],
       [12,  4]])

执行[:, 0, :]会为您提供每个块的第一行：

>>> x[:, 0, :]
array([[36, 16],
       [48, 24],
       [12,  4],
       [12,  4]])

Answer 2

我只想添加一个澄清的例子：

>>> np.arange(4*4*2).reshape(4,4,2)
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]]])

由于我们处于三个维度，我们仍然可以保持一个空间隐喻。想象一下，这些4X2切片在你面前依次堆叠起来（就像它们是书本一样）。也就是说，我们采取第一个，并支持它像一本书，第二个支持它，等等。我们从第一个维度中选择第一个块，它只是让我们回到第一个“书”：

>>> a[0,:,:]
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7]])

现在看看它与第二维的第一块之间的区别：

>>> a[:,0,:]
array([[ 0,  1],
       [ 8,  9],
       [16, 17],
       [24, 25]])

这就像切顶一样。想象一下剃掉顶部。碰巧的是，对于您发布的阵列，这些都是一样的！

现在终于，第三个维度的第一个块：

>>> a[:,:,0]
array([[ 0,  2,  4,  6],
       [ 8, 10, 12, 14],
       [16, 18, 20, 22],
       [24, 26, 28, 30]])

这就像把你面前的东西切成两半 - 想象一下空手道劈开。

这是一张（非常粗糙的）图片（在我的笔记本电脑上绘制...对不起）。

Answer 3

这本书的比喻很好，但我倾向于以稍微不同的顺序排列我的数组。如果我们考虑以下数据数组......

a = np.arange(2*3*4).reshape(2,3,4)
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]]])

对我来说，上面的内容是2页，一页在另一页之上。每页有3行，每行有4个单词。

我写了一个函数来获取相同的信息并将它并排排列，因为这是我倾向于安排我正在处理的事情的方式。（这里的细节并不相关......）。这是视觉目的的重新安排......

a = np.arange(2*3*4).reshape(2,3,4)

Array... shape (2, 3, 4), ndim 3, not masked
  0,  1,  2,  3    12, 13, 14, 15   
  4,  5,  6,  7    16, 17, 18, 19   
  8,  9, 10, 11    20, 21, 22, 23   
 sub (0)           sub (1)    

a[0,:,:]
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

a[:,0,:]
array([[ 0,  1,  2,  3],
       [12, 13, 14, 15]])

>>> a[:,:,0]
array([[ 0,  4,  8],
       [12, 16, 20]])

所以在我的例子中，从[0，：，]，[[，0，：]到[：，：，0]的序列遵循序列页，行和单词。

人们可以从不同的角度来论证，但我认为重要的是要认识到并非所有人都以同样的方式看待事物。我经常使用图像，我更喜欢上面的（图像，行，列）排列，它等同于（页面，行，单词）符号。

请注意......如果您不喜欢阵列的外观，或者它不适合您...只需交换轴。

a.swapaxes(2,0)
array([[[ 0, 12],
        [ 4, 16],
        [ 8, 20]],

       [[ 1, 13],
        [ 5, 17],
        [ 9, 21]],

       [[ 2, 14],
        [ 6, 18],
        [10, 22]],

       [[ 3, 15],
        [ 7, 19],
        [11, 23]]])

仍然感觉不到？...尝试不同的安排，直到它点击或简化您的计算。

Answer 4

代码> DF ft_technical ft_performative ft_procedural ft_moral topic_lab 1 3 10 9 10 performative 2 8 5 7 9 moral 3 4 6 6 6 performative 4 7 9 10 8 procedural 5 6 1 4 1 technical 6 1 7 8 3 procedural 7 10 8 3 4 technical 8 9 4 2 7 technical 9 2 3 1 5 moral 10 5 2 5 2 technical。如果代码为s=np.arange(Total no. of matrices * number of rows * number of columns).reshape(Total no. of matrices * number of rows * number of columns)的示例[[5 =要生成的矩阵总数]]。[[4 * 4是4 * 4维矩阵]]。将会得到5个矩阵，每个矩阵都是4 * 4维矩阵。代码rameez=np.arange(5*4*4).reshape(5,4,4)将整体生成10个矩阵，每个矩阵具有（（3 * 2））维。

Python高级切片

4 个答案: