【python VS vba】(7) 在python使用numpy库

NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。
NumPy 的前身为 Numeric ，最早由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。 [1]
一个用python实现的科学计算，包括：

一个强大的N维数组对象Array；
比较成熟的（广播）函数库；
用于整合C/C++和Fortran代码的工具包；
实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。

NumPy provides an N-dimensional array type, the ndarray, which describes a collection of “items” of the same type.
NumPy提供了一个N维数组类型ndarray，它描述了相同类型的“items”的集合。
np.array 只能是数字中创建数组(ndarray 都是数值型的)
ndarray到底跟原生python列表的区别：

从图中我们可以看出ndarray在存储数据的时候，数据与数据的地址都是连续的，这样就给使得批量操作数组元素时速度更快。
这是因为ndarray中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以ndarray在存储元素时内存可以连续，而python原生list就只能通过寻址方式找到下一个元素，这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list，但在科学计算中，Numpy的ndarray就可以省掉很多循环语句，代码使用方面比Python原生list简单的多。
numpy内置了并行运算功能，当系统有多个核心时，做某种计算时，numpy会自动做并行计算。
Numpy底层使用C语言编写，数组中直接存储对象，而不是存储对象指针，所以其运算效率远高于纯Python代码。
下图也来自baidu百科

2? numpy里创建数组的各种方法

2.0 总结

方法1，使用 np.array()? 手动创建一维向量，或2维向量，或多维向量
方法2，使用 np.matrix() 手动创建2维向量，或多维向量（默认至少是2维向量）
方法3，使用np.arange()
方法3，使用np.linspace()
方法3，使用np.random

2.1 方法1，使用np.array()手动创建

2.1.1使用np.array()创建ndarray 数组/向量

np.array() 生成类型，ndarray()

2.1.2 可以使用reshape()转换

可以转1维数组：reshape()只有1个参数表示只有1行，数字是列数？
例子里是[1 1 2 2]这样一个1维数组
转2维数组，reshaple(行数,列数)

纯手动方法1：np.array()

M1=np.array([[1,1],[2,2]])
print(f"M1:\n{M1}")

转1维数组

reshape()只有1个参数表示只有1行，数字是列数. 只有1个参数默认就是1行的数组
print(f"M1.reshape(4)\n{M1.reshape(4)}")

#转2维数组,? reshaple(行数,列数)

print(f"M1.reshape(1,4)\n{M1.reshape(1,4)}")
print(f"M1.reshape(4,1)\n{M1.reshape(4,1)}")

2.2 方法2，用np.matrix()手动创建，

使用 np.matrix() 创建

使用reshape()转换? ? ?

matrix只能转二维，即使这样，也不能转1维数组，还是一个1行数据的二维数组
例子里是 [[1 1 2 2]]这样一个2维数组
转2维数组，reshaple(行数,列数)

纯手动方法2：np.matrix() ? ? ? ? ?
N1=np.matrix([[1,1],[2,2]])
print(f"N1:\n{N1}")

matrix只能转二维，即使这样，也不能转1维数组，还是一个1行数据的二维数组
#reshape()只有1个参数表示只有1行，数字是列数？
print(f"N1.reshape(4):\n{N1.reshape(4)}")

转2维数组,行数：列数
print(f"N1.reshape(1,4):\n{N1.reshape(1,4)}")
print(f"N1.reshape(4,1):\n{N1.reshape(4,1)}")
print()
?

2.3? 方法3：np.linspace()? #核心是按个数生成，(终点-起点)/个数均匀生成

语法：np.linspace(起点,终点,个数,endpoint=False)

核心按个数生成
按线性分隔，按?(终点-起点)/个数均匀生成多个数
如果只2个参数，缺省参数默认会被认为是个数50，前面的默认为上下限，可以逆序排列
np.linspace(10)? ? ? #错误的，至少2个参数?
np.linspace(1,10)? ?#起点，终点，个数=50
np.linspace(1,10,50)

