numpy库使用说明

酷曦

于 2024-09-17 16:42:16 发布

阅读量709

点赞数 10

文章标签： numpy

本文链接：https://blog.csdn.net/weixin_55799608/article/details/141830308

版权

1.数组基础

1.1整数型数组与浮点型数组

例如：

import numpy as np

# 创建整数型数组
arr_1 = np.array([1, 2, 3])  #  元素都为整数
print(arr_1)   #  [1 2 3]
# 创建浮点型数组
arr_2 = np.array([1.2, 3, 4])  # 元素包含浮点数即为浮点型
print(arr_2)   # [1.2  3.  4.]

同化：

向整数型数组里插入浮点数，该浮点数会自动被截断为整数
向浮点型数组里插入整数，该整数会自动变为浮点数

import numpy as py

arr_1 = np.array([1, 2, 3])  #  创建整数型数组
arr_1[0] = 5.2   # 插入浮点数会被截断，仍然为整数型
print(arr_1)    # [5 2 3]

arr_2 = np.array([1.2, 3.1, 4.5])  # 创建浮点型数组
arr_2[0] = 6    # 插入整数型，仍然为浮点数
print(arr_2)    # [6.  3.1  4.5]

共同改变：

整数型数组和浮点型数组相互转换，规范的方法是使用 .astype() 方法

import numpy as np
# 创建整数型数组
 arr_1 = np.array([1, 2, 3])
 print(arr_1)   # [1 2 3]
 # 整数型——>浮点型
 arr_2 = arr_1.astype(float)
 print(arr_2)  # [1. 2. 3.]
 # 浮点型——>整数型
 arr_3 = arr_2.astype(int)
 print(arr_3)  # [1 2 3]

其他方法：
整数型数组在运算过程中 (加、减、乘、除) 会升级为浮点型数组
但是浮点型数组一般在运算中不会变为整数型数组

import numpy as np

arr_1 = np.array([1, 2, 3])
print(arr_1)   # [1 2 3]
print(arr_1 + 0.1)  # [1.1  2.1  3.1]
print(arr_1 - 0.1)  # [0.9  1.9  2.9]
print(arr_1 * 0.1)  # [0.1  0.2  0.3]
print(arr_1 / 1)  # [1.  2.  3.]

此外：整数型数组与浮点型数组做运算也会变为浮点型数组

1.2数组维度

（1）一维数组和二维数组

不同维度的数组：
一维数组使用1层中括号表示
二维数组使用 2 层中括号表示
三维数组使用 3 层中括号表示
有些函数要传入数组的形状参数，不同维度数组的形状参数为：
一维数组的形状参数形如： x 或 (x,) ；
二维数组的形状参数形如： (x,y) ；
三维数组的形状参数形如： (x,y,z) 。
举例：
当数组有 1 层中括号，如[1 2 3]，则其为一维数组，其形状是 3 或 (3,)
当数组有 2 层中括号，如[[1 2 3]]，则其为二维数组，其形状是 (1,3)
当数组有 3 层中括号，如[[[1 2 3]]]，则其为三维数组，其形状是 (1,1,3)
演示：

import numpy as np
arr1 = np.ones(3)  # 传入形状3
print(arr1)   # [1. 1. 1.]   一维数组

arr2 = np.ones((1, 3))  # 传入形状（1, 3）
print(arr2)   # [[1. 1. 1.]]   二维数组

arr3 = np.ones((1, 1, 3))  # 传入形状（1, 1, 3）
print(arr3)   # [[[1. 1. 1.]]]   三维数组

# 使用数组的 .shape属性查看数组的形状
print(arr1.shape)  # (3,)
print(arr2.shape)  # (1, 3)
print(arr3.shape)  # (1, 1, 3)

（2）不同维度数组之间的转换
一维数组转二维数组，还是二维数组转一维数组，均要使用的是数组的重塑方法 .reshape( ) ，该方法需要传入重塑后的形状（shape）参数。这个方法神奇的是，给定了其他维度的数值，剩下一个维度可以填-1，让它自己去计算。比如把一个 5 行 6 列的矩阵重塑为 3 行 10 列的矩阵，当列的参数10 告诉它，行的参数直接可以用-1 来替代，它会自己去用 30 除以 10 来计算。

