python解微分方程

❶ python的scipy里的odeint这个求微分方程的函数怎么用啊

scipy.integrate.odeint(func,y0,t,args=(),Dfun=None,col_deriv=0,full_output=0,ml=None,mu=None,rtol=None,atol=None,tcrit=None,h0=0.0,hmax=0.0,hmin=0.0,ixpr=0,mxstep=0,mxhnil=0,mxordn=12,mxords=5,printmessg=0) 实际使用中，还是主要使用前三个参数，即微分方程的描写函数、初值和需要求解函数值对应的的时间点。接收数组形式。这个函数，要求微分方程必须化为标准形式，即dy/dt=f(y,t,)。 fromscipyimportodeint y=odeint(dy/dt=r*y*(1-y/k),y(0)=0.1,t) 对于微分方程全还给老师了，

❷ 如何使用python计算常微分方程

常用形式
odeint(func, y0, t,args,Dfun)
一般这种形式就够用了。
下面是官方的例子，求解的是
D(D(y1))-t*y1=0
为了方便，采取D=d/dt。如果我们令初值
y1(0) = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)
D(y1)(0) = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)
这个微分方程的解y1=airy(t)。

令D(y1)=y0，就有这个常微分方程组。
D(y0)=t*y1
D(y1)=y0

Python求解该微分方程。
>>> from scipy.integrate import odeint
>>> from scipy.special import gamma, airy
>>> y1_0 = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)
>>> y0_0 = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)
>>> y0 = [y0_0, y1_0]
>>> def func(y, t):
... return [t*y[1],y[0]]
>>> def gradient(y,t):
... return [[0,t],[1,0]]
>>> x = arange(0,4.0, 0.01)
>>> t = x
>>> ychk = airy(x)[0]
>>> y = odeint(func, y0, t)
>>> y2 = odeint(func, y0, t, Dfun=gradient)
>>> print ychk[:36:6]
[ 0.355028 0.339511 0.324068 0.308763 0.293658 0.278806]
>>> print y[:36:6,1]
[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]
>>> print y2[:36:6,1]
[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]

得到的解与精确值相比，误差相当小。
=======================================================================================================

args是额外的参数。
用法请参看下面的例子。这是一个洛仑兹曲线的求解，并且用matplotlib绘出空间曲线图。（来自《python科学计算》）
from scipy.integrate import odeint
import numpy as np
def lorenz(w, t, p, r, b):
# 给出位置矢量w，和三个参数p, r, b 计算出
# dx/dt, dy/dt, dz/dt 的值
x, y, z = w
# 直接与lorenz 的计算公式对应
return np.array([p*(y-x), x*(r-z)-y, x*y-b*z])
t = np.arange(0, 30, 0.01) # 创建时间点
# 调用ode 对lorenz 进行求解, 用两个不同的初始值
track1 = odeint(lorenz, (0.0, 1.00, 0.0), t, args=(10.0, 28.0, 3.0))
track2 = odeint(lorenz, (0.0, 1.01, 0.0), t, args=(10.0, 28.0, 3.0))
# 绘图
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = Axes3D(fig)
ax.plot(track1[:,0], track1[:,1], track1[:,2])
ax.plot(track2[:,0], track2[:,1], track2[:,2])
plt.show()
===========================================================================
scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0)
计算常微分方程（组）
使用 FORTRAN库odepack中的lsoda解常微分方程。这个函数一般求解初值问题。

参数：

func : callable(y, t0, ...) 计算y在t0 处的导数。
y0 : 数组 y的初值条件（可以是矢量）
t : 数组 为求出y，这是一个时间点的序列。初值点应该是这个序列的第一个元素。
args : 元组 func的额外参数
Dfun : callable(y, t0, ...) 函数的梯度(Jacobian)。即雅可比多项式。
col_deriv : boolean. True，Dfun定义列向导数（更快），否则Dfun会定义横排导数
full_output : boolean 可选输出，如果为True 则返回一个字典，作为第二输出。
printmessg : boolean 是否打印convergence 消息。

返回： y : array, shape (len(y0), len(t))
数组，包含y值，每一个对应于时间序列中的t。初值y0 在第一排。
infodict : 字典，只有full_output == True 时，才会返回。
字典包含额为的输出信息。
键值：

‘hu’ vector of step sizes successfully used for each time step.
‘tcur’ vector with the value of t reached for each time step. (will always be at least as large as the input times).
‘tolsf’ vector of tolerance scale factors, greater than 1.0, computed when a request for too much accuracy was detected.
‘tsw’ value of t at the time of the last method switch (given for each time step)
‘nst’ cumulative number of time steps
‘nfe’ cumulative number of function evaluations for each time step
‘nje’ cumulative number of jacobian evaluations for each time step
‘nqu’ a vector of method orders for each successful step.
‘imxer’index of the component of largest magnitude in the weighted local error vector (e / ewt) on an error return, -1 otherwise.
‘lenrw’ the length of the double work array required.
‘leniw’ the length of integer work array required.
‘mused’a vector of method indicators for each successful time step: 1: adams (nonstiff), 2: bdf (stiff)
其他参数，官方网站和文档都没有明确说明。相关的资料，暂时也找不到。

❸ 用matlab或maple或者python解一个二阶常微分方程-数值解（用差分或者有限元方法）（非直接ode45类型的）

我用 Maple 2015 做了1个，如下：

可以在 Maple 中运行，滑动两个滑动条，得到相应的数值解的绘图，其中原式中的 n=两个滑动条之和。Maple文件如果需要可以邮箱发给你，应该可以用 Maple 17 及以上版本打开。

如果没有 Maple，可以用以下链接试试在线的：
http://202.121.241.38/maplenet/worksheet/uploads/dsolve&plot.mw

❹ python 的scipy 里的 odeint 这个求微分方程的函数怎么用啊

scipy中提供了用于解常微分方程的函数odeint()，完整的调用形式如下：
scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0,hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0)
实际使用中，还是主要使用前三个参数，即微分方程的描写函数、初值和需要求解函数值对应的的时间点。接收数组形式。这个函数，要求微分方程必须化为标准形式，即dy/dt=f(y,t,)。

from scipy import odeint
y = odeint(dy/dt=r*y*(1-y/k) ,y(0)=0.1,t)

对于微分方程全还给老师了，
http://hyry.dip.jp:8000/pydoc/index.html
这个地址有很多关于python做科学计算的文档，你可以去查查

❺ 用python如何得到一个方程的多个解

方法/步骤

• 用Python解数学方程，需要用到Python的一个库——SymPy库。

  SymPy是符号数学的Python库，它的目标是成为一个全功能的计算机代数系统，同时保持代码简洁、易于理解和扩展。

  如果你的电脑上还没有安装sympy库，那就赶紧安装吧，安装命令：

  pip3 install sympy

  

❻ 求助关于一个用Python求微分方程并算出极值

所说所有的变量都是对象。 对象在python里，其实是一个指针，指向一个数据结构，数据结构里有属性，有方法。对象通常就是指变量。从面向对象OO的概念来讲，对象是类的一个实例。在python里很简单，对象就是变量。class A:myname="class a"上面就是一个类。不是对象a=A()这里变量a就是一个对象。它有一个属性（类属性），myname，你可以显示出来print a.myname所以，你看到一个变量后面跟点一个小数点。那么小数点后面

❼ dy/dx=E(y)/x，怎么使用使用python的scipy库中的odeint求解y和x的关系

odeint实际是用来解微分方程组的。
令z = y’,可以把方程化为方程组：
y' = z
z' = -b*y-a*z
将y, z分别替换为y[0], y[1]就得到了程序里的return array([ y[1], a*y[0]+b*y[1] ])， 这个程序把a,b前面的符号放到参数赋值里了。

搞明白上面的就能用来解方程了，下面画图部分无关紧要
hold('on')是用来保持之前画的曲线

legend() 显示曲线的标签

❽ python求微分方程组的数值解曲线01

如图所示：

❾ 如何系统地自学 Python

是否非常想学好 Python，一方面被琐事纠缠，一直没能动手，另一方面，担心学习成本太高，心里默默敲着退堂鼓？

幸运的是，Python 是一门初学者友好的编程语言，想要完全掌握它，你不必花上太多的时间和精力。

Python 的设计哲学之一就是简单易学，体现在两个方面：

• 语法简洁明了：相对 Ruby 和 Perl，它的语法特性不多不少，大多数都很简单直接，不玩儿玄学。

• 切入点很多：Python 可以让你可以做很多事情，科学计算和数据分析、爬虫、Web 网站、游戏、命令行实用工具等等等等，总有一个是你感兴趣并且愿意投入时间的。


废话不多说，学会一门语言的捷径只有一个： Getting Started

¶ 起步阶段
任何一种编程语言都包含两个部分：硬知识和软知识，起步阶段的主要任务是掌握硬知识。

硬知识
“硬知识”指的是编程语言的语法、算法和数据结构、编程范式等，例如：变量和类型、循环语句、分支、函数、类。这部分知识也是具有普适性的，看上去是掌握了一种语法，实际是建立了一种思维。例如：让一个 Java 程序员去学习 Python，他可以很快的将 Java 中的学到的面向对象的知识 map 到 Python 中来，因此能够快速掌握 Python 中面向对象的特性。

如果你是刚开始学习编程的新手，一本可靠的语法书是非常重要的。它看上去可能非常枯燥乏味，但对于建立稳固的编程思维是必不可少。

下面列出了一些适合初学者入门的教学材料：

廖雪峰的 Python 教程 Python 中文教程的翘楚，专为刚刚步入程序世界的小白打造。

笨方法学 Python 这本书在讲解 Python 的语法成分时，还附带大量可实践的例子，非常适合快速起步。

The Hitchhiker’s Guide to Python! 这本指南着重于 Python 的最佳实践，不管你是 Python 专家还是新手，都能获得极大的帮助。

Python 的哲学：

• 用一种方法，最好是只有一种方法来做一件事。

学习也是一样，虽然推荐了多种学习资料，但实际学习的时候，最好只选择其中的一个，坚持看完。

必要的时候，可能需要阅读讲解数据结构和算法的书，这些知识对于理解和使用 Python 中的对象模型有着很大的帮助。

软知识
“软知识”则是特定语言环境下的语法技巧、类库的使用、IDE的选择等等。这一部分，即使完全不了解不会使用，也不会妨碍你去编程，只不过写出的程序，看上去显得“傻”了些。

对这些知识的学习，取决于你尝试解决的问题的领域和深度。对初学者而言，起步阶段极易走火，或者在选择 Python 版本时徘徊不决，一会儿看 2.7 一会儿又转到 3.0，或者徜徉在类库的大海中无法自拔，Scrapy，Numpy，Django 什么都要试试，或者参与编辑器圣战、大括号缩进探究、操作系统辩论赛等无意义活动，或者整天跪舔语法糖，老想着怎么一行代码把所有的事情做完，或者去构想圣洁的性能安全通用性健壮性全部满分的解决方案。

很多“大牛”都会告诫初学者，用这个用那个，少走弯路，这样反而把初学者推向了真正的弯路。
还不如告诉初学者，学习本来就是个需要你去走弯路出 Bug，只能脚踏实地，没有奇迹只有狗屎的过程。

选择一个方向先走下去，哪怕脏丑差，走不动了再看看有没有更好的解决途径。

自己走了弯路，你才知道这么做的好处，才能理解为什么人们可以手写状态机去匹配却偏要发明正则表达式，为什么面向过程可以解决却偏要面向对象，为什么我可以操纵每一根指针却偏要自动管理内存，为什么我可以嵌套回调却偏要用 Promise...

更重要的是，你会明白，高层次的解决方法都是对低层次的封装，并不是任何情况下都是最有效最合适的。

技术涌进就像波浪一样，那些陈旧的封存已久的技术，消退了迟早还会涌回的。就像现在移动端应用、手游和 HTML5 的火热，某些方面不正在重演过去 PC 的那些历史么？

因此，不要担心自己走错路误了终身，坚持并保持进步才是正道。

起步阶段的核心任务是掌握硬知识，软知识做适当了解，有了稳固的根，粗壮的枝干，才能长出浓密的叶子，结出甜美的果实。

¶ 发展阶段
完成了基础知识的学习，必定会感到一阵空虚，怀疑这些语法知识是不是真的有用。

没错，你的怀疑是非常正确的。要让 Python 发挥出它的价值，当然不能停留在语法层面。
发展阶段的核心任务，就是“跳出 Python，拥抱世界”。

在你面前会有多个分支：科学计算和数据分析、爬虫、Web 网站、游戏、命令行实用工具等等等等，这些都不是仅仅知道 Python 语法就能解决的问题。

拿爬虫举例，如果你对计算机网络，HTTP 协议，HTML，文本编码，JSON 一无所知，你能做好这部分的工作么？而你在起步阶段的基础知识也同样重要，如果你连循环递归怎么写都还要查文档，连 BFS 都不知道怎么实现，这就像工匠做石凳每次起锤都要思考锤子怎么使用一样，非常低效。

