

In [1]:

    
import sympy as sy



In [14]:

    
x=sy.Symbol('x')
y=sy.Symbol('y')

x, y, z = sy.symbols('x y z')     # 符号对象, 可限定 real = True , positive = True, complex = True , integer = True ...



In [41]:

    
f = sy.Function("f")



In [51]:

    
f, g = sy.symbols('f g', cls=sy.Function)

表达式变换

sy.exp(sy.I*x).expand(complex=True) # 展开为复数, 可理解为将x当作复数处理表达式展开
sy.cos(x).series(x, 0, 10) # .series(var, point, order) 泰勒级数展开
sy.simplify(expr) # 对数学表达式进行化简化简

sy.radsimp(expr) # 对表达式的分母进行有理化分母进行有理化

     它所得到的表达式的分母部分将不含无理数。即将表达式转换为分子除分母的形式。

sy.ratsimp(expr) # 对表达式的分母进行通分运算通分运算

sy.cancel(expr) # 对表达式的分子分母进行约分运算约分运算

     只能对纯符号的分式表达式进行约分
     不能对函数内部的表达式进行约分，不能对带函数的表达式进行约分

sy.trim(expr) # 对表达式的分子分母进行约分运算约分运算

     可以对表达式中的任意部分进行约分，并且支持函数表达式的约分运算。

sy.apart(expr) # 对表达式进行部分分式分解部分分式分解
sy.factor(expr) # 对表达式进行因式分解因式分解
sy.together(1/x+1/y) # 代数式的合并代数式的合并

sy.trigsimp(expr) # 对表达式中的三角函数进行化简三角函数化简

     有两个可选参数——deep和recursive，默认值都为False。
        当deep参数为True时，将对表达式中所有子表达式进行化简运算
        当recursive参数为True时，将递归使用trigsimp()进行最大限度的化简

sy.expand_trig(expr) # 展开三角函数三角函数展开

积分



In [6]:

    
sy.integrate(6*x**5, x)









    Out[6]:





x**6



In [7]:

    
sy.integrate(x**3, (x, 0, 10))          #定积分









    Out[7]:





2500



In [8]:

    
sy.integrate(6*x**5+y, x,y)             #双重不定积分









    Out[8]:





x**6*y + x*y**2/2



In [9]:

    
sy.integrate(x**3+y, (x, -1, 1),(y,1,3) ) #双重定积分









    Out[9]:





8

微分



In [55]:

    
print f(x).diff(x)









    



Derivative(f(x), x)



In [16]:

    
sy.diff(sy.sin(x), x)                                                #    解析微分









    Out[16]:





cos(x)



In [17]:

    
sy.diff(sy.sin(2*x), x, 2) # 高阶微分 diff(func, var, n)









    Out[17]:





-4*sin(2*x)



In [20]:

    
sy.diff(sy.sin(x*y),x,2,y,3) # 对表达式进行x的2阶求导,对y进行3阶求导









    Out[20]:





x*(x**2*y**2*cos(x*y) + 6*x*y*sin(x*y) - 6*cos(x*y))



In [21]:

    
sy.diff(sy.sin(2*x),x)









    Out[21]:





2*cos(2*x)



In [22]:

    
sy.sin(2*x).diff(x,1)









    Out[22]:





2*cos(2*x)



In [24]:

    
t=sy.Derivative(sy.sin(x),x)  
# Derivative是表示导函数的类，它的第一个参数是需要进行求导的数学函数，第二个参数是求导的自变量，
# 注意：Derivative所得到的是一个导函数，它不会进行求导运算。

极限



In [25]:

    
sy.limit(sy.sin(x)/x, x, 0)       # 极限









    Out[25]:





1

求和



In [28]:

    
sy.summation(2*x - 1, (x, 1, y))     #  连加求和









    Out[28]:





y**2

替换

expression.subs(x, y) # 将算式中的x替换成y 替换



In [32]:

    
(1 + x*y).subs(x, sy.pi)









    Out[32]:





pi*y + 1

expression.subs({x:y,u:v}) 使用字典进行多次替换

expression.subs([(x,y),(u,v)]) 使用列表进行多次替换



