讲完了数组对象的基本知识，我们今天看看如何变化一个数组的结构，也就是转置操作。

转置，就是在数组维度不变的情况下，使数组结构发生变化的过程。

转置可能是体、行、列的数目发生变化，也可能是元素的排列顺序发生变化。但一个数组的转置，其维度永远不变。

转置有点类似玩魔方。设想一下你也可以将魔方各种颠倒、行变列、列变行，也可以扭转魔方把小块打散。但魔方永远是一个立方体（用锤子不算）。

转置包括以下操作方法：

• np.transpose()方法：将数组的shape进行对调，有参数。
• object.T方法（没有括号）：将行列对调。
• np.swapaxes()方法：调换shape的任意两个值，有参数。
• np.rollaxis()方法：将指定的shape值滚到指定的位置，有参数。

---

np.transpose()方法：

将一个数组的维度，按指定要求对调。共有两个参数：

• a：指定的数组；
• axes：指定的维度顺序，接收一个元组，该元组像索引一样，对应着数组shape（c,b,a）的参数。

像这样：

transpose()参数.png

import numpy as np
arr = np.arange(24).reshape((2,3,4))   # 2块 3行 4列
print('原arr数组：\n',arr)
arr1 = np.transpose(arr, axes=(1,2,0))   # 3块 4行 2列
print('转置后的arr1数组：\n',arr1)
# 运行结果：
原arr数组：
 [[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
转置后的arr1数组：
 [[[ 0 12]
  [ 1 13]
  [ 2 14]
  [ 3 15]]

 [[ 4 16]
  [ 5 17]
  [ 6 18]
  [ 7 19]]

 [[ 8 20]
  [ 9 21]
  [10 22]
  [11 23]]]

发现了吗？

既然理解了axes=（0,1,2）和shape参数（叫“轴”）呈索引对应关系，也就懂了元素是如何被调换的。是的，每个元素都有一个index坐标系（如上例中的元素“0”是[0, 0, 0]，元素“14”是[1, 0, 2]），逐一对每个元素坐标执行axes的调换规则就是了。
最后说一句，transpose()方法不写axes参数，代表直接行列对倒（“轴”对倒），如（2,4）到（4,2），（2,5,3）到（3,5,2）等等。

object.T方法（没有括号）：

这个操作和transpose()方法不带参时别无二致，不多讲了。

swapaxes()方法：

该方法用于交换数组的任意两个轴。共有三个参数：

• a：指定的数组；
• axis1：要对调的一个轴；
• axis2：要对调的另一个轴。

import numpy as np
arr = np.arange(24).reshape((2,3,4))   # 2块 3行 4列
print('原arr数组：\n',arr)
print('原arr数组的shape：',arr.shape)
arr1 = np.swapaxes(arr, axis1=1, axis2=2)  # arr的1轴（行）和2轴（列）对调。也可写成（arr,2,1）是一个意思

print('对调任意两个轴后的arr1数组:\n',arr1)
print('arr1的shape：',arr1.shape)
# 运行结果：
原arr数组：
 [[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
原arr数组的shape： (2, 3, 4)
对调任意两个轴后的arr1数组:
 [[[ 0  4  8]
  [ 1  5  9]
  [ 2  6 10]
  [ 3  7 11]]

 [[12 16 20]
  [13 17 21]
  [14 18 22]
  [15 19 23]]]
arr1的shape： (2, 4, 3)

rollaxis()方法：

将指定的shape值滚到指定的位置。注意rolaxis是滚，不是调。

rollaxis向后滚动.png

参数也有三个：

• a：指定的数组；
• axis：指定要滚动的轴；
• start：滚到第几位。不写默认start=0，即让轴移动到第一位。

import numpy as np
arr = np.arange(120).reshape((3,5,2,4))   # 2块 3行 4列
arr1 = np.rollaxis(arr, axis=0, start=4)  # shape()的0轴滚到第4个
arr2 = np.rollaxis(arr, axis=2, start=1)  # shape()的2轴滚到第2个
arr3 = np.rollaxis(arr, axis=3, start=4)  # shape()的3轴滚到第4个
arr4 = np.rollaxis(arr, axis=3, start=2)  # shape()的3轴滚到第3个
arr5 = np.rollaxis(arr, axis=0, start=0)  # shape()的0轴滚到第1个

print('原arr数组的shape：',arr.shape)
print('arr1的shape：',arr1.shape)
print('arr2的shape：',arr2.shape)
print('arr3的shape：',arr3.shape)
print('arr4的shape：',arr4.shape)
print('arr5的shape：',arr5.shape)
# 运行结果：
原arr数组的shape： (3, 5, 2, 4)
arr1的shape： (5, 2, 4, 3)
arr2的shape： (3, 2, 5, 4)
arr3的shape： (3, 5, 2, 4)
arr4的shape： (3, 5, 4, 2)
arr5的shape： (3, 5, 2, 4)

以上是数组转置的所有内容。其实四个方法有很多共通之处，底层都是调动轴索引到指定位置。

我们拿一个小案例，用四种方法实现对一个二维数组的T转置（行列互倒）。

import numpy as np
arr = np.arange(12).reshape(3, 4)
arr1 = np.transpose(a=arr, axes=(1,0))   # 将0轴和1轴重新排序
arr2 = np.swapaxes(a=arr, axis1=0, axis2=1)   # 将0轴和一轴对调
arr3 = arr.T   # T转置
arr4 = np.rollaxis(a=arr, axis=1, start=0)  # 将1轴提到最前面
print('arr数组的shape:', arr.shape)
print('arr1数组的shape:', arr1.shape)
print('arr2数组的shape:', arr2.shape)
print('arr3数组的shape:', arr3.shape)
print('arr4数组的shape:', arr4.shape)
# 运行结果：
arr数组的shape: (3, 4)
arr1数组的shape: (4, 3)
arr2数组的shape: (4, 3)
arr3数组的shape: (4, 3)
arr4数组的shape: (4, 3)

---

“轴”，是操作array对象非常重要的概念。让我们再总结下何为“轴”：

轴，基于数组的shape而存在。

• 当shape有1个，即（a,）：
  此时a是0轴；代表array对象的最小元素 --- 列。

• 当shape为2个，即（b,a）：
  此时b是0轴，代表array对象的 --- 行；
  此时a是1轴，代表array对象的最小元素 --- 列。

• 当shape为3个，即（c,b,a）：
  此时c是0轴，代表array对象的 --- 块；
  此时b是1轴，代表array对象的 --- 行；
  此时a是2轴，代表array对象的最小元素 --- 列。

• 当shape为4个，即（d,c,b,a）：
  此时d是0轴，代表array对象的 --- 大块（土话别介意 =。=）；
  此时c是1轴，代表array对象的 --- 小块；
  此时b是2轴，代表array对象的 --- 行；
  此时a是3轴，代表array对象的最小元素 --- 列。

有逻辑的地方在于，在shape(2,3,4)中，你可以把轴理解为shape元素的索引，通过索引定位到shape元素，并实现元素间的各种对倒和互换；
而在一个可视化的数组中，比如print(array)时，可以把轴理解为数组的颗粒度递增，就像上面的shape(d,c,b,a)，0轴代表大块，1轴代表小块，2轴代表行，3轴代表列。而shape(a,)，0轴代表列，因为列已经是最小的分割单位了。

---

更新一下numpy系列的学习进度：

后面会再讲一下numpy的数组拼接和分割，希望用一篇搞定。而后有关数组的常规操作就讲完了，到此你也对numpy的玩法有了相当全面的掌握。再往后就是各种数学函数的调用，用来实现特定的计算。没有太多烧脑的部分，甚至需要时再百度也来得及。