一.简介
1.主要用于科学计算，主要特点是ndarray数组
2.http://www.numpy.org/
3.https://numpy.org/doc/1.18/numpy-ref.pdf
二.ndarray类
1.简介：n维数组
（1）相当于python中的容器对象（比如列表），执行效率更高（速度快），代码更少（内存小）
（2）数组中的每个元素都需要具有相同的数据类型，内存分配的大小也相同
（3）初始化创建时最好指明：数组中元素的类型（dtype），数组的大小(shape)，用来创建数组的对象（比如列表或嵌套的多维表现形式）
2.常用属性
（1）dtype：元素类型，表现数据的存储方式和大小，比如float16、float32、float64、float、bool、complex、uint8、int32、int8、int16.....
（2）shape：数组形状（元组形式），从外往内数一维数组元素的个数，比如【【【1,2,3】 【4,5,6】】 、 【【3,4,5】【2,4,5,】 】 、 【【3,4,5】【2,4,5,】 】 】：（3，2，3）最外层一维数组总有三个元素，每个元素中又有两个元素，这两个元素中每个又有三个元素。若是二维，则表示行数和列数，注意：维度是从外往内的、从1开始，对应axis=0，
（3）T：转置
（4）ndim：维度，shape元组的长度
1 import numpy as np 2 a = np.arange(15).reshape(3, 5) 3 print(a) # 显示数组 4 print(type(a)) # 类型是ndarry（多维数组） 5 print(a.shape) # 数组形状，3行5列 6 print(a.size) # 数组的元素总数，3*5=15 7 print(a.ndim) # 数组轴数，2，从0开始即0,1,2 8 print(a.dtype) # 数组中元素的类型，int32 9 10 print(a.itemsize) # 数组中每个元素的大小（以字节为单位）,32/8=4 11 print(a.data) # 包含数组实际元素的缓冲区,不常用 12 print(a.flags) # 对象的内存信息 13 print(a.itemsize) # 返回数组中每个元素的字节单位长度 14 print(a.T) # 转置 15 --------------------------------------------------------------- 16 [[ 0 1 2 3 4] 17 [ 5 6 7 8 9] 18 [10 11 12 13 14]] 19 <class 'numpy.ndarray'> 20 (3, 5) 21 15 22 2 23 int32 24 4 25 <memory at 0x0000025EDCC1BA68> 26 C_CONTIGUOUS : True 27 F_CONTIGUOUS : False 28 OWNDATA : False 29 WRITEABLE : True 30 ALIGNED : True 31 WRITEBACKIFCOPY : False 32 UPDATEIFCOPY : False 33 34 4 35 [[ 0 5 10] 36 [ 1 6 11] 37 [ 2 7 12] 38 [ 3 8 13] 39 [ 4 9 14]]
3.常用方法
（1）修改数组形状：
【1】.reshape（）：改变数组形状,返回已修改的数组，但不更改原始数组，比如把（3,2）变成（2,3）
【2】.ravel()：返回所有元素的一维数组，从左到右，从上到下
【3】.transpose：转置相当于.T
【4】.swapaxes：维度交换，若ndarray是二维的，则就变成了转置
1 ###########数组变化############## 2 a = np.floor(10*np.random.random((3,4))) 3 print(a) 4 # 返回已修改的数组，但不更改原始数组 5 print(a.reshape(4, 3)) # reshape方法改变数组的形状， 6 print(a.reshape(3,-1)) # 尺寸指定为-1，则会自动计算其他尺寸 7 print(a.ravel()) # 返回所有元素的一维数组，从左到右，从上到下 8 print(a.transpose()) # 转置 9 print(a.flatten()) # 扁平化 10 print(a.swapaxes(0,1)) # 维度交换 11 print(a) 12 print('#'*30) 13 print(a.resize((2, 6))) # resize方法修改数组本身 14 print(a) 15 ------------------------------ 16 [[8. 8. 8. 2.] 17 [3. 0. 5. 9.] 18 [1. 1. 1. 8.]] 19 [[8. 8. 8.] 20 [2. 3. 0.] 21 [5. 9. 1.] 22 [1. 1. 8.]] 23 [[8. 8. 8. 2.] 24 [3. 0. 5. 9.] 25 [1. 1. 1. 8.]] 26 [8. 8. 8. 2. 3. 0. 5. 9. 1. 1. 1. 8.] 27 [[8. 3. 1.] 28 [8. 0. 1.] 29 [8. 5. 1.] 30 [2. 9. 8.]] 31 [8. 8. 8. 2. 3. 0. 5. 9. 1. 1. 1. 8.] 32 [[8. 3. 1.] 33 [8. 0. 1.] 34 [8. 5. 1.] 35 [2. 9. 8.]] 36 [[8. 8. 8. 2.] 37 [3. 0. 5. 9.] 38 [1. 1. 1. 8.]] 39 ############################## 40 None 41 [[8. 8. 8. 2. 3. 0.] 42 [5. 9. 1. 1. 1. 8.]]
（2）一般方法
1 # 一般方法####################################################### 2 import numpy as np 3 a = np.array([[1,2,3],[4,5,6],[2,4,5]]) 4 print(a.item(3)) # 相当于索引，一个值相当于扁平化的所有，返回标量 5 print(a.item((1,2))) # 相当于索引，相当于a[1,2]，返回标量 6 print(a.tolist()) # 转变为列表 7 print(a.tostring()) # 转变为字符串 8 print(a.tofile('c.txt')) # 存储进文件 9 print(a.astype('float32')) # 转变元素类型 10 print(a.copy()) # 复制，生成数组及其数据的完整副本，完全拷贝了父对象及其子对象,深拷贝id变了 11 print(a.view(dtype=np.int8)) # 创建一个查看数据的新数组对象,浅拷贝 12 print(a) 13 14 print(a.fill(1)) # 以上的操作不改变a，但fill填充改变a 15 print(a) 16 ------------------------------------------- 17 4 18 6 19 [[1, 2, 3], [4, 5, 6], [2, 4, 5]] 20 b'x01x00x00x00x02x00x00x00x03x00x00x00x04x00x00x00x05x00x00x00x06x00x00x00x02x00x00x00x04x00x00x00x05x00x00x00' 21 None 22 [[1. 2. 3.] 23 [4. 5. 6.] 24 [2. 4. 5.]] 25 [[1 2 3] 26 [4 5 6] 27 [2 4 5]] 28 [[1 0 0 0 2 0 0 0 3 0 0 0] 29 [4 0 0 0 5 0 0 0 6 0 0 0] 30 [2 0 0 0 4 0 0 0 5 0 0 0]] 31 [[1 2 3] 32 [4 5 6] 33 [2 4 5]] 34 None 35 [[1 1 1] 36 [1 1 1] 37 [1 1 1]]
（3）涉及维度的方法：axis = 0表示在第一个维度上操作，axis=1表示在第二个维度上操作
1 #涉及维度######################################################################## 2 import numpy as np 3 a = np.array([[1,2,3],[5,4,6],[2,4,5]]) 4 print(a.repeat(2,axis=1)) # 在第二维度上每个元素重复两次 5 print(a.sort(axis=1)) # 在第二维度上进行排序，改变a,若排序的是数组，则以每个数组第一个元素来进行排序 6 print(a) 7 print(a.argsort(axis=1)) # 得出排序的索引 8 print(a.diagonal()) # 得出对角线元素的数组 9 ------------------------------------------------------- 10 [[1 1 2 2 3 3] 11 [5 5 4 4 6 6] 12 [2 2 4 4 5 5]] 13 None 14 [[1 2 3] 15 [4 5 6] 16 [2 4 5]] 17 [[0 1 2] 18 [0 1 2] 19 [0 1 2]] 20 [1 5 5]
（4）涉及计算的方法：axis = 0表示在第一个维度上操作，axis=1表示在第二个维度上操作
1 import numpy as np 2 a = np.array([[1,2,3],[4,5,6]]) 3 print(a) 4 # axis表示第几维度的元素进行运算，从0开始，第一维度开始 5 print(a.max()) # 获取整个矩阵的最大值 结果： 6 6 print(a.min()) # 结果：1 7 print(a.max(axis=0)) # 获得第一个维度所有元素比较得到(列)的最大（小）值[4 5 6] 8 print(a.min(axis=1)) # 获得第二个维度所有元素比较得到(行)的最大（小）值[1 4] 9 print(a.argmax(axis=1)) # 要想获得最大最小值元素所在的位置，可以通过argmax函数来获得 10 print(a.mean()) # 元素的平均值 11 print(a.mean(axis=0)) # 每列平均值,第一个维度所有元素加和的平均值[2.5 3.5 4.5] 12 print(a.mean(axis=1)) # 每行平均值，第二个维度所有元素加和的平均值[2. 5.] 13 print(a.var()) # 方差相当于函数mean(abs(x - x.mean())**2) 14 print(a.std()) # 标准差相当于sqrt(mean(abs(x - x.mean())**2)) 15 print(np.median(a)) # 对所有数取中值 16 print(np.median(a,axis=0)) # 列方向取中值 17 print(a.sum()) # 对整个矩阵求和 18 print(a.cumsum()) # 对整个矩阵求累积和,某位置累积和指的是该位置之前(包括该位置)所有元素的和[ 1 3 6 10 15 21] 19 print(a.round(4)) # 四舍五入 20 print(a.trace()) # 对角线元素求和6 21 print(a.prod()) # 整个数组求积 22 print(a.cumprod()) # 累积 23 print(a.all()) # 布尔判断，且 24 print(a.any()) # 布尔判断，或 25 ------------------------------------------------------------ 26 [[1 2 3] 27 [4 5 6]] 28 6 29 1 30 [4 5 6] 31 [1 4] 32 [2 2] 33 3.5 34 [2.5 3.5 4.5] 35 [2. 5.] 36 2.9166666666666665 37 1.707825127659933 38 3.5 39 [2.5 3.5 4.5] 40 21 41 [ 1 3 6 10 15 21] 42 [[1 2 3] 43 [4 5 6]] 44 6 45 720 46 [ 1 2 6 24 120 720] 47 True 48 True
4.索引和切片：类似序列，冒号‘：’表示某个维度从...到...，后面还可接步长；逗号‘,’表示分隔不同维度
1 import numpy as np 2 a = np.array([[1, 2, 3, 4, 5], 3 [6, 7, 8, 9, 10]]) 4 print(a) 5 print(a[1]) # 选取行号为1的全部元素，等于print(a[1, :]),print(a[1, ...])省略号表示该维度都取值 6 print(a[1][2]) # 截取行号为一，列号为2的元素8,与上面的等价 7 print(a[:, 2]) # 选择列为2的全部元素 print (a[1,...]) 8 9 print(a[:]) # 选取全部元素 10 print(a[0:1]) # 默认行数截取[0,1)，等于print(a[0:1,:]) 11 print(a[1, 2:5]) # 截取第二行第[2,5）的元素[ 8 9 10] 12 print(a[0:1, 1:3:2]) # 截取第一个维度【0:1），第二个维度【1,3），步长为2的元素 13 14 # 高级索引 15 rows = np.array([[0,0],[1,1]]) 16 cols = np.array([[0,3],[0,4]]) 17 print(a[rows, cols]) # 整数数组索引，通过不同维度的具体表示来指定具体的索引：(0,0),(0,3),(1,0)(1,4) 18 # 按条件截取 19 print(a[a>6]) # 截取矩阵a中大于6的数，范围的是一维数组 20 print(a > 6) # 比较a中每个数和6的大小，输出值False或True 21 a[a > 6] = 0 # 把a中大于6的数变成0， 22 print(a) 23 24 # 使用~（取补运算符）来过滤NaN 25 a1 = np.array([np.nan,1,2,np.nan,3,4,5]) 26 print(a1[~np.isnan(a1)]) 27 ---------------------------------------------- 28 [[ 1 2 3 4 5] 29 [ 6 7 8 9 10]] 30 [ 6 7 8 9 10] 31 8 32 [3 8] 33 [[ 1 2 3 4 5] 34 [ 6 7 8 9 10]] 35 [[1 2 3 4 5]] 36 [ 8 9 10] 37 [[2]] 38 [[ 1 4] 39 [ 6 10]] 40 [ 7 8 9 10] 41 [[False False False False False] 42 [False True True True True]] 43 [[1 2 3 4 5] 44 [6 0 0 0 0]] 45 [1. 2. 3. 4. 5.]
5.迭代：
1 import numpy as np 2 a=np.arange(4,16).reshape(4,3) 3 print(a) 4 print('*'*30) 5 for i in a:#迭代数组 6 print(i,end=' ') 7 print() 8 print('*'*30) 9 for row in a:#以行迭代数组 10 print(row,end=' ') 11 print() 12 print('*'*30) 13 for column in a.T:#以列迭代数组 14 print(column,end=' ') 15 print() 16 print('*'*30) 17 print(a.flatten())#以一个列表的形式存储所有元素 18 for item in a.flat:#迭代数组的每一个元素 19 print(item,end=' ') 20 print() 21 print('*'*30) 22 ------------------------------------------------------ 23 [[ 4 5 6] 24 [ 7 8 9] 25 [10 11 12] 26 [13 14 15]] 27 ****************************** 28 [4 5 6] [7 8 9] [10 11 12] [13 14 15] 29 ****************************** 30 [4 5 6] [7 8 9] [10 11 12] [13 14 15] 31 ****************************** 32 [ 4 7 10 13] [ 5 8 11 14] [ 6 9 12 15] 33 ****************************** 34 [ 4 5 6 7 8 9 10 11 12 13 14 15] 35 [[ 4 5 6] 36 [ 7 8 9] 37 [10 11 12] 38 [13 14 15]] 39 4 5 6 7 8 9 10 11 12 13 14 15 40 ******************************
6.创建数组
（1）从已知的数据中创建数组
【1】array函数创建数组，将元组或列表作为参数
1 import numpy as np 2 3 # 创建数组，将元组或列表作为参数,dtype设定元素类型 4 a1 = np.array( [2, 3, 4] )#1*3 5 a2 = np.array( ([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]) )#2*5 6 a3 = np.array( [(1.5, 2, 3), (4, 5, 6)], dtype=complex )#2*3 7 a4 = np.array( [[1, 2], [4, 5, 7], 3] )#3*1 8 print(a1) 9 print(a2) 10 print(a3) 11 print(a4) 12 ------------------------------------------------------------ 13 [2 3 4] 14 [[ 1 2 3 4 5] 15 [ 6 7 8 9 10]] 16 [[1.5+0.j 2. +0.j 3. +0.j] 17 [4. +0.j 5. +0.j 6. +0.j]] 18 [list([1, 2]) list([4, 5, 7]) 3]
【2】其他方法：copy、asarray、asmatrix....
（2）创建特殊数组--给定形状和元素类型
【1】空数组，实际有值
1 a_empty = np.empty((3,4),dtype=float) # empty(N)生成一个N长度的未初始化一维的数组，创建3*4的空矩阵 2 print(a_empty) # 空矩阵（实际有值--随机给值） 3 a = ([1,2,3], [4,5,6]) 4 print(np.empty_like(a)) # 形状和类型与给定数组相同的新数组 5 ------------------------------------- 6 [[6.23042070e-307 1.42417221e-306 1.37961641e-306 1.27945651e-307] 7 [8.01097889e-307 1.78020169e-306 7.56601165e-307 1.02359984e-306] 8 [1.33510679e-306 2.22522597e-306 1.33511562e-306 2.18569063e-312]] 9 [[6619222 7536754 7274601] 10 [ 110 0 0]]
【2】单位矩阵
1 a_eye = np.eye(3) # eye(N)创建一个N * N的二维单位矩阵，创建3阶单位矩阵， 2 print(a_eye) # 单位矩阵,等同于np.identity( N ) 3 ------------------------------------------ 4 [[1. 0. 0.] 5 [0. 1. 0.] 6 [0. 0. 1.]]
【3】全1数组
1 a_ones = np.ones((3,4)) # ones(N)生成一个N长度的一维全一的数组，创建3*4的全1矩阵 2 print(a_ones) # 全1矩阵 3 a1 = np.arange(6).reshape((2, 3)) 4 print(np.ones_like(a1)) # 创建类似的全1矩阵 5 ---------------------------------- 6 [[1. 1. 1. 1.] 7 [1. 1. 1. 1.] 8 [1. 1. 1. 1.]] 9 [[1 1 1] 10 [1 1 1]]
【4】全0数组
1 a_zeros = np.zeros((3,4)) # zeros(N)生成一个N长度的一维全零的数组，创建3*4的全0矩阵 2 print(a_zeros) # 全0矩阵 3 a1 = np.arange(6).reshape((2, 3)) 4 print(np.zeros_like(a1)) # 创建类似结构的全0矩阵 5 -------------------------- 6 [[0. 0. 0. 0.] 7 [0. 0. 0. 0.] 8 [0. 0. 0. 0.]] 9 [[0 0 0] 10 [0 0 0]]
【5】填充数组
1 # 以某个数填充数组，即把每个单位元素都变为该数 2 print(np.full((2, 2), np.inf)) 3 print(np.full((2, 2), 10)) 4 print(np.full_like(np.arange(6, dtype=int), 1)) 5 ----------------------------------- 6 [[inf inf] 7 [inf inf]] 8 [[10 10] 9 [10 10]] 10 [1 1 1 1 1 1]
（3） 给定范围创建特殊数组
【1】np.arrage()：给定间隔内的均匀间隔的值，创建数组序列（一维），类似range，不过返回的是数组而不是列表，右边默认为开区间
1 import numpy as np 2 a = np.arange(12) # 利用arange函数创建数组, 3 print(a) 4 a2=np.arange(1,2,0.1) # arang函数和range函数相似,(开始，结束，步长) 5 print(a2) 6 --------------------------------------------------- 7 [ 0 1 2 3 4 5 6 7 8 9 10 11] 8 [1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9]
【2】linspace用于创建指定数量等间隔的序列，实际生成一个等差数列，右边默认为闭区间
1 a = np.linspace(0,1,12) # 从0开始到1结束，共12个数的等差数列 2 a2 = np.linspace(2.0, 3.0, num=5) # 从2.0开始到3.0结束，共5个数的等差数列 3 print(a) 4 print(a2) 5 -------------------------------- 6 [0. 0.09090909 0.18181818 0.27272727 0.36363636 0.45454545 7 0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1. ] 8 [2. 2.25 2.5 2.75 3. ]
【3】logspace和geomspace用于生成等比数列，对数刻度均匀分布，右边默认为闭区间
1 a = np.logspace(2.0, 8.0, num=4, base=2.0) # 生成首位是2的2次方，末位是2的8次方，含4个数的等比数列 2 # 等价于2-8分成四份（2,4,6,8），然后以2为底的指数 3 print(a) 4 a2 = np.geomspace(1, 1000, num=4) # 生成从1到1000的等比数列，自动计算比 5 print(a2) 6 ---------------------------------------- 7 [ 4. 16. 64. 256.] 8 [ 1. 10. 100. 1000.]
【4】坐标矩阵
1 nx, ny = (3, 2) 2 x = np.linspace(0, 1, nx) 3 y = np.linspace(0, 1, ny) 4 xv, yv = np.meshgrid(x, y) # 坐标系网格，有对应关系 5 print(xv) 6 print(yv) 7 -------------------------------- 8 [[0. 0.5 1. ] 9 [0. 0.5 1. ]] 10 [[0. 0. 0.] 11 [1. 1. 1.]]
（4）其他特殊矩阵：对角矩阵，上三角和下三角矩阵
1 x = np.arange(1,10).reshape((3,3)) 2 print(x) 3 print(np.diag(x)) # 提取对角线元素组成数组 4 print(np.diag(np.diag(x))) # 根据数组创建对角矩阵 5 print(np.tril(x)) # 下三角矩阵 6 print(np.triu(x)) # 上三角矩阵 7 ---------------------------------------- 8 [[1 2 3] 9 [4 5 6] 10 [7 8 9]] 11 [1 5 9] 12 [[1 0 0] 13 [0 5 0] 14 [0 0 9]] 15 [[1 0 0] 16 [4 5 0] 17 [7 8 9]] 18 [[1 2 3] 19 [0 5 6] 20 [0 0 9]]
三.数组间的操作
1.基本运算
1 a = np.array([[1, 2], 2 [4, 1]]) 3 b = np.array([[2, 2], 4 [3, 4]]) 5 print(a + b) # 对应元素相加 6 print(a - b) # 对应元素相减 7 print(a/b) # 对应元素相除 8 print(a//b) # 对应元素取整 9 print(a % b) # 对应元素相除后取余数 10 print(a * b) # 每个元素对应元素的相乘---点乘（数量积）（内积）--相当于print(np.multiply(a,b)) 11 print(a.dot(b)) # 矩阵乘法--叉乘（向量积）（外积）---相当于print(a @ b)--第一个矩阵的列数等于第二个矩阵的行数 12 print(2+a) # 标量与矩阵元素运算，+/-/*// 13 print(a < 3) # 布尔运算，每个元素的比较 14 print(b ** 2) # 每个元素的乘方 15 16 import numpy.linalg as lg # 求矩阵的逆需要先导入numpy.linalg用linalg的inv函数来求逆 17 print(lg.inv(a)) # 求逆 18 ---------------------------------------- 19 [[3 4] 20 [7 5]] 21 [[-1 0] 22 [ 1 -3]] 23 [[0.5 1. ] 24 [1.33333333 0.25 ]] 25 [[0 1] 26 [1 0]] 27 [[1 0] 28 [1 1]] 29 [[ 2 4] 30 [12 4]] 31 [[ 8 10] 32 [11 12]] 33 [[3 4] 34 [6 3]] 35 [[ True True] 36 [False True]] 37 [[ 4 4] 38 [ 9 16]] 39 [[-0.14285714 0.28571429] 40 [ 0.57142857 -0.14285714]]
2.数组堆叠
1 a1 = np.array([[1, 2], [3, 4]]) 2 a2 = np.array([[5, 6], [7, 8]]) 3 4 # 1. 水平堆叠，横向合并 5 print(np.hstack([a1,a2])) # 参数传入时要以列表list或元组tuple的形式传入 6 print(np.concatenate((a1, a2), axis=1)) # 和hstack一样，axis=1表示两个数组对应的第二维度中的元素叠加，第一维度长度不变 7 print(np.stack((a1, a2), axis=1)) # 两个数组沿新轴连接数组序列 8 9 # 2.纵向合并，垂直堆叠 10 print(np.vstack([a1,a2])) 11 print(np.concatenate((a1, a2), axis=0)) # 和vstack一样，axis=0表示两个数组对应的第一维度中的元素叠加，第二维度长度不变 12 print(np.stack((a1, a2), axis=0)) # 两个数组沿新轴连接数组序列 13 ----------------------------------- 14 [[1 2 5 6] 15 [3 4 7 8]] 16 [[1 2 5 6] 17 [3 4 7 8]] 18 [[[1 2] 19 [5 6]] 20 21 [[3 4] 22 [7 8]]] 23 [[1 2] 24 [3 4] 25 [5 6] 26 [7 8]] 27 [[1 2] 28 [3 4] 29 [5 6] 30 [7 8]] 31 [[[1 2] 32 [3 4]] 33 34 [[5 6] 35 [7 8]]]
3.数组拆分
1 a = np.arange(12).reshape(3,4) 2 print(a) 3 4 # 1.纵向分割 5 print(np.vsplit(a,3)) # 纵向分割，分割线为水平 6 print(np.split(a,3,axis=0)) # 对a进行分割成3块，以行方向进行操作，对第一维度中的元素进行分割 7 8 # 2.横向分割 9 print(np.hsplit(a,2)) 10 print(np.split(a,2,axis=1)) # 对a进行分割成2块，以列方向进行操作，对第二维度中的元素进行分割 11 12 # 注意：split分割只能进行相等的分割 13 —————————————————————————————————————————— 14 [[ 0 1 2 3] 15 [ 4 5 6 7] 16 [ 8 9 10 11]] 17 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])] 18 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])] 19 [array([[0, 1], 20 [4, 5], 21 [8, 9]]), array([[ 2, 3], 22 [ 6, 7], 23 [10, 11]])] 24 [array([[0, 1], 25 [4, 5], 26 [8, 9]]), array([[ 2, 3], 27 [ 6, 7], 28 [10, 11]])]
4.其他操作
1 a = np.array([[1,2,3],[4,5,6]]) 2 print(np.append(a, [[7,8,9]],axis=0)) # 对于第一维度添加一个元素 3 print(np.append(a, [[5,5,5],[7,8,9]],axis=1)) # 对于第二维度，添加元素 4 print(np.insert(a, 2, 11, axis=1)) # 在给定索引之前，沿给定轴在输入数组中插入值 5 print(np.insert(a,1,[11],axis = 0)) # 在第一维度中插入元素 6 print(np.delete(a,1,axis = 1)) # 在第二维度中删除第二个元素 7 8 a2 = np.array([5,2,6,2,7,5,6,8,2,9]) 9 print(np.unique(a2)) # 去重 10 ------------------------------------------------- 11 [[1 2 3] 12 [4 5 6] 13 [7 8 9]] 14 [[1 2 3 5 5 5] 15 [4 5 6 7 8 9]] 16 [[ 1 2 11 3] 17 [ 4 5 11 6]] 18 [[ 1 2 3] 19 [11 11 11] 20 [ 4 5 6]] 21 [[1 3] 22 [4 6]] 23 [2 5 6 7 8 9]
四.矩阵类matrix
1.和数组类似，继承 ndarray类，也有对应的方法和属性，但是它必须是2维的
2.一般来说，我们使用ndarray而不使用matrix
五.numpy里的random 模块
1 # 浮点数数组 2 print(np.random.rand(2, 3)) # 给定形状，生成随机0-1均匀分布的数组 3 print(np.random.randn(2,3)) # 返回一个具有标准正太分布的样本 4 print(np.random.random((3, 2)))#返回随机的浮点数，在半开区间 [0.0, 1.0) 5 #rangdom方法相当于ranf/sample/random_sample 6 7 # 整数数组 8 print(np.random.randint(low=5,high=20, size=(2, 4))) # 返回【5,20）的整数数组 9 10 #子数组 11 print(np.random.choice([5,4,5,6,2],[3,2]))#从给定的数组，生成满足形式的数组 12 print(np.random.bytes(10)) # 返回随机字节。 13 14 #排序 15 arr = np.arange(10) 16 np.random.shuffle(arr) # 修改序列，改变自身内容 17 print(arr) 18 arr2=np.random.permutation(10) # 返回一个随机排列 19 print(arr2) 20 ----------------------------- 21 [[0.95669054 0.2450761 0.4263026 ] 22 [0.56699365 0.5552199 0.15680032]] 23 [[ 0.04848332 0.99717328 -0.47334977] 24 [-0.13636914 -1.44547204 0.7402848 ]] 25 [[0.46582226 0.90037162] 26 [0.01326151 0.13804806] 27 [0.90242105 0.64924892]] 28 [[ 8 12 9 10] 29 [18 9 12 9]] 30 [[4 6] 31 [2 5] 32 [5 5]] 33 b'q: $Yxadxb9/Jxc9' 34 [0 4 9 8 6 2 5 3 7 1] 35 [0 5 1 9 4 8 3 2 7 6]
六.其他
三.