numpy-1.18.4

一.简介

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'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00'
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]
array

【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]]
全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]]
全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]
arange

【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: $Y\xad\xb9/J\xc9'
34 [0 4 9 8 6 2 5 3 7 1]
35 [0 5 1 9 4 8 3 2 7 6]
随机数

 

六.其他

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

三.

 

posted on 2020-05-28 15:12  温润有方  阅读(613)  评论(0编辑  收藏  举报