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

2023-12-13 10:05:10

目录

1 numpy 的基本介绍

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

2.0 总结

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

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

2.1.2 可以使用reshape()转换

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

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

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

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

2.4.2 生成方法

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

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

2.5.2 用法

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

2.6.0 多种方法

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

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

2.6.3 np.random.randn()

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

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

2.8 代码测试

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

3.1 numpy特殊的数据类型

3.1.1 python的数据类型

3.1.2 首先 python原生的list 和 tuple?

3.1.3 numpy的数据类型

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

3.2.1 首先,两种写法相同

3.2.2?np.matrix的特点

3.2.3?np.matrix的属性

3.2.4 np.matrix的方法

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

(2)其他方法

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

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

3.4? 代码例子

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

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

3.5.2 矩阵的+

3.5.3 矩阵的-

3.5.4 矩阵的*

3.6.5 矩阵的/

3.6.6 下面是试验代码

4 np.matrix的相关

4.1 两种写法

4.2 优点

4.2.1 求转置矩阵方便

4.2.2 求逆矩阵方便

4.2.3 求矩阵的秩方便

4.3 相关代码试验

5 np 与多项式

5.1 创建二项式公式

5.2 求函数的导函数

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

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

5.5 代码相关


1 numpy 的基本介绍

以下介绍来自baidu百科

  • NumPy(Numeric Python)提供了许多高级的数值编程工具,如:矩阵数据类型、矢量处理,以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用,以及核心的科学计算组织如:Lawrence Livermore,NASA用其处理一些本来使用C++,Fortran或Matlab等所做的任务。
  • NumPy 的前身为 Numeric ,最早由 Jim Hugunin 与其它协作者共同开发,2005 年,Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色,并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。 [1]
  • 一个用python实现的科学计算,包括:
  1. 一个强大的N维数组对象Array;
  2. 比较成熟的(广播)函数库;
  3. 用于整合C/C++和Fortran代码的工具包;
  4. 实用的线性代数、傅里叶变换和随机数生成函数。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列表的区别:
  1. 从图中我们可以看出ndarray在存储数据的时候,数据与数据的地址都是连续的,这样就给使得批量操作数组元素时速度更快。
  2. 这是因为ndarray中的所有元素的类型都是相同的,而Python列表中的元素类型是任意的,所以ndarray在存储元素时内存可以连续,而python原生list就只能通过寻址方式找到下一个元素,这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list,但在科学计算中,Numpy的ndarray就可以省掉很多循环语句,代码使用方面比Python原生list简单的多。
  3. numpy内置了并行运算功能,当系统有多个核心时,做某种计算时,numpy会自动做并行计算。
  4. Numpy底层使用C语言编写,数组中直接存储对象,而不是存储对象指针,所以其运算效率远高于纯Python代码。
  5. 下图也来自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
  • 矩阵乘法
  1. 线性代数里包括很多,点乘,叉乘等等
  2. numpy里除了点乘,叉乘外,还包括对应位置元素的乘法?
  • 矩阵加法,线性代数=numpy
  1. 线性代数理论上没有矩阵除法
  2. numpy还包括对应位置元素的除法?

3.5.2 矩阵的+

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

3.5.3 矩阵的-

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

3.5.4 矩阵的*

  • 其实这个挺有问题的
  • 一般来说,矩阵并没有对应元素相乘这种乘法吧?
  • 其实这个挺有问题的
  • 矩阵的乘法分为点乘--内积 和 叉乘--外积
  • 但是 numpy提供了一种同型矩阵对应元素相乘的算法
  1. matrix 只有用 np.multiply() 是对应元素相乘
  2. matrix 用* 或者 np.dot 都是点乘计算
  3. ndarray?用* 或者 np.multiply() 都是对应元素相乘
  4. 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
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。