Python - Numpy库的使用（简单易懂）
2024-05-09 06:05:55
目录
numpy多维数组——数组的创建
1、array函数创建数组对象
2、通过arange、linspace函数创建等差数组对象
3、通过logspace函数创建等比数列数组
函数 zeros ones diag eye full
numpy多维数组——生成随机数
函数 seed rand randn randint
函数 binomial normal 和不常用函数
shuffle函数
numpy多维数组——数组的属性
属性 .ndim .shape .szie .dtype .itemszie
numpy多维数组——数组的变换
数组重塑方法 .reshape .flatten
数组合并 .hstack() .vstack() .concatenate((),axis=0/1)
数组分割 .hsplit() .vsplit() .split()
数组的访问——数组的索引和切片
一维数组的索引和切片
多维数组的索引和切片
数组的访问——修改数组元素的值
函数 。append() .insert() .delete()
数组的运算——数组与数组的运算
数组算术运算
二维数组与一维数组的运算
二维数组与二维数组的运算
数组的运算——条件逻辑运算
True/False的数组
where用法
布尔型索引
数组的运算——numpy库常用的数学函数运算
函数 ceil() floor() round() exp().....
numpy中的数据统计与分析
排序 sort() argsort()
数据去重与重复 去重unique() 重复tile() repeat()
常用统计函数 最大值、最小值、平均值、中值
计算数组的和、最大值、最小值
计算数组均值、中值
计算数组方差、标准差、协方差矩阵
计算数组的百分位数
求解线性方程组——数组与矩阵
数组ndarray和矩阵matrix
矩阵和数组的点乘运算
求解线性方程组
numpy多维数组——数组的创建
1、array函数创建数组对象
- 语法格式：np.array(object, dtype=None, ndmin=0)
import numpy as np #导入模块并命名为 np
arr1 = np.array([1,2,3],dtype='float') #创建一维数组,数据类型为float
print("一维数组:\n",arr1)
arr2 = np.array([[1, 2, 3], [4, 5, 6]])#创建一个二维数组
print("二维数组:\n",arr2)
一维数组:[1. 2. 3.]
二维数组:[[1 2 3][4 5 6]]2、通过arange、linspace函数创建等差数组对象
- arange函数语法格式：np.arange(start, end, step, dtype = None) 左闭右开区间
- linspace函数语法格式：np.linspace(start, end, num, endpoint=True) 闭区间
import numpy as np #导入模块并命名为 np
a_arange=np.arange(1,20,5) #在区间[1, 20)生成初始值为1，步长为5的等差数列
print("arange创建数组：\n",a_arange)
a_linspace=np.linspace(-1,2,5) #区间[-1,2]生成初始值-1，5个等间距的等差数列
print("linspace创建数组：\n",a_linspace)
arange创建数组：[ 1 6 11 16]
linspace创建数组：[-1. -0.25 0.5 1.25 2. ]3、通过logspace函数创建等比数列数组
- 语法格式：np.logspace(start, end, num, endpoint=True, base=10.0)
# 构造从2的0次方到2的9次方的等比数列，该等比数列长度是10个元素.
import numpy as np
a_logspace =np.logspace(0,9,10,base=2)
print(a_logspace)[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]函数 zeros ones diag eye full
import numpy as np #导入模块并命名为 np
a_zeros1 = np.zeros(3,dtype=int) #创建元素值全是0的一维数组,数据类型为int
print("由0组成的一维数组：\n",a_zeros1)
a_zeros2 = np.zeros([3, 4]) #创建元素值全是0的二维数组
print("由0组成的二维数组：\n",a_zeros2)
b_ones1 = np.ones(3) #创建元素值全是1的一维数组
print("由1组成的一维数组：\n",b_ones1)
b_ones2 = np.ones([3, 4]) #创建元素值全是1的二维数组
print("由1组成的二维数组：\n",b_ones2)
c_diag = np.diag([1,2,3,4]) #创建对角线数组
print("给定对角线二维数组：\n",c_diag)
d_eye=np.eye(3) #创建单位数组
print("单位数组：\n",d_eye)
e_full=np.full([4,4], 3) #创建值相同的二维数组数组
print("值相同的二维数组数组：\n",e_full)
由0组成的一维数组：[0 0 0]
由0组成的二维数组：[[0. 0. 0. 0.][0. 0. 0. 0.][0. 0. 0. 0.]]
由1组成的一维数组：[1. 1. 1.]
由1组成的二维数组：[[1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.]]
给定对角线二维数组：[[1 0 0 0][0 2 0 0][0 0 3 0][0 0 0 4]]
单位数组：[[1. 0. 0.][0. 1. 0.][0. 0. 1.]]
值相同的二维数组数组：[[3 3 3 3][3 3 3 3][3 3 3 3][3 3 3 3]]numpy多维数组——生成随机数
函数 seed rand randn randint
|
函数名称 |
函数功能 |
|
seed |
种随机数种子，根据同一种子产生的随机数是相同的 |
|
rand |
产生数组中的值服从均匀分布的随机数 |
|
randn |
产生数组中的值服从标准正态分布 |
|
randint(low[, high, size]) |
产生随机整数，low：最小值；high：最大值；size：数据个数 |
import numpy as np #导入模块并命名为 np
np.random.seed(100) #同一种子产生的一组随机数是相同的
a_randint1=np.random.randint(0, 20, 5) # 生成一维数组， 5个0到20之间的随机整数
print("由随机整数组成的一维数组：\n",a_randint1)
a_randint2=np.random.randint(0, 20, (3,4)) # 3行4列二维数组，随机整数都介于[0,20)
print("由随机整数组成的二维数组：\n",a_randint2)
b_rand=np.random.rand(5) # 5个介于[0,1)的随机数一维数组
print("由随机数组成的一维数组：\n",b_rand)
c_randn=np.random.randn(5) # 产生5个标准正态分布随机数组成一维数组
print("产生5个标准正态分布随机数组成一维数组：\n",c_randn)
由随机整数组成的一维数组：[ 8 3 7 15 16]
由随机整数组成的二维数组：[[10 2 2 2][14 2 17 16][15 4 11 16]]
由随机数组成的一维数组：[0.56229626 0.00581719 0.30742321 0.95018431 0.12665424]
产生5个标准正态分布随机数组成一维数组：[-0.23198063 -0.51772213 1.43018797 0.94971126 0.65692046]函数 binomial normal 和不常用函数
|
函数名称 |
函数功能 |
|
binomial(n, p[, size]) |
产生二项分布的随机数 |
|
poisson([lam, size]) |
产生泊松分布的随机数 |
|
uniform([low, high, size]) |
产生均匀分布的随机数 |
|
exponential([scale, size]) |
产生指数分布的随机数 |
|
normal([loc, scale, size]) |
产生正态(高斯)分布的随机数 |
|
chisquare(df[, size]) |
产生卡方分布的随机数 |
|
f(dfnum, dfden[, size]) |
产生F分布的随机数 |
|
gamma(shape[, scale, size]) |
产生伽马分布的随机数 |
import numpy as np #导入numpy模块并命名为 np
import matplotlib.pyplot as plt #导入绘图模块并命名为plt
mu=1 #数学期望：1
sigma=3 #标准差：3
num=1000000 #个数：1000000
rand_data = np.random.normal(mu, sigma, num) #产生正态分布的随机数
plt.hist(rand_data, 100) #绘制直方图
plt.show() #显示图片
shuffle函数
shuffle函数功能是将序列类型中的元素随机排列，返回打乱后的序列。对多维数组进行打乱排列时，默认是对第一个维度也就是列维度进行随机打乱。
import numpy as np
arr1= np.arange(10)
print("一维数组原顺序：\n",arr1)
np.random.shuffle(arr1)
print("一维数组打乱顺序：\n",arr1)
np.random.seed(100)
arr2=np.arange(1,13).reshape(3,4)
print("二维数组原顺序：\n",arr2)
np.random.shuffle(arr2)
print("二维数组打乱顺序：\n",arr2)一维数组原顺序：[0 1 2 3 4 5 6 7 8 9]
一维数组打乱顺序：[8 1 4 6 7 2 5 3 0 9]
二维数组原顺序：[[ 1 2 3 4][ 5 6 7 8][ 9 10 11 12]]
二维数组打乱顺序：[[ 5 6 7 8][ 9 10 11 12][ 1 2 3 4]]numpy多维数组——数组的属性
属性 .ndim .shape .szie .dtype .itemszie
|
属性 |
说明 |
|
.ndim |
秩 (rank)，即数组轴的数量或者维度的数量 |
|
.shape |
数组形状，返回一个元组表示各个维度中元素的个数 |
|
.size |
数组元素的总数 |
|
.dtype |
数组中每个元素的数据类型和数据大小 |
|
.itemsize |
数组中每个元素的大小，以字节为单位 |
|
.flags |
数组的内存信息 |
|
.real |
数组元素的实部 |
|
.imag |
数组元素的虚部 |
import numpy as np
a1 = np.arange(1,13)
print("一维数组a1:{}".format(a1))
print("一维数组a1的维度:{}".format(a1.ndim))
print("一维数组a1的形状:{}".format(a1.shape))
print("一维数组a1的元素个数:{}".format(a1.size))
a2= np.array([[1,2,3],[4,5,6]])
print("二维数组a2:\n{}".format(a2))
print("二维数组a2的维度:{}".format(a2.ndim))
print("二维数组a2的形状:{}".format(a2.shape))
print("二维数组a2的元素个数:{}".format(a2.size))一维数组a1:[ 1 2 3 4 5 6 7 8 9 10 11 12]
一维数组a1的维度:1
一维数组a1的形状:(12,)
一维数组a1的元素个数:12
二维数组a2:
[[1 2 3][4 5 6]]
二维数组a2的维度:2
二维数组a2的形状:(2, 3)
二维数组a2的元素个数:6Process finished with exit code 0
注意一维形状表示！
numpy多维数组——数组的变换
数组重塑方法 .reshape .flatten
|
方法 |
说明 |
|
.reshape(shape) |
不改变数组元素，返回一个shape形状的数组，原数组不变 |
|
.flatten() |
对数组进行降维，返回折叠后的一维数组，原数组不变 |
import numpy as np
a1 = np.arange(1,13) #生成一维数组
print("一维数组a1:\n{}".format(a1))
a2=a1.reshape(3,4) #将原数组重塑成3行4列的新数组
print("reshape重塑数组生成新数组a2:\n{}".format(a2))
a3=a1.reshape(-1,6) #将原数组重塑成x行6列的新数组
print("reshape重塑数组生成新数组a3:\n{}".format(a3))
print("原数组a1不变:{}".format(a1))
a4=a3.flatten() #使用flatten函数把a3中的数据展开成一维数组
print("flatten函数把a3中的数据展开成一维数组a4：\n{}".format(a4))一维数组a1:
[ 1 2 3 4 5 6 7 8 9 10 11 12]
reshape重塑数组生成新数组a2:
[[ 1 2 3 4][ 5 6 7 8][ 9 10 11 12]]
reshape重塑数组生成新数组a3:
[[ 1 2 3 4 5 6][ 7 8 9 10 11 12]]
原数组a1不变:[ 1 2 3 4 5 6 7 8 9 10 11 12]
flatten函数把a3中的数据展开成一维数组a4：
[ 1 2 3 4 5 6 7 8 9 10 11 12]Process finished with exit code 0
数组合并 .hstack() .vstack() .concatenate((),axis=0/1)
数组的合并是指沿着特定的方向把多个数组合并到一起，numpy使用hstack、vstack和concatenate函数用于实现多个数组的合并。
import numpy as np
#水平合并(左右合并) 要求两个数组的行数一致
A = np.zeros((2, 3), int)
B = np.ones((2, 4), int)
print("A=\n", A)
print("B=\n", B)
print("hstack水平合并:\n", np.hstack((A, B)))
# axis =0垂直，1是水平
print("concatenate水平合并:\n", np.concatenate((A, B), axis=1))
A=[[0 0 0][0 0 0]]
B=[[1 1 1 1][1 1 1 1]]
hstack水平合并:[[0 0 0 1 1 1 1][0 0 0 1 1 1 1]]
concatenate水平合并:[[0 0 0 1 1 1 1][0 0 0 1 1 1 1]]
import numpy as np
# 垂直合并(上下合并) 两个数组列数一致
A = np.zeros((2,5), int)
B = np.ones((3, 5), int)
print("A=\n", A)
print("B=\n", B)
print("vstack垂直合并\n", np.vstack((A, B)))
# axis =0垂直，1是水平
print("concatenate垂直合并\n", np.concatenate((A, B), axis=0))
A=[[0 0 0 0 0][0 0 0 0 0]]
B=[[1 1 1 1 1][1 1 1 1 1][1 1 1 1 1]]
vstack垂直合并[[0 0 0 0 0][0 0 0 0 0][1 1 1 1 1][1 1 1 1 1][1 1 1 1 1]]
concatenate垂直合并[[0 0 0 0 0][0 0 0 0 0][1 1 1 1 1][1 1 1 1 1][1 1 1 1 1]]数组分割 .hsplit() .vsplit() .split()
与数组的合并相反，数组的分割是指沿着特定的方向把一个数组分割为多个小数组， numpy使用hsplit 、vsplit 和split 函数用于实现数组的分割。数组拆分后为list类型。
import numpy as np
arr=np.arange(12).reshape(3,4)
print("原数组：\n",arr)
print("水平分割为：\n",np.hsplit(arr,2))
print("垂直分割为：\n",np.vsplit(arr,3))
#axis=1,水平分割，axis=0,垂直分割
arr_split=np.split(arr,2,axis=1)
print("使用split水平拆分后的新数组：\n",arr_split)
print(type(arr_split))#新数据的数据类型为列表，列表中的元素是分割后的数组
print(type(arr))原数组：[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11]]
水平分割为：[array([[0, 1],[4, 5],[8, 9]]), array([[ 2, 3],[ 6, 7],[10, 11]])]
垂直分割为：[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
使用split水平拆分后的新数组：[array([[0, 1],[4, 5],[8, 9]]), array([[ 2, 3],[ 6, 7],[10, 11]])]
<class 'list'>
<class 'numpy.ndarray'>Process finished with exit code 0
数组的访问——数组的索引和切片
一维数组的索引和切片
import numpy as np
arr = np.arange(10)
print("原数组：",arr)
print("数组逆序：",arr[::-1]) #逆序
print("数组第3个元素：",arr[2]) #索引访问指定某个元素
print("数组最后一个元素：",arr[-1])
print("数组第3到6个元素：",arr[2:6])#切片访问多个元素
print("数组从第一位元素开始所有元素隔一个取一个：",arr[::2])
原数组： [0 1 2 3 4 5 6 7 8 9]
数组逆序： [9 8 7 6 5 4 3 2 1 0]
数组第3个元素： 2
数组最后一个元素： 9
数组第3到6个元素： [2 3 4 5]
数组从第一位元素开始所有元素隔一个取一个： [0 2 4 6 8]多维数组的索引和切片
import numpy as np #导入模块并命名为 np
np.random.seed(100) #同一种子产生的一组随机数是相同的
arr=np.random.randint(0, 50, (4,5)) # 4行5列二维数组，20个随机整数都介于[0,50)
print("原数组：\n",arr)
print("数组第1行第2列元素：",arr[0,1]) #索引访问指定某个元素
print("数组第2,4行元素：\n",arr[[1,3],:]) #索引访问指定某些行元素
print("数组第1,2,3列元素：\n",arr[:,0:3]) #索引访问指定某些列元素
print("从第三行开始，第三列开始的元素：\n",arr[2:,2:]) #索引访问指定某些元素
print("数组最后两行，最后三列元素：\n",arr[-2:,-3:])原数组：[[ 8 24 3 39 23][15 48 10 30 34][ 2 34 14 34 49][48 24 15 36 43]]
数组第1行第2列元素： 24
数组第2,4行元素：[[15 48 10 30 34][48 24 15 36 43]]
数组第1,2,3列元素：[[ 8 24 3][15 48 10][ 2 34 14][48 24 15]]
数组最后两行，最后三列元素：[[14 34 49][15 36 43]]
数组最后两行，最后三列元素：[[14 34 49][15 36 43]]数组的访问——修改数组元素的值
函数 。append() .insert() .delete()
可以使用索引和切片的方式直接修改数组中一个或者多个元素的值，也可以使用append、insert函数在原数组的基础上追加或者插入元素并返回新数组，还可以使用delete函数在原数组的基础上删除数组元素并返回新数组。
import numpy as np
arr = np.arange(10)
print("原数组：",arr)
arr1=np.append(arr,88) #在数组最后追加一个元素88，生成新数组，原数组不变
print("数组追加元素：",arr1)
arr2=np.insert(arr,1,100) #索引为1的位置增加一个元素100，生成新数组，原数组不变
print("数组插入元素：",arr2)
arr3=np.delete(arr,3) #删除索引为3的数组元素，生成新数组，原数组不变
print("删除索引为3的数组元素：",arr3)
arr[2]=66 #将数组索引为2的元素修改为66，原数组发生变化
print("修改后数组：",arr)
原数组： [0 1 2 3 4 5 6 7 8 9]
数组追加元素： [ 0 1 2 3 4 5 6 7 8 9 88]
数组插入元素： [ 0 100 1 2 3 4 5 6 7 8 9]
删除索引为3的数组元素： [0 1 2 4 5 6 7 8 9]
修改后数组： [ 0 1 66 3 4 5 6 7 8 9]数组的运算——数组与数组的运算
数组算术运算
在numpy中数组支持与标量的加、减、乘、除、幂等算数运算，不需要通过循环就可以完成批量计算，计算结果为一个新数组，新数组的元素为标量与原数组中每个元素进行计算的结果。
import numpy as np
arr = np.arange(1,6)
print("原数组：",arr)
print("数组与数值相加：",arr+2)
print("数组与数值相减：",arr-2)
print("数组与数值相乘：",arr*2)
print("数组与数值相除：",arr/2)
print("数组与数值幂运算：",arr**2)
print("数组与数值取余：",arr%2)
原数组： [1 2 3 4 5]
数组与数值相加： [3 4 5 6 7]
数组与数值相减： [-1 0 1 2 3]
数组与数值相乘： [ 2 4 6 8 10]
数组与数值相除： [0.5 1. 1.5 2. 2.5]
数组与数值幂运算： [ 1 4 9 16 25]
数组与数值取余： [1 0 1 0 1]
二维数组与一维数组的运算
若两个相同维度的数组进行运算，生成一个新数组，新数组每个元素的值为原来的两个数组中对应位置上的元素进行运算的结果。若两个数组维度不同时，若符合广播要求则进行广播，否则就报错并结束运行。
import numpy as np
A = np.arange(1,13).reshape(4,3) #4行3列数组
B = np.array([3]) #1行1列数组
C= A+B
print("{}+{}=\n{}".format(A,B,C))
[[ 1 2 3][ 4 5 6][ 7 8 9][10 11 12]]+[3]=
[[ 4 5 6][ 7 8 9][10 11 12][13 14 15]]import numpy as np
A = np.arange(1,13).reshape(4,3) #4行3列数组
B = np.array([2,1,3]) #1行3列数组
C= A-B
print("{}-{}=\n{}".format(A,B,C))
[[ 1 2 3][ 4 5 6][ 7 8 9][10 11 12]]-[2 1 3]=
[[-1 1 0][ 2 4 3][ 5 7 6][ 8 10 9]]二维数组与二维数组的运算
import numpy as np
A = np.arange(1,13).reshape(4,3) #4行3列数组
B = np.array([[4],[5],[-2],[2]]) #4行1列数组
C= A*B
print("{}×\n{}=\n{}".format(A,B,C))
[[ 1 2 3][ 4 5 6][ 7 8 9][10 11 12]]×
[[ 4][ 5][-2][ 2]]=
[[ 4 8 12][ 20 25 30][-14 -16 -18][ 20 22 24]]数组的运算——条件逻辑运算
数组的布尔运算：在numpy中可以使用基本的关系运算实现数组的条件运算，返回包含若干True/False的数组
True/False的数组
import numpy as np
np.random.seed(100)
arr = np.random.randint(1,21,10)
print("原数组：",arr)
print("判断数组中的元素是否大于 10:",arr>10)
print("数组中大于10的元素:",arr[arr>10])
print("统计数组中5～15的元素总数：",sum((arr>5)&(arr<15)))
print("是否都大于3:",np.all(arr>3))
print("是否有元素小于5:",np.any(arr<5))
原数组： [ 9 4 8 16 17 11 3 3 3 15]
判断数组中的元素是否大于 10: [False False False True True True False False False True]
数组中大于10的元素: [16 17 11 15]
统计数组中5～15的元素总数： 3
是否都大于3: False
是否有元素小于5: True
where用法
import numpy as np
arr = np.array([8,5,4,6,1,3,9,7])
print("原数组：",arr)
print("数组中大于5的元素对应1，其他对应0：",np.where(arr > 5 ,1,0))
print("数组中大于5的元素的索引：",np.where(arr>5))
print("数组中大于5的元素：",arr[np.where(arr>5)])
原数组： [8 5 4 6 1 3 9 7]
数组中大于5的元素对应1，其他对应0： [1 0 0 1 0 0 1 1]
数组中大于5的元素的索引： (array([0, 3, 6, 7], dtype=int64),)
数组中大于5的元素： [8 6 9 7]布尔型索引
将同样大小的布尔数组传进索引，会返回一个由所有True对应位置的元素的数组
import numpy as np #导入模块并命名为 np
np.random.seed(100) #同一种子产生的一组随机数是相同的
arr=np.random.randint(0, 50, 10) # 生成10个随机整数都介于[0,50)的一维数组
print("原数组：",arr)
print("数组大于20：",arr>20)
print("数组中大于20的元素：",arr[arr>20])
print("数组中大于20的奇数元素：",arr[(arr>20) & (arr%2!=0)])
原数组： [ 8 24 3 39 23 15 48 10 30 34]
数组大于20： [False True False True True False True False True True]
数组中大于20的元素： [24 39 23 48 30 34]
数组中大于20的奇数元素： [39 23]数组的运算——numpy库常用的数学函数运算
函数 ceil() floor() round() exp().....
|
函数 |
功能 |
|
sqrt(array) |
平方根函数 |
|
exp(array) |
e^array[i]的数组 |
|
abs(array) |
计算绝对值 |
|
square(array) |
计算各元素的平方，等于array**2 |
|
log/log10/log2(array) |
计算各元素的各种对数 |
|
sign(array) |
计算各元素正负号 |
|
ceil(array) |
向上取整,也就是取比这个数大的整数 |
|
floor(array) |
向下取整,也就是取比这个数小的整数 |
|
round(array) |
四舍五入 |
|
sin(array) |
正弦值 |
|
cos(array) |
余弦值 |
|
tan(array) |
正切值 |
import numpy as np
import numpy as np
#通过乘 pi/180 转化为弧度
arr = np.array([0, 30, 45, 60, 90])* np.pi / 180
print('数组中不同角度的正弦值：\n',np.sin(arr))
print('数组中不同角度的余弦值：\n',np.cos(arr))
print('数组中不同角度的正切值：\n',np.tan(arr))arr2=np.array([0,12,8,6.6,0.5,-2,-0.1,-0.6,-1.1])
print('e^array[i]的数组：\n',np.exp(arr2))
print('四舍五入(实则五舍六入)：\n',np.round(arr2))
print('计算各元素的平方，等于array**2：\n',np.square(arr2))
print('计算各元素正负号：\n',np.sign(arr2))
print('向下取整,也就是取比这个数小的整数：\n',np.floor(arr2))数组中不同角度的正弦值：[0. 0.5 0.70710678 0.8660254 1. ]
数组中不同角度的余弦值：[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-016.12323400e-17]
数组中不同角度的正切值：[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+001.63312394e+16]
e^array[i]的数组：[1.00000000e+00 1.62754791e+05 2.98095799e+03 7.35095189e+021.64872127e+00 1.35335283e-01 9.04837418e-01 5.48811636e-013.32871084e-01]
四舍五入(实则五舍六入)：[ 0. 12. 8. 7. 0. -2. -0. -1. -1.]
计算各元素的平方，等于array**2：[0.000e+00 1.440e+02 6.400e+01 4.356e+01 2.500e-01 4.000e+00 1.000e-023.600e-01 1.210e+00]
计算各元素正负号：[ 0. 1. 1. 1. 1. -1. -1. -1. -1.]
向下取整,也就是取比这个数小的整数：[ 0. 12. 8. 6. 0. -2. -1. -1. -2.]numpy中的数据统计与分析
排序 sort() argsort()
sort函数语法格式：np.sort(a, axis, kind, order)
参数说明：a:要排序的数组；axis：排序沿着指定轴对数组进行排序，0表示按行排序，1表示按列排序；
sort方法语法格式：a.sort()
功能：对数组a排序，改变原始数组，无返回值。
mport numpy as np
np.random.seed(100)
a=np.random.randint(10,100,12)
print("原数组a：",a)
print("使用sort函数排序结果：",np.sort(a)) #对数组排序，不改变原数组
print("原数组a不变：",a)
b=a.reshape(4,3) #将a变形为4行3列数组b
print("二维数组b:\n",b)
print("二维数组b按行排序:\n",np.sort(b,axis=1))#axis =0垂直，1是水平
print("二维数组b按列排序:\n",np.sort(b,axis=0))
a.sort() #改变原数组 ，无返回值
print("使用sort方法对数组a排序后改变原数组：",a)
原数组a： [18 34 77 97 89 58 20 62 63 76 24 44]
使用sort函数排序结果： [18 20 24 34 44 58 62 63 76 77 89 97]
原数组a不变： [18 34 77 97 89 58 20 62 63 76 24 44]
二维数组b:[[18 34 77][97 89 58][20 62 63][76 24 44]]
二维数组b按行排序:[[18 34 77][58 89 97][20 62 63][24 44 76]]
二维数组b按列排序:[[18 24 44][20 34 58][76 62 63][97 89 77]]
使用sort方法对数组a排序后改变原数组： [18 20 24 34 44 58 62 63 76 77 89 97]Process finished with exit code 0
argsort函数语法格式：np.argsort(a, axis, kind, order)
功能：对数组a排序，返回一个由整数构成的索引数组
import numpy as np
a=np.array([4,2,6])
print("原数组a：",a)
print("排序后：",np.argsort(a)) #原数组中索引为1的元素最小，索引为0的元素次之，索引为2的元素最大
原数组a： [4 2 6]
排序后： [1 0 2]
数据去重与重复 去重unique() 重复tile() repeat()
通过unique函数可以找出数组中的唯一值并返回已经排序的结果。
import numpy as np
colors=np.array(['red','blue','yellow','white','blue'])
print("原数组：",colors)
print("去重后的数组：",np.unique(colors))
原数组： ['red' 'blue' 'yellow' 'white' 'blue']
去重后的数组： ['blue' 'red' 'white' 'yellow']tile函数语法格式：np.tile(A, reps)
repeat函数语法格式：np.repeat(A, reps, axis=None)
import numpy as np
arr = np.arange(5)
print("原数组：",arr)
arr1 = np.tile(arr,3)
print("原数组重复3次：",arr1)
arr2=np.arange(9).reshape(3,3) #3行3列二维数组
print("二维数组：\n",arr2)
arr3 = np.repeat(arr2,2,axis=0) #按行重复
print("二维数组按行重复2次：\n",arr3)
#axis =0垂直，1是水平
原数组： [0 1 2 3 4]
原数组重复3次： [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
二维数组：[[0 1 2][3 4 5][6 7 8]]
二维数组按行重复2次：[[0 1 2][0 1 2][3 4 5][3 4 5][6 7 8][6 7 8]]
常用统计函数 最大值、最小值、平均值、中值
计算数组的和、最大值、最小值
|
函数 |
功能 |
|
sum(a, axis) |
计算数组中的元素沿指定轴的和 |
|
min(a, axis) |
计算数组中的元素沿指定轴的最小值。 |
|
argmin(a, axis) |
计算数组中的元素最小值的索引 |
|
max(a, axis) |
计算数组中的元素沿指定轴的最大值 |
|
argmax(a, axis) |
计算数组中的元素最大值的索引 |
import numpy as np
np.random.seed(10)
arr = np.random.randint(0,20,9).reshape(3,3) #3行3列数组
print("原数组：\n",arr)
print("数组全部元素求和：",np.sum(arr))
print("数组按行求最大值：",np.max(arr,axis=1))
print("数组按行求最大值索引：",np.argmax(arr,axis=1))
print("数组按列求最小值：",np.min(arr,axis=0))
print("数组按列求最小值索引：",np.argmin(arr,axis=0))
原数组：[[ 9 4 15][ 0 17 16][17 8 9]]
数组全部元素求和： 95
数组按行求最大值： [15 17 17]
数组按行求最大值索引： [2 1 0]
数组按列求最小值： [0 4 9]
数组按列求最小值索引： [1 0 2]Process finished with exit code 0
计算数组均值、中值
|
函数 |
功能 |
|
median(a, axis) |
沿指定轴计算数组中元素的中值 |
|
mean(a, axis) |
沿指定轴计算数组中元素的平均值 |
import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
print("原数组：\n",arr)
print("数组全部元素的平均值",np.mean(arr))
print("数组按行求平均值：",np.mean(arr,axis=1))
print("数组按列求平均值：",np.mean(arr,axis=0))
print("数组全部元素的中值",np.median(arr))
print("数组按行求中值：",np.median(arr,axis=1))
print("数组按列求中值：",np.median(arr,axis=0))
C:\python\Python310\python.exe A:/PycharmProjects/pythonProject/NumpyStudy.py
原数组：[[1 2 3][4 5 6]]
数组全部元素的平均值 3.5
数组按行求平均值： [2. 5.]
数组按列求平均值： [2.5 3.5 4.5]
数组全部元素的中值 3.5
数组按行求中值： [2. 5.]
数组按列求中值： [2.5 3.5 4.5]Process finished with exit code 0
计算数组方差、标准差、协方差矩阵
|
函数 |
功能 |
|
std(a, axis,ddof=1) |
计算数组的标准差 |
|
var(a, axis,ddof=1) |
计算数组的方差，标准差是方差的平方根 |
|
cov(a) |
计算协方差矩阵 |
import numpy as np
np.random.seed(10)
arr = np.random.randint(0,50,20).reshape(2,10) #2行10列数组
print("原数组：\n",arr)
print("数组全部元素的方差",np.var(arr))
print("数组全部元素的无偏方差",np.var(arr,ddof=1))
print("数组按行求无偏方差：",np.var(arr,axis=1,ddof=1))
print("数组按列求方差：",np.var(arr,axis=0))
print("数组协方差矩阵：\n",np.cov(arr)) # 默认行为变量计算方式
C:\python\Python310\python.exe A:/PycharmProjects/pythonProject/NumpyStudy.py
原数组：[[ 9 36 15 0 49 28 25 29 48 29][49 8 9 0 42 40 36 16 36 47]]
数组全部元素的方差 259.24750000000006
数组全部元素的无偏方差 272.89210526315793
数组按行求无偏方差： [246.17777778 328.67777778]
数组按列求方差： [400. 196. 9. 0. 12.25 36. 30.25 42.25 36. 81. ]
数组协方差矩阵：[[246.17777778 101.4 ][101.4 328.67777778]]Process finished with exit code 0
计算数组的百分位数
函数的语法格式：percentile(a, q, axis)
参数说明：
- a: 输入数组；
- q: 要计算的百分比的数字，该数字在 0 ~ 100 之间；
- axis: 沿着它计算百分位数的轴。
import numpy as np
np.random.seed(10)
arr = np.random.randint(0,50,10)
print("原数组：",arr)
print("数组的平均值",np.mean(arr))
print("数组的中值",np.median(arr))
print("数组的百分位为50的值：",np.percentile(arr,50))
print("数组的百分位为0,25,50,75,100的值：",np.percentile(arr,[0,25,50,75,100]))
C:\python\Python310\python.exe A:/PycharmProjects/pythonProject/NumpyStudy.py
原数组： [ 9 36 15 0 49 28 25 29 48 29]
数组的平均值 26.8
数组的中值 28.5
数组的百分位为50的值： 28.5
数组的百分位为0,25,50,75,100的值： [ 0. 17.5 28.5 34.25 49. ]Process finished with exit code 0
求解线性方程组——数组与矩阵
数组ndarray和矩阵matrix
numpy库包含了两种基本类型：数组ndarray和矩阵matrix。 numpy数组中所有元素的类型必须是相同的，矩阵matrix必须是二维的，是特殊的数组。matrix 拥有array的所有特性， matrix的主要优势是：相对简单的乘法运算符号。
import numpy as np
A_mat = np.mat([[1, 2],[3, 4]], int) #创建矩阵
A_array = np.array([[1, 2],[3, 4]]) #创建二维数组
print("A_mat矩阵：\n",A_mat)
print("A_mat矩阵的类型：",type(A_mat))
print("A_array二维数组：\n",A_array)
print("A_array二维数组的类型：",type(A_array))
C:\python\Python310\python.exe A:/PycharmProjects/pythonProject/NumpyStudy.py
A_mat矩阵：[[1 2][3 4]]
A_mat矩阵的类型： <class 'numpy.matrix'>
A_array二维数组：[[1 2][3 4]]
A_array二维数组的类型： <class 'numpy.ndarray'>Process finished with exit code 0
矩阵和数组的点乘运算
矩阵和数组的点乘运算有点不同：当采用 * 符号进行运算时，矩阵可以实现点乘运算，而数组的运算结果是对应元素的乘积；在调用 dot 函数时矩阵和数组均可实现点乘运算。dot 函数为矩阵乘法，该函数功能：若为一维数组，求出内积；若为二维数组，则进行矩阵乘法。矩阵乘法的第一个矩阵的列数（column）和第二个矩阵的行数（row）必须相同。
import numpy as np
A_mat = np.mat([[1, 2],[3, 4]], int) #2×2矩阵
B_mat = np.mat([[1],[2]], int) #2×1矩阵
print("A_mat*B_mat=\n",A_mat*B_mat)
print("dot函数矩阵计算结果：\n",np.dot(A_mat,B_mat))
A_array = np.array([[1, 2],[3, 4]]) #2×2二维数组
B_array = np.array([[1],[2]]) #2×1二维数组
print("A_array*B_array=\n",A_array*B_array)
print("dot函数数组计算结果：\n",np.dot(A_array,B_array))
C:\python\Python310\python.exe A:/PycharmProjects/pythonProject/NumpyStudy.py
A_mat*B_mat=[[ 5][11]]
dot函数矩阵计算结果：[[ 5][11]]
A_array*B_array=[[1 2][6 8]]
dot函数数组计算结果：[[ 5][11]]Process finished with exit code 0
求解线性方程组
方法一：
import numpy as np
A_mat = np.mat([[2,1, -5, 1], [1,-3, 0, -6], [0,2, -1,2],[1,4,-7,6]], int)
b_mat = np.mat([[8], [6], [-2],[2]], int)
x = np.linalg.solve(A_mat, b_mat)
print("线性方程组的解：\n",x)
线性方程组的解：[[ 4. ][-1.55555556][-0.22222222][ 0.44444444]]
方法二：
import numpy as np
A_array = np.array([[2,1, -5, 1], [1,-3, 0, -6], [0,2, -1,2],[1,4,-7,6]])
b_array = np.array([[8], [6], [-2],[2]])
x = np.linalg.solve(A_array, b_array)
print("线性方程组的解：\n",x)
线性方程组的解：[[ 4. ][-1.55555556][-0.22222222][ 0.44444444]]
Python - Numpy库的使用（简单易懂）相关推荐
- python numpy库安装-Python Numpy库安装与基本操作示例
本文实例讲述了Python Numpy库安装与基本操作.分享给大家供大家参考,具体如下: 概述 NumPy(Numeric Python)扩展包提供了数组功能,以及对数据进行快速处理的函数. NumP ...
- python numpy库 一些统计量计算
import numpy as np # a = np.array([[3,7,5],[8,4,3],[2,4,9]]) # print ('我们的数组是:') # print (a) # print ...
- Python Numpy库教程
目录 1 Numpy概述 1.1 概念 1.2 功能 1.3 对象 1.4 数据类型 1.5 数组属性 2 Numpy数组操作 2.1 Numpy创建 2.1.1 利用列表生成数组 2.1.2 利用r ...
- Python Numpy库教程(超详细)
1 Numpy概述 1.1 概念 Python本身含有列表和数组,但对于大数据来说,这些结构是有很多不足的.由于列表的元素可以是任何对象,因此列表中所保存的是对象的指针.对于数值运算来说这种 结构比较 ...
- python numpy库
文章目录 NumPy( Numeric Python) numpy的引用 Ndarray 引入n维数组的意义 ndarray的组成 ndarray对象的属性 数据类型 ndarray支持多种数据类型的 ...
- Python -- Numpy库的使用
Numpy库的使用 要点:numpy是用于处理含有同种元素的多维数组运算的第三方库. 1.numpy库概述 Python标准库中提供了一个array类型,用于保存数组类型数据,然而这个类型不支 ...
- python numpy库中省略号...的一些用法
在学习<Designing Machine Learning Systems with Python>(<机器学习系统设计Python语言实现>)一书的第五章梯度下降一节代码中 ...
- python numpy库是第三方库吗_浅谈python的第三方库——numpy（终）
本文作为numpy系列的总结篇,继续介绍numpy中常见的使用小贴士 1 手动转换矩阵规格 转换矩阵规格,就是在保持原矩阵的元素数量和内容不变的情况下,改变原矩阵的行列数目.比如,在得到一个5x4的矩 ...
- python numpy库_numpy库学习总结（基础知识）
最近在学习Python中OpenCV库,学习花了很多时间,发现基础知识很重要,尤其是numpy这个库,在进行程序开发时,处理大量类似数组这种数据结构时,它的重要性等同于Python中的列表,像前篇我们 ...
最新文章
- react native 导入组件
- 两个单链表相交的一系列问题
- 《Deep Learning With Python second edition》英文版读书笔记：第十一章DL for text: NLP、Transformer、Seq2Seq
- 误删表数据，如何恢复过来
- CentOS上快速安装Oracle11g数据库
- 【转】 NSArray copy 问题
- 【mac apache】了解自带的apache
- IIS6应用程序池中间的 Web 园
- 前端开发之功能封装大全
- Python深度学习环境配置全流程
- WES 7 FBWF灾难性故障
- python 校验邮箱格式、手机号格式
- Spring5-完全注解开发【之】第一步，先实现功能（增删改查），再讲解陌生代码
- 1-3年Android开发工程师面试经验分享，面试建议
- python 正则表达式量词
- 做谷粒商城电脑配置不够怎么办？
- 如何改typecho主题头像_细节决定成败，抖音昵称、头像、简介、视频封面的重要性...
- 大学计算机基础第四章ppt,大学计算机基础第四章.ppt
- 2014年3月份第3周51Aspx源码发布详情
- MATLAB台大郭彦甫老师课程笔记：第一课：基本操作与矩阵输入