6.Python科学计算与数据处理.pptx

6.Python科学计算与数据处理.pptx

《6.Python科学计算与数据处理.pptx》由会员分享，可在线阅读，更多相关《6.Python科学计算与数据处理.pptx（73页珍藏版）》请在冰点文库上搜索。

1,SymPy,符号运算库,目录,从例子开始欧拉恒等式球体体积数学表达式符号数值运算符和函数符号运算表达式变换和化简方程,2,目录,微分微分方程积分其他功能,3,4,SymPy是一个符号数学Python库。

它的目标是成为一个全功能的计算机代数系统，同时保持代码的精简而易于理解和可扩展。

SymPy完全由Python写成，不需要任何外部库。

可用SymPy进行数学表达式的符号推导和演算。

可使用isympy运行程序，isympy在IPython的基础上添加了数学表达式的直观显示功能。

启动时还会自动运行下面的程序：

这段程序首先将Python的除法操作符“/”从整数除法改为普通除法。

然后从SymPy库载入所有符号，并且定义了四个通用的数学符号x、y、z、t，三个表示整数的符号k、m、n，以及三个表示数学函数的符号f、g、h。

5,from_future_importdivisionfromsympyimport*x,y,z,t=symbols（x,y,z,t）k,m,n=symbols（k,m,n,integer=True）f,g,h=symbols（f,g,h,cls=Function）#init_printing（）,从例子开始,欧拉恒等式此公式被称为欧拉恒等式，其中e是自然常数，i是虚数单位，是圆周率。

此公式被誉为数学中最奇妙的公式，它将5个基本数学常数用加法、乘法和幂运算联系起来。

从SymPy库载入的符号中，E表示自然常数，I表示虚数单位，pi表示圆周率，因此上面的公式可以直接如下计算：

6,E*（I*pi）+10,从例子开始,SymPy除了可以直接计算公式的值之外，还可以帮助做数学公式的推导和证明。

欧拉恒等式可以将代入下面的欧拉公式得到：

在SymPy中可以使用expand（）将表达式展开，用它展幵试试看：

没有成功，只是换了一种写法而已。

当expand（）的complex参数为True时，表达式将被分为实数和虚数两个部分：

7,expand（E*（I*x）exp（I*x）,从例子开始,这次将表达式展开了，但是得到的结果相当复杂。

显然，expand（）将x当做复数了。

为了指定x为实数，需要重新定义x:

终于得到了需要的公式。

可以用泰勒多项式对其进行展开：

8,expand（exp（I*x）,complex=True）I*exp（-im（x）*sin（re（x）+exp（-im（x）*cos（re（x）,x=Symbol（x,real=True）expand（exp（I*x）,complex=True）Isin（x）+cos（x）,从例子开始,series（）对表达式进行泰勒级数展开。

可以看到展开之后虚数项和实数项交替出现。

根据欧拉公式，虚数项的和应该等于sin（x）的泰勒展开，而实数项的和应该等于cos（x）的泰勒展开。

9,tmp=series（exp（I*x）,x,0,10）printtmp1+I*x-x*2/2-I*x*3/6+x*4/24+I*x*5/120-x*6/720-I*x*7/5040+x*8/40320+I*x*9/362880+O（x*10）tmp,从例子开始,下面获得tmp的实部：

下面对cos（x）进行泰勒展开，可看到其中各项和上面的结果是一致的。

10,re（tmp）x*8/40320-x*6/720+x*4/24-x*2/2+re（O（x*10）+1,series（cos（x）,x,0,10）1-x*2/2+x*4/24-x*6/720+x*8/40320+O（x*10）,从例子开始,11,下面获得tmp的虚部:

下面对sin（x）进行泰勒展开，其中各项也和上面的结果一致。

由于展开式的实部和虚部分别等于cos（x）和sin（x）,因此验证了欧拉公式的正确性。

im（tmp）x*9/362880-x*7/5040+x*5/120-x*3/6+x+im（O（x*10）,series（sin（x）,x,0,10）x-x*3/6+x*5/120-x*7/5040+x*9/362880+O（x*10）,从例子开始,球体体积Scipy介绍了如何使用数值定积分计算球体的体积，SymPy中的integrate（）则可以进行符号积分。

用integrate（）进行不定积分运算：

如果指定变量x的取值范围,integrate（）就能进行定积分运算:

