numpy 库

简介

  1. 提供了多维数组、矩阵的常用操作和一些高效的科学计算函数。
  2. 底层运算通过 C 语言实现，处理速度快、效率高，适用于大规模多维数组。
  3. 可以直接完成数组和矩阵运算，无需循环。

多维数组

形状(Shape):是一个元组,描述数组的维度,以及各个维度的长度。 长度(Length):某个维度中的元素个数。 shape(5,) 长度为 5 的一维数组， shape(30,5) 30x5 的二维数组，shape(10, )

NumPy 数组 ★ 每个数组都是一个 ndarray 对象 ★ 数组中的元素数据类型相同 ★ 数组中的元素下标从 0 开始 ★ 数组对象的常用属性：维数、形状、数据类型等。

数组创建

array([list]/(tuple)) 定义数组时，可以指定 dtype 数据类型: array([list]/(tuple)，dtype=数据类型)

asarray() 函数：将列表或元组转化为数组对象

当数据源本身已经是一个 ndarray 对象时, array() 仍然会复制出一个副本,而 asarray() 则直接引用了本来的数组。

数组属性

属性 描述
ndim 数组的维数
shape 数组的形状
size 数组元素的总个数
dtype 数组中元素的数据类型
itemsize 数组中每个元素的字节数

特殊数组

函 数 功能描述
np.arange() 创建数字序列数组
np.ones() 创建全 1 数组
np.zeros() 创建全 0 数组
np.eye() 创建单位矩阵
np.linspace() 创建等差数列
np.logspace() 创建等比数列
  1. arange() 函数：创建一个由数字序列构成的数组(步长可为小数)，类似于 range() 
    1
    2
    3
    np.arange(起始数字，结束数字，步长，dtype=数据类型)
    np.arange(4)
    np.arange(0,2,0.2)
  2. ones() 函数：创建一个元素全部为 1 的数组 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    np.ones(shape, dtype=数据类型)
    >>> np.ones((3,2),dtype=np.int32)
    array([[1, 1],
       [1, 1],
       [1, 1]], dtype=int32)
    # 默认是 float64 类型
    >>> np.ones((3,2))
    array([[1., 1.],
           [1., 1.],
           [1., 1.]])
  3. zeros() 函数，np.zeros(shape, dtype=数据类型)
  4. eye() 函数，np.eye(shape) shape 不用单独加元组括号
  5. linspace()函数 np.linspace(start, stop, num) 区间 [start, stop]中 num 个数
  6. logspace() 函数 np.logspace(start, stop, num, base) 区间 [base^start, base^stop]中 num 个数

数组切片

二维数组

1
2
3
4
5
6
7
8
9
10
11
>>> b
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
# 切前两维数组
>>> b[:2]
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
# 切某一列
>>> b[:,2]
array([ 2,  6, 10])

三维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
In [3]: t
Out[3]:
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 [4]: t[:,:,0]
Out[4]:
array([[ 0,  4,  8],
       [12, 16, 20]])
# 全部维度，第三行，第一列
In [5]: t[:,2,0]
Out[5]: array([ 8, 20])
# 全部维度，第1，2行，第一列
In [6]: t[:,0:2,0]
Out[6]:
array([[ 0,  4],
       [12, 16]])

改变数组形状

函数 功能描述
np.reshape(shape) 不改变当前数组,按照 shape 创建新的数组
np.resize(shape) 改变当前数组,按照 shape 创建数组

注意：当改变形状时，应该考虑到数组中元素的个数，确保改变前后，元素总个数相等。

创建数组，并改变数组形状

1
2
3
4
5
6
In [63]: a=np.logspace(0,5,6,base=2,dtype=np.int64).reshape(2,3)

In [64]: a
Out[64]:
array([[ 1,  2,  4],
       [ 8, 16, 32]])

np.reshape(shape) 中 shape 的值可以把其中的某一个维度设置为 -1，让 numpy 根据数组中元素总个数、以及其他维度的取值，来自动计算出这个维度的取值。 例如：将多维转换为一维

1
2
3
4
5
6
7
8
9
10
11
12
13
In [67]: a
Out[67]:
array([[ 1,  2,  4],
       [ 8, 16, 32]])

In [68]: a.reshape(-1,1)
Out[68]:
array([[ 1],
       [ 2],
       [ 4],
       [ 8],
       [16],
       [32]])

数组运算

numpy 支持数组的四则运算和逆运算. 一维数组可以和多维数组相加，相加时，会将一维数组扩展到多维。 当两个数组中元素的数据类型不同时，精度低的数据类型，会自动转换为精度更高的数据类型，然后再进行运算。

