Python Numpy科学计算库

1. array结构

# array结构的创建，也可有加入dtype属性; 
# np.array([1,2,3,4], dtype=np.int32)
test_array = np.array([1,2,3,4])
out: array([3, 4, 5, 6, 7])
print(type(array))
out:<class 'numpy.ndarray'>

# array结构的属性；
# 数据类型
test_array .dtype
out:dtype('int32')
print(type(array.dtype))
out:<class 'numpy.dtype'>
# 数组的形状,也可以使用np.shape()的方法,其他属性也有类似的方法
test_array .shape
out:(4,)
# 数组中每个元素占用的字节数，相当于dtype占用的字节数，
test_array .itemsize
# 数组中元素的个数
test_array .size
# 数组的维数,array为1维数组
test_array .ndim
out: 1
# 数组填充为指定的值
test_array .fill(0)
out: array([0, 0, 0, 0, 0])

# 改变数组的dtype属性
test_array = np.arange(1,10)
test2_array = np.asarray(test_array, dtype=np.float32)
out: array([1., 2., 3., 4., 5., 6., 7., 8., 9.], dtype=float32)
# 也可以使用数组的内置方法
test2_array = test_array.astype(np.float32)

2. 数组的生成

# 使用array生产数组
np.array([1,2,3])
# np.arange(start, end, step)
# start,end为左闭右开; start默认为0，step默认为1
test_array = np.arange(1,10)
out: array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# linspace(start, end, num) 生成num个等间隔数据
# start,end为左闭右闭；数据间隔为（end - start）/(num - 1)
np.linspace(0,10,11)
out: array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
# np.zeros()生成全0的数据, np.ones()生成全1的数据, np.empty() 生成的数据未初始化
# np.zeros_like()获取参数的shape值，并用np.zeros()生成数据，np_ones_like()类似
test_array = np.zeros((2,3))
out: array([[0., 0., 0.],
       [0., 0., 0.]])
np.ones_like(test_array)
out: array([[1., 1., 1.],
       [1., 1., 1.]])
# 数组的填充
test_array.fill(8)
out: array([[8., 8., 8.],
       [8., 8., 8.]])
# 生产单位矩阵
np.identity(3)
out: array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

3. 数组的索引

# 单个数据索引
test_array = np.array([[1,2,3],[4,5,6]])
out:array([[1, 2, 3],
       [4, 5, 6]])
# 获取第一行数据
test_array[0]
out:array([1, 2, 3])
# 获取指定位置数据，或使用test_array[0][1]
test_array[0,1]   
out: 2

# 切片索引，和python的切片一样
test_array [:1, 1:]
out:array([[2, 3]])

# bool索引
test_array = np.arange(1,10)
out: array([1, 2, 3, 4, 5, 6, 7, 8, 9])
mask = np.array([1,0,3,0,1,0,2,0,0 ], dtype=bool)
out: array([ True, False,  True, False,  True, False,  True, False, False])
array[mask]
out: array([1, 3, 5, 7])
test_array [mask] = 10
out: array([10,  2, 10,  4, 10,  6, 10,  8,  9])
# 可以用比较符号获取bool类型的mask
test_array = np.arange(1,10)
test_array > 5
out: array([False, False, False, False, False,  True,  True,  True,  True])

# 使用数组进行索引，用列表也可以
test_array = np.arange(1,10)
mask = np.array([1,2,3])
test_array[mask]
out: array([2, 3, 4])
# 获取数组的索引值，索引用数组保存
mask = test_array > 5
np.where(mask)
(array([5, 6, 7, 8], dtype=int64),)

4. 数组形状的改变

# 使用reshape改变数组形状
test_array = np.arange(1,7,1)
test_array = test_array.reshape(2,3)
out: array([[1, 2, 3],
       [4, 5, 6]])
# 添加一个维度
test_array = test_array[np.newaxis,...]
test_array.shape
out: (1, 2, 3)
# 压缩维度，会将shape中1对应的维度压缩掉
test_array = test_array.squeeze()
test_array.shape
out: (2, 3)
# 矩阵的转置，也可以使用test_array.transpose()
test_array.T
out: array([[1, 4],
       [2, 5],
       [3, 6]])
# 数组的拼接
a = np.array([[1,2,3],[4,5,6]])
b = np.array([[11,22,33],[44,55,66]])
np.concatenate((a,b))	# 默认安装axis=0方向拼接；也可以使用np.vstack((a,b))
out: array([[ 1,  2,  3],
        [ 4,  5,  6],
        [11, 22, 33],
        [44, 55, 66]])
np.concatenate((a,b), axis=1)  # 也可以使用np.hstack((a,b))
out: array([[ 1,  2,  3, 11, 22, 33],
       [ 4,  5,  6, 44, 55, 66]])
# 数组的展平
a.flatten()		# 也可以使用a.ravel()
array([1, 2, 3, 4, 5, 6])

5. 运算

# 数组的复制
# 用=号复制，对test1_array 会影响test_array；test1_array 相当于test_array的别名
test1_array = test_array
# 用copy复制，对test1_array不会影响test_array
test2_array = test_array.copy()

# 数组的幅值
# 单个元素索引幅值
test_array = np.arange(1,10)
test_array[0] = 10
out: array([10,  2,  3,  4,  5,  6,  7,  8,  9])
# 多个元素的索引幅值，该方法也可用于bool索引，数组索引
test_array[0:5] = 8
out: array([8, 8, 8, 8, 8, 6, 7, 8, 9])

