python3 Numpy

一.Numpy

1.主要用于科学计算，主要特色是数组--ndarry

2.优势：

（1）相比于python中的列表，numpy数组在建立时固定大小，更改ndarry的大小将建立一个新数组并删除原始数组

（2）ndarry数组中的元素都须要具备相同的数据类型,所以在内存中的大小相同

（3）ndarry数组相比于python内置序列，相应操做的执行效率更高（速度快），代码更少（内存小）

（4）numpy也是其余一些科学计算库的基础，好比scipy，pandas等

3.http://www.numpy.org/

 

二.数组（ndarry）

1.ndarry的基本属性

 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 print(a.itemsize)#数组中每一个元素的大小（以字节为单位）,32/8=4
10 print(a.data)    #包含数组实际元素的缓冲区,不经常使用
11 ----------------------------------------------------------------
12 [[ 0  1  2  3  4]
13  [ 5  6  7  8  9]
14  [10 11 12 13 14]]
15 <class 'numpy.ndarray'>
16 (3, 5)
17 15
18 2
19 int32
20 4
21 <memory at 0x0030D558>

ndarry-多维数组

2.建立数组

（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）arange函数建立数组序列（一维），相似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

（3）数组之间的基本操做

 1 import numpy as np
 2 
 3 a = np.array([[1, 1],
 4               [0, 1]])
 5 b = np.array([[2, 0],
 6               [3, 4]])
 7 print(a)
 8 print(b)
 9 print(a + b)  # 元素对应元素的加减
10 print(b ** 2)  # 每一个元素的乘方
11 print(10 * b)  # 10*每一个元素
12 print(a < 3)  # 每一个元素的比较
13 print(a * b)  # 每一个元素对应元素的相乘
14 print(a @ b)  # 矩阵相乘
15 print(a.dot(b))  # 矩阵相乘
16 print(a.sum())#全部元素的和
17 print(a.min(),a.max())#最大最小值
18 print(a.sum(axis=0))#axis=0表示对列进行操做，求每列的和
19 print(a.min(axis=1))#axis=1表示对行进行操做，求每行的最小值
20 print(a.cumsum(axis=1))#cumsum累加，对行操做
21 --------------------------------------------------------
22 [[1 1]
23  [0 1]]
24 [[2 0]
25  [3 4]]
26 [[3 1]
27  [3 5]]
28 [[ 4  0]
29  [ 9 16]]
30 [[20  0]
31  [30 40]]
32 [[ True  True]
33  [ True  True]]
34 [[2 0]
35  [0 4]]
36 [[5 4]
37  [3 4]]
38 [[5 4]
39  [3 4]]
40 3
41 0 1
42 [1 2]
43 [1 0]
44 [[1 2]
45  [0 1]]

数组操做

3.建立特殊数组（矩阵）

（1）linspace用于建立指定数量等间隔的序列，实际生成一个等差数列

1 import numpy as np
2 a=np.linspace(0,1,12)#从0开始到1结束，共12个数的等差数列
3 print(a)
4 -------------------------------------------------------------------
5 [0.         0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
6  0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1.        ]

linspace

（2）logspace用于生成等比数列

1 import numpy as np
2 a = np.logspace(0,2,5)#生成首位是10的0次方，末位是10的2次方，含5个数的等比数列
3 print(a)
4 -----------------------------------------------------------------
5 [  1.           3.16227766  10.          31.6227766  100.        ]

logspace

（3）其余特殊矩阵建立方式等

 1 import numpy as np
 2 a_ones = np.ones((3,4))# ones(N)生成一个N长度的一维全一的数组，建立3*4的全1矩阵
 3 print(a_ones)#全1矩阵
 4 
 5 a_zeros = np.zeros((3,4))#zeros(N)生成一个N长度的一维全零的数组，建立3*4的全0矩阵
 6 print(a_zeros)#全0矩阵
 7 
 8 a_eye = np.eye(3)#eye(N)建立一个N * N的单位矩阵，建立3阶单位矩阵
 9 print(a_eye)#单位矩阵,等同于np.identity( N )
