Numpy基础知识

Numpy基础（个人微信公众号：“我将在南极找寻你”）

1Numpy数组对象以及创建方式

ndarray是一个多维数组对象，由“实际数据”+“元数据”组成

创建一维数组

1. >>> a=np.arange(5)

2. >>> a.dtype

3. dtype('int32')

4. >>> a

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

6. >>> a.shape

7. (5L,)

创建多维数组

1. >>> c=np.array([np.arange(4),np.arange(4),np.arange(4)])

2. >>> c

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

4.       [0, 1, 2, 3],

5.       [0, 1, 2, 3]])

6. >>> c.shape

7. (3L, 4L)

2选取数组元素

首先创建一个2*2数组：

1. >>> a=np.array([[1,2],[3,4]])

2. >>> a

3. array([[1, 2],

4.       [3, 4]])

开始选取：

1. >>> a[0,0]

2. 1

3. >>> a[0,1]

4. 2

3指定Numpy数据类型

1. >>> x=np.arange(5,dtype=int)

2. >>> x

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

4. >>> x.dtype

5. dtype('int32')

4索引与切片

一维数组的索引与切片

1. >>> r=np.arange(10)

2. >>> r

3. array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

4. >>> r[0:4]

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

6. >>> r[:4]

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

8. >>> r[3:7]

9. array([3, 4, 5, 6])

10. >>> r[:7:2]

11. array([0, 2, 4, 6])

12. >>> r[::-1]

13. array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

多维数组的索引与切片

首先创建一个数组并改变其维度为3维

1. >>> x.shape

2. (24L,)

3. >>> x=np.arange(24).reshape(2,3,4)

4. >>> x.shape

5. (2L, 3L, 4L)

6. >>> x

7. array([[[ 0,  1,  2,  3],

8.        [ 4,  5,  6,  7],

9.        [ 8,  9, 10, 11]],

10.       [[12, 13, 14, 15],

11.        [16, 17, 18, 19],

12.        [20, 21, 22, 23]]])

选取特定元素：

1. >>> x[0,0,0]

2. 0

3. >>> x[0,1,1]

4. 5

切片：

1. >>> x[:,0,0]

2. array([ 0, 12])

3. >>> x[0]

4. array([[ 0,  1,  2,  3],

5.       [ 4,  5,  6,  7],

6.       [ 8,  9, 10, 11]])

7. >>> x[0,:,:]

8. array([[ 0,  1,  2,  3],

9.       [ 4,  5,  6,  7],

10.       [ 8,  9, 10, 11]])

11. >>> x[0,...]

12. array([[ 0,  1,  2,  3],

13.       [ 4,  5,  6,  7],

14.       [ 8,  9, 10, 11]])

15. >>> x[0,1]

16. array([4, 5, 6, 7])

间隔选取

1. >>> x[0,1]

2. array([4, 5, 6, 7])

3. >>> x[0,0,::2]

4. array([0, 2])

5. >>> x[0,1,::2]

6. array([4, 6])

7. >>> x[0,1,::1]

8. array([4, 5, 6, 7])

9. >>> x[0,1]

10. array([4, 5, 6, 7])

11. >>> x[0,::2,-1]

12. array([ 3, 11])

13. >>> x[0,::-1,-1]

14. array([11,  7,  3])

：：2代表间隔为2（含第一个元素）

上下翻转：

1. >>> x[::-1]

2. array([[[12, 13, 14, 15],

3.        [16, 17, 18, 19],

4.        [20, 21, 22, 23]],

5.       [[ 0,  1,  2,  3],

6.        [ 4,  5,  6,  7],

7.        [ 8,  9, 10, 11]]])

其实就是把列逆序重排了一下

5改变数组维度

（1）ravel：将ndarray展平成一维数组

1. >>> x

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

3.        [ 4,  5,  6,  7],

4.        [ 8,  9, 10, 11]],

5.       [[12, 13, 14, 15],

6.        [16, 17, 18, 19],

7.        [20, 21, 22, 23]]])

8. >>> x.ravel

9. <built-in method ravel of numpy.ndarray object at 0x0000000003497490>

10. >>> x.ravel()

11. array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,

12.       17, 18, 19, 20, 21, 22, 23])

（2）flatten:作用与ravel类似，但是它会请求分配内存来保存结果

（3）用tuple来设置维度，功能同reshape：

1. >>> x.shape

2. (2L, 3L, 4L)

3. >>> x.shape=(3,8)

4. >>> x.shape

5. (3L, 8L)

6. >>> x

7. array([[ 0,  1,  2,  3,  4,  5,  6,  7],

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

9.       [16, 17, 18, 19, 20, 21, 22, 23]])

