数组的访问——数组的索引和切片
一维数组的索引和切片
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().....
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]]
常用统计函数 最大值、最小值、平均值、中值
计算数组的和、最大值、最小值
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]]