10 
11 a_empty = np.empty((3,4))#empty(N)生成一个N长度的未初始化一维的数组，建立3*4的空矩阵
12 print(a_empty)#空矩阵（实际有值）
13 ----------------------------------------------------------------------------------
14 [[1. 1. 1. 1.]
15  [1. 1. 1. 1.]
16  [1. 1. 1. 1.]]
17 [[0. 0. 0. 0.]
18  [0. 0. 0. 0.]
19  [0. 0. 0. 0.]]
20 [[1. 0. 0.]
21  [0. 1. 0.]
22  [0. 0. 1.]]
23 [[0. 0. 0. 0.]
24  [0. 0. 0. 0.]
25  [0. 0. 0. 0.]]

矩阵建立

 

三.数组的索引和切片和迭代，类似于序列

 1 import numpy as np
 2 a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
 3 print(a)
 4 print(a[:])#选取所有元素
 5 print(a[1])#选取行为1的所有元素
 6 print(a[0:1]) #截取[0,1)的元素
 7 print(a[1,2:5]) #截取第二行第[2,5）的元素[ 8  9 10]
 8 print(a[1,:]) #截取第二行,返回 [ 6  7  8  9 10]
 9 print(a[1,2])#截取行号为一，列号为2的元素8
10 print(a[1][2])#截取行号为一，列号为2的元素8,与上面的等价
11 #与序列索引切片类似，冒号从哪到哪，逗号分隔行列
12 
13 #按条件截取
14 print(a[a>6])# 截取矩阵a中大于6的数，范围的是一维数组
15 print(a>6)#比较a中每一个数和6的大小，输出值False或True
16 
17 a[a>6] = 0#把矩阵a中大于6的数变成0，
18 print(a)
19 --------------------------------------------------------------
20 [[ 1  2  3  4  5]
21  [ 6  7  8  9 10]]
22 [[ 1  2  3  4  5]
23  [ 6  7  8  9 10]]
24 [ 6  7  8  9 10]
25 [[1 2 3 4 5]]
26 [ 8  9 10]
27 [ 6  7  8  9 10]
28 8
29 8
30 [ 7  8  9 10]
31 [[False False False False False]
32  [False  True  True  True  True]]

索引和切片

 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 ******************************

迭代

 

四.数组的基本方法

1.改变数组形状

 1 a = np.floor(10*np.random.random((3,4)))
 2 print(a)
 3 #1.改变数组形状,返回已修改的数组，但不更改原始数组
 4 print(a.ravel())#返回全部元素的一维数组，从左到右，从上到下
 5 print(a.reshape(6, 2))#reshape方法改变数组的形状
 6 print(a.T)#转置
 7 print(a)
 8 print('#'*30)
 9 #2.resize方法修改数组自己
10 a.resize((2,6))
11 print(a)
12 a.reshape(3,-1)#尺寸指定为-1，则会自动计算其余尺寸
13 print(a)
14 ------------------------------------------------
15 [[3. 2. 2. 7.]
16  [0. 8. 0. 9.]
17  [7. 8. 2. 2.]]
18 [3. 2. 2. 7. 0. 8. 0. 9. 7. 8. 2. 2.]
19 [[3. 2.]
20  [2. 7.]
21  [0. 8.]
22  [0. 9.]
23  [7. 8.]
24  [2. 2.]]
25 [[3. 0. 7.]
26  [2. 8. 8.]
27  [2. 0. 2.]
28  [7. 9. 2.]]
29 [[3. 2. 2. 7.]
30  [0. 8. 0. 9.]
31  [7. 8. 2. 2.]]
32 ##############################
33 [[3. 2. 2. 7. 0. 8.]
34  [0. 9. 7. 8. 2. 2.]]
35 [[3. 2. 2. 7. 0. 8.]
36  [0. 9. 7. 8. 2. 2.]]