（4）transpose：转置

1. >>> x

2. array([[ 0,  1,  2,  3,  4,  5,  6,  7],

3.       [ 8,  9, 10, 11, 12, 13, 14, 15],

4.       [16, 17, 18, 19, 20, 21, 22, 23]])

5. >>> x.transpose()

6. array([[ 0,  8, 16],

7.       [ 1,  9, 17],

8.       [ 2, 10, 18],

9.       [ 3, 11, 19],

10.       [ 4, 12, 20],

11.       [ 5, 13, 21],

12.       [ 6, 14, 22],

13.       [ 7, 15, 23]])

（5）resize：同reshape，但会直接修改所操作的数组

1. >>> x

2. array([[ 0,  1,  2],

3.       [ 3,  4,  5],

4.       [ 6,  7,  8],

5.       [ 9, 10, 11],

6.       [12, 13, 14],

7.       [15, 16, 17],

8.       [18, 19, 20],

9.       [21, 22, 23]])

10. >>> x.resize(6,4)

11. >>> x

12. array([[ 0,  1,  2,  3],

13.       [ 4,  5,  6,  7],

14.       [ 8,  9, 10, 11],

15.       [12, 13, 14, 15],

16.       [16, 17, 18, 19],

17.       [20, 21, 22, 23]])

18. >>> x.shape

19. (6L, 4L)

6数组的组合

首先，我们来创建一个数组 ：

1. >>> a=np.array(np.arange(9)).reshape(3,3)

2. >>> a

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

4.       [3, 4, 5],

5.       [6, 7, 8]])

或者

1. >>> a=np.arange(9).reshape(3,3)

2. >>> a

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

4.       [3, 4, 5],

5.       [6, 7, 8]])

两者都可以生成，whatever，我们已经创建完了数组a，下面来创建数组b

1. >>> b=2*a

2. >>> b

3. array([[ 0,  2,  4],

4.       [ 6,  8, 10],

5.       [12, 14, 16]])

（1）水平组合

hstack

1. >>> np.hstack((a,b))

2. array([[ 0,  1,  2,  0,  2,  4],

3.       [ 3,  4,  5,  6,  8, 10],

4.       [ 6,  7,  8, 12, 14, 16]])

concatenate

1. >>> np.concatenate((a,b),axis=1)

2. array([[ 0,  1,  2,  0,  2,  4],

3.       [ 3,  4,  5,  6,  8, 10],

4.       [ 6,  7,  8, 12, 14, 16]])

（2）垂直组合

vstack

1. >>> np.vstack((a,b))

2. array([[ 0,  1,  2],

3.       [ 3,  4,  5],

4.       [ 6,  7,  8],

5.       [ 0,  2,  4],

6.       [ 6,  8, 10],

7.       [12, 14, 16]])

concatenate

1. >>> np.concatenate((a,b),axis=0)

2. array([[ 0,  1,  2],

3.       [ 3,  4,  5],

4.       [ 6,  7,  8],

5.       [ 0,  2,  4],

6.       [ 6,  8, 10],

7.       [12, 14, 16]])

一般来说，axis=0在行（竖向）方向上处理，axis=1在列（横向）方向上处理

（3）深度组合

1. >>> np.dstack((a,b))

2. array([[[ 0,  0],

3.        [ 1,  2],

4.        [ 2,  4]],

5.       [[ 3,  6],

6.        [ 4,  8],

7.        [ 5, 10]],

8.       [[ 6, 12],

9.        [ 7, 14],

10.        [ 8, 16]]])

11. >>> np.dstack((a,b)).shape

12. (3L, 3L, 2L)

所谓深度组合，就是将一系列数组沿着纵轴方向进行层叠组合

（4）列组合

column_stack

1. >>> oned=np.arange(2)

2. >>> oned

3. array([0, 1])

4. >>> twice_oned=2*oned

5. >>> twice_oned

6. array([0, 2])

7. >>> np.column_stack((oned,twice_oned))

8. array([[0, 0],

9.       [1, 2]])

所以对于二维数组，column_stack与hstack效果相同

（5）行组合

row_stack

1. >>> np.row_stack((oned,twice_oned))

2. array([[0, 1],

3.       [0, 2]])

所以对于二维数组，row_stack与vstack效果相同

7数组的分割

（1）水平分割

hsplit

1. >>> np.hsplit(a,3)

2. [array([[0],

3.       [3],

4.       [6]]), array([[1],

5.       [4],

6.       [7]]), array([[2],

7.       [5],

8.       [8]])]

分割成了3个子数组，他们组成了一个列表

>>> len(np.hsplit(a,3))

3

>>> type(np.hsplit(a,3))