12,integrate（x*sin（x）,x）-x*cos（x）+sin（x）,integrate（x*sin（x）,（x,0,2*pi）-2*pi,从例子开始,为了计算球体体积，首先看看如何计算圆的面积，假设圆的半径为r，则圆上任意一点的Y坐标函数为：

因此可以直接对函数y（x）在-r到r区间上进行定积分得到半圆面积。

13,x,y,r=symbols（x,y,r）f=2*integrate（sqrt（r*r-x*2）,（x,-r,r）printf2*Integral（sqrt（r*2-x*2）,（x,-r,r）,从例子开始,首先需要定义运算中所需的符号，这里用symbols（）一次创建多个符号。

Integrate（）没有计算出积分结果，而是直接返冋了输入的算式。

这是因为SymPy不知道r是大于0的，重新定义r，就可以得到正确答案了：

接下来对此面积公式进行定积分，就可以得到球体的体积，但是随着X轴坐标的变化，对应切面的半径也会发生变化。

14,r=symbols（r,positive=True）circle_area=2*integrate（sqrt（r*2-x*2）,（x,-r,r）printcircle_areapi*r*2,从例子开始,假设X轴的坐标为x,球体的半径为r,那么x处球的切面半径可以使用前面的公式y（x）计算出。

因此需要对圆的面积公式circle_area中的变量r进行替代：

然后对circle_area中的变量x在区间-r到r上进行定积分，就可以得到球体的体积公式:

15,circle_area=circle_area.subs（r,sqrt（r*2-x*2）printcircle_areapi*（r*2-x*2）,printintegrate（circle_area,（x,-r,r）4*pi*r*3/3,从例子开始,16,用subs进行算式替换:

subs（）可以将算式中的符号进行替换，它有3种调用方式：

expression.subs（x,y）:

将算式中的x替换成y.expression.subs（x:

y,u:

v）:

使用字典进行多次替换.expression.subs（x,y）,（u,v）：

使用列表进行多次替換.请注意多次替换是顺序执行的，因此：

expression.subs（x,y）,（y,x）并不能对符号x和y进行交换。

数学表达式,符号创建一个符号使用symbols（），此函数会返回一个Symbol对象，用于表示符号变量，其有name属性，这是符号名，如：

其中左边的x是一个符号对象，而右边括号中用引号包着的x是符号对象的name属性，两个x不要求一样，但是为了易于理解，通常将符号对象和name属性显示成一样，另外name属性是引号包起来的。

如要同时配置多个符号对象，symbols（）中多个name属性可以以,17,x0=symbols（x0）,数学表达式,空格或者逗号分隔，然后用引号包住，如下：

一次配置三个符号，由于符号对象名和name属性名经常一致，所以可以使用var（）函数，如：

这语句和上个语句功能一致，在当前环境中创建了4个同名的Symbol对象（为了防止误会，使用symbols其实更好）。

18,var（x0,y0,x1,y1）（x0,y0,x1,y1）,x0,y0,x1,y1=symbols（x0,y0,x1,y1）,数学表达式,上面的语句创建了名为x0、y0、x1、y1的4个Symbol对象，同时还在当前的环境中创建了4个同名的变量来分别表示这4个Symbol对象。

因为符号对象在转换为字符串时直接使用它的name属性，因此在交互式环境中看到变量,x0的值就是x0，但是査看变量x0的类型时就可以发现，它实际上是一个Symbol对象。

19,x0x0type（x0）sympy.core.symbol.Symbolx0.namex0type（x0.name）str,数学表达式,变量名和符号名当然也可以是不一样的，例如：

数学公式中的符号一般都有特定的假设，例如m、n通常是整数，而z经常表示复数。

在用var（）、symbols（）或Symbol（）创建Symbol对象时，可以通过关键字参数指定所创建符号的假设条件，这些假设条件会影响到它们所参与的计算。

20,a,b=symbols（alpha,beta）a,b（alpha,beta）,数学表达式,例如，下面创建了两个整数符号m和n,以及一个正数符号x:

每个符号都有许多is_*属性，用以判断符号的各种假设条件。

在IPython中，使用自动完成功能可以快速査看这些假设的名称。

注意下划线后为大写字母的属性，用来判断对象的类型;而全小写字母的属性，则用来判断符号的假设条件。