幂运算：对数组中的每个元素求 n 次方

矩阵相乘：

  • 乘号运算符：矩阵中对应的元素分别相乘，c=a*b
  • 矩阵相乘（点乘）：按照矩阵相乘的规则运算 np.matmul(a,b) np.dot(a,b)

矩阵转置和求逆 矩阵转置：np.transpose(a) 矩阵求逆：np.linalg.inv(a)

数组元素之间的运算

函数 功能描述
numpy.sum() 计算所有元素的和
numpy.prod() 计算所有元素的乘积
numpy.dif() 计算数组的相邻元素之间的差
np.sqrt() 计算各元素的平方根
np.exp() 计算各元素的指数值
np.abs() 取各元素的绝对值

求和

轴（axis）：数组中的每一个维度被称为一个轴。 秩（rank）：轴的个数。

16151051607795

数组堆叠

np.stack((数组1，数组2,..), axis) 在不同的轴方向上，进行堆叠,新出现的轴是哪个轴，axis=几

16151055149631 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [120]: a = np.array([[1, 2, 3], [4, 5, 6]])

In [121]: b = np.array([[7, 8, 9], [10, 11, 12]])

In [122]: c=np.stack((a, b), axis=1)

In [123]: c
Out[123]:
array([[[ 1,  2,  3],
        [ 7,  8,  9]],

       [[ 4,  5,  6],
        [10, 11, 12]]])

In [124]: print(c.shape)
(2, 2, 3)

矩阵和随机数

numpy.matrix

matrix(字符串/列表/元组/数组) / mat(字符串/列表/元组/数组) 当参数为字符串时，各个元素之间空格分割，不同行用分号分割。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [128]: a=np.mat("1 2 3;4 5 6")

In [129]: a
Out[129]:
matrix([[1, 2, 3],
        [4, 5, 6]])
In [131]: a=np.array([[1,2,3],[4,5,6]])
In [133]: m=np.mat(a)

In [134]: m
Out[134]:
matrix([[1, 2, 3],
        [4, 5, 6]])

In [135]: type(a), type(m)
Out[135]: (numpy.ndarray, numpy.matrix)

矩阵对象, 同样具备 ndim，shape，size，dtype 属性。

矩阵运算

矩阵之间乘号是矩阵相乘。

1
2
3
4
5
6
7
8
9
10
11
12
13
In [140]: a1,a2
Out[140]:
(matrix([[0, 1],
         [2, 3]]),
 matrix([[1, 1],
         [2, 0]]))

In [141]: a3=a1*a2

In [142]: a3
Out[142]:
matrix([[2, 0],
        [8, 2]])

矩阵转置：.T， 矩阵求逆：.I

1
2
3
4
5
6
7
8
9
In [144]: a1.T
Out[144]:
matrix([[0, 2],
        [1, 3]])

In [145]: a1.I
Out[145]:
matrix([[-1.5,  0.5],
        [ 1. ,  0. ]])

矩阵 vs 二维数组

numpy 中的矩阵和二维数组相似，在很多时候是通用的

矩阵 二维数组
运算符号简单; A*B 能够表示高维数组; 数组更加灵活，速度更快

随机数

函数 功能描述 返回值
np.random.rand(d1,.,dn) 元素在[0,1)区间均匀分布的数组 浮点数
np.random.uniform(low,high,size) 元素在[low,high)区间均匀分布的数组 浮点数
numpy.random.randint(low,high, size) 元素在[low,high)区间均匀分布的数组 整数
np.random.randn(d0,.,dn) 产生标准正态分布的数组 浮点数
np.random.normal(loc, scale, size) 产生均值为 loc，方差为 scale 的正态分布的数组 浮点数 
1
2
3
4
5
In [27]: np.random.normal(0,1,(3,2))
Out[27]:
array([[-2.01119139, -0.66620011],
       [-1.61697634, -1.14187373],
       [-0.51972518, -1.73302281]])

伪随机数：由随机种子，根据一定的算法生成的。 随机种子：指定随机数生成时所用算法开始的整数值。

  1. 如果使用相同的 seed（）值，则每次生成的随即数都相同。
  2. 如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同。
  3. 采用 seed（）函数设置随机种子，仅一次有效。
  4. 随机数产生的算法，和系统有关。
1
2
np.random.seed(num) 设置随机数种子
np.random.shuffle(序列) # 打乱序列顺序，对于多维数组，只打乱第一维