解析的SymPy表达式的导数始终为0

Question

I am writing a program that requires the user to enter an expression. This expression is entered as a string and converted to a Sympy expression using parse_expr . I then need to take the partial derivative of that expression that the user entered. However, diff is returning 0 with every expression I am testing.

For example if the user enters a*exp(-b*(xc)**(2)) , using the following code, diff returns 0 when it should (as far as I know about diff ) return 2*a*b*(c - x)*exp(-b*(x - c)**2) when taking the partial derivative with respect to x :

a, b, c, x = symbols('a b c x', real=True)
str_expr = "a*exp(-b*(x-c)**(2))"
parsed_expr = parse_expr(str_expr)
result = diff(parsed_expr, x)
print(result) # prints 0

What am I doing wrong?

Answer 1

Bottom line: use parse_expr(str_expr,locals()) .

Add global_dict=<dict of allowed entities to use> , too, if the expression may use any entities not imported into the local namespace and not accessible with the default from sympy import * .

---

According to Calculus — SymPy Tutorial - SymPy 1.0.1.dev documentation , you type the symbolic expression into the diff() argument as-is. Due to the fact that the letters are Symbol objects (with overridden operators), Python is tricked into constructing the SymPy object corresponding to the expression as it evaluates the argument!

Thus, if you have it as a string, you eval it to trigger the same behaviour:

<...>
>>> s="a*exp(-b*(x-c)**(2))"
>>> diff(eval(s), x)
−ab(−2c+2x)e−b(−c+x)2

But eval is a security hazard if used with untrusted input because it accepts arbitrary Python code.

This is where replacements like parse_expr come into play. However, due to the way expressions are parsed, described above, it needs access to the external entities used in the expression - like the Symbol objects for variables and function objects for the named functions used - through the local_dict and global_dict arguments.

Otherwise, it creates the Symbol objects on the fly. Which means, the Symbol object it has created for x in the expression is different from the variable x ! No wonder that the derivative over it is 0!

<...>
>>> ps=parse_expr(s)
>>> ps.free_symbols
{a,b,c,x}
>>> x in _
False
>>> diff(ps,x)
0

>>> ps=parse_expr(s,locals())
>>> x in ps.free_symbols
True
>>> diff(ps,x)
-ab(−2c+2x)e−b(−c+x)2

Answer 2

Work is ongoing to make sympify safer than eval . Better to use something like the following:

from sympy import *

var ('a b c x')

str_expr = "a*exp(-b*(x-c)**(2))"
parsed_expr = sympify(str_expr)
result = diff(parsed_expr, x)
print(result) 

Result:

-a*b*(-2*c + 2*x)*exp(-b*(-c + x)**2)

Answer 3

Replace a, b, c, x = symbols('abc x', real=True) with:

a = Symbol('a')
b = Symbol('b')
c = Symbol('c')
x = Symbol('x')

Answer 4

Symbols with different assumptions compare unequal:

>>> Symbol('x') == Symbol('x', real=True)
False

When you use sympify or parse_expr , it parses unknown variables as symbols without assumptions. In your case, this creates Symbol('x') , which is considered distinct from the Symbol('x', real=True) you already created.

The solution is to either remove the assumptions, or include the locals() dictionary when you parse, so that it recognizes the name x as being the Symbol('x', real=True) that you already defined, like

parse_expr(str_expr,locals())

or

sympify(str_expr, locals())