import numpy as np
# 创建一维数组
arr1 = np.arange(10)   # 从 0 开始，到 10 之前结束，还可以指定步长
print(arr1)  # [0 1 2 3 4 5 6 7 8 9]   一维数组
# 一维数组转换为二维数组
arr2 = arr1.reshape((1, -1))   #  这里传入的是（1, -1） 1 表示一行， -1表示让它自己算，这里arr1总共10个元素，所以是1 X 10
print(arr2)  # [[0 1 2 3 4 5 6 7 8 9]]  二维数组

arr3 = np.arange(10).reshape(2, 5)  # 连起来写  2行5列
print(arr3)    
 # [[0 1 2 3 4]
 #  [5 6 7 8 9]]
 
 # 二维数组转换为一维数组
 arr4 = arr3.reshape(-1)  #  -1这里让它自己算，也可以填10
 print(arr4)  # [0 1 2 3 4 5 6 7 8 9]   一维数组

二、数组创建

2.1创建指定数组

import numpy as np
# 创建一维数组--向量
arr1 = np.array([1, 2, 3])
print(arr1)  # [1 2 3]
 # 创建二维数组——行矩阵
arr2 = np.array( [ [1,2,3] ] )   # 1行3列
print(arr2)  # [[1 2 3]]
# 创建二维数组——列矩阵
arr3 = np.array( [ [1],[2],[3] ] )  # 3行1列
print(arr3)
# [[1]
#  [2]
#  [3]]

2.2 创建同值数组

需要创建同值数组时，使用 np.zeros( ) 函数以及 np.ones( ) 函数

import numpy as np
# 全0数组
arr1 = np.zeros(3)  # 形状为3的向量（一维数组）
print(arr1)  # [0. 0. 0.]

# 全1数组
arr2 = np.ones(3) # 形状为（1, 3）的矩阵（二维数组）
print(arr2) [[1. 1. 1.]]

# 全3.14数组
arr3 = 3.14*np.ones((2, 3))  # 形状为（2, 3）的矩阵
print(arr3)

2.3创建随机数组

有时需要创建随机数组，那么可以使用 np.random 系列函数

import numpy as np
# 0-1 均匀分布的浮点型随机数组
arr1 = np.random.random( 5 ) # 形状为 5 的向量
print( arr1 )
[0.59699399 0.89113584 0.00695752 0.49089431 0.32050609]
# 如果想创建 60-100 范围内均匀分布的 3 行 3 列随机数组，可输入 (100-60)*np.random.random( (3,3) ) + 60

# 整数型随机数组
arr2 = np.random.randint( 10,100,(1,15) ) # 形状为(1,15)的矩阵,范围10-100
print( arr2 )
[[17 65 54 48 82 57 52 26 28 27 53 36 61 92 13]]

# 服从正态分布的随机数组
arr3 = np.random.normal( 0,1,(2,3) ) # 形状为(2,3)的二维矩阵
print( arr3 )
[[-0.43163964 -1.56817412 0.5460523 ]
	[-2.93093358 0.42577899 -1.69842077]]
# 该函数需要额外输入正态参数，本例中均值为 0、标准差为 1，这种情况可直接使用 np.random.randn( )函数，只需要传入形状参数即可

三、数组切片

在这里插入图片描述

3.1 向量切片（一维）

import numpy as np
arr1 = np.arange(10)
print( arr1 )
print( arr1[ 1 : 4 ] ) # 从索引[1]开始，切到索引[4]之前
print( arr1[ 1 : ] ) # 从索引[1]开始，切到结尾
print( arr1[ : 4 ] ) # 从数组开头开始，切到索引[4]之前
[0 1 2 3 4 5 6 7 8 9]
[1 2 3]
[1 2 3 4 5 6 7 8 9]
[0 1 2 3]

print( arr1 ) 
print( arr1[ 2 : -2 ] ) # 切除开头 2 个和结尾 2 个
print( arr1[ 2 : ] ) # 切除开头 2 个
print( arr1[ : -2 ] ) # 切除结尾 2 个
[0 1 2 3 4 5 6 7 8 9]
[2 3 4 5 6 7]
[2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7]

print( arr1 ) 
print( arr1[ : : 2 ] ) # 每 2 个元素采样一次
print( arr1[ : : 3 ] ) # 每 3 个元素采样一次
print( arr1[ 1 : -1 : 2 ] ) # 切除一头一尾后，每 2 个元素采样一次
[0 1 2 3 4 5 6 7 8 9]
[0 2 4 6 8]
[0 3 6 9]
[1 3 5 7]

