1. 创建数组

1.1 array()

可以利用array()函数将Python列表或元组类型数据直接转化为numpy.array数组（以下简称为“数组”）。

import numpy as np

a = np.array([2, 3, 4])
# note that `a=np.array(2, 3, 4)` is wrong

a
Out[3]: array([2, 3, 4])

a.dtype
Out[4]: dtype('int32')

b = np.array([1.2, 3.5, 5.1])

b
Out[6]: array([ 1.2,  3.5,  5.1])

b.dtype
Out[7]: dtype('float64')

利用array()函数，还可以根据参数中序列的嵌套层数创建二维或三维数组。同时，可以通过array()函数中的dtype参数指定数组中的数据类型。

c = np.array([(1.5, 2, 3), (4, 5, 6)])

c
Out[9]: 
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

d = np.array([[1, 2], [3, 4]], dtype=complex)

d
Out[11]: 
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])

1.2 zeros()和ones()和empty()

多数情况下，数组的维数及数据数量是已知的，但具体的数据值是未知的。此时可以利用zeros()、ones()、empty()函数创建数组，其中的初始数据起到占位作用。

• zeros()函数创建的数组中，所有初始数据均为0；
• ones()函数创建的数组中，所有初始数据均为1；
• empty()函数创建的数组中，所有初始数据是随机生成的，且与存储状态有关。

np.zeros((3,4))
Out[12]: 
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])

np.ones((2,3,4), dtype=np.int16)
Out[13]: 
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]], dtype=int16)

np.empty((2,3))
Out[14]: 
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

1.3 arange()和linspace()

利用arange()和linspace()函数可以创建一个由数列组成的数组。二者的区别在于arange()函数中定义的是数组中元素间的步长，而linspace()函数中定义的则是数组中元素的数量。

np.arange( 10, 30, 5 )
Out[16]: array([10, 15, 20, 25])

np.arange( 0, 2, 0.3 )
Out[17]: array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

np.linspace( 0, 2, 9 )
Out[18]: array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])

2. 数组的基本属性

通过以上方法创建的数组均为numpy.ndarray类型，其主要属性包括：

• ndarray.ndim: 数组的维数；
• ndarray.shape: 返回一个由整数构成的元组，给出数组中每一维中的元素数量，例如一个由n行和m列构成的矩阵，其ndarray.shape的返回结果为(n, m);
• ndarray.size: 返回数组中所有元素的数量，其数值等于ndarray.shape返回的元组中的各个元组的乘积；
• ndarray.dtype: 返回数组中所有元素的数据类型（数组中所有元素的类型需保持一致）；

e = np.arange(15).reshape(3, 5)

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

e.ndim
Out[26]: 2

e.shape
Out[27]: (3, 5)

e.size
Out[28]: 15

e.dtype
Out[29]: dtype('int32')

3. 基本算数操作

对数组进行算数操作，实际上是对其中的各个元素依次进行算术操作。注意，乘号*只进行简单的元素间相乘，如果想要完成矩阵相乘，则应使用dot()函数或方法。

a = np.array([20, 30, 40, 50])

b = np.arange(4)

b
Out[32]: array([0, 1, 2, 3])

c = a - b

c
Out[34]: array([20, 29, 38, 47])

b**2
Out[35]: array([0, 1, 4, 9], dtype=int32)

10 * np.sin(a)
Out[36]: array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])

a < 35
Out[37]: array([ True,  True, False, False], dtype=bool)

A = np.array([[1, 1], [0, 1]])

B = np.array([[2, 0], [3, 4]])

A*B
Out[40]: 
array([[2, 0],
       [0, 4]])

A.dot(B)
Out[41]: 
array([[5, 4],
       [3, 4]])

np.dot(A, B)
Out[43]: 
array([[5, 4],
       [3, 4]])

诸如+=和*=之类的运算符，其运算结果会用来更改原有的数组，而不会新建数组。但当两个数组中的数据类型不同时，应注意数据类型转换的问题，避免引发异常。

a = np.ones((2,3), dtype=int)

b = np.random.random((2, 3))

a *= 3

a
Out[61]: 
array([[3, 3, 3],
       [3, 3, 3]])

b += a
# if we use `a += b`, it will raise an exception 
# because `b` is not automatically converted to integer type

b
Out[63]: 
array([[ 3.81943122,  3.59808999,  3.27408353],
       [ 3.73746823,  3.57589972,  3.05348849]])

一些单元运算符，如求和计算，可以通过numpy.ndarray类中的方法来实现。默认情况下，这些方法会应用于数组中的所有元素，但也可以通过定义这些方法中的axis参数，将这些方法应用于数组中的某一维度。

a = np.arange(12).reshape(3,4)

a
Out[50]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

a.sum()
Out[51]: 66

a.sum(axis=0)
Out[52]: array([12, 15, 18, 21])

a.min()
Out[53]: 0

a.min(axis=1)
Out[54]: array([0, 4, 8])

a.cumsum()
Out[55]: array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45, 55, 66], dtype=int32)

a.cumsum(axis=1)
Out[56]: 
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38]], dtype=int32)

numpy中还提供了一些简单的数学函数，如exp()、sqrt()、sin()等。这些函数也是对数组中每个元素依次进行操作的。

A = np.arange(3)

np.exp(A)
Out[66]: array([ 1.        ,  2.71828183,  7.3890561 ])

np.sqrt(A)
Out[67]: array([ 0.        ,  1.        ,  1.41421356])

B = np.array([2., -1., 4.])

np.add(A, B)
Out[69]: array([ 2.,  0.,  6.])