代码收藏家 Python – Numpy库的使用（简单易懂）
目录
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函数创建数组对象
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函数创建等差数组对象
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函数创建等比数列数组
# 构造从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的元素个数:6
Process 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-01
6.12323400e-17]
数组中不同角度的正切值：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
e^array[i]的数组：
[1.00000000e+00 1.62754791e+05 2.98095799e+03 7.35095189e+02
1.64872127e+00 1.35335283e-01 9.04837418e-01 5.48811636e-01
3.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-02
3.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]]
来源：NO.-LL