3.2矩阵切片（二维）

import numpy as np
arr2 = np.arange(1,21).reshape(4,5)
print( arr2 )
[[ 1 2 3 4 5]
[6 7 8 9 10]
[11 12 13 14 15]
[16 17 18 19 20]]

# 左闭右开
print( arr2[ 1:3 , 1:-1 ] ) # 矩阵切片初体验  1:3表示1,2行，1:-1表示从索引1到最后1列（不包括最后一列）
[[ 7 8 9]
[12 13 14]]

print( arr2[ ::3 , ::2 ] ) # 跳跃采样  ::3表示所有行但是步长为3， ::2表示所有列但是步长为2
[[ 1 3 5]
[16 18 20]]

print( arr2[ 2 , : ] ) # 提取第 2 行   行索引为2，列无要求所以为全部行
[11 12 13 14 15]
print( arr3[ 1:3 , : ] ) # 提取 1 至 2 行
[[6 7 8 9 10]
[11 12 13 14 15]]

print( arr3[ 2 , : ] ) # 规范的提取行
print( arr3[2] ) # 简便的提取行
[11 12 13 14 15]
[11 12 13 14 15]

3.3数组切片只是视图

import numpy as np
arr = np.arange(10) # 创建原数组 arr
print(arr)
[0 1 2 3 4 5 6 7 8 9]
cut = arr[ : 3 ] # 创建 arr 的切片 cut
print(cut)
[0 1 2]
cut[0] = 100 # 对切片的数值进行修改
print(cut)
[100 1 2]
print(arr) # 原数组也被修改
[100 1 2 3 4 5 6 7 8 9]
# 备份切片
copy = arr[ : 3 ] .copy() # 创建 arr 的拷贝切片
print(copy)
[0 1 2]
copy [0] = 100 # 对拷贝切片的数值进行修改
print(copy)
[100 1 2]
print(arr) # 原数组不为所动
[0 1 2 3 4 5 6 7 8 9]

四、数组的变形

4.1数组的转置

import numpy as np
arr1 = np.arange(1, 4).reshape(1, -1)
print(arr1)
[[1 2 3]]
arr2 = arr1.T   # 行矩阵的转置
print(arr2)
[[1]
  [2]
  [3]]
# 列的转置也类似

4.2数组的翻转

数组的翻转方法有两个，一个是上下翻转的 np.flipud( ) ，表示 up-down；一个是左右翻转的 np.fliplr( )，表示 left-right。其中，向量只能使用 np.flipud( )，在数学中，向量并不是横着排的，而是竖着排的。

import numpy as np
# 创建向量
arr1 = np.arange(10)
print( arr1 )
[0 1 2 3 4 5 6 7 8 9]
# 翻转向量
arr_ud = np.flipud(arr1)
print( arr_ud )
[9 8 7 6 5 4 3 2 1 0]