21,m,n=symbols（m,n,integer=True）x=Symbol（x,positive=True）,数学表达式,22,x.is_#按了tab键自动完成x.is_Symbol#x是一个符号Truex.is_positive#x是一个正数Truex.is_imaginary#因为x可以比较大小，所以它不是虚数Falsex.is_complex#x是一个复数，因为复数包括实数，而实数包括正数True,数学表达式,23,使用assumptions0属性可以快速査看所有的假设条件，其中commutative为True表示此符号满足交换律，其余的假设条件根据英文名很容易知道它们的含义。

在SymPy中，所有的对象都从Basic类继承，实际上这些is_*属性和assumptions0属性都是在Basic类中定义的：

x.assumptions0,Symbol.mro（）,数学表达式,数值为了实现符号运算，在SymPy内部有一整套数值运算系统。

因此SymPy的数值和Python的整数、浮点数是完全不同的对象。

为了使用方便，SymPy会尽量自动将Python的数值类型转换为SymPy的数值类型。

此外，SymPy提供了一个S对象用于进行这种转换。

在下面的例子中，当有SymPy的数值参与计算时，结果将是SymPy的数值对象。

24,数学表达式,“5/6”在SymPy中使用Rational对象表示，它由两个整数的商表示，数学上称之为有理数。

也可以直接通过Rational创建：

25,1/2+1/3#结果为浮点数0.8333333333333333S

（1）/2+1/S（3）#结果为SymPy的数值对象5/6,Rational（5,10）#有理数会自动进行约分处理1/2,数学表达式,26,运算符和函数SymPy重新定义了所有的数学运算符和数学函数。

例如Add类表示加法，Mul类表示乘法，而Pow类表示指数运算，sin类表示正弦函数。

和Symbol对象一样，这些运算符和函数都从Basic类继承，可在IPython中查看它们的继承列表（例如:

Add.mro（）。

可以使用这些类创建复杂的表达式：

var（x,y,z,n）Add（x,y,z）x+y+zAdd（Mul（x,y,z）,Pow（x,y）,sin（z）x*y*z+x*y+sin（z）,数学表达式,由于在Basic类中重新定义了_add_（）等用于创建表达式的方法，因此可以使用和Python表达式相同的方式创建SymPy的表达式：

在Basic类中定义了两个很重要的属性：

func和args。

func属性得到对象的类，而args得到其参数。

使用这两个属性可以观察SymPy所创建的表达式。

SymPy没有减法运算类，下面看看减法运算所得到的表达式：

27,x*y*z+sin（z）+x*yx*y*z+x*y+sin（z）,数学表达式,通过上面的例子可以看出，表达式“x-y”在SymPy中实际上是用“Add（x,Mul（-1,y）”表示的。

同样，SymPy中没有除法类，可使用和上面相同的方法观察“x/y”在SymPy中是如何表示的。

28,t=x-yt.func#减法运算用加法类Add表示sympy.core.add.Addt.args#两个加数一个是x，一个是-y（x,-y）t.args1.func#-y是用Mul表示的sympy.core.mul.Mult.args1.args（-1,y）,数学表达式,SymPy的表达式实际上是一个由Basic类的各种对象进行多层嵌套所得到的树状结构。

下面的函数使用递归显示这种树状结构：

由于fsolve函数在调用函数f时，传递的参数为数组，因此如果直接使用数组中的元素计算的话，计算速度将会有所降低，因此这里先用float函数将数组中的元素转换为Python中的标准浮点数，然后调用标准math库中的函数进行运算。

29,defprint_expression（e,level=0）:

spaces=*levelifisinstance（e,（Symbol,Number）:

printspaces+str（e）returniflen（e.args）0:

printspaces+e.func._name_forargine.args:

print_expression（arg,level+1）else:

printspaces+e.func._name_,数学表达式,例如在SymPy中使用下面的树表示：

由于其中的各个对象的args属性类型是元组，因此表达式一旦创建就不能再改变。

使用不可变的结构表示表达式有很多优点，例如可以用表达式作为字典的键。

30,print_expression（sqrt（x*2+y*2）PowAddPowx2Powy21/2,数学表达式,除了使用SymPy中预先定义好的具有特殊运算含义的数学函数之外，还可以使用Function（）创建自定义的数学函数：

请注意Function虽然是一个类，但是上面的语句所得到的f并不是Function类的实例。

