python求函数的微分 python 微分

python里怎么样求解微分方程

有很多大学生问python求函数的微分我python求函数的微分，学习python有什么用呢？我说：python求函数的微分你至少可以用来解微分方程python求函数的微分，如下面的例子,就是解决微分方程：

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

代码如下：

[python] view plain copy

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

from scipy.integrate import odeint

from pylab import *

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

a = -2.0

b = -0.1

return array([ 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()

输出结果如下：

相关问答

Q1: 如何使用python计算常微分方程？

常用形式

odeint(func, y0, t,args,Dfun)

一般这种形式就够用了。

下面是官方python求函数的微分的例子python求函数的微分，求解的是

D(D(y1))-t*y1=0

为了方便，采取D=d/dt。如果python求函数的微分我们令初值

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)

其python求函数的微分他参数，官方网站和文档都没有明确说明。相关的资料，暂时也找不到。

Q2: 常微分方程的解析解(方法归纳)以及基于Python的微分方程数值解算例实现

本文归纳常见常微分方程的解析解解法以及基于Python的微分方程数值解算例实现。

考虑常微分方程的解析解法，我们一般可以将其归纳为如下几类：

这类微分方程可以变形成如下形式：

两边同时积分即可解出函数，难点主要在于不定积分，是最简单的微分方程。

某些方程看似不可分离变量，但是经过换元之后，其实还是可分离变量的，不要被这种方程迷惑。

形如

的方程叫做一阶线性微分方程，若 为0，则方程齐次，否则称为非齐次。

解法： (直接套公式)

伯努利方程

形如

的方程称为伯努利方程，这种方程可以通过以下步骤化为一阶线性微分方程：

令 , 方程两边同时乘以 ，得到

即 .

这就将伯努利方程归结为可以套公式的一阶线性微分方程。

形如

的方程称为二阶常系数微分方程，若 ，则方程称为齐次的，反之称为非齐次的。以下默认方程是非齐次的。

求解此类方程分两步：

原方程的解 = 齐次通解 + 非齐次特解

首先假设 .用特征方程法，写出对应的特征方程并且求解：

解的情况分为以下三种：

情况一：方程有两个不同的实数解

假设两个实数解分别是 , 此时方程的通解是

情况二：方程有一个二重解

假设该解等于 ，此时方程的通解是

情况三：方程有一对共轭复解

假设这对解是 , 此时方程的通解是

对于 和特征根的情况，对特解的情况做如下归纳：

形如

的方程叫做高阶常系数微分方程，若 ，则方程是齐次的，否则是非齐次的。下面默认方程是非齐次的。

求解此类方程分两步：

原方程的解 = 齐次通解 + 非齐次特解

考虑带有第三类边界条件的二阶常系数微分方程边值问题

问题一:两点边值问题的解析解

由于此方程是非齐次的,故 求解此类方程分两步：

原方程的解 = 齐次通解 + 非齐次特解

首先假设 . 用特征方程法，写出对应的特征方程

求解得到两个不同的实数特征根: .

此时方程的齐次通解是

由于 . 所以非齐次特解形式为

将上式代入控制方程有

求解得: , 即非齐次特解为 .

原方程的解 = 齐次通解 + 非齐次特解

于是,原方程的全解为

因为该问题给出的是第三类边界条件,故需要求解的导函数

且有

将以上各式代入边界条件

解此方程组可得: .

综上所述,原两点边值问题的解为

对一般的二阶微分方程边值问题

假定其解存在唯一,

为求解的近似值, 类似于前面的做法,

考虑带有第三类边界条件的二阶常系数微分方程边值问题

问题二:有限差分方法算出其数值解及误差

对于 原问题 ,取步长 h=0.2 ,用 有限差分 求其 近似解 ,并将结果与 精确解y(x)=-x-1 进行比较.

因为

先以将区间划分为5份为例，求出数值解

结果:

是不是解出数值解就完事了呢？当然不是。我们可以将问题的差分格式解与问题的真解进行比较，以得到解的可靠性。通过数学计算我们得到问题的真解为 ，现用范数来衡量误差的大小：

结果:

接下来绘图比较 时数值解与真解的差距：

结果:

将区间划分为 份, 即 时.

结果:

绘图比较 时数值解与真解的差距：

最后，我们还可以从数学的角度分析所采用的差分格式的一些性质。因为差分格式的误差为 ， 所以理论上来说网格每加密一倍，与真解的误差大致会缩小到原来的 . 下讨论网格加密时的变化：

结果：

Q3: python 牛顿微分解超越方程

import matplotlib.pyplotas plt

from matplotlib.pyplotimport plot

from matplotlib.animationimport FuncAnimation

import numpyas np

variation =1e-6  # 选定y值误差区间

ini_x =2.0  # 选型x初始值

l_x = []

l_y = []

def newton(variation, ini_x):

print('current acceptable error: ' +str(variation) +'\n')

cur_y = np.log(ini_x +1) - ini_x ** (-1) -1  # 

cur_x = ini_x

l_x.append(ini_x)

l_y.append(cur_y)

count =1  # 迭代计数

    while abs(cur_y) variation:# 比较y和误差区间

        print(str(count) +' root = ' +str(cur_x))

# f(x)=ln(x+1)-x^(-1)-1

# df(x)=1/(x+1)+x^(-2)

        func = np.log(cur_x +1) - cur_x ** (-1) -1

        dif_func = (cur_x +1) ** (-1) + cur_x ** (-2)

cur_x = cur_x - (func / dif_func)# 迭代x

        cur_y = func# 计算y

        l_x.append(cur_x)# 保存x

        l_y.append(cur_y)# 保存y值

        count +=1

    print(l_x, len(l_x))

print(l_y, len(l_y))

newton(variation, ini_x)

fig, ax = plt.subplots()

plt.title("y1=ln(x+1)-x^(-1)-1=0, x0")

plt.xlabel('x')

plt.ylabel("y")

x = np.arange(2.0, 3.0, 0.01)

y = np.log(x +1) - x ** (-1) -1

# y1 = np.log(x + 1)

# y2 = x ** (-1) + 1

plt.xticks(np.arange(2.0, 3.0, 0.1))

plt.yticks(np.arange(-10.0, 10.0, 0.1))

plt.plot(x, y, 'springgreen')

# plt.plot(x, y1, 'blue')

# plt.plot(x, y2, 'firebrick')

plt.grid()

def update(frame):

if frame =len(l_x):

frame =len(l_x) -1

    if frame =0:

print(50*'*')

print(frame)

print(l_x[frame])

print(l_y[frame])

if frame

plot(l_x[frame], l_y[frame +1], 'r.')# 画点

            plot([l_x[frame], l_x[frame]], [0, l_y[frame +1]], 'r')# 画竖线

            if frame

plot([l_x[frame], l_x[frame +1]], [l_y[frame +1], l_y[frame +2]], 'b')# 画切线

            plt.pause(0.5)

ani = FuncAnimation(fig, update, frames=100, interval=1000)

plt.show()

==================================================================

current acceptable error: 1e-06

1 root = 2.0

2 root = 2.6880932194260976

3 root = 2.851452484812813

4 root = 2.857327888394379

5 root = 2.857334825939737

[2.0, 2.6880932194260976, 2.851452484812813, 2.857327888394379, 2.857334825939737, 2.857334825949379] 6

[-0.4013877113318902, -0.4013877113318902, -0.06690132645083557, -0.002248115753633595, -2.648275835737124e-06, -3.680611371237319e-12] 6

import matplotlib.pyplotas plt

from matplotlib.pyplotimport plot

from matplotlib.animationimport FuncAnimation

import numpyas np

variation =1e-6  # 选定y值误差区间

ini_x = -0.9  # 选型x初始值

l_x = []

l_y = []

def newton(variation, ini_x):

print('current acceptable error: ' +str(variation) +'\n')

cur_y = np.log(ini_x +1) - ini_x ** (-1) -1 

cur_x = ini_x

l_x.append(ini_x)

l_y.append(cur_y)

count =1  # 迭代计数

    while abs(cur_y) variation:# 比较y和误差区间

        print(str(count) +' root = ' +str(cur_x))

# f(x)=ln(x+1)-x^(-1)-1

# df(x)=1/(x+1)+x^(-2)

        func = np.log(cur_x +1) - cur_x ** (-1) -1

        dif_func = (cur_x +1) ** (-1) + cur_x ** (-2)

cur_x = cur_x - (func / dif_func)# 迭代x

        cur_y = func# 计算y

        l_x.append(cur_x)# 保存x

        l_y.append(cur_y)# 保存y值

        count +=1

    print(l_x, len(l_x))

print(l_y, len(l_y))

newton(variation, ini_x)

fig, ax = plt.subplots()

plt.title("y1=ln(x+1)-x^(-1)-1=0, x0")

plt.xlabel('x')

plt.ylabel("y")

x = np.arange(-0.9, -0.5, 0.01)

y = np.log(x +1) - x ** (-1) -1

# y1 = np.log(x + 1)

# y2 = x ** (-1) + 1

plt.xticks(np.arange(-0.9, -0.5, 0.1))

plt.yticks(np.arange(-10.0, 0.1, 0.1))

plt.plot(x, y, 'springgreen')

# plt.plot(x, y1, 'blue')

# plt.plot(x, y2, 'firebrick')

plt.grid()

def update(frame):

if frame =len(l_x):

frame =len(l_x) -1

    if frame =0:

print(50*'*')

print(frame)

print(l_x[frame])

print(l_y[frame])

if frame

plot(l_x[frame], l_y[frame +1], 'r.')# 画点

            plot([l_x[frame], l_x[frame]], [0, l_y[frame +1]], 'r')# 画竖线

            if frame

plot([l_x[frame], l_x[frame +1]], [l_y[frame +1], l_y[frame +2]], 'b')# 画切线

            plt.pause(0.5)

ani = FuncAnimation(fig, update, frames=100, interval=1000)

plt.show()

==================================================================

current acceptable error: 1e-06

1 root = -0.9

2 root = -0.7049347334807499

3 root = -0.5564576676032453

4 root = -0.5535619883061157

5 root = -0.5535670215561312

[-0.9, -0.7049347334807499, -0.5564576676032453, -0.5535619883061157, -0.5535670215561312, -0.5535670215717203] 6

[-2.1914739818829347, -2.1914739818829347, -0.8019876618459221, -0.01588013567347135, 2.7699642681566772e-05, 8.579137400488435e-11] 6

Q4: 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)

对于微分方程全还给老师了，

Q5: 如何用python进行符号求解？

Python中有多个符号计算库可以用于符号求解python求函数的微分，其中最常用的是SymPy库。SymPy是一个符号计算库python求函数的微分，它提供python求函数的微分了许多用于符号计算的函数和类。可以使用SymPy库来进行符号求解python求函数的微分，例如求导、积分、求解方程、求解微分方程等。

以下是一个使用SymPy库进行符号求解的示例代码：

import sympy as sp

# 定义符号变量

x = sp.Symbol('x')

# 求导

f = sp.sin(x) + x**2

f_prime = sp.diff(f, x)

print("f的导函数为：", f_prime)

# 求积分

g = x**2 + 2*x + 1

g_integral = sp.integrate(g, x)

print("g的不定积分为：", g_integral)

# 解方程

h = x**2 + 2*x + 1 - 3

h_roots = sp.solve(h, x)

print("h的解为：", h_roots)

在上面的代码中，我们首先导入python求函数的微分了SymPy库。然后，我们定义了一个符号变量x，用于表示未知数。接下来，我们分别使用diff()函数、integrate()函数和solve()函数来求导、积分和解方程。最后，我们输出了相应的结果。

SymPy库提供了非常丰富的符号计算功能，包括微积分、线性代数、离散数学、几何学等多个领域。因此，如果需要进行符号计算，SymPy库是一个非常好的选择。

python求函数的微分的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python 微分、python求函数的微分的信息别忘了在本站进行查找喔。