# 求和运算, 也可以用test_array.sum()
test_array = np.array([[1,2,3],[4,5,6]])
np.sum(test_array)	# 全部求和
out: 21
# 指定维度方向；test_array的维度数为2；分别用0，1指示。维度方向0，表示最外围的数组；维度方向1，表示内部的数组，如[1,2,3]和[4,5,6];
np.sum(test_array, axis=0) 
out: array([5, 7, 9])
np.sum(test_array, axis=1)
out: array([ 6, 15])

# 乘法运算
# 所有元素的乘积
test_array.prod()
out: 720
# 指定维度方向的乘积
test_array.prod(axis=0)
out: array([ 4, 10, 18])
test_array.prod(axis=1)
out：test_array.prod(axis=1)

# 求最小值，最大值test_array.max()
test_array.min()
out: 1
test_array.min(axis=0)
out: array([1, 2, 3])
test_array.min(axis=1)
out: array([1, 4])

# 查找最小值和最大值的索引位置
# 会将数组展平求索引位置
test_array = np.array([[4,2,3],[1,5,6]])
out: 3
# 指定维度方向，如果不指定维度，会将二维数组展平，在获取其最大/最小值索引
# 获取最小值索引test_array.argmin();获取最大值索引test_array.argmax();
test_array.argmin(axis=0)
out: array([1, 0, 0], dtype=int64)
test_array.argmin(axis=1)
out: array([1, 0], dtype=int64)

# 求均值
test_array.mean()
out: 3.5
test_array.mean(axis=0)
out: array([2.5, 3.5, 4.5])

# 求标准差；方差使用test_array.var()
test_array.std()
out: 1.707825127659933
test_array.std(axis=0)
out: array([1.5, 1.5, 1.5])

# 数据的截断
test_array.clip(2, 4)
out: array([[4, 2, 3],
       [2, 4, 4]])

# 四舍五入
test_array = np.array([1.22, 1.33, 1.55, 1.66])
test_array.round()
out: array([1., 1., 2., 2.])
test_array.round(decimals=1) # 指定小数一位
array([1.2, 1.3, 1.6, 1.7])

```python
# 两个数组的算术运行，
# 数组shape相同，各个元素进行运算
a = np.arange(1,7).reshape(2,3)
out: array([[1, 2, 3],
       [4, 5, 6]])
b = np.arange(2,8).reshape(2,3)
out: array([[2, 3, 4],
       [5, 6, 7]])
a + b
out: array([[ 3,  5,  7],
       [ 9, 11, 13]])
a * b
array([[ 2,  6, 12],
       [20, 30, 42]])
# 广播运算，数组shape不相同，将数组广播为shape相同再运算
# 广播规则如下：
# 1. 两个数组的shape按右对齐；如下4和4对齐，3和1对齐；
# 2. shape左边可以添加1；如：(  3,4) --> (1,2,4)
# 3. 1可以广播为任意数；如：(1,2,4) --> (2,3,4)；(2,1,4) --> (2,3,4)
# (  3,4) --> (1,3,4) --> (2,3,4)
# (2,1,4) --> (2,3,4)
a = np.ones((3,4))
b = np.ones((2,1,4))
# 逻辑运算，逻辑运算也遵循广播规则
# np.logical_and(), np.logical_or(), np.logical_not();
a = np.ones((3,3))
b = np.zeros(3)
np.logical_and(a,b)
out: array([[False, False, False],
       [False, False, False],
       [False, False, False]])
# 矩阵计算
a = np.array([[2],[3]])
b = np.array([[4,5]])
np.dot(a,b)
out: array([[ 8, 10],
       [12, 15]])

6. 随机模块

# 生成的数的值为0~1
np.random.rand(3,2)		# 生成3行两列的数据
# 随机生成整数 np.random.randint(low, high=None, size=None)，范围如下
# 当high = None, 生成的数范围为：[0,low），否则范围为：[low, high)
np.random.randint(2, 5,size = (2))
out: array([4, 3])
# 生成正太分布的数据np.random.normal(均值，方差，生成数据的个数)
mean, sigma= 0, 0.01
np.random.normal（mean, sigma, 5）
out: array([ 3.96969242e-03, -7.93685844e-05, -1.83804326e-03,  3.73820907e-03, -3.60027281e-03])
# 可以设置打印精度，显示小数后几位数据
np.set_printoptions(precision = 2)
np.random.rand(3)
out: array([0.64, 0.12, 0.51])
# 设置随机种子生成随机数；在生成随机数之前，先运行一下随机种子，若随机种子相同，则生成的随机数一样;
# 随机种子可以是任何大于等于0的数
# 如下两次random的数据是一样的
np.random.seed(1)
np.random.rand(3)
out: array([4.17e-01, 7.20e-01, 1.14e-04])
np.random.seed(1)
np.random.rand(3)
out: array([4.17e-01, 7.20e-01, 1.14e-04]) 
# 洗牌，打乱数据排列, 只对第一个维度进行打乱
test_array = test_array.reshape(5,2)
out: array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])
np.random.shuffle(test_array)
test_array
out: array([[4, 5],
       [0, 1],
       [2, 3],
       [6, 7],
       [8, 9]])

7. 排序

test_array = np.array([[2,8,6],[9, 5, 2]])
out: array([[2, 8, 6],
       [9, 5, 2]])
np.sort(test_array)	 # 默认按照axis=1排序
out: array([[2, 6, 8],
       [2, 5, 9]])
np.sort(test_array, axis=0)
out: array([[2, 5, 2],
       [9, 8, 6]])