改变形状

2.数组的堆叠

 1 import numpy as np
 2 a1 = np.array([[1,2],[3,4]])
 3 a2 = np.array([[5,6],[7,8]])
 4 
 5 #!注意 参数传入时要以列表list或元组tuple的形式传入
 6 print(np.hstack([a1,a2]))
 7 #横向合并，np.concatenate( (a1,a2), axis=1)等价于np.hstack( (a1,a2) ) 
 8 
 9 print(np.vstack((a1,a2)))
10 #纵向合并，np.concatenate( (a1,a2), axis=0)等价于np.vstack( (a1,a2) )
11 ----------------------------------------------------
12 [[1 2 5 6]
13  [3 4 7 8]]
14 [[1 2]
15  [3 4]
16  [5 6]
17  [7 8]]

数组堆叠

3.数组拆分

 1 import numpy as np
 2 a=np.arange(12).reshape(3,4)
 3 print(a)
 4 
 5 print(np.split(a,2,axis=1))#对a进行分割成2块，以列方向进行操做
 6 print(np.split(a,3,axis=0))#对a进行分割成3块，以行方向进行操做
 7 # print(np.split(a,2,axis=0))array split does not result in an equal division
 8 #split分割只能进行相等的分割
 9 
10 print(np.array_split(a,2,axis=0))
11 #array_split进行不等分割
12 
13 print(np.vsplit(a,3))#纵向分割
14 print(np.hsplit(a,3))#横向分割
15 ----------------------------------------------------------
16 [[ 0  1  2  3]
17  [ 4  5  6  7]
18  [ 8  9 10 11]]
19 [array([[0, 1],
20        [4, 5],
21        [8, 9]]),
22  array([[ 2,  3],
23        [ 6,  7],
24        [10, 11]])]
25 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
26 [array([[0, 1, 2, 3], [4, 5, 6, 7]]), 
27   array([[ 8,  9, 10, 11]])]
28 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

数组分割

4.数组的拷贝

 1 a = np.arange(12)
 2 #赋值,改变a则至关于改变b
 3 b = a
 4 print(id(a)==id(b))
 5 print(b is a )
 6 print(b.base is a)
 7 print('#'*30)
 8 
 9 #浅拷贝：拷贝父对象，不会拷贝对象的内部的子对象,不一样的数组对象共享相同的数据，即底部数据相同
10 c = a.view()#view方法建立一个查看相同数据的新数组对象
11 print(id(a)==id(c))
12 print(c is a )
13 print(c.base is a)
14 print('#'*30)
15 
16 #深拷贝：copy方法生成数组及其数据的完整副本，彻底拷贝了父对象及其子对象
17 d = a.copy()
18 print(id(a)==id(d))
19 print(d is a )
20 print(d.base is a)
21 a = np.arange(12).reshape(3,4)
22 print(a)
23 --------------------------------------------
24 True
25 True
26 False
27 ##############################
28 False
29 False
30 True
31 ##############################
32 False
33 False
34 False
35 [[ 0  1  2  3]
36  [ 4  5  6  7]
37  [ 8  9 10 11]]

拷贝

 

五.矩阵matrix

1.矩阵和数据相似

2.matrix矩阵类 继承 ndarray类

3.产生一个矩阵类

 1 x = np.array([[1, 2], [3, 4]])
 2 m1 = np.mat(x)#若是x是矩阵或数组，则m1和x指向同一个对象，=asmatrix
 3 m2=  np.matrix(x)#建立一个全新的对象
 4 x[0,0] = 5
 5 print(m1)
 6 print(m2)
 7 print(type(m1))
 8 ----------------------------------------------
 9 [[5 2]
10  [3 4]]
11 [[1 2]
12  [3 4]]
13 <class 'numpy.matrixlib.defmatrix.matrix'>

矩阵matrix