In [34]:

    
(1 + x*y).subs([(x, sy.pi), (y, 2)])









    Out[34]:





1 + 2*pi

方程

方程构建: 任何表达式都可以直接表示值为0的方程,即表达式 expr 也是方程 expr=0



In [36]:

    
# 用sy.Eq构建方程
u_max, rho_max, A, B = sy.symbols('u_max rho_max A B')     # 符号对象, 可限定 real = True , positive = True, complex = True , integer = True ...
eq1 = sy.Eq( 0, u_max*rho_max*(1 - A*rho_max-B*rho_max**2) )  # 一般方程



In [52]:

    
eq1 = sy.Eq(f(x).diff(x)+f(x)+f(x)**2,0)   # 微分方程
print eq1









    



Eq(f(x)**2 + f(x) + Derivative(f(x), x), 0)

sy.solve(方程,未知数) # 方程求解 ,返回值为list 方程求解

                它的第一个参数是表示方程的表达式，其后的参数是表示方程中未知量的符号。



In [53]:

    
sy.solve(eq1,x)









    



---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
<ipython-input-53-3a39fcc28893> in <module>()
----> 1 sy.solve(eq1,x)

/Users/chengjun/anaconda/lib/python2.7/site-packages/sympy/solvers/solvers.pyc in solve(f, *symbols, **flags)
   1051     ###########################################################################
   1052     if bare_f:
-> 1053         solution = _solve(f[0], *symbols, **flags)
   1054     else:
   1055         solution = _solve_system(f, symbols, **flags)

/Users/chengjun/anaconda/lib/python2.7/site-packages/sympy/solvers/solvers.pyc in _solve(f, *symbols, **flags)
   1617 
   1618     if result is False:
-> 1619         raise NotImplementedError('\n'.join([msg, not_impl_msg % f]))
   1620 
   1621     if flags.get('simplify', True):

NotImplementedError: 
No algorithms are implemented to solve equation _Dummy_172 + f(x)**2 + f(x)



In [48]:

    
sy.solveset(sy.sin(x)+x,x) # 即对 sy.sin(x)+x=0 求解









    Out[48]:





ConditionSet(x, Eq(x + sin(x), 0), Complexes((-oo, oo) x (-oo, oo), False))

sy.roots(expr) # 计算单变量方程expr=0的根方程求解



In [56]:

    
sy.dsolve(eq1,f(x))  # 微分方程求解                                            微分方程求解









    Out[56]:





Eq(f(x), -C1/(C1 - exp(x)))

可以对微分方程进行符号求解，它的第一个参数是一个带未知函数的表达式，第二个参数是需要进行求解的未知函数。

它在解微分方程中可以传递hint参数，指定微分方程的解法，若设置为“best”则放dsolve()尝试所有的方法并返回最简单的解。



In [57]:

    
from sympy.utilities.lambdify import lambdify



In [58]:

    
lambdify([x],f(x),modules="numpy") # 第一个参数为自变量列表









    Out[58]:





<function numpy.<lambda>>



In [59]:

    
sy.N(sy.pi,20)









    Out[59]:





3.1415926535897932385



In [60]:

    
sy.pi.evalf(n=50)









    Out[60]:





3.1415926535897932384626433832795028841971693993751



In [62]:

    
i=sy.Symbol('i')



In [64]:

    
f = sy.Sum(sy.Indexed('x',i)*sy.cos(i*sy.pi),(i,1,10))  
f









    Out[64]:





Sum(cos(pi*i)*x[i], (i, 1, 10))



In [67]:

    
func = lambdify(x, f, 'numpy') # returns a numpy-ready function
print func









    



<function <lambda> at 0x108494b90>



In [68]:

    
numpy_array_of_results = func(y)
numpy_array_of_results









    



---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-68-adb2d1657b9e> in <module>()
----> 1 numpy_array_of_results = func(y)
      2 numpy_array_of_results

/Users/chengjun/anaconda/lib/python2.7/site-packages/numpy/__init__.pyc in <lambda>(_Dummy_204)

/Users/chengjun/anaconda/lib/python2.7/site-packages/numpy/__init__.pyc in <genexpr>((i,))

TypeError: 'Symbol' object does not support indexing



In [ ]: