python——numpy库操作，快速入门笔记(全)_python的numpy学习笔记

第二章numpy

2.1——numpy介绍

相比列表来说，具有更高效的数据运算方式，主要就是产生一个numpy数组，对着个numpy数组进行一系列的操作

2.1.1——numpy基础定义

• numpy提供了一个n维数组类型ndarray，它描述了相同类型的“items”的集合

产生一个numpy数组，用np.array()

import numpy as np
score=np.array([[80,89,93],[99,100,97],[100,91,89]])
print(score)
1
2
3

>>>

[[ 80 89 93]

[ 99 100 97]

[100 91 89]]

2.1.2.numpy创建方式：

• ANumpy.array(列表嵌套，dtype=”数据类型”)

score=np.array([[80,89,93],[99,100,97],[100,91,89]])
1

2.2——Numpy的数学运算/基础使用

2.2.1——数据运算

数据相加（直接将numpy数组相加）

import numpy as np
a=np.array([1,2,3,4])
b=np.array([2,5,7,9])
print(a+b)
1
2
3
4

>>> [ 3 ,7, 10, 13]

数据相乘（直接将numpy数组相乘，对应位置相乘）

import numpy as np
l=np.array([0,1,2,3])
m=np.array([1,5,6,7])
print(l*m)
1
2
3
4

>>>[0,5,12,21]

2.2.2——产生数组/数组中的操作

1. 从列表产生数组

l=[0,1,2,3]

a=np.array(l)

print(a)
1
2
3
4
5

>>>[0 1 2 3]

2. 从列表传入

a=np.array([1,2,3,4])

print(a)
1
2
3

>>>[0,1,2,3]

3. 生成全0的数组：（np.zeros(n)）

np.zeros(5)

>>>[0. 0. 0. 0. 0.]#这里全都是以浮点数形式呈现
1
2
3

4 .生成全是1的数组：(np.ones())

import numpy as np

#dtype参数可以用来设置数据类型

a=np.ones(5,dtype='bool')

print(a)
1
2
3
4
5
6
7

>>>[ True True True True True]

5. 使用fill方法将数组设为指定值（np.fill(指定数字)）

import numpy as np

#dtype参数可以用来设置数据类型

a=np.ones(5,dtype='bool');

a.fill(False)

b=np.ones(5,dtype='int')

b.fill(8)

print(f'{a}\n{b}')

>>>

[False False False False False]

[8 8 8 8 8]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• Fill中写的数据必须与上面列表中的数据类型一致

若不一致：如下

b=np.ones(5,dtype='int') 			
b.fill(2.5) 			
print(f'{a}\n{b}') 	
1
2
3

>>>[2 2 2 2 2] 自动取整

6. 强制转换数组数据类型:

a=a.astype(‘float’) 			
a.fii(a) 		
print(a)
1
2
3

>>> [2.5 2.5 2.5 2.5 2.5] 这样就不会取整了

7. 生成整数数列：

Np.arange(min，max，步长)

import numpy as np						
a=np.arange(1,10,2)#左闭右开，第三个参数是步长			
print(f'{a}\n')
1
2
3

>>> [1 3 5 7 9]

8. 生成等差数列：

np.linspace()

• 第一个参数：起始值；

• 第二个参数：末尾值；

• 第三个参数：数列元素总数

• 该数列为左闭右闭的

import numpy as np						
a=np.linspace(2,10,5)#左闭右开，第三个参数是步长			
print(f'{a}\n')
1
2
3

>>> [ 2. 4. 6. 8. 10.] (default as float)

9. 生成随机数：

np.rand(begin，stop，step)

import numpy as np					
a=np.random.rand(10)#左闭右开，第三个参数是步长		
print(f'{a}\n') 	
1
2
3

>>> [0.91932804 0.09148843 0.33195572 0.53666308 0.84589437
0.03116192

0.59439441 0.71651447 0.23198908 0.40219744]

生成0到1之间的10个浮点数——np.randn()

import numpy as np 					
a=np.random.randn(10)#左闭右开，第三个参数是步长 				
print(f'{a}\n') 
1
2
3

>>>

[ 2.36241182 -1.94827648 -0.38120604 2.1457075 -0.47019724 1.10687691

0.38223196 1.01900408 0.95301641 -0.48533215]

生成0到1的十个随机浮点数，但是是按照正态分布的——np.randint()

import numpy as np 			
a=np.random.randint(1,10,10)#左闭右开，第三个参数是随机数个数
print(f'{a}\n')
1
2
3

>>> [2 1 7 1 8 8 7 2 4 9]

10. numpy生成随机矩阵

①数值在0-1之间

np.random.randome(m,n) #生成一个m*n的矩阵
1

②数值为整数

np.random.randint(min,max,size=(m,n))
1

生成一个数值在min~max之间的m*n的矩阵，max是取不到的，min可以取到

2.3——数组属性

2.3.1——查看数组类型

import numpy as np 			
a=np.array([8,22,3,1]) 			
print(type(a)) 	
1
2
3

>>> <class ‘numpy.ndarray’>

2.3.2——查看数组中的数据类型

import numpy as np
a=np.array([8,22,3,1])
print(a.dtype)
1
2
3

>>> int32

2.3.3——查看数组形状

① a.shape 查看形状，会返回一个元组

import numpy as np
a=np.array([[8,22,3,1],[3,1,2,9]])
print(a.shape)
1
2
3

>>> (2, 4) 两行四列

② np.size(a) 查看a数组中的元素个数

import numpy as np
a=np.array([[8,22,3,1],[3,1,2,9],[5,6,7,8]])
print(np.size(a))
1
2
3

>>> 12

③ a.ndim 查看数组维度

import numpy as np
a=np.array([[8,22,3,1],[3,1,2,9],[5,6,7,8]])
print(a.ndim)
1
2
3

>>>2

2.4——索引与切片

2.4.1——常规索引

• 与python列表的索引用法一致

• 每一维度都支持切片的规则，注意这个切片操作是从一维上去进行的，如果是多维，那么每个维度之间用逗号隔开，且每个维度都是如下的切片操作，步长可以省略，默认为1

[lower：upper：step]

2.4.2——多维数组索引

A[行索引，列索引]

• 可以使用单个索引来索引一整行内容

A[0,3:5]  #得到第一行的第四和第五两个元素
1

• 得到第三列：（行索引不填，即为要得到一整列的内容）

本质：行索引为[不填：不填]所以行索引和列索引之间要加一个逗号。a[:,2]

2.4.3——切片的引用机制

2.4.3.1——切片引用机制

• Numpy数组的切片引用机制，用一个变量以切片取出另一个numpy数组变量中的值，则用改变前者的同时也会改变后者

import numpy as np
a=np.array([0,1,2,3,4])
b=a[2:4]
print(b)
b[0]=10
print(a)
1
2
3
4
5
6

• 引用机制意味着，python并没有为b分配新的空间来储存它的值，而是让b指向了a所分配的内存空间，因此，改变b会改变a的值。

• b指向[2,3]，所以后期改变的也是这个位置

2.4.3.2——如何避免切片机制

• 使用copy方法这样改变b的同时不会改变a

import numpy as np
a=np.array([0,1,2,3,4])
b=a[2:4].copy()
print(b)
b[0]=10
print(a)
1
2
3
4
5
6

>>>[2 3]

[0 1 2 3 4]

2.4.4——花式索引

2.4.4.1——花式索引需要指定索引位置

import numpy as np
a=np.array([0,1,2,3,4])
index=[0,3]//第一行的第4列
print(a[index])
1
2
3
4

>>>[0 3]

2.4.4.2——使用布尔数组来花式索引：

mask=np.array([0,1,1,0,2],dtype='bool')
print(mask)
1
2

Mask必须是布尔数组，长度必须和数组长度相等。

​ print(a[mask])

>>>[1 2 4] 布尔花式索引与上面的数组对应，取出为True的元素

2.4.4.3——二维花式索引

• 需要给定行和列的值，索引分别用括号包含每一维度的位置，中间用逗号隔开

1. 返回对角线数据

import numpy as np
b=np.random.rand(5,5)
print(b[(0,1,2,3,4),(0,1,2,3,4)])
1
2
3

>>>[0.33667912 0.57474909 0.15822414 0.58057992 0.04927936]

可见取出了对角线的数据

2. 返回最后三行的第1，3，5列

import numpy as np
b=np.random.rand(5,5)
print(b)
print(f'取出数据为：\n{b[3:,[0,2,4]]}')
1
2
3
4

>>>

[[0.24637232 0.02090892 0.47057795 0.17539054 0.68465151]

[0.77696115 0.22541052 0.96777386 0.61846717 0.85367903]

[0.38041631 0.97900975 0.93722615 0.59153615 0.39870354]

[0.43944809 0.61795432 0.99711014 0.16310237 0.67411796]

[0.63311709 0.8688676 0.94573147 0.41703868 0.23195399]]

取出数据为：

[[0.43944809 0.99711014 0.67411796]

[0.63311709 0.94573147 0.23195399]]

外面[]，[]里面()或者[]都可以，不会报错

2.4.4.4——不完全索引

• 只给定行索引的时候，返回整行：

import numpy as np
b=np.random.rand(5,5)
print(b)
print(f'取出第四行到最后一行数据为：\n{b[3:]}')
1
2
3
4

>>>取出第四行到最后一行数据为：

[[0.78723266 0.2606867 0.31336913 0.43824877 0.23370714]

[0.26809932 0.37805853 0.87038233 0.8518646 0.55466361]]

2.5——Where 语句