#方法3：np.linspace() ?#核心按个数生成，按线性分隔，均匀生成多个数
A1=np.linspace(1,10,10,endpoint=False)
print(f"A1:\n{A1}")

#只2个参数，缺省参数默认会被认为是个数50，前面的默认为上下限，可以逆序排列
A2=np.linspace(10,10)
print(f"A2:\n{A2}")
print()

2.4 方法4：np.arange()? #核心是按步长生成，(终点-起点)按步长逐个生成

2.4.1 语法 np.arange([start, ]stop, [step, ]dtype=None)

start:起点值；可忽略不写，默认从0开始
stop:终点值；生成的元素不包括结束值
step:步长；可忽略不写，默认步长为1
dtype:默认为None，设置显示元素的数据类型
例子np.arange(1,10,1)
例子np.arange(10)

2.4.2 生成方法

np.arange() #核心按步长生成，
(终点-起点)按步长逐个生成
步长可以省略，默认是1
步长也可以修改为小数
起点可以省略，默认是0开始
如果1个参数，默认就是终点,? 认为起点=0
如果2个参数，默认就是起点和终点，step=1

#方法4：np.arange() #核心按步长生成，
#步长可以省略，默认是1？步长也可以修改为小数
#起点可以省略，默认是0开始
B1=np.arange(5)
B2=np.arange(1,5)
B3=np.arange(1,5,0.5)
print(f"B1\n{B1}")
print(f"B2\n{B2}")
print(f"B3\n{B3}")
print()
?

2.5 对比?python原生的 range() 只能生成python的数组list=[]

2.5.1 语法 range(起点，终点，step)

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5）等价于 range(0, 5, 1)

2.5.2 用法

np.arange()<class 'numpy.ndarray'>
range()的类型是 <class 'range'>
python里，range()可以帮助生成数组，但本身并不是数组，向量！

虽然range()并不是数组，但是

python里，list(range()) 这样嵌套就可以生成数组！
还可以使用遍历range()内容
还可以使用λ简短形式，形成数组

#方法4.1：np.arange() 比较python原生的range()
#range()只适合整数

# np.arange()<class 'numpy.ndarray'>
# range()的类型是 <class 'range'>
print(type(np.arange(0,5)))
print(type(range(0,5)))

#python里，range()可以帮助生成数组，但本身并不是数组，向量！
D1=range(0,5)
print(f"D1:{D1}")
print(f"range(0,5):{range(0,5)}")

#python里，list(range()) 这样嵌套就可以生成数组！
D2=range(0,10,3)
list(D2)
print(f"list(D2):{list(D2)}")

#还可以使用遍历range()内容
for i in range(0,5,2):
? ? print(i,end=",")

#还可以使用λ简短形式
print()
D3=[i for i in range(0,5)]
print(f"D3:{D3}")

2.6 方法5：使用np.random 生成

2.6.0 多种方法

np.random.rand()
np.random.randn()
np.random.randint(low，high，size，dtype)
np.random.uniform(low，high，size)

2.6.1 np.random.uniform(low=-1, high=0, size=(2, 2))

np.random.uniform(low，high，size)

np.random.uniform(low=-1, high=0, size=(2, 2))
如果不写第3个数字，生成的元素范围，就是默认是生成1个数
每个数都是从 [low, high] 范围内生成

2.6.2 np.random.rand()/np.random.random()

np.random.rand()/np.random.random()
np.random.rand() 默认只生成 [0,1）之间的随机数
np.random.rand()? ? ? ? ?#默认生成1个数
np.random.rand(2)? ? ? ?#生成2个数
np.random.rand(2,3)? ? #生成(2,3) 这个shape数组形态的?个数

2.6.3 np.random.randn()

该函数和rand()函数比较类似
只不过运用该函数之后返回的结果是服从均值为0，方差为1的标准正态分布，而不是局限在0-1之间，也可以为负值，因为标准正态分布的曲线是关于x轴对阵的。

2.6.4 np.random.randint(low，high，size，dtype)? ?整数

low：生成的元素值的最小值，即下限，如果没有指定high这个参数，则low为生成的元素值的最大值。
high：生成的元素值的最大值，即上限。
size：指定生成元素值的形状，也就是数组维度的大小。
dtype：指定生成的元素值的类型，如果不指定，默认为整数型
返回结果：返回值是一个大小为size的数组，如果指定了low和high这两个参数，那么生成的元素值的范围为[low,high)，不包括high；如果不指定high这个参数，则生成的元素值的范围为[0,low)。如果不指定size这个参数，那么生成的元素值的个数只有一个。

2.7 和这里没关系，正态分布? np.random.normal()

np.random.normal(loc=0.0, scale=1.0, size=None)

2.8 代码测试

import numpy as np

#手动生成numpy的数组，矩阵/向量组

#纯手动方法1：np.array()
M1=np.array([[1,1],[2,2]])
print(f"M1:\n{M1}")
#转1维数组
#reshape()只有1个参数表示只有1行，数字是列数？
print(f"M1.reshape(4)\n{M1.reshape(4)}")
#转2维数组,行数：列数
print(f"M1.reshape(1,4)\n{M1.reshape(1,4)}")
print(f"M1.reshape(4,1)\n{M1.reshape(4,1)}")
print()        
            
#纯手动方法2：np.matrix()          
N1=np.matrix([[1,1],[2,2]])
print(f"N1:\n{N1}")
#matrix只能转二维，即使这样，也不能转1维数组，还是一个1行数据的二维数组
#reshape()只有1个参数表示只有1行，数字是列数？
print(f"N1.reshape(4):\n{N1.reshape(4)}")
#转2维数组,行数：列数
print(f"N1.reshape(1,4):\n{N1.reshape(1,4)}")
print(f"N1.reshape(4,1):\n{N1.reshape(4,1)}")
print()


#方法3：np.linspace()  #核心按个数生成，按线性分隔，均匀生成多个数
A1=np.linspace(1,10,10,endpoint=False)
print(f"A1:\n{A1}")

#只2个参数，缺省参数默认会被认为是个数50，前面的默认为上下限，可以逆序排列
A2=np.linspace(10,10)
print(f"A2:\n{A2}")
print()


#方法4：np.arange() #核心按步长生成，
#步长可以省略，默认是1？步长也可以修改为小数
#起点可以省略，默认是0开始
B1=np.arange(5)
B2=np.arange(1,5)
B3=np.arange(1,5,0.5)
print(f"B1\n{B1}")
print(f"B2\n{B2}")
print(f"B3\n{B3}")
print()


#方法4.1：np.arange() 比较python原生的range()
#range()只适合整数

# np.arange()<class 'numpy.ndarray'>
# range()的类型是 <class 'range'>
print(type(np.arange(0,5)))
print(type(range(0,5)))

#python里，range()可以帮助生成数组，但本身并不是数组，向量！
D1=range(0,5)
print(f"D1:{D1}")
print(f"range(0,5):{range(0,5)}")

#python里，list(range()) 这样嵌套就可以生成数组！
D2=range(0,10,3)
list(D2)
print(f"list(D2):{list(D2)}")

#还可以使用遍历range()内容
for i in range(0,5,2):
    print(i,end=",")

#还可以使用λ简短形式
print()
D3=[i for i in range(0,5)]
print(f"D3:{D3}")



print()
#方法5：np.random.random()
C1=np.random.random(5)
C2=np.random.random(5)
print(f"C1\n{C1}")
print(f"C2\n{C2}")
print()

3? numpy里的两种新数据类型：ndarray 和?matrix

从图中我们可以看出ndarray在存储数据的时候，数据与数据的地址都是连续的，这样就给使得批量操作数组元素时速度更快。
这是因为ndarray中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以ndarray在存储元素时内存可以连续，而python原生list就只能通过寻址方式找到下一个元素，这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list，但在科学计算中，Numpy的ndarray就可以省掉很多循环语句，代码使用方面比Python原生list简单的多。

3.1 numpy特殊的数据类型

3.1.1 python的数据类型

list=[]
tupe=()
dict={}

3.1.2 首先 python原生的list 和 tuple?

就不是matrix
因此就没有.shape属性， .shape? .ndim? .size? .dtype? .itemsize 这些属性都没有
也不能被? reshape() 方法修改

3.1.3 numpy的数据类型

ndarray，是用np.array() 创建的数据类型，存储的内容数据类型都相同
matrix，是用np.matrix() 创建的数据类型
这两种数据类型都是用来保存，矩阵/向量组的
写入例如? ?
A=np.array([[1,2,3],[4,5,6]])
注意矩阵里，多套[] 的嵌套

3.2 np.matrix() 或者 np.mat()

3.2.1 首先，两种写法相同

首先np.matrix()=np.mat()

3.2.2?np.matrix的特点

np.matrix 显然就是指矩阵，或向量组
np.matrix 甚至还可以是三维的，比如 np.mat([[1,2,3],[1,2,3]],[[1,2,3],[1,2,3]])
np.matrix 可以从字符串数据 / 或数字中创建矩阵
np.matrix() 无论是从字符串内容创建的，还是从数字创建的，没有区别
对比下，np.array 只能是数字中创建数组(ndarray 都是数值型的)

3.2.3?np.matrix的属性

np.matrix().shape? ? ? ? #n行m列，
np.matrix().ndim? ? ? ? ? #维度数，比如(2,3) 是2维的
np.matrix().size? ? ? ? ? ?#矩阵的元素个数=n*m
np.matrix().dtype? ? ? ? ?#矩阵元素的类型，而不是矩阵的类型
np.matrix().itemsize? ? ?#矩阵元素的大小

3.2.4 np.matrix的方法

（1）比如关于 .reshape()方法

只要修改合理，可以根据总元素数，随意修改元素的实际shape
可以把其他类型得数组/矩阵等，转化为矩阵
比如(12,) 修改为(3,4)? 或(4,3)

（2）其他方法

3.3.5 对? np.matrix 进行切片操作

matrix()产生的至少是二维的向量组，不能是一维的
matrix的切片，大致规则是默认是2维矩阵
matrix[1]只写1维就表示行
matrix[:,1]逗号后的数表示列index
matrix[i,j]? i表示行，逗号,后的j 才表示列

import numpy as np

#matrix()产生的至少是二维的向量组，不能是一维的
A1=np.matrix([1,2,3])
print(f"A1:\n{A1}")
print(f"A1:\n{A1[0]}")
print(f"A1:\n{A1[:,1]}")
print()

A2=np.matrix([[1,2,3],[4,5,6]])
print(f"A2:\n{A2}")
print(f"A2:\n{A2[0]}")
print(f"A2:\n{A2[:,1]}")
print()

#matrix的切片，大致规则是默认是2维矩阵，只写1维就表示行inde,[:,1]逗号后的数表示列index
B=np.matrix([[1,2,3],[10,20,30]])
print(f"B:\n{B}")
print(f"B[0]:{B[0]}")
#print(f"B:{B[0,1]}")  #不能用[0,1]这种index写法
print(f"B[1]:{B[1]}")
print(f"B[:,1]:\n{B[:,1]}")

#关于matrix 和ndarray的切片，增减，合并等还比较复杂，另外单开贴再学
print(f"B[0][0]:{B[0][0]}")
print(f"B[1][0]:{B[1][0]}")
print()

3.3 np.array 只是数组ndarray，基本等同 np.matirx

np.array 只是数组ndarray，基本等同 np.matirx
和np.matrix的区别
一个是np.array() 可以生成1维数组，np.matrix() 一定生成2维度
一个是两者计算上有差别，尤其是乘法上，见下面

3.4? 代码例子

print(A)? ? ? #可直接打印矩阵内容
type(A)? ? ? #可获得变量类型
只有 ndarray 和 matrix? 才有 .shape 属性和使用 reshape()方法

import numpy as np

mylist1=[1,2,3,4,5,6]
mytuple1=(1,2,3,4,5,6)
A1=np.mat("1,2,3;10,20,30")   #mat=matrix 可以从string里创建向量组
A=np.mat([[1,2,3],[10,20,30]])
B=np.matrix([[1,2,3],[10,20,30]])
C=np.array([[1,2,3],[10,20,30]])   #np.array()只能用数字创建向量组

#py语法内容
print(f"mylist1:{type(mylist1)}\n{mylist1}")
print(f"mytuple1:{type(mytuple1)}\n{mytuple1}")

#numpy 语法内容
print(f"A1:{type(A1)}维数={A1.shape}\n{A1}")
print(f"A:{type(A)}维数={A.shape}\n{A}")
print(f"B:{type(B)}维数={B.shape}\n{B}")
print(f"C:{type(C)}维数={C.shape}\n{C}")


#测试 向量组/矩阵.属性 .shape

#python里原生的list和tuple没有shape属性
#print(mylist1.shape)
#print(mytuple1.shape)

# numpy里，numpy.matrix 和 numpy.ndarray 都是有维度的矩阵/向量组
print(A1.shape)
print(A.shape)
print(B.shape)
print(C.shape)

#测试  矩阵/向量组的多个属性
print(A.ndim)    #几维
print(A.shape)   #n行m列？具体的维度数
print(A.size)    #总数量个数=n*m
#print(A.type)   #报错
print(A.dtype)   #描述数组元素类型,而不是数组整体的类型
print(A.itemsize) #数组每个元素的字节大小。比如一个数组的元素为float64，它的itemsize为8(=64/8)
print(A.data)     #？

# 可被reshape的部分数组，向量，向量组，矩阵？
print(f"C可被变形为\n{C.reshape(3,2)}")
# py的原生类型list tuple无法使用reshape()方法
#print(f"mylist1可被变形为{mylist1.reshape(3,2)}")

3.5 两者矩阵的计算方式的差别

3.5.1 线性代数里的矩阵计算和 numpy里矩阵计算的区别

矩阵的+，- ，* ，/，虽然从线性代数和numpy的计算是有区别的

矩阵加法，线性代数=numpy
矩阵减法，线性代数=numpy
矩阵乘法

线性代数里包括很多，点乘，叉乘等等
numpy里除了点乘，叉乘外，还包括对应位置元素的乘法？

矩阵加法，线性代数=numpy

线性代数理论上没有矩阵除法
numpy还包括对应位置元素的除法？

3.5.2 矩阵的+

同型矩阵的对应元素直接相加

3.5.3 矩阵的-

同型矩阵的对应元素直接相减

3.5.4 矩阵的*

其实这个挺有问题的
一般来说，矩阵并没有对应元素相乘这种乘法吧？
其实这个挺有问题的
矩阵的乘法分为点乘--内积和叉乘--外积
但是 numpy提供了一种同型矩阵对应元素相乘的算法

matrix 只有用 np.multiply() 是对应元素相乘
matrix 用* 或者 np.dot 都是点乘计算
ndarray?用* 或者 np.multiply() 都是对应元素相乘
ndarray 用 np.dot 才是点乘计算

print(np.multiply(mat_A,mat_B)) ? ?#矩阵用multiply对应元素相乘
print(mat_A*mat_B)? ? ? ? ? ? ? ? ? ? ? ?#矩阵用*，是点乘
print(np.dot(mat_A,mat_B))? ? ? ? ? ?#矩阵用.dot，是点乘

print(np.multiply(arr_A,arr_B)) ? ?#ndarray用multiply，是对应元素相乘
print(arr_A*arr_B)? ? ? ? ? ? ? ? ? ? ? ?#ndarray用*，是对应元素相乘
print(np.dot(arr_A,arr_B))? ? ? ? ? ?#ndarray用时矩阵.dot，是点乘

3.6.5 矩阵的/

理论上，线性代数里并没有矩阵的除法吧
而numpy提供了一种，两个同型矩阵，对应元素/的算法。。。。

3.6.6 下面是试验代码

import numpy as np

mat_A=np.mat([[1,1],[2,2]])
mat_B=np.mat([[2,2],[3,3]])

print(mat_A+mat_B)
print(mat_A-mat_B)
print(np.multiply(mat_A,mat_B))    #矩阵用multiply对应元素相乘
print(mat_A*mat_B)                 #矩阵用*，是点乘
print(np.dot(mat_A,mat_B))         #矩阵用.dot，是点乘
print(mat_A/mat_B)
print()

arr_A=np.array([[1,1],[2,2]])
arr_B=np.array([[2,2],[3,3]])

print(arr_A+arr_B)
print(arr_A-arr_B)
print(np.multiply(arr_A,arr_B))    #ndarray用multiply，是对应元素相乘
print(arr_A*arr_B)                 #ndarray用*，是对应元素相乘
print(np.dot(arr_A,arr_B))         #ndarray用时矩阵.dot，是点乘
print(arr_A/arr_B)
print()

4 np.matrix的相关

4.1 两种写法

np.matrix()=np.mat()

4.2 优点

4.2.1 求转置矩阵方便

转置矩阵方法1：A.T
转置矩阵方法1：np.transpose(A)

4.2.2 求逆矩阵方便

逆矩阵方法1：A.I? （注意，ndarray是不能这样求逆矩阵的）
逆矩阵方法2：

4.2.3 求矩阵的秩方便

矩阵的秩方法1：np.linalg.matrix_rank(A))

4.3 相关代码试验

import numpy as np

A=np.mat([[1,2,3],[10,20,30]])
print(A)
print(A.T)
print(A.I)
print("A的秩为：{}".format(np.linalg.matrix_rank(A)))
print()

A=np.mat([[1,2,3],[10,20,30]])
print(A)
A=np.mat([[1,2,3],[10,20,30]])
print(A.T)
A=np.mat([[1,2,3],[10,20,30]])
print(A.I)
print()

A=np.mat([[1,2,3],[10,20,30]])
print(A)
print(A.I)
print()

5 np 与多项式

numpy 可以支持多项式的计算
配合? matplotlib 可以显示多项式的图形

5.1 创建二项式公式

#np与二项式
# y = 2x^2 + 4x + 8
arr = np.array([2, 4, 8])
func = np.poly1d(arr)

5.2 求函数的导函数

# m=1表示求一阶导数，依次类推
func1 = func.deriv(m=1)

5.3 设置多项式的X轴和Y轴内容

# 设置定义域-5,5；并将定义域等分了100份
x = np.linspace(-5, 5, 100)

y = func(x)
y1 = func1(x)

5.4 利用matplotlib 打印带坐标轴的函数图形

# 绘制
plt.plot(x, y, label="{}".format(func))
plt.plot(x, y1, label="{}".format(func1))
plt.xlabel("x")
plt.legend()
plt.show()

# 绘制
plt.plot(x, y, label="{}".format(func))
plt.plot(x, y1, label="{}".format(func1))
plt.xlabel("x")
plt.ylabel("y")

# 显示图例
plt.legend()

# 显示图像
plt.show()

5.5 代码相关

import numpy as np
import matplotlib.pyplot as plt

#np与二项式
# y = 2x^2 + 4x + 8
arr = np.array([2, 4, 8])
func = np.poly1d(arr)

# m=1表示求一阶导数，依次类推
func1 = func.deriv(m=1)

# 设置定义域-5,5；并将定义域等分了100份
x = np.linspace(-5, 5, 100)

y = func(x)
y1 = func1(x)


# 打印多项式
print(func)
# 打印多项式对应的一阶导数
print(func1)

# 绘制
plt.plot(x, y, label="{}".format(func))
plt.plot(x, y1, label="{}".format(func1))
plt.xlabel("x")
plt.ylabel("y")

# 显示图例
plt.legend()

print("多项式的根:")
print(np.roots(func))

# 显示图像
plt.show()

文章来源:https://blog.csdn.net/xuemanqianshan/article/details/134834365
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！