Python学习笔记--Numpy--Numpy 数组形状

目录：

名称	作用	备注
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)
 in ()
----> 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 方法的作用是将多维数组转化为1维数组：

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

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 的一个view。

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  返回的结果是从小到大排列的