# 创建矩阵
arr2 = np.arange(1,21).reshape(4,5) 
print( arr2 )
[[ 1 2 3 4 5]
 [6 7 8 9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]
 # 左右翻转
arr_lr = np.fliplr(arr2)
print( arr_lr )
[[5 4 3 2 1]
 [10 9 8 7 6]
 [15 14 13 12 11]
 [20 19 18 17 16]]
# 上下翻转
arr_ud = np.flipud(arr2)
print( arr_ud )
[[16 17 18 19 20]
 [11 12 13 14 15]
 [6 7 8 9 10]
 [1 2 3 4 5]]

4.3数组的拼接

arr3 = np.concatenate(arr1, arr2)
# 按第一个维度（行）拼接
arr3 = np.concatenate( [arr1,arr2] ) # 默认参数 axis=0
# 按第二个维度（列）拼接
arr4 = np.concatenate( [arr1,arr2] ,axis=1 )

五、数组的函数

数组的运算总结为各个对应元素的运算，而这节是线代里面的矩阵乘积使用 np.dot() 函数

5.1向量与向量的乘积

(1, 5 )X (5, 1) = (1, 1)

import numpy as np
# 创建向量
arr1 = np.arange(5)
arr2 = np.arange(5)
print(arr1)
print(arr2)
[0 1 2 3 4]
[0 1 2 3 4]
# 矩阵乘积
print( np.dot(arr1,arr2) )
30

5.2向量与矩阵的乘积

(1, 5 )X (5, 3) = (1, 3)

import numpy as np
# 创建数组
arr1 = np.arange(5)
arr2 = np.arange(15).reshape(5,3)
# 矩阵乘积
print( np.dot(arr1,arr2) )
[90 100 110]

注意前后位置关系，其他也是类似

5.3数学函数

几个常见的数学函数

import numpy as np

# 绝对值函数
arr_v = np.array( [-10, 0, 10] )
abs_v = np.abs(arr_v)
print( '原数组是：' , arr_v )
print( '绝对值是：' , abs_v )
原数组是： [-10 0 10]
绝对值是： [10 0 10]

# 三角函数
theta = np.arange(3) * np.pi / 2
sin_v = np.sin(theta)
cos_v = np.cos(theta)
tan_v = np.tan(theta)
print( '原数组是：' , theta )
print( '正弦值是：' , sin_v )
print( '余弦值是：' , cos_v )
print( '正切值是：' , tan_v )
原数组是： [0. 1.57079633 3.14159265]
正弦值是： [0.0000000e+00 1.0000000e+00 1.2246468e-16]
余弦值是： [ 1.000000e+00 6.123234e-17 -1.000000e+00]
正切值是： [ 0.00000000e+00 1.63312394e+16 -1.22464680e-16]

# 指数函数
x = np.arange(1,4)
print( 'x =' , x )
print( 'e^x =' , np.exp(x) )
print( '2^x =' , 2**x )
print( '10^x = ' , 10**x )
x = [1 2 3]
e^x = [ 2.71828183 7.3890561 20.08553692]
2^x = [2 4 8]
10^x = [ 10 100 1000]

# 对数函数
x = np.array( [1,10,100,1000] )
print( 'x =' , x )
print( 'ln(x) =' , np.log(x) )
print( 'log2(x) =' , np.log(x) / np.log(2) )   #  这里是换底公式
print( 'log10(x) =' , np.log(x) / np.log(10) )
x = [ 1 10 100 1000]
ln(x) = [0. 2.30258509 4.60517019 6.90775528]
log2(x) = [0. 3.32192809 6.64385619 9.96578428]
log10(x) = [0. 1. 2. 3.]

5.4聚合函数

介绍6个重要的聚合函数，这里只演示3个，其他对称的用法完全一致

import numpy as np
# 最大值函数 np.max( )与最小值函数 np.min( )
arr = np.random.random((2,3))
print( arr )
print( '按维度一求最大值：' , np.max(arr,axis=0) )
print( '按维度二求最大值：' , np.max(arr,axis=1) )
print( '整体求最大值：' , np.max(arr) )
[[0.54312818 0.57067295 0.11898755]
 [0.85857494 0.33915753 0.4742594 ]]
按维度一求最大值： [0.85857494 0.57067295 0.4742594 ]
按维度二求最大值： [0.57067295 0.85857494]
整体求最大值： 0.8585749445359108

# 求和函数 np.sum( )与求积函数 np.prod( )
arr = np.arange(10).reshape(2,5)
print( arr )
print( '按维度一求和：' , np.sum(arr,axis=0) )
print( '按维度二求和：' , np.sum(arr,axis=1) )
print( '整体求和：' , np.sum(arr) )
[[0 1 2 3 4]
 [5 6 7 8 9]]
按维度一求和： [ 5 7 9 11 13]
按维度二求和： [10 35]
整体求和： 45

# 均值函数 np.mean( )与标准差函数 np.std( )
arr = np.arange(10).reshape(2,5)
print( arr )
print( '按维度一求平均：' , np.mean(arr,axis=0) )
print( '按维度二求平均：' , np.mean(arr,axis=1) )
print( '整体求平均：' , np.mean(arr) )
[[0 1 2 3 4]
 [5 6 7 8 9]]
按维度一求平均： [2.5 3.5 4.5 5.5 6.5]
按维度二求平均： [2. 7.]
整体求平均： 4.5

注意：

当 axis=0 时，最终结果与每一行的元素个数一致；
当 axis=1 时，最终结果与每一列的元素个数一致。
考虑到大型数组难免有缺失值，以上聚合函数碰到缺失值时会报错，因此出现了聚合函数的安全版本，即计算时忽略缺失值：np.nansum( )、
np.nanprod( ) 、np.nanmean( )、np.nanstd( )、np.nanmax( )、np.nanmin( )