SymPy - 符号类
Symbol 是 symPy 库中最重要的类. 正如前面提及的, 符号计算是通过 symbol对象进行的. SymPy 变量是 Symbols 类中的对象.
函数 Symbol() 的参数是包含符号的字符串, 可以为一个变量赋值.
>>> from sympy import Symbol
>>> x=Symbol('x')
>>> y=Symbol('y')
>>> expr=x**2+y**2
>>> expr
上面的代码给出的结果等价于 −
一个符号 symbol 可以包含多个字符.
>>> s=Symbol('side')
>>> s**3
上述代码输出为 −
SymPy 也有一个函数 Symbols() 可以一次性定义多个符号. 包含变量名的字符串用逗号或者空格分割.
>>> from sympy import symbols
>>> x,y,z=symbols("x,y,z")
在 SymPy 的 abc 模块中, 所有的拉丁字母 Latin 和希腊字母 Greek 定义为符号 symbols. 因此, 相对于 Symbol 对象的实例化, 这种方法是便利的.
>>> from sympy.abc import x,y,z
然而, 变量名 C, O, S, I, N, E 和 Q 是系统预先定义了的符号 symbols. 另外, 多个字母的符号在 abc 模块中没有定义, 此类对象你需要如前面的方法定义,即用 Symbol 对象. abc模块定义两个特殊变量名可以检测缺省SymPy名称空间的定义. clash1 包括单个字符变量而 clash2 包含多个字符的变量
>>> from sympy.abc import _clash1, _clash2 >>> _clash1
上述命令的输出 −
{'C': C, 'O': O, 'Q': Q, 'N': N, 'I': I, 'E': E, 'S': S}
>>> _clash2
输出为 −
{'beta': beta, 'zeta': zeta, 'gamma': gamma, 'pi': pi}
也可以定义有索引符号的符号变量, 语法类似于 range() 函数. 范围由冒号定义. 范围的类型由冒号右边的字符决定. 如果 itr 是一个数字, 那么从零开始到比它少一的连续范围的值都会取到.
>>> from sympy import symbols
>>> symbols('a:5')
上述命令的输出 −
(a0, a1, a2, a3, a4)
>>> symbols('mark(1:4)')
输出是 −
(mark1, mark2, mark3)
SymPy - 代换
数学表达式上执行的一种最基本操作就是代换. SymPy中的函数 subs() 将第一个参数用第二个参数替换.
>>> from sympy.abc import x,a >>> expr=sin(x)*sin(x)+cos(x)*cos(x) >>> expr
上述代码给出一个等价于下面式子的输出结果 −
>>> expr.subs(x,a)
上述代码给出一个等价于下面式子的输出结果 −
如果我们想计算特定的表达式这个函数就是有用的. 例如, 我们想计算下面算式把a换成5的值.
>>> expr=a*a+2*a+5 >>> expr
上述代码给出一个等价于下面式子的输出结果 −
expr.subs(a,5)
输出 −
40
>>> from sympy.abc import x >>> from sympy import sin, pi >>> expr=sin(x) >>> expr1=expr.subs(x,pi) >>> expr1
上述命令输出 −
0
这个函数也用于将一个子式替换为另一个子式. 下面的例子中把 b 替换为 a+b.
>>> from sympy.abc import a,b >>> expr=(a+b)**2 >>> expr1=expr.subs(b,a+b) >>> expr1
上述代码给出一个等价于下面式子的输出结果 −
SymPy - 符号化函数sympify()
函数 sympify() 用于将任意的表达式转换为可用于 SymPy 的表达式. 正规的 Python 对象, 例如整数对象是可以转换的. 字符串也可以转换为 SymPy 表达式.
>>> expr="x**2+3*x+2" >>> expr1=sympify(expr) >>> expr1 >>> expr1.subs(x,2)
上述代码给出结果 −
12
任何 Python 对象可以转换为 SymPy 对象. 但是, 因为转换内部使用的是函数 eval(), 不能识别的表达式是不能使用的, 否则会产生 SympifyError.
>>> sympify("x***2")
---------------------------------------------------------------------------
SympifyError: Sympify of expression 'could not parse 'x***2'' failed, because of exception being raised.
函数 sympify() 选取参数是:
* strict: 默认是 False. 如果设置为 True, 只有那些定义了显示转换的类型才会被执行, 否则产生错误 SympifyError is raised.
* evaluate: 如果设置为False, 算术和算子将被转换为它们在SymPy中未必计算的对象.
>>> sympify("10/5+4/2")
输出结果 −
4
>>> sympify("10/5+4/2", evaluate=False)
而上述的命名结果为 −
SymPy - 计算浮点数值的函数evalf()
这个函数计算一个给定的数值表达式到给定精度的浮点数(最多100位小数). 这个函数也接受 subs 作为参数, 其中代换使用字典结构. 考虑如下的表达式
>>> from sympy.abc import r >>> expr=pi*r**2 >>> expr
上述代码给出一个等价于下面式子的输出结果 −
把r代换成5, 使用函数 evalf() 计算上述表达式
>>> expr.evalf(subs={r:5})
结果如下 −
78.5398163397448
默认情况下, 浮点数精度到15 位小数, 这个数字可以重载, 但不能超过100. 接下来的表达式计算到20位精度.
>>> expr=a/b
>>> expr.evalf(20, subs={a:100, b:3})
结果如下 −
33.333333333333333333
SymPy - 抽象函数 Lambdify()
函数Lambdify()把SymPy 表达式翻译成 Python 函数. 如果一个表达式在大范围数据上计算, 函数 evalf() 效率不高. lambdify 扮演着一个 lambda 函数的角色, 除了它把 SymPy 的名称转换为给定的数值包(通常是 NumPy)的名称. 默认情况下, lambdify 在math标准库中实现.
>>> expr=1/sin(x) >>> f=lambdify(x, expr) >>> f(3.14)
上述命令结果为 −
627.8831939138764
表达式也可以不止一个变量. 在此情况下, lambdify() 函数的第一个参数是一个变量列表, 接着是要计算的表达式.
>>> expr=a**2+b**2 >>> f=lambdify([a,b],expr) >>> f(2,3)
上述代码给出结果 −
13
然而为了使 numpy 库以数值计算为背景, 我们不得不以 lambdify() 一个参数的形式给出.
>>> f=lambdify([a,b],expr, "numpy")
上面函数中我们使用两个数组a,b作为两个参数. 在numpy数组情形下计算是相当迅速的.
>>> import numpy >>> l1=numpy.arange(1,6) >>> l2=numpy.arange(6,11) >>> f(l1,l2)
上述代码给出如下结果 −
array([ 37, 53, 73, 97, 125], dtype=int32)
SymPy - 逻辑表达式Logical Expressions
布尔Boolean函数定义在 sympy.basic.booleanarg 模块中. 可以使用标准的python算子 & (And), | (Or), ~ (Not) 以及 >> 和 << 构造布尔表达式. 布尔表达式从基本的 SymPy 的核心模块中继承而来.
布尔 Boolean真值True 函数
这个函数等价于Python核心模块中的 True. 返回一个单一类, 可以通过调用 S.true得到.
>>> from sympy import * >>> x=sympify(true) >>> x, S.true
上述代码的输出 −
(True, True)
布尔 Boolean 假 False 函数
类似地, 这个函数等价于Python 中的 Boolean False, 可以通过 S.false访问
>>> from sympy import * >>> x=sympify(false) >>> x, S.false
上述代码给出结果 −
(False, False)
And 且函数
逻辑且 AND 函数计算两个参数返回假 False 如果两者中有一个为假 False. 这个函数模拟算子 &.
>>> from sympy import *
>>> from sympy.logic.boolalg import And
>>> x,y=symbols('x y')
>>> x=True
>>> y=True
>>> And(x,y), x"&"y
上述代码给出的结果 −
(True, True)
>>> y=False >>> And(x,y), x"&"y
上述代码给出的结果 −
(False, False)
Or 或函数
这个函数计算两个布尔参数返回假 TRUE 如果两者中有一个为真 True. 算子 | 模拟了它的行为.
>>> from sympy import *
>>> from sympy.logic.boolalg import Or
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Or(x,y), x|y
上述代码的结果 −
(True, True)
>>> x=False >>> y=False >>> Or(x,y), x|y
上述代码的输出 −
(False, False)
Not 非函数
逻辑非 Not 函数导致逻辑参数的逆转. 如果它的参数为False返回 True, 如果参数为True返回 False. 算子 ~ 执行的操作类似于 Not 函数. 如下例所示 −
>>> from sympy import *
>>> from sympy.logic.boolalg import Or, And, Not
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Not(x), Not(y)
结果为 −
(False, True)
>>> Not(And(x,y)), Not(Or(x,y))
上述代码输出 −
(True, False)
Xor 异或函数
The Logical XOR (exclusive OR) function returns True if an odd number of the arguments are True and the rest are False and returns False if an even number of the arguments are True and the rest are False. Similar operation is performed by ^ operator.
>>> from sympy import *
>>> from sympy.logic.boolalg import Xor
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Xor(x,y), x^y
The above code snippet gives the following output −
(True, True)
>>> a,b,c,d,e=symbols('a b c d e')
>>> a,b,c,d,e=(True, False, True, True, False)
>>> Xor(a,b,c,d,e)
The above code snippet gives the following output −
True
In above case, three (odd number) arguments are True, hence Xor returns true. However, if number of True arguments is even, it results in False, as shown below −
>>> a,b,c,d,e=(True, False, False, True, False) >>> Xor(a,b,c,d,e)
The above code snippet gives the following output −
False
Nand 非且函数
This function performs Logical NAND operation. It evaluates its arguments and returns True if any of them are False, and False if they are all True.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nand
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nand(a,b,c), Nand(a,c)
The above code snippet gives the following output −
(True, False)
Nor 非或函数
这个函数执行逻辑 NOR 运算. 它计算参数返回 False 当其中任何一个是 True, 返回 True 如果参数都是 False.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nor
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nor(a,b,c), Nor(a,c)
上述命令的输出 −
(False, False)
注意到: 尽管 SymPy 基于便利而: 为Xor提供了算子 ^, 为Not提供了算子 ~, 为Or提供了算子 |, 为And提供了算子 &, 但是它们在Python中的正确用法是位运算符. 因此, 如果操作数是整数, 结果将会是不同于期望的结果.
Equivalent 等价函数
这个函数返回等价关系. Equivalent(A, B) 是 True 当且仅当 A 和 B 都是 True 或者 False. 这个函数返回 True 如果所有的参数在逻辑上是等价的. 否则返回 False.
>>> from sympy import *
>>> from sympy.logic.boolalg import Equivalent
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Equivalent(a,b), Equivalent(a,c)
上述代码输出结果 −
(False, True)
ITE 函数
这个函数扮演着和编程语言中的 If then else 从句的角色.ITE(A, B, C) 计算及返回结果 B 如果 A 是 true 否则返回结果 C. 所有的参数必须是布尔值 Booleans.
>>> from sympy import *
>>> from sympy.logic.boolalg import ITE
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> ITE(a,b,c), ITE(a,c,b)
上述代码给出结果 −
