Python之Numpy学习（2）

数组的转置和换轴

数组的转置拥有T和transpose方法，其中后者可以接收包含轴编号的元组，值得注意的是转置和换轴操作返回的是原数组的视图而非拷贝

In [17]: arr = np.arange(15).reshape(3,5)

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

In [19]: arr.T #行列交换 即原来的arr[1,2]变成arr[2,1]
Out[19]:
array([[ 0,  5, 10],
       [ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13],
       [ 4,  9, 14]])

transpose方法支持指定轴的转置

In [20]: arr = np.arange(16).reshape(2,2,4)

In [21]: arr
Out[21]:
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

In [23]: arr.transpose((1,0,2))#原来是（2,2,4）数组 交换0维和1维后任然是（2,2,4），区别在于原来的（x,y,z）经过变换后是（y,x,z）。
比如原来arr[0,1,2]=7,经过变换后7对应[1,0,2]
Out[23]:
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

In [24]: arr.transpose((1,2,0))#同理，（2,2,4）交换后变成（2,4,2），元素对应发生变化
Out[24]:
array([[[ 0,  8],
        [ 1,  9],
        [ 2, 10],
        [ 3, 11]],

       [[ 4, 12],
        [ 5, 13],
        [ 6, 14],
        [ 7, 15]]])

numpy还有一个swapaxes方法，接收一队轴编号作为参数，进行重组数据，其实现思想与上述方法一样

In [25]: arr
Out[25]:
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

In [26]: arr.swapaxes(0,1)
Out[26]:
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

numpy中条件where方法的使用，来之官方的解释：

where(condition, [x, y])

Return elements, either from `x` or `y`, depending on `condition`.

If only `condition` is given, return ``condition.nonzero()``.

condition : array_like, bool
    When True, yield `x`, otherwise yield `y`.

换成人话就是，若只给了condition，那么返回非0的元素索引；如果即给了condition有个了x,y。若condition为真则使用x,否则使用y。

In [28]: arr = np.random.randn(5,3)

In [29]: arr
Out[29]:
array([[ 0.43703499, -0.05710531,  0.57378502],
       [-0.85058875,  0.70299826, -0.51432804],
       [ 1.19617151,  0.61335183, -0.39875677],
       [ 0.02182784,  0.77989441, -0.48106154],
       [ 0.29206884,  0.57348274, -0.43154266]])

In [30]: np.where(arr > 0)#只给了condition，返回非零元素的索引
Out[30]:
(array([0, 0, 1, 2, 2, 3, 3, 4, 4], dtype=int32),
 array([0, 2, 1, 0, 1, 0, 1, 0, 1], dtype=int32))

In [31]: np.where(arr > 0,1,-1)若元素大于0则置为1，否则为-1
Out[31]:
array([[ 1, -1,  1],
       [-1,  1, -1],
       [ 1,  1, -1],
       [ 1,  1, -1],
       [ 1,  1, -1]])

传递给where的可以是标量和数组的集合，比如，只想让数组中小于0的元素置0，其他元素不变，这是就可以传递一个原数组

In [33]: np.where(arr < 0,0,arr)
Out[33]:
array([[0.43703499, 0.        , 0.57378502],
       [0.        , 0.70299826, 0.        ],
       [1.19617151, 0.61335183, 0.        ],
       [0.02182784, 0.77989441, 0.        ],
       [0.29206884, 0.57348274, 0.        ]])

numpy中数学统计方法的使用

基础数组统计方法

方法	描述
sum	沿着轴向计算所有元素的和
mean	数学平均，0长度平均值是NaN
std,var	标准差和方差，可以自由调整（默认分母是n）
argmin,argmax	最小值和最大值的位置
min,max	最小值和最大值
cumsum	从0开始元素累积和
cumprod	从0开始元素累积积

 

 

 

 

 

 

 

 

 

 mean()方法，可以指定轴

In [41]: arr = np.arange(24).reshape((2,3,4))

In [42]: arr
Out[42]:
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]]])

In [43]: arr.mean()#默认计算所有元素的均值
Out[43]: 11.5

In [44]: arr.mean(axis = 0)#计算维度为0的均值。原来的数组是（2,3,4），将0维度（即2）压缩成1。换句话说以前是两个3*4的数组，
现在压缩成一个
Out[44]:
array([[ 6.,  7.,  8.,  9.],
       [10., 11., 12., 13.],
       [14., 15., 16., 17.]])

In [45]: arr.mean(axis = 1)#同理，计算维度为1的均值，将原来的（2,3,4）变成（2,4）。把维度为1的数组压缩成一个。以前有两个
0维的子数组（0-11,12-23），每个子数组中有3个1维的数组，现在需要把这三个压缩成一个
Out[45]:
array([[ 4.,  5.,  6.,  7.],
       [16., 17., 18., 19.]])

In [46]: arr.mean(axis = 2)
Out[46]:
array([[ 1.5,  5.5,  9.5],
       [13.5, 17.5, 21.5]])

 sum（）方法，同样可以指定轴，思想与上面的一样

In [48]: arr.sum()
Out[48]: 276

In [49]: arr.sum(axis = 0)
Out[49]:
array([[12, 14, 16, 18],
       [20, 22, 24, 26],
       [28, 30, 32, 34]])

In [50]: arr.sum(axis = 1)
Out[50]:
array([[12, 15, 18, 21],
       [48, 51, 54, 57]])

In [51]: arr.sum(axis = 2)
Out[51]:
array([[ 6, 22, 38],
       [54, 70, 86]])

 剩下的其他数学方法使用类似。

对于布尔值数组，有两个非常有用的方法any（）和all（）。

前者判断数组中是否至少有一个True，后者判断每个值是否都是True

In [55]: arr = np.array([True,True,False,True])

In [56]: arr.any()
Out[56]: True

In [57]: arr.all()
Out[57]: False