<type 'list'>

>>> 

split，取axis=1

1. >>> a

2. array([[0, 1, 2],

3.       [3, 4, 5],

4.       [6, 7, 8]])

5. >>> np.split(a,3,axis=1)

6. [array([[0],

7.       [3],

8.       [6]]), array([[1],

9.       [4],

10.       [7]]), array([[2],

11.       [5],

12.       [8]])]

（2）垂直分割

vsplit

1. >>> a

2. array([[0, 1, 2],

3.       [3, 4, 5],

4.       [6, 7, 8]])

5. >>> np.vsplit(a,3)

6. [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

split，取axis=0

1. >>> np.split(a,3,axis=0)

2. [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

（3）深度分割

所谓深度分割，就是按照深度方向分割数组

首先创建一个3维数组

1. >>> c=np.arange(27).reshape(3,3,3)

2. >>> c.shape

3. (3L, 3L, 3L)

4. >>> c

5. array([[[ 0,  1,  2],

6.        [ 3,  4,  5],

7.        [ 6,  7,  8]],

8.       [[ 9, 10, 11],

9.        [12, 13, 14],

10.        [15, 16, 17]],

11.       [[18, 19, 20],

12.        [21, 22, 23],

13.        [24, 25, 26]]])

然后利用dsplit函数进行深度分割

1. >>> np.dsplit(c,3)

2. [array([[[ 0],

3.        [ 3],

4.        [ 6]],

5.       [[ 9],

6.        [12],

7.        [15]],

8.       [[18],

9.        [21],

10.        [24]]]), array([[[ 1],

11.        [ 4],

12.        [ 7]],

13.       [[10],

14.        [13],

15.        [16]],

16.       [[19],

17.        [22],

18.        [25]]]), array([[[ 2],

19.        [ 5],

20.        [ 8]],

21.       [[11],

22.        [14],

23.        [17]],

24.       [[20],

25.        [23],

26.        [26]]])]

分割成了1个列表，长度为3

1. >>> type(np.dsplit(c,3))

2. <type 'list'>

3. >>> len(np.dsplit(c,3))

4. 3

8数组的属性

ndim：给出数组的维数或者数组轴的个数

size：给出数组元素的总个数

itemsize：给出数组中的元素在内存中所占用的字节数

nbytes：size*itemsize

T：与transpose一样

复数的虚部用j表示：

1. >>> b=np.array([1.j+1,2.j+3])

2. >>> b

3. array([ 1.+1.j,  3.+2.j])

real：给出复数数组的实部：

1. >>> b.real

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

imag：给出复数数组的虚部：

1. >>> b.imag

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

fliter属性将返回一个numpy.flatiter对象：

1. >>> z=np.arange(6).reshape(3,2)

2. >>> z

3. array([[0, 1],

4.       [2, 3],

5.       [4, 5]])

6. >>> f=z.flat

7. >>> f

8. <numpy.flatiter object at 0x00000000032BED00>

9. >>> for item in f:

10.    print item

11. 0

12. 1

13. 2

14. 3

15. 4

16. 5

还可以直接用flatiter队对象获取一个数组元素：

1. >>> z.flat[2]

2. 2

或者获取多个元素：

1. >>> z.flat[[0,1,2]]

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

falt是一个可赋值的属性，赋值将导致整个数组数组的元素都被覆盖：

1. >>> z.flat=1

2. >>> z

3. array([[1, 1],

4.       [1, 1],

5.       [1, 1]])

或者：

1. >>> z.flat[[0,1,2,3]]=10

2. >>> z

3. array([[10, 10],

4.       [10, 10],

5.       [ 1,  1]])

9数组的转换

tolist函数：将Numpy转换为Python列表

1. >>> z

2. array([[10, 10],

3.       [10, 10],

4.       [ 1,  1]])

5. >>> z.tolist()

6. [[10, 10], [10, 10], [1, 1]]

7. >>> type( z.tolist())

8. <type 'list'>

1. >>> b

2. array([ 1.+1.j,  3.+2.j])

3. >>> b.tolist()

4. [(1+1j), (3+2j)]

5. >>> type(b.tolist())

6. <type 'list'>

astype函数可以在转换数组时指定数据类型：

1. >>> b

2. array([ 1.+1.j,  3.+2.j])

3. >>> b.astype(int)

4. Warning (from warnings module):

5.  File "__main__", line 2

6. ComplexWarning: Casting complex values to real discards the imaginary part

7. array([1, 3])

9. >>> b.astype('complex')

10. array([ 1.+1.j,  3.+2.j])

11. >>> b.astype(complex)

12. array([ 1.+1.j,  3.+2.j])