在这个阶段，不可避免要接触大量类库，阅读大量书籍的。

类库方面
“Awesome Python 项目”：vinta/awesome-python · GitHub
这里列出了你在尝试解决各种实际问题时，Python 社区已有的工具型类库，如下图所示：



vinta/awesome-python

你可以按照实际需求，寻找你需要的类库。

至于相关类库如何使用，必须掌握的技能便是阅读文档。由于开源社区大多数文档都是英文写成的，所以，英语不好的同学，需要恶补下。

书籍方面
这里我只列出一些我觉得比较有一些帮助的书籍，详细的请看豆瓣的书评：

科学和数据分析：
❖“集体智慧编程”：集体智慧编程 (豆瓣)
❖“数学之美”：数学之美 (豆瓣)
❖“统计学习方法”：统计学习方法 (豆瓣)
❖“Pattern Recognition And Machine Learning”：Pattern Recognition And Machine Learning (豆瓣)
❖“数据科学实战”：数据科学实战 (豆瓣)
❖“数据检索导论”：信息检索导论 (豆瓣)

爬虫：
❖“HTTP 权威指南”：HTTP权威指南 (豆瓣)

Web 网站：
❖“HTML & CSS 设计与构建网站”：HTML & CSS设计与构建网站 (豆瓣)

...

列到这里已经不需要继续了。

聪明的你一定会发现上面的大部分书籍，并不是讲 Python 的书，而更多的是专业知识。

事实上，这里所谓“跳出 Python，拥抱世界”，其实是发现 Python 和专业知识相结合，能够解决很多实际问题。这个阶段能走到什么程度，更多的取决于自己的专业知识。

¶ 深入阶段
这个阶段的你，对 Python 几乎了如指掌，那么你一定知道 Python 是用 C 语言实现的。

可是 Python 对象的“动态特征”是怎么用相对底层，连自动内存管理都没有的C语言实现的呢？这时候就不能停留在表面了，勇敢的拆开 Python 的黑盒子，深入到语言的内部，去看它的历史，读它的源码，才能真正理解它的设计思路。

这里推荐一本书：
“Python 源码剖析”：Python源码剖析 (豆瓣)
这本书把 Python 源码中最核心的部分，给出了详细的阐释，不过阅读此书需要对 C 语言内存模型和指针有着很好的理解。

另外，Python 本身是一门杂糅多种范式的动态语言，也就是说，相对于 C 的过程式、 Haskell 等的函数式、Java 基于类的面向对象而言，它都不够纯粹。换而言之，编程语言的“道学”，在 Python 中只能有限的体悟。学习某种编程范式时，从那些面向这种范式更加纯粹的语言出发，才能有更深刻的理解，也能了解到 Python 语言的根源。

这里推荐一门公开课
“编程范式”：斯坦福大学公开课：编程范式
讲师高屋建瓴，从各种编程范式的代表语言出发，给出了每种编程范式最核心的思想。

值得一提的是，这门课程对C语言有非常深入的讲解，例如C语言的范型和内存管理。这些知识，对阅读 Python 源码也有大有帮助。

Python 的许多最佳实践都隐藏在那些众所周知的框架和类库中，例如 Django、Tornado 等等。在它们的源代码中淘金，也是个不错的选择。

¶ 最后的话
每个人学编程的道路都是不一样的，其实大都殊途同归，没有迷路的人只有不能坚持的人！

希望想学 Python 想学编程的同学，不要犹豫了，看完这篇文章，

Just Getting Started ！！！

❿ python里怎么样求解微分方程

有很多大学生问我，学习python有什么用呢？我说：你至少可以用来解微分方程，如下面的例子,就是解决微分方程：
y"+a*y'+b*y=0

代码如下：

[python]view plain

• #y"+a*y'+b*y=0

• fromscipy.integrateimportodeint

• frompylabimport*

• defderiv(y,t):#返回值是y和y的导数组成的数组

• a=-2.0

• b=-0.1

• returnarray([y[1],a*y[0]+b*y[1]])

• time=linspace(0.0,50.0,1000)

• yinit=array([0.0005,0.2])#初值

• y=odeint(deriv,yinit,time)

• figure()

• plot(time,y[:,0],label='y')#y[:,0]即返回值的第一列，是y的值。label是为了显示legend用的。

• plot(time,y[:,1],label="y'")#y[:,1]即返回值的第二列，是y’的值

• xlabel('t')

• ylabel('y')

• legend()

• show()

输出结果如下：