【python VS vba】(7) 在python使用numpy库
目录
2.1.1使用np.array()创建ndarray 数组/向量
2.3? 方法3:np.linspace()? #核心是按个数生成,(终点-起点)/个数 均匀生成
2.4 方法4:np.arange()? #核心是按步长生成,(终点-起点)按步长逐个生成
2.4.1 语法 np.arange([start, ]stop, [step, ]dtype=None)
2.5 对比?python原生的 range() 只能生成python的数组list=[]
2.6.1 np.random.uniform(low=-1, high=0, size=(2, 2))
2.6.2 np.random.rand()/np.random.random()
2.6.4 np.random.randint(low,high,size,dtype)? ?整数
2.7 和这里没关系,正态分布? np.random.normal()
3? numpy里的两种新数据类型:ndarray 和?matrix
3.1.2 首先 python原生的list 和 tuple?
3.3 np.array 只是数组ndarray,基本等同 np.matirx
3.5.1 线性代数里的矩阵计算和 numpy里矩阵计算的区别
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实现的科学计算,包括:
- 一个强大的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()
?
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!