目录：

名称

作用

备注

shape和reshape

可直接修改数组形状

都没有括号，前者改变后会改变原来数组形状，后者不会

newaxis

 

增加数组维数

 

根据插入位置的不同，可以返回不同形状的数组：

squeeze

 

去除多余的轴

 

squeeze 返回一个将所有长度为1的维度去除的新数组

a.transpose()

a.T

 

数组转置

 

转置可以作用于多维数组

转置返回的是对原数组的另一种view，所以改变转置会改变原来数组的值

concatenate((a0,a1,...,aN), axis=0)

数组连接

 

默认沿着第一维进行连接

Vstack 沿着第一维

Hstack 沿着第二维

Dstack 连接成三维

Flatten

ravel

 

将多维数组转化为1维数组

b = a.flatten()

b = a.ravel()

前者修改b会改变a

后者不会

atleast_xd

 

保证数组至少有 x 维：

x 可以取值 1，2，3。



修改数组的形状


In [2]: 



a = arange(6)
a



Out[2]:



array([0, 1, 2, 3, 4, 5])




将形状修改为2乘3：


In [3]: 



a.shape = 2,3
a



Out[3]:



array([[0, 1, 2], [3, 4, 5]])



与之对应的方法是 reshape

In [4]: 



a.reshape(3,2)



Out[4]:



array([[0, 1], [2, 3], [4, 5]])


In [5]: 



a



Out[5]:



array([[0, 1, 2], [3, 4, 5]])



shape 和 reshape

In [6]: 



a.reshape(4,2)




---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-6-1a35a76a1693> in <module>()
----> 1 a.reshape(4,2)

ValueError: total size of new array must be unchanged




使用 newaxis 增加数组维数


In [7]: 



a = arange(3)
shape(a)



Out[7]:



(3L,)


In [8]: 



y = a[newaxis, :]
shape(y)



Out[8]:



(1L, 3L)




根据插入位置的不同，可以返回不同形状的数组：


In [9]: 



y = a[:, newaxis]
shape(y)



Out[9]:



(3L, 1L)




插入多个新维度：


In [10]: 



y = a[newaxis, newaxis, :]
shape(y)



Out[10]:



(1L, 1L, 3L)




squeeze 方法去除多余的轴


In [11]: 



a = arange(6)
a.shape = (2,1,3)


In [12]: 



b = a.squeeze()
b.shape



Out[12]:



(2L, 3L)




squeeze 返回一个将所有长度为1的维度去除的新数组。




数组转置



使用 transpose

In [13]: 



a



Out[13]:



array([[[0, 1, 2]], [[3, 4, 5]]])




对于二维数组，这相当于交换行和列：


In [14]: 



a.transpose()



Out[14]:



array([[[0, 3]], [[1, 4]], [[2, 5]]])




或者使用缩写属性：


In [15]: 



a.T



Out[15]:



array([[[0, 3]], [[1, 4]], [[2, 5]]])




注意：

  • 对于复数数组，转置并不返回复共轭，只是单纯的交换轴的位置
  • 转置可以作用于多维数组


In [16]: 



a = arange(60)
a



Out[16]: 



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])


In [17]: 



a.shape = 3,4,5
a



Out[17]: 



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]]])


In [18]: 



b = a.T
b.shape



Out[18]:



(5L, 4L, 3L)




转置只是交换了轴的位置。

另一方面，转置返回的是对原数组的另一种view，所以改变转置会改变原来数组的值。


In [19]: 



a = arange(6)
a.shape = (2,3)
a



Out[19]:



array([[0, 1, 2], [3, 4, 5]])




修改转置：


In [20]: 



b = a.T
b[0,1] = 30




原数组的值也改变：


In [21]: 



a



Out[21]:



array([[ 0, 1, 2], [30, 4, 5]])




数组连接




有时我们需要将不同的数组按照一定的顺序连接起来：




concatenate((a0,a1,...,aN), axis=0)



注意，这些数组要用 ()



除了给定的轴外，这些数组其他轴的长度必须是一样的。


In [22]: 



x = array([
        [0,1,2],
        [10,11,12]
    ])
y = array([
        [50,51,52],
        [60,61,62]
    ])
print x.shape
print y.shape




(2L, 3L) (2L, 3L)




默认沿着第一维进行连接：


In [23]: 



z = concatenate((x,y))
z



Out[23]: 



array([[ 0,  1,  2],
       [10, 11, 12],
       [50, 51, 52],
       [60, 61, 62]])


In [24]: 



z.shape



Out[24]:



(4L, 3L)




沿着第二维进行连接：


In [25]: 



z = concatenate((x,y), axis=1)
z



Out[25]: 



array([[ 0,  1,  2, 50, 51, 52],
       [10, 11, 12, 60, 61, 62]])


In [26]: 



z.shape



Out[26]:



(2L, 6L)



注意到这里 x 和 y 的形状是一样的，还可以将它们连接成三维的数组，但是 concatenate

In [27]: 



z = array((x,y))


In [28]: 



z.shape



Out[28]:



(2L, 2L, 3L)




事实上，Numpy提供了分别对应这三种情况的函数：

  • vstack
  • hstack
  • dstack


In [29]: 



vstack((x, y)).shape



Out[29]:



(4L, 3L)


In [30]: 



hstack((x, y)).shape



Out[30]:



(2L, 6L)


In [31]: 



dstack((x, y)).shape



Out[31]:



(2L, 3L, 2L)




Flatten 数组



flatten

In [32]: 



a = array([[0,1],
           [2,3]])
b = a.flatten()
b



Out[32]:



array([0, 1, 2, 3])



返回的是数组的复制，因此，改变 b 并不会影响 a

In [33]: 



b[0] = 10
print b
print a




[10 1 2 3] [[0 1] [2 3]]




flat 属性



还可以使用数组自带的 flat

In [34]: 



a.flat



Out[34]:



<numpy.flatiter at 0x3d546a0>



a.flat

In [35]: 



b = a.flat


In [36]: 



b[0]



Out[36]:



0



但此时修改 b 的值会影响 a

In [37]: 



b[0] = 10
print a




[[10 1] [ 2 3]]


In [38]: 



a.flat[:]



Out[38]:



array([10, 1, 2, 3])




ravel 方法



除此之外，还可以使用 ravel 方法，ravel

In [39]: 



a = array([[0,1],
           [2,3]])
b = a.ravel()
b



Out[39]:



array([0, 1, 2, 3])



修改 b 会改变 a

In [40]: 



b[0] = 10
a



Out[40]:



array([[10, 1], [ 2, 3]])




但另一种情况下：


In [41]: 



a = array([[0,1],
           [2,3]])
aa = a.transpose()
b = aa.ravel()
b



Out[41]:



array([0, 2, 1, 3])


In [42]: 



b[0] = 10


In [43]: 



aa



Out[43]:



array([[0, 2], [1, 3]])


In [44]: 



a



Out[44]:



array([[0, 1], [2, 3]])



可以看到，在这种情况下，修改 b 并不会改变 aa 的值，原因是我们用来 ravel 的对象 aa 本身是 a



atleast_xd 函数



保证数组至少有 x

In [45]: 



x = 1
atleast_1d(x)



Out[45]:



array([1])


In [46]: 



a = array([1,2,3])
b = atleast_2d(a)
b.shape



Out[46]:



(1L, 3L)


In [47]: 



b



Out[47]:



array([[1, 2, 3]])


In [48]: 



c = atleast_3d(b)


In [49]: 



c.shape



Out[49]:



(1L, 3L, 1L)





sort

 返回的结果是从小到大排列的