和预定义的数学函数一样，f是一个类，它从Function类继承：

31,f=Function（f）,f._base_sympy.core.function.AppliedUndefisinstance（f,Function）False,数学表达式,当我使用f创建一个表达式时，就相当于创建它的一个实例：

f的实例t可以参与表达式运算：

32,t=f（x,y）isinstance（t,Function）Truetype（t）ft.func#（其中func和args是Basic类的两个非常重要的属性，分别表示对象的类和对象的参数）ft.args（x,y）,t+t*tf（x,y）*2+f（x,y）,符号运算,表达式变换和化简simplify（）可以对数学表达式进行化简，例如:

simplify（）调用SymPy内部的多种表达式变换函数对表达式进行化简运算。

但是数学表达式的化简是一件非常复杂的工作，并且对于同一个表达式，根据其使用目的可以有多种化简方案。

33,simplify（x+2）*2-（x+1）*2）2*x+3,符号运算,34,radsimp（）对表达式的分母进行有理化，它所得到的表达式的分母部分将不含无理数。

例如：

它也可以对带符号的表达式进行处理:

radsimp（1/（sqrt（5）+2*sqrt

（2）（-sqrt（5）+2*sqrt

（2）/3,radsimp（1/（y*sqrt（x）+x*sqrt（y）（-sqrt（x）*y+x*sqrt（y）/（x*y*（x-y）,符号运算,ratsimp（）对表达式中的分母进行通分运算，即将表达式转换为分子除分母的形式：

fraction（）返回一个包含表达式的分子和分母的元组,用它可以获得ratsimp（）通分之后的分子或分母：

注意fraction（）不会自动对表达式进行通分运算，因此：

35,ratsimp（x/（x+y）+y/（x-y）2*y*2/（x*2-y*2）+1,fraction（ratsimp（1/x+1/y）（x+y,x*y）,fraction（1/x+1/y）（1/y+1/x,1）,符号运算,cancel（）对分式表达式的分子分母进行约分运算，可以对纯符号的分式表达式以及自定义函数表达式进行约分，但是不能对内部函数的表达式进行约分。

36,cancel（x*2-1）/（1+x）x-1cancel（sin（x*2-1）/（1+x）#cancel不能对函数内部的表达式进行约分sin（x*2/（x+1）-1/（x+1）cancel（f（x）*2-1）/（f（x）+1）#能对自定义函数表达式进行约分f（x）-1,符号运算,trigsimp（）对表达式中的三角函数进行化简。

它有两个可选参数-deep和recursive，默认值都为False。

当deep参数为True时，将对表达式中的所有子表达式进行简化运算；当recursive参数为True时，将递归使用trigsimp（）进行最大限度的化简：

37,trigsimp（sin（x）*2+2*sin（x）*cos（x）+cos（x）*2）sin（2*x）+1trigsimp（f（sin（x）*2+2*sin（x）*cos（x）+cos（x）*2）#也能对自定义函数中的三角函数化简，至今不知道deep和recursive是干嘛的f（sin（2*x）+1）,符号运算,38,expand_trig（）可以对三角函数的表达式进行展开。

它实际上是对expand（）的封装，通过将expand（）的trig参数设置为True,实现三角函数的展开计算。

输入“expand_trig?

”来査看它调用expand（）时的参数。

expand（）通用的展开运算，根据用户设置的标志参数对表达式进行展幵。

默认情况下，以下的标志参数为True。

mul：

展开乘法,expand_trig（sin（2*x+y）（2*cos（x）*2-1）*sin（y）+2*sin（x）*cos（x）*cos（y）,符号运算,log:

展开对数函数参数中的乘积和幂运算multinomial:

展开加法式的整数次幂power_base:

展开幂函数的底数乘积,39,x,y=symbols（x,y,positive=True）expand（log（x*y*2）log（x）+2*log（y）,expand（x+y）*3）x*3+3*x*2*y+3*x*y*2+y*3,expand（x*（y+z）x*y*x*z,符号运算,可以将默认为True的标志参数设置为False,强制不展开对应的表达式。

在下面的例子中，将mul设置为False,因此不对乘法进行展开：

expand（）的以下标志参数默认为False。

complex:

展开复数的实部和虚部，默认不展开复数的实部和虚部:

40,x,y,z=symbols（x,y,z,positive=True）expand（x*log（y*z）,mul=False）x*（log（y）+log（z）,x,y=symbols（x,y,complex=True）expand（x*y,complex=True）re（x）*re（y）+I*re（x）*im（y）+I*re（y）*im（x）-im（x）*im（y）,符号运算,func:

对一些特殊函数进行展开trig:

展开三角函数expand_log（）、expandmul（）、expand_complex（）、expand_trig（）、expand_func（）等函数则通过将相应的标志参数设置为True,对expand（）进行封装。

41,expand（gamma（1+x）,func=True）x*gamma（x）,expand（sin（x+y）,trig=True）sin（x）*cos（y）+sin（y）*cos（x）,符号运算,42,factor（）可以对多项式表达式进行因式分解：

collect（）收集表达式中指定符号的有理指数次幂的系数。

例如，希望获得如下表达式中x的各次幂的系数：

factor（15*x*2+2*y-3*x-10*x*y）（3*x-2*y）*（5*x-1）factor（expand（x+y）*20）（x+y）*20,a,b=symbols（a,b）eq=（1+a*x）*3+（1+b*x）*2,符号运算,首先需要对表达式eq进行展开，得到的表达式eq2是一系列乘式的和:

然后调用collect（）,对表达式eq2中X的幂的系数进行收集：

43,eq2=expand（eq）eq2a*3*x*3+3*a*2*x*2+3*a*x+b*2*x*2+2*b*x+2,collect（eq2,x）a*3*x*3+x*2*（3*a*2+b*2）+x*（3*a+2*b）+2,符号运算,默认情况下，collect（）返回的是一个整理之后的表达式，如果我们希望得到x的各次幂的系数，可以设置evaluate参数为False,让它返回一个以X的幂为键、值为系数的字典：

44,p=collect（eq2,x,evaluate=False）pS

（1）#常数项，注意需要用SymPy中的数值1,或者使用px*02px*2#x的2次项系数b*2+3*a*2,符号运算,45,collect（）也可以收集表达式的各次幂的系数，例如下面的程序收集表达式“sin（2*x）”的系数:

collect（a*sin（2*x）+b*sin（2*x）,sin（2*x）（a+b）*sin（2*x）,符号运算,46,方程在SymPy中，表达式可以直接表示值为0的方程。

也可以使用Eq（）创建方程。

solve（）可以对方程进行符号求解，它的第一个参数是表示方程的表达式，其后的参数是表示方程中未知变量的符号。

下面的例子使用solve（）对一元二次方程进行求解:

a,b,c=symbols（a,b,c）solve（a*x*2+b*x+c,x）（-b+sqrt（-4*a*c+b*2）/（2*a）,-（b+sqrt（-4*a*c+b*2）/（2*a）,符号运算,使用Eq创建一个方程对象并求解：

47,my_eq=Eq（a*x*2+b*x+c,0）solve（my_eq,x）（-b+sqrt（-4*a*c+b*2）/（2*a）,-（b+sqrt（-4*a*c+b*2）/（2*a）,符号运算,由于方程的解可能有多组，因此solve（）返回一个列表保存所有的解。

可以传递包含多个表达式的元组或列表，让solve（）对方程组进行求解，得到的解是两层嵌套的列表，其中每个元组表示方程组的一组解：

48,#对方程组求解（用元组将几个方程组成一个组）solve（x*2+x*y+1,y*2+x*y+2）,x,y）（-sqrt（3）*I/3,-2*sqrt（3）*I/3）,（sqrt（3）*I/3,2*sqrt（3）*I/3）#有两组解,符号运算,微分Derivative是表示导函数的类，它的第一个参数是需要进行求导的数学函数，第二个参数是求导的自变量.注意Derivative所得到的是一个导函数，它并不会进行求导运算：

如果希望它进行实际的运算，计算出导函数，可以调用其doit（）方法：

49,t=Derivative（sin（x）,x）#创建了一个导函数对象tDerivative（sin（x）,x）,t.doit（）cos（x）,符号运算,50,也可以直接使用diff（）函数或表达式的diff（）方法来计算导函数：

使用Derivative对象可以表示自定义的数学函数的导函数，例如：

diff（sin（2*x）,x）2*cos（2*x）sin（2*x）.diff（x）2*cos（2*x）diff（sin（2*x）,x,2）-4*sin（2*x）diff（sin（2*x）,x,3）-8*cos（