numpy模块之创建矩阵、矩阵运算

最新推荐文章于 2022-05-01 15:12:10 发布

weixin_30606669

最新推荐文章于 2022-05-01 15:12:10 发布

阅读量363

点赞数

文章标签： python 数据结构与算法 c/c++

原文链接：http://www.cnblogs.com/woaixuexi9999/p/9229357.html

版权

本文参考给妹子讲python https://zhuanlan.zhihu.com/p/34673397

NumPy是Numerical Python的简写，是高性能科学计算和数据分析的基础包，他是许多高级工具的构建基础。

他的核心功能是：

1.多维向量的描述和快速高效计算能力，让数组和矩阵的使用更加自然；
2.大量实用的数学函数，支撑复杂的线性代数、随机数生成以及傅里叶变换函数
3.具备数据的磁盘读写工具
对于同样的数值计算任务，使用NumPy要比直接编写Python代码便捷的多。
这是因为NumPy能够直接对数组和矩阵进行操作，可以省略很多循环语句，
其众多的数学函数也会让编写代码的工作轻松许多。
同时底层算法在设计时有着优异的的性能，NumPy中数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构，如嵌套list。
example1:用python对象的list来创建ndarray对象

import numpy as np  
data = [1,2.11,4,59] 
arr = np.array(data) 
print(arr) 
print(type(arr)) 

 [  1.     2.11   4.    59.  ] 
<class 'numpy.ndarray'>

当然ndarray对象也可以转换成list

import numpy as np  

arr = np.arange(8) 
L = arr.tolist() 
print(type(L)) 
print(L)  

<class 'list'> 
[0, 1, 2, 3, 4, 5, 6, 7]

example2:用嵌套列表来创建多维矩阵

import numpy as np  

data = [[1,2,3,4],[5,6,7,8.2]] 
arr = np.array(data) 
print(arr) 
print(arr.ndim) 
print(arr.shape) 
print(arr.dtype) 
print(type(arr))  

[[ 1.   2.   3.   4. ]  
[ 5.   6.   7.   8.2]] 
2 
(2, 4) 
float64 
<class 'numpy.ndarray'>
#ndim就是数组的维数，

#data.ndim = len(data.shape)

example3：对已有的ndarray数组进行数据类型的显式转换

import numpy as np  

arr1 = np.array([1,2,3,4], dtype=np.float64) 
arr2 = np.array([1,2,3,4], dtype=np.int32) 
arr3 = arr2.astype(np.float64)  
print(arr1) 
print(arr2) 
print(arr3)  

[ 1.  2.  3.  4.] 
[1 2 3 4] 
[ 1.  2.  3.  4.]
#我们看到arr2在创建ndarray数组时，显式指定了元素类型为int32，后续又通过astype进行数据类型的显式转换，创建了新的数组arr3，其数据类型为float64浮点型。

example4：创建全0、全1、没有具体值的矩阵

import numpy as np  

arr_0 = np.zeros(8)  #全0矩阵
arr_1 = np.ones((3, 8)) # 3行8列全1矩阵
arr_e = np.empty((2,3,2)) # 维度为2,3,2的矩阵
print(arr_0) 
print(arr_1) 
print(arr_e)  

[ 0.  0.  0.  0.  0.  0.  0.  0.]  

[[ 1.  1.  1.  1.  1.  1.  1.  1.]  
 [ 1.  1.  1.  1.  1.  1.  1.  1.]  
 [ 1.  1.  1.  1.  1.  1.  1.  1.]]  

[[[  2.05931344e-316   1.87072344e-316]   
  [  1.85828998e-316   1.98442969e-316]   
  [  1.85755284e-316   1.70134311e-316]]   
 [[  1.71304417e-316   2.37875336e-316]   
  [  1.84704347e-316   1.70132375e-316]   
  [  2.46176627e-316   2.34552329e-316]]]

除此之外，之前我们讲过python内置函数中有一个range函数，np中也有一个类似的函数实现该功能

import numpy as np  

arr1 = np.arange(8) 
print(arr1) 
print(type(arr1))  

[0 1 2 3 4 5 6 7] 
<class 'numpy.ndarray'>  


import numpy as np  

arr2 = np.arange(0,11,2,dtype=float) 
print(arr2)  

[  0.   2.   4.   6.   8.  10.]

还有一种网格数据的生成方法：即指定起始点和终止点（包含），以及网格点的个数

import numpy as np  

arr = np.linspace(0,80,5) 
print(arr)  

[  0.  20.  40.  60.  80.]

ndarray数据的维度转换与最简单的标量运算：

import numpy as np  

a = np.arange(24).reshape((6,4)) 
print(a)  

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

# 然后将其展平，即将其转化为一个24项的一维数组
import numpy as np  

a = np.arange(24).reshape((6,4)) 
print(a.flatten())  

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

#还有一种维度转换的使用场景，如，将之前的6×4的二维数组，转化为3×8的二维数组

import numpy as np  

a = np.arange(24).reshape((6,4)) 
a.resize((3,8)) 
print(a)  

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

#转置
import numpy as np  

a = np.arange(24).reshape((6,4)) 
print(a) 
print(a.transpose())  # 或者缩写成 a.T

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

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

数组的组合

# 首先是水平的组合

import numpy as np 
 
a = np.arange(6).reshape((2,3)) 
b = a * 2 
print(a) 
print(b) 
print(np.hstack((a,b)))  

[[0 1 2]  
 [3 4 5]]  

[[ 0  2  4]  
 [ 6  8 10]]  

[[ 0  1  2  0  2  4]  
 [ 3  4  5  6  8 10]]
# 再来看看垂直组合

import numpy as np  

a = np.arange(6).reshape((2,3)) 
b = a * 2 
print(a) 
print(b) 
print(np.vstack((a,b)))  

[[0 1 2]  
 [3 4 5]]  

[[ 0  2  4]  
 [ 6  8 10]]  

[[ 0  1  2]  
 [ 3  4  5]  
 [ 0  2  4]  
 [ 6  8 10]]

最后我们来看看数组的标量计算

其实下面介绍的数组的标量计算功能用传统的基本数组List类型肯定是都能实现的，但是NumPy提供的最主要的便利之一就是，我们可以像操作原子数据类型一样对NumPy对象进行操作：不需要显式循环就可以对它们进行加、减、乘等运算，避免了显式循环的使用，使得代码更加清晰。同时，NumPy底层是用C语言实现的，因此代码运行的也更快。

import numpy as np  

arr = np.array([[1,2,3],[4,5,6]],dtype=np.float64)  
print(arr + 1) 
print(arr ** 2) 
print(1/arr)  

[[ 2.  3.  4.]  
 [ 5.  6.  7.]]  

[[  1.   4.   9.]  
 [ 16.  25.  36.]]  

[[ 1.          0.5         0.33333333]  
 [ 0.25        0.2         0.16666667]]

# 另外还有数组与数组之间的运算，这里暂时只谈论维数相同的数组运算
import numpy as np  

arr = np.array([[1,2,3],[4,5,6]],dtype=np.float64)  
print(arr+arr) 
print(arr*arr)  

[[  2.   4.   6.]  
 [  8.  10.  12.]] 

[[  1.   4.   9.]  
 [ 16.  25.  36.]]

#对整个向量运用基本数学表达式
import numpy as np 
 
arr = np.arange(8) 
print(np.sin(arr))  

[ 0.          0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427  -0.2794155   0.6569866 ]