1. 查找符合条件的数组中的元素的
2. Where(array)

Where函数会返回所有非零元素的索引

2.5.1——判断数组中元素的大小与否

a=np.random.randint(1,5,5)
print(a)
b=np.where(a>3)
print(b)
1
2
3
4

>>>[2 4 1 4 4]

(array([1, 3, 4], dtype=int64),)

• Where返回的是一个元组，返回的是索引位置，索引[1,3,4]大于3的数

2.6——数组类型

2.6.1——基本数组类型

2.6.2——类型转换

2.6.2.1——使用dtype

a=np.array([1，5，-3]，dtype=float)
1

2.6.2.2——使用asarray函数

• 具有赋值功能

a=np.array([1,2,3])
np.asarray(a,dtype=float)
1
2

>>>array([1.，2.，3.])

2.6.2.3——使用astype函数

• Astype方法会返回一个新数组，所以并不会改变a的值，意思就是不具备赋值功能

a=np.array([1,2,3])
a.astype(float)
#>>>array([1.，2.，3.])
1
2
3

2.7——数组操作

2.7.1——数组排序

• sort函数，默认按照从小到大顺序排列，返回数组排序的副本

b=[956,456,789]
b=np.sort(b)
print(b)
1
2
3

>>>[456 789 956]

补充

• 按行排列：np.sort(b，axis=1) 返回的每行数组中元素都已经从小到大排序过了

2.7.2——argsort函数

1. 返回从小到大排列在数组中索引的位置

b=[956,456,789]
b=np.argsort(b)
print(b)
1
2
3

>>>[1 2 0]

补充

• argsort函数使得numpy数组按照行排列或列排序

Np.argsort(数组[行索引,列索引])

举例：

• 按第一行排列：

Np.argsort(b[0，：])
1

• 按第一列排列：

Np.argsort(b[：，0])
1

2.7.3——求和

np.sum(数组名)

b=[956,456,789]
b=np.sum(b)
print(f'结果是{b}')
1
2
3

>>>结果是2201

2.7.4——最大值

np.max(数组名)

b=[956,456,789]
b=np.max(b)
print(f'结果是{b}')
1
2
3

>>>结果是956

2.7.5——最小值

2.7.6——均值

np.mean()

b=[956,456,789]
b=np.mean(b)
print(f'结果是{b}')
1
2
3

>>>结果是733.6666666666666

还可以写成 b.mean()

2.7.7——标准差

np.std()

b=[956,456,789]
b=np.std(b)
print(f'结果是{b}')
1
2
3

>>>结果是207.84021640566957

2.7.8——相关系数矩阵

a=np.array([546,888,777])
b=np.array([956,456,789])
corr_coef=np.corrcoef(a,b)
print(f'相关系数矩阵是：\n{corr_coef}')
1
2
3
4

>>>相关系数矩阵是：

[[ 1. -0.92519115]

[-0.92519115 1. ]]

Cov是协方差

2.7.9——shape方法

2.7.9.1——shape

import numpy as np
a=np.arange(6)//默认步长为1
print(a)
a.shape=2,3
print(a)
1
2
3
4
5

>>>[0 1 2 3 4 5]

[[0 1 2]

[3 4 5]]

• 与之对应的是reshape，但他不会修改原来数组的值，而是返回一个新的数组
• Shape可以用来转置矩阵

2.7.9.2——reshape()

np.reshape(m，n)

• 将数组转换成m行n列

eg: a.reshape

reshape(m，-1)
1

将数组转换成m行的形式，加上-1意思为，列由计算机自行计算

• 注意，不仅仅是二维的，n维的都可以。

2.7.10——转置矩阵

a.T
a.transpose()
1
2

• 这两种方法都可以用来转置矩阵，但是都不具备赋值的功能，而是返回一个新的数组

2.7.11——数组连接

• 将不同的数组按照一定的顺序连接起来

2.7.11.1——concatenate

Concatenate(（a0，a1,…aN），axis=0)

• 0是按行拼接，1是按列拼接，默认为0

import numpy as np
a=np.arange(6)
a.shape=2,3
b=np.array([[2,5,7],[5,8,9]])
z=np.concatenate((a,b),axis=0)
print(f'a为\n{a}\nb为\n{b}\n拼接后的矩阵为{z}\n')
1
2
3
4
5
6

>>>

a为

[[0 1 2]

[3 4 5]]

b为

[[2 5 7]

[5 8 9]]

拼接后的矩阵为[[0 1 2]

[3 4 5]

[2 5 7]

[5 8 9]]

2.7.11.2——其他拼接函数

1. vstack 纵向拼接
2. hstack 横向拼接
3. datack 三维拼接

2.8——numpy内置函数

2.9 numpy矩阵操作

2.9.1 两个数组的矩阵乘积，matmul（）函数。

np.matmul(arr1，arr2)
1