4.矩阵相关操做

 1 import numpy as np
 2 a = np.matrix([[1,2,3],[4,5,6]])
 3 print(a)
 4 print(a.T)#转置
 5 print(a.getI())#a的逆
 6 print(a.max()) #获取整个矩阵的最大值 结果： 6
 7 print(a.min()) #结果：1
 8 print(a.max(axis=0))#得到每列的最大（小）值
 9 print(a.max(axis=1))#得到每行的最大（小）值
10 print(a.argmax(axis=1))# 要想得到最大最小值元素所在的位置，能够经过argmax函数来得到
11 print(a.mean())#元素的平均值
12 print(a.mean(axis=0))#每列平均值
13 print(a.mean(axis=1))#每行平均值
14 print(a.var())#方差至关于函数mean(abs(x - x.mean())**2)
15 print(a.std())#标准差至关于sqrt(mean(abs(x - x.mean())**2))
16 print(a.sum())# 对整个矩阵求和
17 print(a.cumsum())#对整个矩阵求累积和,某位置累积和指的是该位置以前(包括该位置)全部元素的和
18 print(a.tolist())#把矩阵变成一维的
19 ---------------------------------------------------------------
20 [[1 2 3]
21  [4 5 6]]
22 [[1 4]
23  [2 5]
24  [3 6]]
25 [[-0.94444444  0.44444444]
26  [-0.11111111  0.11111111]
27  [ 0.72222222 -0.22222222]]
28 6
29 1
30 [[4 5 6]]
31 [[3]
32  [6]]
33 [[2]
34  [2]]
35 3.5
36 [[2.5 3.5 4.5]]
37 [[2.]
38  [5.]]
39 2.9166666666666665
40 1.707825127659933
41 21
42 [[ 1  3  6 10 15 21]]
43 [[1, 2, 3], [4, 5, 6]]

矩阵操做

 

六.numpy里的random 模块

 

 1 import numpy as np
 2 # 浮点数数组
 3 print(np.random.rand(2, 3))#给定形状，生成随机0-1的数组
 4 print(np.random.randn(2,3))#返回一个具备标准正太分布的样本
 5 print(np.random.random((3, 2)))#返回随机的浮点数，在半开区间 [0.0, 1.0)
 6 #rangdom方法至关于ranf/sample/random_sample
 7 
 8 #整数数组
 9 print(np.random.randint(5, size=(2, 4)))#返回【0,5）的整数数组
10 print(np.random.random_integers(5, size=(3, 2)))#返回随机的整数，位于闭区间 [0,5]
11 
12 #子数组
13 print(np.random.choice([5,4,5,6,2],[3,2]))#从给定的数组，生成知足形式的数组
14 
15 print(np.random.bytes(10))#返回随机字节。
16 
17 #排序
18 arr = np.arange(10)
19 np.random.shuffle(arr)#修改序列，改变自身内容
20 print(arr)
21 arr2=np.random.permutation(10)#    返回一个随机排列
22 print(arr2)
23 ---------------------------------------------
24 [[0.56087409 0.24298699 0.198769  ]
25  [0.16400281 0.03769762 0.6634636 ]]
26 [[ 0.91762298 -0.93118239  0.09195282]
27  [ 1.18961487 -0.37537299 -1.34785821]]
28 [[0.40749711 0.76773468]
29  [0.30788695 0.7469718 ]
30  [0.14610159 0.40701196]]
31 [[1 4 1 2]
32  [3 3 4 3]]
33 [[4 4]
34  [1 4]
35  [1 5]]
36 [[2 5]
37  [5 5]
38  [5 5]]
39 b'\xbfu\xa5R\xb5c\xbf\x85\x99l'
40 [5 7 9 2 3 8 1 4 0 6]
41 [7 0 4 9 3 2 1 5 6 8]

numpy的random模块

 

七.其余

线性代数linalg；测试支持testing；离散傅里叶变化fft；数学函数emath等